a4db48a23cfeca5de87515cf8e8f99b96441e50d
[svn42.git] / rf433ctl / rf433ctl.pde
1 #include <avr/io.h>
2 #include <avr/interrupt.h>
3 #include <inttypes.h>
4 #include <OneWire.h>
5 #include <DallasTemperature.h>
6
7 //********************************************************************//
8
9 #define RF_DATA_OUT_PIN 13
10 #define IR_MOVEMENT_PIN 9
11 #define ONE_WIRE_PIN 8
12 #define PANIC_BUTTON_PIN 7
13 #define BLUELED_PWM_PIN 6
14 #define BLUELED2_PWM_PIN 10
15 #define PHOTO_ANALOGPIN 0
16 //movement is reported if during IR_SAMPLE_DURATION at least IR_TRESHOLD ir signals are detectd
17 #define IR_SAMPLE_DURATION 15000
18 #define IR_TRESHOLD 10000
19 //duration PanicButton needs to be pressed before status change occurs (i.e. for two PanicButton Reports, the buttons needs to be pressed 1000 cycles, releases 1000 cycles and again pressed 1000 cycles)
20 #define PB_TRESHOLD 1000
21 #define PHOTO_SAMPLE_INTERVAL 4000
22
23 OneWire  onewire(ONE_WIRE_PIN);
24 DallasTemperature dallas_sensors(&onewire);
25 DeviceAddress onShieldTemp = { 0x10, 0xE7, 0x77, 0xD3, 0x01, 0x08, 0x00, 0x3F };
26 #define TEMPC_OFFSET_ARDUINO_GENEREATED_HEAT -4.0
27
28 typedef struct {
29   byte offset;
30   byte state;
31 } rf_bit_t;
32
33 // offset is number of alphas (0.08ms)
34
35 const rf_bit_t zero_bit[] = { {  4, 1 },
36                               { 16, 0 },
37                               { 20, 1 },
38                               { 32, 0 },
39                               {  0, 0 } };
40
41 const rf_bit_t one_bit[] = { { 12, 1 },
42                              { 16, 0 },
43                              { 28, 1 },
44                              { 32, 0 },
45                              {  0, 0 } };
46
47 const rf_bit_t float_bit[] = { {  4, 1 },
48                                { 16, 0 },
49                                { 28, 1 },
50                                { 32, 0 },
51                                {  0, 0 } };
52
53 const rf_bit_t sync_bit[] = { {   4, 1 },
54                               { 128, 0 },
55                               {   0, 0 } };
56
57 typedef enum { ZERO = 0, ONE , FLOAT , SYNC } adbit_t;
58 typedef byte ad_bit_t;
59 #define WORD_LEN 13
60 typedef ad_bit_t word_t[WORD_LEN];
61
62 const rf_bit_t* bit_defs[] = { zero_bit, one_bit, float_bit, sync_bit };
63
64 byte alpha_cnt = 0;
65 byte bit_cnt = 0;
66 byte chunk_cnt = 0;
67 byte word_cnt = 0;
68 const ad_bit_t* current_word;
69 byte volatile frame_finished = 1;
70
71 #define FRAME_LEN 8
72
73 #define A1_ON  0
74 #define A1_OFF 1
75 #define A2_ON  2
76 #define A2_OFF 3
77
78 #define B1_ON  4
79 #define B1_OFF 5
80 #define B2_ON  6
81 #define B2_OFF 7
82
83 #define C1_ON  8
84 #define C1_OFF 9
85 #define C2_ON  10
86 #define C2_OFF 11
87
88 #define D1_ON  12
89 #define D1_OFF 13
90 #define D2_ON  14
91 #define D2_OFF 15
92
93 const word_t words[]  = { 
94 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A1_ON
95 { ZERO,  ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A1_OFF
96 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // A2_ON
97 { ZERO,  ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // A2_OFF
98
99 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B1_ON
100 { FLOAT, ZERO,  FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B1_OFF
101 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // B2_ON
102 { FLOAT, ZERO,  FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // B2_OFF
103
104 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C1_ON
105 { ZERO,  FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C1_OFF
106 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // C2_ON
107 { ZERO,  FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // C2_OFF
108
109 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D1_ON
110 { FLOAT, FLOAT, FLOAT, FLOAT, ZERO,  ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }, // D1_OFF
111 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, FLOAT, SYNC }, // D2_ON
112 { FLOAT, FLOAT, FLOAT, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO, FLOAT, FLOAT, ZERO,  SYNC }  // D2_OFF
113 };
114
115
116 //********************************************************************//
117
118 void start_timer()
119 {
120   // timer 1: 2 ms
121   TCCR1A = 0;                    // prescaler 1:8, WGM = 4 (CTC)
122   TCCR1B = 1<<WGM12 | 1<<CS11;   // 
123   OCR1A = 159;        // (1+159)*8 = 1280 -> 0.08ms @ 16 MHz -> 1*alpha
124 //  OCR1A = 207;        // (1+207)*8 = 1664 -> 0.104ms @ 16 MHz -> 1*alpha
125   TCNT1 = 0;          // reseting timer
126   TIMSK1 = 1<<OCIE1A; // enable Interrupt
127 }
128
129 void stop_timer() // stop the timer
130 {
131   // timer1
132   TCCR1B = 0; // no clock source
133   TIMSK1 = 0; // disable timer interrupt
134 }
135
136 void init_word(const word_t w)
137 {
138   current_word = w;
139   alpha_cnt = 0;
140   chunk_cnt = 0;
141   bit_cnt = 0;
142
143   if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
144     digitalWrite(RF_DATA_OUT_PIN, HIGH);
145   else
146     digitalWrite(RF_DATA_OUT_PIN, LOW);
147
148   start_timer();
149 }
150
151 ISR(TIMER1_COMPA_vect)
152 {
153   alpha_cnt++;
154   if(alpha_cnt < bit_defs[current_word[bit_cnt]][chunk_cnt].offset)
155     return;
156
157   chunk_cnt++;
158   if(bit_defs[current_word[bit_cnt]][chunk_cnt].offset != 0) {
159     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
160       digitalWrite(RF_DATA_OUT_PIN, HIGH);
161     else
162       digitalWrite(RF_DATA_OUT_PIN, LOW);
163     return;
164   }
165   
166   bit_cnt++;
167   if(bit_cnt < WORD_LEN) {
168     alpha_cnt = 0;
169     chunk_cnt = 0;
170     if(bit_defs[current_word[bit_cnt]][chunk_cnt].state)
171       digitalWrite(RF_DATA_OUT_PIN, HIGH);
172     else
173       digitalWrite(RF_DATA_OUT_PIN, LOW);
174     return;
175   }
176   stop_timer();
177   digitalWrite(RF_DATA_OUT_PIN, LOW);
178
179   word_cnt++;
180   if(word_cnt < FRAME_LEN)
181     init_word(current_word);
182
183   frame_finished = 1;
184 }
185
186 //***********//
187
188
189 void send_frame(const word_t w)
190 {
191   word_cnt = 0;
192   frame_finished = 0;
193   init_word(w);
194
195   for(;;)
196     if(frame_finished)
197       break;
198
199   Serial.println("Ok");
200 }
201
202 //********************************************************************//
203
204 void printTemperature(DeviceAddress deviceAddress)
205 {
206   dallas_sensors.requestTemperatures();
207   float tempC = dallas_sensors.getTempC(deviceAddress);
208   Serial.print("Temp C: ");
209   Serial.println(tempC TEMPC_OFFSET_ARDUINO_GENEREATED_HEAT);
210   //Serial.print(" Temp F: ");
211   //Serial.println(DallasTemperature::toFahrenheit(tempC)); // Converts tempC to Fahrenheit
212 }
213
214 //********************************************************************//
215
216 unsigned int light_level_mean_ = 0;
217 unsigned int light_sample_time_ = 0;
218
219 void updateLightLevel(unsigned int pin)
220 {
221   light_sample_time_++;
222   if (light_sample_time_ < PHOTO_SAMPLE_INTERVAL)
223     return;
224   light_sample_time_ = 0;
225   
226   unsigned int value = analogRead(pin);
227   if (value == light_level_mean_)
228     return;
229   
230   unsigned int diff = abs(value - light_level_mean_);
231   if (light_level_mean_ < 6 || diff > 250)
232     light_level_mean_ = value;
233   else
234       light_level_mean_=(unsigned int) ( ((float) light_level_mean_) * 0.98 + ((float)value)*0.02 );
235 }
236
237 void printLightLevel()
238 {
239   Serial.print("Photo: ");
240   Serial.println(light_level_mean_);
241 }
242
243 //********************************************************************//
244
245 unsigned long wm_start_=0;
246 bool wait_millis(unsigned long ms)
247 {
248   if (wm_start_ > 0)
249   {
250     if (millis() < wm_start_ || millis() > wm_start_+ ms)
251     {
252       wm_start_=0;
253       return false;
254     }
255     else
256       return true;
257   }
258   else
259   {
260     wm_start_=millis();
261     return true;
262   }
263 }
264
265 unsigned int flash_led_time_=0;
266 unsigned int flash_led_brightness_=256;
267 unsigned int flash_led_delay_=8;
268 void calculate_led_level(unsigned int pwm_pin)
269 {
270   if (flash_led_time_ == 0)
271     return;
272   if (wait_millis(flash_led_delay_))
273     return;
274   flash_led_time_--;
275   int c = abs(sin(float(flash_led_time_) / 100.0)) * flash_led_brightness_;
276   analogWrite(BLUELED_PWM_PIN,c);
277   analogWrite(BLUELED2_PWM_PIN,c);
278 }
279
280 void flash_led(unsigned int times, unsigned int brightness_divisor, unsigned int delay_divisor)
281 {
282   unsigned int new_flash_led_brightness = 256 / brightness_divisor;
283   unsigned int new_flash_led_delay = 8 / delay_divisor;
284   if (flash_led_time_ == 0 || new_flash_led_brightness > flash_led_brightness_)
285     flash_led_brightness_=new_flash_led_brightness;
286   if (flash_led_time_ == 0 || new_flash_led_delay < flash_led_delay_)
287     flash_led_delay_=new_flash_led_delay;
288   flash_led_time_ += 314*times;
289 }
290
291 //********************************************************************//
292
293 void setup()
294 {
295   pinMode(RF_DATA_OUT_PIN, OUTPUT);
296   digitalWrite(RF_DATA_OUT_PIN, LOW);
297   pinMode(IR_MOVEMENT_PIN, INPUT);      // set pin to input
298   digitalWrite(IR_MOVEMENT_PIN, LOW);  // turn off pullup resistors  
299   pinMode(PANIC_BUTTON_PIN, INPUT);      // set pin to input
300   digitalWrite(PANIC_BUTTON_PIN, HIGH);  // turn on pullup resistors 
301   analogWrite(BLUELED_PWM_PIN,0);
302
303   Serial.begin(9600);
304   
305   onewire.reset();
306   onewire.reset_search();
307   dallas_sensors.begin();
308   //in case we change temp sensor:
309   if (!dallas_sensors.getAddress(onShieldTemp, 0)) 
310     Serial.println("Error: Unable to find address for Device 0"); 
311   dallas_sensors.setResolution(onShieldTemp, 9);  
312 }
313
314 unsigned int ir_time=IR_SAMPLE_DURATION;
315 unsigned int ir_count=0;
316 boolean pb_last_state=0;
317 boolean pb_state=0;
318 boolean pb_postth_state=0;
319 unsigned int pb_time=0;
320
321 void sensorEchoCommand(char command)
322 {
323   Serial.print("Sensor ");
324   Serial.print(command);
325   Serial.print(": ");
326 }
327
328 void loop()
329 {
330   ir_time--;
331   ir_count += (digitalRead(IR_MOVEMENT_PIN) == HIGH);
332
333   if (pb_time < PB_TRESHOLD)
334     pb_time++;
335   pb_state=(digitalRead(PANIC_BUTTON_PIN) == LOW);
336   
337   if (ir_time == 0)
338   {
339     if (ir_count >= IR_TRESHOLD)
340     {
341       flash_led(1,8,1);
342       Serial.println("movement");
343     }
344     ir_time=IR_SAMPLE_DURATION;
345     ir_count=0;
346   }
347   
348   if (pb_state == pb_last_state && pb_time >= PB_TRESHOLD)
349   {
350     if (pb_state && ! pb_postth_state)
351     {   
352       pb_postth_state=1;
353       Serial.println("PanicButton");
354       flash_led(7,1,2);
355     }
356     else if (!pb_state)
357       pb_postth_state=0;
358   }
359   else if (pb_state != pb_last_state)
360   {
361     pb_time=0;
362     pb_last_state=pb_state;
363   }
364   
365   updateLightLevel(PHOTO_ANALOGPIN);
366   calculate_led_level(BLUELED_PWM_PIN);
367   
368   if(Serial.available()) {
369     char command = Serial.read();
370     
371     if(command == 'A')
372       send_frame(words[A1_ON]);
373     else if(command == 'a')
374       send_frame(words[A1_OFF]);
375     else if(command == 'B')
376       send_frame(words[A2_ON]);
377     else if(command == 'b')
378       send_frame(words[A2_OFF]);
379
380     else if(command == 'C')
381       send_frame(words[B1_ON]);
382     else if(command == 'c')
383       send_frame(words[B1_OFF]);
384     else if(command == 'D')
385       send_frame(words[B2_ON]);
386     else if(command == 'd')
387       send_frame(words[B2_OFF]);
388
389     else if(command == 'E')
390       send_frame(words[C1_ON]);
391     else if(command == 'e')
392       send_frame(words[C1_OFF]);
393     else if(command == 'F')
394       send_frame(words[C2_ON]);
395     else if(command == 'f')
396       send_frame(words[C2_OFF]);
397
398     else if(command == 'G')
399       send_frame(words[D1_ON]);
400     else if(command == 'g')
401       send_frame(words[D1_OFF]);
402     else if(command == 'H')
403       send_frame(words[D2_ON]);
404     else if(command == 'h')
405       send_frame(words[D2_OFF]);
406     else if(command == 'T')
407     {
408       sensorEchoCommand(command);
409       printTemperature(onShieldTemp);
410     }
411     else if(command == 'P')
412     {
413       sensorEchoCommand(command);
414       printLightLevel();
415     }
416     else
417       Serial.println("Error: unknown command");
418   }
419 }