unisasa.c

#include"unisasa.h"

//Global Variables
sensor_t sensors[NUMSENS];
actuator_t actuators[NUMACTS];
device_t thisDevice;
unsigned int nextIDSen = FIRST_ID_SEN;
unsigned int nextIDAct = FIRST_ID_ACT;

unsigned char numSens=0;
unsigned char numActs=0;


// ---------------------- Internal tools ------------------------- //

converter_t converter;

void _reverseArray(unsigned char* src, unsigned int size, unsigned char* dest)
{
    int i,j;
    i=0;
    j=size -1 ;
    while (j >= 0) 
    {
        dest[i] = src[j];
        i++;
        j--;
    }
}


unsigned char _getSizeBytes(unsigned int i)
{
    converter_t con;
    con.integer = i;
#ifdef BIG_ENDIAN
    converter_t tmp;
    tmp.integer=con.integer;
    _reverseArray(tmp.byte, BYTES_UNSIGNED_INT, con.byte);
#endif
    unsigned char size = 0;
    for(i=0; i<BYTES_UNSIGNED_INT; i++)
        if(con.byte[i] != 0)
            size = i;
    return size + 1;
}

union message_t {
    unsigned int integer;
    unsigned char byte[BYTES_MESSAGE];
} message,answer;
// ------------------------------------------------------------- //

void createDevice(unsigned int address, unsigned char sizeIOmsg,messageHandlerFunc msgHandler, messageAndAnswerHandlerFunc msgAnsHandler)
{
    thisDevice.address.integer = address;
    thisDevice.sizeIOMsg = sizeIOmsg;
    thisDevice.sizeIDSen = _getSizeBytes(NUMSENS);
    thisDevice.sizeIDAct = _getSizeBytes(NUMACTS);
    thisDevice.messageHandler = msgHandler;
    thisDevice.messageAndAnswerHandler = msgAnsHandler;
}

void addSensor(unsigned int typeSensor,unsigned char sizeOutput,unsigned char typeOutput, getSensorValueFunc getValue)
{
    sensors[nextIDSen].ID.integer = nextIDSen;
    sensors[nextIDSen].typeSensor.integer = typeSensor;
    sensors[nextIDSen].sizeOutput = sizeOutput;
    sensors[nextIDSen].typeOutput = typeOutput;
    sensors[nextIDSen].getValue = getValue;
    nextIDSen++;
    numSens++;
}

void addActuator(unsigned int typeActuator,unsigned char sizeInput,unsigned char typeInput, setActuatorValueFunc setValue)
{
    actuators[nextIDAct].ID.integer = nextIDAct;
    actuators[nextIDAct].typeActuator.integer = typeActuator;
    actuators[nextIDAct].sizeInput = sizeInput;
    actuators[nextIDAct].typeInput = typeInput;
    actuators[nextIDAct].setValue = setValue;
    nextIDAct++;
    numActs++;
}


void communication(receiveUnisasa receive, sendUnisasa send )
{
    unsigned int id; //sen or act
    int s,a;
/*  while(1)
    { */
        receive(message.byte,1);
        switch (message.byte[0])
        {
            case DISCOVERY:
                /*
                 *    1 byte    sizeAddr    1 byte
                 * | sizeaddr |   addr   | sizeIOMsg | ...
                 *                       
                 *       1 byte     sizeIDSen  sizeIDSen   2 byte    1 byte     1 byte  
                 * ... | sizeIDSen | num Sens |  ID Sen  | type Sen | size Out | type Out ...
                 *
                 *    1 byte     sizeIDAct   sizeIDAct    2 byte    1 byte    1 byte
                 * ... | sizeIDAct | num Acts |  ID Act   | type Act | size In | type In |
                 *
                 */
                message.byte[0] = BYTES_ADDRESS_DEVICE;
                send(message.byte,1);
                SEND(thisDevice.address.byte,BYTES_ADDRESS_DEVICE,converter.byte);
                send(&(thisDevice.sizeIOMsg),1);

                send(&thisDevice.sizeIDSen,1);
                SEND(&numSens,thisDevice.sizeIDSen,converter.byte);
                for(s=0;s< numSens; s++)
                {
                    SEND(sensors[s].ID.byte,thisDevice.sizeIDSen,converter.byte);
                    SEND(sensors[s].typeSensor.byte,SIZE_TYPE_SENSOR,converter.byte);
                    send(&(sensors[s].sizeOutput),1);
                    send(&(sensors[s].typeOutput),1);
                }
                send(&(thisDevice.sizeIDAct),1);
                SEND(&numActs,thisDevice.sizeIDAct,converter.byte);
                for(a=0;a< numActs; a++)
                {
                    SEND(actuators[a].ID.byte,thisDevice.sizeIDAct,converter.byte);
                    SEND(actuators[a].typeActuator.byte,SIZE_TYPE_ACTUATOR,converter.byte);
                    send(&(actuators[a].sizeInput),1);
                    send(&(actuators[a].typeInput),1);
                }
                break;
            case CHECK_DEVICE:
                message.byte[0] = ACTIVE_DEVICE_ACK;
                send(message,1);
                SEND(thisDevice.address.byte,BYTES_ADDRESS_DEVICE,converter.byte);
                break;
            case MSG_TO_DEVICE:
                message.integer=0;
                RECV(message.byte,thisDevice.sizeIOMsg,converter.byte);
                thisDevice.messageHandler(message.byte);
                break;
            case MSG_AND_ANSWER_TO_DEVICE:
                RECV(message.byte,thisDevice.sizeIOMsg,converter.byte);
                thisDevice.messageAndAnswerHandler(message.byte,answer.byte);
                SEND(answer.byte,thisDevice.sizeIOMsg,converter.byte);
                break;
            case GET_SENSOR_VALUE:
                message.integer=0;
                answer.integer=0;
                RECV(message.byte,thisDevice.sizeIDSen,converter.byte);
                id=message.integer;
                sensors[id].getValue(answer.byte);
                SEND(answer.byte,sensors[id].sizeOutput,converter.byte);
                break;
            case SET_ACTUATOR_VALUE:
                message.integer=0;
                RECV(message.byte,thisDevice.sizeIDAct,converter.byte);
                id = message.integer;
                RECV(message.byte,actuators[id].sizeInput,converter.byte);
                actuators[id].setValue(message.byte);
                break;
            default:
                break;
        }//end switch/case
    //}//end while
}