Ignore:
Timestamp:
03/18/14 16:33:18 (11 years ago)
Author:
dneise
Message:
new FSC firmware version without any ASCII parsing and fancy stuff. Introduced: 
binary output
checksums
File:
1 edited

Legend:

Unmodified
Added
Removed

  • firmware/FSC/src/FSC.c

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