We require the cp210x kernel module for our Intel Galileo image. In order to do that, we will go to our build system with Yocto Project and build the cp210x kernel module; we'll then install it into Intel Galileo using the following steps:

Serial communication is a widely used protocol to receive and transfer bytes from/to devices. For example, the 6-pin FTDI cable you've connected to your Intel Galileo and your PC's USB host communicate using the RS232 serial protocol, to send the keyboard data you entered on minicom and get the terminal output to your device.

Most of the PC interfaces of home automation controllers use serial communication. We will use the Aeon Labs Z-Stick, but there are other USB adapters that can be found for use with Z-Wave devices.

First we need to set up the serial communication interface from our application. We will continue with a new project only with this purpose in mind. First, we will open the device file /dev/ttyUSB0 and then we will set the serial interface with a 1,15,200 baud rate, 8 data bits, 1 stop bit, and no parity bits. If this setting isn't done right, the sent or received data will be corrupted.

We defined the function open_serial_device to get the device file and set the device communication options as shown here:

int open_serial_device(const char* serial_device_path) {
 //Open Device File /dev/ttyUSB0
 int device_file = open(serial_device_path, O_RDWR | O_NOCTTY, 0);
 if (device_file < 0) {
    printf("Can't Open Serial Controller
");
    return -1;
  }
struct termios options;
 int bits;
  bits = 0;
  ioctl(device_file, TIOCMSET, &bits);
  /**
   * Get Current Options
   */
  tcgetattr(device_file, &options);
  //No Parity
  options.c_iflag = IGNPAR;
  options.c_iflag |= IGNBRK;
  //Set 8 Data bits
  options.c_cflag |= CS8 | CREAD | CLOCAL;
  options.c_oflag = 0;
  options.c_lflag = 0;
  int i;
  for (i = 0; i < NCCS; i++) {
    options.c_cc[i] = 0;
  }
  options.c_cc[VMIN] = 0;
  options.c_cc[VTIME] = 1;
  //Set Baudrate for Serial Communication
  cfsetspeed(&options, B115200);
  if (tcsetattr(device_file, TCSANOW, &options) < 0) {
    printf("Can't Set The Serial Device Parameters
");
  } else {
    printf("Successfully Set the Serial Device Parameters
");
  }
  //Flush the waiting bits/bytes
  tcflush(device_file, TCIOFLUSH);
  return device_file;
}

In the function, we first open the serial device file, then we request the current options from system function tcgetattr and complete the settings to make the device ready for communication.

Now, we will proceed to implement the methods to read and write bytes from/to the serial device using the read_from_serial_device and write_to_serial_device functions.

The following function writes bytes to the serial device and then checks whether the bytes are written correctly:

int write_to_serial_device(int device_file, uint8_t buffer[], int length) {
  int i = 0;
  int count = 0;
  printf("Writing: ");
  while (count < length) {
    if (write(device_file, &buffer[count], 1) == 1) {
      printf("0x%x ", buffer[count]);
      count++;
    } else {
      printf("
 Can't Write Byte
");
      break;
    }
  }
  if (count == length) {
    printf("
Write Successful
");
    return count;
  } else {
    printf("
Can't Write All Frame to Serial Device
");
    return -1;
  }
}

The following function read bytes from the serial device:

int read_from_serial_device(int device_file, uint8_t *data) {
 int bytesRead;
 uint8_t buffer[256];
 //Read Data From Serial Device to Buffer
 bytesRead = read(device_file, buffer, sizeof(buffer));
 //Print Bytes
 data = malloc(sizeof(uint8_t) * bytesRead);
 if (bytesRead > 0) {
  int i = 0;
  printf("Received: ");
  for (; i < bytesRead; i++) {
   data[i] = buffer[i];
   printf("0x%x, ", data[i]);
  }
  printf("
");
 }
 return bytesRead;
}

So we have implemented the required functions for serial communication. In order to communicate correctly with the Z-Wave controller, we need to learn basic Z-Wave commands to get and set values from/to the remote wall plug. We will obtain help from open source projects to get information about Z-Wave communication.

In the following sample, we will only use basic commands to switch on/off and read energy meter value from the Fibaro wall plug. We will not parse the raw data received from the Z-Wave controller. In the following chapter, we will parse the received values and create a more automated application by bringing together the blocks.

Basically, the Z-Wave controller creates a home network and generates a number (or a home ID) for that. In this way, it isolates your devices from any other controller to reach out and give a number for each of the devices or nodes added, starting from 2. The first node is the controller itself.

The following function is the main function that is used to simply get power information from the wall plug. We create a thread to read the received data while we send data to the controller.

void* reader_thread(void *arg) {
  while (1) {
    read_from_serial_device();
}
 return NULL;
}
int main(int argc, char* argv[]){
//Open Aeon Stick Z-Wave
 device_file = open_serial_device(SERIAL_DEVICE);
 if (device_file < 0) {
  return EXIT_FAILURE;
 }
  //Create Thread
  pthread_t reader;
  int err = pthread_create(&reader, NULL, &reader_thread, NULL);
  if (err != 0) {
    close_serial_device();
    printf("Can't create Thread
");
    return -1;
  }
uint8_t get_energy_meter[] = { 0x01, 0x0a, 0x00, 0x13, 0x03, 0x03, 0x32, 0x01, 0x00, 0x25, 0x16, 0xe6 };
  //Send Energy Meter Value
  write_to_serial_device(get_energy_meter, 12);
if (pthread_join(reader, NULL)) {
    fprintf(stderr, "Error joining thread
");
    return 2;
  }
  close_serial_device(device_file); 
  return EXIT_SUCCESS;
}  

In this sample, we have a Z-Wave command to send to the corresponding node and Fibaro wall plug to receive energy readings as raw values. In this command, the first four bytes form the home ID, the fifth byte forms the node ID or device ID assigned by the controller, then we have the command code and address, and finally the checksum of the bytes.

When we build and run the application, we will have the following outputs. The first received byte is an acknowledgment and then the next 18 bytes are for data.

root@clanton:~# ./zwave-galileo
Writing: 0x1 0xa 0x0 0x13 0x3 0x3 0x32 0x1 0x0 0x25 0x16 0xe6
Write Successful
Received 1 Bytes: 0x6
Received 18 Bytes: 0x1 0x10 0x0 0x4 0x0 0x3 0xa 0x32 0x2 0x21 0x44 0x0 0x0 0x0 0x33 0x0 0x0 0x84

Communication with remote Z-Wave devices is being handled with similar messages sent to the controller. For example, in order to query the controller for the home ID and device ID, you can send "0x1 0x3 0x0 0x20 0xdc" bytes to get 10 bytes of data, four bytes (the fifth to eighth bytes), the home ID, and the ninth byte to represent the node ID of the controller. Some common messages used to get data from the serial controller are listed in the following table:

You can follow up with Z-Wave messages (frames) with open source projects for more information on this.