diagram.json

import machine

flame_timer = 0
flame_last = 0.0
glowing_on = False
water_temp = 25.0  # Replace with the actual water temperature or a sensor reading if needed

# GPIO pins setup
glow_plug_pin = 14  # pin for the glow plug control
push_pin = 32       # ADC pin for battery voltage reading
flame_sensor_pin = 36  # ADC pin for flame sensor reading
fuel_pump_pin = 27 # pin for fuel pump control
burn_fan_pin = 12 # pin for combustion fan control
water_pump_pin = 15 # pin for water circulation pump
water_temp_pin = 34 # ADC pin for water temperature sensor reading
Room_Temp_pin = 39  # ADC pin for room temperature sensor reading
soliniod = 21 # pin for heater valve control
over_temp = 32 # pin for over temerature sense

interrupt_pin = machine.Pin(32, machine.Pin.IN)  # Pin 32 for interrupt with pull-up

#ADC Setup
adc_batt = machine.ADC(machine.Pin(push_pin))
adc_batt.width(machine.ADC.WIDTH_10BIT)
adc_batt.atten(machine.ADC.ATTN_11DB)

adc_flame = machine.ADC(machine.Pin(flame_sensor_pin))
adc_flame.width(machine.ADC.WIDTH_10BIT)
adc_flame.atten(machine.ADC.ATTN_11DB)

# Setup GPIO for glow plug, burn fan & fuel pump
glow_plug = machine.Pin(glow_plug_pin, machine.Pin.OUT)
burn_fan = machine.Pin(burn_fan_pin, machine.Pin.OUT)
fuel_pump = machine.Pin(fuel_pump_pin, machine.Pin.OUT)

# timers(e.g., 1000 Hz, 1000 ms)
clear_chamber_time = 3000 
glow_plug_on_time = 5000
no_start_low_batt_volts = 9.9

# PMW values
clear_chamber_pwm = 70
wait_for_glowplug_pwm = 40

config.py

import time
import config


adc_flame = config.adc_flame




# Calibration data for flame detect voltage (raw ADC Value, Current Display
calibration_data_flame = [
    (0, 0.0),
    (512, 1.65),
    (587, 3.3)
]


def flame_volts(adc, samples=10):
    def analog_read(adc_flame):
        return adc.read()

    def sample_adc(adc, samples):
        total = 0
        for _ in range(samples):
            total += analog_read(adc)
            time.sleep(0.001)  # Short delay between samples
        average = total // samples
        return average

    def linear_interpolation(raw_value, calibration_points):
        for i in range(len(calibration_points) - 1):
            x0, y0 = calibration_points[i]
            x1, y1 = calibration_points[i + 1]
            if x0 <= raw_value <= x1:
                # Perform linear interpolation
                slope = (y1 - y0) / (x1 - x0)
                flame_volts = y0 + slope * (raw_value - x0)
                return flame_volts
        return None  # Return None if raw_value is out of bounds

    # Sample ADC and calculate average
    raw_value = sample_adc(adc, samples)
    
    # Perform linear interpolation
    glow_current = linear_interpolation(raw_value, calibration_data_flame)
    if glow_current is None:
        print("Error: glow sense voltage out of calibration range.")
        return -99.0
    
    #print("Glow Plug Current: {:.1f} V".format(glow_current))
    
    return glow_current


current.py

import time
import volts
import current
import config



# Constants
adc_batt = config.adc_batt
adc_flame = config.adc_flame
value = 0
glow_ohms = 0

FLAME_TIMER = config.flame_timer
FLAME_LAST = config.flame_last
GLOWING_ON = config.glowing_on
WATER_TEMP = config.water_temp # Replace with the actual water temperature or a sensor reading if needed

# GPIO pins setup

glow_plug = config.glow_plug

def millis():
    return int(time.ticks_ms())


def flame_temp_read():
    import volts
    global FLAME_TIMER, FLAME_LAST, GLOWING_ON, WATER_TEMP

    if (millis() - FLAME_TIMER) < 1000:
        glow_plug.value(0)  # Turn off the glow plug
        return FLAME_LAST

    FLAME_TIMER = millis()
    if GLOWING_ON:
        return -99.0  # Cannot take a reading if the glow plug is switched on

    # Call for battery voltage:
    battery_voltage = volts.batt_volts(adc_batt)
    
    #Print battery voltage 
    #print("Battery Voltage: {:.1f} V".format(battery_voltage))

  
    # Measure the initial votage on the FET sense pin
    #initial_reading_avg = volts.batt_volts(adc_flame)

    # Turn on the glow plug briefly
    glow_plug.value(1)
    time.sleep(1.000)

    # Measure the voltage on the FET sense  pin
    glow_amps = current.flame_volts(adc_flame)
    
    #Print raw adc value for calibration procedure 
    #print("Glowplug Current: {:.1f} A".format(glow_amps))

    
    # Turn off the glow plug
    glow_plug.value(0)

    # Calculate the current in amps
    #glow_amps = (glow_plug_current)

    # Ensure glow_amps is not zero to avoid division by zero
    if glow_amps != 0:
        glow_ohms = battery_voltage / glow_amps
        flame_last = ((1300.0 - 25.0) / (1.6 - 0.342) * (glow_ohms - 0.40) / 2)
        flame_last = WATER_TEMP / 1.48 + flame_last  # Adjust with water temperature
    else:
        glow_ohms = float('inf')
        flame_last = float('inf')  # Or some other default value indicating an error

    # Print readings for debugging
    print("Battery Voltage: {:.2f} V".format(battery_voltage))
    #print("Flame Voltage: {:.2f} V".format(flame_voltage))
    print("Glow Plug Current: {:.2f} A".format(glow_amps))
    print("Glow Resistance: {:.2f} Ohms".format(glow_ohms))
    print("Flame Temperature: {:.2f} °C".format(flame_last))

    FLAME_LAST = flame_last
    return flame_last

flame.py

import time
import config



adc_batt = config.adc_batt


# Calibration data for battery voltage, (raw ADC Value, voltage Display)
calibration_data_batt = [
    (387, 8.0),
    (429, 9.0),
    (464, 10.0),
    (493, 11.0),
    (506, 11.5),
    (519, 12.0),
    (529, 12.5),
    (540, 13.0),
    (559, 14.0),
    (575, 15.0),
    (587, 16.0)
]




def batt_volts(adc, samples=10):
    def analog_read(adc_batt):
        return adc.read()

    def sample_adc(adc, samples):
        total = 0
        for _ in range(samples):
            total += analog_read(adc)
            time.sleep(0.001)  # Short delay between samples
        average = total // samples
        return average

    def linear_interpolation(raw_value, calibration_points):
        for i in range(len(calibration_points) - 1):
            x0, y0 = calibration_points[i]
            x1, y1 = calibration_points[i + 1]
            if x0 <= raw_value <= x1:
                # Perform linear interpolation
                slope = (y1 - y0) / (x1 - x0)
                battery_volts = y0 + slope * (raw_value - x0)
                return battery_volts
        return None  # Return None if raw_value is out of bounds

    # Sample ADC and calculate average
    raw_value = sample_adc(adc, samples)
    
    # Perform linear interpolation
    battery_voltage = linear_interpolation(raw_value, calibration_data_batt)
    if battery_voltage is None:
        print("Error: Battery voltage out of calibration range.")
        return -99.0
    
    #print("Battery Voltage: {:.1f} V".format(battery_voltage))
    
    return battery_voltage

























volts.py

webrepl_cfg.py

from machine import Pin, Timer
import utime
import config

class FuelPumpController:
    def __init__(self, get_power_demand, state):
        self.fuel_pump_pin = Pin(config.fuel_pump, Pin.OUT)
        self.get_power_demand = get_power_demand
        self.state = state
        self.lookup_table_hz = [1, 1.1, 1.1, 1.3, 1.67, 2, 2.5, 3.33, 5, 10]
        self.pump_on = False
        self.next_pulse_time = 0
        self.timer = Timer(-1)
        self.fan_duty_cycle = 0  # Initialize fan duty cycle

    def hz_to_ms(self, frequency):
        return 1000 / frequency

    def interpolate_pulse_frequency(self, power_demand):
        if power_demand < 0:
            power_demand = 0
        elif power_demand > 100:
            power_demand = 100
        lower_index = power_demand // 10
        upper_index = lower_index + 1 if lower_index < len(self.lookup_table_hz) - 1 else lower_index
        fraction = (power_demand % 10) / 10.0
        lower_value = self.lookup_table_hz[lower_index]
        upper_value = self.lookup_table_hz[upper_index]
        interpolated_value = lower_value + (upper_value - lower_value) * fraction
        return interpolated_value

    def update_fuel_pump(self):
        # Use self.fan_duty_cycle to adjust fuel pump logic if needed
        power_demand = self.fan_duty_cycle
        self.state['pulse_frequency'] = self.interpolate_pulse_frequency(power_demand)
        pulse_interval = self.hz_to_ms(self.state['pulse_frequency'])
        if not self.pump_on:
            self.start_fuel_pump()
        else:
            self.next_pulse_time = utime.ticks_add(utime.ticks_ms(), int(pulse_interval))

    def stop_fuel_pump(self, timer):
        self.fuel_pump_pin.off()
        self.pump_on = False

    def start_fuel_pump(self):
        self.fuel_pump_pin.on()
        self.pump_on = True
        self.timer.init(period=100, mode=Timer.ONE_SHOT, callback=self.stop_fuel_pump)

    def set_fan_duty_cycle(self, duty_cycle):
        self.fan_duty_cycle = duty_cycle
        self.update_fuel_pump()




fuel_pump_controller.py

from machine import Pin, PWM
import volts
import config

class FanController:
    def __init__(self, burn_fan_pin, adc_pin):
        self.burn_fan_pin = burn_fan_pin
        self.adc_pin = adc_pin
        self.fan_pwm = PWM(Pin(self.burn_fan_pin))
        self.fan_pwm.freq(1000)  # Set PWM frequency to 1000 Hz
        self.voltage_to_duty_cycle_table = {
            10.0: 1,
            11.0: 0.95,
            12.0: 0.9,
            13.0: 0.84,
            14.0: 0.72
        }
        self.current_duty_cycle = 0  # Initialize current duty cycle
        self.demanded_duty_cycle = 0  # Initialize demanded duty cycle

    def map_value(self, x, in_min, in_max, out_min, out_max):
        return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min

    def interpolate_duty_cycle(self, voltage, table):
        voltages = sorted(table.keys())
        duty_cycles = [table[v] for v in voltages]
        
        if voltage <= voltages[0]:
            return duty_cycles[0]
        elif voltage >= voltages[-1]:
            return duty_cycles[-1]
        else:
            for i in range(len(voltages) - 1):
                if voltage >= voltages[i] and voltage <= voltages[i+1]:
                    v1, v2 = voltages[i], voltages[i+1]
                    dc1, dc2 = duty_cycles[i], duty_cycles[i+1]
                    return dc1 + (dc2 - dc1) * ((voltage - v1) / (v2 - v1))

    def calculate_real_duty_cycle(self, input_voltage, demanded_duty_cycle, table):
        if demanded_duty_cycle < 0.0:
            demanded_duty_cycle = 0.0
        elif demanded_duty_cycle > 1.0:
            demanded_duty_cycle = 1.0

        adjustment_factor = self.interpolate_duty_cycle(input_voltage, table)
        real_duty_cycle = demanded_duty_cycle * adjustment_factor
        real_duty_cycle = max(0.0, min(real_duty_cycle, 1.0))
        return real_duty_cycle

    def update_fan(self, demanded_duty_cycle):
        input_voltage = volts.batt_volts(self.adc_pin)
        self.demanded_duty_cycle = demanded_duty_cycle  # Store the demanded duty cycle
        duty_cycle = self.calculate_real_duty_cycle(input_voltage, demanded_duty_cycle / 100, self.voltage_to_duty_cycle_table)
        duty_cycle = int(duty_cycle * 100)

        percent_map = self.map_value(duty_cycle, 0, 100, 0, 1023)
        self.fan_pwm.duty(percent_map)
        self.current_duty_cycle = duty_cycle  # Store the current duty cycle
        print (self.current_duty_cycle)

    def get_status(self):
        print (self.current_duty_cycle)
        # Return the current fan status as a dictionary
        return {
            "percent_map": self.current_duty_cycle,
            "input_voltage": volts.batt_volts(self.adc_pin),
            "demanded_duty_cycle": self.demanded_duty_cycle,
            "real_duty_cycle": self.current_duty_cycle
        }

    def get_duty_cycle(self):
        return self.current_duty_cycle





fan_controller.py

import utime
import machine
import config
from heater_control import HeaterControl
from fan_controller import FanController
from fuel_pump_controller import FuelPumpController

# Initialize state
state = {'pulse_frequency': 0}

# Initialize controllers
heater_control = HeaterControl()
fan_controller = FanController(config.burn_fan, config.adc_batt)
fuel_pump_controller = FuelPumpController(heater_control.get_power_demand, state)

# Main control loop
last_print_time = utime.ticks_ms()

while True:
    if utime.ticks_diff(utime.ticks_ms(), last_print_time) >= 1000:
        fan_status = fan_controller.get_status()
        print (fan_status)
        heater_control.print_out(state, fan_status)
        last_print_time = utime.ticks_ms()

    utime.sleep(0.1)
    heater_control.control_heater()
    #fuel_pump_controller.fuel()
    machine.idle()


main.py

import machine
import utime
import volts
import config
from fan_controller import FanController
from fuel_pump_controller import FuelPumpController

class HeaterControl:
    def __init__(self):
        self.initialize_pins()
        self.initialize_state()
        self.setup_interrupt()
        self.fan_controller = FanController(config.burn_fan, config.adc_batt)  # Initialize FanController
        self.fuel_pump_controller = FuelPumpController(self.get_power_demand, {'pulse_frequency': 0})  # Initialize FuelPumpController

    def initialize_pins(self):
        self.glow_plug_pin = machine.Pin(config.glow_plug, machine.Pin.OUT)
        self.interrupt_pin = machine.Pin(config.interrupt_pin, machine.Pin.IN)

    def initialize_state(self):
        self.interrupt_triggered = False
        self.control_state = "IDLE"
        self.start_time = 0

    def setup_interrupt(self):
        self.interrupt_pin.irq(trigger=machine.Pin.IRQ_FALLING | machine.Pin.IRQ_RISING, handler=self.interrupt_handler)

    def get_status(self):
        return self.fan_controller.get_status()

    def print_out(self, state, fan_status):
        print(self.control_state)
        print(f"Pulse frequency: {state['pulse_frequency']:.2f} Hz")
        print(f"Raw ADC value written to pin: {fan_status['percent_map']:.0f}")
        print(f"Input Voltage: {fan_status['input_voltage']:.2f}V")
        print(f"Demanded Duty Cycle: {fan_status['demanded_duty_cycle']:.1f}%")
        print(f"Real Duty Cycle: {fan_status['real_duty_cycle']:.1f}%")

    def get_power_demand(self):
        return self.fan_controller.get_duty_cycle()

    def read_battery_voltage(self):
        return volts.batt_volts(config.adc_batt)

    def turn_on_fan(self, duty_cycle):
        if not (0 <= duty_cycle <= 100):
            print(f"Error: Duty cycle {duty_cycle} is out of range.")
            return
        #print(f"Turning on fan with duty cycle: {duty_cycle}%")
        self.fan_controller.update_fan(duty_cycle)

    def turn_off_fan(self):
        print("Turning off fan.")
        self.fan_controller.update_fan(0)

    def turn_on_glow_plug(self):
        print("Turning on glow plug.")
        self.glow_plug_pin.value(1)

    def turn_off_glow_plug(self):
        print("Turning off glow plug.")
        self.glow_plug_pin.value(0)

    def check_glow_plug_resistance(self):
        return True

    def interrupt_handler(self, pin):
        if not self.interrupt_triggered:
            if pin.value() == 0:
                self.interrupt_triggered = True
        else:
            if pin.value() == 1:
                print("Interrupt triggered, starting heater control.")
                self.start_control_process()
                self.interrupt_triggered = False

    def start_control_process(self):
        self.control_state = "CHECK_BATTERY"
        self.start_time = utime.ticks_ms()

    def control_heater(self):
        if self.control_state == "CHECK_BATTERY":
            if self.read_battery_voltage() > config.no_start_low_batt_volts:
                self.control_state = "CLEAR_CHAMBER"
                self.start_time = utime.ticks_ms()
            else:
                print("Battery voltage too low. Heater will not start.")
                self.control_state = "IDLE"

        elif self.control_state == "CLEAR_CHAMBER":
            self.turn_on_fan(config.clear_chamber_pwm)
            if utime.ticks_diff(utime.ticks_ms(), self.start_time) >= config.clear_chamber_time:
                self.control_state = "INITIAL_TURN_ON"

        elif self.control_state == "INITIAL_TURN_ON":
            self.turn_on_glow_plug()
            self.control_state = "WAIT_FOR_GLOW_PLUG"
            self.start_time = utime.ticks_ms()

        elif self.control_state == "WAIT_FOR_GLOW_PLUG":
            self.turn_on_fan(config.wait_for_glowplug_pwm)
            # Pass the fan duty cycle to the fuel pump controller
            self.fuel_pump_controller.set_fan_duty_cycle(config.wait_for_glowplug_pwm)
            if utime.ticks_diff(utime.ticks_ms(), self.start_time) >= config.glow_plug_on_time:
                self.control_state = "CHECK_GLOW_PLUG"

        elif self.control_state == "CHECK_GLOW_PLUG":
            if self.check_glow_plug_resistance():
                self.control_state = "INCREMENT_FAN"
                self.start_time = utime.ticks_ms()
            else:
                print("Glow plug did not fire up. Shutting down.")
                self.turn_off_fan()
                self.turn_off_glow_plug()
                self.control_state = "IDLE"

        elif self.control_state == "INCREMENT_FAN":
            elapsed_time = utime.ticks_diff(utime.ticks_ms(), self.start_time) // 1000
            duty_cycle = min(100, config.wait_for_glowplug_pwm + elapsed_time)
            self.turn_on_fan(duty_cycle)
            self.fuel_pump_controller.set_fan_duty_cycle(duty_cycle)  # Update fuel pump with new duty cycle
            if duty_cycle >= 100:
                print("Heater is now running at full capacity.")
                self.control_state = "RUNNING"

        elif self.control_state == "RUNNING":
            self.turn_on_fan(100)
            self.fuel_pump_controller.set_fan_duty_cycle(100)  # Ensure fuel pump is updated


