comm_lin.c

PIC Kit serial source code.

               comm_state = COMM_STATE_GEN_NEXT;   // ADVANCE THE SCRIPT
               COMM_PROC_LOOP_FLAG = 1;
            }
            break;
         }

         //---------------------------------------
         //--- 'IMPLIED' SYNC CHARACTER
         //---------------------------------------
         if(comm_state == COMM_TAG_LIN_XMT_FRAME)
            COMM_3_FLAG = 1;

         //-------------------------------------------------
         //--- take advantage of state to xmit data byte(s)
         //-------------------------------------------------
         comm_state = COMM_TAG_LIN_XMT_DATA;
         
      //====================================================
      case COMM_TAG_LIN_XMT_DATA:
      
         //-----------------------------
         //--- GET BYTE COUNT
         //-----------------------------
         if(not COMM_1_FLAG)
         {

            if(TXSTAbits.TRMT == 0)
               break;
               
            if(comm_data_get())                 // script byte available ?
            {
               COMM_1_FLAG = 1;                 //
               comm_cmnd_count_2 = comm_data;   // load byte count
            }
            else
               break;
         }

         //-----------------------------
         //--- CHECK BYTE COUNT
         //-----------------------------
         if(COMM_1_FLAG)
         {
            //------------------------------------
            //--- 'IMPLIED' SYNC CHARACTER 
            //    (NOT PART OF SUPPLIED DATA)
            //------------------------------------

            if(COMM_3_FLAG)
            {
               if(PIR1bits.TXIF)
               {
                  COMM_3_FLAG = 0;
                  comm_data = 0x55;
                  comm_lin_svc_tx();
               }
               else
                  break;
            }

            //------------------------------------
            //--- BYTE COUNT == 0 ??
            //------------------------------------
            else if(comm_cmnd_count_2 == 0)
            {
               if(PIR1bits.TXIF)
               {
                  PIE1bits.TXIE = 0;
                  COMM_LIN_TX_SVC_FLAG = 0;
                  comm_state = COMM_STATE_GEN_NEXT;
               }
               break;
            }

            //------------------------------------
            //--- BYTE COUNT != 0 !
            //------------------------------------
            else
            {
               if(PIR1bits.TXIF)
               {
                  if(comm_data_get())
                  {
                     comm_cmnd_count_2--;
                     comm_led_busy_data();    
                     comm_lin_svc_tx();
                  }
               }
            }
         }
         break;

      //====================================================
      case COMM_TAG_LIN_BAUD_SET:
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               SPBRG = comm_data;
               COMM_SB_LIN_BRG_LO_REG = SPBRG;
               COMM_0_FLAG = 1;
               COMM_PROC_LOOP_FLAG = 1;
            }
         }
         else
         {
            if(comm_data_get())
            {
               SPBRGH = comm_data;
               COMM_SB_LIN_BRG_HI_REG = SPBRGH;
               comm_state = COMM_STATE_GEN_NEXT;
               COMM_PROC_LOOP_FLAG = 1;
            }
         }
         break;

      //====================================================
      case COMM_TAG_LIN_SPROFILE_ID_WRITE:

         //-----------------------------
         //--- FETCH ID
         //-----------------------------
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               COMM_0_FLAG = 1;
               comm_data_3 = comm_data;
               if(comm_lin_sp_iddef_search(comm_data))
                  COMM_4_FLAG = 1;
            }
         }

         //-----------------------------
         //--- FETCH BYTE COUNT
         //-----------------------------
         if(not COMM_1_FLAG)
         {
            if(comm_data_get())
            {
               COMM_1_FLAG = 1;
               comm_cmnd_count_1 = comm_data;
            }
         }

         //-----------------------------
         //--- FETCH BYTES
         //-----------------------------
         if(COMM_1_FLAG)
         {
            while(1)
            {

               //---------------------------------
               //--- TAG BYTE COUNT ZERO
               //---------------------------------
               if(comm_cmnd_count_1 == 0)
               {
                  comm_state = COMM_STATE_GEN_NEXT;
                  COMM_PROC_LOOP_FLAG = 1;
                  break;
               } //--- END: BYTE COUNT ZERO - EXIT ...
               
               //---------------------------------
               //--- TAG BYTE COUNT NOT ZERO
               //---------------------------------
               else
               {
                  if(comm_data_get())
                  {
                     comm_cmnd_count_1--;
                     if(COMM_4_FLAG)
                     {
                        if(COMM_LIN_SP_NBYTES)
                        {
                           cbuf3_data[COMM_LIN_SP_INDEX_DATA] = comm_data;
                           COMM_LIN_SP_NBYTES--;
                           COMM_LIN_SP_INDEX_DATA++;
                        }
                     }
                  }
                  else
                     break;
               } //--- END: BYTE COUNT NOT ZERO
            } //--- END: HARD LOOP FETCHING/PROCESSING BYTES FROM SCRIPT
         } //--- END: FETCHING BYTES FROM SCRIPT
         break;
               

      //====================================================
      case COMM_TAG_LIN_SPROFILE_ID_READ:
         if(comm_data_get())
         {
            comm_post_cbuf2(COMM_TAG_LIN_SPROFILE_ID_DATA);
            comm_post_cbuf2(comm_data);
            if(comm_lin_sp_iddef_search(comm_data))
            {
               comm_post_cbuf2(COMM_LIN_SP_NBYTES);
               while(COMM_LIN_SP_NBYTES--)
               {
                  comm_post_cbuf2(cbuf3_data[COMM_LIN_SP_INDEX_DATA]);
                  COMM_LIN_SP_INDEX_DATA++;
               }
            }
               
            //--- NO ID FOUND IN PROFILE - SEND ZERO BYTES
            else
            {
               comm_post_cbuf2(0x00);
            }
            comm_state = COMM_STATE_GEN_NEXT;
            COMM_PROC_LOOP_FLAG = 1;
         }
         break;

      //====================================================
      case COMM_STATE_GEN_NEXT:
         break;
         
      //====================================================
      default:
         COMM_SB_BAD_CMND_FLAG = 1;
         break;

   } // end SWITCH
   
   //---------------------------------------------
   //--- RE-ENABLE INTERRUPT IF NECESSARY
   //---------------------------------------------
   if(COMM_LIN_GIEL1_FLAG)
      INTCONbits.GIEL = 1;
   //---------------------------------------------

}



//==========================================================
//--- comm_lin_postproc()
//    post processing
//
//    look for status error(s)
//    set appropriate STATUS_BLOCK flags
//    set composite status bit
//==========================================================
void comm_lin_postproc(void)
{
   TD_BYTE  temp1;
   
   //-----------------------------------
   //--- SET 'ERROR' FLAG(s)
   //-----------------------------------
   if(COMM_LIN_FERR_FLAG)
   {
      COMM_SB_LIN_STAT_FERR_FLAG = 1;
   }
   COMM_LIN_FERR_FLAG = 0;
   
   if(COMM_LIN_OERR_FLAG || RCSTAbits.OERR)
   {
      COMM_SB_LIN_STAT_OERR_FLAG = 1;
      RCSTAbits.CREN = 0;
      comm_data_2 = RCREG;
      RCSTAbits.CREN = 1;
   }
   COMM_LIN_OERR_FLAG = 0;

   if(COMM_LIN_ABERR_FLAG)
      COMM_SB_LIN_STAT_ABAUDERR_FLAG = 1;
   COMM_LIN_ABERR_FLAG = 0;
   
   //-----------------------------------
   //--- SAVE CURRENT BAUD
   //-----------------------------------
   COMM_SB_LIN_BRG_LO_REG = SPBRG;
   COMM_SB_LIN_BRG_HI_REG = SPBRGH;

   //-----------------------------------
   //--- FLASH 'DATA' LED
   //-----------------------------------
   if(COMM_LIN_DATA_FLAG)
   {
      comm_led_busy_data();
      COMM_LIN_DATA_FLAG = 0;
   }
   
   //-----------------------------------
   //--- transaction error
   //-----------------------------------
   //--- FERR & OERR set in data receive module
   if(LIN_AFAULT_PORT==0)
   {
#ifndef __DEBUG_LIN_AUX2
      COMM_SB_LIN_STAT_AFAULT_FLAG = 1;
#endif
   }

   //-----------------------------------
   //--- composite error
   //-----------------------------------
   if(COMM_SB_LIN_STAT_ERR_REG & COMM_SB_LIN_STAT_ERR_REG_MASK)
   {
      Nop();
      COMM_SB_LIN_STAT_ERR_FLAG = 1;

   }
   
   //-----------------------------------
   //--- if error status change - post it ...
   //-----------------------------------
   /*
   if(COMM_SB_LIN_STAT_ERR_REG != exec_status_save_2)
   {
      Nop();
      exec_status_save_2 = COMM_SB_LIN_STAT_ERR_REG;
      comm_post_event_1b(COMM_TAG_LIN_EVENT_STAT_ERR, COMM_SB_LIN_STAT_ERR_REG);
   }
   */
   
   //-----------------------------------
   //--- ACTIVE STATUS
   //-----------------------------------

}


//==========================================================
//--- SLAVE PROFILE UTILITIES
//==========================================================

//==========================================================
//--- comm_lin_sp_iddef_search()
//==========================================================
//    search slave profile for given id definition
//    if found:
//       - IDENTIFIER info loaded in global registers
//       - return "1"
//    if not found:
//       - return "0"
//==========================================================
TD_BYTE comm_lin_sp_iddef_search(TD_BYTE id)
{
//   id &= 0x3F;
   COMM_LIN_SP_INDEX = 1;   
   while(comm_lin_sp_iddef_next())
   {
      if(COMM_LIN_SP_ID == id)
         return(1);
   }
   return(0);
}

//==========================================================
//--- comm_lin_sp_iddef_next()
//==========================================================
//    examine slave profile at the current cbuf3 index
//    if not an ID DEF
//       - return "0"
//    if it is an ID DEF
//       - load the registers with contents of ID DEF
//       - advance the index to next ID DEF
//       - return "1"
//==========================================================
TD_BYTE comm_lin_sp_iddef_next(void)
{
   TD_BYTE i;

   i = cbuf3_data[COMM_LIN_SP_INDEX]; 
   if(i & 0x80)
   {
      COMM_LIN_SP_IDDEF = i; 
      COMM_LIN_SP_NBYTES = i & 0x0F;
      COMM_LIN_SP_INDEX++;
      COMM_LIN_SP_ID = cbuf3_data[COMM_LIN_SP_INDEX];
      COMM_LIN_SP_INDEX_DATA = ++COMM_LIN_SP_INDEX;
      COMM_LIN_SP_INDEX += COMM_LIN_SP_NBYTES;
      return(1);
   }
   return(0);
}


//==========================================================
//--- comm_lin_rx_isr()
//==========================================================
//    IN ORDER OF PRIORITY, LOOK FOR:
//    1. BREAK
//    2. AUTOBAUD FINISH
//    3. DATA
//==========================================================
void comm_lin_rx_isr(void)
{
   TD_BYTE i;
   
   //---------------------------------------------
   //--- SAVE ERROR FLAG(s), FETCH BYTE
   //---------------------------------------------
   if(RCSTAbits.FERR == 1)                   // FRAMING ERROR ?
      COMM_LIN_FERR_FLAG = 1;