Subversion Repositories HomeAutomation

Rev

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

  1.  
  2. #include "act_softPWM.h"
  3.  
  4. #if (act_softPWM_PIN_0_INVERT == 0)
  5.     #define set_pin_0_below_trigger gpio_set_pin(act_softPWM_PIN_0)
  6.     #define set_pin_0_above_trigger gpio_clr_pin(act_softPWM_PIN_0)
  7. #else
  8.     #define set_pin_0_below_trigger gpio_set_pin(act_softPWM_PIN_0)
  9.     #define set_pin_0_above_trigger gpio_clr_pin(act_softPWM_PIN_0)
  10. #endif
  11.  
  12. #if (act_softPWM_PIN_1_INVERT == 0)
  13.     #define set_pin_1_below_trigger gpio_set_pin(act_softPWM_PIN_1)
  14.     #define set_pin_1_above_trigger gpio_clr_pin(act_softPWM_PIN_1)
  15. #else
  16.     #define set_pin_1_below_trigger gpio_set_pin(act_softPWM_PIN_1)
  17.     #define set_pin_1_above_trigger gpio_clr_pin(act_softPWM_PIN_1)
  18. #endif
  19.  
  20. #if (act_softPWM_PIN_2_INVERT == 0)
  21.     #define set_pin_2_below_trigger gpio_set_pin(act_softPWM_PIN_2)
  22.     #define set_pin_2_above_trigger gpio_clr_pin(act_softPWM_PIN_2)
  23. #else
  24.     #define set_pin_2_below_trigger gpio_set_pin(act_softPWM_PIN_2)
  25.     #define set_pin_2_above_trigger gpio_clr_pin(act_softPWM_PIN_2)
  26. #endif
  27.  
  28. #if (act_softPWM_PIN_3_INVERT == 0)
  29.     #define set_pin_3_below_trigger gpio_set_pin(act_softPWM_PIN_3)
  30.     #define set_pin_3_above_trigger gpio_clr_pin(act_softPWM_PIN_3)
  31. #else
  32.     #define set_pin_3_below_trigger gpio_set_pin(act_softPWM_PIN_3)
  33.     #define set_pin_3_above_trigger gpio_clr_pin(act_softPWM_PIN_3)
  34. #endif
  35.  
  36. #if (act_softPWM_PIN_4_INVERT == 0)
  37.     #define set_pin_4_below_trigger gpio_set_pin(act_softPWM_PIN_4)
  38.     #define set_pin_4_above_trigger gpio_clr_pin(act_softPWM_PIN_4)
  39. #else
  40.     #define set_pin_4_below_trigger gpio_set_pin(act_softPWM_PIN_4)
  41.     #define set_pin_4_above_trigger gpio_clr_pin(act_softPWM_PIN_4)
  42. #endif
  43.  
  44. #if (act_softPWM_PIN_5_INVERT == 0)
  45.     #define set_pin_5_below_trigger gpio_set_pin(act_softPWM_PIN_5)
  46.     #define set_pin_5_above_trigger gpio_clr_pin(act_softPWM_PIN_5)
  47. #else
  48.     #define set_pin_5_below_trigger gpio_set_pin(act_softPWM_PIN_5)
  49.     #define set_pin_5_above_trigger gpio_clr_pin(act_softPWM_PIN_5)
  50. #endif
  51.  
  52. #if (act_softPWM_PIN_6_INVERT == 0)
  53.     #define set_pin_6_below_trigger gpio_set_pin(act_softPWM_PIN_6)
  54.     #define set_pin_6_above_trigger gpio_clr_pin(act_softPWM_PIN_6)
  55. #else
  56.     #define set_pin_6_below_trigger gpio_set_pin(act_softPWM_PIN_6)
  57.     #define set_pin_6_above_trigger gpio_clr_pin(act_softPWM_PIN_6)
  58. #endif
  59.  
  60. #if (act_softPWM_PIN_7_INVERT == 0)
  61.     #define set_pin_7_below_trigger gpio_set_pin(act_softPWM_PIN_7)
  62.     #define set_pin_7_above_trigger gpio_clr_pin(act_softPWM_PIN_7)
  63. #else
  64.     #define set_pin_7_below_trigger gpio_set_pin(act_softPWM_PIN_7)
  65.     #define set_pin_7_above_trigger gpio_clr_pin(act_softPWM_PIN_7)
  66. #endif
  67.  
  68. static uint16_t currentTimer = 0;
  69. static uint16_t maxTimer = 10;
  70. static uint8_t  resolution = 1;
  71. static uint8_t act_softPWM_ReportInterval =0;
  72. static uint8_t currentSendChannelId = 0;
  73.  
  74.  
  75. #ifdef act_softPWM_USEEEPROM
  76. #include "act_softPWM_eeprom.h"
  77. struct eeprom_act_softPWM EEMEM eeprom_act_softPWM =
  78. {
  79.     {
  80.         ///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.
  81.         10000,  // x
  82.         10,
  83.         0x14    //Reportinteval 20 sec.
  84.     },
  85.     0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
  86. };
  87. #endif
  88.  
  89. static uint16_t pwmValue[NUMBEROFCHANNELS];
  90. static uint16_t pwmValueCAN[NUMBEROFCHANNELS];
  91.  
  92. #if act_softPWM_ACTIVATE_AUTOOFF != 0
  93. static uint8_t offCounter[NUMBEROFCHANNELS];
  94. #endif
  95.  
  96. void act_softPWM_Init(void)
  97. {
  98. #ifdef act_softPWM_USEEEPROM
  99.     //if (EEDATA_OK)
  100.     //{
  101.      // ;
  102.     //} else
  103.     //{ //The CRC of the EEPROM is not correct, store default values and update CRC
  104.         eeprom_write_word_crc(EEDATA16.maxTimer, 10000 , WITHOUT_CRC);
  105.         eeprom_write_byte_crc(EEDATA.resolution, 1 , WITHOUT_CRC);
  106.         eeprom_write_byte_crc(EEDATA.ReportInterval, 0x05 , WITHOUT_CRC);
  107.         EEDATA_UPDATE_CRC;
  108.     //}
  109.     act_softPWM_ReportInterval = eeprom_read_byte(EEDATA.ReportInterval);
  110.     maxTimer = eeprom_read_word(EEDATA16.maxTimer);
  111.     resolution = eeprom_read_byte(EEDATA.resolution);
  112.     Timer_SetTimeout(act_softPWM_SEND_TIMER, act_softPWM_ReportInterval*1000 , TimerTypeFreeRunning, 0);
  113. #endif  
  114.     ///TODO: Initialize hardware etc here
  115. uint8_t i;
  116. for (i=0; i < NUMBEROFCHANNELS; i++) {
  117.     pwmValue[i] = 0;
  118.     pwmValueCAN[i] = 0;
  119. }
  120. #ifdef act_softPWM_PIN_0
  121.     gpio_set_out(act_softPWM_PIN_0);
  122.     set_pin_0_below_trigger;
  123. #endif
  124. #ifdef act_softPWM_PIN_1
  125.     gpio_set_out(act_softPWM_PIN_1);
  126.     set_pin_1_below_trigger;
  127. #endif
  128. #ifdef act_softPWM_PIN_2
  129.     gpio_set_out(act_softPWM_PIN_2);
  130.     set_pin_2_below_trigger;
  131. #endif
  132. #ifdef act_softPWM_PIN_3
  133.     gpio_set_out(act_softPWM_PIN_3);
  134.     set_pin_3_below_trigger;
  135. #endif
  136. #ifdef act_softPWM_PIN_4
  137.     gpio_set_out(act_softPWM_PIN_4);
  138.     set_pin_4_below_trigger;
  139. #endif
  140. #ifdef act_softPWM_PIN_5
  141.     gpio_set_out(act_softPWM_PIN_5);
  142.     set_pin_5_below_trigger;
  143. #endif
  144. #ifdef act_softPWM_PIN_6
  145.     gpio_set_out(act_softPWM_PIN_6);
  146.     set_pin_6_below_trigger;
  147. #endif
  148. #ifdef act_softPWM_PIN_7
  149.     gpio_set_out(act_softPWM_PIN_7);
  150.     set_pin_7_below_trigger;
  151. #endif
  152.    
  153.     Timer_SetTimeout(act_softPWM_TIMER, resolution, TimerTypeFreeRunning, NULL);
  154. }
  155.  
  156. void act_softPWM_Process(void)
  157. {
  158.     if (Timer_Expired(act_softPWM_TIMER)) {
  159.         currentTimer++;
  160.         if (currentTimer >= maxTimer) {
  161. //printf("cleard Timer %d\n",pwmValue[0]);
  162.             currentTimer=0;
  163.             #ifdef act_softPWM_PIN_0
  164.                 if (pwmValue[0]!=0) {
  165.                     set_pin_0_below_trigger;
  166.                 }
  167.             #endif
  168.             #ifdef act_softPWM_PIN_1
  169.                 if (pwmValue[1]!=0) {
  170.                     set_pin_1_below_trigger;
  171.                 }
  172.             #endif
  173.             #ifdef act_softPWM_PIN_2
  174.                 if (pwmValue[2]!=0) {
  175.                     set_pin_2_below_trigger;
  176.                 }
  177.             #endif
  178.             #ifdef act_softPWM_PIN_3
  179.                 if (pwmValue[3]!=0) {
  180.                     set_pin_3_below_trigger;
  181.                 }
  182.             #endif
  183.             #ifdef act_softPWM_PIN_4
  184.                 if (pwmValue[4]!=0) {
  185.                     set_pin_4_below_trigger;
  186.                 }
  187.             #endif
  188.             #ifdef act_softPWM_PIN_5
  189.                 if (pwmValue[5]!=0) {
  190.                     set_pin_5_below_trigger;
  191.                 }
  192.             #endif
  193.             #ifdef act_softPWM_PIN_6
  194.                 if (pwmValue[6]!=0) {
  195.                     set_pin_6_below_trigger;
  196.                 }
  197.             #endif
  198.             #ifdef act_softPWM_PIN_7
  199.                 if (pwmValue[7]!=0) {
  200.                     set_pin_7_below_trigger;
  201.                 }
  202.             #endif
  203.         }
  204.         #ifdef act_softPWM_PIN_0
  205.         if (currentTimer >= pwmValue[0] && gpio_get_state(act_softPWM_PIN_0) != 0) {
  206.             set_pin_0_above_trigger;
  207.         }
  208.         #endif
  209.         #ifdef act_softPWM_PIN_1
  210.         if (currentTimer >= pwmValue[1] && gpio_get_state(act_softPWM_PIN_1) != 0) {
  211.             set_pin_1_above_trigger;
  212.         }
  213.         #endif
  214.         #ifdef act_softPWM_PIN_2
  215.         if (currentTimer >= pwmValue[2] && gpio_get_state(act_softPWM_PIN_2) != 0) {
  216.             set_pin_2_above_trigger;
  217.         }
  218.         #endif
  219.         #ifdef act_softPWM_PIN_3
  220.         if (currentTimer >= pwmValue[3] && gpio_get_state(act_softPWM_PIN_3) != 0) {
  221.             set_pin_3_above_trigger;
  222.         }
  223.         #endif
  224.         #ifdef act_softPWM_PIN_4
  225.         if (currentTimer >= pwmValue[4] && gpio_get_state(act_softPWM_PIN_4) != 0) {
  226.             set_pin_4_above_trigger;
  227.         }
  228.         #endif
  229.         #ifdef act_softPWM_PIN_5
  230.         if (currentTimer >= pwmValue[5] && gpio_get_state(act_softPWM_PIN_5) != 0) {
  231.             set_pin_5_above_trigger;
  232.         }
  233.         #endif
  234.         #ifdef act_softPWM_PIN_6
  235.         if (currentTimer >= pwmValue[6] && gpio_get_state(act_softPWM_PIN_6) != 0) {
  236.             set_pin_6_above_trigger;
  237.         }
  238.         #endif
  239.         #ifdef act_softPWM_PIN_7
  240.         if (currentTimer >= pwmValue[7] && gpio_get_state(act_softPWM_PIN_7) != 0) {
  241.             set_pin_7_above_trigger;
  242.         }
  243.         #endif
  244.     }
  245.     if (Timer_Expired(act_softPWM_SEND_TIMER)) {
  246. //printf("sending...\n");
  247.         while(1)
  248.         {
  249.             if (0
  250.                 #ifdef act_softPWM_PIN_0
  251.                 || currentSendChannelId == 0
  252.                 #endif
  253.                 #ifdef act_softPWM_PIN_1
  254.                 || currentSendChannelId == 1
  255.                 #endif
  256.                 #ifdef act_softPWM_PIN_2
  257.                 || currentSendChannelId == 2
  258.                 #endif
  259.                 #ifdef act_softPWM_PIN_3
  260.                 || currentSendChannelId == 3
  261.                 #endif
  262.                 #ifdef act_softPWM_PIN_4
  263.                 || currentSendChannelId == 4
  264.                 #endif
  265.                 #ifdef act_softPWM_PIN_5
  266.                 || currentSendChannelId == 5
  267.                 #endif
  268.                 #ifdef act_softPWM_PIN_6
  269.                 || currentSendChannelId == 6
  270.                 #endif
  271.                 #ifdef act_softPWM_PIN_7
  272.                 || currentSendChannelId == 7
  273.                 #endif
  274.             ) {
  275.                 break;
  276.             }
  277.             currentSendChannelId++;
  278.             if (currentSendChannelId >= NUMBEROFCHANNELS)
  279.                 currentSendChannelId=0;
  280.         }
  281. //printf(" %d\n",currentSendChannelId);
  282.         StdCan_Msg_t txMsg;
  283.         StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
  284.         StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  285.         txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SOFTPWM;
  286.         txMsg.Header.ModuleId = act_softPWM_ID;
  287.         txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_PWM;
  288.         txMsg.Length = 3;
  289.         txMsg.Data[0] = currentSendChannelId;
  290.         txMsg.Data[1] = (pwmValue[currentSendChannelId]>>8)&0xff;
  291.         txMsg.Data[2] = (pwmValue[currentSendChannelId])&0xff;
  292.         while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  293. //printf("sent pwm2: %d %d\n",pwmValueCAN[currentSendChannelId],currentSendChannelId);
  294. #if act_softPWM_ACTIVATE_AUTOOFF != 0
  295.         offCounter[currentSendChannelId]--;
  296.         if (offCounter[currentSendChannelId] == 0) {
  297.             pwmValue[currentSendChannelId] = 0;
  298.             pwmValueCAN[currentSendChannelId] = 0;
  299.             offCounter[currentSendChannelId] = 1;
  300.         }
  301. #endif
  302.         currentSendChannelId++;
  303.         if (currentSendChannelId >= NUMBEROFCHANNELS)
  304.             currentSendChannelId=0;
  305.     }
  306. }
  307.  
  308.  
  309.  
  310. void act_softPWM_HandleMessage(StdCan_Msg_t *rxMsg)
  311. {
  312.     if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
  313.         StdCan_Ret_direction(rxMsg->Header) == DIRECTIONFLAG_TO_OWNER &&
  314.         rxMsg->Header.ModuleType == CAN_MODULE_TYPE_ACT_SOFTPWM &&
  315.         rxMsg->Header.ModuleId == act_softPWM_ID)
  316.     {
  317.         switch (rxMsg->Header.Command)
  318.         {
  319. //printf("Got can\n");
  320.         case CAN_MODULE_CMD_PHYSICAL_PWM:
  321. //printf("Got pwm value\n");
  322.             if (rxMsg->Length == 3)
  323.             {
  324. //printf("3\n");
  325.                 if (rxMsg->Data[0] < NUMBEROFCHANNELS) {
  326.                     pwmValueCAN[rxMsg->Data[0]] = ((uint16_t)((rxMsg->Data[1]<<8) + rxMsg->Data[2]));
  327.                     if (pwmValueCAN[rxMsg->Data[0]] >= 10000) {
  328.                         pwmValue[rxMsg->Data[0]] = maxTimer+1;
  329.                     } else {
  330.                         pwmValue[rxMsg->Data[0]] = ((uint16_t)((((uint32_t)pwmValueCAN[rxMsg->Data[0]])*(maxTimer))/10000));
  331.                     }
  332.                     rxMsg->Data[1] = (uint8_t)(0x00ff & (pwmValueCAN[rxMsg->Data[0]]>>8));
  333.                     rxMsg->Data[2] = (uint8_t)(0x00ff & pwmValueCAN[rxMsg->Data[0]]);
  334.                     StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
  335.                     rxMsg->Length = 3;
  336.                     while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
  337. //printf("sent pwm3: %d %d %d\n",pwmValue[rxMsg->Data[0]],maxTimer,resolution);
  338.                     #if act_softPWM_ACTIVATE_AUTOOFF != 0
  339.                     offCounter[rxMsg->Data[0]] = act_softPWM_ACTIVATE_AUTOOFF;
  340.                     #endif
  341.                 }
  342.             } else if (rxMsg->Length == 1) {
  343.                 rxMsg->Data[1] = (uint8_t)(0x00ff & (pwmValueCAN[rxMsg->Data[0]]>>8));
  344.                 rxMsg->Data[2] = (uint8_t)(0x00ff & pwmValueCAN[rxMsg->Data[0]]);
  345.                 StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
  346.                 rxMsg->Length = 3;
  347.                 while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
  348.             } else {
  349.                 rxMsg->Data[0] = (8);
  350.                 rxMsg->Data[1] = (uint8_t)(0x00ff & (pwmValueCAN[0]>>8));
  351.                 rxMsg->Data[2] = (uint8_t)(0x00ff & pwmValueCAN[0]);
  352.                 StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
  353.                 rxMsg->Length = 3;
  354.                 while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
  355.             }
  356.             break;
  357.         case CAN_MODULE_CMD_SOFTPWM_CONFIG:
  358.             maxTimer = (((uint16_t)rxMsg->Data[0])<<8) + rxMsg->Data[1];
  359.             resolution = rxMsg->Data[2];
  360.             Timer_SetTimeout(act_softPWM_TIMER, resolution, TimerTypeFreeRunning, NULL);
  361.             eeprom_write_word_crc(EEDATA16.maxTimer, maxTimer , WITHOUT_CRC);
  362.             eeprom_write_byte_crc(EEDATA.resolution, resolution , WITHOUT_CRC);
  363.             EEDATA_UPDATE_CRC;
  364.             StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
  365.             while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
  366.             break;
  367.         case CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL:
  368.             if (rxMsg->Length > 0)
  369.             {
  370.                 act_softPWM_ReportInterval = rxMsg->Data[0];
  371.                 eeprom_write_byte_crc(EEDATA.ReportInterval, act_softPWM_ReportInterval , WITH_CRC);
  372.                 Timer_SetTimeout(act_softPWM_SEND_TIMER, act_softPWM_ReportInterval*1000 , TimerTypeFreeRunning, 0);
  373.             }
  374.  
  375.             StdCan_Msg_t txMsg;
  376.  
  377.             StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
  378.             StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  379.             txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SOFTPWM;
  380.             txMsg.Header.ModuleId = act_softPWM_ID;
  381.             txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL;
  382.             txMsg.Length = 1;
  383.             txMsg.Data[0] = act_softPWM_ReportInterval;
  384.             while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  385.             break;
  386.         }
  387.     }
  388. }
  389.  
  390. void act_softPWM_List(uint8_t ModuleSequenceNumber)
  391. {
  392.     StdCan_Msg_t txMsg;
  393.    
  394.     StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT); ///TODO: Change this to the actual class type
  395.     StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
  396.     txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SOFTPWM; ///TODO: Change this to the actual module type
  397.     txMsg.Header.ModuleId = act_softPWM_ID;
  398.     txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_LIST;
  399.     txMsg.Length = 6;
  400.  
  401.     txMsg.Data[0] = NODE_HW_ID_BYTE0;
  402.     txMsg.Data[1] = NODE_HW_ID_BYTE1;
  403.     txMsg.Data[2] = NODE_HW_ID_BYTE2;
  404.     txMsg.Data[3] = NODE_HW_ID_BYTE3;
  405.    
  406.     txMsg.Data[4] = NUMBER_OF_MODULES;
  407.     txMsg.Data[5] = ModuleSequenceNumber;
  408.    
  409.     while (StdCan_Put(&txMsg) != StdCan_Ret_OK);
  410. }
  411.