---

X10Interface.cpp

Go to the documentation of this file.

/***************************************************************************
                          X10Interface.cpp  -  description
                             -------------------
    begin                : Tue Sep 4 2001
    copyright            : (C) 2001 by 
    email                : 
 ***************************************************************************/


#include <stdio.h> /* Standard input/output definitions */
#include <string.h> /* String function definitions */
#include <unistd.h> /* UNIX standard function definitions */
#include <errno.h>
#include <time.h>
#include <assert.h>

#include "X10Interface.h"
#include "BitOp.h"
#include "SerialOp.h"



namespace rwil {
using namespace BitOp;
using namespace SerialOp;
  namespace X10 {

    //Initialize the X10 controller for sending data
    void send_init()
    {
      int n=0;
      char buf[10];
      time_t temp;

      temp = time(0);

      if(fd==0)
        {
          open_port();
          configure_port();
        }

    writetwo:
      sleep(1);

      while(n<1)
        {       n=write(fd, "\002", 1);
        if(n < 1) printf("Write \\x02 failed"); }
      //        write(fd, "\x63\x46\x4c\x45\x41", 5);

      buf[0]=0x20;
      while(buf[0]!=0x06)
        {       
          if((time(0)-temp) > 5) return;
          n=read(fd, buf, 1);
          errno=0;
          if(buf[0]==0x15) goto writetwo;
          //            printf("%d&%d*%d=",fd, (int)buf[0], n);
        }
      while((buf[0]!=CARRIAGE) &&(buf[0]!=0xa))
        {
          n=read(fd, buf, 1);
          if(buf[0]!=CARRIAGE && n ==1 &&(buf[0]!=0xa)) printf("Expected CARRIAGE got 0x%x\n", (int) buf[0]);
          if((time(0)-temp) > 5) return;
        }
    }

    //Send a simple X10 command
    void send_X10(char realhouse, char realnumber, char command)
    {
      int n, x;
      char buf[11];
      time_t temp;
      temp = time(0);
      //        printf("before init --");
      send_init();


      //        printf(" and after\n");

      buf[0] = 0x63;
      buf[1] = realhouse;
      buf[2] = realnumber;
      buf[3] = command;
      buf[4] = 0x41;
      //        for(n=0;n<5;n++) printf("%X.", buf[n]);
      //        printf("here\n");

      n= write(fd, buf, 5);
      if(n!=5) printf("Write failed\n");
        
      buf[2] = 0;
      while(buf[2] != command)
        {
          n = 0;
          while(n<5)
            {
              x= read(fd, buf+n, 1);
              if((time(0)-temp) > 5) return;
              if(x ==1)
                {
                  //                            printf("%x>", (unsigned)buf[n]);
                  n++;
                }
            }
        }
    }



    /*inputLength is in bits */
    //Add the signature to the data and create the complemented form
    //of the data
    int createCompAndAddSig(char* input, char *output, int inputlength)
    {
      int inPos= 0;
      int outPos = 0;
      int bitLength = inputlength;
        
      SetBit(output, 0, 1);
      SetBit(output, 1, 1);
      SetBit(output, 2, 1);
      SetBit(output, 3, 0);
        
      outPos = 4;
        
      for(;inPos < bitLength; inPos++)
        {       
          SetBit(output, outPos, input[inPos/8] & (1 << (7-inPos%8)) ? 1 : 0);
          outPos++;
          SetBit(output, outPos, input[inPos/8] & (1 << (7-inPos%8)) ? 0 : 1);
          outPos++;
        }
      return outPos; /*Not sure if this is right*/
    }

    void send_Dim_X10(char realhouse, char realnumber, int percent)
    {
      char data[10], output[20], realout[20];
      int loc;
      int brightsend;
      time_t temp;
      //      printf("Send Dim %c %c %d\n", realhouse, realnumber, percent);
      temp = time(0);

      send_init();
        
      //House Code A
      SetBits(data, 0, 4, realhouse - 0x40);
      //Extended Code 1
      SetBits(data, 4, 5, 0x0F);
        
      //Unit Code
      SetBits(data, 9, 4, (realnumber - 0x40) >> 1);    
        
      //Full on is 0x3f ...  0x20 is about 50%
      if(percent < 0) brightsend = 0;
      else if(percent > 100) brightsend = 0x3f;
      else brightsend = percent * 62 /100;
        
        
      SetBits(data, 13, 8, brightsend);
      //PresetDim
      SetBits(data, 21, 8, 0x31);
        
      send_arbitrary(data, 29);

      loc = createCompAndAddSig(data, output, 29);
      SetBits(output, loc, 20, 0);
      //        PrintBits(output, 80);

      memcpy(realout, "\x80\x09", 2);
      memcpy(realout+2, output, 10);
      //        PrintBits(realout, 120);

      /*        write(fd, realout, 12);
        
                while(1)
                {
                if((time(0)-temp) > 5) return;
                loc = read(fd, data, 1);
                if((loc==1) && ((data[0] == CARRIAGE)|| (data[0] == 0xa)))
                break;
                //      printf("=%x\n", 0xFF &(int)data[0]);
                }*/
    }

    //Strips the signature from the incoming data
    int stripSigAndCompress(char * input, char* output, int inputlength)
    {
      int inPos = 12;
      int outPos = 0;
        
      for(;inPos < inputlength; inPos+=2)
        {
          SetBit(output, outPos, input[inPos/8] & (1 << (7-inPos%8)) ? 1 : 0);
          outPos++;
        }
      return outPos;
    }

    void send_arbitrary(char data[10], int sizebits)
    {
      char output[25];
      int loc;
      time_t temp;

      temp = time(0);
        
      send_init();
        
      loc = createCompAndAddSig(data, output + 2, sizebits);
      SetBits(output + 2, loc, 16, 0);
      output[0] = 0x80;
      output[1] = loc / 8 + 1;
      //    PrintBits(output, 120);

      write(fd, output, loc / 8 + 4);
        
      while(1)
        {
          if((time(0)-temp) > 5) return;
          loc = read(fd, data, 1);
          if((loc==1) && ((data[0] == CARRIAGE)|| (data[0] == 0xa)))
            break;
          //    printf("=%x\n", 0xFF &(int)data[0]);
        }
    }

    //Read data from the X10 interface until either a Carriage return is found or the buffer is full
    //The function will demangle and strip the incoming data
    //bufsize is measured in bytes
    //the max buffer size supported is 100 bytes
    //Return value is the number of bits gathered
    int readFromX10(char *buffer, int bufSize)
    {
      char data[10], output[250];
      int n;
      int loc;
      n=0;
      data[0] = 0;
      while(1)
        {
          loc = read(fd, data, 1);
          if(loc==1)
            {
              /*                        printf("=%x\n", 0xFF &(int)data[0]);*/
              if(data[0] == CARRIAGE)
                break;
              output[n] = data[0];
              n++;
              if(n>=bufSize*2) break;
            }
        }
        
      return stripSigAndCompress(output, buffer, 8 * n);
    }


    //Get the status of the X10 device ... this has been proofed against
    //lockup with a 10 second timeout, if the timeout is reached a
    //-1 is returned otherwise a percentage representing status is returned
    int get_status_X10(char realhouse, char realnumber)
    {
      char data[10], output[20], realout[20];
      int loc;
      int n;
      time_t temp;

      temp = time(0);

      send_init();
        
      //House Code A
      SetBits(data, 0, 4, realhouse - 0x40);
      //Extended Code 1
      SetBits(data, 4, 5, 0x0F);
        
      //Unit Code
      SetBits(data, 9, 4, (realnumber - 0x40) >> 1);    
        
      //Status Check
      SetBits(data, 13, 8, 0x00);
      //
      SetBits(data, 21, 8, 0x37);
        
        
      loc = createCompAndAddSig(data, output, 29);
      SetBits(output, loc, 20, 0);
      //        PrintBits(output, 80);

      memcpy(realout, "\x80\x09", 2);
      memcpy(realout+2, output, 10);

      write(fd, realout, 12);
        
      while(1)
        {
          if((time(0)-temp) > 10) return -1;
          loc = read(fd, data, 1);
          /*if(loc==1)  printf("=%x\n", 0xFF &(int)data[0]);*/
          if((loc==1) && ((data[0] == CARRIAGE)|| (data[0] == 0xa)))
            break;
        }
        
      n=0;
      data[0] = 0;
      while(1)
        {
          if((time(0)-temp) > 10) return -1;
          loc = read(fd, data, 1);
          if(loc==1)
            {
              /*                        printf("=%x\n", 0xFF &(int)data[0]);*/
              if((data[0] == CARRIAGE)|| (data[0] == 0xa))
                break;
              output[n] = data[0];
              n++;
            }
        }
      stripSigAndCompress(output, realout, 56);
      /*PrintBits(realout, 25);*/
      return GetBits(realout, 15,6)*100/62;
    }

  }//End namespace X10
}

---