source: firmware/FSC/src/FSC_eth_with_user_interface.c @ 10677

Last change on this file since 10677 was 10677, checked in by neise, 9 years ago
File size: 9.7 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 "muxer_fsc.h"
10#include "output.h"
11#include "parser.h"
12#include "interpol.h"
13#include "w5100_spi_interface.h"
14#include "timer.h"
15#include <avr/interrupt.h>
16#include <avr/wdt.h>
17#include <stdlib.h>
18
19// MAIN WORKFLOW GLOBAL VARIABLES
20        bool verbose;  // should go to w5100.c or so
21        bool heartbeat_enable;
22       
23// AD7719 global variables
24        U32 ad7719_values[RESISTANCE_CHANNELS];
25        U08 ad7719_enables[RESISTANCE_CHANNELS/8];
26        U08 ad7719_channels_ready[RESISTANCE_CHANNELS/8];
27        U08 ad7719_readings_since_last_muxing = 0;
28        U08 ad7719_current_channel = 0;
29        U32 ad7719_current_reading = 0;
30        bool ad7719_measured_all = false;
31        bool ad7719_values_printed = true;
32        bool ad7719_print_endless = false;
33
34// ATMEGA ADC global variables
35        U08 adc_readings_until_mean=250;
36        U32 adc_values[VOLTAGE_CHANNELS]; // stores measured voltage in steps of 16mV
37        U08 adc_enables[VOLTAGE_CHANNELS/8];
38        U08 adc_channels_ready[VOLTAGE_CHANNELS/8];
39        U08 adc_readings_since_last_muxing = 0;
40        U08 adc_current_channel = 0;
41        U16 adc_current_reading = 0;
42        bool adc_measured_all = false;
43        bool adc_values_printed = true;
44        bool adc_print_endless = false;
45
46        bool once_told_you = true;
47        bool debug_mode = false;
48       
49// ETHERNET VARS
50U08 downloaded_bytes;
51
52//-----------------------------------------------------------------------------
53//   M A I N    ---   M A I N    ---   M A I N    ---   M A I N    ---  M A I N   
54//-----------------------------------------------------------------------------
55/*
56int main(void)
57{
58       
59
60        U16 received_bytes;
61        U08 really_downloaded_bytes;
62        while(!usart_rx_ready){
63                received_bytes = get_S0_RX_RSR();
64               
65               
66               
67       
68                if (get_S0_RX_RSR() != 0) { // we have something to read
69                        usart_write_str((pU08)"\nReading ");
70                        usart_write_U16(get_S0_RX_RSR(), 6);
71                        usart_write_str((pU08)" b from W5100\n");
72               
73                        while (received_bytes != 0) {
74                                really_downloaded_bytes = w5100_get_RX(16, true);
75                                usart_write_char('!');
76                                usart_write_U08(really_downloaded_bytes,4);
77                                usart_write_char('\n');
78                                for (U08 i=0; i<really_downloaded_bytes; i++){
79                                        usart_write_U08_hex(eth_read_buffer[i]);
80                                        usart_write_char(' ');
81                                }
82                                received_bytes -= really_downloaded_bytes;
83                        }
84                }
85                usart_write_char('\n');
86               
87                _delay_ms(400);
88                _delay_ms(400);
89                _delay_ms(400);
90                _delay_ms(400);
91        }
92        usart_rx_ready = false;
93       
94        bool quit = false;
95        while (!quit) {
96        usart_write_str((pU08)"Enter the string to send to PC or \"XXX\" in order to quit\n");
97                while(!usart_rx_ready){
98                        _delay_ms(100);
99                }
100                usart_rx_ready = false;
101       
102                if ( (usart_rx_buffer[0]=='X') &&  (usart_rx_buffer[1]=='X') && (usart_rx_buffer[2]=='X') )
103                        quit = true;
104                else {
105                        // copy string to W5100 TX buffer and issue 'SEND' command.
106                        for (U08 i =0; i<usart_received_chars; i++){
107                                eth_write_buffer[i]=usart_rx_buffer[i];
108                        }
109                       
110                        w5100_set_TX(usart_received_chars);
111                       
112                }               
113                       
114               
115        }
116       
117} // end of main()     
118*/
119int main(void)
120{
121        app_init();               // Setup: Watchdog and I/Os
122        usart_init();
123        spi_init();             // Initialize SPI interface as master
124        timer_init();           // set up TIMER2: TIMER2_COMP interrupt occurs every 1ms
125       
126        w5100_reset();
127        w5100_init();
128
129        //  Enable interrupts
130        sei();
131
132       
133for ( U08 i=0; i < (RESISTANCE_CHANNELS/8); ++i ) {
134        ad7719_enables[i]=0x00;
135        ad7719_channels_ready[i]=0;
136        }
137for ( U08 i=0; i < (VOLTAGE_CHANNELS/8); ++i ) {
138        adc_enables[i]=0x00;
139        adc_channels_ready[i]=0;
140}
141
142        static U08 welcome[]="welcome to:\n FSC command interface 0.1 \n build: ??.05.2010\n";
143        usart_write_str(welcome);
144        /*
145        print_help();
146        print_adc_enable_status(true);
147        usart_write_char('\n');
148        print_ad7719_enable_status(true);
149        usart_write_char('\n');
150        usart_write_str((pU08)"time:");
151        usart_write_U32(sec , 7);
152        usart_write_str((pU08)" sec.\n");
153*/
154//MAIN LOOP
155while (1)
156{
157        // checks if socket is okay and resets in case of problem the W5100
158        if (w5100_caretaker()) 
159        {
160        // something is not okay with the ethernet ...
161        // will be reset in the next revolution.. but maybe we want to do more...
162        }
163       
164        // this if should check every 25ms if we have any data on the W5100
165        if ( (milisec % W5100_INPUT_CHECK_TIME == 0) && (w5100_ready) )
166        {
167                if (get_S0_RX_RSR() != 0) { // we have something to read
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');
177                }
178        }
179       
180//----------------------------------------------------------------------------
181        if (check_if_adc_measurement_done()) {
182                if(adc_print_endless){
183                        usart_write_str((pU08)"V|");
184                        usart_write_U32(sec ,8);
185                        print_adc_nicely(false,true);
186                        for ( U08 i=0; i<(VOLTAGE_CHANNELS/8); ++i ) {
187                                adc_channels_ready[i]=0;
188                        }
189                } else 
190                if ( !adc_values_printed) {
191                        adc_values_printed = true;
192                        print_adc_nicely(true,true);
193                }
194        } 
195
196        if (check_if_ad7719_measurement_done()) {
197                if(ad7719_print_endless){
198                        usart_write_str((pU08)"R|");
199                        usart_write_U32(sec ,8);
200                        print_ad7719_nicely(false,true);
201                        for ( U08 i=0; i<(RESISTANCE_CHANNELS/8); ++i ) {
202                                ad7719_channels_ready[i]=0;
203                        }
204                } else 
205                if ( !ad7719_values_printed) {
206                        ad7719_values_printed = true;
207                        print_ad7719_nicely(true,true);
208                }
209        } 
210
211//----------------------------------------------------------------------------
212
213        // in order to check the user interface on a hardware near level.
214        // user can issue 'heartbeat command'.
215        // then this üpin is toggled with the 'main-while-loop-frequency'
216        // --> nice check for this frequency as well
217        if (heartbeat_enable) {
218                PORTA ^= (1<<HEARTBEATPIN);
219        }
220               
221//----------------------------------------------------------------------------
222        //IF we need to send away one byte, and ready to send
223        // apparently depricated
224        if ( (usart_tx_buffer_index > 0) && (UCSRA & (1<<UDRE)) ) { 
225                UDR = usart_tx_buffer[0];
226                // THis is shit
227                for (U08 i=0 ; i < USART_TX_BUFFER_SIZE; ++i) {
228                        usart_tx_buffer[i] = usart_tx_buffer[i+1];
229                }
230                usart_tx_buffer_index--;
231        }
232
233//----------------------------------------------------------------------------
234
235        //IF USART DOR bit is set, PC is sending data to fast!!!
236        if ( UCSRA & (1<<DOR) ){
237                usart_write_str((pU08)"PC sending to fast!\n");
238                //usart_last_char = UDR;
239                UDR;
240                // flush TX_buffer and write warning message in
241                // maybe even switch off every measurement. ?
242        }
243//----------------------------------------------------------------------------
244
245        //IF TX_BUFFER was overrun.     
246        if (usart_tx_buffer_overflow) {
247                // flash TX_buffer and write warning message in
248                // maybe even switch off every measurement. ?
249                //
250                // this should only happen, in verbose mode and with low baudrates.
251        }
252//----------------------------------------------------------------------------
253       
254        //IF one command was received.
255        //      -It is not allowed to send more than one command between two '\n'
256        if (usart_rx_ready){ 
257                void MSR_parser();
258        }
259//----------------------------------------------------------------------------
260
261        //IF ATmega internal ADC did finish a conversion --every 200us
262        if ( (ADCSRA & (1<<ADIF)) && !adc_measured_all) {
263                adc_current_reading = (U16)ADCL;
264                adc_current_reading += (U16)ADCH<<8;
265                if (adc_readings_since_last_muxing == ADC_READINGS_UNTIL_SETTLED+adc_readings_until_mean-1) {
266                        adc_channels_ready[adc_current_channel/8] |= (1<<(adc_current_channel%8));
267                        adc_current_channel = increase_adc (adc_current_channel);
268                        adc_values[adc_current_channel] = 0;
269                        Set_V_Muxer(adc_current_channel);
270                        adc_readings_since_last_muxing = 0;
271                        _delay_ms(10);
272                }
273                else if (adc_readings_since_last_muxing >= ADC_READINGS_UNTIL_SETTLED-1) {
274                        adc_values[adc_current_channel] += adc_current_reading;
275                        ++adc_readings_since_last_muxing;
276                }
277                else  {
278                        ++adc_readings_since_last_muxing;
279                }
280
281        }
282//----------------------------------------------------------------------------
283
284        //IF AD7719 ADC just finished a conversion -- every 60ms
285       
286        if (AD7719_IS_READY() && !ad7719_measured_all) {
287                ad7719_current_reading = read_adc(); // --takes at 4MHz SCLK speed about 6us
288                // AD7719 is only read out if settled. saves time.     
289                if (ad7719_readings_since_last_muxing == AD7719_READINGS_UNTIL_SETTLED-1) {
290                        ad7719_values[ad7719_current_channel] = ad7719_current_reading;
291                        ad7719_readings_since_last_muxing=0;
292                        if (debug_mode) {
293                                usart_write_U32_hex(ad7719_current_reading);
294                                usart_write_char('\n');
295                                usart_write_char('\n');
296                        }
297                        // now prepare the data to be send away via USART.
298                       
299                        // note that this channel is ready, now and
300                        // proceed to the next enabled channel.
301                        ad7719_channels_ready[ad7719_current_channel/8] |= (1<<(ad7719_current_channel%8));
302                        ad7719_current_channel = increase_ad7719 (ad7719_current_channel);
303                        Set_T_Muxer(ad7719_current_channel);
304                } else { // the AD7719 did not settle yet, we discard the reading
305                        ++ad7719_readings_since_last_muxing;
306                        if (debug_mode) {
307                                usart_write_U32_hex(ad7719_current_reading);
308                                usart_write_char('\n'); 
309                        }
310
311                        // current reading is not used for anything else
312                }
313        }
314
315
316} // end of MAIN LOOP
317
318} // end of main function
319//-----------------------------------------------------------------------------
320//    E N D     E N D     E N D     E N D     E N D     E N D     E N D     
321//-----------------------------------------------------------------------------
322
Note: See TracBrowser for help on using the repository browser.