WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/PIC/canIR/Source/Main.c

+ *
  *                  Main application
+ *
  *********************************************************************
  * FileName:        $HeadURL: https://svn.auml.se/svn/HomeAutomation/trunk/EmbeddedSoftware/PIC/canIR/Source/Main.c $
- * Last changed:    $LastChangedDate: 2007-03-03 19:07:14 +0100 (Sat, 03 Mar 2007) $
+ * Last changed:    $LastChangedDate: 2007-03-13 18:29:20 +0100 (Tue, 13 Mar 2007) $
  * By:              $LastChangedBy: johboh $
- * Revision:        $Revision: 353 $
+ * Revision:        $Revision: 363 $
  ********************************************************************/
+#include <p18cxxx.h>
 #include <compiler.h>
 #include <stackTasks.h>
 #include <Tick.h>
 #include <funcdefs.h>
 #include <CAN.h>
+#include <EEAccess.h>
+#include <crc16.h>
 #include "..\canBoot\Include\boot.h"
+typedef enum _EE_STATE {eesWAITING_START,eesSEND_ACK,eesWAIT_FIRST_DATA,eesWAIT_DATA_OR_CRC,eesWRITE_DATA,eesDONE} EE_STATE;
 #ifdef USE_IREC
     #include <IRec.h>
 #endif
 static void mainInit(void);
+static void loadIrCommands(void);
+#define EE_PACKET_TIMOUT 5*TICK_100MS
+#define IR_TIMOUT 2*TICK_100MS
+static BOOL hasCtrlPacket = FALSE;
+static CAN_PACKET ctrlPacket;
+typedef struct _IR_COMMAND
+{
+    BYTE repeat;
+    BYTE addr;
+    BYTE data;
+    BYTE pgm_class;
+    WORD pgm_id;
+    BYTE pgm_data[2];
+} IR_COMMAND;
+#define IR_COUNT 32
+static BYTE irValids = 0;
+static BYTE irCounts = 0;
+static TICK tick_irTimout = 0;
+static BYTE pgmData[56];
+#pragma udata big_mem
+static IR_COMMAND irCommands[IR_COUNT];
+#pragma udata
 void main()
+{
+    static EE_STATE ees = eesWAITING_START;
+    static EE_STATE eesAckNext = eesWAITING_START;
+    static BYTE ee_programmerId = 0;
+    static BOOL ee_externalEE = FALSE;
+    static DWORD ee_pgmAddress = 0;
+    static DWORD ee_newPgmAddress = 0;
+    static PGM_CTRL_TYPE ee_ackType = pctEE_ACK;
+    static BYTE ee_lastLocalIndex = 0;
+    CAN_PACKET outCp;
     // Inits
     mainInit();
+    #ifdef USE_IREC
+        loadIrCommands();
+    #endif
     canInit();
     #ifdef USE_IREC
         irecInit();
     #endif
+    for(ee_programmerId=0;ee_programmerId<56;ee_programmerId++) pgmData[ee_programmerId]=0xFF;
     while(1)
+    {
         TICK currentTick = tickGet();
         static TICK tick_led = 0;
+        static TICK tick_ee = 0;
         if ((currentTick-tick_led)>(1*TICK_1S))
+        {
-            LED0_IO=~LED0_IO;
+            //LED0_IO=~LED0_IO;
             tick_led = currentTick;
+        }
+        if ((currentTick-tick_irTimout)>IR_TIMOUT)
+        {
+            irCounts = 0;
+            tick_irTimout = currentTick;
+        }
+        switch(ees)
+        {
+            case eesWAITING_START:
+                if (hasCtrlPacket == TRUE && ctrlPacket.pgm.id == pctEE_START && ctrlPacket.data[4] == myId())
+                {
+                    ee_programmerId = ctrlPacket.sid;
+                    ee_externalEE = (ctrlPacket.data[3]==1?TRUE:FALSE);
+                    ee_pgmAddress = (((DWORD)ctrlPacket.data[2])<<16)+(((DWORD)ctrlPacket.data[1])<<8)+((DWORD)ctrlPacket.data[0]);
+                    tick_ee = currentTick;
+                    ee_ackType = pctEE_ACK;
+                    eesAckNext = eesWAIT_FIRST_DATA;
+                    ees = eesSEND_ACK;
+                }
+                break;
+            case eesSEND_ACK:
+                // send ack
+                outCp.type = ptPGM;
+                outCp.pgm.class = pcCTRL;
+                outCp.pgm.id = ee_ackType;
+                outCp.length=0;
+                tick_ee = currentTick;
+                ees = eesAckNext;
+                while(!canSendMessage(outCp,PRIO_HIGH));
+                break;
+            case eesWAIT_FIRST_DATA:
+                // Wait for first pgm packet. use offset to determine data index.
+                // When receiving crc from host, check crc for offsets bytes.
+                if ((currentTick-tick_ee)>EE_PACKET_TIMOUT)
+                {
+                    // Timeout, resend ack/nack.
+                    eesAckNext = eesWAIT_FIRST_DATA;
+                    ees = eesSEND_ACK;
+                }
+                if (hasCtrlPacket == TRUE && ctrlPacket.pgm.id==pctEE_PGM)
+                {
+                    BYTE localIndex = ctrlPacket.data[7];
+                    ee_lastLocalIndex = localIndex;
+                    pgmData[localIndex+0]=ctrlPacket.data[0]; pgmData[localIndex+1]=ctrlPacket.data[1]; pgmData[localIndex+2]=ctrlPacket.data[2]; pgmData[localIndex+3]=ctrlPacket.data[3];
+                    pgmData[localIndex+4]=ctrlPacket.data[4]; pgmData[localIndex+5]=ctrlPacket.data[5]; pgmData[localIndex+6]=ctrlPacket.data[6];
+                    ees = eesWAIT_DATA_OR_CRC;
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_START)
+                {
+                    ees   = eesWAITING_START;
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_CRC)
+                {
+                    ees   = eesWAIT_DATA_OR_CRC;
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_DONE)
+                {
+                    ees = eesDONE;
+                }
+                break;
+            case eesWAIT_DATA_OR_CRC:
+                // Wait for pgm packet. use offset to determine data index.
+                // When receiving crc from host, check crc for offsets bytes.
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_CRC)
+                {
+                    WORD crc16 = (((WORD)ctrlPacket.data[4])<<8)+((WORD)ctrlPacket.data[3]);
+                    WORD crc16calc = calc_crc(pgmData,56);
+                    // check CRC.
+                    if (crc16calc==crc16)
+                    {
+                        ee_newPgmAddress = (((DWORD)ctrlPacket.data[2])<<16)+(((DWORD)ctrlPacket.data[1])<<8)+((DWORD)ctrlPacket.data[0]);
+                        eesAckNext = eesWAIT_FIRST_DATA;
+                        ees = eesWRITE_DATA;
+                    }
+                    else
+                    {
+                        tick_ee = currentTick;
+                        ee_ackType = pctEE_NACK;
+                        eesAckNext = eesWAIT_FIRST_DATA;
+                        ees = eesSEND_ACK;
+                    }
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_PGM)
+                {
+                    BYTE localIndex = ctrlPacket.data[7];
+                    ee_lastLocalIndex = localIndex;
+                    pgmData[localIndex+0]=ctrlPacket.data[0]; pgmData[localIndex+1]=ctrlPacket.data[1]; pgmData[localIndex+2]=ctrlPacket.data[2]; pgmData[localIndex+3]=ctrlPacket.data[3];
+                    pgmData[localIndex+4]=ctrlPacket.data[4]; pgmData[localIndex+5]=ctrlPacket.data[5]; pgmData[localIndex+6]=ctrlPacket.data[6];
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_START)
+                {
+                    ees   = eesWAITING_START;
+                }
+                if (hasCtrlPacket==TRUE && ctrlPacket.pgm.id==pctEE_DONE)
+                {
+                    ees = eesDONE;
+                }
+                break;
+            case eesWRITE_DATA:
+                ClrWdt();
+                // Write EE and send ack.
+                if (ee_externalEE == FALSE)
+                {
+                    BYTE i;
+                    ee_pgmAddress = EE_IR_START+1+(WORD)((EE_INTERNAL_SIZE-1) & ee_pgmAddress);
+                    for(i=0;i<56;i++)
+                    {
+                        EEWrite(ee_pgmAddress+i,pgmData[i]);
+                        pgmData[i]=0xFF;
+                    }
+                }
+                ee_pgmAddress   = ee_newPgmAddress;
+                ee_ackType      = pctEE_ACK;
+                ees             = eesSEND_ACK;
+            break;
+            case eesDONE:
+                EEWrite(EE_IR_START,32);
+                loadIrCommands();
+                ees = eesWAITING_START;
+            break;
+            default:
+                ees = eesWAITING_START;
+            break;
         }
+            hasCtrlPacket = FALSE;
     }
+}
 #pragma interrupt high_isr
 void high_isr(void)
     #ifdef USE_IREC
         irecISR();
     #endif
 }
 #pragma interrupt low_isr
 void low_isr(void)
+{
+}
+void loadIrCommands()
+{
+    // Load IRs
+    BYTE i;
+    irValids = EERead(EE_IR_START);
+    for(i=0;(i<irValids && i<IR_COUNT);i++)
+    {
+        IR_COMMAND * buf_ptr = &irCommands[0];
+        buf_ptr[i].repeat = EERead(EE_IR_START+1+(i<<3));
+        buf_ptr[i].addr = EERead(EE_IR_START+2+(i<<3));
+        buf_ptr[i].data = EERead(EE_IR_START+3+(i<<3));
+        buf_ptr[i].pgm_class = EERead(EE_IR_START+4+(i<<3));
+        buf_ptr[i].pgm_id = ((WORD)EERead(EE_IR_START+5+(i<<3)) << 8)+(WORD)EERead(EE_IR_START+6+(i<<3));
+        buf_ptr[i].pgm_data[1] = EERead(EE_IR_START+7+(i<<3));
+        buf_ptr[i].pgm_data[0] = EERead(EE_IR_START+8+(i<<3));
+        /*
+        buf_ptr[0].repeat = 5;
+        buf_ptr[0].addr = 5;
+        buf_ptr[0].data = 5;
+        buf_ptr[0].pgm_class = 5;
+        buf_ptr[0].pgm_id = 5;
+        buf_ptr[0].pgm_data[1] = 5;
+        buf_ptr[0].pgm_data[0] = 5;
+        buf_ptr[1].repeat = 7;
+        buf_ptr[1].addr = 7;
+        buf_ptr[1].data = 7;
+        buf_ptr[1].pgm_class = 7;
+        buf_ptr[1].pgm_id = 7;
+        buf_ptr[1].pgm_data[1] = 7;
+        buf_ptr[1].pgm_data[0] = 7;
+        buf_ptr[2].repeat = 9;
+        buf_ptr[2].addr = 9;
+        buf_ptr[2].data = 9;
+        buf_ptr[2].pgm_class = 9;
+        buf_ptr[2].pgm_id = 9;
+        buf_ptr[2].pgm_data[1] = 9;
+        buf_ptr[2].pgm_data[0] = 9;
+        */
+    }
+}
 /*
 *   Function: mainInit
+*
 *   Input:  none
 *   Output: none
 *   Pre-conditions: none
 *   Affects: Se code
 *   Depends: none.
 */
 void mainInit()
+{
     LED0_TRIS=0;
     // Enable Interrupts
     INTCONbits.GIEH = 1;
     INTCONbits.GIEL = 1;
     // Enable interrupt prirority
     RCONbits.IPEN=1;
+}
 /*
 *   Function: canParse
+*
 *   Depends: none.
 */
 void canParse(CAN_PACKET cp)
+{
+    BYTE i;
+    if (cp.pgm.class == pcCTRL)
+    {
+        hasCtrlPacket = TRUE;
+        ctrlPacket.sid = cp.sid;
+        for(i=0;i<8;i++) ctrlPacket.data[i]=cp.data[i];
+        ctrlPacket.length = cp.length;
+        ctrlPacket.pgm.id = cp.pgm.id;
+    }
 }
 /*
 *   Function: irecParse
 *   Input:  Received IR message
 *   Output: none
 *   Pre-conditions: irecInit
 *   Affects: Sensors/actuators/etc. See code.
 *   Depends: none.
 */
 #ifdef USE_IREC
 void irecParse(IR_TYPE type, BYTE toggle, BYTE addr, BYTE data)
+{
+    static BYTE lastToogle = 0;
     CAN_PACKET outCp;
+    BYTE i;
+    IR_COMMAND * buf_ptr = &irCommands[0];
+    tick_irTimout = tickGet();
+    irCounts++;
     outCp.type      = ptPGM;
     outCp.pgm.class = pcSENSOR;
     outCp.pgm.id    = pstIR;
     outCp.length    = 4;
     outCp.data[3]   = type;
     outCp.data[2]   = toggle;
     outCp.data[1]   = addr;
     outCp.data[0]   = data;
     while(!canSendMessage(outCp,PRIO_HIGH));
+    // DUMP
+    if (addr==0x15 && data>=0x00)
+    {
+        for(i=0;i<7;i++)
+        {
+            outCp.type      = ptPGM;
+            outCp.pgm.class = 0x05;
+            outCp.pgm.id    = 0x91;
+            outCp.length    = 8;
+            outCp.data[7] = buf_ptr[i].repeat;
+            outCp.data[6]=buf_ptr[i].addr;
+            outCp.data[5]=buf_ptr[i].data;
+            outCp.data[4]=buf_ptr[i].pgm_class;
+            outCp.data[3]=(BYTE)((buf_ptr[i].pgm_id & 0xFF00) >> 8);
+            outCp.data[2]=(BYTE)buf_ptr[i].pgm_id;
+            outCp.data[1]=buf_ptr[i].pgm_data[1];
+            outCp.data[0]=buf_ptr[i].pgm_data[0];
+            while(!canSendMessage(outCp,PRIO_HIGH));
+        }
+    }
+    /*
+    if (addr==0x15 && data>=0x09)
+    {
+        for(i=0;i<7;i++)
+        {
+            outCp.type      = ptPGM;
+            outCp.pgm.class = 0x05;
+            outCp.pgm.id    = 0x91;
+            outCp.length    = 8;
+            outCp.data[7] = pgmData[i*8];
+            outCp.data[6]=pgmData[i*8+1];
+            outCp.data[5]=pgmData[i*8+2];
+            outCp.data[4]=pgmData[i*8+3];
+            outCp.data[3]=pgmData[i*8+4];
+            outCp.data[2]=pgmData[i*8+5];
+            outCp.data[1]=pgmData[i*8+6];
+            outCp.data[0]=pgmData[i*8+7];
+            while(!canSendMessage(outCp,PRIO_HIGH));
+        }
+    }
+    */
+    // slow? bad?
+    for(i=0;(i<irValids && i<IR_COUNT);i++)
+    {
+        if (buf_ptr[i].addr==addr && buf_ptr[i].data==data && ((buf_ptr[i].repeat == 0 && (lastToogle != toggle || irCounts==1)) || (buf_ptr[i].repeat == irCounts)))
+        {
+            outCp.type      = ptPGM;
+            outCp.pgm.class = buf_ptr[i].pgm_class;
+            outCp.pgm.id    = buf_ptr[i].pgm_id;
+            outCp.length    = 2;
+            outCp.data[1]   = buf_ptr[i].pgm_data[1];
+            outCp.data[0]   = buf_ptr[i].pgm_data[0];
+            while(!canSendMessage(outCp,PRIO_HIGH));
+            if (buf_ptr[i].repeat>0) irCounts = 0;
+        }
+    }
+    lastToogle  = toggle;
+}
 #endif
 // Below are mandantory when using bootloader

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/PIC/canIR/Source/Main.c @ 363 – Rev 353 → 363