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

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