pc_m1.c

SPI主机模式进行串行通信

                  (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sw <
                  ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sw)) {
                    /* recorder is configured to rising edge actual value       */
                    /* greater than threshold last value smaller than threshold */
                    bitSet(ST_RECRUNNING,status);
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                }
                else
                  if ((((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgMode == PCMDRV_REC_TRIGFAL) &&
                    (actual.sw <= ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sw) &&
                    (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sw >
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sw)) {
                      /* recorder is configured to falling edge actual value      */
                      /* smaller than Threshold last value greater than Threshold */
                      bitSet(ST_RECRUNNING,status);
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                        ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                  }
              }
              else
                if(status & ST_REC_READ_PRETRIG)((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd--;
              /* buffer is full */
              if (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd==0) {
                bitClear(ST_RECRUNNING | ST_RECACTIVATED | ST_REC_READ_PRETRIG,status);
                ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd=1;
              }
              /* remember last value  */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sw = actual.sw;
              /* reset recorder time   */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recTime = 0;
          }break;
          case REC_LONG_UNSIGNED: {    /* size=4, unsigned double word  */
              if( (!(status & ST_RECRUNNING)) && (status & ST_REC_READ_PRETRIG) ){
                if ((((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgMode == PCMDRV_REC_TRIGRIS) &&
                  (actual.ud >= ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.ud) &&
                  (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.ud <
                  ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.ud)) {
                    /* recorder is configured to rising edge actual value       */
                    /* greater than threshold last value smaller than threshold */
                    bitSet(ST_RECRUNNING,status);
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                }
                else
                  if ((((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgMode == PCMDRV_REC_TRIGFAL) &&
                    (actual.ud <= ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.ud) &&
                    (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.ud >
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.ud)) {
                      /* recorder is configured to falling edge actual value      */
                      /* smaller than Threshold last value greater than Threshold */
                      bitSet(ST_RECRUNNING,status);
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                        ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                  }
              }
              else
                if(status & ST_REC_READ_PRETRIG)((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd--;
              /* buffer is full */
              if (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd==0) {
                bitClear(ST_RECRUNNING | ST_RECACTIVATED | ST_REC_READ_PRETRIG,status);
                ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd=1;
              }
              /* remember last value  */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.ud = actual.ud;
              /* reset recorder time   */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recTime = 0;
          }break;
          case REC_LONG_SIGNED: {      /* size=4,   signed double word  */
              if( (!(status & ST_RECRUNNING)) && (status & ST_REC_READ_PRETRIG) ) {
                if ((((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgMode == PCMDRV_REC_TRIGRIS) &&
                  (actual.sd >= ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sd) &&
                  (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sd <
                  ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sd)) {
                    /* recorder is configured to rising edge actual value       */
                    /* greater than threshold last value smaller than threshold */
                    bitSet(ST_RECRUNNING,status);
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                }
                else
                  if ((((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgMode == PCMDRV_REC_TRIGFAL) &&
                    (actual.sd <= ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sd) &&
                    (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sd >
                    ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->trgThreshold.sd)) {
                      /* recorder is configured to falling edge actual value      */
                      /* smaller than Threshold last value greater than Threshold */
                      bitSet(ST_RECRUNNING,status);
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd =
                      ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->postTrigger-1;
                  }
              }
              else
                if(status & ST_REC_READ_PRETRIG)((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd--;
              /* buffer is full */
              if (((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd==0) {
                bitClear(ST_RECRUNNING | ST_RECACTIVATED | ST_REC_READ_PRETRIG,status);
                ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recToEnd=1;
              }
              /* remember last value  */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recLastVal.sd = actual.sd;
              /* reset recorder time   */
              ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recTime = 0;
          }break;
        }
      }
      else {
        ((pcmdrv_sRecorder *)(PCMasterComm->p_recorder))->recTime++;
      }
  }
  else {                               /* recorder not activated */
    recPretrigCount = 0;
    bitClear(ST_REC_READ_PRETRIG, status);
  }
}

/*
** ===================================================================
**     Method      :  memCopy (bean PC_Master)
**
**     Description :
**         This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
static UWord16 memCopy(register volatile char unsigned *srcAddr,
                       register volatile unsigned char *destAddr,
                       register volatile char size)
{
  while ((--size) >= 0) {
    *destAddr++ = *srcAddr++;
  }
  return(0);
}

/*
** ===================================================================
**     Method      :  sendBuffer (bean PC_Master)
**
**     Description :
**         This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
inline static void sendBuffer(void)
{
  if (pos <= length) {                 /* is it end of message ? */
    Inhr1_SendChar((PCMasterComm)->p_dataBuff[pos]); /* send one char to SCI */
    if ((PCMasterComm)->p_dataBuff[pos] != '+') { /* current character is not '+' */
      checkSum += (PCMasterComm)->p_dataBuff[pos]; /* accumulate checksum */
      pos++;
    }
    else {                             /* current character is '+' */
      if (status & ST_ST_SENT) {       /* the last sent char was '+' */
        bitClear(ST_ST_SENT,status);
        checkSum += (PCMasterComm)->p_dataBuff[pos]; /* accumulate checksum */
        pos++;
      }
      else {                           /* the last sent byte was not '+' */
        bitSet(ST_ST_SENT,status);
      }
    }
    if ((pos == length) && !(status & ST_CS_ADDED)) { /* the last byte before cs was sent, now add the checksum */
      checkSum = (-checkSum) & 0x00FF; /* compute checksum */
      (PCMasterComm)->p_dataBuff[pos] = (UInt8)checkSum;
      bitSet(ST_CS_ADDED,status);      /* set flag */
    }
  }
  else {                               /* end of transmitting */
    bitClear(ST_SENDING | ST_CS_ADDED,status); /* reset transmitter (switch to receiving mode) */
    SCItxEmptyIsr(INT_DISABLE);        /* disable SCI Tx Empty Interrupt */
    SCIrxFullIsr(INT_ENABLE);          /* enable SCI Rx Full Interrupt */
  }
}

/*
** ===================================================================
**     Method      :  sendResponse (bean PC_Master)
**
**     Description :
**         This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
static void sendResponse(sResponse *resp)
{
  bitSet(ST_SENDING,status);           /* set flag */
  (PCMasterComm)->p_dataBuff[0] = resp->status; /* status of trasmitted message */
  length=resp->length;                 /* length of message */
  pos=0;                               /* position in the message */

  /* send start of message */
  inChar = '+';
  SCIwrite(inChar);                    /* send start character */

  SCIrxFullIsr(INT_DISABLE);           /* disable SCI Rx Full Interrupt */
  SCItxEmptyIsr(INT_ENABLE);           /* enable SCI Tx Empty Interrupt */
  checkSum = 0;                        /* reset checksum */
}

/*
** ===================================================================
**     Method      :  messageDecode (bean PC_Master)
**
**     Description :
**         This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
static void messageDecode(void)
{
  unsigned char *varaddr;
  #ifndef PCMDRV_INCLUDE_CMD_GETINFOBRIEF
  unsigned char cnt;
  #endif

  switch(PCMasterComm->p_dataBuff[0]) {
  /* -------------------------
  special format commands
  ------------------------- */
    case PCMDRV_CMD_READVAR8EX: {      /* read 8-bit variable */
        /* read address */
        memCopy(((sReadVarEx *)(PCMasterComm->p_dataBuff))->addrByte,
          (unsigned char *)&varaddr, POINT32_LEN);
        /* read data */
        memCopy(varaddr, ((sReturnData *)(PCMasterComm->p_dataBuff))->data, BYTE_LEN);
        respPrepare(PCMDRV_STC_OK, 2); /* OK */
    }break;
    case PCMDRV_CMD_READVAR16EX: {     /* read 16-bit variable */
        /* read address */
        memCopy(((sReadVarEx *)(PCMasterComm->p_dataBuff))->addrByte,
          (unsigned char *)&varaddr, POINT32_LEN);
        /* read data */
        memCopy(varaddr, ((sReturnData *)(PCMasterComm->p_dataBuff))->data, WORD_LEN);
        respPrepare(PCMDRV_STC_OK, 3); /* OK */
    }break;
    case PCMDRV_CMD_READVAR32EX: {     /* read 32-bit variable */
        /* read address */
        memCopy(((sReadVarEx *)(PCMasterComm->p_dataBuff))->addrByte,
          (unsigned char *)&varaddr, POINT32_LEN);
        /* read data */
        memCopy(varaddr, ((sReturnData *)(PCMasterComm->p_dataBuff))->data, LONG_LEN);
        respPrepare(PCMDRV_STC_OK, 5); /* OK */
    }break;
    #ifdef PCMDRV_INCLUDE_CMD_SCOPE
    case PCMDRV_CMD_READSCOPE: {       /* read scope variables */
        unsigned char i, cnt, index = 0;
        /* scope not configured */
        if (((pcmdrv_sScope *)(PCMasterComm->p_scope))->varCnt==0) {
          respPrepare(PCMDRV_STC_NOTINIT,1); /* scope not initialized */
        }
        else {                         /* scope configured */
          /* read number of variables */
          cnt = ((pcmdrv_sScope *)(PCMasterComm->p_scope))->varCnt;
          for (i=0; i < cnt; i++) {
            /* read size of variable */
            length = ((pcmdrv_sScope *)(PCMasterComm->p_scope))->varDef[i].varSize;
            /* read address of variable */
            memCopy( ((pcmdrv_sScope *)(PCMasterComm->p_scope))->varDef[i].addrByte,
              (unsigned char *)&varaddr, POINT32_LEN);
            /* copy data into the input/output buffer */
            memCopy( varaddr, (unsigned char *)&((sReturnData *)
            (PCMasterComm->p_dataBuff))->data[index], (Int8) length);
            index += length;
          }
          respPrepare(PCMDRV_STC_OK, (UInt8)(index +1)); /* OK */
        }
    }break;
    #endif
    #ifdef PCMDRV_INCLUDE_CMD_APPCMD
    case PCMDRV_CMD_GETAPPCMDSTS: {    /* get user application command call status */
        /* buffer is not initialized (zero length) */
        if (PCMasterComm->appCmdSize == 0) {
          respPrepare(PCMDRV_STC_INVCMD,1); /* invalid command */
          return;