Mercurial > ~darius > hgwebdir.cgi > tempctrl
annotate tempctrl.c @ 76:4abce5954d25
Add a routine to return text versions of errors from the temperature
conversion routine.
author | darius@Inchoate |
---|---|
date | Wed, 21 Jan 2009 22:51:37 +1030 |
parents | 56165caf744b |
children | ca5fc59ec4f0 |
rev | line source |
---|---|
41 | 1 /* |
2 * Temperature control logic | |
3 * | |
73
56165caf744b
Missed some USB related crud + copyright updates.
darius@Inchoate
parents:
71
diff
changeset
|
4 * Copyright (c) 2009 |
41 | 5 * Daniel O'Connor <darius@dons.net.au>. All rights reserved. |
6 * | |
7 * Redistribution and use in source and binary forms, with or without | |
8 * modification, are permitted provided that the following conditions | |
9 * are met: | |
10 * 1. Redistributions of source code must retain the above copyright | |
11 * notice, this list of conditions and the following disclaimer. | |
12 * 2. Redistributions in binary form must reproduce the above copyright | |
13 * notice, this list of conditions and the following disclaimer in the | |
14 * documentation and/or other materials provided with the distribution. | |
15 * | |
16 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND | |
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
19 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE | |
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
26 * SUCH DAMAGE. | |
27 */ | |
28 | |
29 #include <stdio.h> | |
30 #include <stdint.h> | |
31 #include <stdlib.h> | |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
32 #include <string.h> |
41 | 33 #include <avr/interrupt.h> |
34 #include <avr/pgmspace.h> | |
35 #include <avr/eeprom.h> | |
46 | 36 #include <avr/wdt.h> |
41 | 37 #include <util/crc16.h> |
38 | |
39 #include "cons.h" | |
40 #include "1wire.h" | |
41 #include "tempctrl.h" | |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
42 #include "ds1307.h" |
41 | 43 |
44 typedef struct { | |
45 int32_t sec; | |
46 int32_t usec; | |
47 } time_t; | |
48 | |
49 /* Holds all the settings needed */ | |
50 typedef struct { | |
51 uint8_t fermenter_ROM[8]; | |
52 uint8_t fridge_ROM[8]; | |
53 uint8_t ambient_ROM[8]; | |
54 int16_t target_temp; | |
55 uint16_t hysteresis; | |
56 /* How much to under/overshoot on heating/cooling */ | |
57 int16_t minheatovershoot; | |
58 int16_t mincoolovershoot; | |
59 | |
60 /* Minimum time the cooler can be on/off */ | |
61 int16_t mincoolontime; | |
62 int16_t mincoolofftime; | |
63 | |
64 /* Minimum time the heater can be on/off */ | |
65 int16_t minheatontime; | |
66 int16_t minheatofftime; | |
67 | |
68 #define TC_MODE_AUTO 'a' /* Automatic control */ | |
69 #define TC_MODE_HEAT 'h' /* Force heating */ | |
70 #define TC_MODE_COOL 'c' /* Force cooling */ | |
71 #define TC_MODE_IDLE 'i' /* Force idle */ | |
72 #define TC_MODE_NOTHING 'n' /* Do nothing (like idle but log nothing) */ | |
73 char mode; | |
74 | |
75 /* Bit patterns for various modes */ | |
76 uint8_t coolbits; | |
77 uint8_t heatbits; | |
78 uint8_t idlebits; | |
79 | |
80 /* Check/stale times */ | |
81 int16_t check_interval; | |
82 int16_t stale_factor; | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
83 |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
84 /* Beep if stale */ |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
85 int8_t dobeep; |
41 | 86 } __attribute__((packed)) settings_t; |
87 | |
88 /* Current settings in RAM */ | |
89 static settings_t settings; | |
90 | |
91 /* Our map of EEPROM */ | |
92 struct { | |
93 settings_t settings; | |
94 uint16_t crc; | |
95 } ee_area __attribute__((section(".eeprom"))); | |
96 | |
97 /* Defaults that are shoved into EEPROM if it isn't inited */ | |
98 const PROGMEM settings_t default_settings = { | |
66
5c2a1c68e386
Change to new ROM ID (EEPROM appears to be fried now - ARGH)
darius@Inchoate
parents:
65
diff
changeset
|
99 .fermenter_ROM = { 0x10, 0x8b, 0x7a, 0x53, 0x01, 0x08, 0x00, 0xb4 }, |
41 | 100 .fridge_ROM = { 0x10, 0xa6, 0x2a, 0xc4, 0x00, 0x08, 0x00, 0x11 }, |
101 .ambient_ROM = { 0x10, 0x97, 0x1b, 0xfe, 0x00, 0x08, 0x00, 0xd1 }, | |
102 .target_temp = 1400, | |
103 .hysteresis = 100, | |
104 .minheatovershoot = 50, | |
105 .mincoolovershoot = -50, | |
106 .mincoolontime = 300, | |
107 .mincoolofftime = 600, | |
108 .minheatontime = 60, | |
109 .minheatofftime = 60, | |
67
52aa7716148c
Default to auto (EEPROM is fried so this is the only way..)
darius@Inchoate
parents:
66
diff
changeset
|
110 .mode = TC_MODE_AUTO, |
46 | 111 .coolbits = _BV(6), |
112 .heatbits = _BV(7), | |
41 | 113 .idlebits = 0x00, |
114 .check_interval = 10, | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
115 .stale_factor = 3, |
59
c72cf25881fe
Default to not beeping (saves eardrums during testing)
darius@Inchoate
parents:
55
diff
changeset
|
116 .dobeep = 0 |
41 | 117 }; |
118 | |
119 /* Local variable declarations */ | |
120 volatile static time_t now; | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
121 volatile static uint8_t beeping = 0; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
122 volatile static uint8_t lasttoggle = 0; |
41 | 123 |
124 /* Local function prototypes */ | |
125 static void tempctrl_load_or_init_settings(void); | |
126 static void tempctrl_default_settings(void); | |
127 static void tempctrl_write_settings(void); | |
128 static void setstate(char state); | |
129 static const PROGMEM char*state2long(char s); | |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
130 static void printtemp(char *name, int tmp, char *trailer); |
41 | 131 |
132 /* | |
133 * tempctrl_init | |
134 * | |
135 * Setup timer, should be called with interrupts disabled. | |
136 * | |
137 */ | |
138 void | |
139 tempctrl_init(void) { | |
140 /* Setup timer */ | |
141 /* 16Mhz / 1024 = 15625 Hz / 125 = 125 Hz = IRQ every 8 ms */ | |
142 | |
143 /* CTC mode, no output on pin, Divide clock by 1024 */ | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
144 TCCR2 = _BV(WGM21)| _BV(CS22) | _BV(CS21) | _BV(CS20); |
41 | 145 |
146 /* Compare with ... */ | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
147 OCR2 = 125; |
41 | 148 |
149 /* Enable interrupt for match on A */ | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
150 TIMSK = _BV(OCIE2); |
41 | 151 |
152 now.sec = 0; | |
153 now.usec = 0; | |
154 | |
155 tempctrl_load_or_init_settings(); | |
156 } | |
157 | |
158 /* | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
159 * Timer 2 Compare IRQ |
41 | 160 * |
161 * Update time counter | |
162 */ | |
163 | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
164 ISR(TIMER2_COMP_vect) { |
46 | 165 wdt_reset(); |
166 | |
41 | 167 now.usec += 8000; /* 1000000 * 1 / F_CPU / 1024 / 125 */ |
168 while (now.usec > 1000000) { | |
169 now.usec -= 1000000; | |
170 now.sec++; | |
171 } | |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
172 |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
173 if (beeping) { |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
174 lasttoggle++; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
175 // 63 * 8ms = ~0.5s |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
176 if (lasttoggle > 63) { |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
177 DDRB ^= _BV(PB3); |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
178 lasttoggle = 0; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
179 } |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
180 } else { |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
181 DDRB &= ~_BV(PB3); |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
182 lasttoggle = 0; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
183 } |
41 | 184 } |
185 | |
186 /* | |
187 * tempctrl_update | |
188 * | |
189 * Should be called in a normal context, could run things that take a long time. | |
190 * (ie 1wire bus stuff) | |
191 * | |
192 */ | |
193 void | |
194 tempctrl_update(void) { | |
195 /* State variables */ | |
196 static int32_t checktime = 0; // Time of next check | |
46 | 197 static int32_t lastdata = INT32_MIN; // Last time we got data |
41 | 198 |
199 static int16_t fermenter_temp = 0; // Fermenter temperature | |
200 static int16_t fridge_temp = 0; // Fridge temperature | |
201 static int16_t ambient_temp = 0; // Ambient temperature | |
46 | 202 static int32_t lastheaton = INT32_MIN; // Last time the heater was on |
203 static int32_t lastheatoff = INT32_MIN;// Last time the heater was off | |
204 static int32_t lastcoolon = INT32_MIN; // Last time the cooler was on | |
205 static int32_t lastcooloff = INT32_MIN;// Last time the cooler was off | |
41 | 206 static char currstate = 'i'; // Current state |
46 | 207 /* We init to times to INT32_MIN so that things function properly when |
208 * now < settings.minheat/cool/on/offtime */ | |
41 | 209 |
210 /* Temporary variables */ | |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
211 int32_t t, tempt; |
41 | 212 int16_t diff; |
213 char nextstate; | |
214 int forced; | |
215 int stale; | |
216 | |
217 t = gettod(); | |
218 /* Time to check temperatures? */ | |
219 if (t < checktime) | |
220 return; | |
221 | |
222 checktime = t + settings.check_interval; | |
223 | |
224 /* Don't do any logging, just force idle and leave */ | |
225 if (settings.mode == TC_MODE_NOTHING) { | |
226 nextstate = 'i'; | |
227 goto setstate; | |
228 } | |
229 | |
230 /* Update our temperatures */ | |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
231 tempt = OWGetTemp(settings.fermenter_ROM); |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
232 fridge_temp = OWGetTemp(settings.fridge_ROM); |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
233 ambient_temp = OWGetTemp(settings.ambient_ROM); |
41 | 234 |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
235 /* We only care about this one, only update the value we decide on |
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
236 * only if it is valid |
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
237 */ |
68 | 238 if (tempt > OW_TEMP_BADVAL) { |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
239 fermenter_temp = tempt; |
41 | 240 lastdata = t; |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
241 } |
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
242 |
41 | 243 /* Check for stale data */ |
244 if (lastdata + (settings.check_interval * settings.stale_factor) < t) | |
245 stale = 1; | |
246 else | |
247 stale = 0; | |
248 | |
249 /* Default to remaining as we are */ | |
250 nextstate = '-'; | |
251 | |
252 /* Temperature diff, -ve => too cold, +ve => too warm */ | |
253 diff = fermenter_temp - settings.target_temp; | |
254 | |
255 switch (currstate) { | |
256 case 'i': | |
257 /* If we're idle then only heat or cool if the temperate difference is out of the | |
258 * hysteresis band | |
259 */ | |
260 if (abs(diff) > settings.hysteresis) { | |
261 if (diff < 0 && settings.minheatofftime + lastheatoff < t) | |
262 nextstate = 'h'; | |
263 else if (diff > 0 && settings.mincoolofftime + lastcooloff < t) | |
264 nextstate = 'c'; | |
265 } | |
266 break; | |
267 | |
268 case 'c': | |
269 /* Work out if we should go idle (based on min on time & overshoot) */ | |
270 if (diff + settings.mincoolovershoot < 0 && | |
271 settings.mincoolontime + lastcoolon < t) | |
272 nextstate = 'i'; | |
273 break; | |
274 | |
275 case 'h': | |
276 if (diff - settings.minheatovershoot > 0 && | |
277 settings.minheatontime + lastheaton < t) | |
278 nextstate = 'i'; | |
279 break; | |
280 | |
281 default: | |
282 printf_P(PSTR("\r\nUnknown state %c, going to idle\n"), currstate); | |
283 nextstate = 'i'; | |
284 break; | |
285 } | |
286 | |
287 /* Override if we have stale data */ | |
288 if (stale) | |
289 nextstate = 'i'; | |
290 | |
55 | 291 /* Handle beeping */ |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
292 if (settings.dobeep && stale) |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
293 beeping = 1; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
294 else |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
295 beeping = 0; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
296 |
41 | 297 /* Handle state forcing */ |
298 if (settings.mode != TC_MODE_AUTO) | |
299 forced = 1; | |
300 else | |
301 forced = 0; | |
302 | |
303 if (settings.mode == TC_MODE_IDLE) | |
304 nextstate = 'i'; | |
305 else if (settings.mode == TC_MODE_HEAT) | |
306 nextstate = 'h'; | |
307 else if (settings.mode == TC_MODE_COOL) | |
308 nextstate = 'c'; | |
309 | |
42
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
310 // Keep track of when we last turned things on or off |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
311 switch (nextstate) { |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
312 case 'c': |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
313 if (currstate == 'h') |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
314 lastheatoff = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
315 lastcoolon = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
316 break; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
317 |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
318 case 'h': |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
319 if (currstate == 'c') |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
320 lastcooloff = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
321 lastheaton = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
322 break; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
323 |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
324 default: |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
325 if (currstate == 'c') |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
326 lastcooloff = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
327 if (currstate == 'h') |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
328 lastheatoff = t; |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
329 } |
97ae82023d5b
Actually keep track of when the heater & cooler go on/off..
darius@inchoate.localdomain
parents:
41
diff
changeset
|
330 |
41 | 331 if (nextstate != '-') |
332 currstate = nextstate; | |
333 | |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
334 #if 0 |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
335 printf_P(PSTR("Time: %10ld, "), t); |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
336 #else |
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
337 ds1307_printtime(PSTR(""), PSTR(": ")); |
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
338 #endif |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
339 printtemp(PSTR("Target"), settings.target_temp, PSTR(", ")); |
62
e955aa7047ed
Don't update the temperature we make decisions if it is invalid.
darius@Inchoate
parents:
60
diff
changeset
|
340 printtemp(PSTR("Fermenter"), tempt, PSTR(", ")); // Use actual value from sensor |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
341 printtemp(PSTR("Fridge"), fridge_temp, PSTR(", ")); |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
342 printtemp(PSTR("Ambient"), ambient_temp, PSTR(", ")); |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
343 printf_P(PSTR("State: %S, Flags: %S%S\r\n"), state2long(currstate), |
41 | 344 forced ? PSTR("F") : PSTR(""), |
345 stale ? PSTR("S") : PSTR("")); | |
346 | |
347 setstate: | |
348 setstate(currstate); | |
349 } | |
350 | |
351 /* Return 'time of day' (really uptime) */ | |
352 int32_t | |
353 gettod(void) { | |
354 int32_t t; | |
355 | |
356 cli(); | |
357 t = now.sec; | |
358 sei(); | |
359 | |
360 return(t); | |
361 } | |
362 | |
50
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
363 /* |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
364 * Print out temperature (or NA + error code) with specified trailer |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
365 */ |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
366 static void |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
367 printtemp(char *name, int tmp, char *trailer) { |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
368 if (tmp > OW_TEMP_BADVAL) |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
369 printf_P(PSTR("%S: %d.%02d%S"), name, GETWHOLE(tmp), GETFRAC(tmp), trailer); |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
370 else |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
371 printf_P(PSTR("%S: NA (%d)%S"), name, tmp, trailer); |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
372 } |
a13e0ccc1d2d
Rejig how temperatures are logged. Print out the final line at the end so it
darius@Inchoate
parents:
49
diff
changeset
|
373 |
41 | 374 /* Read the settings from EEPROM |
375 * If the CRC fails then reload from flash | |
376 */ | |
377 static void | |
378 tempctrl_load_or_init_settings(void) { | |
379 uint8_t *dptr; | |
380 uint16_t crc, strcrc; | |
381 int i; | |
382 | |
383 crc = 0; | |
384 eeprom_busy_wait(); | |
385 eeprom_read_block(&settings, &ee_area.settings, sizeof(settings_t)); | |
386 strcrc = eeprom_read_word(&ee_area.crc); | |
387 | |
388 dptr = (uint8_t *)&settings; | |
389 | |
390 for (i = 0; i < sizeof(settings_t); i++) | |
391 crc = _crc16_update(crc, dptr[i]); | |
392 | |
393 /* All OK? */ | |
394 if (crc == strcrc) | |
395 return; | |
396 | |
397 printf_P(PSTR("CRC mismatch got 0x%04x vs 0x%04x, setting defaults\r\n"), crc, strcrc); | |
398 tempctrl_default_settings(); | |
399 tempctrl_write_settings(); | |
400 } | |
401 | |
402 /* Load in the defaults from flash */ | |
403 static void | |
404 tempctrl_default_settings(void) { | |
405 memcpy_P(&settings, &default_settings, sizeof(settings_t)); | |
406 } | |
407 | |
408 /* Write the current settings out to EEPROM */ | |
409 static void | |
410 tempctrl_write_settings(void) { | |
411 uint16_t crc; | |
412 uint8_t *dptr; | |
413 int i; | |
414 | |
415 eeprom_busy_wait(); | |
416 eeprom_write_block(&settings, &ee_area.settings, sizeof(settings_t)); | |
417 | |
418 dptr = (uint8_t *)&settings; | |
419 crc = 0; | |
420 for (i = 0; i < sizeof(settings_t); i++) | |
421 crc = _crc16_update(crc, dptr[i]); | |
422 | |
423 eeprom_write_word(&ee_area.crc, crc); | |
424 } | |
425 | |
426 /* Set the relays to match the desired state */ | |
427 static void | |
428 setstate(char state) { | |
429 switch (state) { | |
430 case 'c': | |
431 PORTC = settings.coolbits; | |
432 break; | |
433 | |
434 case 'h': | |
435 PORTC = settings.heatbits; | |
436 break; | |
437 | |
438 default: | |
439 printf_P(PSTR("Unknown state %c, setting idle\r\n"), state); | |
440 /* fallthrough */ | |
441 | |
442 case 'i': | |
443 PORTC = settings.idlebits; | |
444 break; | |
445 } | |
446 } | |
447 | |
448 /* Handle user command | |
449 * | |
450 */ | |
451 void | |
452 tempctrl_cmd(char *buf) { | |
453 char cmd[6]; | |
454 int16_t data; | |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
455 uint8_t ROM[8]; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
456 |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
457 if (sscanf_P(buf, PSTR("tc %5s"), cmd, &data) == 0) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
458 printf_P(PSTR("Unable to parse tc subcommand\r\n")); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
459 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
460 } |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
461 |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
462 if (!strcasecmp_P(cmd, PSTR("help"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
463 printf_P(PSTR( |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
464 "tc help This help\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
465 "tc save Save settings to EEPROM\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
466 "tc load Load or default settings from EEPROM\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
467 "tc dflt Load defaults from flash\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
468 "tc list List current settings\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
469 "tc mode [achin] Change control mode, must be one of\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
470 " a Auto\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
471 " c Always cool\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
472 " h Always heat\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
473 " i Always idle\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
474 " n Like idle but don't log anything\r\n" |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
475 "tc beep [01] Enable/disable beeping when data is stale\r\n" |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
476 "tc X Y Set X to Y where X is one of\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
477 " targ Target temperature\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
478 " hys Hysteresis range\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
479 " mhov Minimum heat overshoot\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
480 " mcov Minimum cool overshoot\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
481 " mcon Minimum cool on time\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
482 " mcoff Minimum cool off time\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
483 " mhin Minimum heat on time\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
484 " mhoff Minimum heat off time\r\n" |
65 | 485 "tc A B Set temperature sensor ID\r\n" |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
486 " Where A is ferm, frg or amb\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
487 " and B is of the form xx:xx:xx:xx:xx:xx:xx:xx\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
488 "\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
489 " Times are in seconds\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
490 " Temperatures are in hundredths of degrees Celcius\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
491 )); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
492 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
493 } |
41 | 494 |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
495 if (!strcasecmp_P(cmd, PSTR("save"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
496 tempctrl_write_settings(); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
497 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
498 } |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
499 if (!strcasecmp_P(cmd, PSTR("load"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
500 tempctrl_load_or_init_settings(); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
501 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
502 } |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
503 if (!strcasecmp_P(cmd, PSTR("dflt"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
504 tempctrl_default_settings(); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
505 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
506 } |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
507 if (!strcasecmp_P(cmd, PSTR("list"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
508 printf_P(PSTR("Fermenter ROM ID %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
509 "Fridge ROM ID %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
510 "Ambient ROM ID %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
511 "Mode - %c, Target - %d, Hystersis - %d\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
512 "Min heat overshoot - %d, Min cool overshoot - %d\r\n" |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
513 "Min cool on time - %d, Min cool off time - %d\r\n" |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
514 "Min heat on time - %d, Min heat off time - %d\r\n" |
55 | 515 "Beep on stale - %S\r\n" |
516 ), | |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
517 settings.fermenter_ROM[0], settings.fermenter_ROM[1], settings.fermenter_ROM[2], settings.fermenter_ROM[3], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
518 settings.fermenter_ROM[4], settings.fermenter_ROM[5], settings.fermenter_ROM[6], settings.fermenter_ROM[7], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
519 settings.fridge_ROM[0], settings.fridge_ROM[1], settings.fridge_ROM[2], settings.fridge_ROM[3], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
520 settings.fridge_ROM[4], settings.fridge_ROM[5], settings.fridge_ROM[6], settings.fridge_ROM[7], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
521 settings.ambient_ROM[0], settings.ambient_ROM[1], settings.ambient_ROM[2], settings.ambient_ROM[3], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
522 settings.ambient_ROM[4], settings.ambient_ROM[5], settings.ambient_ROM[6], settings.ambient_ROM[7], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
523 settings.mode, settings.target_temp, settings.hysteresis, |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
524 settings.minheatovershoot, settings.mincoolovershoot, |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
525 settings.mincoolontime, settings.minheatontime, |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
526 settings.minheatontime, settings.minheatofftime, |
55 | 527 settings.dobeep ? PSTR("yes") : PSTR("no") |
528 ); | |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
529 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
530 } |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
531 if (!strcasecmp_P(cmd, PSTR("mode"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
532 switch (buf[8]) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
533 case TC_MODE_AUTO: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
534 case TC_MODE_HEAT: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
535 case TC_MODE_COOL: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
536 case TC_MODE_IDLE: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
537 case TC_MODE_NOTHING: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
538 settings.mode = buf[8]; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
539 break; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
540 |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
541 default: |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
542 printf_P(PSTR("Unknown mode character '%c'\r\n"), buf[8]); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
543 break; |
41 | 544 } |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
545 return; |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
546 } |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
547 if (!strcasecmp_P(cmd, PSTR("beep"))) { |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
548 if (buf[8] == '1' || buf[8] == 'y') |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
549 settings.dobeep = 1; |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
550 else if (buf[8] == '0' || buf[8] == 'n') |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
551 settings.dobeep = 0; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
552 else |
60
50fca9562310
Add support for reading/writing to a DS1307 over TWI/IIC.
darius@Inchoate
parents:
59
diff
changeset
|
553 printf_P(PSTR("Expected a y/1 or n/0\r\n")); |
54
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
554 return; |
58f1ec46bff6
Add a beeper when the data is stale (only when USB is disabled as they share
darius@Inchoate
parents:
51
diff
changeset
|
555 } |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
556 if (!strcasecmp_P(cmd, PSTR("ferm")) || |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
557 !strcasecmp_P(cmd, PSTR("frg")) || |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
558 !strcasecmp_P(cmd, PSTR("amb"))) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
559 |
69
3dcf933f2640
Write the sub command into the right variable (oops). Now you can set the
darius@Inchoate
parents:
68
diff
changeset
|
560 if (sscanf_P(buf, PSTR("tc %5s %hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hhx"), cmd, |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
561 &ROM[0], &ROM[1], &ROM[2], &ROM[3], |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
562 &ROM[4], &ROM[5], &ROM[6], &ROM[7]) != 9) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
563 printf_P(PSTR("Unable to parse ROM ID\r\n")); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
564 } else { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
565 if (!strcasecmp_P(cmd, PSTR("ferm"))) |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
566 memcpy(settings.fermenter_ROM, ROM, sizeof(ROM)); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
567 if (!strcasecmp_P(cmd, PSTR("frg"))) |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
568 memcpy(settings.fridge_ROM, ROM, sizeof(ROM)); |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
569 if (!strcasecmp_P(cmd, PSTR("amb"))) |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
570 memcpy(settings.ambient_ROM, ROM, sizeof(ROM)); |
41 | 571 } |
70 | 572 return; |
41 | 573 } |
574 | |
70 | 575 /* Handle setting the multitude of variables |
576 * It's last to simplify things */ | |
51
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
577 if (sscanf_P(buf, PSTR("tc %5s %d"), cmd, &data) != 2) { |
cb184206344d
Rejig command parsing and assume the compiler isn't dumb (eg it can reuse
darius@Inchoate
parents:
50
diff
changeset
|
578 printf_P(PSTR("Unable to parse tc subcommand & value\r\n")); |
41 | 579 return; |
580 } | |
581 | |
582 if (!strcasecmp_P(cmd, PSTR("targ"))) { | |
583 settings.target_temp = data; | |
584 } else if (!strcasecmp_P(cmd, PSTR("hys"))) { | |
585 settings.hysteresis = data; | |
586 } else if (!strcasecmp_P(cmd, PSTR("mhov"))) { | |
587 settings.minheatovershoot = data; | |
588 } else if (!strcasecmp_P(cmd, PSTR("mcov"))) { | |
589 settings.mincoolovershoot = data; | |
590 } else if (!strcasecmp_P(cmd, PSTR("mcon"))) { | |
591 settings.mincoolontime = data; | |
592 } else if (!strcasecmp_P(cmd, PSTR("mcoff"))) { | |
593 settings.mincoolofftime = data; | |
594 } else if (!strcasecmp_P(cmd, PSTR("mhon"))) { | |
595 settings.minheatontime = data; | |
596 } else if (!strcasecmp_P(cmd, PSTR("mhoff"))) { | |
597 settings.minheatofftime = data; | |
598 } else { | |
599 printf_P(PSTR("Unknown setting\r\n")); | |
600 } | |
601 } | |
602 | |
71 | 603 static const char* |
41 | 604 state2long(char s) { |
605 switch (s) { | |
606 case 'i': | |
607 return PSTR("idle"); | |
608 break; | |
609 | |
610 case 'c': | |
611 return PSTR("cool"); | |
612 break; | |
613 | |
614 case 'h': | |
615 return PSTR("heat"); | |
616 break; | |
617 | |
618 case '-': | |
619 return PSTR("-"); | |
620 break; | |
621 | |
622 default: | |
623 return PSTR("unknown"); | |
624 break; | |
625 } | |
626 } |