comm_i2cm.c

PIC Kit serial source code.

            if(COMM_CB_I2CM_EVENT_STOP_TX_FLAG)
               comm_post_event(COMM_TAG_I2CM_EVENT_STOP);
            comm_led_busy_data();
         }
         else
         {
            if(SSPCON2bits.PEN == 0)
               comm_state = COMM_STATE_GEN_NEXT;
         }
         break;

      //==========================================
      case COMM_TAG_I2CM_RESTART:
         if(not COMM_0_FLAG)
         {
            SSPCON2bits.RSEN = 1;
            COMM_0_FLAG = 1;
            if(COMM_CB_I2CM_EVENT_RESTART_TX_FLAG)
               comm_post_event(COMM_TAG_I2CM_EVENT_RESTART);
            comm_led_busy_data();
         }
         else
         {
            if(SSPCON2bits.RSEN == 0)
               comm_state = COMM_STATE_GEN_NEXT;
         }
         break;

      //==========================================
      case COMM_TAG_I2CM_WRITE_BYTES:

         //--- GET BYTE COUNT
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               comm_cmnd_count_2 = comm_data;
               COMM_0_FLAG = 1;
            }
         }

         //--- CHECK BYTE COUNT
         else if(not COMM_1_FLAG)
         {
            if(not comm_cmnd_count_2)
            {
               comm_state = COMM_STATE_GEN_NEXT;
               break;
            }
            if(SSPSTATbits.BF == 0)
               COMM_1_FLAG = 1;
         }
         
         //--- OUTPUT BYTE (when/if available)
         else if(not COMM_2_FLAG)
         {
            if(comm_data_get())
            {
               comm_cmnd_count_2--;
               COMM_2_FLAG = 1;
               PIR1bits.SSPIF = 0;
               SSPBUF = comm_data;
               if(COMM_CB_I2CM_EVENT_BYTE_TX_FLAG)
                  comm_post_event_1b(COMM_TAG_I2CM_EVENT_BYTE_WRITE, comm_data);
               comm_led_busy_data();
            }
         }

         //--- WAIT FOR ACK/NACK
         else
         {
            if(PIR1bits.SSPIF==1)
            {
               PIR1bits.SSPIF = 0;
               if(SSPCON2bits.ACKSTAT==1)
               {
                  if(COMM_CB_I2CM_EVENT_ACK_RX_FLAG)
                     comm_post_event(COMM_TAG_I2CM_EVENT_NACK_RX);
                  COMM_SB_I2CM_NACK_FLAG = 1;       
               }
               else
               {
                  if(COMM_CB_I2CM_EVENT_ACK_RX_FLAG)
                     comm_post_event(COMM_TAG_I2CM_EVENT_ACK_RX);
               }
               COMM_1_FLAG = 0;
               COMM_2_FLAG = 0;
               comm_led_busy_data();
            }
         }
         break;
         
      //==========================================
      case COMM_TAG_I2CM_READ_BYTES:
      case COMM_TAG_I2CM_READ_BYTES_NLB:
         
         //--- GET BYTE COUNT
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               comm_cmnd_count_2 = comm_data;
               COMM_0_FLAG = 1;
            }
         }

         //--- CHECK BYTE COUNT
         else if(not COMM_1_FLAG)
         {
            if(not comm_cmnd_count_2)
            {
               comm_state = COMM_STATE_GEN_NEXT;
               COMM_PROC_LOOP_FLAG = 1;
               break;
            }
            COMM_1_FLAG = 1;
            SSPCON2bits.RCEN = 1;
         }

         //--- READ BYTE (when/if available)
         else if(not COMM_2_FLAG)
         {
            if(PIR1bits.SSPIF)
            {
               PIR1bits.SSPIF = 0;
               comm_data = SSPBUF;
               if(COMM_CB_I2CM_EVENT_BYTE_RX_FLAG)
                  comm_post_event_1b(COMM_TAG_I2CM_EVENT_BYTE_READ, comm_data);
               comm_post_data();
               comm_cmnd_count_2--;
               COMM_2_FLAG = 1;
               
               SSPCON2bits.ACKDT = 0;
               if((comm_state == COMM_TAG_I2CM_READ_BYTES_NLB) && (not comm_cmnd_count_2))
                  SSPCON2bits.ACKDT = 1;
               SSPCON2bits.ACKEN = 1;
               comm_led_busy_data();
            }
         }
         
         //--- WAIT FOR ACK/NACK EXECUTION
         else
         {
            if(PIR1bits.SSPIF)
            {
               PIR1bits.SSPIF = 0;
               if(COMM_CB_I2CM_EVENT_ACK_TX_FLAG)
               {
                  if(SSPCON2bits.ACKDT)
                     comm_post_event(COMM_TAG_I2CM_EVENT_NACK_TX);
                  else
                     comm_post_event(COMM_TAG_I2CM_EVENT_ACK_TX);
               }

               COMM_1_FLAG = 0;
               COMM_2_FLAG = 0;
               COMM_PROC_LOOP_FLAG = 1;
               comm_led_busy_data();
            }
         }
         break;
         
      //==========================================
      case COMM_TAG_I2CM_READ_BLOCK:
      case COMM_TAG_I2CM_READ_BLOCK_NLB:

         //--- GET BYTE COUNT
         if(PIR1bits.SSPIF)
         {
            //--- process byte
            PIR1bits.SSPIF = 0;
            comm_data = SSPBUF;
            comm_post_data();
            comm_cmnd_count_2 = comm_data;

            //--- issue ACK
            SSPCON2bits.ACKDT = 0;
            SSPCON2bits.ACKEN = 1;

            //--- prep for "READ_BYTES" state
            COMM_0_FLAG = 1;
            COMM_1_FLAG = 1;
            COMM_2_FLAG = 1;
            comm_state = COMM_TAG_I2CM_READ_BYTES;
            if(comm_state == COMM_TAG_I2CM_READ_BLOCK_NLB)
               comm_state = COMM_TAG_I2CM_READ_BYTES_NLB;
            comm_led_busy_data();
         }
         break;
         
      //==========================================
      case COMM_TAG_I2CM_BITRATE:
         if(comm_data_get())
         {
            SSPADD = comm_data;
            COMM_SB_I2CM_BITRATE_REG = SSPADD;
            comm_state = COMM_STATE_GEN_NEXT;
         }
         break;
         

      //====================================================
      case COMM_TAG_I2CM_AUX1_RST:
         I2CM_AUX1_PORT = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX1_SET:
         I2CM_AUX1_PORT = 1;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX1_OUT:
         I2CM_AUX1_TRIS = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX1_IN:
         I2CM_AUX1_TRIS = 1;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX1_WAIT_0:
         if(not I2CM_AUX1_PORT)
         {
            comm_state = COMM_STATE_GEN_NEXT;
            COMM_PROC_LOOP_FLAG = 1;
         }
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX1_WAIT_1:
         if(I2CM_AUX1_PORT)
         {
            comm_state = COMM_STATE_GEN_NEXT;
            COMM_PROC_LOOP_FLAG = 1;
         }
         break;
         

      //====================================================
      case COMM_TAG_I2CM_AUX2_RST:
         I2CM_AUX2_PORT = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX2_SET:
         I2CM_AUX2_PORT = 1;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX2_OUT:
         I2CM_AUX2_TRIS = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX2_IN:
         I2CM_AUX2_TRIS = 1;
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_PROC_LOOP_FLAG = 1;
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX2_WAIT_0:
         if(not I2CM_AUX2_PORT)
         {
            comm_state = COMM_STATE_GEN_NEXT;
            COMM_PROC_LOOP_FLAG = 1;
         }
         break;
         
      //====================================================
      case COMM_TAG_I2CM_AUX2_WAIT_1:
         if(I2CM_AUX2_PORT)
         {
            comm_state = COMM_STATE_GEN_NEXT;
            COMM_PROC_LOOP_FLAG = 1;
         }
         break;
         

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

   } // end SWITCH
   
}