ccp.c

ccp

      /* Increment ODT */
      if (++ccp.CurrentOdt>ccp.DaqList[ccp.CurrentDaq].last) {

        /* DAQ list done */
        ccp.CurrentOdt = 0;
        ccp.DaqList[ccp.CurrentDaq].flags &= ~DAQ_FLAG_SEND;

        /* Increment DAQ */
        if (++ccp.CurrentDaq>=CCP_MAX_DAQ) ccp.CurrentDaq = 0;

      }

      break;

    } else {

      /* Increment DAQ */
      if (++ccp.CurrentDaq>=CCP_MAX_DAQ) ccp.CurrentDaq = 0;

    }


  }

}

#endif

/* Data aquisition */
void ccpDaq( CCP_BYTE eventChannel )
{
  CCP_BYTE q,o;
  #ifndef CCP_SEND_SINGLE
    CCP_BYTE j;
  #endif

  if (!(ccp.SessionStatus&SS_RUN)) return;

  SET_PORT_BIT(4); /* Timingtest */

  for (o=0,q=0; q<CCP_MAX_DAQ; o+=CCP_MAX_ODT,q++) {

    if (!(ccp.DaqList[q].flags&DAQ_FLAG_START)) continue;

    if (ccp.DaqList[q].eventChannel!=eventChannel) continue;
    if (--ccp.DaqList[q].cycle!=0) continue;
    ccp.DaqList[q].cycle = ccp.DaqList[q].prescaler;

    #ifdef CCP_SEND_SINGLE

      /* Just mark DAQ for transmission */
      ccp.DaqList[q].flags |= DAQ_FLAG_SEND;

    #else

      /* Check that the current queue space fits a complete cycle */
      #if defined(CCP_SEND_QUEUE) && defined(CCP_SEND_QUEUE_OVERRUN_INDICATION)
        if (CCP_SEND_QUEUE_SIZE-ccp.Queue.len<=ccp.DaqList[q].last) {
          ccp.DaqList[q].flags |= DAQ_FLAG_OVERRUN;
          continue; /* Skip this DAQ list on overrun */
        }
      #endif

      /* Use BIT7 of PID to indicate overruns (CANape special feature) */
      #ifdef CCP_SEND_QUEUE_OVERRUN_INDICATION

        for (j=0;j<=ccp.DaqList[q].last;j++) {
          if (!ccpSampleAndTransmitDtm((o+j)|(ccp.DaqList[q].flags&DAQ_FLAG_OVERRUN),q,j)) {
            ccp.DaqList[q].flags |= DAQ_FLAG_OVERRUN;
          } else {
            ccp.DaqList[q].flags &= ~DAQ_FLAG_OVERRUN;
          }
        } /* j */

      #else

        for (j=0;j<=ccp.DaqList[q].last;j++) {
          ccpSampleAndTransmitDtm(o+j,q,j);
        } /* j */

      #endif

    #endif

  } /* q */

  /* Check for the next ODT to send */
  #ifdef CCP_SEND_SINGLE
    ccpSampleAndSendNextDtm();
  #endif

  RST_PORT_BIT(4); /* Timingtest */

}

#endif /* CCP_DAQ */


/*--------------------------------------------------------------------------*/
/* Background Processing */
/* Used for Checksum Calculation */
/*--------------------------------------------------------------------------*/

/* Table for CCITT checksum calculation */
#ifdef CCP_CHECKSUM_CCITT
  CCP_ROM CCP_WORD CRC16CCITTtab[256] = {

    0x0000,0x1189,0x2312,0x329B,0x4624,0x57AD,0x6536,0x74BF,
    0x8C48,0x9DC1,0xAF5A,0xBED3,0xCA6C,0xDBE5,0xE97E,0xF8F7,
    0x1081,0x0108,0x3393,0x221A,0x56A5,0x472C,0x75B7,0x643E,
    0x9CC9,0x8D40,0xBFDB,0xAE52,0xDAED,0xCB64,0xF9FF,0xE876,
    0x2102,0x308B,0x0210,0x1399,0x6726,0x76AF,0x4434,0x55BD,
    0xAD4A,0xBCC3,0x8E58,0x9FD1,0xEB6E,0xFAE7,0xC87C,0xD9F5,
    0x3183,0x200A,0x1291,0x0318,0x77A7,0x662E,0x54B5,0x453C,
    0xBDCB,0xAC42,0x9ED9,0x8F50,0xFBEF,0xEA66,0xD8FD,0xC974,
    0x4204,0x538D,0x6116,0x709F,0x0420,0x15A9,0x2732,0x36BB,
    0xCE4C,0xDFC5,0xED5E,0xFCD7,0x8868,0x99E1,0xAB7A,0xBAF3,
    0x5285,0x430C,0x7197,0x601E,0x14A1,0x0528,0x37B3,0x263A,
    0xDECD,0xCF44,0xFDDF,0xEC56,0x98E9,0x8960,0xBBFB,0xAA72,
    0x6306,0x728F,0x4014,0x519D,0x2522,0x34AB,0x0630,0x17B9,
    0xEF4E,0xFEC7,0xCC5C,0xDDD5,0xA96A,0xB8E3,0x8A78,0x9BF1,
    0x7387,0x620E,0x5095,0x411C,0x35A3,0x242A,0x16B1,0x0738,
    0xFFCF,0xEE46,0xDCDD,0xCD54,0xB9EB,0xA862,0x9AF9,0x8B70,
    0x8408,0x9581,0xA71A,0xB693,0xC22C,0xD3A5,0xE13E,0xF0B7,
    0x0840,0x19C9,0x2B52,0x3ADB,0x4E64,0x5FED,0x6D76,0x7CFF,
    0x9489,0x8500,0xB79B,0xA612,0xD2AD,0xC324,0xF1BF,0xE036,
    0x18C1,0x0948,0x3BD3,0x2A5A,0x5EE5,0x4F6C,0x7DF7,0x6C7E,
    0xA50A,0xB483,0x8618,0x9791,0xE32E,0xF2A7,0xC03C,0xD1B5,
    0x2942,0x38CB,0x0A50,0x1BD9,0x6F66,0x7EEF,0x4C74,0x5DFD,
    0xB58B,0xA402,0x9699,0x8710,0xF3AF,0xE226,0xD0BD,0xC134,
    0x39C3,0x284A,0x1AD1,0x0B58,0x7FE7,0x6E6E,0x5CF5,0x4D7C,
    0xC60C,0xD785,0xE51E,0xF497,0x8028,0x91A1,0xA33A,0xB2B3,
    0x4A44,0x5BCD,0x6956,0x78DF,0x0C60,0x1DE9,0x2F72,0x3EFB,
    0xD68D,0xC704,0xF59F,0xE416,0x90A9,0x8120,0xB3BB,0xA232,
    0x5AC5,0x4B4C,0x79D7,0x685E,0x1CE1,0x0D68,0x3FF3,0x2E7A,
    0xE70E,0xF687,0xC41C,0xD595,0xA12A,0xB0A3,0x8238,0x93B1,
    0x6B46,0x7ACF,0x4854,0x59DD,0x2D62,0x3CEB,0x0E70,0x1FF9,
    0xF78F,0xE606,0xD49D,0xC514,0xB1AB,0xA022,0x92B9,0x8330,
    0x7BC7,0x6A4E,0x58D5,0x495C,0x3DE3,0x2C6A,0x1EF1,0x0F78
  };
#endif

#ifndef CCP_CHECKSUM_BLOCKSIZE
  #define CCP_CHECKSUM_BLOCKSIZE 256
#endif

CCP_BYTE ccpBackground( void ) {

  SET_PORT_BIT(3); /* Timingtest */

  /* CCP command pending */
  #ifdef CCP_CMD_NOT_IN_INTERRUPT
    CCP_DISABLE_INTERRUPT;
    if (ccp.SendStatus&CCP_CMD_PENDING) {
      ccp.SendStatus &= ~CCP_CMD_PENDING;
      ccpCommand(CCP_RX_DATA_PTR);
    }
    CCP_ENABLE_INTERRUPT;
  #endif

  /* Call the user backgound function */
  ccpUserBackground();

  /* CCP checksum calculation */
  #ifdef CCP_CHECKSUM

    /*
       Checksum algorithm is not defined by the standard
       Type is defined by CCP_CHECKSUM_TYPE, Maximum blocksize is 64K
    */

    /* Checksum calculation in progress */
    if (ccp.CheckSumSize) {

      register CCP_BYTE n;
      #ifndef CCP_CHECKSUM_CCITT
        register CCP_BYTE b;
      #endif

      if (ccp.CheckSumSize<=(CCP_CHECKSUM_BLOCKSIZE-1)) {
        n = (CCP_BYTE)ccp.CheckSumSize;
        ccp.CheckSumSize = 0;
      } else {
        n = 0;
        ccp.CheckSumSize -= CCP_CHECKSUM_BLOCKSIZE;
      }

      do {
        #ifdef CCP_CHECKSUM_CCITT

          /* CRC */
          #ifdef CCP_MOTOROLA
            (*(CCP_WORD*)&ccp.Crm[4]) = CRC16CCITTtab[ccp.Crm[5] ^ *(ccp.MTA[CCP_INTERNAL_MTA]++)] ^ ccp.Crm[4];
          #else
            (*(CCP_WORD*)&ccp.Crm[4]) = CRC16CCITTtab[ccp.Crm[4] ^ *(ccp.MTA[CCP_INTERNAL_MTA]++)] ^ ccp.Crm[5];
          #endif

        #else

          /* Compiler Error BSO Tasking 16x */
          /* *(CCP_CHECKSUM_TYPE*)&ccp.Crm[4] += *(ccp.MTA[CCP_INTERNAL_MTA]++); does not work */

          /* Sum */
          b = *(ccp.MTA[CCP_INTERNAL_MTA]);
          *(CCP_CHECKSUM_TYPE*)&ccp.Crm[4] += b;
          ccp.MTA[CCP_INTERNAL_MTA]++;

        #endif
      } while (--n!=0);

      /* Checksum calculation finished ? */
      if (ccp.CheckSumSize) {
        RST_PORT_BIT(3); /* Timingtest */
        return 1; /* Still pending */
      }

      ccpSendCrm();

    } /* ccp.CheckSumSize */
  #endif

  RST_PORT_BIT(3); /* Timingtest */

  return 0;
}


/*--------------------------------------------------------------------------*/
/* Command Processor */
/*--------------------------------------------------------------------------*/

void ccpCommand( CCP_BYTEPTR com ) {

  SET_PORT_BIT(1); /* Timingtest */

  #define cmd com[0]
  #define ctr com[1]

  /* Handle CONNECT or TEST command */
  if (cmd==CC_CONNECT||cmd==CC_TEST) {

    #define stationAddr (*(CCP_WORD*)&com[2]) /* Has to be Intel-Format ! */

    #ifdef CCP_TESTMODE
      if (gDebugLevel) CCPPRINT("\n%u: %s addr=%u\n",ctr,cmd==CC_CONNECT?"CONNECT":"TEST",stationAddr);
    #endif

    /* This station */
    if (stationAddr==CCP_STATION_ADDR||stationAddr==CCP_BROADCAST_STATION_ADDR) { /* This station */

      if (cmd==CC_CONNECT) {
        #ifdef CCP_DAQ
          if (!(ccp.SessionStatus&SS_TMP_DISCONNECTED)) {
            ccpStopAllDaq();
            ccp.SendStatus = 0; /* Clear all transmission flags */
          }
        #endif
        ccp.SessionStatus |= SS_CONNECTED;
        ccp.SessionStatus &= ~SS_TMP_DISCONNECTED;

        #ifdef CCP_TESTMODE
          if (gDebugLevel) CCPPRINT("*** connected ***\n");
        #endif
      }

      /* Responce */
      /* Station addresses in Intel Format */
      ccp.Crm[0] = 0xFF;
      ccp.Crm[1] = CRC_OK;
      ccp.Crm[2] = ctr;
      ccp.Crm[3] = 0xFE;
      *(CCP_WORD*)&ccp.Crm[4] = CCP_STATION_ADDR;
      *(CCP_WORD*)&ccp.Crm[6] = CCP_BROADCAST_STATION_ADDR;

      /* responce */
      /* |||| */
    }

    /* Another station */
    else {

      /* If connected, temporary disconnect */
      if (ccp.SessionStatus&SS_CONNECTED) {

        ccp.SessionStatus &= ~SS_CONNECTED;
        ccp.SessionStatus |= SS_TMP_DISCONNECTED;

        #ifdef CCP_TESTMODE
          if (gDebugLevel) CCPPRINT("*** temporary disconnect ***\n");
        #endif

      }

      RST_PORT_BIT(1); /* Timingtest */

      /* no responce */
      return;

    }

  }

  /* Handle other commands only if connected */
  else if (ccp.SessionStatus&SS_CONNECTED) {

    /* prepare the responce */
    ccp.Crm[0] = 0xFF;
    ccp.Crm[1] = CRC_OK;
    ccp.Crm[2] = ctr;

    switch (cmd) {

      case CC_DISCONNECT:
        {
          #define disconnectCmd com[2]
          #define disconnectStationAddr (*(CCP_WORD*)&com[4])

          ccp.SessionStatus &= ~SS_CONNECTED;
          #ifdef CCP_TESTMODE
            if (gDebugLevel) CCPPRINT("%u: DISCONNECT cmd=%u\n",ctr,disconnectCmd);
          #endif

          if (disconnectCmd==0x00) { /* Temporary */
            ccp.SessionStatus |= SS_TMP_DISCONNECTED;
            #ifdef CCP_TESTMODE
              if (gDebugLevel) CCPPRINT("*** temporary disconnect ***\n");
            #endif
          } else {           /* End of session */
            #ifdef CCP_DAQ
              ccpStopAllDaq();
            #endif
            #ifdef CCP_SEED_KEY
              ccp.ProtectionStatus = 0; /* Clear Protection Status */
            #endif
            #ifdef CCP_TESTMODE
              if (gDebugLevel) CCPPRINT("*** end of session ***\n");
            #endif
          }
        }
        break;

      case CC_EXCHANGE_ID: /* Exchange Station Identifications */
        {
          CCP_BYTE i;
          #define masterId com[2]
          for(i=0;ccpStationId[i]!=0;i++) ;
          ccp.Crm[3] = i; /* Lenght of slave device identifier */
          ccp.Crm[4] = 0;
          /* Build the Resource Availability and Protection Mask */
          ccp.Crm[5] = PL_CAL; /* Default: Calibration available */
          ccp.Crm[6] = 0;      /* Default: No Protection */
          #ifdef CCP_SEED_KEY
            ccp.Crm[6] |= PL_CAL;   /* Protected Calibration */
          #endif
          #ifdef CCP_DAQ
            ccp.Crm[5] |= PL_DAQ;     /* Data Acquisition */
            #ifdef CCP_SEED_KEY
              ccp.Crm[6] |= PL_DAQ;   /* Protected Data Acquisition */
            #endif
          #endif
          #if defined(CCP_PROGRAM) || defined(CCP_BOOTLOADER_DOWNLOAD)
            ccp.Crm[5] |= PL_PGM;     /* Flash Programming */
            #ifdef CCP_SEED_KEY
              ccp.Crm[6] |= PL_PGM;   /* Protected Flash Programming */
            #endif
          #endif
          ccp.Crm[7] = CCP_DRIVER_VERSION; /* Driver version number */
          ccpSetMTA(0,(CCP_MTABYTEPTR)ccpStationId);
          #ifdef CCP_TESTMODE
            if (gDebugLevel) CCPPRINT("%u: EXCANGE_ID master_id=%u\n",ctr,masterId);
          #endif
        }
        break;

      #ifdef CCP_SEED_KEY

      case CC_GET_SEED: /* Get Seed for Key */
        {
          #define privilegeLevel com[2]
          ccp.Crm[3] = 0; /* Protection Status: No key required */
          *(CCP_DWORD*)&ccp.Crm[4] = 0;
          #ifdef CCP_SEED_KEY
            /* Keys required for CAL or PGM */
            switch (privilegeLevel) {
              case PL_CAL:
                ccp.Crm[3] = (0==(ccp.ProtectionStatus&PL_CAL)); /* Protection Status */
                *(CCP_DWORD*)&ccp.Crm[4] = ccpGetSeed(PL_CAL);
                break;
              case PL_PGM:
                ccp.Crm[3] = (0==(ccp.ProtectionStatus&PL_PGM)); /* Protection Status */
                *(CCP_DWORD*)&ccp.Crm[4] = ccpGetSeed(PL_PGM);
                break;
              case PL_DAQ:
                ccp.Crm[3] = (0==(ccp.ProtectionStatus&PL_DAQ)); /* Protection Status */
                *(CCP_DWORD*)&ccp.Crm[4] = ccpGetSeed(PL_DAQ);
                break;
              default:
                ccp.Crm[1] = CRC_CMD_SYNTAX;
                /* Error */
            }
          #endif
          #ifdef CCP_TESTMODE
            if (gDebugLevel) CCPPRINT("%u: GET_SEED resource=%02X, protection_status=%u\n",ctr,privilegeLevel,ccp.Crm[3]);
          #endif
        }
        break;

      case CC_UNLOCK: /* Unlock Protection */
        {
          #define key com[2] /* Key may be up to 6 Bytes */
          /* Check key */
          ccp.ProtectionStatus |= ccpUnlock(&com[2]); /* Reset the appropriate resource protection mask bit */
          ccp.Crm[3] = ccp.ProtectionStatus; /* Current Protection Status */
          #ifdef CCP_TESTMODE
            if (gDebugLevel) CCPPRINT("%u: UNLOCK protection_status=%02X\n",ctr,ccp.ProtectionStatus);
          #endif
        }
        break;

      #endif /* CCP_SEED_KEY */

      case CC_SET_MTA: /* Set transfer address */
        {
          #define mta     com[2]
          #define addrExt com[3]
          #define addr    (*(CCP_DWORD*)&com[4])
         if (mta<CCP_MAX_MTA-1) {
            ccpSetMTA(mta,ccpGetPointer(addrExt,addr));
         } else {
            ccp.Crm[1] = CRC_OUT_OF_RANGE;
         }
          #ifdef CCP_TESTMODE
            if (gDebugLevel) CCPPRINT("%u: SET_MTA %u to %08lX,%u\n",ctr,mta,addr,addrExt);
          #endif
        }
        break;

      case CC_DNLOAD: /* Download */
        {
          CCP_BYTE r;
          #define size com[2]
          #ifdef CCP_SEED_KEY
            if (!(ccp.ProtectionStatus&PL_CAL)) {
              ccp.Crm[1] = CRC_ACCESS_DENIED;
              r = 0;
            }
            else
          #endif
          r = ccpWriteMTA(0,size,&com[3]);
          #ifdef CCP_STANDARD
            ccpGetMTA0((CCP_BYTE*)&ccp.Crm[3],(CCP_DWORD*)&ccp.Crm[4]);
          #endif
          if (r==CCP_WRITE_PENDING) return; /* EEPROM write pending */
          if (r==CCP_WRITE_DENIED||r==CCP_WRITE_ERROR) ccp.Crm[1] = CRC_ACCESS_DENIED; /* No write access */
          #ifdef CCP_TESTMODE
            if (gDebugLevel) {
              int i;
              CCPPRINT("%u: DNLOAD n=%u, ",ctr,size);
              for (i=3;i<3+size&&i<8;i++) CCPPRINT("%02X ",com[i]);
              CCPPRINT("\n");
            }
          #endif
        }
        break;

      case CC_DNLOAD6: /* Download */
        {
          CCP_BYTE r;
          #ifdef CCP_SEED_KEY
            if (!(ccp.ProtectionStatus&PL_CAL)) {
              ccp.Crm[1] = CRC_ACCESS_DENIED;
              r = 0;
            }
            else
          #endif
          r = ccpWriteMTA(0,6,&com[2]);
          #ifdef CCP_STANDARD
            ccpGetMTA0((CCP_BYTE*)&ccp.Crm[3],(CCP_DWORD*)&ccp.Crm[4]);
          #endif
          if (r==CCP_WRITE_PENDING) return; /* EEPROM write pending */
          if (r==CCP_WRITE_DENIED||r==CCP_WRITE_ERROR) ccp.Crm[1] = CRC_ACCESS_DENIED; /* No write access */
          #ifdef CCP_TESTMODE
            if (gDebugLevel) {
              int i;
              CCPPRINT("%u: DNLOAD6 ",ctr);
              for (i=2;i<8;i++) CCPPRINT("%02X ",com[i]);
              CCPPRINT("\n");
          }
          #endif
        }
        break;

      case CC_UPLOAD: /* Upload */
        {
          #define size com[2]
          ccpReadMTA(0,size,&ccp.Crm[3]);
          #ifdef CCP_TESTMODE
            if (gDebugLevel) {
              int i;
              CCPPRINT("%u: UPLOAD n=%u, ",ctr,size);
              for (i=3;i<3+size;i++) CCPPRINT("%02X ",ccp.Crm[i]);
              CCPPRINT("\n");
            }
          #endif
        }
        break;

      case CC_SHORT_UPLOAD: /* Upload with Address */
        {
          #define size    com[2]
          #define addrExt com[3]
          ccpSetMTA(CCP_INTERNAL_MTA,ccpGetPointer(addrExt,addr));
          ccpReadMTA(CCP_INTERNAL_MTA,size,&ccp.Crm[3]);
          #ifdef CCP_TESTMODE
            if (gDebugLevel) {
              int i;
              CCPPRINT("%u: SHORT_UPLOAD p=%08lX,%u,n=%u, ",ctr,addr,addrExt,size);
              for (i=3;i<3+size&&i<8;i++) CCPPRINT("%02X ",ccp.Crm[i]);
              CCPPRINT("\n");
            }
          #endif
        }
        break;