Subversion Repositories HomeAutomation

Rev

Rev 1113 | Rev 1178 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed

Rev 1113 Rev 1119
Line 7... Line 7...
7 
{
 7 
{
8 
    {
 8 
    {
9 
        ///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.
9 
        ///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.
10 
        0xABcd, // x
 10 
        0xABcd, // x
11 
        0x1234, // y
 11 
        0x1234, // y
12 
        0x00
 12 
        0x00,
- 
 
 13 
        0x14    //Reportinteval 20 sec.
13 
    },
 14 
    },
14 
    0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
 15 
    0   // crc, must be a correct value, but this will also be handled by the EEPROM module or make scripts
15 
};
 16 
};
16 
#endif
 17 
#endif
17 
 
 18 
 
18 
uint8_t pwmDefaultState,pwmDefaultStartState;
 19 
uint8_t pwmDefaultState,pwmDefaultStartState,act_SlowPWM_ReportInterval;
19 
uint16_t pwmDefaultValue;
 20 
uint16_t pwmDefaultValue;
20 
uint16_t pwmPeriod, pwmValue;
 21 
uint16_t pwmPeriod, pwmValue;
21 
uint8_t pwmStatus;
 22 
uint8_t pwmStatus;
22 
 
 23 
 
23 
#define PWM_LOW 0
 24 
#define PWM_LOW 0
24 
#define PWM_HIGH 1
 25 
#define PWM_HIGH 1
25 
#define PWM_OFF 2
 26 
#define PWM_OFF 2
26 
void updatePWM_callback(uint8_t timer) {
 27 
void updatePWM_callback(uint8_t timer) {
27 
    //pwmValue = DEFAULT_PWM_VALUE;
 28 
    //pwmValue = DEFAULT_PWM_VALUE;
- 
 
 29 
StdCan_Msg_t txMsg;
28 
    if (pwmStatus == PWM_HIGH) { //Pwm output is low
 30 
    if (pwmStatus == PWM_HIGH) { //Pwm output is low
29 
        gpio_clr_pin(PWM_PIN);  //Sets low
 31 
        gpio_clr_pin(PWM_PIN);  //Sets low
30 
        pwmStatus = 1;
 32 
        pwmStatus = PWM_LOW;
31 
        Timer_SetTimeout(act_SlowPWM_TIMER, pwmValue, TimerTypeOneShot, &updatePWM_callback);
 33 
        Timer_SetTimeout(timer, pwmValue, TimerTypeOneShot, &updatePWM_callback);
- 
 
 34 
 
- 
 
 35 
/*
- 
 
 36 
        StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
- 
 
 37 
        StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 38 
        txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SLOWPWM;
- 
 
 39 
        txMsg.Header.ModuleId = act_SlowPWM_ID;
- 
 
 40 
        txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL;
- 
 
 41 
        txMsg.Length = 1;
- 
 
 42 
 
- 
 
 43 
        txMsg.Data[0] = 10;
- 
 
 44 
        StdCan_Put(&txMsg);
32 
       
 45 
        */
33 
    } else if (pwmStatus == PWM_LOW){ //Pwm output is high
 46 
    } else if (pwmStatus == PWM_LOW){ //Pwm output is high
34 
        gpio_set_pin(PWM_PIN);  //Sets high
 47 
        gpio_set_pin(PWM_PIN);  //Sets high
35 
        pwmStatus = 0;
 48 
        pwmStatus = PWM_HIGH;
36 
        Timer_SetTimeout(act_SlowPWM_TIMER, pwmPeriod - pwmValue, TimerTypeOneShot, &updatePWM_callback);
 49 
        Timer_SetTimeout(timer, pwmPeriod - pwmValue, TimerTypeOneShot, &updatePWM_callback);
- 
 
 50 
/*
- 
 
 51 
StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
- 
 
 52 
        StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 53 
        txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SLOWPWM;
- 
 
 54 
        txMsg.Header.ModuleId = act_SlowPWM_ID;
- 
 
 55 
        txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL;
- 
 
 56 
        txMsg.Length = 1;
- 
 
 57 
 
- 
 
 58 
        txMsg.Data[0] = 20;
- 
 
 59 
        StdCan_Put(&txMsg);
37 
    } else  //PWM_OFF
 60 
*/  } else  //PWM_OFF
- 
 
 61 
    {
- 
 
 62 
      if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_LOW)
- 
 
 63 
      {
- 
 
 64 
        gpio_set_out(PWM_PIN);
- 
 
 65 
        gpio_clr_pin(PWM_PIN);
- 
 
 66 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_HIGH)
- 
 
 67 
      {
- 
 
 68 
        gpio_set_out(PWM_PIN);
- 
 
 69 
        gpio_set_pin(PWM_PIN);
- 
 
 70 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_TRISTATE)
38 
    {
 71 
      {
- 
 
 72 
        gpio_set_in(PWM_PIN);
- 
 
 73 
        gpio_clr_pin(PWM_PIN);
- 
 
 74 
      }
- 
 
 75 
    }
- 
 
 76 
}
- 
 
 77 
 
- 
 
 78 
 
- 
 
 79 
void pwmInit(void) {
39 
      if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_LOW)
 80 
    if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_LOW)
40 
      {
 81 
      {
41 
        gpio_set_out(PWM_PIN);
 82 
        gpio_set_out(PWM_PIN);
42 
        gpio_clr_pin(PWM_PIN);
 83 
        gpio_clr_pin(PWM_PIN);
43 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_HIGH)
 84 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_HIGH)
Line 45... Line 86...
45 
        gpio_set_out(PWM_PIN);
 86 
        gpio_set_out(PWM_PIN);
46 
        gpio_set_pin(PWM_PIN);
 87 
        gpio_set_pin(PWM_PIN);
47 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_TRISTATE)
 88 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_TRISTATE)
48 
      {
 89 
      {
49 
        gpio_set_in(PWM_PIN);
 90 
        gpio_set_in(PWM_PIN);
50 
        gpio_clr_pin(PWM_PIN);
 91 
        gpio_clr_pin(PWM_PIN);
51 
      }
 - 
 
52 
    }
 - 
 
53 
}
 - 
 
54 
 
 - 
 
55 
 
 - 
 
56 
void pwmInit(void) {
 - 
 
57 
    if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_LOW)
 - 
 
58 
      {
 - 
 
59 
        gpio_set_out(PWM_PIN);
 - 
 
60 
        gpio_clr_pin(PWM_PIN);
 - 
 
61 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_HIGH)
 - 
 
62 
      {
 - 
 
63 
        gpio_set_out(PWM_PIN);
 - 
 
64 
        gpio_set_pin(PWM_PIN);
 - 
 
65 
      } else if (pwmDefaultState == CAN_MODULE_ENUM_SLOWPWM_CONFIG_DEFAULTSTATE_TRISTATE)
 - 
 
66 
      {
 - 
 
67 
        gpio_set_in(PWM_PIN);
 - 
 
68 
        gpio_clr_pin(PWM_PIN);
 - 
 
69 
      }
 92 
      }
70 
 
 93 
 
71 
    pwmValue = pwmDefaultValue;
 94 
    pwmValue = pwmDefaultValue;
72 
    pwmStatus = PWM_OFF;
 95 
    pwmStatus = PWM_OFF;
73 
    if (pwmDefaultStartState==CAN_MODULE_ENUM_SLOWPWM_CONFIG_STARTUPSTATE_ON) {
 96 
    if (pwmDefaultStartState==CAN_MODULE_ENUM_SLOWPWM_CONFIG_STARTUPSTATE_ON) {
74 
        Timer_SetTimeout(act_SlowPWM_TIMER, pwmValue, TimerTypeOneShot, &updatePWM_callback);
 97 
        Timer_SetTimeout(act_SlowPWM_TIMER, pwmValue, TimerTypeOneShot, &updatePWM_callback);
75 
        pwmStatus = PWM_LOW;
 98 
        pwmStatus = PWM_LOW;
76 
        gpio_set_out(PWM_PIN);
 99 
        gpio_set_out(PWM_PIN);
77 
        gpio_clr_pin(PWM_PIN);
 100 
        gpio_clr_pin(PWM_PIN);
78 
    }
 101 
    }
79 
}
 102 
}
80 
 
 103 
 
81 
void act_SlowPWM_Init(void)
 104 
void act_SlowPWM_Init(void)
82 
{
 105 
{
83 
#ifdef act_SlowPWM_USEEEPROM
 106 
#ifdef act_SlowPWM_USEEEPROM
84 
    if (EEDATA_OK)
 107 
    if (EEDATA_OK)
Line 87... Line 110...
87 
    } else
 110 
    } else
88 
    {   //The CRC of the EEPROM is not correct, store default values and update CRC
 111 
    {   //The CRC of the EEPROM is not correct, store default values and update CRC
89 
        eeprom_write_word_crc(EEDATA16.PwmPeriod, DEFAULT_PWM_PERIOD , WITHOUT_CRC);
 112 
        eeprom_write_word_crc(EEDATA16.PwmPeriod, DEFAULT_PWM_PERIOD , WITHOUT_CRC);
90 
        eeprom_write_word_crc(EEDATA16.defaultPwmValue, DEFAULT_PWM_VALUE , WITHOUT_CRC);
 113 
        eeprom_write_word_crc(EEDATA16.defaultPwmValue, DEFAULT_PWM_VALUE , WITHOUT_CRC);
91 
        eeprom_write_byte_crc(EEDATA.defaultStates, 0xa0 , WITHOUT_CRC);
 114 
        eeprom_write_byte_crc(EEDATA.defaultStates, 0xa0 , WITHOUT_CRC);
- 
 
 115 
        eeprom_write_byte_crc(EEDATA.ReportInterval, 0x14 , WITHOUT_CRC);
92 
        EEDATA_UPDATE_CRC;
 116 
        EEDATA_UPDATE_CRC;
93 
    }
 117 
    }
94 
    pwmDefaultValue = eeprom_read_word(EEDATA16.defaultPwmValue);
 118 
    pwmDefaultValue = eeprom_read_word(EEDATA16.defaultPwmValue);
95 
    pwmPeriod = eeprom_read_word(EEDATA16.PwmPeriod);
 119 
    pwmPeriod = eeprom_read_word(EEDATA16.PwmPeriod);
96 
    pwmDefaultState = (eeprom_read_byte(EEDATA.defaultStates)>>6) & 0x03;
 120 
    pwmDefaultState = (eeprom_read_byte(EEDATA.defaultStates)>>6) & 0x03;
97 
    pwmDefaultStartState = ((eeprom_read_byte(EEDATA.defaultStates)>>5) & 0x01);
 121 
    pwmDefaultStartState = ((eeprom_read_byte(EEDATA.defaultStates)>>5) & 0x01);
- 
 
 122 
    act_SlowPWM_ReportInterval = (eeprom_read_byte(EEDATA.ReportInterval));
- 
 
 123 
    Timer_SetTimeout(act_SlowPWM_SEND_TIMER, act_SlowPWM_ReportInterval*1000 , TimerTypeFreeRunning, 0);
98 
#endif  
 124 
#endif  
99 
    ///TODO: Initialize hardware etc here
 125 
    ///TODO: Initialize hardware etc here
100 
    pwmInit();
 126 
    pwmInit();
101 
}
 127 
}
102 
 
 128 
 
103 
void act_SlowPWM_Process(void)
 129 
void act_SlowPWM_Process(void)
104 
{
 130 
{
105 
    ///TODO: Stuff that needs doing is done here
 131 
    ///TODO: Stuff that needs doing is done here
- 
 
 132 
    if (Timer_Expired(act_SlowPWM_SEND_TIMER)) {
- 
 
 133 
        StdCan_Msg_t txMsg;
- 
 
 134 
        StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
- 
 
 135 
        StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 136 
        txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SLOWPWM;
- 
 
 137 
        txMsg.Header.ModuleId = act_SlowPWM_ID;
- 
 
 138 
        txMsg.Header.Command = CAN_MODULE_CMD_PHYSICAL_SLOWPWM;
- 
 
 139 
        txMsg.Length = 3;
- 
 
 140 
        txMsg.Data[0] = PWMSENSORID;
- 
 
 141 
        txMsg.Data[1] = (pwmValue>>8)&0xff;
- 
 
 142 
        txMsg.Data[2] = (pwmValue)&0xff;
- 
 
 143 
        StdCan_Put(&txMsg);
- 
 
 144 
    }
106 
}
 145 
}
107 
 
 146 
 
108 
void act_SlowPWM_HandleMessage(StdCan_Msg_t *rxMsg)
 147 
void act_SlowPWM_HandleMessage(StdCan_Msg_t *rxMsg)
109 
{
 148 
{
110 
    if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
 149 
    if (    StdCan_Ret_class(rxMsg->Header) == CAN_MODULE_CLASS_ACT &&
Line 120... Line 159...
120 
                if (rxMsg->Length == 3)
 159 
                if (rxMsg->Length == 3)
121 
                {
 160 
                {
122 
                    pwmValue= (rxMsg->Data[1]<<8) + rxMsg->Data[2];
 161 
                    pwmValue= (rxMsg->Data[1]<<8) + rxMsg->Data[2];
123 
                    if (pwmValue > pwmPeriod)
 162 
                    if (pwmValue > pwmPeriod)
124 
                        pwmValue = pwmPeriod;
 163 
                        pwmValue = pwmPeriod;
- 
 
 164 
                    Timer_SetTimeout(act_SlowPWM_TIMER, pwmValue, TimerTypeOneShot, &updatePWM_callback);
- 
 
 165 
                    pwmStatus = PWM_LOW;
- 
 
 166 
                    gpio_set_out(PWM_PIN);
- 
 
 167 
                    gpio_clr_pin(PWM_PIN);
125 
                } else
 168 
                } else
126 
                {  
 169 
                {  
127 
                    rxMsg->Data[1] = (pwmValue>>8)&0xff;
 170 
                    rxMsg->Data[1] = (pwmValue>>8)&0xff;
128 
                    rxMsg->Data[2] = (pwmValue)&0xff;
 171 
                    rxMsg->Data[2] = (pwmValue)&0xff;
129 
                    StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
 172 
                    StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
130 
                    rxMsg->Length = 3;
 173 
                    rxMsg->Length = 3;
Line 151... Line 194...
151 
                rxMsg->Data[4] = eeprom_read_byte(EEDATA.defaultStates);
 194 
                rxMsg->Data[4] = eeprom_read_byte(EEDATA.defaultStates);
152 
                StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
 195 
                StdCan_Set_direction(rxMsg->Header, DIRECTIONFLAG_FROM_OWNER);
153 
                rxMsg->Length = 5;
 196 
                rxMsg->Length = 5;
154 
                while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
 197 
                while (StdCan_Put(rxMsg) != StdCan_Ret_OK);
155 
            }
 198 
            }
- 
 
 199 
        break;
- 
 
 200 
       
- 
 
 201 
        case CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL:
- 
 
 202 
        if (rxMsg->Length > 0)
- 
 
 203 
        {
- 
 
 204 
            act_SlowPWM_ReportInterval = rxMsg->Data[0];
- 
 
 205 
            eeprom_write_byte_crc(EEDATA.ReportInterval, act_SlowPWM_ReportInterval , WITH_CRC);
- 
 
 206 
            Timer_SetTimeout(act_SlowPWM_SEND_TIMER, act_SlowPWM_ReportInterval*1000 , TimerTypeFreeRunning, 0);
- 
 
 207 
        }
- 
 
 208 
 
- 
 
 209 
        StdCan_Msg_t txMsg;
- 
 
 210 
 
- 
 
 211 
        StdCan_Set_class(txMsg.Header, CAN_MODULE_CLASS_ACT);
- 
 
 212 
        StdCan_Set_direction(txMsg.Header, DIRECTIONFLAG_FROM_OWNER);
- 
 
 213 
        txMsg.Header.ModuleType = CAN_MODULE_TYPE_ACT_SLOWPWM;
- 
 
 214 
        txMsg.Header.ModuleId = act_SlowPWM_ID;
- 
 
 215 
        txMsg.Header.Command = CAN_MODULE_CMD_GLOBAL_REPORT_INTERVAL;
- 
 
 216 
        txMsg.Length = 1;
- 
 
 217 
 
- 
 
 218 
        txMsg.Data[0] = act_SlowPWM_ReportInterval;
- 
 
 219 
        StdCan_Put(&txMsg);
156 
        break;
 220 
        break;
157 
        }
 221 
        }
158 
    }
 222 
    }
159 
 
 223 
 
160 
}
 224 
}