source: firmware/FSC/src/parser.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: 8.3 KB
Line 
1#include "parser.h"
2#include "output.h"
3#include "application.h"
4#include "usart.h"
5// this method parses the data,
6// which came in via USART
7// later it might as well parse the data from ethernet.
8void parse_ascii() {
9        usart_rx_buffer[USART_RX_BUFFER_SIZE-1] = 0;
10        usart_write_str((pU08)"got:");
11        usart_write_str(usart_rx_buffer);
12       
13// look at first byte
14// I hope, I can manage to use one byte commands
15        switch (usart_rx_buffer[0]) {
16                case 'E':       // AD7719 enable bitmaps may be set
17                        set_ad7719_enable_register();
18                        break;
19                case 'e':       // ATmega internal ADC enable bitmaps may be set
20                        // not supported yet.
21                        set_adc_enable_register();
22                        break;
23                case 'h':
24                        usart_write_str((pU08)"\nheartbeat ");
25                        heartbeat_enable = true;
26                        if (usart_rx_buffer[1] == '0'){
27                                heartbeat_enable = false;
28                                usart_write_str((pU08)"off\n");
29                        } else {
30                                usart_write_str((pU08)"on\n");
31                        }
32                        break;
33                case 'G':                       // GET the Temperature channels, which are enabled
34                        once_told_you = false;
35                        for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
36                                ad7719_channels_ready[i]=0;
37                        }
38                        break;
39
40                case 'g':                       // GET the voltage/current/humidity channels, which are enabled
41                        once_told_you = false;
42                        for ( U08 i=0; i<V_BITMAP + I_BITMAP + H_BITMAP; ++i ) {
43                                adc_channels_ready[i]=0;
44                        }
45                        break;
46
47                case 'P':
48                        print_ad7719_nicely();
49                        break;
50                       
51                case 'p':
52                        print_adc_nicely();
53                        break;
54
55                case 's':
56                        print_status();
57                        break; 
58
59                case 'd':
60                        usart_write_str((pU08)"\ndebug mode ");
61                        debug_mode = true;
62                        if (usart_rx_buffer[1] == '0'){
63                                debug_mode = false;
64                                usart_write_str((pU08)"off\n");
65                        } else {
66                                usart_write_str((pU08)"on\n");
67                        }
68                        break;         
69        }
70       
71       
72        usart_write_str((pU08)"\nready?");
73        for (U08 i=0; i<USART_RX_BUFFER_SIZE; ++i)
74                usart_rx_buffer[i] = 0;
75}
76
77void parse_non_human_readable_input() {
78
79
80}
81
82// this guy checks, if an incoming byte is:
83// to be stored, because it belongs to a command
84// to be discarded, because something went wrong, and the bytemade no sense...
85// the end of a commmand, and so the 'real parser' may do his work.
86
87void incoming_byte_parser() {
88        static bool receiving_command = false;
89        U08 current_byte = UDR;
90       
91        if (!receiving_command) { 
92                switch (current_byte) {
93                        case 0x01:
94                                receiving_command = true;
95                                break;
96                }
97        }
98       
99        if (receiving_command)
100        {
101                usart_rx_buffer[usart_received_chars] = usart_last_char;
102                usart_received_chars++;
103        }
104       
105       
106}
107
108
109// this is the recent MSR parser
110/////////////////////////////////////////////////////////////////////////////////////////////////////
111/////////////// P A R S E R /////////////////////////////////////////////////////////////////////////
112/////////////////////////////////////////////////////////////////////////////////////////////////////
113// this method parses the data,
114// which came in via USART
115// later it might as well parse the data from ethernet.
116void MSR_parser() {
117
118U08 input_number = 0;
119bool enable = false;
120// look at first byte
121// I hope, I can manage to use one byte commands
122        usart_rx_buffer[USART_RX_BUFFER_SIZE-1] = 0;
123        usart_write_char(' ');
124        usart_write_str(usart_rx_buffer);
125        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) {
130                switch (usart_rx_buffer[0]) {
131                        case 'E':               // user wants to enable/disable something
132                        case 'e':
133                                enable = true;
134                        case 'D':
135                        case 'd':
136                       
137                                if (usart_rx_buffer_index>=1) {  // let's see what.
138                                        if (    usart_rx_buffer[1] != 'r'  &&
139                                                        usart_rx_buffer[1] != 'v'  &&
140                                                        usart_rx_buffer[1] != 'h'  &&
141                                                        usart_rx_buffer[1] != 'p' )
142                                                {
143                                                        print_invalid_enable_statement();
144                                                        break;
145                                                }
146                                }
147                               
148                                input_number = 0;
149                                if (usart_rx_buffer_index >2) {  // lets check the first digit
150                                        if ( usart_rx_buffer[2] >= '0' && usart_rx_buffer[2] <= '9' ) {
151                                                input_number = usart_rx_buffer[2] - '0';
152                                        } else {
153                                                print_invalid_enable_statement();
154                                                break;
155                                        }
156                                }
157                                if (usart_rx_buffer_index >3) {  // lets check the 2nd digit
158                                        if ( usart_rx_buffer[3] >= '0' && usart_rx_buffer[3] <= '9' ) {
159                                                input_number = 10*input_number + usart_rx_buffer[3] - '0';
160                                        } else {
161                                                // okay as well ... if the second digit is missing ..
162                                                // we might have trailing spaces
163                                                // that's okay .. we just accept the first number.
164                                        }
165                                }
166                                if (usart_rx_buffer_index>2) {
167                                        usart_write_str((pU08)"\n I will switch ");
168                                        if (enable) 
169                                                usart_write_str((pU08)"on ");
170                                        else
171                                                usart_write_str((pU08)"off ");
172                                       
173                                        // now we know, what the user wanted ... and we need to do it.
174                                        switch (usart_rx_buffer[1]) {
175                                                case 'r':
176                                                        if (enable)
177                                                                ad7719_enables[input_number/8] |= (1<<(input_number%8));
178                                                        else {
179                                                                ad7719_enables[input_number/8] &= ~(1<<(input_number%8));
180                                                                ad7719_channels_ready[input_number/8] &= ~(1<<(input_number%8));
181                                                                }
182                                                        usart_write_str((pU08)" resistance channel ");
183                                                        usart_write_U08(input_number,2);
184                                                        usart_write_char('\n');
185                                                        break;
186                                                case 'v':
187                                                        if (enable)
188                                                                adc_enables[input_number/8] |= (1<<(input_number%8));
189                                                        else {
190                                                                adc_enables[input_number/8] &= ~(1<<(input_number%8));
191                                                                adc_channels_ready[input_number/8] &= ~(1<<(input_number%8));
192                                                                }
193                                                        usart_write_str((pU08)" voltage channel ");
194                                                        usart_write_U08(input_number,2);
195                                                        usart_write_char('\n');
196                                                        break;
197                                                       
198                                                case 'h':
199                                                        if (enable)
200                                                                adc_enables[1] |= (1<<(input_number%4));
201                                                        else {
202                                                                adc_enables[1] &= ~(1<<(input_number%4));
203                                                                adc_channels_ready[1] &= ~(1<<(input_number%4));
204                                                                }
205                                                        usart_write_str((pU08)" humidity channel ");
206                                                        usart_write_U08(input_number,2);
207                                                        usart_write_char('\n');
208                                                        break;
209                                                case 'p':
210                                                        if (enable)
211                                                                adc_enables[1] |= (1<<((input_number%4) + 4));
212                                                        else {
213                                                                adc_enables[1] &= ~(1<<((input_number%4) + 4));
214                                                                adc_channels_ready[1] &= ~(1<<((input_number%4) + 4));
215                                                                }
216                                                        usart_write_str((pU08)" pressure channel ");
217                                                        usart_write_U08(input_number,2);
218                                                        usart_write_char('\n');
219                                                        break;
220                                                default:
221                                                        usart_write_str((pU08)"\n DAMN! this should never happen"
222                                                        "- enable/disable switch-case!\n");
223                                                        break;
224                                        }
225                                       
226                                       
227                                       
228                                }// end of if usart_rx_buffer_index>2  --> this should not be necessary at all
229                                break;
230                               
231                        case 'b':
232                                usart_write_str((pU08)"\nheartbeat ");
233                                heartbeat_enable = true;
234                                if (usart_rx_buffer[1] == '0'){
235                                        heartbeat_enable = false;
236                                        usart_write_str((pU08)"off\n");
237                                } else {
238                                        usart_write_str((pU08)"on\n");
239                                }
240                                break;
241                        case 'G':                       // GET the Temperature channels, which are enabled
242                                ad7719_values_printed = false;
243                                for ( U08 i=0; i<CHANNEL_BITMAP; ++i ) {
244                                        ad7719_channels_ready[i]=0;
245                                }
246                                break;
247                        case 'g':                       // GET the voltage/current/humidity channels, which are enabled
248                                adc_values_printed = false;
249                                for ( U08 i=0; i<V_BITMAP; ++i ) {
250                                        adc_channels_ready[i]=0;
251                                }
252                                break;
253
254                        case 'p':
255                                        adc_print_endless = true;
256                                if (usart_rx_buffer[1] == '0')
257                                        adc_print_endless = false;
258                                break;         
259
260                        case 'P':
261                                        ad7719_print_endless = true;
262                                if (usart_rx_buffer[1] == '0')
263                                        ad7719_print_endless = false;
264                                break;         
265                               
266
267                        case 's':                       
268                                print_adc_enable_status(true);
269                                usart_write_char('\n');
270
271                                print_ad7719_enable_status(true);
272                                usart_write_char('\n');
273                       
274                                usart_write_str((pU08)"time:");
275                                usart_write_float((float)local_ms/1000 , 1,7);
276                                usart_write_str((pU08)" sec.\n");
277                                break; 
278
279                        case '!':
280                                usart_write_str((pU08)"\ndebug mode ");
281                                debug_mode = true;
282                                if (usart_rx_buffer[1] == '0'){
283                                        debug_mode = false;
284                                        usart_write_str((pU08)"off\n");
285                                } else {
286                                        usart_write_str((pU08)"on\n");
287                                }
288                                break;         
289                               
290                        case 'h':
291                        case 'H':
292                                print_help();
293                                break;
294                }
295        } else
296        {
297                // zero bytes received
298        }
299       
300       
301        for (U08 i=0; i<USART_RX_BUFFER_SIZE; ++i)
302                usart_rx_buffer[i] = 0;
303        usart_rx_buffer_index = 0;     
304        usart_rx_ready = false;
305}       // END of MSR_parser();
306
Note: See TracBrowser for help on using the repository browser.