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