Subversion Repositories HomeAutomation

Rev

Rev 1910 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | SVN | RSS feed

  1.  
  2. #include "tst_TestPrgRig.h"
  3.  
  4. uint8_t DUTconnectState=DUTCONNSTATE_IDLE;
  5.  
  6.  
  7. /*
  8. This module will generate a lot of warnings when compiling due to CAN_PRINTF-define in configs, this is ok
  9.  
  10.  
  11.  
  12. */
  13.  
  14.  
  15. #ifdef tst_TestPrgRig_USEEEPROM
  16. #include "tst_TestPrgRig_eeprom.h"
  17. struct eeprom_tst_TestPrgRig EEMEM eeprom_tst_TestPrgRig =
  18. {
  19.     {
  20.         ///TODO: Define initialization values on the EEPROM variables here, this will generate a *.eep file that can be used to store this values to the node, can in future be done with a EEPROM module and the make-scrips. Write the values in the exact same order as the struct is defined in the *.h file.
  21.         0xAB,   // x
  22.         0x1234  // y
  23.     },
  24.     0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
  25. };
  26. #endif
  27.  
  28. void tst_TestPrgRig_Init(void)
  29. {
  30. #ifdef tst_TestPrgRig_USEEEPROM
  31.     if (EEDATA_OK)
  32.     {
  33.       ///TODO: Use stored data to set initial values for the module
  34.       blablaX = eeprom_read_byte(EEDATA.x);
  35.       blablaY = eeprom_read_word(EEDATA.y);
  36.     } else
  37.     {   //The CRC of the EEPROM is not correct, store default values and update CRC
  38.       eeprom_write_byte_crc(EEDATA.x, 0xAB, WITHOUT_CRC);
  39.       eeprom_write_word_crc(EEDATA.y, 0x1234, WITHOUT_CRC);
  40.       EEDATA_UPDATE_CRC;
  41.     }
  42. #endif  
  43.  
  44.     ADC_Init();
  45.     Timer_SetTimeout(tst_TestPrgRig_REPORT_TIMER, tst_TestPrgRig_ReportInterval , TimerTypeFreeRunning, 0);
  46.  
  47.     gpio_set_in(tst_TestPrgRig_CONNPIN);
  48.     gpio_set_pullup(tst_TestPrgRig_CONNPIN);
  49.     gpio_set_out(tst_TestPrgRig_ENABLEPIN);
  50.    
  51.     DUTconnectState=DUTCONNSTATE_IDLE;
  52. }
  53.  
  54. void tst_TestPrgRig_Process(void)
  55. {
  56.     /*uint16_t VccVoltage = ADC_Get(tst_TestPrgRig_5VFEEDBACKAD);
  57.     VccVoltage = (VccVoltage & 0x03ff) * ADC_FACTOR;
  58.     uint16_t Current = ADC_Get(tst_TestPrgRig_CURRFEEDBACKAD)>>1;
  59.     */
  60.     uint8_t sendData = 0;
  61.    
  62.     uint16_t VccVoltage = ADC_Get(tst_TestPrgRig_5VFEEDBACKAD);
  63.     VccVoltage = (VccVoltage & 0x03ff) * ADC_FACTOR;
  64.     VccVoltage = VccVoltage>>1;
  65.     uint16_t Current = ADC_Get(tst_TestPrgRig_CURRFEEDBACKAD)>>1;
  66.  
  67.     if (VccVoltage > 6000)
  68.     {
  69.         DUTconnectState=DUTCONNSTATE_FAILED_VOLT;
  70.         /* disable power on DUT */
  71.         gpio_clr_pin(tst_TestPrgRig_ENABLEPIN);
  72.         sendData = 1;
  73.     }
  74.     else if (Current > 40)
  75.     {
  76.         DUTconnectState=DUTCONNSTATE_FAILED_CURR;
  77.         /* disable power on DUT */
  78.         gpio_clr_pin(tst_TestPrgRig_ENABLEPIN);
  79.         sendData = 1;
  80.     }
  81.  
  82.     if (Timer_Expired(tst_TestPrgRig_REPORT_TIMER)) {
  83.         if (!gpio_get_state(tst_TestPrgRig_CONNPIN) && DUTconnectState==DUTCONNSTATE_IDLE)
  84.         {
  85.             DUTconnectState=DUTCONNSTATE_QUAL1;
  86.         }
  87.         else if (!gpio_get_state(tst_TestPrgRig_CONNPIN) && DUTconnectState==DUTCONNSTATE_QUAL1)
  88.         {
  89.             DUTconnectState=DUTCONNSTATE_QUAL2;
  90.         }
  91.         else if (!gpio_get_state(tst_TestPrgRig_CONNPIN) && DUTconnectState==DUTCONNSTATE_QUAL2)
  92.         {
  93.             DUTconnectState=DUTCONNSTATE_ENABLED;
  94.             /* enable power on DUT */
  95.             gpio_set_pin(tst_TestPrgRig_ENABLEPIN);
  96.         }
  97.         else if (gpio_get_state(tst_TestPrgRig_CONNPIN))
  98.         {
  99.             DUTconnectState=DUTCONNSTATE_IDLE;
  100.             /* disable power on DUT */
  101.             gpio_clr_pin(tst_TestPrgRig_ENABLEPIN);
  102.         }
  103.         sendData = 1;
  104.     }
  105.        
  106.     if (sendData == 1)
  107.     {
  108.         printf("V: %4dmV, C: %2dmA", VccVoltage, Current);
  109.         if (!gpio_get_state(tst_TestPrgRig_CONNPIN))
  110.         {
  111.             printf(", DUT    connected");
  112.         }
  113.         else
  114.         {
  115.             printf(", DUT disconnected");
  116.         }
  117.         switch (DUTconnectState)
  118.         {
  119.             case 0:
  120.                 printf(", S: Idle");
  121.                 break;
  122.             case 1:
  123.                 printf(", S: Q1");
  124.                 break;
  125.             case 2:
  126.                 printf(", S: Q2");
  127.                 break;
  128.             case 3:
  129.                 printf(", S: Enabled");
  130.                 break;
  131.             case 254:
  132.                 printf(", S: Fail Curr");
  133.                 break;
  134.             case 255:
  135.                 printf(", S: Fail Volt");
  136.                 break;
  137.         }
  138.         printf("\n");
  139.        
  140.         /*StdCan_Msg_t txMsg;
  141.         StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_TST);
  142.         StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  143.         txMsg.Header.ModuleType = CAN_MODULE_TYPE_TST_DEBUG;
  144.         txMsg.Header.ModuleId = tst_TestPrgRig_ID;
  145.         txMsg.Header.Command = CAN_MODULE_CMD_DEBUG_TESTERDATA;
  146.         txMsg.Length = 6;
  147.         txMsg.Data[0] = (VccVoltage>>(ADC_SCALE-6+8))&0xff;
  148.         txMsg.Data[1] = (VccVoltage>>(ADC_SCALE-6))&0xff;
  149.         txMsg.Data[2] = (Current>>(8-6))&0xff;
  150.         txMsg.Data[3] = (Current<<(6))&0xff;
  151.         txMsg.Data[4] = (!gpio_get_state(tst_TestPrgRig_CONNPIN))&0xff;
  152.         txMsg.Data[5] = (DUTconnectState)&0xff;
  153.         StdCan_Put(&txMsg);
  154.         */
  155.     }
  156. }
  157.  
  158. void tst_TestPrgRig_HandleMessage(StdCan_Msg_t *rxMsg)
  159. {
  160.     /*if (  StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_xyz && ///TODO: Change this to the actual class type
  161.         StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_FROM_OWNER &&
  162.         rxMsg->Header.ModuleType == CAN_MODULE_TYPE_xyz && ///TODO: Change this to the actual module type
  163.         rxMsg->Header.ModuleId == tst_TestPrgRig_ID)
  164.     {
  165.         switch (rxMsg->Header.Command)
  166.         {
  167.         case CAN_CMD_MODULE_DUMMY:
  168.         ///TODO: Do something dummy
  169.         break;
  170.         }
  171.     }*/
  172. }
  173.  
  174. void tst_TestPrgRig_List(uint8_t ModuleSequenceNumber)
  175. {
  176.     StdCan_Msg_t txMsg;
  177.    
  178.     StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_TST);
  179.     StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  180.     txMsg.Header.ModuleType = CAN_MODULE_TYPE_TST_DEBUG;
  181.     txMsg.Header.ModuleId = tst_TestPrgRig_ID;
  182.     txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_LIST;
  183.     txMsg.Length = 6;
  184.  
  185.     txMsg.Data[0] = NODE_HW_ID_BYTE0;
  186.     txMsg.Data[1] = NODE_HW_ID_BYTE1;
  187.     txMsg.Data[2] = NODE_HW_ID_BYTE2;
  188.     txMsg.Data[3] = NODE_HW_ID_BYTE3;
  189.    
  190.     txMsg.Data[4] = NUMBER_OF_MODULES;
  191.     txMsg.Data[5] = ModuleSequenceNumber;
  192.    
  193.     while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  194. }
  195.