File content as of revision 5:dcbebd42186a:

#include "mbed.h" 
#include "X2D.h" 

#define BUF_SIZE    1000
#define BIT_SIZE    145

int processData(void);

DigitalOut Reg_Data(PC_1);
DigitalOut RxTx(PB_0);
DigitalOut Tx(PA_9);
DigitalOut UART(PA_0, 1);

DigitalIn CD(PC_0);
//DigitalIn Rx(PB_7);
DigitalIn BU(PA_4);
DigitalIn CLR(PA_1);
DigitalIn RSTO(PC_2);

InterruptIn Rx(PB_7, PullUp);

pulse_t timeDiff;
CircularBuffer<pulse_t, BUF_SIZE> PulseWidth;
bool dataBits[BIT_SIZE]={0}; // 18 Nibbles +1


long startedAt=0;
long endedAt=0;

Timer xTime; 

void getPulseF(void)
{
        endedAt = xTime.read_us(); // set timer end for last pin
        timeDiff.v = endedAt - startedAt;
        timeDiff.pin = 1;
        PulseWidth.push(timeDiff);
        startedAt= endedAt; //  set timer start for this pin
}

void getPulseR(void)
{
        endedAt = xTime.read_us(); // set timer end for last pin
        timeDiff.v = endedAt - startedAt;
        timeDiff.pin = 0;
        PulseWidth.push(timeDiff);
        startedAt= endedAt; //  set timer start for this pin
}

void wait_posedge(void)
{
    if(CLR != 0)
    {
        while(CLR != 0) ;
    }
    else ;
    while(CLR == 0) ;
}

void wait_negedge(void)
{
    if(CLR == 0)
    {
        while(CLR == 0) ;
    }   
    else ;
    while(CLR != 0) ;
}

unsigned long read_ctrl_reg(void)
{
    unsigned long return_value = 0;
    unsigned long curr_bit = 0 ;
    int i ;
    
    RxTx = 1;
    //Reg_Data = 0;
    wait_posedge();
    //wait_ms(10);
    Reg_Data = 1;
    RxTx = 1;

    for(i=0;i<=23;i++)
    {
        //DBG("i= %d", i);
        wait_posedge();
        curr_bit = Rx ;
        return_value |= ((curr_bit) << (23-i)) ;
    }
    //wait_negedge();

    Reg_Data = 0;   //clr pin reg_data

    wait(1) ;
    return return_value ;
}

void write_ctrl_reg(unsigned long write_data)
{
    int i ;

    DBG("Write_reg = %X",write_data);
    wait_posedge();   //find posedge for Tcr
    Reg_Data = 1;   //set pin reg_data to Register mode
    RxTx = 0;       //set pin rxtx to Tx mode
  //  wait_negedge();
    //delay(50) ;       //delay for Tcc

    for(i=0;i<=23;i++) //low code effciency may result in wrong writing
    {
        if(((write_data >> (23-i)) & 0x1) == 0)
        {
            Tx = 0;
        }
        else
        {
            Tx = 1;
        }
        wait_posedge();
    }
    RxTx = 1;       //set pin rxtx to Rx
    Reg_Data = 0;   //set pin reg_data
    Tx = 0;
    wait(0.1);
}

void SendBit(bool value)
{
//    DBG("%d ", value);
    Tx = !Tx;
    if(value)
        {
        wait_us(800);
        Tx = !Tx;
        wait_us(800);
        }
    else
        {
        wait_us(1600);
        }
}
    
void SendByte(char value)
{
int i=0;
bool bit;
static char cnt=0;

    pc.printf("%0.2X ", value);
    for(i=0; i<8; i++)
        {
        bit = (bool)(0x01 & (value>>i)); // LSB first
        SendBit(bit); 
        if(bit)
            cnt++;
        else
            cnt=0;
        if(cnt == 5)
            SendBit(0);
        }
}

void SendPreamble(void)
{
int i;

    pc.printf("\r\n");
    Tx=1;
    for(i=0; i<17; i++)
        SendBit(0);
    for(i=0; i<6; i++)
        SendBit(1);
    SendBit(0);

}

void SendPostamble(void)
{
int i;

    for(i=0; i<8; i++)  // Send 0xFF
        SendBit(1);
    for(i=0; i<8; i++)
        SendBit(0);

}

void SendFrame(char *data, int length)
{

int i, chksum=0;

    RxTx = 0;       //set pin rxtx to Tx
    wait_ms(1);

    SendPreamble();

    for(i=0; i<length; i++)
        {
        SendByte(data[i]);
        chksum += data[i];
        }
    chksum = ~chksum +1;

    SendByte((char)(chksum>>8));
    SendByte((char)chksum);
    SendPostamble();

    RxTx = 1;       //set pin rxtx to Rx
}

void SendCmd(prog prog, int zone)
{
char tab[8]={0xF1,0xE6,0x01,0x10,0x01,0x00,0x03,0x64};    // Zone1 Sun
char maison[2]={0xF1,0xE6};
char source = 0x01;
char dest = 0;
char trans = 0x01;
int i;

    dest = 0x10 + zone-1;
    tab[3] = dest;
    tab[6] = prog;

    for(i=0; i<3; i++)
        {
        tab[5]=i;    //message count
        SendFrame(tab, 8);
        wait_ms(30);
        }

}

int detectPreamble(void)
{
pulse_t pulse;
int cnt = 0;
char tmp[32]={0};
char timing[8*1024]={0};
char state=0;
char s=0, l=0, bit_ptr=0;

    while (!PulseWidth.empty())
    {
        PulseWidth.pop(pulse);
        sprintf(tmp, "%d, %ld|", pulse.pin, pulse.v);
        strcat(timing, tmp);
        
        if ((pulse.v > 700) && (pulse.v < 1000))
                { // short off detected
                    s++;
                    l=0;
                }
        else if ((pulse.v > 1500) && (pulse.v < 1800))
                { // long off detected
                    l++;
                    s=0;
                }
        else
                {
                    l=0;
                    s=0;
                    bit_ptr=0;
                    state=0;
                }
        switch(state)
            {
            case 0:     // Detect preamble 
                        if(s >= 12) // out of 12
                            state=1;
                        //pc.printf("%d ", s);
                        break;
            case 1:     // wait start bit (first long)
                        //pc.printf("OK2");
                        s=0;
                        if (l==1)
                            {
                            state = 2;
                            //bit_ptr++; inculde start bit in payload
                            }
                        l=0;
                        break;
            case 2: 
                        //pc.printf(" %d", pulse.v);
            
                        if (s == 2)
                            { 
                            dataBits[bit_ptr] = 1;
                            l=0;
                            s=0;
                            bit_ptr++;
                            }
                        if (l == 1 && s==0)
                            {
                            dataBits[bit_ptr] = 0;
                            l=0;
                            s=0;
                            bit_ptr++;
                            }
                        if(bit_ptr > BIT_SIZE)
                            {
                            state=0;
                            bit_ptr=0;
                            printf("Frame too long ; dropped");
                            }
                            
                        break;
            }
                        
        if(pulse.v > 30000 && cnt>0)     // End of frame
              {
              processData();
              //timing[0]=0;
              state=0;
              bit_ptr=0;
              //PulseWidth.reset();
//              WARN(" Waiting...");
              }
       
        cnt++;
    }
    if (cnt>0)      // if buffer wasn't empty
        {
        processData();
        //pc.printf("%s\r\n", timing);
        }

    return(0);
}

int processData(void)
{
int x=0;
int i = 0;
int j=  0;
char nibble[18]={0}, cnt=0;
int chksum=0, etx_ptr=16;

/*    pc.printf("\r\n");
    for (x=0;x<128;x++)
    {
        if(x%8==0)
            pc.printf(" ");
        pc.printf("%d", dataBits[x]);
    }
*/
x=0;

    for (i=0; i<etx_ptr; i++)
        {
        for (j=0;j<8;j++)
            {
            if ( dataBits[x])
                {
                nibble[i] |= 1<<j;
                cnt++;
                }
            else
                {
                if (cnt == 5)
                    j--;
                cnt=0;
                }
            dataBits[x] =0; // clean variable
            x++;
            }
        if (cnt >= 8)    // End of Frame detection
            etx_ptr=i;
        }
                

    for (i=0; i<etx_ptr-2; i++)   // Calculate Checksum
        chksum += nibble[i];
    chksum = ~chksum +1;
        
#ifdef __DEBUG__
    for (i=0; i<etx_ptr; i++)
        pc.printf("%0.2X ",nibble[i]);
    if ( (char)(chksum>>8) != nibble[etx_ptr-2] || (char)chksum != nibble[etx_ptr-1] )
        pc.printf("  CRC Error");
    pc.printf("\r\n");
#endif
    
    return 0;
}


void Init_X2D()
{
int Ctrl_Reg = 0;

    Rx.fall(&getPulseF);
    Rx.rise(&getPulseR);
    UART = 1;

    write_ctrl_reg(0x01E22F); // 1200 baud, deviation =1, Asynchrone
    Ctrl_Reg = read_ctrl_reg();
    DBG("Ctrl_reg = %X", Ctrl_Reg);

    RxTx = 1;       //set pin rxtx to Rx
    Reg_Data = 0;   //set pin reg_data 
    Tx = 0;

    xTime.start();
    xTime.reset();
    startedAt = xTime.read_us(); // set initial timer end

    //thread.start(getData);
}