source: firmware/FSC/src/FSC.c@ 10110

Last change on this file since 10110 was 10110, checked in by lutz, 12 years ago
two empty lines deleted :-)
File size: 22.9 KB
Line 
1//-----------------------------------------------------------------------------
2#include "typedefs.h"
3#include "application.h"
4#include "spi_master.h"
5#include "ad7719_adc.h"
6#include "atmega_adc.h"
7#include "usart.h"
8#include "macros.h"
9#include "interpol.h"
10#include "w5100_spi_interface.h"
11#include <avr/interrupt.h>
12#include <avr/wdt.h>
13#include <stdlib.h>
14//-----------------------------------------------------------------------------
15// definition of some functions:
16// these function are implemented below the main()
17// here in FSC.c
18//
19// sooner or later, they will be moved into more apropriate files.
20U08 increase_adc (U08 channel);
21U08 increase_ad7719 (U08 channel);
22void Set_V_Muxer (U08 channel);
23void Set_T_Muxer(U08 channel);
24void talk(void);// never used up to now.
25void ad7719_output(U08 channel, U32 data);
26void adc_output(U08 channel, U08 data);
27void adc_output_all();
28void parse(); //doesn't do anything at the moment
29void check_if_measured_all() ;
30// end of function definition:
31//-----------------------------------------------------------------------------
32
33// MAIN WORKFLOW GLOBAL VARIABLES
34 bool verbose;
35 bool heartbeat_enable;
36
37// USART global variables
38 U08 usart_rx_buffer[USART_RX_BUFFER_SIZE];
39 U08 usart_tx_buffer[USART_TX_BUFFER_SIZE];
40 U08 usart_rx_buffer_index = 0;
41 U08 usart_tx_buffer_index = 0;
42 U08 usart_last_char; // last received char
43
44// USART FLAGS
45 bool usart_tx_buffer_overflow = false; // true if usart_tx_buffer was full.
46 bool usart_rx_ready = false; // EOL was received, parser needs to be called
47
48// TIMER global variable
49 volatile U32 local_ms = 0;
50
51// AD7719 global variables
52 #define TEMP_CHANNELS 64
53 #define CHANNEL_BITMAP 8
54 #define AD7719_READINGS_UNTIL_SETTLED 1 // bei3:480ms
55 U32 ad7719_values[TEMP_CHANNELS];
56 U08 ad7719_enables[CHANNEL_BITMAP];
57 U08 ad7719_channels_ready[CHANNEL_BITMAP];
58 U08 ad7719_readings_since_last_muxing = 0;
59 U08 ad7719_current_channel = 0;
60 U32 ad7719_current_reading = 0;
61 bool ad7719_measured_all = false;
62
63// ATMEGA ADC global variables
64 #define V_CHANNELS 40
65 #define I_CHANNELS 40
66 #define H_CHANNELS 4
67 #define V_BITMAP 5
68 #define I_BITMAP 5
69 #define H_BITMAP 1
70 #define ADC_READINGS_UNTIL_SETTLED 1
71 U32 adc_values[V_CHANNELS + I_CHANNELS + H_CHANNELS]; // stores measured voltage in steps of 16mV
72 U08 adc_enables[V_BITMAP + I_BITMAP + H_BITMAP];
73 U08 adc_channels_ready[V_BITMAP + I_BITMAP + H_BITMAP];
74 U08 adc_readings_since_last_muxing = 0;
75 U08 adc_current_channel = 0;
76 U08 adc_current_reading = 0;
77 bool adc_measured_all = false;
78
79//-----------------------------------------------------------------------------
80// M A I N --- M A I N --- M A I N --- M A I N --- M A I N
81//-----------------------------------------------------------------------------
82int main(void)
83{
84 app_init(); // Setup: Watchdog and I/Os
85 usart_init(); // Initialize serial interface
86 spi_init(); // Initialize SPI interface as master
87 ad7719_init(); // Initialize AD7719 ADC as SPI slave
88 atmega_adc_init();
89
90// TIMER2 is used as local clock:
91// configure timer 2
92 TCCR2 = (1<<WGM21); // CTC Modus
93 TCCR2 |= (1<<CS21) | (1<<CS20); // Prescaler 64 --> counts up every 8us
94 OCR2 = 125-1; // --> output compare interrupt occurs every 125 x 8us = 1ms
95 // Compare Interrupt erlauben
96 TIMSK |= (1<<OCIE2);
97
98 // Enable interrupts
99 sei();
100
101for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
102 ad7719_enables[i]=0xFF;
103 ad7719_channels_ready[i]=0;
104 }
105for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
106 adc_enables[i]=0xFF;
107 adc_channels_ready[i]=0;
108}
109 static U08 welcome[]="\n\nwelcome to FACT FSC commandline interface v0.1\nready?";
110 usart_write_str(welcome);
111
112
113//MAIN LOOP
114while (1)
115{
116 if (heartbeat_enable) PORTB ^= (1<<PB3); // toggle Out2_spare --> heartbeat
117//----------------------------------------------------------------------------
118 //IF we need to send away one byte, and ready to send
119
120 if ( (usart_tx_buffer_index > 0) && (UCSRA & (1<<UDRE)) ) {
121 UDR = usart_tx_buffer[0];
122 // THis is shit
123 for (U08 i=0 ; i < USART_TX_BUFFER_SIZE; ++i) {
124 usart_tx_buffer[i] = usart_tx_buffer[i+1];
125 }
126 usart_tx_buffer_index--;
127 }
128//----------------------------------------------------------------------------
129
130 //IF we just received one byte, and there is enough space in the RX_buffer
131 if ( (UCSRA & (1<<RXC)) && (usart_rx_buffer_index < USART_RX_BUFFER_SIZE) ){
132 usart_last_char = UDR;
133 if (usart_last_char == '\n'){ // if EOL was received
134 usart_rx_ready = true;
135 }else {
136 usart_rx_buffer[usart_rx_buffer_index] = usart_last_char;
137 usart_rx_buffer_index++;
138 }
139 // here is still something strange .... better send an enter automatically
140 } else if (UCSRA & (1<<RXC)) { // if there is no scace in the buffer; read anyway.
141 usart_last_char = UDR;
142 usart_rx_buffer_index =0;
143 }
144//----------------------------------------------------------------------------
145
146 //IF USART DOR bit is set, PC is sending data to fast!!!
147 if ( UCSRA & (1<<DOR) ){
148 // flush TX_buffer and write warning message in
149 // maybe even switch off every measurement. ?
150 }
151//----------------------------------------------------------------------------
152
153 //IF TX_BUFFER was overrun.
154 if (usart_tx_buffer_overflow) {
155 // flash TX_buffer and write warning message in
156 // maybe even switch off every measurement. ?
157 //
158 // this should only happen, in verbose mode and with low baudrates.
159 }
160//----------------------------------------------------------------------------
161
162 //IF one command was received.
163 // -It is not allowed to send more than one command between two '\n'
164 if (usart_rx_ready){
165 parse();
166 usart_rx_buffer_index = 0;
167 usart_rx_ready = false;
168 }
169//----------------------------------------------------------------------------
170
171 //IF ATmega internal ADC did finish a conversion --every 200us
172 if ( (ADCSRA & (1<<ADIF)) && !adc_measured_all) {
173 adc_current_reading = ADCH;
174 if (adc_readings_since_last_muxing == ADC_READINGS_UNTIL_SETTLED) {
175 adc_values[adc_current_channel] = adc_current_reading;
176 adc_readings_since_last_muxing=0;
177 // note that this channel is ready, now and
178 adc_output(adc_current_channel, adc_current_reading);
179 // proceed to the next enabled channel.
180 adc_channels_ready[adc_current_channel/8] |= (1<<(adc_current_channel%8));
181 adc_current_channel = increase_adc (adc_current_channel);
182 Set_V_Muxer(adc_current_channel);
183 } else { // the ADC did not settle yet, we discard the reading
184 ++adc_readings_since_last_muxing;
185 // current reading is not used for anything else
186 }
187 }
188//----------------------------------------------------------------------------
189
190 //IF AD7719 ADC just finished a conversion -- every 60ms
191
192 if (AD7719_IS_READY()) {
193 ad7719_current_reading = read_adc(); // --takes at 4MHz SCLK speed about 6us
194 // AD7719 is only read out if settled. saves time.
195 if (ad7719_readings_since_last_muxing == AD7719_READINGS_UNTIL_SETTLED) {
196 ad7719_values[ad7719_current_channel] = ad7719_current_reading;
197 ad7719_readings_since_last_muxing=0;
198 // now prepare the data to be send away via USART.
199 //ad7719_output(ad7719_current_channel, ad7719_current_reading);
200 // note that this channel is ready, now and
201 // proceed to the next enabled channel.
202 ad7719_channels_ready[ad7719_current_channel/8] |= (1<<(ad7719_current_channel%8));
203 ad7719_current_channel = increase_ad7719 (ad7719_current_channel);
204 Set_T_Muxer(ad7719_current_channel);
205 } else { // the AD7719 did not settle yet, we discard the reading
206 ++ad7719_readings_since_last_muxing;
207
208 // current reading is not used for anything else
209 }
210 }
211//----------------------------------------------------------------------------
212 //IF one of the ADC measured all channels, we wanted to know.
213 check_if_measured_all();
214
215 if (ad7719_measured_all && adc_measured_all)
216 adc_output_all();
217
218//----------------------------------------------------------------------------
219/*
220 if (verbose == true)
221 // talk() was just defined so the
222 // code is not at this place ... look down.
223 talk();
224*/
225
226} // end of MAIN LOOP
227//-----------------------------------------------------------------------------
228// E N D E N D E N D E N D E N D E N D E N D
229//-----------------------------------------------------------------------------
230
231
232
233float resistance;
234
235U08 SA_mux_val = 0x00;
236U08 SB_mux_val = 0x00;
237
238//U08 counter = 0;
239U08 Res_or_Volt = 0x00;
240
241
242while (TRUE)
243 {
244
245
246 ++Res_or_Volt;
247 if (Res_or_Volt <= 64){
248
249
250 // if USART data arrives. i.e. data via USB
251 // the usart_rx_ready flag is set TRUE
252 // now process the incoming data which is stored in
253 // U08 usart_rx_buffer[USART_RX_BUFFER_SIZE]
254 // and tell the USART interface, it may receive new data
255 // by setting the usart_rx_ready flag FALSE again
256 ++SA_mux_val;
257 if (Res_or_Volt == 1) SB_mux_val = 16;
258 else if (SA_mux_val == 64) SA_mux_val = 32;
259 else if (SA_mux_val == 16) SA_mux_val = 48;
260 else if (SA_mux_val == 32) SA_mux_val = 0;
261 PORTA = (SA_mux_val & 0x3F);
262
263// usart_write_str((pU08)"SA:");
264 usart_write_U08(SA_mux_val,2);
265 usart_write_str((pU08)" Sensor:");
266 usart_write_U08((SA_mux_val % 8)+1,2);
267 usart_write_str((pU08)" an Temperatur_");
268 switch (SA_mux_val / 8)
269 {
270 case 0: usart_write_str((pU08)"C");
271 break;
272 case 1: usart_write_str((pU08)"D");
273 break;
274 case 2: usart_write_str((pU08)"A");
275 break;
276 case 3: usart_write_str((pU08)"B");
277 break;
278 case 4: usart_write_str((pU08)"G");
279 break;
280 case 5: usart_write_str((pU08)"H");
281 break;
282 case 6: usart_write_str((pU08)"E");
283 break;
284 case 7: usart_write_str((pU08)"F");
285 break;
286 default: usart_write_str((pU08)"alarm!");
287 break;
288 }
289// usart_write_str((pU08)"\n");
290 usart_write_str((pU08)" ");
291
292
293 startconv(0);
294
295
296 while (!AD7719_IS_READY())
297 {
298 // just wait until ADC is redy -- really bad code here!
299 }
300
301 resistance = getresistance();
302 //Start a new A/D Conversion
303 //temp = readandsendtemp();
304 //adcword = getadc();
305
306 //temperature = gettemp();
307 usart_write_str((pU08)"R:");
308 usart_write_float(resistance,3,4);
309 usart_write_str((pU08)"kOhm ");
310
311 //_delay_ms(200);
312
313 startconv(0);
314
315 while (!AD7719_IS_READY())
316 {
317 // just wait until ADC is redy -- really bad code here!
318 }
319 //Start a new A/D Conversion
320 //temp = readandsendtemp();
321 //adcword = getadc();
322 resistance = getresistance();
323 //temperature = gettemp();
324 usart_write_str((pU08)"R:");
325 usart_write_float(resistance,3,4);
326 usart_write_str((pU08)"kOhm ");
327
328//usart_write_str((pU08)"\n");
329switch (SA_mux_val)
330 {
331 case 7: usart_write_str((pU08)"\n\n");
332 break;
333 case 15: usart_write_str((pU08)"\n\n");
334 break;
335 case 23: usart_write_str((pU08)"\n\n");
336 break;
337 case 31: usart_write_str((pU08)"\n\n");
338 break;
339 case 39: usart_write_str((pU08)"\n\n");
340 break;
341 case 47: usart_write_str((pU08)"\n\n");
342 break;
343 case 55: usart_write_str((pU08)"\n\n");
344 break;
345 case 63: usart_write_str((pU08)"\n\n");
346 break;
347 default: usart_write_str((pU08)"\n");
348 break;
349 }
350SB_mux_val = 0;
351}
352else if (Res_or_Volt == 148) Res_or_Volt = 0;
353else {
354
355
356 ++SB_mux_val;
357 if (SB_mux_val == 84) SB_mux_val = 0;
358 else if (SB_mux_val == 74) SB_mux_val = 82;
359 else if (SB_mux_val == 82) SB_mux_val = 72;
360 else if (SB_mux_val == 72) SB_mux_val = 74;
361 else if (SB_mux_val == 48) SB_mux_val = 64;
362 else if (SB_mux_val == 64) SB_mux_val = 32;
363 else if (SB_mux_val == 32) SB_mux_val = 48;
364 PORTC = (SB_mux_val & 0x7F);
365
366
367
368
369usart_write_str((pU08)"8bit-ADC: ");
370
371if (SB_mux_val < 64)
372{
373 switch (SB_mux_val / 16)
374 {
375 case 0: usart_write_str((pU08)"voltage_A: ");
376 break;
377 case 1: usart_write_str((pU08)"voltage_B: ");
378 break;
379 case 2: usart_write_str((pU08)"voltage_D: ");
380 break;
381 case 3: usart_write_str((pU08)"voltage_C: ");
382 break;
383 }
384
385 if (SB_mux_val % 2 == 0) {
386 usart_write_str((pU08)"U");
387 usart_write_U08( (SB_mux_val%16)/2 , 1 );
388 } else {
389 usart_write_str((pU08)"I");
390 usart_write_U08( ((SB_mux_val%16)-1)/2 , 1 );
391 }
392
393
394} else {
395
396
397 if (SB_mux_val < 72) {
398 usart_write_str((pU08)"voltage_E: ");
399 if (SB_mux_val % 2 == 0) {
400 usart_write_str((pU08)"U");
401 usart_write_U08( (SB_mux_val%8)/2 , 1 );
402 } else {
403 usart_write_str((pU08)"I");
404 usart_write_U08( ((SB_mux_val%8)-1)/2 , 1 );
405 }
406
407 }
408else if (SB_mux_val == 72) usart_write_str((pU08)"humidity_A: H0");
409else if (SB_mux_val == 73) usart_write_str((pU08)"humidity_A: H1");
410
411else if (SB_mux_val < 82) {
412 usart_write_str((pU08)"voltage_F: ");
413 if (SB_mux_val % 2 == 0) {
414 usart_write_str((pU08)"U");
415 usart_write_U08( ((SB_mux_val-2)%8)/2 , 1 );
416 } else {
417 usart_write_str((pU08)"I");
418 usart_write_U08( (((SB_mux_val-2)%8)-1)/2 , 1 );
419 }
420
421 }
422else if (SB_mux_val == 82) usart_write_str((pU08)"humidity_B: H0");
423else if (SB_mux_val == 83) usart_write_str((pU08)"humidity_B: H1");
424}
425
426for (U08 counter = 0; counter < 1; ++counter) {
427 while (ADCSRA & (1<<ADSC) ); // wait until internal ADC is ready
428 float voltage;
429 voltage = ( (float)ADCH ) / 256 * 4.096;
430 usart_write_str((pU08)" ");
431 usart_write_float(voltage,3,4);
432
433
434}
435//usart_write_str((pU08)"\n");
436
437switch (SB_mux_val)
438 {
439 case 15: usart_write_str((pU08)"\n\n");
440 break;
441 case 31: usart_write_str((pU08)"\n\n");
442 break;
443 case 47: usart_write_str((pU08)"\n\n");
444 break;
445 case 63: usart_write_str((pU08)"\n\n");
446 break;
447 case 71: usart_write_str((pU08)"\n\n");
448 break;
449 case 73: usart_write_str((pU08)"\n\n");
450 break;
451 case 81: usart_write_str((pU08)"\n\n");
452 break;
453 case 83: usart_write_str((pU08)"\n\n");
454 break;
455 default: usart_write_str((pU08)"\n");
456 break;
457 }
458
459SA_mux_val = 15;
460}
461 /*
462 if ( usart_rx_ready == TRUE )
463 {
464 //understand what it means and react
465
466 switch (usart_rx_buffer[0])
467 {
468
469 case 'h':
470 {
471 // toggle the heartbeat mode on or off.
472 heartbeat_enable = !heartbeat_enable;
473 break;
474 }
475 case 'a':
476 {
477 // conduct adc - AD7719 SPI interface test
478
479 break;
480 }
481 case 'e':
482 {
483 // conduct ethernet module SPI interface test
484 strtol((char*) usart_rx_buffer+1, NULL, 0);
485 break;
486 }
487
488 default:
489 {
490 usart_write_str((pU08)"? you wrote: ");
491 usart_write_str((pU08)usart_rx_buffer);
492 usart_write_str((pU08)"\n");
493 break;
494 }
495 }
496
497 heartbeat_enable = !heartbeat_enable;
498 usart_rx_ready = FALSE;
499 }
500*/
501// das ist ein paar schritte zu früh.
502// erstmal müssen die interfaces getestet werden.
503/*
504
505 for (U08 i = 0; i<16; i++)
506 {
507
508 if((~PIND) & 0x08) // PD4 is #ADC_RDY input. Inverted logic! if PD4=0 this evaluates to true
509 {
510 PORTA = (PORTA & 0xF0) | ((i) & 0x0F); // switch muxer
511 startconv(); //Start a new A/D Conversion
512 //temp = readandsendtemp();
513 //adcword = getadc();
514 //resistance = getresistance();
515 temperature = gettemp();
516 usart_write_float(temperature,2,4);
517 usart_write_str((pU08)"\t");
518
519 } // end of if adc ready
520 else
521 {
522 i--;
523 }
524 } // end of for loop over 16 channels
525 usart_write_crlf();
526
527*/
528
529 } // end of infinite while loop
530} // end of main()
531
532
533ISR (TIMER2_COMP_vect)
534{
535 ++local_ms;
536}
537
538
539U08 increase_adc (U08 channel){
540bool valid_ch_found = false;
541 while (!valid_ch_found){
542
543 // just increase 'channel' or turnover to zero.
544 ++channel;
545 if (channel == V_CHANNELS + I_CHANNELS + H_CHANNELS)
546 channel = 0;
547
548 // check if this channel is enabled in the bitmap
549 if (adc_enables[channel/8] & (1<<channel%8))
550 valid_ch_found = true;
551 } // end of while loop
552 return channel;
553} // end if increase_adc;
554
555U08 increase_ad7719 (U08 channel){
556bool valid_ch_found = false;
557 while (!valid_ch_found){
558
559 // just increase 'channel' or turnover to zero.
560 ++channel;
561 if (channel == TEMP_CHANNELS)
562 channel = 0;
563
564 // check if this channel is enabled in the bitmap
565 if (ad7719_enables[channel/8] & (1<<channel%8))
566 valid_ch_found = true;
567 } // end of while loop
568 return channel;
569} // end if increase_adc;
570
571
572// Sets voltage Muxer to current channel
573// this is a Muxing, and therefor the adc might need some time to settle.
574// Since there are:
575// - 40 voltage monitor channels
576// - 40 current monitor channels
577// - 4 humidity monitor channels
578// the muxer is set as follows.
579// channel 00..39 --> looking at the voltage channels
580// channel 40..79 --> looking at the current channels
581// channel 80..83 --> looking at the humidities
582void Set_V_Muxer (U08 channel){
583U08 SB = 0;
584 // voltages
585 if (channel < 40) {
586 if (channel < 36)
587 SB = channel*2;
588 else
589 SB = (channel+1)*2;
590 }
591 // currents
592 else if (channel < 80) {
593 channel -= 40;
594 if (channel < 36)
595 SB = channel*2+1;
596 else
597 SB = (channel+1)*2+1;
598 }
599 // humidities
600 else if (channel < 84) {
601 channel -= 80;
602 switch (channel) {
603 case 0:
604 SB = 0x48; //0100.1000
605 break;
606 case 1:
607 SB = 0x49; //0100.1001
608 break;
609 case 2:
610 SB = 0x58; //0101.0010
611 break;
612 case 3:
613 SB = 0x58; //0101.0011
614 break;
615 } // end of switch-case
616 } // end of if (channel < some_number)
617
618 PORTC = (PORTC & 0x80) | (0x7F & SB); // Here the muxer is switched.
619}
620
621void Set_T_Muxer(U08 channel) {
622U08 SA = 0x00;
623
624 switch (channel/16) {
625 case 0:
626 SA |= 1<<4; // 0001.0000
627 break;
628 case 1:
629 break; // 0000.0000
630 case 2:
631 SA |= (1<<4)|(1<<5); // 0011.0000
632 break;
633 case 3:
634 SA |= 1<<5; // 0010.0000
635 break;
636 }
637
638 SA = SA | (channel%16);
639
640 PORTA = (PORTA & 0xC0) | (0x3F & SA); // Here the muxer is switched.
641}
642
643void talk(void){
644
645/*
646// makes no sense to declare the 'new_measurement' vars here
647// but maybe the whole function will be deleted, anyway ...
648// I'm thinking about it.
649bool ad7719_new_measurement;
650bool atmega_adc_new_measurement;
651 if (verbose == true) {
652 // somebody wants to read every new measured value, even if it is trash!
653 // do not actually send away data !
654 // just prepare the data to be send away.
655 if ( ad7719_new_measurement == true ) {
656 add_str_to_output_stream("ad7719: reading:");
657 add_dec_to_output_stream(reading_since_last_muxer_switch,1);
658 add_str_to_output_stream(" temperature channel:");
659 add_dec_to_output_stream(current_temperature_channel,2);
660 add_str_to_output_stream(" = ");
661 add_float_to_output_stream(current_ad7719_value,4,3);
662 add_str_to_output_stream("\n");
663 }
664 if (atmega_adc_new_measurement == true) {
665 add_str_to_output_stream("atmega_adc: reading:");
666 add_dec_to_output_stream(reading_since_last_muxer_switch,1);
667 add_str_to_output_stream(" voltage channel:");
668 add_dec_to_output_stream(current_voltage_channel,2);
669 add_str_to_output_stream(" = ");
670 add_float_to_output_stream(current_atmega_adc_value,4,3);
671 add_str_to_output_stream("\n");
672 }
673 } // end of: if verbose
674*/
675} // end of talk()
676
677// this function generates some output.
678void ad7719_output(U08 channel, U32 data) {
679 usart_write_str((pU08)"R:"); //R for resistance
680 usart_write_char('A'+channel/8); // Letters A,B,C,D,E,F,G,H
681 usart_write_char(' ');
682 usart_write_U08(channel%8+1,1); // Numbers 1...8
683 usart_write_char(':');
684 usart_write_U32_hex(data); //data
685 usart_write_char('\n');
686}
687
688void adc_output(U08 channel, U08 data) {
689
690 if (channel < 40)
691 usart_write_str((pU08)"V:"); //V for Vendetta
692 else if (channel < 80)
693 usart_write_str((pU08)"I:"); //I for Irregular verbs
694 else if (channel < 84)
695 usart_write_str((pU08)"H:"); //H for Huurrray!!!
696
697 switch (channel/16) {
698 case 0:
699 usart_write_char('A'); //V for Vendetta
700 case 1:
701 usart_write_char('B'); //V for Vendetta
702 case 2:
703 usart_write_char('D'); //V for Vendetta
704 case 3:
705 usart_write_char('C'); //V for Vendetta
706 case 4:
707 usart_write_char('EF'); //V for Vendetta
708 }
709 usart_write_char(' ');
710 usart_write_U08((channel/2)%8+1,1); // Numbers 1...8
711 usart_write_char(':');
712 usart_write_U16((U16)data*16,5); //data
713 usart_write_char('\n');
714
715
716}
717
718
719void adc_output_all() {
720 // output all values, which are enabled
721 for (U08 i=0 ; i<40; ++i){
722 if (i==0) usart_write_str((pU08)"voltages:(in units of 16mV)\n");
723 if (i==40) usart_write_str((pU08)"currents:\n");
724 if (i==80) usart_write_str((pU08)"humidities:\n");
725 if (adc_enables[i/8] & i%8){
726 usart_write_U08(adc_values[i],3);
727 usart_write_char('\t');
728 }
729 if (i%8==7) usart_write_char('\n');
730 if (i==83) usart_write_char('\n');
731 }
732}
733
734
735// this method parses the data,
736// which came in via USART
737// later it might as well parse the data from ethernet.
738void parse() {
739U08 command = usart_rx_buffer[0];
740// look at first byte
741// I hope, I can manage to use one byte commands
742 usart_rx_buffer[USART_RX_BUFFER_SIZE-1] = 0;
743 usart_write_str((pU08)"got:");
744 usart_write_str(usart_rx_buffer);
745
746
747
748 switch (command) {
749 case 'E': // AD7719 enable bitmaps may be set
750 for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
751 ad7719_enables[i]=usart_rx_buffer[i+1];
752 ad7719_channels_ready[i]=0;
753 }
754 break;
755 case 'e': // ATmega internal ADC enable bitmaps may be set
756 for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
757 adc_enables[i]=usart_rx_buffer[i+1];
758 adc_channels_ready[i]=0;
759 }
760 break;
761 case 'h':
762 usart_write_str((pU08)"\nheartbeat ");
763 heartbeat_enable = true;
764 if (usart_rx_buffer[1] == '0'){
765 heartbeat_enable = false;
766 usart_write_str((pU08)"off\n");
767 } else {
768 usart_write_str((pU08)"on\n");
769 }
770 break;
771 case 'G': // GET the Temperature channels, which are enabled
772 for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
773 ad7719_channels_ready[i]=0;
774 }
775 break;
776 case 'g': // GET the voltage/current/humidity channels, which are enabled
777 for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
778 adc_channels_ready[i]=0;
779 }
780 break;
781 case 's':
782 usart_write_char('\n');
783 for (U08 i=0; i< CHANNEL_BITMAP;++i) {
784 usart_write_U08_bin(ad7719_enables[i]);
785 usart_write_char('\t');
786 }
787 usart_write_char('\n');
788 for (U08 i=0; i< CHANNEL_BITMAP;++i){
789 usart_write_U08_bin(ad7719_channels_ready[i]);
790 usart_write_char('\t');
791 }
792 usart_write_char('\n');
793 usart_write_U32_hex(local_ms);
794 break;
795 }
796 usart_write_str((pU08)"\nready?");
797 for (U08 i=0; i<USART_RX_BUFFER_SIZE; ++i)
798 usart_rx_buffer[i] = 0;
799}
800
801void check_if_measured_all() {
802 adc_measured_all = true;
803 for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
804 if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
805 adc_measured_all = false;
806 break;
807 }
808 }
809 ad7719_measured_all = true;
810 for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
811 if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
812 ad7719_measured_all = false;
813 break;
814 }
815 }
816
817
818}
Note: See TracBrowser for help on using the repository browser.