Subversion Repositories HomeAutomation

Rev

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