Changeset 10677


Ignore:
Timestamp:
May 12, 2011, 5:47:17 PM (8 years ago)
Author:
neise
Message:
 
Location:
firmware/FSC/src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • firmware/FSC/src/FSC_eth_with_user_interface.c

    r10674 r10677  
    3333
    3434// ATMEGA ADC global variables
    35         U08 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
     35        U08 adc_readings_until_mean=250;
     36        U32 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
    3637        U08 adc_enables[VOLTAGE_CHANNELS/8];
    3738        U08 adc_channels_ready[VOLTAGE_CHANNELS/8];
    3839        U08 adc_readings_since_last_muxing = 0;
    3940        U08 adc_current_channel = 0;
    40         U08 adc_current_reading = 0;
     41        U16 adc_current_reading = 0;
    4142        bool adc_measured_all = false;
    4243        bool adc_values_printed = true;
     
    4546        bool once_told_you = true;
    4647        bool debug_mode = false;
     48       
     49// ETHERNET VARS
     50U08 downloaded_bytes;
    4751
    4852//-----------------------------------------------------------------------------
    4953//   M A I N    ---   M A I N    ---   M A I N    ---   M A I N    ---  M A I N   
    5054//-----------------------------------------------------------------------------
     55/*
    5156int main(void)
    5257{
     
    5863                received_bytes = get_S0_RX_RSR();
    5964               
    60                 usart_write_U16_hex(get_S0_TX_FSR()); usart_write_char('\t'); usart_write_char('|');
    61                 usart_write_U16_hex(get_S0_TX_RD()); usart_write_char('\t'); usart_write_char('|');
    62                 usart_write_U16_hex(get_S0_TX_WR()); usart_write_char('\t'); usart_write_char('|');
    63                 usart_write_U16_hex(get_S0_RX_RSR()); usart_write_char('\t'); usart_write_char('|');
    64                 usart_write_U16_hex(get_S0_RX_RD()); usart_write_char('\t'); usart_write_char('|');
     65               
    6566               
    6667       
     
    115116       
    116117} // end of main()     
    117 
     118*/
    118119int main(void)
    119120{
     
    141142        static U08 welcome[]="welcome to:\n FSC command interface 0.1 \n build: ??.05.2010\n";
    142143        usart_write_str(welcome);
     144        /*
    143145        print_help();
    144146        print_adc_enable_status(true);
     
    149151        usart_write_U32(sec , 7);
    150152        usart_write_str((pU08)" sec.\n");
    151 
     153*/
    152154//MAIN LOOP
    153155while (1)
    154156{
    155         if (w5100_caretaker())
     157        // checks if socket is okay and resets in case of problem the W5100
     158        if (w5100_caretaker()) 
    156159        {
    157160        // something is not okay with the ethernet ...
     
    159162        }
    160163       
     164        // this if should check every 25ms if we have any data on the W5100
    161165        if ( (milisec % W5100_INPUT_CHECK_TIME == 0) && (w5100_ready) )
    162166        {
    163167                if (get_S0_RX_RSR() != 0) { // we have something to read
    164                         really_downloaded_bytes = w5100_get_RX(ETH_READ_BUFFER_SIZE, true);
     168                        downloaded_bytes = w5100_get_RX(ETH_READ_BUFFER_SIZE, true);
     169                        usart_write_str((pU08)"got ethernet stream - no. of. bytes:");
     170                        usart_write_U08(downloaded_bytes,3);
     171                        usart_write_char('\n');
     172                        for (U08 i=0; i<downloaded_bytes; i++){
     173                                usart_write_U08_hex(eth_read_buffer[i]);
     174                                usart_write_char(' ');
     175                        }
     176                        usart_write_char('\n');
    165177                }
    166178        }
     
    170182                if(adc_print_endless){
    171183                        usart_write_str((pU08)"V|");
    172                         usart_write_float((float)local_ms/1000 , 1,4);
     184                        usart_write_U32(sec ,8);
    173185                        print_adc_nicely(false,true);
    174                         for ( U08 i=0; i<V_BITMAP; ++i ) {
     186                        for ( U08 i=0; i<(VOLTAGE_CHANNELS/8); ++i ) {
    175187                                adc_channels_ready[i]=0;
    176188                        }
     
    185197                if(ad7719_print_endless){
    186198                        usart_write_str((pU08)"R|");
    187                         usart_write_float((float)local_ms/1000 , 1,4);
     199                        usart_write_U32(sec ,8);
    188200                        print_ad7719_nicely(false,true);
    189                         for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
     201                        for ( U08 i=0; i<(RESISTANCE_CHANNELS/8); ++i ) {
    190202                                ad7719_channels_ready[i]=0;
    191203                        }
     
    224236        if ( UCSRA & (1<<DOR) ){
    225237                usart_write_str((pU08)"PC sending to fast!\n");
    226                 usart_last_char = UDR;
     238                //usart_last_char = UDR;
     239                UDR;
    227240                // flush TX_buffer and write warning message in
    228241                // maybe even switch off every measurement. ?
  • firmware/FSC/src/FSC_test.c

    r10667 r10677  
    1111#include "parser.h"
    1212#include "interpol.h"
     13#include "timer.h"
    1314#include "w5100_spi_interface.h"
    1415#include <avr/interrupt.h>
     
    2930        bool verbose;
    3031        bool heartbeat_enable;
    31 
     32/*
    3233// USART global variables
    3334        U08 usart_rx_buffer[USART_RX_BUFFER_SIZE];
     
    3940// USART FLAGS
    4041        bool usart_tx_buffer_overflow = false;  // true if usart_tx_buffer was full.
    41        
     42        */
    4243// TIMER global variable
    4344        volatile U32 local_ms = 0;
    4445
    4546// AD7719 global variables
    46         U32 ad7719_values[TEMP_CHANNELS];
    47         U08 ad7719_enables[CHANNEL_BITMAP];
    48         U08 ad7719_channels_ready[CHANNEL_BITMAP];
     47        U32 ad7719_values[RESISTANCE_CHANNELS];
     48        U08 ad7719_enables[RESISTANCE_CHANNELS/8];
     49        U08 ad7719_channels_ready[RESISTANCE_CHANNELS/8];
    4950        U08 ad7719_readings_since_last_muxing = 0;
    5051        U08 ad7719_current_channel = 0;
     
    5354       
    5455// ATMEGA ADC global variables
    55         U08 adc_values[V_CHANNELS + I_CHANNELS + H_CHANNELS]; // stores measured voltage in steps of 16mV
    56         U08 adc_enables[V_BITMAP + I_BITMAP + H_BITMAP];
    57         U08 adc_channels_ready[V_BITMAP + I_BITMAP + H_BITMAP];
     56        U08 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
     57        U08 adc_enables[VOLTAGE_CHANNELS/8];
     58        U08 adc_channels_ready[VOLTAGE_CHANNELS/8];
    5859        U08 adc_readings_since_last_muxing = 0;
    5960        U08 adc_current_channel = 0;
     
    356357*/
    357358
    358 
     359/*
    359360
    360361ISR (TIMER2_COMP_vect)
     
    366367
    367368
     369*/
  • firmware/FSC/src/application.c

    r10667 r10677  
    139139U08     increase_adc (U08 channel){
    140140U08 effective_channel;
    141         for ( U08 increase = 1 ; increase <= V_CHANNELS + I_CHANNELS + H_CHANNELS; increase++)
    142         {
    143                 effective_channel = (channel + increase) % (V_CHANNELS + I_CHANNELS + H_CHANNELS);
     141        for ( U08 increase = 1 ; increase <= VOLTAGE_CHANNELS; increase++)
     142        {
     143                effective_channel = (channel + increase) % (VOLTAGE_CHANNELS);
    144144                if (adc_enables[effective_channel/8] & (1<<effective_channel%8))
    145145                        return effective_channel;
     
    150150U08     increase_ad7719 (U08 channel){
    151151U08 effective_channel;
    152         for ( U08 increase = 1 ; increase <= TEMP_CHANNELS; increase++)
    153         {
    154                 effective_channel = (channel + increase) % (TEMP_CHANNELS);
     152        for ( U08 increase = 1 ; increase <= RESISTANCE_CHANNELS; increase++)
     153        {
     154                effective_channel = (channel + increase) % (RESISTANCE_CHANNELS);
    155155                if (ad7719_enables[effective_channel/8] & (1<<effective_channel%8))
    156156                        return effective_channel;
     
    161161void check_if_measured_all() {
    162162        adc_measured_all = true;
    163         for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
     163        for ( U08 i=0; i<(VOLTAGE_CHANNELS/8); ++i ) {
    164164                if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
    165165                        adc_measured_all = false;
     
    168168        }
    169169        ad7719_measured_all = true;
    170         for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
     170        for ( U08 i=0; i<(RESISTANCE_CHANNELS/8); ++i ) {
    171171                if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
    172172                        ad7719_measured_all = false;
     
    177177
    178178}
     179
     180
     181bool check_if_adc_measurement_done(){
     182        adc_measured_all = true;
     183        for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
     184                if ((adc_enables[i] ^ adc_channels_ready[i]) != 0x00) {
     185                        adc_measured_all = false;
     186                        break;
     187                }
     188        }
     189        return adc_measured_all;
     190}
     191
     192bool check_if_ad7719_measurement_done(){
     193        ad7719_measured_all = true;
     194        for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
     195                if ((ad7719_enables[i] ^ ad7719_channels_ready[i]) != 0x00) {
     196                        ad7719_measured_all = false;
     197                        break;
     198                }
     199        }
     200        return ad7719_measured_all;
     201}
  • firmware/FSC/src/application.h

    r10674 r10677  
    6363
    6464// ATMEGA ADC global variables
    65         extern U08 adc_values[]; // stores measured voltage in steps of 16mV
     65        extern U32 adc_values[]; // stores measured voltage in steps of 16mV
    6666        extern U08 adc_enables[];
    6767        extern U08 adc_channels_ready[];
    6868        extern U08 adc_readings_since_last_muxing;
    6969        extern U08 adc_current_channel;
    70         extern U08 adc_current_reading;
     70        extern U16 adc_current_reading;
    7171        extern bool adc_measured_all;
    7272        extern bool adc_values_printed;
     
    9595void check_what_measurement_was_finished() ;
    9696void check_if_measured_all() ;
     97
     98bool check_if_adc_measurement_done();
     99bool check_if_ad7719_measurement_done();
    97100// end of function definition:
    98101//-----------------------------------------------------------------------------
  • firmware/FSC/src/output.c

    r10674 r10677  
    66void print_status() {
    77        usart_write_str((pU08)"adc status:\n");
    8         for (U08 i=0; i< V_BITMAP + I_BITMAP + H_BITMAP;++i) {
     8        for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i) {
    99                usart_write_U08_bin(adc_enables[i]);   
    1010                usart_write_char(' ');
    1111        }
    1212        usart_write_char('\n');
    13         for (U08 i=0; i< V_BITMAP + I_BITMAP + H_BITMAP;++i){
     13        for (U08 i=0; i< VOLTAGE_CHANNELS/8;++i){
    1414                usart_write_U08_bin(adc_channels_ready[i]);
    1515                usart_write_char(' ');
     
    1818
    1919        usart_write_str((pU08)"ad7719 status:\n");
    20         for (U08 i=0; i< CHANNEL_BITMAP;++i) {
     20        for (U08 i=0; i< RESISTANCE_CHANNELS/8;++i) {
    2121                usart_write_U08_bin(ad7719_enables[i]);
    2222                usart_write_char(' ');
    2323        }
    2424        usart_write_char('\n');
    25         for (U08 i=0; i< CHANNEL_BITMAP;++i){
     25        for (U08 i=0; i< RESISTANCE_CHANNELS/8;++i){
    2626                usart_write_U08_bin(ad7719_channels_ready[i]);
    2727                usart_write_char(' ');
     
    5757        usart_write_str((pU08)"\n printing voltages in mV:\n");
    5858        // output:      U08 adc_values[V_CHANNELS + I_CHANNELS + H_CHANNELS];
    59         for (U08 i=0; i< V_CHANNELS + I_CHANNELS + H_CHANNELS;++i) {
     59        for (U08 i=0; i< VOLTAGE_CHANNELS;++i) {
    6060                if (i%8 == 0) usart_write_char('\n');
    6161                adc_output(i, adc_values[i]);
     
    7272        usart_write_str((pU08)"\n printing measured resistance in kohms:\n");
    7373
    74         for (U08 i=0; i< TEMP_CHANNELS;++i) {
     74        for (U08 i=0; i< RESISTANCE_CHANNELS;++i) {
    7575                if (i%8 == 0) usart_write_char('\n');
    7676
  • firmware/FSC/src/parser.c

    r10674 r10677  
    3333                case 'G':                       // GET the Temperature channels, which are enabled
    3434                        once_told_you = false;
    35                         for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
     35                        for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
    3636                                ad7719_channels_ready[i]=0;
    3737                        }
     
    4040                case 'g':                       // GET the voltage/current/humidity channels, which are enabled
    4141                        once_told_you = false;
    42                         for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
     42                        for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
    4343                                adc_channels_ready[i]=0;
    4444                        }
     
    8484// to be discarded, because something went wrong, and the bytemade no sense...
    8585// the end of a commmand, and so the 'real parser' may do his work.
    86 
     86/*
    8787void incoming_byte_parser() {
    8888        static bool receiving_command = false;
     
    105105       
    106106}
    107 
     107*/
     108/*
    108109
    109110// this is the recent MSR parser
     
    124125        usart_write_str(usart_rx_buffer);
    125126        usart_write_char('\n');
    126         //usart_write_str((pU08)"\n received number of bytes:");
    127         //usart_write_U08(usart_rx_buffer_index,3);
    128 
    129         if (usart_rx_buffer_index >0) {
     127       
     128
     129        if (usart_received_chars >0) {
    130130                switch (usart_rx_buffer[0]) {
    131131                        case 'E':               // user wants to enable/disable something
     
    135135                        case 'd':
    136136                       
    137                                 if (usart_rx_buffer_index>=1) {  // let's see what.
     137                                if (usart_received_chars>=1) {  // let's see what.
    138138                                        if (    usart_rx_buffer[1] != 'r'  &&
    139139                                                        usart_rx_buffer[1] != 'v'  &&
     
    141141                                                        usart_rx_buffer[1] != 'p' )
    142142                                                {
    143                                                         print_invalid_enable_statement();
     143                                                        //print_invalid_enable_statement();
    144144                                                        break;
    145145                                                }
     
    147147                               
    148148                                input_number = 0;
    149                                 if (usart_rx_buffer_index >2) {  // lets check the first digit
     149                                if (usart_received_chars >2) {  // lets check the first digit
    150150                                        if ( usart_rx_buffer[2] >= '0' && usart_rx_buffer[2] <= '9' ) {
    151151                                                input_number = usart_rx_buffer[2] - '0';
    152152                                        } else {
    153                                                 print_invalid_enable_statement();
     153                                                //print_invalid_enable_statement();
    154154                                                break;
    155155                                        }
    156156                                }
    157                                 if (usart_rx_buffer_index >3) {  // lets check the 2nd digit
     157                                if (usart_received_chars >3) {  // lets check the 2nd digit
    158158                                        if ( usart_rx_buffer[3] >= '0' && usart_rx_buffer[3] <= '9' ) {
    159159                                                input_number = 10*input_number + usart_rx_buffer[3] - '0';
     
    164164                                        }
    165165                                }
    166                                 if (usart_rx_buffer_index>2) {
     166                                if (usart_received_chars>2) {
    167167                                        usart_write_str((pU08)"\n I will switch ");
    168168                                        if (enable)
     
    226226                                       
    227227                                       
    228                                 }// end of if usart_rx_buffer_index>2  --> this should not be necessary at all
     228                                }// end of if usart_received_chars>2  --> this should not be necessary at all
    229229                                break;
    230230                               
     
    241241                        case 'G':                       // GET the Temperature channels, which are enabled
    242242                                ad7719_values_printed = false;
    243                                 for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
     243                                for ( U08 i=0; i<RESISTANCE_CHANNELS/8; ++i ) {
    244244                                        ad7719_channels_ready[i]=0;
    245245                                }
     
    247247                        case 'g':                       // GET the voltage/current/humidity channels, which are enabled
    248248                                adc_values_printed = false;
    249                                 for ( U08 i=0; i<V_BITMAP; ++i ) {
     249                                for ( U08 i=0; i<VOLTAGE_CHANNELS/8; ++i ) {
    250250                                        adc_channels_ready[i]=0;
    251251                                }
     
    301301        for (U08 i=0; i<USART_RX_BUFFER_SIZE; ++i)
    302302                usart_rx_buffer[i] = 0;
    303         usart_rx_buffer_index = 0;     
     303        usart_received_chars = 0;       
    304304        usart_rx_ready = false;
    305305}       // END of MSR_parser();
    306306
     307*/
  • firmware/FSC/src/spi_master.c

    r10667 r10677  
    5353       
    5454        // Lets try with the fastest!
    55         spi_clock_index = 0;  // Set Clockindex for lowest clock speed (F_CPU / 128)
     55        spi_clock_index = 4;   // this is reasonable for W5100 because of slow level shifters on the FSC.
    5656
    5757  spi_dord = 0;                                 // Data Order MSB first dord = 0  --> good for all devices
     
    188188  for (n = 0; n < bytes; n++)
    189189  {
     190  PORTB |= 1<< PB3;
    190191  // Check for active slave select level
    191192  if (SPI_DEVICE_ACTIVE_HIGH[device])
     
    206207  }
    207208
    208  
     209  PORTB &= ~(1<< PB3);
    209210    spi_read_buffer[n] = spi_transfer_byte(spi_write_buffer[n]);
    210  
     211  PORTB |= 1<< PB3;
    211212
    212213  // Check for inactive slave select level
     
    227228                }
    228229  }
    229  
     230   PORTB &= ~(1<< PB3);
    230231  }
    231232}
     
    240241
    241242  // Wait for transfer completed
     243  PORTB |= 1<<PB3;
    242244  while (!(SPSR & (1 << SPIF)))
    243245  {
    244   }
     246  PORTB ^= 1<<PB3;
     247  }
     248  PORTB &= ~(1<<PB3);
    245249
    246250  // Return result of transfer
     
    282286}
    283287//-----------------------------------------------------------------------------
     288
     289
     290//-----------------------------------------------------------------------------
     291
     292void spi_transfer_w5100(U08 bytes)
     293{
     294
     295        U08 n;
     296        // Transfer requested bytes
     297        SPCR |= 1<<MSTR; // make sure we are still SPI MASTER ... sometimes this bit is cleared by something ... dkw?
     298        for (n = 0; n < bytes; n++)
     299        {
     300                PORTB &= ~(1<< PB4);  // SS low
     301
     302                SPDR = spi_write_buffer[n];
     303                while (!(SPSR & (1 << SPIF)))
     304                spi_read_buffer[n] = SPDR       ;
     305
     306                PORTB |= (1<< PB4);  // SS HIGH
     307        }
     308
     309
     310}
     311//-----------------------------------------------------------------------------
  • firmware/FSC/src/spi_master.h

    r10109 r10677  
    2626void spi_init(void);
    2727void spi_transfer(U08 bytes, U08 device);
     28void spi_transfer_w5100(U08 bytes);
    2829U08 spi_transfer_byte(U08 data);
    2930void spi_set_clock_index(U08 clock_index);
  • firmware/FSC/src/w5100_spi_interface.c

    r10674 r10677  
    2424        if (socket_status == SR_SOCK_ESTABLISHED) {
    2525                w5100_ready = true;
     26               
    2627                // everything is fine...
    2728                return 0;
     
    6364spi_write_buffer[3]=data;
    6465
    65 spi_transfer(4, 0);
     66spi_transfer_w5100(4);
    6667// spi_read_buffer should contain 0x00 0x01 0x02 and 0x03 ... nice check!
    6768}
     
    7475spi_write_buffer[3]=0x00;
    7576
    76 spi_transfer(4, 0);
     77spi_transfer_w5100(4);
    7778return spi_read_buffer[3];
    7879// spi_read_buffer should contain 0x00 0x01 0x02 and data ... nice check!
     
    117118        w5100_write ( S0_PORT0, 0x13 );         // Port 5000 -> 0x1388
    118119        w5100_write ( S0_PORT1, 0x88 );
    119         usart_write_str((pU08)"Issuing Socket open command. NOW\n");
    120120        w5100_write ( S0_CR, CR_OPEN );         // issue Socket open command
    121121        while (sock0_status != SR_SOCK_INIT) {
    122122                sock0_status = w5100_read(S0_SR); // request socket 0 status
    123                 usart_write_str((pU08)"Socket 0 status is:");
    124                 usart_write_U08_hex(sock0_status);
    125                 usart_write_char('\n');
    126         }
    127 
    128         usart_write_str((pU08)"Issuing Socket LISTEN command. NOW\n");
     123        }
     124
    129125        w5100_write ( S0_CR, CR_LISTEN );               // issue Socket listen command
    130        
    131126        while (sock0_status != SR_SOCK_LISTEN) {
    132127                sock0_status = w5100_read(S0_SR); // request socket 0 status
    133                 usart_write_str((pU08)"Socket 0 status is:");
    134                 usart_write_U08_hex(sock0_status);
    135                 usart_write_char('\n');
    136128        }
    137129        return sock0_status;
  • firmware/FSC/src/w5100_spi_interface.h

    r10674 r10677  
    1111
    1212#define ETH_READ_BUFFER_SIZE 32
    13 #define ETH_WRITE_BUFFER_SIZE 16
     13#define ETH_WRITE_BUFFER_SIZE 32
    1414extern volatile U08 eth_read_buffer[ETH_READ_BUFFER_SIZE];
    1515extern volatile U08 eth_write_buffer[ETH_WRITE_BUFFER_SIZE];
Note: See TracChangeset for help on using the changeset viewer.