comm_gen.c

PIC Kit serial source code.

      //----------------------
      if(COMM_CB_VSRC_ENABLE_FLAG)
      {
         if(COMM_CB_VSRC_VAR_FLAG)
         {
            vsrc_set_var(COMM_CB_VSRC_SETPOINT_REG);
         }
         else
         {
            vsrc_set_on();
         }
      }
      else
      {
         vsrc_set_off();
      }
      
   }
   
   //---------------------------------------------
   //--- if timer done, measure VSRC
   //---------------------------------------------
   if(not COMM_VSRC_TIMER)
   {
      COMM_SB_VSRC_MEAS_REG = vsrc_read(COMM_CB_VSRC_FAULTLEVEL_REG);
      COMM_VSRC_TIMER = COMM_VSRC_MEAS_INTV_TA;
      if(VSRC_FAULT_FLAG)
         COMM_SB_VSRC_FAULT_FLAG = 1;
      else
         COMM_SB_VSRC_FAULT_FLAG = 0;
   }

   //---------------------------------------------
   //--- SET: PULLUP
   //---------------------------------------------
   if(COMM_CB_PULLUP_ENABLE_FLAG)
      COMM_PULLUP_PIN = 0;
   else
      COMM_PULLUP_PIN = 1;      

         
   //---------------------------------------------
   //---------------------------------------------
   if(COMM_SB_MODE_REG == COMM_MODE_IDLE)
      return;

   //---------------------------------------------
   //--- preproc activity
   //---------------------------------------------
   do 
   {
      COMM_PROC_LOOP_FLAG = 0;
   
      //---------------------------------------------
      //--- process 
      //---------------------------------------------
      Nop();
      if(comm_state > COMM_STATE_GEN_MAX)
      {
         Nop();
         switch(COMM_SB_MODE_REG)
         {
            case COMM_MODE_I2CM:
               comm_i2cm_svc();
               break;
            case COMM_MODE_SPI:
            case COMM_MODE_MWIRE_M:
               comm_spi_svc();
               break;
            case COMM_MODE_USART_A:
            case COMM_MODE_USART_SM:
            case COMM_MODE_USART_SS:
               comm_usart_svc();
               break;
            case COMM_MODE_I2CS:
               comm_i2cs_svc();
               break;
            case COMM_MODE_LIN:
               comm_lin_svc();
               break;
            default:
               {}
         }
      }
      else
      {
         comm_gen();
      }
   
   } while(COMM_PROC_LOOP_FLAG);
   
   //---------------------------------------------
   //--- postproc activity
   //---------------------------------------------
   //-----------------------------------
   //--- check EVENT timer for overflow
   //-----------------------------------
   if(COMM_CB_EVENT_TIME_FLAG)
   {
      comm_post_event_time_get();
   }

   //-----------------------------------
   //--- check process timeout AB0
   //-----------------------------------
   if(COMM_TIMEOUT_AB0_FLAG)
   {
      if(not timer0_AB0_W._word)
      {
         COMM_SB_TIMEOUT_AB0_FLAG = 1;
         if(COMM_CB_EVENT_TIMEOUT_AB0_FLAG)
            comm_post_event(COMM_TAG_GEN_EVENT_TIMEOUT_AB0);
         COMM_TIMEOUT_AB0_FLAG = 0;
      }
   }
   
   //-----------------------------------
   //--- check process timeout AB1
   //-----------------------------------
   if(COMM_TIMEOUT_AB1_FLAG)
   {
      if(not timer0_AB1_W._word)
      {
         COMM_SB_TIMEOUT_AB1_FLAG = 1;
         if(COMM_CB_EVENT_TIMEOUT_AB1_FLAG)
            comm_post_event(COMM_TAG_GEN_EVENT_TIMEOUT_AB1);
         COMM_TIMEOUT_AB1_FLAG = 0;
      }
   }
   
   //-----------------------------------
   //--- device postproc
   //-----------------------------------
   if(COMM_SB_MODE_REG == COMM_MODE_I2CM)
      comm_i2cm_postproc();
   switch(COMM_SB_MODE_REG)
   {
      case COMM_MODE_I2CM:
         comm_i2cm_postproc();
         break;
      case COMM_MODE_SPI:
      case COMM_MODE_MWIRE_M:
         comm_spi_postproc();
         break;
      case COMM_MODE_USART_A:
      case COMM_MODE_USART_SM:
      case COMM_MODE_USART_SS:
         comm_usart_postproc();
         break;
      case COMM_MODE_I2CS:
         comm_i2cs_postproc();
         break;
      case COMM_MODE_LIN:
         comm_lin_postproc();
         break;
      default:
         {}
   }

   //-----------------------------------
   //--- set "COMPOSITE" error
   //-----------------------------------
   if(COMM_SB_GEN_ERR_REG & COMM_SB_GEN_ERR_REG_MASK)
   {
      Nop();
      COMM_SB_GEN_ERR_FLAG = 1;
   }

   //-----------------------------------
   //--- change in error status
   //-----------------------------------
   /*
   if(COMM_CB_EVENT_STATUS_ERR_FLAG)
   {
      if(exec_status_B[4]._byte != exec_status_save_1)
      {
         exec_status_save_1 = exec_status_B[4]._byte;
         comm_post_event_1b(COMM_TAG_GEN_STATUS_ERR, exec_status_B[4]._byte);
      }
   }
   */
   
}
      
//==========================================================
//--- comm_gen()
//    process "general" comm controller commands
//==========================================================
void comm_gen(void)
{
   
   //-----------------------------------
   //--- STALL PROCESSING ?
   //-----------------------------------
   if(COMM_SB_BAD_CMND_FLAG)
   {
      comm_state = COMM_STATE_GEN_STALL;
   }
   
   //=======================================================
   //--- SWITCH: COMM CONTROLLER SCRIPT STATE/COMMAND
   //=======================================================
   switch (comm_state)
   {
      //====================================================
      case COMM_STATE_GEN_NEXT:
         comm_flags1_B._byte = 0;
         comm_state = COMM_STATE_GEN_NEXT_;
         //break;

      //====================================================
      case COMM_STATE_GEN_NEXT_:

         //--- MACRO
         if(COMM_MACRO_FLAG)
         {
            if(not comm_cmnd_macro_count_1)
            {
               comm_state = COMM_STATE_GEN_MACRO_X_INIT;
               COMM_PROC_LOOP_FLAG = 1;
               break;
            }
            COMM_SB_MACRO_BUSY_FLAG = 1;
         }
         else
         {
            COMM_SB_MACRO_BUSY_FLAG = 0;
            COMM_SB_MACRO_CONT_FLAG = 0;
         }

         //--- FETCH SCRIPT CMND FROM BUFFER
         if(comm_data_get())
         {
            comm_state = comm_data;
            COMM_PROC_LOOP_FLAG = 1;
            if(comm_state < COMM_TAG_MIN)
            {
               COMM_SB_BAD_CMND_FLAG = 1;
            }
            else
            {
               COMM_SB_BUSY_FLAG = 1;
               if(not EXEC_CB_LED1_DISABLE_DFLT_FLAG)
               {
                  led_1_config(COMM_LED_CONFIG_BUSY_SCRIPT_STR);
               }
            }
         }
         else
         {
            if(COMM_SB_BUSY_FLAG)
            {
               if(not EXEC_CB_LED1_DISABLE_DFLT_FLAG)
                  led_1_config(COMM_LED_CONFIG_BUSY_SCRIPT_END);
               COMM_SB_BUSY_FLAG = 0;
            }
         }
         break;
      
      //====================================================
      case COMM_STATE_GEN_MACRO_X_INIT:

         //---------------------------------------
         //--- CHECK MACRO ABORT
         //---------------------------------------
         if(COMM_CB_MACRO_ABORT_FLAG)
         {
            comm_post_event_2b(\
               COMM_TAG_GEN_EVENT_MACRO_ABORT, \
               comm_macro_count_1_W.lo, \
               comm_macro_count_1_W.hi);
            COMM_MACRO_FLAG = 0;
         }

         //---------------------------------------
         //--- CHECK MACRO LOOP COUNT
         //---------------------------------------
         else if((not COMM_SB_MACRO_CONT_FLAG) && \
            (comm_macro_count_1_W._word == comm_macro_count_2_W._word))
         {
            //--- EVENT MESSAGE
            if(COMM_CB_EVENT_MACRO_DONE_FLAG)
            {
               comm_post_event_2b(\
                  COMM_TAG_GEN_EVENT_MACRO_DONE, \
                  comm_macro_count_1_W.lo, \
                  comm_macro_count_1_W.hi);
            }
            COMM_MACRO_FLAG = 0;
         }
         
         //---------------------------------------
         //--- RE-INIT FOR NEXT MACRO EXEC
         //---------------------------------------
         else
         {
            //--- EVENT MESSAGE
            if(COMM_CB_EVENT_MACRO_LOOP_FLAG)
            {
               comm_post_event_2b( \
                  COMM_TAG_GEN_EVENT_MACRO_LOOP, \
                  comm_macro_count_1_W.lo, \
                  comm_macro_count_1_W.hi);
            }
            comm_macro_count_1_W._word++;
            comm_cmnd_macro_count_1 = cbuf3.used;

            //--- EVENT MESSAGE
            if((COMM_CB_EVENT_MACRO65K_FLAG)&&(comm_macro_count_1_W._word==0))
            {
               comm_post_event(COMM_TAG_GEN_EVENT_MACRO65K);
            }
         }
         
         comm_state = COMM_STATE_GEN_NEXT;
         break;
            
      //====================================================
      case COMM_STATE_GEN_STALL:
         COMM_SB_BUSY_FLAG = 0;
         break;

      //====================================================
      case COMM_TAG_GEN_LED1:
         if(comm_data_get())
         {
            led_1_config(comm_data);
            comm_state = COMM_STATE_GEN_NEXT;
         }
         break;

      //====================================================
      case COMM_TAG_GEN_LED2:
         if(comm_data_get())
         {
            led_2_config(comm_data);
            comm_state = COMM_STATE_GEN_NEXT;
         }
         break;

      //====================================================
      case COMM_TAG_GEN_WAIT_1:
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               timer0_AB2_W.lo = comm_data;
               COMM_0_FLAG = 1;
            }
         }
         else if(not COMM_1_FLAG)
         {
            if(comm_data_get())
            {
               timer0_AB2_W.hi = comm_data;
               COMM_1_FLAG = 1;
            }
         }
         else
         {
            if(timer0_AB2_W._word)
            {
               COMM_SB_WAIT_FLAG = 1;
            }
            else
            {
               comm_state = COMM_STATE_GEN_NEXT;
               COMM_SB_WAIT_FLAG = 0;
            }
         }
         break;

      //====================================================
      case COMM_TAG_GEN_TIMEOUT_AB0_SET:
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               timer0_AB0_W.lo = comm_data;
               COMM_0_FLAG = 1;
            }
         }
         else
         {
            if(comm_data_get())
            {
               timer0_AB0_W.hi = comm_data;
               COMM_TIMEOUT_AB0_FLAG = 1;
               comm_state = COMM_STATE_GEN_NEXT;
               COMM_PROC_LOOP_FLAG = 1;
            }
         }
         break;

      //====================================================
      case COMM_TAG_GEN_TIMEOUT_AB1_SET:
         if(not COMM_0_FLAG)
         {
            if(comm_data_get())
            {
               timer0_AB1_W.lo = comm_data;
               COMM_0_FLAG = 1;
            }
         }
         else
         {
            if(comm_data_get())
            {
               timer0_AB1_W.hi = comm_data;
               COMM_TIMEOUT_AB1_FLAG = 1;
               comm_state = COMM_STATE_GEN_NEXT;
               COMM_PROC_LOOP_FLAG = 1;
            }
         }
         break;

      //====================================================
      case COMM_TAG_GEN_TIMEOUT_AB0_RST:
         COMM_TIMEOUT_AB0_FLAG = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         break;

      //====================================================