Makefile

-DEVICE     = atxmega256a3u
+DEVICE     = atxmega128a3u
 PROGRAMMER = -c avrispmkII
-OBJECTS    = main.o clock.o debug.o bus.o config.o status.o utils.o messages.o vanne.o debit.o orders.o thermometer.o median_filter.o leds.o main_timer.o
+OBJECTS    = main.o clock.o debug.o bus.o status.o utils.o messages.o orders.o thermometer_cold.o thermometer_hot.o median_filter.o leds.o main_timer.o
 PORT		= usb
 
 # For computing fuse byte values for other devices and options see
@@ -28,10 +28,7 @@ commitid.h: .git/refs/heads
 	cog -r *.c *.h
 	./define_commit_id.py > $@
 
-id.h: ID
-	./define_id.py > $@
-
-%.o: %.c common.h commitid.h id.h
+%.o: %.c common.h commitid.h
 		$(COMPILE) -c $< -o $@
 
 .S.o:

common.h

@@ -3,6 +3,19 @@
 
 #define F_CPU 32000000L
 
+/*[[[cog
+import conf
+hbid = f"{conf.BID:02x}"
+cog.out(f"#define BID 0x{hbid}\n")
+cog.out(f"#define BID_C0 '{hbid[0]}'\n")
+cog.out(f"#define BID_C1 '{hbid[1]}'\n")
+]]]*/
+#define BID 0xc0
+#define BID_C0 'c'
+#define BID_C1 '0'
+//[[[end]]]
+
+
 #include <avr/io.h>
 #include <util/delay.h>
 #include <avr/interrupt.h>
@@ -10,17 +23,14 @@
 
 #include "utils.h"
 #include "commitid.h"
-#include "id.h"
 #include "clock.h"
 #include "debug.h"
 #include "bus.h"
-#include "config.h"
 #include "status.h"
 #include "messages.h"
-#include "vanne.h"
 #include "orders.h"
-#include "debit.h"
-#include "thermometer.h"
+#include "thermometer_cold.h"
+#include "thermometer_hot.h"
 #include "median_filter.h"
 #include "leds.h"
 #include "main_timer.h"

conf.py

@@ -3,28 +3,13 @@ import math
 
 from avrxmegastuff import PinDesc
 
-VANNE = {
-    "cmd_open_close_pindesc": (PinDesc("E0"), PinDesc("E1")),
-    "sensor_open_close_pindesc": (PinDesc("E3"), PinDesc("E4")),
-    "action_limit": "cconfig.minimum_step",
-}
-
-FLOW = PinDesc("E2")
-FLOW_EVSYS_CHANNEL = 1
-FLOW_COUNTER = "TCD0"
-FLOW_FACTOR_FILTRE_5 = 1 - math.exp(-1 / 5)
-FLOW_FACTOR_FILTRE_60 = 1 - math.exp(-1 / 60)
-
-SENSOR_T = PinDesc("E5")
+SENSOR_T_COLD = PinDesc("D0")
+SENSOR_T_HOT = PinDesc("D1")
 
 LED = {
     "STATUS": PinDesc("F0"),
     "TX": PinDesc("F1"),
     "RX": PinDesc("F2"),
-    "MOTOR_1": PinDesc("F3"),
-    "MOTOR_2": PinDesc("F4"),
-    "OVERFLOW": PinDesc("F5"),
-    "UNDERFLOW": PinDesc("F6"),
 }
 
 DEBUG = {"name": "C1", "txpin": 7, "tx": True}
@@ -46,8 +31,7 @@ THERMO_PERIOD = 5
 THERMO_MEDIAN_FILTER_LEN = 13
 THERMO_FACTOR_FILTRE = 1 - math.exp(-5 / 60)
 THERMO_FAIL_NUMBER = 180
-BID_WATER = 0xc0
+BID = 0xc0
 
 ACTION_TIMER_MAIN = "TCC0"
 
-EEPROM_ADDR_CONFIG = "((uint8_t*)0x0000)"

config.c

-#include "config.h"
-
-config_t config;
-cconfig_t cconfig;
-
-void config_write()
-{
-    uint16_t k;
-    for(k=0;k<sizeof(config_t);k++)
-        eeprom_write_byte(EEPROM_ADDR_CONFIG+k, *(((uint8_t*)&config)+k));
-}
-
-void config_read()
-{
-    uint16_t k;
-    for(k=0;k<sizeof(config_t);k++)
-        *(((uint8_t*)&config)+k) = eeprom_read_byte(EEPROM_ADDR_CONFIG+k);
-}
-
-void config_init()
-{
-
-    config_read();
-    cconfig_update(&config, &cconfig);
-    if(!config_valid(&cconfig))
-    {
-        config_default(&config);
-        cconfig_update(&config, &cconfig);
-    }
-    config_mode_change();
-}
-
-void cconfig_update(config_t * c, cconfig_t * cc)
-{
-    cc->mode = c->mode;
-    cc->Kp = (0.01 * c->Kp * c->vol_cuve) / 300;
-    cc->ti = c->ti;
-    cc->consigne_temperature = 0.01 * c->consigne_temperature;
-    cc->debit_max = (0.01 * c->debit_max * c->vol_cuve) / 300;
-    cc->cst_ev = c->cst_ev;
-    cc->debit_min1 = 0.01 * c->debit_min1;
-    cc->debit_min2 = 0.01 * c->debit_min2;
-    cc->minimum_step = c->minimum_step;
-    cc->debit_no_action = cc->minimum_step/cc->cst_ev;
-    cc->volume_manque_max = 0.01 * c->volume_manque_max;
-    cc->m_rattrapage = c->m_rattrapage;
-    cc->consigne_debit = 0.01 * c->consigne_debit;
-    cc->post_refroi_T1 = 0.01 * c->post_refroi_T1;
-    cc->post_refroi_T2 = 0.01 * c->post_refroi_T2;
-    cc->post_refroi_cold_water_T1 = 0.01 * c->post_refroi_cold_water_T1;
-    cc->post_refroi_cold_water_T2 = 0.01 * c->post_refroi_cold_water_T2;
-    cc->post_refroi_hot_water_T1 = 0.01 * c->post_refroi_hot_water_T1;
-    cc->post_refroi_hot_water_T2 = 0.01 * c->post_refroi_hot_water_T2;
-    cc->post_refroi_dmax = (0.01 * c->post_refroi_dmax * c->vol_cuve)/300;
-}
-
-uint8_t config_valid(cconfig_t * cc)
-{
-    if(cc->mode<1 || cc->mode>6)
-        return 0;
-    if(cc->Kp<1 || cc->Kp>100)
-        return 0;
-    if(cc->ti<60 || cc->ti > 86400)
-        return 0;
-    if(cc->consigne_temperature < 10 || cc->consigne_temperature > 40)
-        return 0;
-    if(cc->debit_max < 5 || cc->debit_max > 50)
-        return 0;
-    if(cc->cst_ev < 1 || cc->cst_ev>100)
-        return 0;
-    if(cc->debit_min1 < 1 || cc->debit_min1 > 40)
-        return 0;
-    if(cc->debit_min2 < 1 || cc->debit_min2 > 40)
-        return 0;
-    if(cc->debit_min1 >= cc->debit_min2)
-        return 0;
-    if(cc->debit_min2 >= cc->debit_max)
-        return 0;
-    if(cc->minimum_step < 1 || cc->minimum_step > 150)
-        return 0;
-    if(cc->volume_manque_max < 1 || cc->volume_manque_max>250)
-        return 0;
-    if(cc->m_rattrapage < 1 || cc->m_rattrapage > 60)
-        return 0;
-    if(cc->consigne_debit<0 || cc->consigne_debit>50)
-        return 0;
-    if(cc->post_refroi_T1 < 7 || cc->post_refroi_T2 > 40 || cc->post_refroi_T2-cc->post_refroi_T1<1)
-        return 0;
-    if(cc->post_refroi_cold_water_T1 < 1 || cc->post_refroi_cold_water_T2 > 40 || cc->post_refroi_cold_water_T2-cc->post_refroi_cold_water_T1<1)
-        return 0;
-    if(cc->post_refroi_hot_water_T1 < 1 || cc->post_refroi_hot_water_T2 > 40 || cc->post_refroi_hot_water_T2-cc->post_refroi_hot_water_T1<1)
-        return 0;
-    if(cc->post_refroi_dmax < 0 || cc->post_refroi_dmax>40)
-        return 0;
-    return 1;
-}
-
-void config_default(config_t* c)
-{
-    c->mode = (uint8_t)MODE_FORCE_CLOSE;
-    c->vol_cuve = 300;
-    c->Kp = 32*100;
-    c->ti = 3600;
-    c->consigne_temperature = 2350;
-    c->debit_max = 1500;
-    c->cst_ev = 10;
-    c->debit_min1 = 200;
-    c->debit_min2 = 400;
-    c->minimum_step = 10;
-    c->volume_manque_max = 7500;
-    c->m_rattrapage = 15;
-    c->consigne_debit = 0;
-    c->post_refroi_T1 = 1200;
-    c->post_refroi_T2 = 1600;
-    c->post_refroi_cold_water_T1 = 800;
-    c->post_refroi_cold_water_T2 = 1100;
-    c->post_refroi_hot_water_T1 = 1400;
-    c->post_refroi_hot_water_T2 = 1700;
-    c->post_refroi_dmax = 1000;
-}
-
-void config_apply_new_config(config_t * pnew_config)
-{
-    cconfig_t new_cconfig;
-    cconfig_update(pnew_config, &new_cconfig);
-    if(config_valid(&new_cconfig))
-    {
-        uint8_t mode_change = 0;
-        if(pnew_config->mode != config.mode)
-            mode_change = 1;
-        memcpy(&config, pnew_config, sizeof(config_t));
-        orders.write_config = 1;
-        cconfig_update(&config, &cconfig);
-        if(mode_change)
-            config_mode_change();
-        if(config.mode == MODE_DEBIT)
-            status.consigne_debit = cconfig.consigne_debit;
-    }
-}
-
-void config_mode_change()
-{
-    if(config.mode == MODE_FORCE_CLOSE)
-    {
-        orders.close_ev = 1;
-        status.consigne_debit = 0;
-        status.volume_manque = 0;
-    }
-    else if(config.mode == MODE_FORCE_OPEN)
-    {
-        orders.open_ev = 1;
-        status.consigne_debit = 0;
-        status.volume_manque = 0;
-    }
-    else if(config.mode == MODE_FORCE_VIDANGE)
-    {
-        orders.vidange_ev = 1;
-        status.consigne_debit = 0;
-        status.volume_manque = 0;
-    }
-    else if(config.mode == MODE_DEBIT)
-    {
-        orders.close_ev = 1;
-        status.volume_manque = 0;
-        status.consigne_debit = cconfig.consigne_debit;
-    }
-    else if(config.mode == MODE_AUTO)
-    {
-        orders.close_ev = 1;
-        status.volume_manque = 0;
-        status.accu_integrateur = 0;
-    }
-    else if(config.mode == MODE_POST_REFROI)
-    {
-        orders.close_ev = 1;
-        status.volume_manque = 0;
-        status.consigne_debit = 0;
-    }
-}

config.h

-#include "common.h"
-
-#ifndef CONFIG_H
-#define CONFIG_H 1
-
-/*[[[cog
-import avrxmegastuff
-import conf
-cog.out(f"#define EEPROM_ADDR_CONFIG {conf.EEPROM_ADDR_CONFIG}\n")
-]]]*/
-#define EEPROM_ADDR_CONFIG ((uint8_t*)0x0000)
-//[[[end]]]
-
-#include <avr/eeprom.h>
-
-typedef enum mode_enum
-{
-    MODE_FORCE_CLOSE = 0x01,
-    MODE_FORCE_OPEN = 0x02,
-    MODE_FORCE_VIDANGE = 0x03,
-    MODE_DEBIT = 0x04,
-    MODE_AUTO = 0x05,
-    MODE_POST_REFROI = 0x06,
-} mode_t;
-
-typedef struct config_struct
-{
-    uint8_t mode;
-    uint16_t vol_cuve;
-    uint16_t Kp;
-    uint16_t ti;
-    int16_t consigne_temperature;
-    uint16_t debit_max;
-    uint8_t cst_ev;
-    uint16_t debit_min1;
-    uint16_t debit_min2;
-    uint8_t minimum_step;
-    uint16_t volume_manque_max;
-    uint8_t m_rattrapage;
-    uint16_t consigne_debit;
-    int16_t post_refroi_T1;
-    int16_t post_refroi_T2;
-    int16_t post_refroi_cold_water_T1;
-    int16_t post_refroi_cold_water_T2;
-    int16_t post_refroi_hot_water_T1;
-    int16_t post_refroi_hot_water_T2;
-    uint16_t post_refroi_dmax;
-} config_t;
-
-typedef struct cconfig_struct
-{
-    mode_t mode;
-    float Kp;
-    float ti;
-    float consigne_temperature;
-    float debit_max;
-    float cst_ev;
-    float debit_min1;
-    float debit_min2;
-    uint16_t minimum_step;
-    float debit_no_action;
-    float volume_manque_max;
-    float m_rattrapage;
-    float consigne_debit;
-    float post_refroi_T1;
-    float post_refroi_T2;
-    float post_refroi_cold_water_T1;
-    float post_refroi_cold_water_T2;
-    float post_refroi_hot_water_T1;
-    float post_refroi_hot_water_T2;
-    float post_refroi_dmax;
-} cconfig_t;
-
-void config_read();
-void config_write();
-void cconfig_update(config_t *, cconfig_t *);
-void config_init();
-uint8_t config_valid(cconfig_t *);
-void config_default(config_t *);
-void config_apply_new_config(config_t *);
-void config_mode_change();
-
-extern config_t config;
-extern cconfig_t cconfig;
-
-#endif

debit.c

-
-#include "debit.h"
-
-void debit_init()
-{
-    FLOW_PORT.DIRCLR = FLOW_PIN_bm;
-    FLOW_PINCTRL = PORT_OPC_PULLUP_gc | PORT_ISC_BOTHEDGES_gc;
-    FLOW_EVSYS_CHANNELMUX = FLOW_EVSYS_CHMUX;
-    FLOW_EVSYS_CHANNELCTRL = EVSYS_DIGFILT_2SAMPLES_gc;
-
-    FLOW_COUNTER.PER=0xffff;
-    FLOW_COUNTER.CNT = 0;
-    FLOW_COUNTER.CTRLA = (FLOW_COUNTER.CTRLA & ~TC0_CLKSEL_gm) | FLOW_COUNTER_EVENT;
-
-    status.debit5.v1 = 0;
-    status.debit5.v2 = 0;
-    status.debit60.v1 = 0;
-    status.debit60.v2 = 0;
-    status.volume_manque = 0;
-    status.consigne_debit = 0;
-    status.consigne_adj = 0;
-}
-
-void debit_update()
-{
-    uint16_t count = FLOW_COUNTER.CNT;
-    FLOW_COUNTER.CNT = 0;
-    float vol_sur_seconde = 1.8500e-04*count+(2.9027e-06*count)*count;
-    float debit_insta = vol_sur_seconde*60;
-    status.volume_manque += status.consigne_debit/60-vol_sur_seconde;
-    status.fail &= ~(STATUS_FAIL_UNDERFLOW|STATUS_FAIL_OVERFLOW);
-    if(status.volume_manque > cconfig.volume_manque_max)
-    {
-        status.volume_manque = cconfig.volume_manque_max;
-        status.fail |= STATUS_FAIL_UNDERFLOW;
-    }
-    else if(status.volume_manque < - cconfig.volume_manque_max)
-    {
-        status.volume_manque = - cconfig.volume_manque_max;
-        status.fail |= STATUS_FAIL_OVERFLOW;
-    }
-
-    update_filtre2(&(status.debit5), FLOW_FACTOR_FILTRE_5, debit_insta);
-    update_filtre2(&(status.debit60), FLOW_FACTOR_FILTRE_60, debit_insta);
-
-    status.consigne_adj = status.consigne_debit + status.volume_manque/cconfig.m_rattrapage;
-    if(status.consigne_adj<0)
-        status.consigne_adj = 0;
-}
-
-void debit_vanne_update()
-{ 
-    if(cconfig.mode == MODE_AUTO || cconfig.mode == MODE_DEBIT)
-    {
-        if( (status.consigne_adj>cconfig.debit_min2) ||
-                ((status.consigne_adj>cconfig.debit_min1) && (vanne_internal_status != EV_CLOSED)))
-        {
-            float erreur = status.consigne_adj - status.debit5.v2;
-            if(erreur>0)
-            {
-                // open step
-                orders.open_ev_step_value = cconfig.cst_ev * erreur;
-                orders.open_ev_step = 1;
-            }
-            else
-            {
-                // close step
-                orders.close_ev_step_value = cconfig.cst_ev * (-erreur);
-                orders.close_ev_step = 1;
-            }
-        }
-        else
-        {
-            // close ev
-            orders.close_ev = 1;
-        }
-    }
-}

debit.h

-#include "common.h"
-
-#ifndef H_DEBIT
-#define H_DEBIT 1
-
-/*[[[cog
-import conf
-import avrxmegastuff
-
-cog.out(f"#define FLOW_PORT {conf.FLOW.port}\n")
-cog.out(f"#define FLOW_PIN_bm {conf.FLOW.pin_bm}\n")
-cog.out(f"#define FLOW_PINCTRL {conf.FLOW.pinctrl}\n")
-cog.out(f"#define FLOW_EVSYS_CHMUX {conf.FLOW.evsys_chmux_gc}\n")
-cog.out(f"#define FLOW_EVSYS_CHANNELMUX EVSYS.CH{conf.FLOW_EVSYS_CHANNEL}MUX\n")
-cog.out(f"#define FLOW_EVSYS_CHANNELCTRL EVSYS.CH{conf.FLOW_EVSYS_CHANNEL}CTRL\n")
-cog.out(f"#define FLOW_COUNTER_EVENT TC_CLKSEL_EVCH{conf.FLOW_EVSYS_CHANNEL}_gc\n")
-cog.out(f"#define FLOW_COUNTER {conf.FLOW_COUNTER}\n")
-
-cog.out("\n")
-cog.out(f"#define FLOW_FACTOR_FILTRE_5 {conf.FLOW_FACTOR_FILTRE_5:e}\n")
-cog.out(f"#define FLOW_FACTOR_FILTRE_60 {conf.FLOW_FACTOR_FILTRE_60:e}\n")
-]]] */
-#define FLOW_PORT PORTE
-#define FLOW_PIN_bm PIN2_bm
-#define FLOW_PINCTRL PORTE.PIN2CTRL
-#define FLOW_EVSYS_CHMUX EVSYS_CHMUX_PORTE_PIN2_gc
-#define FLOW_EVSYS_CHANNELMUX EVSYS.CH1MUX
-#define FLOW_EVSYS_CHANNELCTRL EVSYS.CH1CTRL
-#define FLOW_COUNTER_EVENT TC_CLKSEL_EVCH1_gc
-#define FLOW_COUNTER TCD0
-
-#define FLOW_FACTOR_FILTRE_5 1.812692e-01
-#define FLOW_FACTOR_FILTRE_60 1.652855e-02
-// [[[end]]]
-
-void debit_init();
-void debit_consigne_update(float consigne);
-void debit_update();
-void debit_vanne_update();
-
-#endif

leds.c

@@ -24,10 +24,6 @@ void led_init()
     LED_STATUS_PORT.DIRSET = LED_STATUS_PIN_bm;
     LED_TX_PORT.DIRSET = LED_TX_PIN_bm;
     LED_RX_PORT.DIRSET = LED_RX_PIN_bm;
-    LED_MOTOR_1_PORT.DIRSET = LED_MOTOR_1_PIN_bm;
-    LED_MOTOR_2_PORT.DIRSET = LED_MOTOR_2_PIN_bm;
-    LED_OVERFLOW_PORT.DIRSET = LED_OVERFLOW_PIN_bm;
-    LED_UNDERFLOW_PORT.DIRSET = LED_UNDERFLOW_PIN_bm;
 
 }
 // [[[end]]]
@@ -53,14 +49,6 @@ void led_on(led_t led)
         LED_TX_PORT.OUTSET = LED_TX_PIN_bm;
     else if(led == LED_RX)
         LED_RX_PORT.OUTSET = LED_RX_PIN_bm;
-    else if(led == LED_MOTOR_1)
-        LED_MOTOR_1_PORT.OUTSET = LED_MOTOR_1_PIN_bm;
-    else if(led == LED_MOTOR_2)
-        LED_MOTOR_2_PORT.OUTSET = LED_MOTOR_2_PIN_bm;
-    else if(led == LED_OVERFLOW)
-        LED_OVERFLOW_PORT.OUTSET = LED_OVERFLOW_PIN_bm;
-    else if(led == LED_UNDERFLOW)
-        LED_UNDERFLOW_PORT.OUTSET = LED_UNDERFLOW_PIN_bm;
     else {}
 }
 
@@ -72,14 +60,6 @@ void led_off(led_t led)
         LED_TX_PORT.OUTCLR = LED_TX_PIN_bm;
     else if(led == LED_RX)
         LED_RX_PORT.OUTCLR = LED_RX_PIN_bm;
-    else if(led == LED_MOTOR_1)
-        LED_MOTOR_1_PORT.OUTCLR = LED_MOTOR_1_PIN_bm;
-    else if(led == LED_MOTOR_2)
-        LED_MOTOR_2_PORT.OUTCLR = LED_MOTOR_2_PIN_bm;
-    else if(led == LED_OVERFLOW)
-        LED_OVERFLOW_PORT.OUTCLR = LED_OVERFLOW_PIN_bm;
-    else if(led == LED_UNDERFLOW)
-        LED_UNDERFLOW_PORT.OUTCLR = LED_UNDERFLOW_PIN_bm;
     else {}
 }
 
@@ -91,14 +71,6 @@ void led_toogle(led_t led)
         LED_TX_PORT.OUTTGL = LED_TX_PIN_bm;
     else if(led == LED_RX)
         LED_RX_PORT.OUTTGL = LED_RX_PIN_bm;
-    else if(led == LED_MOTOR_1)
-        LED_MOTOR_1_PORT.OUTTGL = LED_MOTOR_1_PIN_bm;
-    else if(led == LED_MOTOR_2)
-        LED_MOTOR_2_PORT.OUTTGL = LED_MOTOR_2_PIN_bm;
-    else if(led == LED_OVERFLOW)
-        LED_OVERFLOW_PORT.OUTTGL = LED_OVERFLOW_PIN_bm;
-    else if(led == LED_UNDERFLOW)
-        LED_UNDERFLOW_PORT.OUTTGL = LED_UNDERFLOW_PIN_bm;
     else {}
 }
 
@@ -108,44 +80,6 @@ volatile led_alert_t led_alert;
 
 void led_update()
 {
-    if(status.volume_manque > cconfig.volume_manque_max - cconfig.debit_no_action)
-        led_toogle(LED_UNDERFLOW);
-    else
-    {
-        if(status.debit5.v2 < status.consigne_adj - cconfig.debit_no_action)
-            led_on(LED_UNDERFLOW);
-        else
-            led_off(LED_UNDERFLOW);
-    }
-    if(status.volume_manque < -cconfig.volume_manque_max + cconfig.debit_no_action)
-        led_toogle(LED_OVERFLOW);
-    else
-    {
-        if(status.debit5.v2 > status.consigne_adj + cconfig.debit_no_action)
-            led_on(LED_OVERFLOW);
-        else
-            led_off(LED_OVERFLOW);
-    }
-    
-    if(led_alert.open)
-    {
-        led_toogle(LED_MOTOR_2);
-        led_alert.open--;
-    }
-    else if(vanne_internal_status == EV_OPENED)
-        led_on(LED_MOTOR_2);
-    else
-        led_off(LED_MOTOR_2);
-    
-    if(led_alert.close)
-    {
-        led_toogle(LED_MOTOR_1);
-        led_alert.close--;
-    }
-    else if(vanne_internal_status == EV_CLOSED)
-        led_on(LED_MOTOR_1);
-    else
-        led_off(LED_MOTOR_1);
     if(led_alert.tx)
     {
         led_toogle(LED_TX);

leds.h

@@ -17,14 +17,6 @@ for led_name, led_pd in conf.LED.items():
 #define LED_TX_PIN_bm PIN1_bm
 #define LED_RX_PORT PORTF
 #define LED_RX_PIN_bm PIN2_bm
-#define LED_MOTOR_1_PORT PORTF
-#define LED_MOTOR_1_PIN_bm PIN3_bm
-#define LED_MOTOR_2_PORT PORTF
-#define LED_MOTOR_2_PIN_bm PIN4_bm
-#define LED_OVERFLOW_PORT PORTF
-#define LED_OVERFLOW_PIN_bm PIN5_bm
-#define LED_UNDERFLOW_PORT PORTF
-#define LED_UNDERFLOW_PIN_bm PIN6_bm
 // [[[end]]]
 
 /*[[[cog
@@ -38,10 +30,6 @@ typedef enum leds_enum
     LED_STATUS,
     LED_TX,
     LED_RX,
-    LED_MOTOR_1,
-    LED_MOTOR_2,
-    LED_OVERFLOW,
-    LED_UNDERFLOW,
 } led_t;
 // [[[end]]]
 

main.c

@@ -8,16 +8,9 @@ int main(void)
 
     debug_init();
     status_init();
-    config_init();
-    vanne_init();
-    debit_init();
     led_init();
     main_timer_init();
 
-    uint8_t k;
-    for(k=0; k<BID; k++)
-        _delay_ms(2500);
-    
     bus_init();
 
     while(1)

main_timer.c

@@ -20,7 +20,6 @@ ISR(ACTION_TIMER_MAIN_OVF_vect)
     if(timer_each10 == 10)
     {
         timer_each10=0;
-        debit_update();
         led_toogle(LED_STATUS);
     }
     
@@ -31,13 +30,6 @@ ISR(ACTION_TIMER_MAIN_OVF_vect)
         orders.get_T = 1;
     }
 
-    timer_each100++;
-    if(timer_each100 == 100)
-    {
-        timer_each100=0;
-        debit_vanne_update();
-    }
-
     led_update();
 };
 

median_filter.c

@@ -10,7 +10,7 @@ import avrxmegastuff as ams
 /*[[[cog
 cog.out(
     ams.median_filter(
-        prefix="median_filter_thermometer",
+        prefix="median_filter_thermometer_cold",
         filter_len=conf.THERMO_MEDIAN_FILTER_LEN,
         data_type="int16_t",
         idx_type="uint8_t",
@@ -18,38 +18,38 @@ cog.out(
     )
 )
 ]]]*/
-volatile int16_t median_filter_thermometer_circbuf[MEDIAN_FILTER_THERMOMETER_len];
-volatile uint8_t median_filter_thermometer_circidx;
-volatile uint8_t median_filter_thermometer_filled;
+volatile int16_t median_filter_thermometer_cold_circbuf[MEDIAN_FILTER_THERMOMETER_COLD_len];
+volatile uint8_t median_filter_thermometer_cold_circidx;
+volatile uint8_t median_filter_thermometer_cold_filled;
 
-void median_filter_thermometer_fill(int16_t value)
+void median_filter_thermometer_cold_fill(int16_t value)
 {
-    for(median_filter_thermometer_circidx = 0; median_filter_thermometer_circidx<MEDIAN_FILTER_THERMOMETER_len; median_filter_thermometer_circidx++)
-        median_filter_thermometer_circbuf[median_filter_thermometer_circidx] = value;
-    median_filter_thermometer_circidx=0;
-    median_filter_thermometer_filled = 1;
+    for(median_filter_thermometer_cold_circidx = 0; median_filter_thermometer_cold_circidx<MEDIAN_FILTER_THERMOMETER_COLD_len; median_filter_thermometer_cold_circidx++)
+        median_filter_thermometer_cold_circbuf[median_filter_thermometer_cold_circidx] = value;
+    median_filter_thermometer_cold_circidx=0;
+    median_filter_thermometer_cold_filled = 1;
 }
 
-void median_filter_thermometer_update(int16_t value)
+void median_filter_thermometer_cold_update(int16_t value)
 {
-    median_filter_thermometer_circbuf[median_filter_thermometer_circidx] = value;
-    median_filter_thermometer_circidx++;
-    median_filter_thermometer_circidx%=MEDIAN_FILTER_THERMOMETER_len;
+    median_filter_thermometer_cold_circbuf[median_filter_thermometer_cold_circidx] = value;
+    median_filter_thermometer_cold_circidx++;
+    median_filter_thermometer_cold_circidx%=MEDIAN_FILTER_THERMOMETER_COLD_len;
 }
 
-int16_t median_filter_thermometer_read()
+int16_t median_filter_thermometer_cold_read()
 {
-    int16_t temp[MEDIAN_FILTER_THERMOMETER_len];
+    int16_t temp[MEDIAN_FILTER_THERMOMETER_COLD_len];
 
     uint8_t i;
-    for(i=0; i<MEDIAN_FILTER_THERMOMETER_len; i++)
-        temp[i] = median_filter_thermometer_circbuf[i];
+    for(i=0; i<MEDIAN_FILTER_THERMOMETER_COLD_len; i++)
+        temp[i] = median_filter_thermometer_cold_circbuf[i];
 
     uint8_t j;
 
-    for(i=0; i<=MEDIAN_FILTER_THERMOMETER_len/2; i++)
+    for(i=0; i<=MEDIAN_FILTER_THERMOMETER_COLD_len/2; i++)
     {
-        for(j=i+1; j<MEDIAN_FILTER_THERMOMETER_len; j++)
+        for(j=i+1; j<MEDIAN_FILTER_THERMOMETER_COLD_len; j++)
         {
             if(temp[i]>temp[j])
             {
@@ -60,6 +60,63 @@ int16_t median_filter_thermometer_read()
         }
     }
 
-    return temp[MEDIAN_FILTER_THERMOMETER_len/2];
+    return temp[MEDIAN_FILTER_THERMOMETER_COLD_len/2];
+}
+//[[[end]]]
+
+/*[[[cog
+cog.out(
+    ams.median_filter(
+        prefix="median_filter_thermometer_hot",
+        filter_len=conf.THERMO_MEDIAN_FILTER_LEN,
+        data_type="int16_t",
+        idx_type="uint8_t",
+        header=False,
+    )
+)
+]]]*/
+volatile int16_t median_filter_thermometer_hot_circbuf[MEDIAN_FILTER_THERMOMETER_HOT_len];
+volatile uint8_t median_filter_thermometer_hot_circidx;
+volatile uint8_t median_filter_thermometer_hot_filled;
+
+void median_filter_thermometer_hot_fill(int16_t value)
+{
+    for(median_filter_thermometer_hot_circidx = 0; median_filter_thermometer_hot_circidx<MEDIAN_FILTER_THERMOMETER_HOT_len; median_filter_thermometer_hot_circidx++)
+        median_filter_thermometer_hot_circbuf[median_filter_thermometer_hot_circidx] = value;
+    median_filter_thermometer_hot_circidx=0;
+    median_filter_thermometer_hot_filled = 1;
+}
+
+void median_filter_thermometer_hot_update(int16_t value)
+{
+    median_filter_thermometer_hot_circbuf[median_filter_thermometer_hot_circidx] = value;
+    median_filter_thermometer_hot_circidx++;
+    median_filter_thermometer_hot_circidx%=MEDIAN_FILTER_THERMOMETER_HOT_len;
+}
+
+int16_t median_filter_thermometer_hot_read()
+{
+    int16_t temp[MEDIAN_FILTER_THERMOMETER_HOT_len];
+
+    uint8_t i;
+    for(i=0; i<MEDIAN_FILTER_THERMOMETER_HOT_len; i++)
+        temp[i] = median_filter_thermometer_hot_circbuf[i];
+
+    uint8_t j;
+
+    for(i=0; i<=MEDIAN_FILTER_THERMOMETER_HOT_len/2; i++)
+    {
+        for(j=i+1; j<MEDIAN_FILTER_THERMOMETER_HOT_len; j++)
+        {
+            if(temp[i]>temp[j])
+            {
+                int16_t swap = temp[i];
+                temp[i] = temp[j];
+                temp[j] = swap;
+            }
+        }
+    }
+
+    return temp[MEDIAN_FILTER_THERMOMETER_HOT_len/2];
 }
 //[[[end]]]

median_filter.h

@@ -10,7 +10,7 @@ import avrxmegastuff as ams
 /*[[[cog
 cog.out(
     ams.median_filter(
-        prefix="median_filter_thermometer",
+        prefix="median_filter_thermometer_cold",
         filter_len=conf.THERMO_MEDIAN_FILTER_LEN,
         data_type="int16_t",
         idx_type="uint8_t",
@@ -18,15 +18,39 @@ cog.out(
     )
 )
 ]]]*/
-#ifndef H_MF_median_filter_thermometer
-#define H_MF_median_filter_thermometer 1
+#ifndef H_MF_median_filter_thermometer_cold
+#define H_MF_median_filter_thermometer_cold 1
 
-#define MEDIAN_FILTER_THERMOMETER_len 13
+#define MEDIAN_FILTER_THERMOMETER_COLD_len 13
 
-void median_filter_thermometer_fill(int16_t);
-void median_filter_thermometer_update(int16_t);
-int16_t median_filter_thermometer_read();
+void median_filter_thermometer_cold_fill(int16_t);
+void median_filter_thermometer_cold_update(int16_t);
+int16_t median_filter_thermometer_cold_read();
 
-extern volatile uint8_t median_filter_thermometer_filled;
+extern volatile uint8_t median_filter_thermometer_cold_filled;
+#endif
+//[[[end]]]
+
+/*[[[cog
+cog.out(
+    ams.median_filter(
+        prefix="median_filter_thermometer_hot",
+        filter_len=conf.THERMO_MEDIAN_FILTER_LEN,
+        data_type="int16_t",
+        idx_type="uint8_t",
+        header=True,
+    )
+)
+]]]*/
+#ifndef H_MF_median_filter_thermometer_hot
+#define H_MF_median_filter_thermometer_hot 1
+
+#define MEDIAN_FILTER_THERMOMETER_HOT_len 13
+
+void median_filter_thermometer_hot_fill(int16_t);
+void median_filter_thermometer_hot_update(int16_t);
+int16_t median_filter_thermometer_hot_read();
+
+extern volatile uint8_t median_filter_thermometer_hot_filled;
 #endif
 //[[[end]]]

messages.c

@@ -3,163 +3,26 @@
 uint8_t get_packet(char * z, uint8_t pid)
 {
     uint8_to_2char(pid,z);
-    if(pid == 0x01)
-    {
-        uint8_to_2char(status.fail, z+2);
-        return 4;
-    }
-    if(pid == 0x02)
-    {
-        int16_t itemp = (status.temperature.v2 * 100 + .5);
-        uint16_to_4char((uint16_t)itemp, z+2);
-        return 6;
-    }
-    if(pid == 0x03)
-    {
-        uint16_to_4char((uint16_t)status.temperature_insta, z+2);
-        return 6;
-    }
-    if(pid == 0x04)
-    {
-        uint16_to_4char((uint16_t)(status.debit60.v2 * 100 + .5), z+2);
-        return 6;
-    }
-    if(pid == 0x05)
-    {
-        uint16_to_4char((uint16_t)(status.debit5.v2 * 100 + .5), z+2);
-        return 6;
-    }
-    if(pid == 0x06)
-    {
-        uint16_to_4char((uint16_t)(status.volume_manque * 100 + .5), z+2);
-        return 6;
-    }
-    if(pid == 0x07)
-    {
-        uint16_to_4char((uint16_t)(status.consigne_debit * 100 + .5), z+2);
-        return 6;
-    }
-    if(pid == 0x08)
-    {
-        uint16_to_4char((uint16_t)(status.consigne_adj * 100 + .5), z+2);
-        return 6;
-    }
-    if(pid == 0x09)
-    {
-        uint16_to_4char((uint16_t)(status.accu_integrateur * 1000 + .5), z+2);
-        return 6;
-    }
     if(pid == 0x0a)
     {
-        int16_t icwtemp = (status.temperature_cold_water * 100 + .5);
+        int16_t icwtemp = (status.temperature_cold.v2 * 100 + .5);
         uint16_to_4char((uint16_t)icwtemp, z+2);
         return 6;
     }
     if(pid == 0x0b)
     {
-        int16_t ichtemp = (status.temperature_hot_water * 100 + .5);
+        int16_t ichtemp = (status.temperature_hot.v2 * 100 + .5);
         uint16_to_4char((uint16_t)ichtemp, z+2);
         return 6;
     }
-
-    if(pid == 0x80)
-    {
-        uint8_to_2char((uint8_t)config.mode, z+2);
-        return 4;
-    }
-    if(pid == 0x81)
-    {
-        uint16_to_4char(config.vol_cuve, z+2);
-        return 6;
-    }
-    if(pid == 0x82)
+    if(pid == 0x0c)
     {
-        uint16_to_4char(config.Kp, z+2);
+        uint16_to_4char((uint16_t)status.temperature_cold_insta, z+2);
         return 6;
     }
-    if(pid == 0x83)
+    if(pid == 0x0d)
     {
-        uint16_to_4char(config.ti, z+2);
-        return 6;
-    }
-    if(pid == 0x84)
-    {
-        uint16_to_4char(config.consigne_temperature, z+2);
-        return 6;
-    }
-    if(pid == 0x85)
-    {
-        uint16_to_4char(config.debit_max, z+2);
-        return 6;
-    }
-    if(pid == 0x86)
-    {
-        uint8_to_2char(config.cst_ev, z+2);
-        return 4;
-    }
-    if(pid == 0x88)
-    {
-        uint8_to_2char(config.minimum_step, z+2);
-        return 4;
-    }
-    if(pid == 0x89)
-    {
-        uint16_to_4char(config.volume_manque_max, z+2);
-        return 6;
-    }
-    if(pid == 0x8a)
-    {
-        uint8_to_2char(config.m_rattrapage, z+2);
-        return 4;
-    }
-    if(pid == 0x8b)
-    {
-        uint16_to_4char(config.consigne_debit, z+2);
-        return 6;
-    }
-    if(pid == 0x8c)
-    {
-        uint16_to_4char(config.debit_min1, z+2);
-        return 6;
-    }
-    if(pid == 0x8d)
-    {
-        uint16_to_4char(config.debit_min2, z+2);
-        return 6;
-    }
-    if(pid == 0x8e)
-    {
-        uint16_to_4char(config.post_refroi_T1, z+2);
-        return 6;
-    }
-    if(pid == 0x8f)
-    {
-        uint16_to_4char(config.post_refroi_T1, z+2);
-        return 6;
-    }
-    if(pid == 0x90)
-    {
-        uint16_to_4char(config.post_refroi_cold_water_T1, z+2);
-        return 6;
-    }
-    if(pid == 0x91)
-    {
-        uint16_to_4char(config.post_refroi_cold_water_T2, z+2);
-        return 6;
-    }
-    if(pid == 0x92)
-    {
-        uint16_to_4char(config.post_refroi_hot_water_T1, z+2);
-        return 6;
-    }
-    if(pid == 0x93)
-    {
-        uint16_to_4char(config.post_refroi_hot_water_T2, z+2);
-        return 6;
-    }
-    if(pid == 0x94)
-    {
-        uint16_to_4char(config.post_refroi_dmax, z+2);
+        uint16_to_4char((uint16_t)status.temperature_hot_insta, z+2);
         return 6;
     }
     if(pid == 0xb1)
@@ -199,60 +62,11 @@ void message_send()
     out = sep.join(
         lines.format(packet_id=pid)
         for pid in (
-            "0x01", "0x02", "0x03", "0x04", "0x05", "0x06", "0x07", "0x08", 
-            "0x09", "0x0a", "0x0b",
-            "0x80", "0x81", "0x82", "0x83", "0x84", "0x85", "0x86",
-            "0x88", "0x89", "0x8a", "0x8b", "0x8c", "0x8d", "0x8e",
-            "0x8f", "0x90", "0x91", "0x92", "0x93", "0x94",
-            "0xb1")
+            "0x0a", "0x0b", "0x0c", "0x0d",
+        )
     )
     cog.out(out)
     ]]]*/
-    packet_len = get_packet(msg+msg_len, 0x01);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x02);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x03);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x04);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x05);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x06);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x07);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x08);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x09);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
     packet_len = get_packet(msg+msg_len, 0x0a);
     msg_len += packet_len;
 
@@ -263,107 +77,12 @@ void message_send()
 
     msg[msg_len] = ',';
     msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x80);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x81);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x82);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x83);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x84);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x85);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x86);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x88);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x89);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8a);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8b);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8c);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8d);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8e);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x8f);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x90);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x91);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x92);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x93);
-    msg_len += packet_len;
-
-    msg[msg_len] = ',';
-    msg_len++;
-    packet_len = get_packet(msg+msg_len, 0x94);
+    packet_len = get_packet(msg+msg_len, 0x0c);
     msg_len += packet_len;
 
     msg[msg_len] = ',';
     msg_len++;
-    packet_len = get_packet(msg+msg_len, 0xb1);
+    packet_len = get_packet(msg+msg_len, 0x0d);
     msg_len += packet_len;
 
     ///[[[end]]]
@@ -388,19 +107,10 @@ void message_send()
 
 void message_get(const char* msg)
 {
-    uint8_t message_from_master = 0;
     if(msg[0] != 'M' || msg[1] != ',')
-    {
-        message_from_master = 1;
-        if(msg[2] != BID_C0 || msg[3] != BID_C1)
-            return; // ce n'est pas à moi qu'on parle
-    }
-    else
-    {
-        if(msg[2] != BID_WATER_C0 || msg[3] != BID_WATER_C1)
-            return; // ce n'est pas WATER qui parle, et à part lui, je n'écoute
-                    // que le master
-    }
+        return; // ce n'est pas master qui parle
+    if(msg[2] != BID_C0 || msg[3] != BID_C1)
+        return; // ce n'est pas à moi qu'on parle
     if(msg[4] != ',' && msg[4] != ':')
         return; //message mal formaté
     uint16_t crc = 0xFFFF;
@@ -422,215 +132,7 @@ void message_get(const char* msg)
     if(zcrc[0] != msg[msg_len] || zcrc[1] != msg[msg_len+1] || zcrc[2] != msg[msg_len+2] || zcrc[3] != msg[msg_len+3])
         return; // invalid message
 
-    if(message_from_master)
-    {
-        if(msg_len>5)
-        {
-            config_t new_config;
-            memcpy(&new_config, &config, sizeof(config_t));
-            uint8_t pos = 5;
-            while(pos<msg_len)
-            {
-                for(k=0; pos+k<msg_len; k++)
-                    if(msg[pos+k] == ',' || msg[pos+k] == ':')
-                        break;
-                readed_packet(msg+pos, k, &new_config);
-                pos += k+1;
-                if(msg[pos-1] == ':')
-                    break;
-            }
-            if(memcmp(&new_config, &config, sizeof(config_t)))
-            {
-                cconfig_t new_cconfig;
-                cconfig_update(&new_config, &new_cconfig);
-                if(config_valid(&new_cconfig))
-                    config_apply_new_config(&new_config);
-            }
-        }
-
-        // we can reply
-        message_send();
-    }
-    else
-    {
-        if(msg_len>5)
-        {
-            uint8_t pos = 5;
-            while(pos<msg_len)
-            {
-                for(k=0; pos+k<msg_len; k++)
-                    if(msg[pos+k] == ',' || msg[pos+k] == ':')
-                        break;
-                update_temp_readed_status_packet(msg+pos, k);
-                pos += k+1;
-            }
-        }
-    }
-}
-
-void update_temp_readed_status_packet(const char *z, uint8_t len)
-{
-    if(len<2)
-        return;
-    uint8_t pid = uint8_from_2char(z);
-    if(pid == 0x0a)
-    {
-        if(len!=6)
-            return;
-        status.temperature_cold_water = 0.01*uint16_from_4char(z+2);
-    }
-    if(pid == 0x0b)
-    {
-        if(len!=6)
-            return;
-        status.temperature_hot_water = 0.01*uint16_from_4char(z+2);
-    }
+    // we can reply
+    message_send();
 }
 
-
-void readed_packet(const char * z, uint8_t len, config_t * nc)
-{
-    if(len<2)
-        return;
-    uint8_t pid = uint8_from_2char(z);
-    if(pid == 0x80)
-    {
-        if(len!=4)
-            return;
-        nc->mode = (mode_t)uint8_from_2char(z+2);
-        return;
-    }
-    if(pid == 0x81)
-    {
-        if(len!=6)
-            return;
-        nc->vol_cuve = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x82)
-    {
-        if(len!=6)
-            return;
-        nc->Kp = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x83)
-    {
-        if(len!=6)
-            return;
-        nc->ti = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x84)
-    {
-        if(len!=6)
-            return;
-        nc->consigne_temperature = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x85)
-    {
-        if(len!=6)
-            return;
-        nc->debit_max = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x86)
-    {
-        if(len!=4)
-            return;
-        nc->cst_ev = uint8_from_2char(z+2);
-        return;
-    }
-    if(pid == 0x88)
-    {
-        if(len!=4)
-            return;
-        nc->minimum_step = uint8_from_2char(z+2);
-        return;
-    }
-    if(pid == 0x89)
-    {
-        if(len!=6)
-            return;
-        nc->volume_manque_max = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x8a)
-    {
-        if(len!=4)
-            return;
-        nc->m_rattrapage = uint8_from_2char(z+2);
-        return;
-    }
-    if(pid == 0x8b)
-    {
-        if(len!=6)
-            return;
-        nc->consigne_debit = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x8c)
-    {
-        if(len!=6)
-            return;
-        nc->debit_min1 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x8d)
-    {
-        if(len!=6)
-            return;
-        nc->debit_min2 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x8e)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_T1 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x8f)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_T2 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x90)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_cold_water_T1 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x91)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_cold_water_T2 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x92)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_hot_water_T1 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x93)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_hot_water_T2 = uint16_from_4char(z+2);
-        return;
-    }
-    if(pid == 0x94)
-    {
-        if(len!=6)
-            return;
-        nc->post_refroi_dmax = uint16_from_4char(z+2);
-        return;
-    }
-}

messages.h

@@ -8,17 +8,5 @@
 uint8_t get_packet(char * z, uint8_t pid);
 void message_send();
 void message_get(const char* msg);
-void readed_packet(const char * z, uint8_t len, config_t * nc);
-void update_temp_readed_status_packet(const char *z, uint8_t len);
-
-/*[[[cog
-import conf
-hbid_water = f"{conf.BID_WATER:02x}"
-cog.out(f"#define BID_WATER_C0 '{hbid_water[0]}'\n")
-cog.out(f"#define BID_WATER_C1 '{hbid_water[1]}'\n")
-]]] */
-#define BID_WATER_C0 'c'
-#define BID_WATER_C1 '0'
-//[[[end]]]
 
 #endif

orders.c

@@ -4,36 +4,6 @@ orders_t orders;
 
 void do_orders()
 {
-    if(orders.open_ev_step)
-    {
-        vanne_step_open(orders.open_ev_step_value);
-        orders.open_ev_step = 0;
-    }
-    if(orders.close_ev_step)
-    {
-        vanne_step_close(orders.close_ev_step_value);
-        orders.close_ev_step = 0;
-    }
-    if(orders.open_ev)
-    {
-        vanne_open();
-        orders.open_ev=0;
-    }
-    if(orders.close_ev)
-    {
-        vanne_close();
-        orders.close_ev=0;
-    }
-    if(orders.vidange_ev)
-    {
-        vanne_vidange();
-        orders.vidange_ev=0;
-    }
-    if(orders.write_config)
-    {
-        orders.write_config=0;
-        config_write();
-    }
     if(orders.get_T)
     {
         orders.get_T=0;
@@ -41,10 +11,19 @@ void do_orders()
         int16_t temp;
         uint8_t status_thermo;
         uint8_t tries=0;
+        status.last_measure = (status.last_measure+1)%2;
         while(1)
         {
-            status_thermo = thermometer_gettemp(&temp,1000);
-            debug_printf("get temp, status = %u\n", status_thermo);
+            if(status.last_measure==0)
+            {
+                status_thermo = thermometer_cold_gettemp(&temp,1000);
+                debug_printf("get temp cold, status = %u\n", status_thermo);
+            }
+            else
+            {
+                status_thermo = thermometer_cold_gettemp(&temp,1000);
+                debug_printf("get temp hot, status = %u\n", status_thermo);
+            }
             if(status_thermo==0)
                 break;
             tries++;
@@ -53,72 +32,64 @@ void do_orders()
         }
         if(status_thermo > 0)
         {
-            if(status.fail_get_T >= THERMO_FAIL_NUMBER)
-                status.fail |= STATUS_FAIL_T;
+            if(status.last_measure==0)
+            {
+                if(status.fail_get_T_cold >= THERMO_FAIL_NUMBER)
+                    status.fail |= STATUS_FAIL_T_COLD;
+                else
+                    status.fail_get_T_cold++;
+            }
             else
-                status.fail_get_T++;
-        }
-        else
-        {
-            status.fail_get_T = 0;
-            status.fail &= ~STATUS_FAIL_T;
-            status.temperature_insta = temp;
-            if(!median_filter_thermometer_filled)
             {
-                median_filter_thermometer_fill(temp);
-                status.temperature.v1 = status.temperature.v2 = .0625*temp;
+                if(status.fail_get_T_hot >= THERMO_FAIL_NUMBER)
+                    status.fail |= STATUS_FAIL_T_HOT;
+                else
+                    status.fail_get_T_hot++;
             }
         }
-        if(median_filter_thermometer_filled)
+        else
         {
-            median_filter_thermometer_update(status.temperature_insta);
-            float Tinstamf = .0625*median_filter_thermometer_read();
-            update_filtre2(&(status.temperature), THERMO_FACTOR_FILTRE, Tinstamf);
-
-            float consigne_debit;
 
-            if(cconfig.mode == MODE_AUTO)
+            if(status.last_measure==0)
             {
-                float temperature_diff = status.temperature.v2 - cconfig.consigne_temperature;
-                status.accu_integrateur += temperature_diff * 5 / cconfig.ti;
-                float max_integrateur = cconfig.debit_max/cconfig.Kp - temperature_diff;
-                if(max_integrateur<0)
-                    max_integrateur = 0;
-                if(status.accu_integrateur>max_integrateur)
-                    status.accu_integrateur = max_integrateur;
-                if(status.accu_integrateur<0)
-                    status.accu_integrateur = 0;
-                consigne_debit = cconfig.Kp * (temperature_diff + status.accu_integrateur);
-                if(consigne_debit>cconfig.debit_max)
-                    consigne_debit = cconfig.debit_max;
-                if(consigne_debit < 0)
+                status.fail_get_T_cold = 0;
+                status.fail &= ~STATUS_FAIL_T_COLD;
+                status.temperature_cold_insta = temp;
+                if(!median_filter_thermometer_cold_filled)
                 {
-                    status.consigne_debit = 0;
-                    status.volume_manque = 0;
+                    median_filter_thermometer_cold_fill(temp);
+                    status.temperature_cold.v1 = status.temperature_cold.v2 = .0625*temp;
                 }
-                else
-                    status.consigne_debit = consigne_debit;
             }
-            else if(cconfig.mode == MODE_POST_REFROI)
+            else
             {
-                if(status.temperature.v2>cconfig.post_refroi_T2)
-                    consigne_debit = cconfig.post_refroi_dmax;
-                else if(status.temperature.v2<cconfig.post_refroi_T1)
-                    consigne_debit = 0;
-                else
-                    consigne_debit = (status.temperature.v2-cconfig.post_refroi_T1)/(cconfig.post_refroi_T2-cconfig.post_refroi_T1)*cconfig.post_refroi_dmax;
-                if (status.temperature_cold_water > cconfig.post_refroi_cold_water_T2)
-                    consigne_debit = 0;
-                else if(status.temperature_cold_water > cconfig.post_refroi_cold_water_T1)
-                    consigne_debit *= (status.temperature_cold_water-cconfig.post_refroi_cold_water_T1)/(cconfig.post_refroi_cold_water_T2-cconfig.post_refroi_cold_water_T1);
-                if (status.temperature_hot_water > cconfig.post_refroi_hot_water_T2)
-                    consigne_debit = 0;
-                else if(status.temperature_hot_water > cconfig.post_refroi_hot_water_T1)
-                    consigne_debit *= (status.temperature_hot_water-cconfig.post_refroi_hot_water_T1)/(cconfig.post_refroi_hot_water_T2-cconfig.post_refroi_hot_water_T1);
-                if(consigne_debit < 0)
-                    status.consigne_debit = 0;
-                else
-                    status.consigne_debit = consigne_debit;
+                status.fail_get_T_hot = 0;
+                status.fail &= ~STATUS_FAIL_T_HOT;
+                status.temperature_hot_insta = temp;
+                if(!median_filter_thermometer_hot_filled)
+                {
+                    median_filter_thermometer_hot_fill(temp);
+                    status.temperature_hot.v1 = status.temperature_hot.v2 = .0625*temp;
+                }
+            }
+        }
+
+        if(status.last_measure==0)
+        {
+            if(median_filter_thermometer_cold_filled)
+            {
+                median_filter_thermometer_cold_update(status.temperature_cold_insta);
+                float Tinstamf = .0625*median_filter_thermometer_cold_read();
+                update_filtre2(&(status.temperature_cold), THERMO_FACTOR_FILTRE, Tinstamf);
+            }
+        }
+        else
+        {
+            if(median_filter_thermometer_hot_filled)
+            {
+                median_filter_thermometer_hot_update(status.temperature_hot_insta);
+                float Tinstamf = .0625*median_filter_thermometer_hot_read();
+                update_filtre2(&(status.temperature_hot), THERMO_FACTOR_FILTRE, Tinstamf);
             }
         }
     }

orders.h

@@ -5,15 +5,7 @@
 
 typedef struct orders_struct
 {
-    uint8_t open_ev_step;
-    uint16_t open_ev_step_value;
-    uint8_t close_ev_step;
-    uint16_t close_ev_step_value;
-    uint8_t open_ev;
-    uint8_t close_ev;
-    uint8_t vidange_ev;
     uint8_t get_T;
-    uint8_t write_config;
 } orders_t;
 
 extern orders_t orders;

status.c

@@ -4,15 +4,14 @@ status_t status;
 
 void status_init()
 {
-    status.temperature.v1 = 0;
-    status.temperature.v2 = 0;
-    status.debit60.v1 = 0;
-    status.debit60.v2 = 0;
-    status.debit5.v1 = 0;
-    status.debit5.v2 = 0;
-    status.volume_manque = 0;
-    status.accu_integrateur = 0;
+    status.last_measure = 0;
+    status.temperature_cold.v1 = 0;
+    status.temperature_cold.v2 = 0;
+    status.temperature_hot.v1 = 0;
+    status.temperature_hot.v2 = 0;
+    status.temperature_cold_insta = 0;
+    status.temperature_hot_insta = 0;
+    status.fail_get_T_cold = 0;
+    status.fail_get_T_hot = 0;
     status.fail = 0;
-    status.temperature_cold_water = 20;
-    status.temperature_hot_water = 20;
 }

status.h

@@ -3,24 +3,19 @@
 #ifndef STATUS_H
 #define STATUS_H 1
 
-#define STATUS_FAIL_T (0x01)
-#define STATUS_FAIL_UNDERFLOW (0x01<<1)
-#define STATUS_FAIL_OVERFLOW (0x01<<2)
+#define STATUS_FAIL_T_COLD (0x01)
+#define STATUS_FAIL_T_HOT (0x01<<1)
 
 typedef struct status_struct
 {
-    int16_t temperature_insta;
-    filtre2_t temperature;
-    filtre2_t debit5;
-    filtre2_t debit60;
-    float volume_manque;
-    float consigne_debit;
-    float consigne_adj;
-    float accu_integrateur;
+    uint8_t last_measure;
+    int16_t temperature_cold_insta;
+    int16_t temperature_hot_insta;
+    filtre2_t temperature_cold;
+    filtre2_t temperature_hot;
+    uint16_t fail_get_T_cold;
+    uint16_t fail_get_T_hot;
     uint8_t fail;
-    uint16_t fail_get_T;
-    float temperature_cold_water;
-    float temperature_hot_water;
 } status_t;
 
 extern status_t status;

thermometer.h

-#include "common.h"
-
-/*[[[cog
-import conf
-import avrxmegastuff as ams
-]]]*/
-//[[[end]]]
-
-
-/*[[[cog
-cog.out(
-    ams.ds18b20(
-        prefix="thermometer",
-        pindesc=conf.SENSOR_T,
-        header=True,
-    )
-)
-]]]*/
-#ifndef H_DS18B20_thermometer
-#define H_DS18B20_thermometer 1
-
-#define THERMOMETER_port PORTE
-#define THERMOMETER_pin PIN5_bm
-#define THERMOMETER_CMD_CONVERTTEMP 0x44
-#define THERMOMETER_CMD_RSCRATCHPAD 0xbe
-#define THERMOMETER_CMD_WSCRATCHPAD 0x4e
-#define THERMOMETER_CMD_CPYSCRATCHPAD 0x48
-#define THERMOMETER_CMD_RECEEPROM 0xb8
-#define THERMOMETER_CMD_RPWRSUPPLY 0xb4
-#define THERMOMETER_CMD_SEARCHROM 0xf0
-#define THERMOMETER_CMD_READROM 0x33
-#define THERMOMETER_CMD_MATCHROM 0x55
-#define THERMOMETER_CMD_SKIPROM 0xcc
-#define THERMOMETER_CMD_ALARMSEARCH 0xec
-
-#include <util/delay.h>
-#include <util/crc16.h>
-
-uint8_t thermometer_reset();
-void thermometer_writebit(uint8_t bit);
-uint8_t thermometer_readbit(void);
-void thermometer_writebyte(uint8_t byte);
-uint8_t thermometer_readbyte(void);
-int8_t thermometer_gettemp(int16_t* temp, uint16_t timeout_ms);
-#endif
-///[[[end]]]