comm_gen.c

PIC Kit serial source code.

      case COMM_TAG_GEN_TIMEOUT_AB1_RST:
         COMM_TIMEOUT_AB1_FLAG = 0;
         comm_state = COMM_STATE_GEN_NEXT;
         break;

      //====================================================
      case COMM_TAG_GEN_MACRO_CLEAR:
         cbuf3_init();
         comm_state = COMM_STATE_GEN_NEXT;
         COMM_MACRO_FLAG = 0;                 // insurance
         break;
                     
      //====================================================
      case COMM_TAG_GEN_MACRO_DATA:
         if(not COMM_0_FLAG)
         {
            if(cbuf1.used)
            {
               comm_cmnd_count_1 = cbuf1_get();
               COMM_0_FLAG = 1;
            }
         }
         else
         {
            while(cbuf1.used)
            {
               if(comm_cmnd_count_1--)
                  comm_post_cbuf3(cbuf1_get());
               else
               {
                  comm_state = COMM_STATE_GEN_NEXT;
                  break;
               }
            }
         }
         break;

      //====================================================
      case COMM_TAG_GEN_MACRO_DATA_START:
         if(cbuf1.used)
         {
            comm_data = cbuf1_get();
            if(comm_data == COMM_TAG_GEN_MACRO_DATA_END)
               comm_state = COMM_STATE_GEN_NEXT;
            else
               comm_post_cbuf3(comm_data);
         }
         break;

      //====================================================
      case COMM_TAG_GEN_MACRO_RUN:
         if(not COMM_0_FLAG)
         {
            if(cbuf1.used)
            {
               comm_macro_count_1_W.lo = 0;
               comm_macro_count_2_W.lo = cbuf1_get();
               COMM_0_FLAG = 1;
            }
         }
         else
         {
            if(cbuf1.used)
            {
               comm_macro_count_1_W.hi = 0;
               comm_macro_count_2_W.hi = cbuf1_get();
               comm_state = COMM_STATE_GEN_MACRO_X_INIT;
               if(comm_macro_count_2_W._word == 0)
                  COMM_SB_MACRO_CONT_FLAG = 1;
               else
                  COMM_SB_MACRO_CONT_FLAG = 0;
               COMM_MACRO_FLAG = 1;
            }
         }
         break;

      //====================================================
      case COMM_TAG_GEN_END_SCRIPT:
         COMM_SB_END_SCRIPT_FLAG = 1;                    // set status bit
         comm_post_event(COMM_TAG_GEN_EVENT_END_SCRIPT); // post "event"
         comm_state = COMM_STATE_GEN_NEXT;               // 
         break;

      //====================================================
      case COMM_TAG_GEN_MARKER_HOST:
         if(comm_data_get())
         {
            comm_post_event_1b(COMM_TAG_GEN_MARKER_DEV, comm_data);
            comm_state = COMM_STATE_GEN_NEXT;
         }
         break;

      //====================================================
      case COMM_TAG_GEN_TIMER_RESET:
         timer0_reg_clear();
         comm_state = COMM_STATE_GEN_NEXT;
         break;

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

}
                     
//==========================================================
//==========================================================
//--- UTILITIES
//==========================================================
//==========================================================

//==========================================================
//--- comm_data_get()
//    fetch byte from script
//
//    retrieve data from circular buffer(s)
//    if MACRO active, fetch byte from CBUF3
//    if MACRO not active, fetch byte from CBUF1
//    return:
//    0: no data available
//    1: data available in global variable: "comm_data"
//==========================================================
TD_BYTE comm_data_get(void)
{
   //--- DISABLE INTERRUPTS
   COMM_GIEL1_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL1_FLAG = 1;
   }

   if(COMM_MACRO_FLAG)
   {
      if(cbuf3.used)
      {
         comm_data = cbuf3_get();
         cbuf3_put(comm_data);  
         comm_cmnd_macro_count_1--;
         if(COMM_GIEL1_FLAG)
            INTCONbits.GIEL = 1;
         return 1;
      }
   }
   else
   {
      if(cbuf1.used)
      {
         comm_data = cbuf1_get();
         if(COMM_GIEL1_FLAG)
            INTCONbits.GIEL = 1;
         return 1;
      }
   }

   if(COMM_GIEL1_FLAG)
      INTCONbits.GIEL = 1;
   return 0;
   

}

//==========================================================
//--- comm_post_cbuf2()
//    post data byte to CBUF2
//
//    if CBUF2 full, set OVF ERROR in STATUS_BLOCK
//==========================================================
void comm_post_cbuf2(TD_BYTE data_byte)
{
//   if(COMM_CB_EVENT_FLAG)
//   {
      if(cbuf2.unused)
      {
         cbuf2_put(data_byte);
      }
      else
      {
         COMM_SB_CBUF2_OVF_FLAG = 1;
      }
//   }
}
      
//==========================================================
//--- comm_post_cbuf2_time()
//    post data byte to CBUF2 & time stamp
//    if CBUF2 full, set OVF ERROR in STATUS_BLOCK
//==========================================================
void comm_post_cbuf2_time(TD_BYTE data_byte)
{
   //--- POST BYTE
   comm_post_cbuf2(data_byte);

   //--- POST TIME
   if(COMM_CB_EVENT_TIME_FLAG)
      comm_post_event_time();
}
      
//==========================================================
//--- comm_post_cbuf3()
//    post data byte to CBUF3
//
//    if CBUF3 full, set OVF ERROR in STATUS_BLOCK
//==========================================================
void comm_post_cbuf3(TD_BYTE data_byte)
{
   if(cbuf3.unused)
   {
      cbuf3_put(data_byte);
   }
   else
   {
      COMM_SB_CBUF3_OVF_FLAG = 1;
   }
}


//==========================================================
//--- comm_led_busy_data()
//    indicate data transaction using LED
//==========================================================
void comm_led_busy_data(void)
{
   if(not EXEC_CB_LED2_DISABLE_DFLT_FLAG)
   {
      led_2_config(COMM_LED_CONFIG_BUSY_DATA);
   }
}


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


//==========================================================
//--- comm_post_event()
//    post "EVENT" marker (and TIME if enabled)
//==========================================================
void comm_post_event(TD_BYTE b0)
{
         
   //--- DISABLE INTERRUPTS
   COMM_GIEL1_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL1_FLAG = 1;
   }

   //--- POST
   if(COMM_CB_EVENT_FLAG)
   {
      comm_post_cbuf2_time(b0);
   }

   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL1_FLAG)
   {
      INTCONbits.GIEL = 1;
   }
}
      
//==========================================================
//--- comm_post_event_1b()
//    post "EVENT" marker w/ 1 "event-dependant" data byte
//==========================================================
void comm_post_event_1b(TD_BYTE b0, TD_BYTE b1)
{

   //--- DISABLE INTERRUPTS
   COMM_GIEL1_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL1_FLAG = 1;
   }


   //--- POST
   if(COMM_CB_EVENT_FLAG)
   {
      comm_post_cbuf2(b0);
      comm_post_cbuf2_time(b1);
   }
   
   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL1_FLAG)
   {
      INTCONbits.GIEL = 1;
   }
}
      
//==========================================================
//--- comm_post_event_2b()
//    post "EVENT" marker w/ 2 "event-dependant" data bytes
//==========================================================
void comm_post_event_2b(TD_BYTE b0, TD_BYTE b1, TD_BYTE b2)
{
   //--- DISABLE INTERRUPTS
   COMM_GIEL1_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL1_FLAG = 1;
   }

   //--- POST
   if(COMM_CB_EVENT_FLAG)
   {
      comm_post_cbuf2(b0);
      comm_post_cbuf2(b1);
      comm_post_cbuf2_time(b2);
   }

   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL1_FLAG)
   {
      INTCONbits.GIEL = 1;
   }
}
      
//==========================================================
//--- comm_post_data()
//    post event: "DATA"
//==========================================================
void comm_post_data(void)
{
   //--- DISABLE INTERRUPTS
   COMM_GIEL1_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL1_FLAG = 1;
   }

   //--- POST
   comm_post_cbuf2(COMM_TAG_GEN_DATA);
   comm_post_cbuf2_time(comm_data);

   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL1_FLAG)
   {
      INTCONbits.GIEL = 1;
   }
}


//==========================================================
//--- comm_post_event_time()
//    post event: "TIME"
//==========================================================
void comm_post_event_time(void)
{
   //--- DISABLE INTERRUPTS
   COMM_GIEL3_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL3_FLAG = 1;
   }

   comm_post_event_time_get();
   comm_post_cbuf2(COMM_TAG_GEN_EVENT_TIME);
   //comm_post_cbuf2(timer0_reg[0]);
   comm_post_cbuf2(timer0_reg[1]);
   comm_post_cbuf2(timer0_reg[2]);

   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL3_FLAG)
      INTCONbits.GIEL = 1;
}

//==========================================================
//--- comm_post_event_time_get()
//    fetch time stamp, post TIMER_OVF event if necessary
//==========================================================
void comm_post_event_time_get(void)
{
   //--- DISABLE INTERRUPTS
   COMM_GIEL2_FLAG = 0;
   if(INTCONbits.GIEL)
   {
      while(INTCONbits.GIEL)
      {
         INTCONbits.GIEL = 0;
      }
      COMM_GIEL2_FLAG = 1;
   }

   //--- TIMER READ - CHECK OVERFLOW
   timer0_reg_read();
   if(TIMER0_REG_OVF_SYNC_FLAG)
   {
      comm_post_cbuf2(COMM_TAG_GEN_EVENT_TIME_ROLLOVER);
      TIMER0_REG_OVF_SYNC_FLAG = 0;
   }

   //--- RE-ENABLE INTERRUPTS
   if(COMM_GIEL2_FLAG)
      INTCONbits.GIEL = 1;
}