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

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