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

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