comm_i2cs.c

PIC Kit serial source code.

      }
      
      //----------------------
      //--- MODE: 1
      //----------------------
      else if(COMM_CB_I2CS_MODE_REG == 1)
      {
         if(cbuf3.used)
         {
            COMM_I2CS_DATA = cbuf3_get();
            comm_i2cs_data_send();
         }
         else
         {
            COMM_I2CS_READ_DATA_RQ_FLAG = 1;
            if(COMM_CB_I2CS_EVENTEN_DATA_RQ_FLAG)
               comm_post_event(COMM_TAG_I2CS_EVENT_DATA_RQ);
         }
      }
      
      //----------------------
      //--- MODE: 2
      //----------------------
      else
      {
         COMM_I2CS_TEMP_FLAG = 0;
         if(COMM_I2CS_PRO_REG_OK_FLAG)
         {
            if(COMM_I2CS_PRO_REG_RDDIS_FLAG == 0)
            {
               if(COMM_I2CS_PRO_REG_BC)
               {
                  COMM_I2CS_DATA = cbuf3_data[COMM_I2CS_PRO_REG_INDEX];
                  comm_i2cs_data_send();
                  COMM_I2CS_PRO_REG_INDEX++;
                  COMM_I2CS_PRO_REG_BC--;
                  COMM_I2CS_TEMP_FLAG = 1;
               }
            }
            if(COMM_I2CS_PRO_REG_SEQ_FLAG)
               cbuf3_data[COMM_I2CS_PRO_SLAVE_REG_INDEX]++;
         }
         if(COMM_I2CS_TEMP_FLAG == 0)
         {
            COMM_I2CS_DATA = COMM_I2CS_DATA_READ_DEFAULT;
            comm_i2cs_data_send();
         }
      }

      //--- RST '1ST BYTE' FLAG ...
      COMM_I2CS_ADDR_FLAG = 0;
   }
}

//==========================================================
//--- SEND/RETURN DATA TO MASTER
//==========================================================
void comm_i2cs_data_send(void)
{
   SSPBUF = COMM_I2CS_DATA;
   SSPCON1bits.CKP = 1;
   if(COMM_CB_I2CS_EVENTEN_DATA_TX_FLAG)
      comm_post_event_1b(COMM_TAG_I2CS_EVENT_DATA_TX, COMM_I2CS_DATA);
}

//==========================================================
//--- comm_i2cs_postproc()
//
//    post-processing
//    set status error flag
//    set composite error flag
//==========================================================
void comm_i2cs_postproc(void)
{
   
   //---------------------------------------------
   //--- CHECK FOR 'STOP' EVENT
   //---------------------------------------------
   if(COMM_I2CS_XSTARTED_FLAG)
   {
      //--- disable interrupts
      do
      {
         INTCONbits.GIEL = 0; 
      } while(INTCONbits.GIEL);

      //--- STOP bit encountered
      if(SSPSTATbits.P == 1)
      {
         if(COMM_CB_I2CS_EVENTEN_STOP_FLAG)
            comm_post_event(COMM_TAG_I2CS_STOP);
         COMM_I2CS_XSTARTED_FLAG = 0;
      }
   }
   INTCONbits.GIEL = 1;
   
   //---------------------------------------------
   //--- CHECK COMM I/O PINS/STATE
   //---------------------------------------------
   if(COMM_IO_4B_PIN)
      COMM_SB_I2CS_SDA_STATE_FLAG = 1;
   else
      COMM_SB_I2CS_SDA_STATE_FLAG = 0;

   if(COMM_IO_5B_PIN)
      COMM_SB_I2CS_SCK_STATE_FLAG = 1;
   else
      COMM_SB_I2CS_SCK_STATE_FLAG = 0;
   
   /*
   if(SSPCON1bits.CKP)
      COMM_SB_I2CS_SCK_HELD_FLAG = 0;
   else
      COMM_SB_I2CS_SCK_HELD_FLAG = 1;
   */
      
   //---------------------------------------------
   //--- IF READING & DATA AVAIL ... SEED OUTPUT
   //---------------------------------------------
   
   if(COMM_CB_I2CS_MODE_REG == 1)
   {
      if(COMM_I2CS_READ_DATA_RQ_FLAG)
      {
         if(cbuf3.used)
         {
            COMM_I2CS_READ_DATA_RQ_FLAG = 0;
            COMM_I2CS_DATA = cbuf3_get();
            comm_i2cs_data_send();
         }
      }
   }      
   

   //-----------------------------------
   //--- transaction error
   //-----------------------------------
   COMM_4_FLAG = 0;
   if(SSPCON1bits.WCOL)
   {
      COMM_4_FLAG = 1;
      SSPCON1bits.WCOL = 0;
      COMM_SB_I2CS_WCOL_FLAG = 1;
   }
   if(SSPCON1bits.SSPOV)
   {
      COMM_4_FLAG = 1;
      SSPCON1bits.SSPOV = 0;
      COMM_SB_I2CS_SSPOV_FLAG = 1;
   }
/*
   if(COMM_4_FLAG)
   {
      if(COMM_CB_I2CS_EVENT_XACT_ERR_FLAG)
      {
         comm_post_event_1b(COMM_TAG_I2CS_XACT_ERR, COMM_SB_I2CS_ERR_REG);
      }
   }
*/
   
   //-----------------------------------
   //--- composite error
   //-----------------------------------
   if(COMM_SB_I2CS_ERR_REG & COMM_SB_I2CS_ERR_REG_MASK)
   {
      COMM_SB_GEN_ERR_FLAG = 1;
      COMM_SB_I2CS_ERR_FLAG = 1;
   }

   //-----------------------------------
   //--- change in error status
   //-----------------------------------
   if(COMM_CB_I2CS_EVENTEN_STATUSERR_FLAG)
   {
      if(COMM_SB_I2CS_ERR_REG != exec_status_save_3)
      {
         exec_status_save_3 = COMM_SB_I2CS_ERR_REG;
         comm_post_event_1b(COMM_TAG_I2CS_EVENT_STATUS_ERR, COMM_SB_I2CS_ERR_REG);
      }
   }
}


//==========================================================
//--- comm_i2cs_svc()
//==========================================================
void comm_i2cs_svc(void)
{

   //=======================================================
   //--- SWITCH CONTROLLER STATE
   //=======================================================
   switch(comm_state)
   {

      //====================================================
      case COMM_TAG_I2CS_INIT:
         comm_i2cs_reset();
         comm_state = COMM_STATE_GEN_NEXT;
         break;
         
      //====================================================
      case COMM_TAG_I2CS_SEND_BYTES:
         
         //--- GET BYTE COUNT
         if(not COMM_1_FLAG)
         {
            if(comm_data_get())
            {
               comm_cmnd_count_1 = comm_data;
               COMM_1_FLAG = 1;
               cbuf3_init();
            }
         }
         
         //--- PULL 'READ' DATA
         else
         {
            while(comm_cmnd_count_1)
            {
               if(comm_data_get())
               {
                  cbuf3_put(comm_data);
                  comm_cmnd_count_1--;
               }
               else
               {
                  break;
               }
            }
            if(comm_cmnd_count_1 == 0)
            {
               COMM_I2CS_READ_DATA_RDY_FLAG = 1;
               comm_state = COMM_STATE_GEN_NEXT;
            }
         }
         break;
         
      //====================================================
      case COMM_TAG_I2CS_REGDATA_LOAD:
         
         //-----------------------------
         //--- IF TAG DATA AVAIL., 
         //    DISABLE INTERRUPTS
         //-----------------------------
         if(not COMM_1_FLAG)
         {
            if(cbuf1.used >= 3)
            {
               comm_i2cs_dint();
               if(COMM_1_FLAG)
                  COMM_PROC_LOOP_FLAG = 1;
            }
         }

         //-----------------------------
         //--- FETCH 1st 3 BYTES OF 'TAG DATA'
         //-----------------------------
         else if(not COMM_2_FLAG)
         {
            comm_data_get();
            COMM_I2CS_ADDR = comm_data;         // SLAVE ADDR
            comm_data_get();
            COMM_I2CS_CMND = comm_data;         // REG ID
            comm_data_get();
            COMM_I2CS_TAGDATA_1 = comm_data;    // BYTE COUNT

            //--------------------------
            //--- SEARCH PROFILE FOR SLAVE/REG
            //--------------------------
            COMM_I2CS_TEMP_2_FLAG = 0;
            comm_i2cs_pro_get_slave();
            if(COMM_I2CS_PRO_SLAVE_OK_FLAG)
            {
               comm_i2cs_pro_get_regdef();
               if(COMM_I2CS_PRO_REG_OK_FLAG)
                  COMM_I2CS_TEMP_2_FLAG = 1;
            }
            COMM_2_FLAG = 1;
            COMM_PROC_LOOP_FLAG = 1;
         }

         //-----------------------------
         //--- PROCESS TAG DATA
         //-----------------------------
         else
         {
            //--- FOR ALL 'TAG DATA'
            while(COMM_I2CS_TAGDATA_1)
            {
               if(comm_data_get())
               {
                  //--- IF SLAVE AND REG FOUND
                  if(COMM_I2CS_TEMP_2_FLAG)
                  {
                     //--- IF REG BYTE COUNT != 0
                     if(COMM_I2CS_PRO_REG_BC)
                        cbuf3_data[COMM_I2CS_PRO_REG_INDEX] = comm_data;
                  }
                  COMM_I2CS_PRO_REG_INDEX++;
                  COMM_I2CS_TAGDATA_1--;
                  COMM_I2CS_PRO_REG_BC--;
               }
               else
               {
                  break;
               }
            }

            INTCONbits.GIEL = 1;
            comm_state = COMM_STATE_GEN_NEXT;
         }            
         break;

      //====================================================
      case COMM_TAG_I2CS_REGDATA_RETURN:
         
         //-----------------------------
         //--- IF TAG DATA AVAIL., 
         //    DISABLE INTERRUPTS
         //-----------------------------
         if(not COMM_1_FLAG)
         {
            if(cbuf1.used >= 2)
            {
               comm_i2cs_dint();
               if(COMM_1_FLAG)
                  COMM_PROC_LOOP_FLAG = 1;
            }
         }

         //-----------------------------
         //--- FETCH 'TAG DATA' (2 bytes)
         //-----------------------------
         else if(not COMM_2_FLAG && (cbuf2.unused>=4))
         {
            comm_data_get();
            COMM_I2CS_ADDR = comm_data;         // SLAVE ADDR
            comm_data_get();
            COMM_I2CS_CMND = comm_data;         // REG ID

            //--------------------------
            //--- SEARCH PROFILE FOR SLAVE/REG
            //--------------------------
            COMM_I2CS_TEMP_2_FLAG = 0;
            comm_i2cs_pro_get_slave();
            if(COMM_I2CS_PRO_SLAVE_OK_FLAG)
            {
               comm_i2cs_pro_get_regdef();
               if(COMM_I2CS_PRO_REG_OK_FLAG)
               {
                  COMM_I2CS_TEMP_2_FLAG = 1;
                  cbuf2_put(COMM_TAG_I2CS_REGDATA);
                  cbuf2_put(COMM_I2CS_ADDR);
                  cbuf2_put(COMM_I2CS_CMND);
                  cbuf2_put(COMM_I2CS_PRO_REG_BC);
               }
            }
            COMM_2_FLAG = 1;
            COMM_PROC_LOOP_FLAG = 1;
         }

         //-----------------------------
         //--- RETURN REG DATA
         //-----------------------------
         else
         {
            //--- IF SLAVE/REG FOUND
            if(COMM_I2CS_TEMP_2_FLAG)
            {

               //--- FOR ALL REG DATA
               while(COMM_I2CS_PRO_REG_BC)
               {
                  if(cbuf2.unused)
                  {
                     comm_data = cbuf3_data[COMM_I2CS_PRO_REG_INDEX];
                     cbuf2_put(comm_data);
                     COMM_I2CS_PRO_REG_INDEX++;
                     COMM_I2CS_PRO_REG_BC--;
                  }
                  else
                     break;
               }
            }

            INTCONbits.GIEL = 1;
            comm_state = COMM_STATE_GEN_NEXT;
         }            
         break;
                  
      //====================================================
      default:
         COMM_SB_BAD_CMND_FLAG = 1;
         break;

   } // end SWITCH
   
}

//==========================================================
//--- comm_i2cs_dint()
//
//    disable interrupts if between I2C transactions
//    COMM_1_FLAG == 1  interrupts successfully disabled
//    COMM_1_FLAG == 0  action failed, 
//                      I2C transaction active, ints enabled
//==========================================================
void comm_i2cs_dint(void)
{
   if((SSPSTATbits.P) | ((!SSPSTATbits.P) && (!SSPSTATbits.S)))
   {
      while(INTCONbits.GIEL)
          INTCONbits.GIEL = 0;
      if((SSPSTATbits.P) | ((!SSPSTATbits.P) && (!SSPSTATbits.S)))        
         COMM_1_FLAG = 1;
      else
         INTCONbits.GIEL = 1;
   }
}