unify emit and listen libs

emit/Makefile

@@ -1,13 +1,13 @@
 all : emit
 
-emit : emit.o emitlib.o
-	gcc -o emit emit.o emitlib.o -lwiringPi
+emit : emit.o buffer.o home_easy.o utils.o
+	gcc -o $@ $^ -lwiringPi
 
 emit.o : emit.c
-	gcc -c emit.c
+	gcc -c $< -o $@
 
-emitlib.o : emitlib.c emitlib.h
-	gcc -c emitlib.c -o emitlib.o
+%.o : %.c %.h
+	gcc -c $< -o $@
 
 clean:
 	rm -f emit *.o

emit/buffer.c

@@ -0,0 +1,125 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <string.h>
+#include "buffer.h"
+
+/**
+ * Create a new byte buffer
+ *
+ * @return the created buffer
+ */
+BYTE_BUFFER createByteBuffer()
+{
+    BYTE_BUFFER buffer;
+    buffer.size = 0;
+    buffer.data = (char*) malloc(1);
+    return buffer;
+}
+
+/**
+ * Release the memory
+ *
+ * @param buffer the buffer to destroy
+ */
+void destroyByteBuffer(BYTE_BUFFER buffer)
+{
+    free(buffer.data);
+}
+
+/**
+ * Print all the bits from a buffer
+ *
+ * @param buffer the buffer holding the data
+ */
+void printfBitBuffer(BYTE_BUFFER buffer)
+{
+    printf("bytes: %lu\nbits: %lu\n", buffer.size, buffer.size*8);
+    unsigned int x;
+    for(x=0; x<buffer.size ; x++) {
+        printfBit(buffer.data[x]);
+        printf("\n");
+    }
+}
+
+/**
+ * Print a byte in binary
+ * 
+ * @param byte the byte to print
+ */
+void printfBit(unsigned char byte)
+{
+    int i;
+    for(i=0x80; i>0; i>>=1) {
+        fprintf(stdout, "%d", ((byte & i) == i));
+    }
+}
+
+
+/**
+ * Print all the bytes from a buffer
+ *
+ * @param buffer the buffer holding the data
+ */
+void printfByteBuffer(BYTE_BUFFER buffer)
+{
+    unsigned int i;
+    for(i=0; i<buffer.size; i++) {
+        fprintf(stdout, "%02X ", (unsigned char)buffer.data[i]);
+    }
+    fprintf(stdout, "\n");
+}
+
+/**
+ * Push a byte in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param byte the byte to push
+ */
+void pushByte(BYTE_BUFFER* buffer, unsigned char byte)
+{
+    buffer->size++;
+    buffer->data = (char*)realloc(buffer->data, buffer->size);
+    buffer->data[buffer->size-1] = byte;
+}
+
+/**
+ * Push a word in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param word the word to push
+ */
+void pushWord(BYTE_BUFFER* buffer, unsigned short int word)
+{
+    unsigned char* data = (unsigned char*)&word;
+    pushByte(buffer, data[1]);
+    pushByte(buffer, data[0]);
+}
+/**
+ * Push some bytes in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param bytes the bytes to push
+ * @param len the number of bytes to push
+ */
+void pushBytes(BYTE_BUFFER* buffer, unsigned char *byte, unsigned int len)
+{
+    buffer->data = (char*)realloc(buffer->data, buffer->size+len);
+    memcpy(&buffer->data[buffer->size], byte, len);
+    buffer->size += len;
+}
+
+/**
+ * Gives the bit at a specific position
+ * 
+ * @param buffer the buffer to evaluate
+ * @param n the bit position
+ * 
+ * @return the bit value
+ */
+unsigned int bitAt(BYTE_BUFFER buffer, unsigned long int n)
+{
+    unsigned char byte = buffer.data[n / 8];
+    return (byte & (0x80 >> (n % 8)) != 0);
+}
+

emit/buffer.h

@@ -0,0 +1,83 @@
+#ifndef __BUFFER_H__
+#define __BUFFER_H__
+
+
+typedef struct {
+    char* data;
+    unsigned long int size;
+} BYTE_BUFFER;
+
+
+/**
+ * Create a new byte buffer
+ *
+ * @return the created buffer
+ */
+BYTE_BUFFER createByteBuffer();
+
+/**
+ * Release the memory
+ *
+ * @param buffer the buffer to destroy
+ */
+void destroyByteBuffer(BYTE_BUFFER buffer);
+
+/**
+ * Print a byte in binary
+ * 
+ * @param byte the byte to print
+ */
+void printfBit(unsigned char byte);
+
+/**
+ * Print all the bytes from a buffer
+ *
+ * @param buffer the buffer holding the data
+ */
+void printfByteBuffer(BYTE_BUFFER buffer);
+
+/**
+ * Push a byte in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param byt the byte to push
+ */
+void pushByte(BYTE_BUFFER* buffer, unsigned char byte);
+
+/**
+ * Push a word in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param word the word to push
+ */
+void pushWord(BYTE_BUFFER* buffer, unsigned short int word);
+
+/**
+ * Push some bytes in a buffer
+ *
+ * @param buffer the buffer holding the data
+ * @param bytes the bytes to push
+ * @param len the number of bytes to push
+ */
+void pushBytes(BYTE_BUFFER* buffer, unsigned char *byte, unsigned int len);
+
+/**
+ * Gives the bit at a specific position
+ * 
+ * @param buffer the buffer to evaluate
+ * @param n the bit position
+ * 
+ * @return the bit value
+ */
+unsigned int bitAt(BYTE_BUFFER buffer, unsigned long int n);
+
+
+/**
+ * Print all the bits from a buffer
+ *
+ * @param buffer the buffer holding the data
+ */
+//void printfBitBuffer(BIT_BUFFER buffer);
+void printfBitBuffer(BYTE_BUFFER buffer);
+
+#endif

emit/emit.c

@@ -2,7 +2,8 @@
 #ifdef __arm__
     #include <wiringPiSPI.h>
 #endif
-#include "emitlib.h"
+#include "home_easy.h"
+#include "buffer.h"
 #include <malloc.h>
 #include <string.h>
 #include <unistd.h>

emit/home_easy.c

@@ -0,0 +1,274 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <string.h>
+#include <wiringPi.h>
+#include "home_easy.h"
+#include "buffer.h"
+#include "utils.h"
+
+unsigned int timings[5][2] = {
+    {275, 275},  //  bit 0
+    {275, 1300}, //  bit 1
+    {275, 9900},  //  end of data
+    {275, 2675}, //  start of frame
+    {275, 2675},  //  end of data
+};
+
+unsigned char homeEasyPinOut = 0;
+unsigned char homeEasyPinIn = 1;
+
+
+/**
+ * Encode bits with HomeEasy encoding (1 => 10, 0 => 01)
+ * 
+ * @param buffer the buffuer to encode
+ * 
+ * @return new buffer
+ * */
+BYTE_BUFFER homeEasyEncode(BYTE_BUFFER *buffer)
+{
+    BYTE_BUFFER result = createByteBuffer();
+    unsigned int i;
+    for(i=0; i<buffer->size; i++) {
+        pushWord(&result, encodeByte(buffer->data[i]));
+    }
+    return result;
+}
+
+/**
+ * Decode bits with HomeEasy encoding (1 => 10, 0 => 01)
+ * 
+ * @param buffer the buffuer to decode
+ * 
+ * @return new buffer
+ * */
+BYTE_BUFFER homeEasyDecode(BYTE_BUFFER *buffer)
+{
+    BYTE_BUFFER result = createByteBuffer();
+    unsigned short int word;
+    unsigned char *byte = (unsigned char*)&word;
+    unsigned int i;
+    for(i=0; i<(buffer->size+1)/2; i++) {
+        byte[1] = buffer->data[2*i];
+        byte[0] = (2*i+1 < buffer->size ? buffer->data[2*i+1]:0);
+        pushByte(&result, decodeByte(word));
+    }
+    return result;
+}
+
+/**
+ * Decode a byte according to HomeEasy
+ * 
+ * @param byte the byte to decode
+ * 
+ * @return the decoded byte
+ */
+unsigned char decodeByte(unsigned short int word)
+{
+    unsigned char decodedChar=0;
+    int j;
+    int shift = 7;
+    for(j=0x8000;j>0; j>>=2) {
+	    decodedChar |= (((word & j) == j) ? 0x01 : 0x00) << shift;
+		shift -=1;
+    }
+    return decodedChar;
+}
+
+/**
+ * Encode a byte according to HomeEasy
+ * 
+ * @param byte the byte to encode
+ * 
+ * @return the encoded byte
+ */
+unsigned short int encodeByte(unsigned char byte)
+{
+    unsigned short int encodedChar=0;
+    int j;
+    int shift = 14;
+    for(j=0x80;j>0; j>>=1) {
+	      encodedChar |= (((byte & j) == j) ? 0x02 : 0x01) << shift;
+	      shift -=2;
+    }
+    return encodedChar;
+}
+
+/**
+ * Create a complete command according to Chacon protocole
+ *
+ * @param id command id (refer to your remote)
+ * @param section button section ('A' | 'B'  | 'C'  | 'D'  | 'G')
+ * @param nb button number(1, 2, 3, 4)
+ * @param on boolean for on/off
+ */
+BYTE_BUFFER createHomeEasyCommand(unsigned char* id, char section, unsigned char nb, unsigned char on)
+{
+    unsigned char last = id[3] & 0xc0;
+    BYTE_BUFFER command;
+    char formatedSection = (section<='Z' ? section : section + 'A' - 'a');
+    // adding global
+    last |= (formatedSection == 'G' ? 0x20 : 0);
+    // adding on/off
+    last |= (on ? 0x10 : 0);
+    // adding section
+    last |= ((formatedSection == 'G' ? 0 : formatedSection - 'A') << 2) & 0x0c;
+    // adding num
+    last |= (formatedSection == 'G' ? 0 : nb-1) & 0x03;;
+    //Preparing output buffer
+    command = createByteBuffer();
+    pushBytes(&command, id, 3);
+    pushByte(&command, last);
+    return command;
+}
+
+/**
+ * Send a complete command according to Chacon protocole
+ *
+ * @param id command id (refer to your remote)
+ * @param section button section ('A' | 'B'  | 'C'  | 'D'  | 'G')
+ * @param nb button number(1, 2, 3, 4)
+ * @param on boolean for on/off
+ * @param repeat number of repeatition
+ */
+void SendHomeEasyCommand(unsigned char* id, char section, unsigned char nb, unsigned char on, unsigned char repeat)
+{
+	BYTE_BUFFER command;
+	unsigned int i;
+	command = createHomeEasyCommand(id, section, nb, on);
+	sendHomeEasyBit(TRIGGER0);
+	sendHomeEasyBit(TRIGGER1);
+	for(i=0; i<repeat; i++) {
+		sendHomeEasyBytes(command);
+		sendHomeEasyBit(END_OF_FRAME);
+	}
+}
+
+/**
+ * Configure the GPIO output pin
+ *
+ * @param pinNumber wiringPi pin number
+ */
+void setHomeEasyTransmittorPin(unsigned char pinNumber)
+{
+	homeEasyPinOut = pinNumber;
+}
+
+/**
+ * read the GPIO output pin
+ *
+ * @return wiringPi pin number
+ */
+unsigned char getHomeEasyTransmittorPin()
+{
+	return homeEasyPinOut;
+}
+
+/**
+ * Configure the GPIO input pin
+ *
+ * @param pinNumber wiringPi pin number
+ */
+void setHomeEasyReceptorPin(unsigned char pinNumber)
+{
+	homeEasyPinIn = pinNumber;
+}
+
+/**
+ * read the GPIO input pin
+ *
+ * @return wiringPi pin number
+ */
+unsigned char getHomeEasyReceptorPin()
+{
+	return homeEasyPinIn;
+}
+
+/**
+ * Send a bit to the RF transmitter
+ * 
+ * @param bit the bit to transmit (0 | 1 | TRIGGER0 | TRIGGER1 | END_OF_FRAME)
+ */
+void sendHomeEasyBit(unsigned char bit)
+{
+	digitalWrite(homeEasyPinOut, 1);
+    delayMicroseconds(timings[bit][0]);
+   	digitalWrite(homeEasyPinOut, 0);
+    delayMicroseconds(timings[bit][1]);
+}
+
+/**
+ * Send a byte to the RF transmitter
+ * 
+ * @param byte the byte to transmit
+ */
+void sendHomeEasyByte(unsigned char byte)
+{
+    int i;
+    for(i=0x80;i>0; i>>=1) {
+    	sendHomeEasyBit((byte & i) == i);
+    }
+}
+
+/**
+ * Send the content of a buffer to the RF transmitter
+ * 
+ * @param buffer the buffer to transmit
+ */
+void sendHomeEasyBytes(BYTE_BUFFER buffer)
+{
+	unsigned int i;
+	for(i=0; i<buffer.size; i++) {
+		sendHomeEasyByte(buffer.data[i]);
+	}
+}
+
+/**
+ * Calculate the length of the frame
+ *
+ * @param data data to scan (each byte represent a bit)
+ * @param high length of high level
+ * @param low length of low level
+ *
+ * @return total length of the frame
+ */
+unsigned int frameSize(unsigned char* data, unsigned int* high, unsigned int* low)
+{
+    unsigned int i=0;
+    if (high) *high = 0;
+    if (data[i] == 1) {
+        for(i=0; data[i]; i++) ;
+        if (high) *high = i;
+    }
+    for(;  !data[i]; i++) ;
+    if (low) *low = i - *high;
+    return i;
+}
+
+/**
+ * Reading data from GPIO
+ *
+ * @param samples number of samples to read
+ * @param duration waiting time between samples
+ *
+ * @return buffer
+ */
+BYTE_BUFFER readData(unsigned long int samples, unsigned int duration)
+{
+    struct timeval* start;
+    BYTE_BUFFER result;
+    unsigned long int i;
+    
+    result = createByteBuffer();
+    result.size = samples;
+    result.data = (char*) realloc(result.data, samples);
+
+    start = showTime(0);
+    for(i=0; i<samples; i++) {
+        result.data[i] = digitalRead(homeEasyPinIn);
+        delayMicroseconds(duration);
+    }
+    showTime(start);
+    return result;
+}

emit/home_easy.h

@@ -0,0 +1,143 @@
+#ifndef __HOME_EASY_H__
+#define __HOME_EASY_H__
+
+#include <stdio.h>
+#include "buffer.h"
+
+#define BIT0 0
+#define BIT1 1
+#define TRIGGER0 2
+#define TRIGGER1 3
+#define END_OF_FRAME 3
+
+#define ON 1
+#define OFF 0
+
+/**
+ * Encode bits with HomeEasy encoding (1 => 10, 0 => 01)
+ * 
+ * @param buffer the buffuer to encode
+ * 
+ * @return new buffer
+ * */
+BYTE_BUFFER homeEasyEncode(BYTE_BUFFER *buffer);
+
+/**
+ * Decode bits with HomeEasy encoding (1 => 10, 0 => 01)
+ * 
+ * @param buffer the buffuer to decode
+ * 
+ * @return new buffer
+ * */
+BYTE_BUFFER homeEasyDecode(BYTE_BUFFER *buffer);
+
+/**
+ * Encode a byte according to HomeEasy
+ * 
+ * @param byte the byte to encode
+ * 
+ * @return the encoded byte
+ */
+unsigned short int encodeByte(unsigned char byte);
+
+/**
+ * Decode a byte according to HomeEasy
+ * 
+ * @param byte the byte to decode
+ * 
+ * @return the decoded byte
+ */
+unsigned char decodeByte(unsigned short int word);
+
+/**
+ * Creata a complete command according to Chacon protocole
+ *
+ * @param id command id (refer to your remote)
+ * @param section button section ('A' | 'B'  | 'C'  | 'D'  | 'G')
+ * @param nb button number(1, 2, 3, 4)
+ * @param on boolean for on/off
+ */
+BYTE_BUFFER createHomeEasyCommand(unsigned char* id, char section, unsigned char nb, unsigned char on);
+
+/**
+ * Send a complete command according to Chacon protocole
+ *
+ * @param id command id (refer to your remote)
+ * @param section button section ('A' | 'B'  | 'C'  | 'D'  | 'G')
+ * @param nb button number(1, 2, 3, 4)
+ * @param on boolean for on/off
+ * @param repeat number of repeatition
+ */
+void SendHomeEasyCommand(unsigned char* id, char section, unsigned char nb, unsigned char on, unsigned char repeat);
+
+/**
+ * Configure the GPIO output pin
+ *
+ * @param pinNumber wiringPi pin number
+ */
+void setHomeEasyTransmittorPin(unsigned char pinNumber);
+
+/**
+ * read the GPIO output pin
+ *
+ * @return wiringPi pin number
+ */
+unsigned char getHomeEasyTransmittorPin();
+
+/**
+ * Configure the GPIO input pin
+ *
+ * @param pinNumber wiringPi pin number
+ */
+void setHomeEasyReceptorPin(unsigned char pinNumber);
+
+/**
+ * read the GPIO input pin
+ *
+ * @return wiringPi pin number
+ */
+unsigned char getHomeEasyReceptorPin();
+
+/**
+ * Send a bit to the RF transmitter
+ * 
+ * @param bit the bit to transmit (0 | 1 | TRIGGER0 | TRIGGER1 | END_OF_FRAME)
+ */
+void sendHomeEasyBit(unsigned char bit);
+
+/**
+ * Send a byte to the RF transmitter
+ * 
+ * @param byte the byte to transmit
+ */
+void sendHomeEasyByte(unsigned char byte);
+
+/**
+ * Send the content of a buffer to the RF transmitter
+ * 
+ * @param buffer the buffer to transmit
+ */
+void sendHomeEasyBytes(BYTE_BUFFER buffer);
+
+/**
+ * Calculate the length of the frame
+ *
+ * @param data data to scan (each byte represent a bit)
+ * @param high length of high level
+ * @param low length of low level
+ *
+ * @return total length of the frame
+ */
+unsigned int frameSize(unsigned char* data, unsigned int* high, unsigned int* low);
+
+/**
+ * Reading data from GPIO
+ *
+ * @param samples number of samples to read
+ * @param duration waiting time between samples
+ *
+ * @return buffer
+ */
+BYTE_BUFFER readData(unsigned long int samples, unsigned int duration);
+
+ #endif

emit/test/Makefile

@@ -1,13 +1,13 @@
 all : test
 
-test : test.o emitlib.o
-	gcc -o test test.o emitlib.o
+test : test.o buffer.o home_easy.o utils.o
+	gcc -o $@ $^
 
 test.o : test.c
-	gcc -c test.c -o test.o
+	gcc -c $< -o $@
 
-emitlib.o : ../emitlib.c ../emitlib.h
-	gcc -c ../emitlib.c -o emitlib.o
+%.o : ../%.c ../%.h
+	gcc -c $< -o $@
 
 clean:
 	rm -f test *.o

emit/test/test.c

@@ -1,5 +1,6 @@
 #include <stdio.h>
-#include "../emitlib.h"
+#include "../home_easy.h"
+#include "../buffer.h"
 
 #define TEST_START printf("\n=== %s ===\n", __FUNCTION__)
 
@@ -36,28 +37,6 @@ void testPrintBits()
     destroyByteBuffer(buffer);
 }
 
-/*void testBitBuffer()
-{
-    BIT_BUFFER buffer;
-    TEST_START;
-    buffer = createBitBuffer();
-    
-    bitPushBit(&buffer, 1);
-    bitPushBit(&buffer, 1);
-    bitPushBit(&buffer, 1);
-    bitPushBit(&buffer, 1);
-    bitPushBit(&buffer, 0);
-    bitPushBit(&buffer, 0);
-    bitPushBit(&buffer, 0);
-    bitPushBit(&buffer, 0);
-    
-    printf("Should: 11110000\nGet: ");
-    printfBitBuffer(buffer);
-    printf("\n");
-    
-    destroyBitBuffer(buffer);
-}*/
-
 void testEncode()
 {
     unsigned char srcByte = 0x28;

emit/utils.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include "utils.h"
+
+
+
+/**
+ * Calculate a duration
+ *
+ * @param start start of the computing or null if
+ * this is the first time this function is inoked
+ *
+ * @return current time
+ */
+struct timeval* showTime(struct timeval* start)
+{
+    struct timeval* stop;
+    long tv_sec;
+    long tv_usec;
+    stop = (struct timeval*)malloc(sizeof(struct timeval));
+    gettimeofday(stop, 0);
+    if (!start) return stop;
+    tv_sec = (start->tv_usec > stop->tv_usec) ? stop->tv_sec - start->tv_sec - 1 : stop->tv_sec - start->tv_sec;
+    tv_usec = (start->tv_usec > stop->tv_usec) ? 1000000 + stop->tv_usec - start->tv_usec : stop->tv_usec - start->tv_usec;
+    fprintf(stderr, "%lus %lums %luµs\n", tv_sec, tv_usec/1000, tv_sec % 1000);
+    return stop;
+}

emit/utils.h

@@ -0,0 +1,18 @@
+#ifndef __UTILS_H__
+#define __UTILS_H__
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+/**
+ * Calculate a duration
+ *
+ * @param start start of the computing or null if
+ * this is the first time this function is inoked
+ *
+ * @return current time
+ */
+struct timeval* showTime(struct timeval* start);
+
+#endif