MicroRally/uDCCD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 8 Wiki Activity

Compare commits

base: MicroRally:f1edc6e15ae97c5ab6d92953bbeaeb0d6f24e6b7
Branches Tags
MicroRally:main MicroRally:develop MicroRally:feat-fw-hbrake MicroRally:feat-pcb-r10 MicroRally:legacy-fw
MicroRally:CPPFW-V0.1 MicroRally:DEV-PCB-R1 MicroRally:R9 MicroRally:HW-EP-R1 MicroRally:LED-R1 MicroRally:R8 MicroRally:R7 MicroRally:R6
..
compare: MicroRally:DEV-PCB-R1
Branches Tags
MicroRally:develop MicroRally:feat-fw-hbrake MicroRally:feat-pcb-r10 MicroRally:main MicroRally:legacy-fw
MicroRally:CPPFW-V0.1 MicroRally:DEV-PCB-R1 MicroRally:R9 MicroRally:HW-EP-R1 MicroRally:LED-R1 MicroRally:R8 MicroRally:R7 MicroRally:R6

1 Commits
f1edc6e15a ... DEV-PCB-R1

Author SHA1 Message Date
Andis Zīle
7f012b1611 develop (#3) 
Finished development/test board R1

Reviewed-on: #3
Co-authored-by: Andis Zīle <andis.jargans@gmail.com>
Co-committed-by: Andis Zīle <andis.jargans@gmail.com>
 2024-04-25 17:35:16 +00:00
140 changed files with 13945 additions and 1737 deletions
Expand all files Collapse all files

BIN
docs/uDCCD_Controller_R9V1_Schematic.PDF
View File

Binary file not shown.

35
firmware/src/bsp/ain.cpp
View File

@@ -1,35 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "ain.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::AnalogIn::AnalogIn(uint8_t adc_ch)
{
this->adc_ch = adc_ch;
this->mul = DEF_AIN_MUL;
this->div = DEF_AIN_DIV;
this->offset = DEF_AIN_OFFSET;
this->last_read = 0;
}
uint16_t bsp::AnalogIn::read(void)
{
//Read ADC
uint16_t raw = mcu::adc_read(this->adc_ch);
//Convert to mV
this->last_read = util::convert_muldivoff(raw, this->mul, this->div, this->offset);
return this->last_read;
}
/**** Private function definitions ****/

37
firmware/src/bsp/ain.h
View File

@@ -1,37 +0,0 @@
#ifndef ANALOG_IN_H_
#define ANALOG_IN_H_
/**** Includes ****/
#include <stdint.h>
namespace bsp {
/**** Public definitions ****/
static const uint8_t DEF_AIN_MUL = 215;
static const uint8_t DEF_AIN_DIV = 44;
static const int16_t DEF_AIN_OFFSET = 0;
class AnalogIn
{
protected:
uint8_t adc_ch;
public:
AnalogIn(uint8_t adc_ch);
uint8_t mul;
uint8_t div;
int16_t offset;
uint16_t last_read;
uint16_t read(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* ANALOG_IN_H_ */

40
firmware/src/bsp/din.cpp
View File

@@ -1,40 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "din.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::DigitalIn::DigitalIn(uint8_t gpio_ch, uint8_t inverted, uint8_t init_value)
{
this->gpio_ch = gpio_ch;
this->invert = inverted;
if(init_value) this->last_read = DIN_HIGH;
else this->last_read = DIN_LOW;
}
bsp::DigitalIn::~DigitalIn(void)
{
return;
}
uint8_t bsp::DigitalIn::read(void)
{
uint8_t lvl = mcu::gpio_read(this->gpio_ch);
if(this->invert) lvl = util::invert(lvl);
if(lvl>0) this->last_read = DIN_HIGH;
else this->last_read = DIN_LOW;
return this->last_read;
}
/**** Private function definitions ****/

35
firmware/src/bsp/din.h
View File

@@ -1,35 +0,0 @@
#ifndef DIGITAL_INPUT_H_
#define DIGITAL_INPUT_H_
/**** Includes ****/
#include <stdint.h>
namespace bsp {
/**** Public definitions ****/
const uint8_t DIN_LOW = 0;
const uint8_t DIN_HIGH = 1;
class DigitalIn
{
protected:
uint8_t gpio_ch;
uint8_t invert;
public:
DigitalIn(uint8_t gpio_ch, uint8_t inverted, uint8_t init_value);
~DigitalIn(void);
uint8_t last_read;
uint8_t read(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* DIGITAL_INPUT_H_ */

34
firmware/src/bsp/dio.cpp
View File

@@ -1,34 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "dio.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::DigitalIO::DigitalIO(uint8_t gpio_ch, uint8_t init_value) : DigitalIn(gpio_ch, 0, init_value), DigitalOut(gpio_ch, 0)
{
return;
}
bsp::DigitalIO::~DigitalIO(void)
{
this->write(DOUT_HIZ);
}
uint8_t bsp::DigitalIO::is_io_match(void)
{
if(this->last_set == DOUT_HIZ) return 1;
uint8_t read_lvl = this->read();
if(read_lvl == (uint8_t)this->last_set) return 1;
else return 0;
}
/**** Private function definitions ****/

32
firmware/src/bsp/dio.h
View File

@@ -1,32 +0,0 @@
#ifndef DIGITAL_IO_H_
#define DIGITAL_IO_H_
/**** Includes ****/
#include <stdint.h>
#include "din.h"
#include "dout.h"
namespace bsp {
/**** Public definitions ****/
const int8_t DIO_LOW = 0;
const int8_t DIO_HIGH = 1;
const int8_t DIO_HIZ = -1;
class DigitalIO : public DigitalIn, public DigitalOut
{
public:
DigitalIO(uint8_t gpio_ch, uint8_t init_value);
~DigitalIO(void);
uint8_t is_io_match(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* DIGITAL_IO_H_ */

52
firmware/src/bsp/dout.cpp
View File

@@ -1,52 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "dout.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::DigitalOut::DigitalOut(uint8_t gpio_ch, uint8_t inverted)
{
this->gpio_ch = gpio_ch;
this->invert = inverted;
this->write(DOUT_HIZ);
}
bsp::DigitalOut::~DigitalOut(void)
{
this->write(DOUT_HIZ);
}
void bsp::DigitalOut::write(int8_t level)
{
if(level > 0)
{
this->last_set = DOUT_HIGH;
if(this->invert) mcu::gpio_write(this->gpio_ch, mcu::LEVEL_LOW);
else mcu::gpio_write(this->gpio_ch, mcu::LEVEL_HIGH);
}
else if(level == 0)
{
this->last_set = DOUT_LOW;
if(this->invert) mcu::gpio_write(this->gpio_ch, mcu::LEVEL_HIGH);
else mcu::gpio_write(this->gpio_ch, mcu::LEVEL_LOW);
}
else
{
this->last_set = DOUT_HIZ;
mcu::gpio_write(this->gpio_ch, mcu::LEVEL_HIZ);
}
}
int8_t bsp::DigitalOut::get_set_level(void)
{
return this->last_set;
}
/**** Private function definitions ****/

36
firmware/src/bsp/dout.h
View File

@@ -1,36 +0,0 @@
#ifndef DIGITAL_OUTPUT_H_
#define DIGITAL_OUTPUT_H_
/**** Includes ****/
#include <stdint.h>
namespace bsp {
/**** Public definitions ****/
const int8_t DOUT_LOW = 0;
const int8_t DOUT_HIGH = 1;
const int8_t DOUT_HIZ = -1;
class DigitalOut
{
protected:
uint8_t gpio_ch;
uint8_t invert;
int8_t last_set;
public:
DigitalOut(uint8_t gpio_ch, uint8_t inverted);
~DigitalOut(void);
void write(int8_t level);
int8_t get_set_level(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* DIGITAL_OUTPUT_H_ */

74
firmware/src/bsp/halfbridge.cpp
View File

@@ -1,74 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "halfbridge.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::Hafbridge::Hafbridge(uint8_t hs_pwm_ch, uint8_t ls_gpio_ch, uint8_t max_dc)
{
this->pwm_ch = hs_pwm_ch;
this->gpio_ch = ls_gpio_ch;
if(max_dc>100) max_dc = 100;
this->max_dc = util::percent_to_16b(max_dc);
this->disable();
}
bsp::Hafbridge::~Hafbridge(void)
{
this->last_duty = 0;
this->disable();
}
void bsp::Hafbridge::write(uint16_t dividend)
{
// Limit duty
if(dividend > this->max_dc) dividend = this->max_dc;
this->last_duty = dividend;
if(this->enabled == 0) return;
// Set PWM
mcu::pwm_write(this->pwm_ch, dividend);
}
void bsp::Hafbridge::write(uint8_t percent)
{
// Convert to dividend/0xFFFF
this->write(util::percent_to_16b(percent));
}
void bsp::Hafbridge::enable(void)
{
mcu::gpio_write(this->gpio_ch, mcu::LEVEL_HIGH);
this->enabled = 1;
this->write(this->last_duty);
}
void bsp::Hafbridge::disable(void)
{
mcu::pwm_write(this->pwm_ch, 0);
mcu::gpio_write(this->gpio_ch, mcu::LEVEL_LOW);
this->enabled = 0;
}
uint8_t bsp::Hafbridge::get_set_duty(void)
{
return this->last_duty;
}
uint8_t bsp::Hafbridge::is_enabled(void)
{
return this->enabled;
}
/**** Private function definitions ****/

38
firmware/src/bsp/halfbridge.h
View File

@@ -1,38 +0,0 @@
#ifndef HALFBRIDGE_H_
#define HALFBRIDGE_H_
/**** Includes ****/
#include <stdint.h>
namespace bsp {
/**** Public definitions ****/
class Hafbridge
{
protected:
uint8_t pwm_ch;
uint8_t gpio_ch;
uint16_t last_duty;
uint8_t enabled;
uint16_t max_dc;
public:
Hafbridge(uint8_t hs_pwm_ch, uint8_t ls_gpio_ch, uint8_t max_dc);
~Hafbridge(void);
void write(uint16_t dividend);
void write(uint8_t percent);
void enable(void);
void disable(void);
uint8_t get_set_duty(void);
uint8_t is_enabled(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* HALFBRIDGE_H_ */

98
firmware/src/bsp/mcu/mcu_hal.h
View File

@@ -1,98 +0,0 @@
#ifndef MCU_HAL_H_
#define MCU_HAL_H_
/**** Includes ****/
#include <stdint.h>
namespace mcu {
/**** Public definitions ****/
/*
*/
const uint8_t GPIO0 = 0; //PC5 Mode
const uint8_t GPIO1 = 1; //PC4 Pot
const uint8_t GPIO2 = 2; //PE1 Down
const uint8_t GPIO3 = 3; //PE3 Up
const uint8_t GPIO4 = 4; //PD7 Dimm
const uint8_t GPIO5 = 5; //PB7 Brakes
const uint8_t GPIO6 = 6; //PB6 Handbrake
const uint8_t GPIO7 = 7; //PB5 Handbrake pull
const uint8_t GPIO8 = 8; //PD6 Speed pull
const uint8_t GPIO9 = 9; //PD0 LED0
const uint8_t GPIO10 = 10; //PD1 LED1
const uint8_t GPIO11 = 11; //PD2 LED2
const uint8_t GPIO12 = 12; //PD3 LED3
const uint8_t GPIO13 = 13; //PD4 LED4
const uint8_t GPIO14 = 14; //PD5 LED5
const uint8_t GPIO15 = 15; //PB0 DCCD Enable
const uint8_t GPIO16 = 16; //PB1 DCCD PWM
const uint8_t GPIO17 = 17; //PB2 LED PWM
const uint8_t LEVEL_LOW = 0;
const uint8_t LEVEL_HIGH = 1;
const int8_t LEVEL_HIZ = -1;
const uint8_t ADC0 = 0; //Output current
const uint8_t ADC1 = 1; //Output voltage
const uint8_t ADC2 = 2; //Battery voltage
const uint8_t ADC3 = 3; //Battery current
const uint8_t ADC4 = 4; //Potentiometer
const uint8_t ADC5 = 5; //Mode
const uint8_t ADC8 = 8; //MCU temperature
const uint8_t ADC14 = 14; //MCU internal reference
const uint8_t ADC15 = 15; //MCU ground
const uint8_t PWM0 = 0; //DCCD
const uint8_t PWM1 = 1; //LED
//ADC definitions
typedef enum {
ADC_DIV2 = 0x01,
ADC_DIV4 = 0x02,
ADC_DIV8 = 0x03,
ADC_DIV16 = 0x04,
ADC_DIV32 = 0x05,
ADC_DIV64 = 0x06,
ADC_DIV128 = 0x07
} adcClkDiv_t;
//Timer definitions
typedef enum {
TIM_DIV1 = 0x01,
TIM_DIV8 = 0x02,
TIM_DIV64 = 0x03,
TIM_DIV256 = 0x04,
TIM_DIV1024 = 0x05
} timerClkDiv_t;
typedef struct {
adcClkDiv_t adc_clk;
timerClkDiv_t pwm_clk;
uint16_t pwm_top;
uint8_t pwm_ch1_en;
} startupCfg_t;
/**** Public function declarations ****/
void startup(startupCfg_t* hwCfg);
uint8_t gpio_read(uint8_t ch);
void gpio_write(uint8_t ch, int8_t lvl);
void gpio_write_pull(uint8_t ch, int8_t lvl);
uint16_t adc_read(uint8_t ch);
void pwm_write(uint8_t ch, uint16_t dc);
uint16_t pwm_read(uint8_t ch);
uint8_t eeprom_read8b(uint16_t address);
uint16_t eeprom_read16b(uint16_t address);
uint32_t eeprom_read32b(uint16_t address);
void eeprom_write8b(uint16_t address, uint8_t value);
void eeprom_write16b(uint16_t address, uint16_t value);
void eeprom_write32b(uint16_t address, uint32_t value);
} //namespace
#endif /* MCU_HAL_H_ */

40
firmware/src/bsp/pwm.cpp
View File

@@ -1,40 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "mcu/mcu_hal.h"
#include "pwm.h"
using namespace bsp;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
bsp::PWMout::PWMout(uint8_t pwm_ch)
{
this->pwm_ch = pwm_ch;
this->write(0);
}
bsp::PWMout::~PWMout(void)
{
this->write(0);
}
void bsp::PWMout::write(uint8_t duty)
{
// Convert percent to 16b duty cycle
uint16_t dc = util::percent_to_16b(duty);
// Set PWM
mcu::pwm_write(this->pwm_ch, dc);
this->last_duty = duty;
}
uint8_t bsp::PWMout::get_set_duty(void)
{
return this->last_duty;
}
/**** Private function definitions ****/

31
firmware/src/bsp/pwm.h
View File

@@ -1,31 +0,0 @@
#ifndef PWM_H_
#define PWM_H_
/**** Includes ****/
#include <stdint.h>
namespace bsp {
/**** Public definitions ****/
class PWMout
{
protected:
uint8_t pwm_ch;
uint8_t last_duty;
public:
PWMout(uint8_t pwm_ch);
~PWMout(void);
void write(uint8_t duty);
uint8_t get_set_duty(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* PWM_H_ */

45
firmware/src/hw/analog.c Normal file
View File

@@ -0,0 +1,45 @@
/**** Includes ****/
#include "board/utils/utils.h"
#include "board/ain.h"
#include "analog.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t ain_mapping(uint8_t analog_ch, uint8_t* ain_ch);
/**** Public function definitions ****/
uint16_t analog_ch_get(uint8_t analog_ch)
{
uint8_t ain_ch;
// Get channel config
if(ain_mapping(analog_ch, &ain_ch)) return 0;
// Read input as mV
uint16_t ch_mv = bsp_ain_read(ain_ch);
// Return result
return ch_mv;
}
/**** Private function definitions ****/
static uint8_t ain_mapping(uint8_t analog_ch, uint8_t* ain_ch)
{
switch(analog_ch)
{
case ANALOG_1: // Pot
*ain_ch = BSP_AIN2;
return 0;
case ANALOG_2: // Mode
*ain_ch = BSP_AIN1;
return 0;
default: //Invalid channel
*ain_ch = BSP_AIN5;
return 1;
}
return 1;
}

20
firmware/src/hw/analog.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef ANALOG_H_
#define ANALOG_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define ANALOG_1 1 //Potentiometer
#define ANALOG_2 2 //Mode
/**** Public function declarations ****/
uint16_t analog_ch_get(uint8_t analog_ch);
#ifdef TESTING
#endif
#endif /* ANALOG_H_ */

77
firmware/src/hw/board/ain.c Normal file
View File

@@ -0,0 +1,77 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "ain.h"
/**** Private definitions ****/
typedef struct {
uint8_t adc_ch;
uint8_t mul;
uint8_t div;
int16_t offset;
} ainchcfg_t;
/**** Private constants ****/
static const uint8_t MV_MUL = BSP_AIN_DEF_MV_MUL;
static const uint8_t MV_DIV = BSP_AIN_DEF_MV_DIV;
static const int16_t MV_OFFSET = BSP_AIN_DEF_MV_OFFSET;
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t ain_mapping(uint8_t ain_ch, ainchcfg_t* ain_ch_cfg);
/**** Public function definitions ****/
uint16_t bsp_ain_read(uint8_t ch)
{
ainchcfg_t cfg;
// Get analog input config, and check validity
if(ain_mapping(ch, &cfg)) return 0;
//Read ADC
uint16_t raw = mcu_adc_read(cfg.adc_ch);
//Convert to mV
raw = util_convert_muldivoff(raw, cfg.mul, cfg.div, cfg.offset);
// Return result
return raw;
}
/**** Private function definitions ****/
static uint8_t ain_mapping(uint8_t ain_ch, ainchcfg_t* ain_ch_cfg)
{
// Default 10bit ADC with 5V reference to mV conversion
ain_ch_cfg->mul = MV_MUL;
ain_ch_cfg->div = MV_DIV;
ain_ch_cfg->offset = MV_OFFSET;
switch(ain_ch)
{
case BSP_AIN1: // Mode
ain_ch_cfg->adc_ch = MCU_ADC5;
return 0;
case BSP_AIN2: // Pot
ain_ch_cfg->adc_ch = MCU_ADC4;
return 0;;
case BSP_AIN3: // MCU Temp
ain_ch_cfg->adc_ch = MCU_ADC8;
return 0;
case BSP_AIN4: // MCU Internal reference
ain_ch_cfg->adc_ch = MCU_ADC14;
return 0;
case BSP_AIN5: // MCU Ground
ain_ch_cfg->adc_ch = MCU_ADC15;
return 0;
default: // Invalid channel
ain_ch_cfg->adc_ch = MCU_ADC15;
return 1;
}
return 1;
}

26
firmware/src/hw/board/ain.h Normal file
View File

@@ -0,0 +1,26 @@
#ifndef AIN_H_
#define AIN_H_
/*
AIN1 MODE
AIN2 POT
*/
/**** Includes ****/
#include <stdint.h>
#include "config.h"
/**** Public definitions ****/
#define BSP_AIN1 1 // Mode
#define BSP_AIN2 2 // Pot
#define BSP_AIN3 3 // MCU Temp
#define BSP_AIN4 4 // MCU Internal reference
#define BSP_AIN5 5 // MCU Ground
/**** Public function declarations ****/
uint16_t bsp_ain_read(uint8_t ch);
#ifdef TESTING
#endif
#endif /* AIN_H_ */

32
firmware/src/hw/board/config.h Normal file
View File

@@ -0,0 +1,32 @@
#ifndef BSP_CONFIG_H_
#define BSP_CONFIG_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define BSP_AIN_DEF_MV_MUL 215
#define BSP_AIN_DEF_MV_DIV 44
#define BSP_AIN_DEF_MV_OFFSET 0
#define BSP_HB_MV_MUL BSP_AIN_DEF_MV_MUL
#define BSP_HB_MV_DIV BSP_AIN_DEF_MV_DIV
#define BSP_HB_MV_OFFSET BSP_AIN_DEF_MV_OFFSET
#define BSP_HB_UDIV_MUL 20
#define BSP_HB_UDIV_DIV 1
#define BSP_HB_UDIV_OFFSET 0
#define BSP_HB_ISUP_MUL 235
#define BSP_HB_ISUP_DIV 6
#define BSP_HB_ISUP_OFFSET 0
#define BSP_HB_IOUT_MUL 215
#define BSP_HB_IOUT_DIV 22
#define BSP_HB_IOUT_OFFSET 0
/**** Public function declarations ****/
#ifdef TESTING
#endif
#endif /* BSP_CONFIG_H_ */

83
firmware/src/hw/board/din.c Normal file
View File

@@ -0,0 +1,83 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "din.h"
/**** Private definitions ****/
typedef struct {
uint8_t gpio_ch;
uint8_t invert;
} dinchcfg_t;
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t din_mapping(uint8_t din_ch, dinchcfg_t* din_ch_cfg);
/**** Public function definitions ****/
uint8_t bsp_din_read(uint8_t ch)
{
dinchcfg_t cfg;
// Get digital input config, and check validity
if(din_mapping(ch, &cfg)) return BSP_DIN_LOW;
//Read GPIO
uint8_t raw = mcu_gpio_read(cfg.gpio_ch);
// Check config and invert
if(cfg.invert) raw = util_invert_8b(raw);
// Return result
return raw;
}
/**** Private function definitions ***/
static uint8_t din_mapping(uint8_t din_ch, dinchcfg_t* din_ch_cfg)
{
// By default ch is not inverted
din_ch_cfg->invert = 0;
switch(din_ch)
{
case BSP_DIN1: //Mode
din_ch_cfg->gpio_ch = MCU_GPIO0;
return 0;
case BSP_DIN2: //Pot
din_ch_cfg->gpio_ch = MCU_GPIO1;
return 0;
case BSP_DIN3: //Down
din_ch_cfg->gpio_ch = MCU_GPIO2;
return 0;
case BSP_DIN4: //Up
din_ch_cfg->gpio_ch = MCU_GPIO3;
return 0;
case BSP_DIN5: //Dimm
din_ch_cfg->gpio_ch = MCU_GPIO4;
din_ch_cfg->invert = 1;
return 0;
case BSP_DIN6: //Brakes
din_ch_cfg->gpio_ch = MCU_GPIO5;
din_ch_cfg->invert = 1;
return 0;
case BSP_DIN7: //Handbrake
din_ch_cfg->gpio_ch = MCU_GPIO6;
din_ch_cfg->invert = 1;
return 0;
case BSP_DIN7N: //Handbrake pull
din_ch_cfg->gpio_ch = MCU_GPIO7;
return 0;
default: //Invalid channel
din_ch_cfg->gpio_ch = 0;
return 1;
}
return 1;
}

37
firmware/src/hw/board/din.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef DIN_H_
#define DIN_H_
/*
DIN1 MODE
DIN2 POT
DIN3 DOWN
DIN4 UP
DIN5 HV DIM
DIN6 HV BRAKES
DIN7 HV HANDBRAKE
DIN8 HBRAKE PULL
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define BSP_DIN1 1
#define BSP_DIN2 2
#define BSP_DIN3 3
#define BSP_DIN4 4
#define BSP_DIN5 5
#define BSP_DIN6 6
#define BSP_DIN7 7
#define BSP_DIN7N 8
#define BSP_DIN_LOW 0
#define BSP_DIN_HIGH 1
/**** Public function declarations ****/
uint8_t bsp_din_read(uint8_t ch);
#ifdef TESTING
#endif
#endif /* DIN_H_ */

58
firmware/src/hw/board/dout.c Normal file
View File

@@ -0,0 +1,58 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "dout.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t dout_mapping(uint8_t dout_ch, uint8_t* gpio_ch);
/**** Public function definitions ****/
void bsp_dout_write(uint8_t ch, int8_t lvl)
{
uint8_t gpio_ch;
// Get digital input config, and check validity
if(dout_mapping(ch, &gpio_ch)) return;
// Write GPIO
mcu_gpio_write(gpio_ch, lvl);
}
/**** Private function definitions ***/
static uint8_t dout_mapping(uint8_t dout_ch, uint8_t* gpio_ch)
{
switch(dout_ch)
{
case BSP_DOUT1: //Mode
*gpio_ch = MCU_GPIO0;
return 0;
case BSP_DOUT2: //Pot
*gpio_ch = MCU_GPIO1;
return 0;
case BSP_DOUT3: //Down
*gpio_ch = MCU_GPIO2;
return 0;
case BSP_DOUT4: //Up
*gpio_ch = MCU_GPIO3;
return 0;
case BSP_DOUT5: //Handbrake pull
*gpio_ch = MCU_GPIO7;
return 0;
case BSP_DOUT6: //Speed pull
*gpio_ch = MCU_GPIO8;
return 0;
default: //Invalid channel
*gpio_ch = 0;
return 1;
}
return 1;
}

34
firmware/src/hw/board/dout.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef DOUT_H_
#define DOUT_H_
/*
DOUT1 MODE
DOUT2 POT
DOUT3 DOWN
DOUT4 UP
DOUT5 HBRAKE PULL
DOUT6 SPEED PULL
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define BSP_DOUT1 1
#define BSP_DOUT2 2
#define BSP_DOUT3 3
#define BSP_DOUT4 4
#define BSP_DOUT5 5
#define BSP_DOUT6 6
#define BSP_DOUT_LOW 0
#define BSP_DOUT_HIGH 1
#define BSP_DOUT_HIZ -1
/**** Public function declarations ****/
void bsp_dout_write(uint8_t ch, int8_t lvl);
#ifdef TESTING
#endif
#endif /* DOUT_H_ */

179
firmware/src/hw/board/halfbridge.c Normal file
View File

@@ -0,0 +1,179 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "halfbridge.h"
/**** Private definitions ****/
typedef struct {
uint8_t adc_ch;
uint8_t mul;
uint8_t div;
int16_t offset;
} ainchcfg_t;
typedef enum {
AIN_OUT_VOLTAGE,
AIN_OUT_CURRENT,
AIN_SUP_VOLTAGE,
AIN_SUP_CURRENT
} hb_ainch_t;
/**** Private constants ****/
// Analog channels conversion coefficients
static const uint8_t MV_MUL = BSP_HB_MV_MUL;
static const uint8_t MV_DIV = BSP_HB_MV_DIV;
static const int16_t MV_OFFSET = BSP_HB_MV_OFFSET;
static const uint8_t UDIV_MUL = BSP_HB_UDIV_MUL;
static const uint8_t UDIV_DIV = BSP_HB_UDIV_DIV;
static const int16_t UDIV_OFFSET = BSP_HB_UDIV_OFFSET;
static const uint8_t ISUP_MUL = BSP_HB_ISUP_MUL;
static const uint8_t ISUP_DIV = BSP_HB_ISUP_DIV;
static const int16_t ISUP_OFFSET = BSP_HB_ISUP_OFFSET;
static const uint8_t IOUT_MUL = BSP_HB_IOUT_MUL;
static const uint8_t IOUT_DIV = BSP_HB_IOUT_DIV;
static const int16_t IOUT_OFFSET = BSP_HB_IOUT_OFFSET;
/**** Private variables ****/
/**** Mapping function declarations ****/
static uint8_t hb_pwm_mapping(uint8_t* pwm_ch);
static uint8_t hb_low_side_mapping(uint8_t* gpio_ch);
static uint8_t hb_ain_mapping(hb_ainch_t ain_ch, ainchcfg_t* ain_ch_cfg);
/**** Private function declarations ****/
static uint16_t limit_pwm(uint16_t pwm_in);
static uint16_t read_ain(hb_ainch_t ch);
/**** Public function definitions ****/
void bsp_hb_write_low(uint8_t state)
{
uint8_t gpio_ch;
// Get GPIO channel, and check validity
if(hb_low_side_mapping(&gpio_ch)) return;
// Set low side on or off
if(state) mcu_gpio_write(gpio_ch, MCU_GPIO_HIGH);
else mcu_gpio_write(gpio_ch, MCU_GPIO_LOW);
}
void bsp_hb_write_pwm(uint16_t pwm)
{
uint8_t pwm_ch;
// Get PWM channel, and check validity
if(hb_pwm_mapping(&pwm_ch)) return;
// Limit PWM, because of charge pump
pwm = limit_pwm(pwm);
// Set pwm
mcu_pwm_write(pwm_ch, pwm);
}
void bsp_hb_read_meas(hb_meas_t* measurements)
{
// Read analog inputs
measurements->out_voltage = read_ain(AIN_OUT_VOLTAGE);
measurements->out_current = read_ain(AIN_OUT_CURRENT);
measurements->sup_voltage = read_ain(AIN_SUP_VOLTAGE);
measurements->sup_current = read_ain(AIN_SUP_CURRENT);
// Calculate secondary measurements
measurements->out_power = util_sat_mul_kilo(measurements->out_voltage, measurements->out_current);
measurements->sup_power = util_sat_mul_kilo(measurements->sup_voltage, measurements->sup_current);
measurements->out_impedance = util_sat_div_kilo(measurements->out_voltage, measurements->out_current);
uint8_t ch;
//Read low side control GPIO level
if(hb_low_side_mapping(&ch)) measurements->low_side_ctrl = 0;
else measurements->low_side_ctrl = mcu_gpio_read(ch);
//Read PWM duty cycle in 16b format
if(hb_pwm_mapping(&ch)) measurements->pwm = 0;
else measurements->pwm = mcu_pwm_read(ch);
}
/**** Private function declarations ****/
static uint16_t read_ain(hb_ainch_t ch)
{
ainchcfg_t cfg;
// Get analog input config, and check validity
if(hb_ain_mapping(ch, &cfg)) return 0;
//Read ADC
uint16_t raw = mcu_adc_read(cfg.adc_ch);
//Convert to target units
raw = util_convert_muldivoff(raw, cfg.mul, cfg.div, cfg.offset);
// Return result
return raw;
}
static uint16_t limit_pwm(uint16_t pwm_in)
{
// Limit to ~95%
if (pwm_in > 0xFC00) return 0xFC00;
else return pwm_in;
}
/**** Mapping function definitions ****/
static uint8_t hb_pwm_mapping(uint8_t* pwm_ch)
{
*pwm_ch = MCU_PWM0;
return 0;
}
static uint8_t hb_low_side_mapping(uint8_t* gpio_ch)
{
*gpio_ch = MCU_GPIO15;
return 0;
}
static uint8_t hb_ain_mapping(hb_ainch_t ain_ch, ainchcfg_t* ain_ch_cfg)
{
switch(ain_ch)
{
case AIN_OUT_VOLTAGE:
ain_ch_cfg->adc_ch = MCU_ADC1;
ain_ch_cfg->mul = UDIV_MUL;
ain_ch_cfg->div = UDIV_DIV;
ain_ch_cfg->offset = UDIV_OFFSET;
return 0;
case AIN_OUT_CURRENT:
ain_ch_cfg->adc_ch = MCU_ADC0;
ain_ch_cfg->mul = IOUT_MUL;
ain_ch_cfg->div = IOUT_DIV;
ain_ch_cfg->offset = IOUT_OFFSET;
return 0;
case AIN_SUP_VOLTAGE:
ain_ch_cfg->adc_ch = MCU_ADC2;
ain_ch_cfg->mul = UDIV_MUL;
ain_ch_cfg->div = UDIV_DIV;
ain_ch_cfg->offset = UDIV_OFFSET;
return 0;
case AIN_SUP_CURRENT:
ain_ch_cfg->adc_ch = MCU_ADC3;
ain_ch_cfg->mul = ISUP_MUL;
ain_ch_cfg->div = ISUP_DIV;
ain_ch_cfg->offset = ISUP_OFFSET;
return 0;
default: //Invalid channel
ain_ch_cfg->adc_ch = MCU_ADC15;
// Default 10bit ADC with 5V reference to mV conversion
ain_ch_cfg->mul = MV_MUL;
ain_ch_cfg->div = MV_DIV;
ain_ch_cfg->offset = MV_OFFSET;
return 1;
}
return 1;
}

34
firmware/src/hw/board/halfbridge.h Normal file
View File

@@ -0,0 +1,34 @@
#ifndef HALFBRIDGE_H_
#define HALFBRIDGE_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
#include "config.h"
/**** Public definitions ****/
typedef struct {
uint16_t out_voltage;
uint16_t out_current;
uint16_t sup_voltage;
uint16_t sup_current;
uint16_t out_power;
uint16_t sup_power;
uint16_t out_impedance;
uint8_t low_side_ctrl;
uint16_t pwm;
} hb_meas_t;
/**** Public function declarations ****/
void bsp_hb_write_low(uint8_t state);
void bsp_hb_write_pwm(uint16_t pwm);
// Feedback functions
void bsp_hb_read_meas(hb_meas_t* measurements);
#ifdef TESTING
#endif
#endif /* HALFBRIDGE_H_ */

120
firmware/src/hw/board/mcu/mcu_hal.h Normal file
View File

@@ -0,0 +1,120 @@
#ifndef MCU_HAL_H_
#define MCU_HAL_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
/*
GPIO0 Down
GPIO1 Up
GPIO2 Mode
GPIO3 Handbrake
GPIO4 Brakes
GPIO5 Dimm
GPIO6 LED0
GPIO7 LED1
GPIO8 LED2
GPIO9 LED3
GPIO10 LED4
GPIO11 LED5
GPIO12 DCCD Enable
GPIO13 Handbrake pull
GPIO14 Speed pull
GPIO15 DCCD PWM
GPIO16 LED PWM
ADC0 Output current
ADC1 Output voltage
ADC2 Battery current
ADC3 Battery voltage
ADC4 Potentiometer
ADC5 Mode
ADC8 MCU temperature
ADC14 MCU internal reference
ADC15 MCU ground
*/
#define MCU_GPIO0 0 //Mode
#define MCU_GPIO1 1 //Pot
#define MCU_GPIO2 2 //Down
#define MCU_GPIO3 3 //Up
#define MCU_GPIO4 4 //Dimm
#define MCU_GPIO5 5 //Brakes
#define MCU_GPIO6 6 //Handbrake
#define MCU_GPIO7 7 //Handbrake pull
#define MCU_GPIO8 8 //Speed pull
#define MCU_GPIO9 9 //LED0
#define MCU_GPIO10 10 //LED1
#define MCU_GPIO11 11 //LED2
#define MCU_GPIO12 12 //LED3
#define MCU_GPIO13 13 //LED4
#define MCU_GPIO14 14 //LED5
#define MCU_GPIO15 15 //DCCD Enable
#define MCU_GPIO16 16 //DCCD PWM
#define MCU_GPIO17 17 //LED PWM
#define MCU_GPIO_LOW 0
#define MCU_GPIO_HIGH 1
#define MCU_GPIO_HIZ -1
#define MCU_ADC0 0 //Output current
#define MCU_ADC1 1 //Output voltage
#define MCU_ADC2 2 //Battery voltage
#define MCU_ADC3 3 //Battery current
#define MCU_ADC4 4 //Potentiometer
#define MCU_ADC5 5 //Mode
#define MCU_ADC8 8 //MCU temperature
#define MCU_ADC14 14 //MCU internal reference
#define MCU_ADC15 15 //MCU ground
#define MCU_PWM0 0 //DCCD
#define MCU_PWM1 1 //LED
//ADC definitions
typedef enum {
MCU_ADC_DIV2 = 0x01,
MCU_ADC_DIV4 = 0x02,
MCU_ADC_DIV8 = 0x03,
MCU_ADC_DIV16 = 0x04,
MCU_ADC_DIV32 = 0x05,
MCU_ADC_DIV64 = 0x06,
MCU_ADC_DIV128 = 0x07
} adcClkDiv_t;
//Timer definitions
typedef enum {
MCU_TIM_DIV1 = 0x01,
MCU_TIM_DIV8 = 0x02,
MCU_TIM_DIV64 = 0x03,
MCU_TIM_DIV256 = 0x04,
MCU_TIM_DIV1024 = 0x05
} timerClkDiv_t;
typedef struct {
adcClkDiv_t adc_clk;
timerClkDiv_t pwm_clk;
uint16_t pwm_top;
uint8_t pwm_chb_en;
} startupCfg_t;
/**** Public function declarations ****/
void mcu_startup(startupCfg_t* hwCfg);
uint8_t mcu_gpio_read(uint8_t ch);
void mcu_gpio_write(uint8_t ch, int8_t lvl);
uint16_t mcu_adc_read(uint8_t ch);
void mcu_pwm_write(uint8_t ch, uint16_t dc);
uint16_t mcu_pwm_read(uint8_t ch);
uint8_t mcu_ee_read8b(uint16_t address);
uint16_t mcu_ee_read16b(uint16_t address);
uint32_t mcu_ee_read32b(uint16_t address);
void mcu_ee_write8b(uint16_t address, uint8_t value);
void mcu_ee_write16b(uint16_t address, uint16_t value);
void mcu_ee_write32b(uint16_t address, uint32_t value);
#endif /* MCU_HAL_H_ */

190
firmware/src/bsp/mcu/mcu_hal_r8.cpp → firmware/src/hw/board/mcu/mcu_hal_r8.c
View File

@@ -3,18 +3,16 @@
#include <avr/eeprom.h>
#include "mcu_hal.h"
using namespace mcu;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t gpio_read_level(uint8_t pin_reg, uint8_t mask);
static uint8_t gpio_read(uint8_t pin_reg, uint8_t mask);
static void pwm_write_ocx(uint8_t ch, uint16_t value);
static uint16_t pwm_read_ocx(uint8_t ch);
/**** Public function definitions ****/
void mcu::startup(startupCfg_t* hwCfg)
void mcu_startup(startupCfg_t* hwCfg)
{
// Fail-safe GPIO init
PORTB = 0xF8; // Set PORTB pull-ups
@@ -34,7 +32,7 @@ void mcu::startup(startupCfg_t* hwCfg)
DDRB |= 0x03; //Set as output
// Common OD PWM pin
if(hwCfg->pwm_ch1_en) PORTB &= ~0x04; //Set low
if(hwCfg->pwm_chb_en) PORTB &= ~0x04; //Set low
else PORTB |= 0x04; //Set high
DDRB |= 0x04; //Set as output
@@ -80,7 +78,7 @@ void mcu::startup(startupCfg_t* hwCfg)
//DCCD and LED PWM configuration
PRR0 &= ~0x80; //Enable Timer1 power
TCCR1A = 0xC2; //Connect OC1A, inverted mode
if(hwCfg->pwm_ch1_en) TCCR1A |= 0x30; //Connect OC1B, inverted mode
if(hwCfg->pwm_chb_en) TCCR1A |= 0x30; //Connect OC1B, inverted mode
TCCR1B = 0x18; //PWM, Phase & Frequency Correct ICR1 top, no clock, WGM:0xE
TCCR1C = 0x00;
TCNT1 = 0x0000;
@@ -95,7 +93,7 @@ void mcu::startup(startupCfg_t* hwCfg)
}
// ADC Interface functions
uint16_t mcu::adc_read(uint8_t ch)
uint16_t mcu_adc_read(uint8_t ch)
{
//check if ADC is enabled
if(!(ADCSRA&0x80)) return 0xFFFF;
@@ -113,7 +111,7 @@ uint16_t mcu::adc_read(uint8_t ch)
}
// PWM Timer Interface functions
void mcu::pwm_write(uint8_t ch, uint16_t dc)
void mcu_pwm_write(uint8_t ch, uint16_t dc)
{
dc = 0xFFFF - dc;
@@ -130,7 +128,7 @@ void mcu::pwm_write(uint8_t ch, uint16_t dc)
pwm_write_ocx(ch, ocrx);
}
uint16_t mcu::pwm_read(uint8_t ch)
uint16_t mcu_pwm_read(uint8_t ch)
{
uint16_t ocrx = pwm_read_ocx(ch);
@@ -148,74 +146,74 @@ uint16_t mcu::pwm_read(uint8_t ch)
return (uint16_t)temp;
}
uint8_t mcu::gpio_read(uint8_t ch)
uint8_t mcu_gpio_read(uint8_t ch)
{
switch(ch)
{
case GPIO0: // Mode DIN1
return gpio_read_level(PINC,0x20);
case MCU_GPIO0: // Mode DIN1
return gpio_read(PINC,0x20);
case GPIO1: // Pot DIN2
return gpio_read_level(PINC,0x10);
case MCU_GPIO1: // Pot DIN2
return gpio_read(PINC,0x10);
case GPIO2: // Down DIN3
return gpio_read_level(PINE,0x02);
case MCU_GPIO2: // Down DIN3
return gpio_read(PINE,0x02);
case GPIO3: // Up DIN4
return gpio_read_level(PINE,0x08);
case MCU_GPIO3: // Up DIN4
return gpio_read(PINE,0x08);
case GPIO4: // Dimm DIN5
return gpio_read_level(PIND,0x80);
case MCU_GPIO4: // Dimm DIN5
return gpio_read(PIND,0x80);
case GPIO5: // Brakes DIN6
return gpio_read_level(PINB,0x80);
case MCU_GPIO5: // Brakes DIN6
return gpio_read(PINB,0x80);
case GPIO6: // Handbrake DIN7
return gpio_read_level(PINB,0x40);
case MCU_GPIO6: // Handbrake DIN7
return gpio_read(PINB,0x40);
case GPIO7: // Handbrake pull DIN8
return gpio_read_level(PINB,0x20);
case MCU_GPIO7: // Handbrake pull DIN8
return gpio_read(PINB,0x20);
case GPIO8: // Speed-pull
return gpio_read_level(PIND,0x40);
case MCU_GPIO8: // Speed-pull
return gpio_read(PIND,0x40);
case GPIO9: // LED 0
return gpio_read_level(PIND,0x01);
case MCU_GPIO9: // LED 0
return gpio_read(PIND,0x01);
case GPIO10: // LED 1
return gpio_read_level(PIND,0x02);
case MCU_GPIO10: // LED 1
return gpio_read(PIND,0x02);
case GPIO11: // LED 2
return gpio_read_level(PIND,0x04);
case MCU_GPIO11: // LED 2
return gpio_read(PIND,0x04);
case GPIO12: // LED 3
return gpio_read_level(PIND,0x08);
case MCU_GPIO12: // LED 3
return gpio_read(PIND,0x08);
case GPIO13: // LED 4
return gpio_read_level(PIND,0x10);
case MCU_GPIO13: // LED 4
return gpio_read(PIND,0x10);
case GPIO14: // LED 5
return gpio_read_level(PIND,0x20);
case MCU_GPIO14: // LED 5
return gpio_read(PIND,0x20);
case GPIO15: // DCCD Enable
return gpio_read_level(PINB,0x01);
case MCU_GPIO15: // DCCD Enable
return gpio_read(PINB,0x01);
case GPIO16: // DCCD PWM
return gpio_read_level(PINB,0x02);
case MCU_GPIO16: // DCCD PWM
return gpio_read(PINB,0x02);
case GPIO17: // LED PWM
return gpio_read_level(PINB,0x04);
case MCU_GPIO17: // LED PWM
return gpio_read(PINB,0x04);
default:
return 0;
}
}
void mcu::gpio_write(uint8_t ch, int8_t lvl)
void mcu_gpio_write(uint8_t ch, int8_t lvl)
{
switch(ch)
{
case GPIO0: // Mode DIN1
case MCU_GPIO0: // Mode DIN1
if(lvl>0)
{
PORTC |= 0x20;
@@ -233,7 +231,7 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
return;
case GPIO1: // Pot DIN2
case MCU_GPIO1: // Pot DIN2
if(lvl>0)
{
PORTC |= 0x10;
@@ -251,7 +249,7 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
return;
case GPIO2: // Down DIN3
case MCU_GPIO2: // Down DIN3
if(lvl>0)
{
PORTE |= 0x02;
@@ -269,7 +267,7 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
return;
case GPIO3: // Up DIN4
case MCU_GPIO3: // Up DIN4
if(lvl>0)
{
PORTE |= 0x08;
@@ -287,7 +285,7 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
return;
case GPIO7: // Handbrake pull DIN
case MCU_GPIO7: // Handbrake pull DIN
if(lvl>0)
{
PORTB |= 0x20;
@@ -305,42 +303,42 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
return;
case GPIO8: // Speed-pull
case MCU_GPIO8: // Speed-pull
if(lvl>0) PORTD |= 0x40;
else PORTD &= ~0x40;
return;
case GPIO9: // LED 0
case MCU_GPIO9: // LED 0
if(lvl>0) PORTD |= 0x01;
else PORTD &= ~0x01;
return;
case GPIO10: // LED 1
case MCU_GPIO10: // LED 1
if(lvl>0) PORTD |= 0x02;
else PORTD &= ~0x02;
return;
case GPIO11: // LED 2
case MCU_GPIO11: // LED 2
if(lvl>0) PORTD |= 0x04;
else PORTD &= ~0x04;
return;
case GPIO12: // LED 3
case MCU_GPIO12: // LED 3
if(lvl>0) PORTD |= 0x08;
else PORTD &= ~0x08;
return;
case GPIO13: // LED 4
case MCU_GPIO13: // LED 4
if(lvl>0) PORTD |= 0x10;
else PORTD &= ~0x10;
return;
case GPIO14: // LED 5
case MCU_GPIO14: // LED 5
if(lvl>0) PORTD |= 0x20;
else PORTD &= ~0x20;
return;
case GPIO15: // DCCD Enable
case MCU_GPIO15: // DCCD Enable
if(lvl>0) PORTB |= 0x01;
else PORTB &= ~0x01;
return;
@@ -350,96 +348,52 @@ void mcu::gpio_write(uint8_t ch, int8_t lvl)
}
}
void mcu::gpio_write_pull(uint8_t ch, int8_t lvl)
{
switch(ch)
{
case GPIO0: // Mode DIN1
if(lvl>0) PORTC |= 0x20;
else PORTC &= ~0x20;
return;
case GPIO1: // Pot DIN2
if(lvl>0) PORTC |= 0x10;
else PORTC &= ~0x10;
return;
case GPIO2: // Down DIN3
if(lvl>0) PORTE |= 0x02;
else PORTE &= ~0x02;
return;
case GPIO3: // Up DIN4
if(lvl>0) PORTE |= 0x08;
else PORTE &= ~0x08;
return;
case GPIO4: // Dimm
if(lvl>0) PORTD |= 0x80;
else PORTD &= ~0x80;
return;
case GPIO5: // Brakes
if(lvl>0) PORTB |= 0x80;
else PORTB &= ~0x80;
return;
case GPIO6: // Handbrake
if(lvl>0) PORTB |= 0x40;
else PORTB &= ~0x40;
return;
default:
return;
}
}
uint8_t mcu::eeprom_read8b(uint16_t address)
uint8_t mcu_ee_read8b(uint16_t address)
{
return eeprom_read_byte((uint8_t*)address);
}
uint16_t mcu::eeprom_read16b(uint16_t address)
uint16_t mcu_ee_read16b(uint16_t address)
{
return eeprom_read_word((uint16_t*)address);
}
uint32_t mcu::eeprom_read32b(uint16_t address)
uint32_t mcu_ee_read32b(uint16_t address)
{
return eeprom_read_dword((uint32_t*)address);
}
void mcu::eeprom_write8b(uint16_t address, uint8_t value)
void mcu_ee_write8b(uint16_t address, uint8_t value)
{
eeprom_write_byte((uint8_t*)address, value);
}
void mcu::eeprom_write16b(uint16_t address, uint16_t value)
void mcu_ee_write16b(uint16_t address, uint16_t value)
{
eeprom_write_word((uint16_t*)address, value);
}
void mcu::eeprom_write32b(uint16_t address, uint32_t value)
void mcu_ee_write32b(uint16_t address, uint32_t value)
{
eeprom_write_dword((uint32_t*)address, value);
}
/**** Private function definitions ****/
static uint8_t gpio_read_level(uint8_t pin_reg, uint8_t mask)
static uint8_t gpio_read(uint8_t pin_reg, uint8_t mask)
{
if(pin_reg&mask) return LEVEL_HIGH;
else return LEVEL_LOW;
if(pin_reg&mask) return MCU_GPIO_HIGH;
else return MCU_GPIO_LOW;
}
static void pwm_write_ocx(uint8_t ch, uint16_t value)
{
switch(ch)
{
case PWM0:
case MCU_PWM0:
OCR1A = value;
return;
case PWM1:
case MCU_PWM1:
OCR1B = value;
return;
@@ -452,13 +406,13 @@ static uint16_t pwm_read_ocx(uint8_t ch)
{
switch(ch)
{
case PWM0:
case MCU_PWM0:
return OCR1A;
case PWM1:
case MCU_PWM1:
return OCR1B ;
default:
return 0x0000;
}
}
}

80
firmware/src/hw/board/odout.c Normal file
View File

@@ -0,0 +1,80 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "odout.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t odout_pwm_mapping(uint8_t* pwm_ch);
static uint8_t odout_mapping(uint8_t od_ch, uint8_t* gpio_ch);
/**** Public function definitions ****/
void bsp_odout_write(uint8_t ch, int8_t lvl)
{
uint8_t gpio_ch;
// Get GPIO channel config, and check validity
if(odout_mapping(ch, &gpio_ch)) return;
// Set output level
if(lvl==0) mcu_gpio_write(gpio_ch, 1); // Output active
else mcu_gpio_write(gpio_ch, 0); // Output off
}
void bsp_odout_write_common(uint8_t percent)
{
uint8_t pwm_ch;
// Get PWM channel config, and check validity
if(odout_pwm_mapping(&pwm_ch)) return;
// Convert percent to 16b duty cycle
uint16_t dc = util_percent_to_16b(percent);
// Set PWM
mcu_pwm_write(pwm_ch, dc);
}
/**** Private function definitions ****/
static uint8_t odout_pwm_mapping(uint8_t* pwm_ch)
{
*pwm_ch = MCU_PWM1;
return 0;
}
static uint8_t odout_mapping(uint8_t od_ch, uint8_t* gpio_ch)
{
switch(od_ch)
{
case BSP_OD1: // LED0
*gpio_ch = MCU_GPIO9;
return 0;
case BSP_OD2: // LED1
*gpio_ch = MCU_GPIO10;
return 0;
case BSP_OD3: // LED2
*gpio_ch = MCU_GPIO11;
return 0;
case BSP_OD4: // LED3
*gpio_ch = MCU_GPIO12;
return 0;
case BSP_OD5: // LED4
*gpio_ch = MCU_GPIO13;
return 0;
case BSP_OD6: // LED5
*gpio_ch = MCU_GPIO14;
return 0;
default: //Invalid channel
*gpio_ch = 0;
return 1;
}
return 1;
}

37
firmware/src/hw/board/odout.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef ODOUT_H_
#define ODOUT_H_
/*
OD1 LED 0
OD2 LED 1
OD3 LED 2
OD4 LED 3
OD5 LED 4
OD6 LED 5
COMMON LED PWM
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define BSP_OD1 1
#define BSP_OD2 2
#define BSP_OD3 3
#define BSP_OD4 4
#define BSP_OD5 5
#define BSP_OD6 6
#define BSP_ODOUT_LOW 0
#define BSP_ODOUT_HIGH 1
#define BSP_ODOUT_HIZ -1
/**** Public function declarations ****/
void bsp_odout_write(uint8_t ch, int8_t lvl);
void bsp_odout_write_common(uint8_t percent);
#ifdef TESTING
#endif
#endif /* ODOUT_H_ */

23
firmware/src/hw/board/setup.c Normal file
View File

@@ -0,0 +1,23 @@
/**** Includes ****/
#include "utils/utils.h"
#include "mcu/mcu_hal.h"
#include "setup.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
/**** Private function definitions ****/
void bsp_startup(void)
{
startupCfg_t mcu_cfg;
mcu_cfg.adc_clk = MCU_ADC_DIV2;
mcu_cfg.pwm_clk = MCU_TIM_DIV1;
mcu_cfg.pwm_top = 511;
mcu_cfg.pwm_chb_en = 1;
mcu_startup(&mcu_cfg);
}

14
firmware/src/hw/board/setup.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef BSP_SETUP_H_
#define BSP_SETUP_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
/**** Public function declarations ****/
void bsp_startup(void);
#ifdef TESTING
#endif
#endif /* BSP_SETUP_H_ */

67
firmware/src/hw/board/utils/faults.c Normal file
View File

@@ -0,0 +1,67 @@
/**** Includes ****/
#include "faults.h"
#include "utils.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Mapping function declarations ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
#ifdef TESTING
#endif
uint8_t fault_process(fault_t* fault, uint8_t w_trig, uint8_t f_trig, fault_cfg_t* cfg)
{
// Override warning trigger in case of fault trigger
if(f_trig) w_trig = 1;
// Increase warning time, if reoccurring
if((w_trig)&&(fault->severity != FAULT_LVL_OK)) fault->w_time = util_sat_add_16b(fault->w_time, 1);
else fault->w_time = 0;
// Check if waring can be considered fault
if((cfg->wtof > 0)&&(fault->w_time > cfg->wtof)) f_trig = 1;
// Increase fault time, if reoccurring
if((f_trig)&&(fault->severity != FAULT_LVL_OK)) fault->f_time = util_sat_add_16b(fault->f_time, 1);
else fault->f_time = 0;
// Modify fault trigger
if((cfg->delay)&&(fault->f_time < cfg->delay)) f_trig = 0;
// Process fault level
if(f_trig)
{
fault->severity = FAULT_LVL_FAULT;
return 1;
}
else
{
if(w_trig) fault->severity = FAULT_LVL_WARNING;
else fault->severity = FAULT_LVL_OK;
}
return 0;
}
uint8_t fault_is_active(fault_t* fault)
{
if(fault->severity == FAULT_LVL_FAULT) return 1;
else return 0;
}
uint8_t fault_is_warning(fault_t* fault)
{
if(fault->severity != FAULT_LVL_OK) return 1;
else return 0;
}
void fault_reset(fault_t* fault)
{
fault->severity = FAULT_LVL_OK;
fault->w_time = 0;
fault->f_time = 0;
}
/**** Private function definitions ****/

37
firmware/src/hw/board/utils/faults.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef FAULTS_H_
#define FAULTS_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
typedef enum {
FAULT_LVL_OK,
FAULT_LVL_WARNING,
FAULT_LVL_FAULT
} fault_lvl_t;
typedef struct {
fault_lvl_t severity;
uint16_t w_time;
uint16_t f_time;
} fault_t;
typedef struct {
uint16_t delay;
uint16_t wtof;
} fault_cfg_t;
/**** Public function declarations ****/
uint8_t fault_process(fault_t* fault, uint8_t w_trig, uint8_t f_trig, fault_cfg_t* cfg);
uint8_t fault_is_active(fault_t* fault);
uint8_t fault_is_warning(fault_t* fault);
void fault_reset(fault_t* fault);
#ifdef TESTING
#endif
#endif /* FAULTS_H_ */

81
firmware/src/hw/board/utils/fuses.c Normal file
View File

@@ -0,0 +1,81 @@
/**** Includes ****/
#include "fuses.h"
#include "utils.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Mapping function declarations ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
#ifdef TESTING
#endif
void fuse_reset(fuse_t* fuse)
{
fuse->state = FUSE_OFF;
fuse->timer = 0;
fuse->count = 0;
}
uint8_t fuse_process(fuse_t* fuse, uint8_t fault, fuse_cfg_t* cfg)
{
// Active fault condition
if(fault)
{
// Note fuse time count
if((fuse->state == FUSE_OFF)||(fuse->state == FUSE_RETRY)) fuse->count++;
// Go to fused state in any case
fuse->state = FUSE_ACTIVE;
fuse->timer = 0;
return 1;
};
// No active fault condition
if(fuse->state==FUSE_ACTIVE)
{
// Go to cooldown
fuse->state = FUSE_COOLDOWN;
fuse->timer = cfg->cooldown_time;
};
// Wait for timeout
if(fuse->timer)
{
fuse->timer--;
if(fuse->state == FUSE_RETRY) return 0;
else return 1;
};
// Timeout end, transition logic
switch(fuse->state)
{
case FUSE_COOLDOWN:
// Cooldown end
if(cfg->retry_time)
{
fuse->state = FUSE_RETRY;
fuse->timer = cfg->retry_time;
}
else
{
fuse->state = FUSE_OFF;
fuse->timer = 0;
}
break;
case FUSE_RETRY:
// Go back to normal
fuse->state = FUSE_OFF;
break;
default:
// Nothing to do
break;
}
return 0;
}
/**** Private function definitions ****/

36
firmware/src/hw/board/utils/fuses.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef FUSES_H_
#define FUSES_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
typedef enum {
FUSE_OFF,
FUSE_ACTIVE,
FUSE_COOLDOWN,
FUSE_RETRY
} fuse_state_t;
typedef struct {
fuse_state_t state;
uint8_t count;
uint16_t timer;
} fuse_t;
typedef struct {
uint16_t cooldown_time;
uint16_t retry_time;
} fuse_cfg_t;
/**** Public function declarations ****/
void fuse_reset(fuse_t* fuse);
uint8_t fuse_process(fuse_t* fuse, uint8_t fault, fuse_cfg_t* cfg);
#ifdef TESTING
#endif
#endif /* FUSES_H_ */

272
firmware/src/hw/board/utils/utils.c Normal file
View File

@@ -0,0 +1,272 @@
/**** Includes ****/
#include "utils.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
#ifndef TESTING
static uint8_t find_interval_end_index(uint16_t val, uint16_t* axis_values, uint8_t len_axis);
static uint16_t interpolate_u16b(uint16_t x, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1);
static uint16_t index2d_to_index1d(uint8_t ix, uint8_t iy, uint8_t len_x);
#endif
/**** Public function definitions ****/
uint8_t util_invert_8b(uint8_t x)
{
if(x!=0) return 0;
else return 1;
}
uint8_t util_sat_add_8b(uint8_t x, uint8_t y)
{
uint8_t z = x + y;
// Check for overflow
if((z < x)||(z < y)) return 0xFF;
else return z;
}
uint8_t util_sat_subtract_8b(uint8_t x, uint8_t y)
{
uint8_t z = x - y;
// Check for underflow
if(z > x) return 0;
else return z;
}
uint16_t util_sat_add_16b(uint16_t x, uint16_t y)
{
uint16_t z = x + y;
// Check for overflow
if((z < x)||(z < y)) return 0xFFFF;
else return z;
}
uint16_t util_sat_subtract_16b(uint16_t x, uint16_t y)
{
uint16_t z = x - y;
// Check for underflow
if(z > x) return 0;
else return z;
}
uint16_t util_limit_u32b_to_u16b(uint32_t in)
{
if(in == 0) return 0;
else if(in >= 0x0000FFFF) return 0xFFFF;
else return (uint16_t)in;
}
uint16_t util_limit_s32b_to_u16b(int32_t in)
{
if(in <= 0) return 0;
else if(in >= 0x0000FFFF) return 0xFFFF;
else return (uint16_t)in;
}
uint16_t util_convert_muldivoff(uint16_t raw, uint8_t mul, uint8_t div, int16_t offset)
{
int32_t temp = (int32_t)raw;
temp = temp * mul;
if(div>1) temp /= div;
temp += offset;
return util_limit_s32b_to_u16b(temp);
}
uint16_t util_sat_mul_kilo(uint16_t xk, uint16_t yk)
{
uint32_t temp = (uint32_t)xk * (uint32_t)yk;
temp /= 1000;
return util_limit_u32b_to_u16b(temp);
}
uint16_t util_sat_div_kilo(uint16_t top, uint16_t bot)
{
//Sanity check bot
if(bot==0) return 0xFFFF; //aka infinity
uint32_t temp = (uint32_t)top * 1000;
temp /= (uint32_t)bot;
return util_limit_u32b_to_u16b(temp);
}
uint16_t util_sat_ratio_16b(uint16_t top, uint16_t bot)
{
//Sanity check bot
if(bot==0) return 0xFFFF; //aka infinity
//Easy option
if(top>=bot) return 0xFFFF;
uint32_t temp = (uint32_t)top * 0x0000FFFF;
temp /= (uint32_t)bot;
return util_limit_u32b_to_u16b(temp);
}
uint16_t util_percent_to_16b(uint8_t percent)
{
uint32_t temp = (uint32_t)percent * 0x0000FFFF;
temp /= 100;
// Limit to 16 bits
uint16_t pwm = util_limit_u32b_to_u16b(temp);
return pwm;
}
uint16_t util_interpolate_1d_u16b(uint16_t x, uint16_t* x_axis, uint16_t* y_values, uint8_t len_axis)
{
// validate axis length
if(len_axis==0) return 0; // Empty data set
if(len_axis==1) return y_values[0]; // Only one data point
uint16_t y;
uint8_t i = find_interval_end_index(x, x_axis, len_axis);
if(i==0)
{
//Less then start
y = y_values[0];
}
else if(i==len_axis)
{
//More than end
y = y_values[len_axis-1];
}
else
{
// Do interpolate
y = interpolate_u16b(x, x_axis[i-1], x_axis[i], y_values[i-1], y_values[i]);
}
return y;
}
uint16_t util_interpolate_2d_u16b(uint16_t x, uint16_t y, uint16_t* x_axis, uint8_t len_x_axis, uint16_t* y_axis, uint8_t len_y_axis, uint16_t* z_values)
{
// validate axis length
if((len_x_axis==0)&&(len_y_axis==0)) return 0; // Empty data set
if((len_x_axis==1)&&(len_y_axis==1)) return z_values[0]; // Only one data point
uint8_t ix = find_interval_end_index(x, x_axis, len_x_axis);
uint8_t iy = find_interval_end_index(y, y_axis, len_y_axis);
// Check corners - easy answers
if((ix==0)&&(iy==0))
{
return z_values[0]; //[0][0] [Y][X]
}
else if((ix==len_x_axis)&&(iy==0))
{
return z_values[len_x_axis-1]; //[0][end]
}
else if((ix==0)&&(iy==len_y_axis))
{
uint16_t i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
return z_values[i]; //[end][0]
}
else if((ix==len_x_axis)&&(iy==len_y_axis))
{
uint16_t i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
return z_values[i]; //[end][end]
};
// Check boundaries - 1D interpolation
if(ix==0)
{
// On ix=0 line
uint16_t i = 0;
uint16_t z0 = z_values[i];
i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate_u16b(y, y_axis[0], y_axis[len_y_axis-1], z0, z1);
}
else if(ix==len_x_axis)
{
// On ix=END line
uint16_t i = len_x_axis-1;
uint16_t z0 = z_values[i];
i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate_u16b(y, y_axis[0], y_axis[len_y_axis-1], z0, z1);
}
else if(iy==0)
{
// On iy=0 line
uint16_t i = 0;
uint16_t z0 = z_values[i];
i = len_x_axis-1;
uint16_t z1 = z_values[i];
return interpolate_u16b(x, x_axis[0], x_axis[len_x_axis-1], z0, z1);
}
else if(iy==len_y_axis)
{
// On iy=END line
uint16_t i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
uint16_t z0 = z_values[i];
i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate_u16b(x, x_axis[0], x_axis[len_x_axis-1], z0, z1);
}
// Do interpolation
// Get axis values
uint16_t x0 = x_axis[ix-1];
uint16_t x1 = x_axis[ix];
uint16_t y0 = y_axis[iy-1];
uint16_t y1 = y_axis[iy];
// Do y0 line calculation
// Get z values at x0 and x1 points on y0 line
uint16_t i = index2d_to_index1d(ix-1, iy-1, len_x_axis);
uint16_t z0 = z_values[i];
uint16_t z1 = z_values[i+1];
// Interpolate z value on y0 line
uint16_t zy0 = interpolate_u16b(x, x0, x1, z0, z1);
// Do y1 line calculation
// Get z values at x0 and x1 points on y1 line
i = index2d_to_index1d(ix-1, iy, len_x_axis);
z0 = z_values[i];
z1 = z_values[i+1];
// Interpolate z value on y0 line
uint16_t zy1 = interpolate_u16b(x, x0, x1, z0, z1);
// Do calculation in y axis on xz line
return interpolate_u16b(y, y0, y1, zy0, zy1);
}
/**** Private function definitions ****/
static uint16_t interpolate_u16b(uint16_t x, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1)
{
int32_t dy = (int32_t)y1 - (int32_t)y0;
int32_t dx = (int32_t)x1 - (int32_t)x0;
int32_t d = (int32_t)x - (int32_t)x0;
int32_t y = dy * d;
y /= dx;
y += y0;
return util_limit_s32b_to_u16b(y);
}
static uint8_t find_interval_end_index(uint16_t val, uint16_t* axis_values, uint8_t len_axis)
{
for(uint8_t i=0; i<len_axis; i++)
{
if(val < axis_values[i]) return i;
continue;
}
return len_axis;
}
static uint16_t index2d_to_index1d(uint8_t ix, uint8_t iy, uint8_t len_x)
{
return ((uint16_t)len_x * iy) + ix;
}

37
firmware/src/hw/board/utils/utils.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef UTILS_H_
#define UTILS_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
/**** Public function declarations ****/
uint8_t util_invert_8b(uint8_t x);
uint16_t util_limit_u32b_to_u16b(uint32_t in);
uint16_t util_limit_s32b_to_u16b(int32_t in);
uint16_t util_convert_muldivoff(uint16_t raw, uint8_t mul, uint8_t div, int16_t offset);
uint16_t util_sat_mul_kilo(uint16_t xk, uint16_t yk);
uint16_t util_sat_div_kilo(uint16_t top, uint16_t bot);
uint16_t util_sat_ratio_16b(uint16_t top, uint16_t bot);
uint16_t util_percent_to_16b(uint8_t percent);
uint8_t util_sat_add_8b(uint8_t x, uint8_t y);
uint8_t util_sat_subtract_8b(uint8_t x, uint8_t y);
uint16_t util_sat_add_16b(uint16_t x, uint16_t y);
uint16_t util_sat_subtract_16b(uint16_t x, uint16_t y);
uint16_t util_interpolate_1d_u16b(uint16_t x, uint16_t* x_axis, uint16_t* y_values, uint8_t len_axis);
uint16_t util_interpolate_2d_u16b(uint16_t x, uint16_t y, uint16_t* x_axis, uint8_t len_x_axis, uint16_t* y_axis, uint8_t len_y_axis, uint16_t* z_values);
#ifdef TESTING
// Access to private functions for unit testing
static uint8_t find_interval_end_index(uint16_t val, uint16_t* axis_values, uint8_t len_axis);
static uint16_t interpolate_u16b(uint16_t x, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1);
static uint16_t index2d_to_index1d(uint8_t ix, uint8_t iy, uint8_t len_x);
#endif
#endif /* UTILS_H_ */

85
firmware/src/hw/button.cpp
View File

@@ -1,85 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "button.h"
using namespace hw;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
hw::Button::Button(bsp::DigitalIn* din_ch, uint8_t act_lvl, uint8_t dbnc_lim, uint8_t init_state)
{
this->din_ch = din_ch;
if(act_lvl) this->act_lvl = bsp::DIN_HIGH;
else this->act_lvl = bsp::DIN_LOW;
this->dbnc_cnter = 0;
this->dbnc_lim = dbnc_lim;
if(init_state) this->state = BUTTON_ON;
else this->state = BUTTON_OFF;
this->time = 0;
this->is_new = 0;
}
hw::Button::~Button(void)
{
return;
}
uint8_t hw::Button::update(void)
{
// Read din level
uint8_t lvl = this->din_ch->last_read;
// Increase state counter
this->time = util::sat_add(this->time, 1);
// Determine next state
uint8_t next_state = BUTTON_OFF;
if(lvl==this->act_lvl) next_state = BUTTON_ON;
// Advance debounce sample counter
if(next_state != this->state) this->dbnc_cnter++;
else this->dbnc_cnter = 0;
// Check for debounce end
if(this->dbnc_cnter < this->dbnc_lim) return this->state;
// Debounce end. Apply new state.
this->state = next_state;
this->time = 0;
this->is_new = 1;
this->dbnc_cnter = 0;
return this->state;
}
uint8_t hw::Button::force_update(void)
{
// Read din level
uint8_t lvl = this->din_ch->read();
// Cancels active debounce
this->dbnc_cnter = 0;
// Determine next state
uint8_t next_state = BUTTON_OFF;
if(lvl==this->act_lvl) next_state = BUTTON_ON;
if(next_state != this->state)
{
this->state = next_state;
this->time = 0;
this->is_new = 1;
};
return this->state;
}
/**** Private function definitions ****/

41
firmware/src/hw/button.h
View File

@@ -1,41 +0,0 @@
#ifndef BUTTON_H_
#define BUTTON_H_
/**** Includes ****/
#include <stdint.h>
#include "../bsp/din.h"
namespace hw {
/**** Public definitions ****/
const uint8_t BUTTON_OFF = 0;
const uint8_t BUTTON_ON = 1;
class Button
{
protected:
bsp::DigitalIn* din_ch;
uint8_t act_lvl;
uint8_t dbnc_cnter;
public:
Button(bsp::DigitalIn* din_ch, uint8_t act_lvl, uint8_t dbnc_lim, uint8_t init_state);
~Button(void);
uint8_t state;
uint16_t time;
uint8_t dbnc_lim;
uint8_t is_new;
uint8_t update(void);
uint8_t force_update(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* BUTTON_H_ */

173
firmware/src/hw/buttons.c Normal file
View File

@@ -0,0 +1,173 @@
/**** Includes ****/
#include "board/utils/utils.h"
#include "board/din.h"
#include "board/dout.h"
#include "buttons.h"
/**** Private definitions ****/
/**** Private constants ****/
static const uint8_t DEF_DBNC_LIM = HW_BTN_DEF_DBNC_LIM;
static const uint16_t DEF_REPEAT_TIME = HW_BTN_DEF_REPEAT_TIME;
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t buttons_mapping(uint8_t btn_ch, uint8_t* din_ch, btn_cfg_t* cfg);
static uint8_t buttons_pull_mapping(uint8_t btn_ch, uint8_t* dout_ch);
/**** Public function definitions ****/
void btn_reset(btn_t* btn)
{
btn->state = BTN_INACTIVE;
btn->new_state = 0;
btn->state_time = 0;
btn->transition_cntr = 0;
btn->dbnc_active = 1;
}
uint8_t btn_ch_process(uint8_t btn_ch, btn_t* btn)
{
// Get channel config
uint8_t din_ch;
btn_cfg_t cfg;
if(buttons_mapping(btn_ch, &din_ch, &cfg)) return BTN_INACTIVE;
// Read din level
uint8_t lvl = bsp_din_read(din_ch);
// Process button logic
uint8_t btn_act = btn_process(lvl, btn, &cfg);
return btn_act;
}
uint8_t btn_process(uint8_t lvl, btn_t* btn, btn_cfg_t* cfg)
{
// Increase state time
btn->state_time = util_sat_add_16b(btn->state_time, 1);
// Check repeated new flag
if((cfg->repeat_time)&&(btn->state_time < 0xFFFF))
{
if((btn->state_time)%(cfg->repeat_time) == 0) btn->new_state = 1;
};
// Calculate saved level from state and active level cfg
uint8_t prev_lvl = 0;
if(((btn->dbnc_active)&&(btn->state))||((!btn->dbnc_active)&&(!btn->state))) prev_lvl = util_invert_8b(cfg->act_lvl);
else prev_lvl = cfg->act_lvl;
// Check if level changed
uint8_t lvl_chnaged = 0;
if(lvl!=prev_lvl) lvl_chnaged = 1;
//Process debounce logic
if(lvl_chnaged)
{
// Changed debounce state
if(!btn->dbnc_active) btn->dbnc_active = 1; // Start debounce
else btn->dbnc_active = 0; // Stop debounce
// Reset debounce counter
btn->transition_cntr = 0;
}
else
{
// Continue debounce
if(btn->dbnc_active) btn->transition_cntr += 1;
}
// Check for debounce end
if((btn->dbnc_active)&&(btn->transition_cntr >= cfg->dbnc_lim))
{
// Reset debounce
btn->dbnc_active = 0; //End debounce
btn->transition_cntr = 0;
// Set new state
if(lvl==cfg->act_lvl) btn->state = BTN_ACTIVE;
else btn->state = BTN_INACTIVE;
btn->state_time = 0; //Reset timer
btn->new_state = 1; //Set new flag
};
return btn->state;
}
void btn_ch_set_pull(uint8_t btn_ch, int8_t lvl)
{
// Get channel config
uint8_t dout_ch;
if(buttons_pull_mapping(btn_ch, &dout_ch)) return;
// Set button pull
bsp_dout_write(dout_ch, lvl);
}
/**** Private function definitions ****/
static uint8_t buttons_mapping(uint8_t btn_ch, uint8_t* din_ch, btn_cfg_t* cfg)
{
// Default, most common config
cfg->act_lvl = BSP_DIN_LOW;
cfg->dbnc_lim = DEF_DBNC_LIM;
cfg->repeat_time = DEF_REPEAT_TIME;
switch(btn_ch)
{
case BTN_1: // Mode
*din_ch = BSP_DIN1;
return 0;
case BTN_2: // Down
*din_ch = BSP_DIN3;
return 0;
case BTN_3: // Up
*din_ch = BSP_DIN4;
return 0;
case BTN_4: // Dimm
*din_ch = BSP_DIN5;
cfg->act_lvl = BSP_DIN_HIGH;
cfg->repeat_time = 0;
return 0;
case BTN_5: // Brakes
*din_ch = BSP_DIN6;
cfg->act_lvl = BSP_DIN_HIGH;
cfg->repeat_time = 0;
return 0;
case BTN_6: // Handbrake
*din_ch = BSP_DIN7;
cfg->repeat_time = 0;
return 0;
case BTN_6N: // Handbrake inverted
*din_ch = BSP_DIN7N;
cfg->repeat_time = 0;
return 0;
default: //Invalid channel
*din_ch = 0;
return 1;
}
return 1;
}
static uint8_t buttons_pull_mapping(uint8_t btn_ch, uint8_t* dout_ch)
{
switch(btn_ch)
{
case BTN_6: // Handbrake
*dout_ch = BSP_DOUT5;
return 0;
case BTN_6N: // Handbrake inverted
*dout_ch = BSP_DOUT5;
return 0;
default: //Invalid channel
*dout_ch = 0;
return 1;
}
return 1;
}

54
firmware/src/hw/buttons.h Normal file
View File

@@ -0,0 +1,54 @@
#ifndef BUTTONS_H_
#define BUTTONS_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
#include "config.h"
/**** Public definitions ****/
typedef struct {
uint8_t act_lvl;
uint8_t dbnc_lim;
uint16_t repeat_time;
} btn_cfg_t;
typedef struct {
uint8_t state;
uint8_t new_state;
uint16_t state_time;
uint8_t transition_cntr;
uint8_t dbnc_active;
} btn_t;
#define BTN_1 1 //DIN1 Mode
#define BTN_2 2 //DIN3 Down
#define BTN_3 3 //DIN4 Up
#define BTN_4 4 //DIN5 Dimm
#define BTN_5 5 //DIN6 Brakes
#define BTN_6 6 //DIN7 Handbrake
#define BTN_6N 7 //DIN7N Direct handbrake
#define BTN_INACTIVE 0
#define BTN_ACTIVE 1
#define BTN_PULL_LOW 0
#define BTN_PULL_HIGH 1
#define BTN_PULL_NONE -1
/**** Public function declarations ****/
void btn_reset(btn_t* btn);
// Using internal map
uint8_t btn_ch_process(uint8_t btn_ch, btn_t* btn);
void btn_ch_set_pull(uint8_t btn_ch, int8_t lvl);
// Manual process
uint8_t btn_process(uint8_t lvl, btn_t* btn, btn_cfg_t* cfg);
#ifdef TESTING
#endif
#endif /* BUTTONS_H_ */

45
firmware/src/hw/config.h Normal file
View File

@@ -0,0 +1,45 @@
#ifndef HW_CONFIG_H_
#define HW_CONFIG_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define HW_BTN_DEF_DBNC_LIM 10
#define HW_BTN_DEF_REPEAT_TIME 1000
#define HW_HB_SUPPLY_VOLT_MIN_W 10000
#define HW_HB_SUPPLY_VOLT_MIN_F 8000
#define HW_HB_SUPPLY_VOLT_MAX_W 16000
#define HW_HB_SUPPLY_VOLT_MAX_F 19500
#define HW_HB_SUPPLY_CURRENT_MAX_W 6000
#define HW_HB_SUPPLY_CURRENT_MAX_F 8000
#define HW_HB_SUPPLY_POWER_MAX_W 30000
#define HW_HB_SUPPLY_POWER_MAX_F 45000
#define HW_HB_OUT_CURRENT_MAX_W 6000
#define HW_HB_OUT_CURRENT_MAX_F 8000
#define HW_HB_OUT_VOLTAGE_MAX_W 8000
#define HW_HB_OUT_VOLTAGE_MAX_F 10000
#define HW_HB_OUT_POWER_MAX_W 30000
#define HW_HB_OUT_POWER_MAX_F 40000
#define HW_HB_OUT_RESISTANCE_MIN_W 750
#define HW_HB_OUT_RESISTANCE_MIN_F 500
#define HW_HB_OUT_RESISTANCE_MAX_W 5000
#define HW_HB_OUT_RESISTANCE_MAX_F 10000
#define HW_HB_FAULT_DELAY 500
#define HW_HB_WTOF_DELAY 0
/**** Public function declarations ****/
#ifdef TESTING
#endif
#endif /* HW_CONFIG_H_ */

53
firmware/src/hw/cv_otput.cpp
View File

@@ -1,53 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "cv_output.h"
using namespace hw;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
hw::CVoutput::CVoutput(bsp::Hafbridge* hbridge, bsp::AnalogIn* supply_u)
{
this->hbridge = hbridge;
this->supply = supply_u;
this->target = 0;
this->min_out = 0;
this->hbridge->disable();
}
hw::CVoutput::~CVoutput(void)
{
this->hbridge->write((uint16_t)0x0000);
this->hbridge->disable();
return;
}
void hw::CVoutput::update(void)
{
// Check target
if((this->target < this->min_out)&&(this->target > 0)) this->target = this->min_out;
// Set output
this->hbridge->write(util::sat_ratio(this->target, this->supply->last_read));
}
void hw::CVoutput::enable(void)
{
this->hbridge->enable();
}
void hw::CVoutput::disable(void)
{
this->hbridge->disable();
}
uint8_t hw::CVoutput::is_enabled(void)
{
return this->hbridge->is_enabled();
}
/**** Private function definitions ****/

39
firmware/src/hw/cv_output.h
View File

@@ -1,39 +0,0 @@
#ifndef CONST_VOLTAGE_OUTPUT_H_
#define CONST_VOLTAGE_OUTPUT_H_
/**** Includes ****/
#include <stdint.h>
#include "../bsp/ain.h"
#include "../bsp/halfbridge.h"
namespace hw {
/**** Public definitions ****/
class CVoutput
{
protected:
bsp::Hafbridge* hbridge;
bsp::AnalogIn* supply;
public:
CVoutput(bsp::Hafbridge* hbridge, bsp::AnalogIn* supply_u);
~CVoutput(void);
uint16_t target;
uint16_t min_out;
void update(void);
void enable(void);
void disable(void);
uint8_t is_enabled(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* CONST_VOLTAGE_OUTPUT_H_ */

180
firmware/src/hw/display_led.cpp
View File

@@ -1,180 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "display_led.h"
using namespace hw;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t img_gen_dot10(uint8_t percent);
static uint8_t img_gen_dot20(uint8_t percent);
static uint8_t img_gen_bar(uint8_t percent);
/**** Public function definitions ****/
hw::DisplayLed::DisplayLed(bsp::DigitalOut* led0, bsp::DigitalOut* led1, bsp::DigitalOut* led2, bsp::DigitalOut* led3, bsp::DigitalOut* led4, bsp::DigitalOut* led5, bsp::PWMout* common)
{
this->led0 = led0;
this->led1 = led1;
this->led2 = led2;
this->led3 = led3;
this->led4 = led4;
this->led5 = led5;
this->common = common;
this->led0->write(0);
this->led1->write(0);
this->led2->write(0);
this->led3->write(0);
this->led4->write(0);
this->led5->write(0);
this->common->write(0);
}
hw::DisplayLed::~DisplayLed(void)
{
this->led0->write(0);
this->led1->write(0);
this->led2->write(0);
this->led3->write(0);
this->led4->write(0);
this->led5->write(0);
this->common->write(0);
}
void hw::DisplayLed::show_percent(uint8_t percent, style_t style)
{
uint8_t image = 0x00;
switch(style)
{
case LED_DSP_BAR:
image = img_gen_bar(percent);
break;
case LED_DSP_DOT10:
image = img_gen_dot10(percent);
break;
default:
image = img_gen_dot20(percent);
break;
}
this->write(image);
}
void hw::DisplayLed::write(uint8_t image)
{
if(image&0x01) this->led0->write(1);
else this->led0->write(0);
if(image&0x02) this->led1->write(1);
else this->led1->write(0);
if(image&0x04) this->led2->write(1);
else this->led2->write(0);
if(image&0x08) this->led3->write(1);
else this->led3->write(0);
if(image&0x10) this->led4->write(1);
else this->led4->write(0);
if(image&0x20) this->led5->write(1);
else this->led5->write(0);
}
void hw::DisplayLed::set_brigthness(uint8_t percent)
{
this->common->write(percent);
}
/**** Private function definitions ****/
static uint8_t img_gen_dot10(uint8_t percent)
{
switch(percent)
{
case 0 ... 5:
return 0x01;
case 6 ... 15:
return 0x03;
case 16 ... 25:
return 0x02;
case 26 ... 35:
return 0x06;
case 36 ... 45:
return 0x04;
case 46 ... 55:
return 0x0C;
case 56 ... 65:
return 0x08;
case 66 ... 75:
return 0x18;
case 76 ... 85:
return 0x10;
case 86 ... 95:
return 0x30;
default:
return 0x20;
}
}
static uint8_t img_gen_dot20(uint8_t percent)
{
switch(percent)
{
case 0 ... 10:
return 0x01;
case 11 ... 30:
return 0x02;
case 31 ... 50:
return 0x04;
case 51 ... 70:
return 0x08;
case 71 ... 90:
return 0x10;
default:
return 0x20;
}
}
static uint8_t img_gen_bar(uint8_t percent)
{
switch(percent)
{
case 0 ... 10:
return 0x01;
case 11 ... 30:
return 0x03;
case 31 ... 50:
return 0x07;
case 51 ... 70:
return 0x0F;
case 71 ... 90:
return 0x1F;
default:
return 0x3F;
}
}

47
firmware/src/hw/display_led.h
View File

@@ -1,47 +0,0 @@
#ifndef DISPLAY_LED_H_
#define DISPLAY_LED_H_
/**** Includes ****/
#include <stdint.h>
#include "../bsp/dout.h"
#include "../bsp/pwm.h"
namespace hw {
/**** Public definitions ****/
class DisplayLed
{
protected:
bsp::DigitalOut* led0;
bsp::DigitalOut* led1;
bsp::DigitalOut* led2;
bsp::DigitalOut* led3;
bsp::DigitalOut* led4;
bsp::DigitalOut* led5;
bsp::PWMout* common;
public:
typedef enum {
LED_DSP_DOT20,
LED_DSP_DOT10,
LED_DSP_BAR
} style_t;
DisplayLed(bsp::DigitalOut* led0, bsp::DigitalOut* led1, bsp::DigitalOut* led2, bsp::DigitalOut* led3, bsp::DigitalOut* led4, bsp::DigitalOut* led5, bsp::PWMout* common);
~DisplayLed(void);
void show_percent(uint8_t percent, style_t style);
void write(uint8_t image);
void set_brigthness(uint8_t percent);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* DISPLAY_LED_H_ */

399
firmware/src/hw/hb_control.c Normal file
View File

@@ -0,0 +1,399 @@
/**** Includes ****/
#include "board/utils/utils.h"
#include "board/halfbridge.h"
#include "hb_control.h"
/**** Private definitions ****/
/**** Private constants ****/
// Fault condition thresholds
static const uint16_t SUPPLY_VOLT_MIN_W = HW_HB_SUPPLY_VOLT_MIN_W;
static const uint16_t SUPPLY_VOLT_MIN_F = HW_HB_SUPPLY_VOLT_MIN_F;
static const uint16_t SUPPLY_VOLT_MAX_W = HW_HB_SUPPLY_VOLT_MAX_W;
static const uint16_t SUPPLY_VOLT_MAX_F = HW_HB_SUPPLY_VOLT_MAX_F;
static const uint16_t SUPPLY_CURRENT_MAX_W = HW_HB_SUPPLY_CURRENT_MAX_W;
static const uint16_t SUPPLY_CURRENT_MAX_F = HW_HB_SUPPLY_CURRENT_MAX_F;
static const uint16_t SUPPLY_POWER_MAX_W = HW_HB_SUPPLY_POWER_MAX_W;
static const uint16_t SUPPLY_POWER_MAX_F = HW_HB_SUPPLY_POWER_MAX_F;
static const uint16_t OUT_CURRENT_MAX_W = HW_HB_OUT_CURRENT_MAX_W;
static const uint16_t OUT_CURRENT_MAX_F = HW_HB_OUT_CURRENT_MAX_F;
static const uint16_t OUT_VOLTAGE_MAX_W = HW_HB_OUT_VOLTAGE_MAX_W;
static const uint16_t OUT_VOLTAGE_MAX_F = HW_HB_OUT_VOLTAGE_MAX_F;
static const uint16_t OUT_POWER_MAX_W = HW_HB_OUT_POWER_MAX_W;
static const uint16_t OUT_POWER_MAX_F = HW_HB_OUT_POWER_MAX_F;
static const uint16_t OUT_RESISTANCE_MIN_W = HW_HB_OUT_RESISTANCE_MIN_W;
static const uint16_t OUT_RESISTANCE_MIN_F = HW_HB_OUT_RESISTANCE_MIN_F;
static const uint16_t OUT_RESISTANCE_MAX_W = HW_HB_OUT_RESISTANCE_MAX_W;
static const uint16_t OUT_RESISTANCE_MAX_F = HW_HB_OUT_RESISTANCE_MAX_F;
static const uint16_t FAULT_DELAY = HW_HB_FAULT_DELAY;
static const uint16_t WTOF_DELAY = HW_HB_WTOF_DELAY;
/**** Private variables ****/
/**** Private function declarations ****/
// Protection functions
static void faults_chs_reset(hb_fault_chs_t* ch_list);
static void faults_init(hb_faults_t* faults, hb_fault_chs_t* en_list);
static void faults_logic(hb_meas_t* measurements, hb_faults_t* faults);
static uint8_t faults_check(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list, fault_lvl_t check);
static uint8_t warnings_feedback(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list);
static uint8_t faults_feedback(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list);
static uint8_t faults_is_any(hb_fault_chs_t* fb_list);
static uint8_t is_outside(uint16_t meas, uint16_t min, uint16_t max);
static uint8_t fuse_subprocess(hb_feedback_t* hb_fb, hb_control_t* hb_ctrl);
static void target_to_control(int16_t target, uint16_t ref_voltage, uint16_t* pwm_out, uint8_t* low_out, hb_fault_chs_t* fault_ch_en);
/**** Public function definitions ****/
void hb_init(hb_feedback_t* hb_fb, hb_control_t* hb_ctrl)
{
// Initialize control
hb_ctrl->enabled = 0;
// Initialize protection structures
faults_init(&hb_ctrl->out_faults, &hb_ctrl->out_faults_en);
fuse_reset(&hb_ctrl->out_fuse);
hb_ctrl->out_fuse_cfg.cooldown_time = 1000;
hb_ctrl->out_fuse_cfg.retry_time = 1000;
// Initialize feedback structure
bsp_hb_read_meas(&hb_fb->analog);
faults_chs_reset(&hb_fb->faults);
faults_chs_reset(&hb_fb->warnings);
hb_fb->enabled = 0;
hb_fb->warning_act = 0;
hb_fb->fault_act = 0;
hb_fb->fused = 0;
bsp_hb_write_pwm(0);
bsp_hb_write_low(0);
}
void hb_enable(hb_control_t* hb_ctrl)
{
bsp_hb_write_pwm(0);
bsp_hb_write_low(1);
hb_ctrl->enabled = 1;
}
void hb_disable(hb_control_t* hb_ctrl)
{
hb_ctrl->enabled = 0;
bsp_hb_write_pwm(0);
bsp_hb_write_low(0);
}
void hb_process(int16_t target, hb_feedback_t* hb_fb, hb_control_t* hb_ctrl)
{
uint16_t out_pwm = 0;
uint8_t low_on = 0;
// Read feedback
bsp_hb_read_meas(&hb_fb->analog);
// Process fuse
uint8_t fuse_act = fuse_subprocess(hb_fb, hb_ctrl);
// Act on fuse state
if((fuse_act)||(!hb_ctrl->enabled))
{
// Turn off output
bsp_hb_write_pwm(0);
bsp_hb_write_low(0);
return;
};
// Process new target
target_to_control(target, hb_fb->analog.sup_voltage, &out_pwm, &low_on, &hb_ctrl->out_faults_en);
// Apply new controls
bsp_hb_write_low(low_on);
bsp_hb_write_pwm(out_pwm);
}
/**** Private function definitions ****/
static void target_to_control(int16_t target, uint16_t ref_voltage, uint16_t* pwm_out, uint8_t* low_out, hb_fault_chs_t* fault_ch_en)
{
if(target < 0)
{
// Fast decay
*pwm_out = 0;
*low_out = 0;
// Set appropriate fault channels
fault_ch_en->out_short = 0;
fault_ch_en->out_ovp = 0;
}
else if(target == 0)
{
// Slow decay
*pwm_out = 0;
*low_out = 1;
// Set appropriate fault channels
fault_ch_en->out_short = 0;
fault_ch_en->out_ovp = 1;
}
else
{
// Calculate target PWM
*pwm_out = util_sat_ratio_16b((uint16_t)target, ref_voltage);
*low_out = 1;
fault_ch_en->out_short = 1;
fault_ch_en->out_ovp = 1;
}
}
static uint8_t fuse_subprocess(hb_feedback_t* hb_fb, hb_control_t* hb_ctrl)
{
// Process faults
faults_logic(&hb_fb->analog, &hb_ctrl->out_faults);
// Check if any enabled fault is active
uint8_t warn_act = warnings_feedback(&hb_ctrl->out_faults, &hb_ctrl->out_faults_en, &hb_fb->warnings);
uint8_t fault_act = faults_feedback(&hb_ctrl->out_faults, &hb_ctrl->out_faults_en, &hb_fb->faults);
// Process fuse state
uint8_t fuse_act = fuse_process(&hb_ctrl->out_fuse, fault_act, &hb_ctrl->out_fuse_cfg);
// Copy feedback data
hb_fb->enabled = hb_ctrl->enabled;
hb_fb->warning_act = warn_act;
hb_fb->fault_act = fault_act;
hb_fb->fused = fuse_act;
return fuse_act;
}
// Fault logic functions
static void faults_chs_reset(hb_fault_chs_t* ch_list)
{
// Zero all channels
ch_list->sup_uvp = 0;
ch_list->sup_ovp = 0;
ch_list->sup_ocp = 0;
ch_list->sup_opp = 0;
ch_list->out_ovp = 0;
ch_list->out_ocp = 0;
ch_list->out_opp = 0;
ch_list->out_short = 0;
ch_list->out_open = 0;
}
static void faults_init(hb_faults_t* faults, hb_fault_chs_t* en_list)
{
// Init state
fault_reset(&faults->sup_uvp);
fault_reset(&faults->sup_ovp);
fault_reset(&faults->sup_ocp);
fault_reset(&faults->sup_opp);
fault_reset(&faults->out_ovp);
fault_reset(&faults->out_ocp);
fault_reset(&faults->out_opp);
fault_reset(&faults->out_short);
fault_reset(&faults->out_open);
// Init enabled channels
faults_chs_reset(en_list);
en_list->sup_ocp = 1;
en_list->out_ocp = 1;
en_list->out_short = 1;
}
static void faults_logic(hb_meas_t* measurements, hb_faults_t* faults)
{
uint8_t w_trig = 0;
uint8_t f_trig = 0;
fault_cfg_t fault_cfg;
fault_cfg.delay = FAULT_DELAY;
fault_cfg.wtof = WTOF_DELAY;
// Check supply voltage
w_trig = is_outside(measurements->sup_voltage, SUPPLY_VOLT_MIN_W, 0);
f_trig = is_outside(measurements->sup_voltage, SUPPLY_VOLT_MIN_F, 0);
fault_process(&faults->sup_uvp, w_trig, f_trig, &fault_cfg);
w_trig = is_outside(measurements->sup_voltage, 0, SUPPLY_VOLT_MAX_W);
f_trig = is_outside(measurements->sup_voltage, 0, SUPPLY_VOLT_MAX_F);
fault_process(&faults->sup_ovp, w_trig, f_trig, &fault_cfg);
// Check supply current
w_trig = is_outside(measurements->sup_current, 0, SUPPLY_CURRENT_MAX_W);
f_trig = is_outside(measurements->sup_current, 0, SUPPLY_CURRENT_MAX_F);
fault_process(&faults->sup_ocp, w_trig, f_trig, &fault_cfg);
// Check supply power
w_trig = is_outside(measurements->sup_power, 0, SUPPLY_POWER_MAX_W);
f_trig = is_outside(measurements->sup_power, 0, SUPPLY_POWER_MAX_F);
fault_process(&faults->sup_opp, w_trig, f_trig, &fault_cfg);
// Check output voltage
w_trig = is_outside(measurements->out_voltage, 0, OUT_VOLTAGE_MAX_W);
f_trig = is_outside(measurements->out_voltage, 0, OUT_VOLTAGE_MAX_F);
fault_process(&faults->out_ovp, w_trig, f_trig, &fault_cfg);
// Check output current
w_trig = is_outside(measurements->out_current, 0, OUT_CURRENT_MAX_W);
f_trig = is_outside(measurements->out_current, 0, OUT_CURRENT_MAX_F);
fault_process(&faults->out_ocp, w_trig, f_trig, &fault_cfg);
// Check output power
w_trig = is_outside(measurements->out_power, 0, OUT_POWER_MAX_W);
f_trig = is_outside(measurements->out_power, 0, OUT_POWER_MAX_F);
fault_process(&faults->out_opp, w_trig, f_trig, &fault_cfg);
// Check output resistance
w_trig = is_outside(measurements->out_impedance, OUT_RESISTANCE_MIN_W, 0);
f_trig = is_outside(measurements->out_impedance, OUT_RESISTANCE_MIN_F, 0);
fault_process(&faults->out_short, w_trig, f_trig, &fault_cfg);
w_trig = is_outside(measurements->out_impedance, 0, OUT_RESISTANCE_MAX_W);
f_trig = is_outside(measurements->out_impedance, 0, OUT_RESISTANCE_MAX_F);
fault_process(&faults->out_open, w_trig, f_trig, &fault_cfg);
}
static uint8_t warnings_feedback(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list)
{
return faults_check(faults, en_list, fb_list, FAULT_LVL_WARNING);
}
static uint8_t faults_feedback(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list)
{
return faults_check(faults, en_list, fb_list, FAULT_LVL_FAULT);
}
// Utilities
static uint8_t is_outside(uint16_t meas, uint16_t min, uint16_t max)
{
if((meas < min)||((max!=0)&&(meas > max))) return 1;
else return 0;
}
static uint8_t faults_check(hb_faults_t* faults, hb_fault_chs_t* en_list, hb_fault_chs_t* fb_list, fault_lvl_t check)
{
if((en_list->sup_uvp)&&(faults->sup_uvp.severity == check)) fb_list->sup_uvp = 1;
if((en_list->sup_ovp)&&(faults->sup_ovp.severity == check)) fb_list->sup_ovp = 1;
if((en_list->sup_ocp)&&(faults->sup_ocp.severity == check)) fb_list->sup_ocp = 1;
if((en_list->sup_opp)&&(faults->sup_opp.severity == check)) fb_list->sup_opp = 1;
if((en_list->out_ovp)&&(faults->out_ovp.severity == check)) fb_list->out_ovp = 1;
if((en_list->out_ocp)&&(faults->out_ocp.severity == check)) fb_list->out_ocp = 1;
if((en_list->out_opp)&&(faults->out_opp.severity == check)) fb_list->out_opp = 1;
if((en_list->out_short)&&(faults->out_short.severity == check)) fb_list->out_short = 1;
if((en_list->out_open)&&(faults->out_open.severity == check)) fb_list->out_open = 1;
return faults_is_any(fb_list);
}
static uint8_t faults_is_any(hb_fault_chs_t* fb_list)
{
if(fb_list->sup_uvp) return 1;
if(fb_list->sup_ovp) return 1;
if(fb_list->sup_ocp) return 1;
if(fb_list->sup_opp) return 1;
if(fb_list->out_ovp) return 1;
if(fb_list->out_ocp) return 1;
if(fb_list->out_opp) return 1;
if(fb_list->out_short) return 1;
if(fb_list->out_open) return 1;
return 0;
}
#ifdef TESTING
uint8_t hb_is_equal_fb_struct(hb_feedback_t* f1, hb_feedback_t* f2)
{
if(f1->analog.out_voltage != f2->analog.out_voltage ) return 0;
if(f1->analog.out_current != f2->analog.out_current ) return 0;
if(f1->analog.sup_voltage != f2->analog.sup_voltage ) return 0;
if(f1->analog.sup_current != f2->analog.sup_current ) return 0;
if(f1->analog.out_power != f2->analog.out_power ) return 0;
if(f1->analog.sup_power != f2->analog.sup_power ) return 0;
if(f1->analog.out_impedance != f2->analog.out_impedance ) return 0;
if(f1->analog.low_side_ctrl != f2->analog.low_side_ctrl ) return 0;
if(f1->analog.pwm != f2->analog.pwm ) return 0;
if(f1->enabled != f2->enabled ) return 0;
if(f1->warning_act != f2->warning_act ) return 0;
if(f1->fault_act != f2->fault_act ) return 0;
if(f1->fused != f2->fused ) return 0;
if(f1->warnings.sup_uvp != f2->warnings.sup_uvp ) return 0;
if(f1->warnings.sup_ovp != f2->warnings.sup_ovp ) return 0;
if(f1->warnings.sup_ocp != f2->warnings.sup_ocp ) return 0;
if(f1->warnings.sup_opp != f2->warnings.sup_opp ) return 0;
if(f1->warnings.out_ovp != f2->warnings.out_ovp ) return 0;
if(f1->warnings.out_ocp != f2->warnings.out_ocp ) return 0;
if(f1->warnings.out_opp != f2->warnings.out_opp ) return 0;
if(f1->warnings.out_short != f2->warnings.out_short ) return 0;
if(f1->warnings.out_open != f2->warnings.out_open ) return 0;
if(f1->faults.sup_uvp != f2->faults.sup_uvp ) return 0;
if(f1->faults.sup_ovp != f2->faults.sup_ovp ) return 0;
if(f1->faults.sup_ocp != f2->faults.sup_ocp ) return 0;
if(f1->faults.sup_opp != f2->faults.sup_opp ) return 0;
if(f1->faults.out_ovp != f2->faults.out_ovp ) return 0;
if(f1->faults.out_ocp != f2->faults.out_ocp ) return 0;
if(f1->faults.out_opp != f2->faults.out_opp ) return 0;
if(f1->faults.out_short != f2->faults.out_short ) return 0;
if(f1->faults.out_open != f2->faults.out_open ) return 0;
return 1;
}
uint8_t hb_is_equal_ctrl_struct(hb_control_t* c1, hb_control_t* c2)
{
if(c1->enabled != c2->enabled ) return 0;
if(c1->out_faults.sup_uvp.severity != c2->out_faults.sup_uvp.severity ) return 0;
if(c1->out_faults.sup_uvp.w_time != c2->out_faults.sup_uvp.w_time ) return 0;
if(c1->out_faults.sup_uvp.f_time != c2->out_faults.sup_uvp.f_time ) return 0;
if(c1->out_faults.sup_ovp.severity != c2->out_faults.sup_ovp.severity ) return 0;
if(c1->out_faults.sup_ovp.w_time != c2->out_faults.sup_ovp.w_time ) return 0;
if(c1->out_faults.sup_ovp.f_time != c2->out_faults.sup_ovp.f_time ) return 0;
if(c1->out_faults.sup_ocp.severity != c2->out_faults.sup_ocp.severity ) return 0;
if(c1->out_faults.sup_ocp.w_time != c2->out_faults.sup_ocp.w_time ) return 0;
if(c1->out_faults.sup_ocp.f_time != c2->out_faults.sup_ocp.f_time ) return 0;
if(c1->out_faults.sup_opp.severity != c2->out_faults.sup_opp.severity ) return 0;
if(c1->out_faults.sup_opp.w_time != c2->out_faults.sup_opp.w_time ) return 0;
if(c1->out_faults.sup_opp.f_time != c2->out_faults.sup_opp.f_time ) return 0;
if(c1->out_faults.out_ovp.severity != c2->out_faults.out_ovp.severity ) return 0;
if(c1->out_faults.out_ovp.w_time != c2->out_faults.out_ovp.w_time ) return 0;
if(c1->out_faults.out_ovp.f_time != c2->out_faults.out_ovp.f_time ) return 0;
if(c1->out_faults.out_ocp.severity != c2->out_faults.out_ocp.severity ) return 0;
if(c1->out_faults.out_ocp.w_time != c2->out_faults.out_ocp.w_time ) return 0;
if(c1->out_faults.out_ocp.f_time != c2->out_faults.out_ocp.f_time ) return 0;
if(c1->out_faults.out_opp.severity != c2->out_faults.out_opp.severity ) return 0;
if(c1->out_faults.out_opp.w_time != c2->out_faults.out_opp.w_time ) return 0;
if(c1->out_faults.out_opp.f_time != c2->out_faults.out_opp.f_time ) return 0;
if(c1->out_faults.out_short.severity != c2->out_faults.out_short.severity ) return 0;
if(c1->out_faults.out_short.w_time != c2->out_faults.out_short.w_time ) return 0;
if(c1->out_faults.out_short.f_time != c2->out_faults.out_short.f_time ) return 0;
if(c1->out_faults.out_open.severity != c2->out_faults.out_open.severity ) return 0;
if(c1->out_faults.out_open.w_time != c2->out_faults.out_open.w_time ) return 0;
if(c1->out_faults.out_open.f_time != c2->out_faults.out_open.f_time ) return 0;
if(c1->out_faults_en.sup_uvp != c2->out_faults_en.sup_uvp ) return 0;
if(c1->out_faults_en.sup_ovp != c2->out_faults_en.sup_ovp ) return 0;
if(c1->out_faults_en.sup_ocp != c2->out_faults_en.sup_ocp ) return 0;
if(c1->out_faults_en.sup_opp != c2->out_faults_en.sup_opp ) return 0;
if(c1->out_faults_en.out_ovp != c2->out_faults_en.out_ovp ) return 0;
if(c1->out_faults_en.out_ocp != c2->out_faults_en.out_ocp ) return 0;
if(c1->out_faults_en.out_opp != c2->out_faults_en.out_opp ) return 0;
if(c1->out_faults_en.out_short != c2->out_faults_en.out_short ) return 0;
if(c1->out_faults_en.out_open != c2->out_faults_en.out_open ) return 0;
if(c1->out_fuse.state != c2->out_fuse.state ) return 0;
if(c1->out_fuse.count != c2->out_fuse.count ) return 0;
if(c1->out_fuse.timer != c2->out_fuse.timer ) return 0;
if(c1->out_fuse_cfg.cooldown_time != c2->out_fuse_cfg.cooldown_time ) return 0;
if(c1->out_fuse_cfg.retry_time != c2->out_fuse_cfg.retry_time ) return 0;
return 1;
}
#endif

67
firmware/src/hw/hb_control.h Normal file
View File

@@ -0,0 +1,67 @@
#ifndef HB_CONTROL_H_
#define HB_CONTROL_H_
/**** Includes ****/
#include <stdint.h>
#include "board/utils/faults.h"
#include "board/utils/fuses.h"
#include "board/halfbridge.h"
#include "config.h"
/**** Public definitions ****/
typedef struct {
fault_t sup_uvp;
fault_t sup_ovp;
fault_t sup_ocp;
fault_t sup_opp;
fault_t out_ovp;
fault_t out_ocp;
fault_t out_opp;
fault_t out_short;
fault_t out_open;
} hb_faults_t;
typedef struct {
uint8_t sup_uvp;
uint8_t sup_ovp;
uint8_t sup_ocp;
uint8_t sup_opp;
uint8_t out_ovp;
uint8_t out_ocp;
uint8_t out_opp;
uint8_t out_short;
uint8_t out_open;
} hb_fault_chs_t;
typedef struct {
hb_meas_t analog;
uint8_t enabled;
uint8_t warning_act;
uint8_t fault_act;
uint8_t fused;
hb_fault_chs_t warnings;
hb_fault_chs_t faults;
} hb_feedback_t;
typedef struct {
uint8_t enabled;
hb_faults_t out_faults;
hb_fault_chs_t out_faults_en;
fuse_t out_fuse;
fuse_cfg_t out_fuse_cfg;
} hb_control_t;
/**** Public function declarations ****/
void hb_init(hb_feedback_t* hb_fb, hb_control_t* hb_ctrl);
void hb_enable(hb_control_t* hb_ctrl);
void hb_disable(hb_control_t* hb_ctrl);
void hb_process(int16_t target, hb_feedback_t* hb_fb, hb_control_t* hb_ctrl);
#ifdef TESTING
uint8_t hb_is_equal_fb_struct(hb_feedback_t* f1, hb_feedback_t* f2);
uint8_t hb_is_equal_ctrl_struct(hb_control_t* c1, hb_control_t* c2);
#endif
#endif /* HB_CONTROL_H_ */

38
firmware/src/hw/led_display.c Normal file
View File

@@ -0,0 +1,38 @@
/**** Includes ****/
#include "board/odout.h"
#include "led_display.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
void led_dsp_set_image(uint8_t image)
{
if(image&0x01) bsp_odout_write(BSP_OD1, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD1, BSP_ODOUT_HIZ);
if(image&0x02) bsp_odout_write(BSP_OD2, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD2, BSP_ODOUT_HIZ);
if(image&0x04) bsp_odout_write(BSP_OD3, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD3, BSP_ODOUT_HIZ);
if(image&0x08) bsp_odout_write(BSP_OD4, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD4, BSP_ODOUT_HIZ);
if(image&0x10) bsp_odout_write(BSP_OD5, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD5, BSP_ODOUT_HIZ);
if(image&0x20) bsp_odout_write(BSP_OD6, BSP_ODOUT_LOW);
else bsp_odout_write(BSP_OD6, BSP_ODOUT_HIZ);
}
void led_dsp_backligth_set(uint8_t percent)
{
bsp_odout_write_common(percent);
}
/**** Private function definitions ****/

19
firmware/src/hw/led_display.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef LED_DISPLAY_H_
#define LED_DISPLAY_H_
/*
*/
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
/**** Public function declarations ****/
void led_dsp_set_image(uint8_t image);
void led_dsp_backligth_set(uint8_t percent);
#ifdef TESTING
#endif
#endif /* LED_DISPLAY_H_ */

35
firmware/src/hw/potentiometer.cpp
View File

@@ -1,35 +0,0 @@
/**** Includes ****/
#include "../utils/utils.h"
#include "../utils/interpolate.h"
#include "potentiometer.h"
using namespace hw;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
hw::Potentiometer::Potentiometer(bsp::AnalogIn* ain_ch, uint16_t low_deadzone, uint16_t high_deadzone)
{
this->ain_ch = ain_ch;
this->low_deadzone = low_deadzone;
this->high_deadzone = high_deadzone;
this->percent = 0;
}
hw::Potentiometer::~Potentiometer(void)
{
return;
}
uint8_t hw::Potentiometer::update(void)
{
// Calculate percent
this->percent = util::interpolate(this->ain_ch->last_read, this->low_deadzone, this->high_deadzone, 0, 100);
return this->percent;
}
/**** Private function definitions ****/

35
firmware/src/hw/potentiometer.h
View File

@@ -1,35 +0,0 @@
#ifndef POTENTIOMETER_H_
#define POTENTIOMETER_H_
/**** Includes ****/
#include <stdint.h>
#include "../bsp/ain.h"
namespace hw {
/**** Public definitions ****/
class Potentiometer
{
protected:
bsp::AnalogIn* ain_ch;
public:
Potentiometer(bsp::AnalogIn* ain_ch, uint16_t low_deadzone, uint16_t high_deadzone);
~Potentiometer(void);
uint16_t low_deadzone;
uint16_t high_deadzone;
uint8_t percent;
uint8_t update(void);
};
/**** Public function declarations ****/
#ifdef TESTING
#endif
} //namespace
#endif /* POTENTIOMETER_H_ */

16
firmware/src/hw/startup.c Normal file
View File

@@ -0,0 +1,16 @@
/**** Includes ****/
#include "board/utils/utils.h"
#include "board/setup.h"
#include "startup.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
void hw_startup(void)
{
bsp_startup();
}
/**** Private function definitions ****/

14
firmware/src/hw/startup.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef HW_STARTUP_H_
#define HW_STARTUP_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
/**** Public function declarations ****/
void hw_startup(void);
#ifdef TESTING
#endif
#endif /* HW_STARTUP_H_ */

41
firmware/src/logic/coil.c Normal file
View File

@@ -0,0 +1,41 @@
/**** Includes ****/
#include "coil.h"
/**** Private definitions ****/
/**** Private constants ****/
static const int16_t TARGET_HANDBRAKE = COIL_TARGET_HANDBRAKE;
static const int16_t LOCK_VOLTAGE = COIL_LOCK_VOLTAGE;
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
int16_t coil_target(uint8_t force, uint8_t hbrake_act)
{
if(hbrake_act)
{
return TARGET_HANDBRAKE;
}
else if(force==0)
{
return 0;
}
else if(force >= 100)
{
return LOCK_VOLTAGE;
}
else
{
// Calculate target
uint32_t t = (uint32_t)force * LOCK_VOLTAGE;
t /= 100;
if(t > LOCK_VOLTAGE) return LOCK_VOLTAGE;
else if(t < 0) return 0;
else return (int16_t)t;
}
return 0;
}
/**** Private function definitions ****/

17
firmware/src/logic/coil.h Normal file
View File

@@ -0,0 +1,17 @@
#ifndef COIL_H_
#define COIL_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define COIL_TARGET_HANDBRAKE -1
#define COIL_LOCK_VOLTAGE 6500
/**** Public function declarations ****/
int16_t coil_target(uint8_t force, uint8_t hbrake_act);
#ifdef TESTING
#endif
#endif /* COIL_H_ */

108
firmware/src/logic/display.c Normal file
View File

@@ -0,0 +1,108 @@
/**** Includes ****/
#include "display.h"
/**** Private definitions ****/
/**** Private constants ****/
static const uint8_t BACKLIGHT_DIMM = DSP_BACKLIGHT_DIMM_PERCENT;
static const uint8_t BACKLIGHT_BRIGTH = DSP_BACKLIGHT_BRIGTH_PERCENT;
/**** Private variables ****/
/**** Private function declarations ****/
static uint8_t img_gen_dot10(uint8_t percent);
static uint8_t img_gen_dot20(uint8_t percent);
static uint8_t img_gen_bar(uint8_t percent);
/**** Public function definitions ****/
void dsp_init_ctrl(dsp_ctrl_t* ctrl)
{
ctrl->img_lock = 0;
ctrl->act_img = 0x00;
}
void dsp_set_lock(dsp_ctrl_t* ctrl)
{
ctrl->img_lock = 1;
}
void dsp_reset_lock(dsp_ctrl_t* ctrl)
{
ctrl->img_lock = 0;
}
uint8_t dsp_img_percent(uint8_t value, dsp_style_t style, dsp_ctrl_t* ctrl)
{
if(ctrl->img_lock) return ctrl->act_img;
switch(style)
{
case LED_DSP_BAR:
ctrl->act_img = img_gen_bar(value);
break;
case LED_DSP_DOT10:
ctrl->act_img = img_gen_dot10(value);
break;
default:
ctrl->act_img = img_gen_dot20(value);
break;
}
return ctrl->act_img;
}
uint8_t dsp_img_raw(uint8_t image, dsp_ctrl_t* ctrl)
{
if(ctrl->img_lock) return ctrl->act_img;
ctrl->act_img = image & 0x3F;
return ctrl->act_img;
}
uint8_t dsp_get_act_img(dsp_ctrl_t* ctrl)
{
return ctrl->act_img;
}
uint8_t dsp_backlight(uint8_t dimm_act)
{
if(dimm_act) return BACKLIGHT_DIMM;
else return BACKLIGHT_BRIGTH;
}
/**** Private function definitions ****/
static uint8_t img_gen_dot10(uint8_t percent)
{
if(percent<6) return 0x01;
else if(percent<16) return 0x03;
else if(percent<26) return 0x02;
else if(percent<36) return 0x06;
else if(percent<46) return 0x04;
else if(percent<56) return 0x0C;
else if(percent<66) return 0x08;
else if(percent<76) return 0x18;
else if(percent<86) return 0x10;
else if(percent<96) return 0x30;
else return 0x20;
}
static uint8_t img_gen_dot20(uint8_t percent)
{
if(percent<11) return 0x01;
else if(percent<31) return 0x02;
else if(percent<51) return 0x04;
else if(percent<71) return 0x08;
else if(percent<91) return 0x10;
else return 0x20;
}
static uint8_t img_gen_bar(uint8_t percent)
{
if(percent<11) return 0x01;
else if(percent<31) return 0x03;
else if(percent<51) return 0x07;
else if(percent<71) return 0x0F;
else if(percent<91) return 0x1F;
else return 0x3F;
}

37
firmware/src/logic/display.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef LOGIC_DISPLAY_H_
#define LOGIC_DISPLAY_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define DSP_BACKLIGHT_DIMM_PERCENT 50
#define DSP_BACKLIGHT_BRIGTH_PERCENT 100
typedef enum {
LED_DSP_DOT20,
LED_DSP_DOT10,
LED_DSP_BAR
} dsp_style_t;
typedef struct {
uint8_t img_lock;
uint8_t act_img;
} dsp_ctrl_t;
/**** Public function declarations ****/
void dsp_init_ctrl(dsp_ctrl_t* ctrl);
void dsp_set_lock(dsp_ctrl_t* ctrl);
void dsp_reset_lock(dsp_ctrl_t* ctrl);
uint8_t dsp_img_percent(uint8_t value, dsp_style_t style, dsp_ctrl_t* ctrl);
uint8_t dsp_img_raw(uint8_t image, dsp_ctrl_t* ctrl);
uint8_t dsp_get_act_img(dsp_ctrl_t* ctrl);
uint8_t dsp_backlight(uint8_t dimm_act);
#ifdef TESTING
#endif
#endif /* LOGIC_DISPLAY_H_ */

63
firmware/src/logic/force.c Normal file
View File

@@ -0,0 +1,63 @@
/**** Includes ****/
#include "force.h"
/**** Private definitions ****/
/**** Private constants ****/
static const uint16_t MAX_HBRAKE_HOLD_TIME = FORCE_MAX_HBRAKE_HOLD_TIME;
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
#ifdef TESTING
#endif
uint8_t force_next(uint8_t handbrake, uint8_t brakes, fbrake_mode_t bmode, uint8_t user_force, uint16_t hbarke_act_time)
{
// Do force logic
if((handbrake)&&(hbarke_act_time < MAX_HBRAKE_HOLD_TIME))
{
return 0;
}
else if(brakes)
{
switch(bmode)
{
case FORCE_BMODE_KEEP:
return user_force;
break;
case FORCE_BMODE_LOCK:
return 100;
break;
default: //FORCE_BMODE_OPEN
return 0;
break;
}
}
else
{
return user_force;
}
return 0;
}
fbrake_mode_t force_cycle_bmode(fbrake_mode_t bmode)
{
switch(bmode)
{
case FORCE_BMODE_OPEN:
return FORCE_BMODE_KEEP;
case FORCE_BMODE_KEEP:
return FORCE_BMODE_LOCK;
default:
return FORCE_BMODE_OPEN;
}
}
/**** Private function definitions ****/

23
firmware/src/logic/force.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef FORCE_H_
#define FORCE_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define FORCE_MAX_HBRAKE_HOLD_TIME 1000
typedef enum {
FORCE_BMODE_OPEN,
FORCE_BMODE_KEEP,
FORCE_BMODE_LOCK
} fbrake_mode_t;
/**** Public function declarations ****/
uint8_t force_next(uint8_t handbrake, uint8_t brakes, fbrake_mode_t bmode, uint8_t user_force, uint16_t hbarke_act_time);
fbrake_mode_t force_cycle_bmode(fbrake_mode_t bmode);
#ifdef TESTING
#endif
#endif /* FORCE_H_ */

42
firmware/src/logic/pot.c Normal file
View File

@@ -0,0 +1,42 @@
/**** Includes ****/
#include "pot.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
#ifdef TESTING
#endif
uint8_t pot_mv_to_percent(uint16_t value, pot_cfg_t* cfg)
{
// Setup limits
uint16_t bottom = 0;
uint16_t top = cfg->reference;
// Adjust for top and bottom deadband
if(bottom < cfg->deadband) bottom = cfg->deadband;
if(top > cfg->deadband) top -= cfg->deadband;
// Calculate percent
if(value <= bottom) return 0;
else if(value >= top) return 100;
else
{
// Adjust values for offset
if(bottom)
{
value = value - bottom;
top = top - bottom;
};
uint32_t y = (uint32_t)value * 100;
y = y/(uint32_t)top;
return (uint16_t)y;
}
}
/**** Private function definitions ****/

19
firmware/src/logic/pot.h Normal file
View File

@@ -0,0 +1,19 @@
#ifndef POTENTIOMETER_H_
#define POTENTIOMETER_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
typedef struct {
uint16_t reference;
uint16_t deadband;
} pot_cfg_t;
/**** Public function declarations ****/
uint8_t pot_mv_to_percent(uint16_t value, pot_cfg_t* cfg);
#ifdef TESTING
#endif
#endif /* POTENTIOMETER_H_ */

52
firmware/src/logic/user_force.c Normal file
View File

@@ -0,0 +1,52 @@
/**** Includes ****/
#include "user_force.h"
/**** Private definitions ****/
/**** Private constants ****/
static const uint8_t MAX_PERCENT = USER_FORCE_MAX_PERCENT;
static const uint8_t MIN_PERCENT = USER_FORCE_MIN_PERCENT;
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
#ifdef TESTING
#endif
uint8_t user_force_btn(uint8_t prev_force, uint8_t up_act, uint8_t down_act, uint8_t delta)
{
uint8_t new_froce = prev_force;
if(up_act)
{
new_froce = prev_force + delta;
// Limit overflow and top value
if(new_froce < prev_force) new_froce = 100;
else if(new_froce < MIN_PERCENT) new_froce = MIN_PERCENT;
};
if(down_act)
{
new_froce = prev_force - delta;
// Limit overflow and top value
if(new_froce > prev_force) new_froce = 0;
else if(new_froce > MAX_PERCENT) new_froce = MAX_PERCENT;
};
// Do deadband
if(new_froce < MIN_PERCENT) new_froce = 0;
else if(new_froce > MAX_PERCENT) new_froce = 100;
return new_froce;
}
uint8_t user_force_pot(uint8_t prev_force, uint8_t pot, uint8_t hyst)
{
uint8_t new_froce = pot;
if(new_froce < MIN_PERCENT) new_froce = 0;
else if(new_froce > MAX_PERCENT) new_froce = 100;
return new_froce;
}
/**** Private function definitions ****/

18
firmware/src/logic/user_force.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef USER_FORCE_H_
#define USER_FORCE_H_
/**** Includes ****/
#include <stdint.h>
/**** Public definitions ****/
#define USER_FORCE_MAX_PERCENT 90
#define USER_FORCE_MIN_PERCENT 10
/**** Public function declarations ****/
uint8_t user_force_btn(uint8_t prev_force, uint8_t up_act, uint8_t down_act, uint8_t delta);
uint8_t user_force_pot(uint8_t prev_force, uint8_t pot, uint8_t hyst);
#ifdef TESTING
#endif
#endif /* USER_FORCE_H_ */

127
firmware/src/main.c Normal file
View File

@@ -0,0 +1,127 @@
/**** Includes ****/
#include <stdint.h>
// Hardware IO
#include "hw/startup.h"
#include "hw/analog.h"
#include "hw/buttons.h"
#include "hw/hb_control.h"
#include "hw/led_display.h"
// Logic blocks
#include "logic/coil.h"
#include "logic/display.h"
#include "logic/force.h"
#include "logic/pot.h"
#include "logic/user_force.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
static volatile uint8_t user_force = 0;
static volatile uint8_t user_force_step = 10;
static volatile fbrake_mode_t bmode = FORCE_BMODE_OPEN;
static volatile uint8_t next_force = 0;
static volatile int16_t next_target = 0;
static volatile hb_feedback_t hb_feedback;
static volatile hb_control_t hb_ctrl;
static volatile uint8_t backlight = 0;
static volatile dsp_ctrl_t dsp_logic_ctrl;
/**** Private function declarations ****/
/**** Public function definitions ****/
int main(void)
{
hw_startup();
// Create objects for all buttons
btn_t btn_mode;
btn_t btn_down;
btn_t btn_up;
btn_t btn_dimm;
btn_t btn_brakes;
btn_t btn_handbrake;
btn_t btn_handbrake_dir;
// Set button pulls
//btn_ch_set_pull(BTN_1, BTN_PULL_HIGH);
//btn_ch_set_pull(BTN_2, BTN_PULL_HIGH);
//btn_ch_set_pull(BTN_3, BTN_PULL_HIGH);
btn_ch_set_pull(BTN_6, BTN_PULL_HIGH);
// Create object for half-bridge control
// Initialize half-bridge
hb_init(&hb_feedback, &hb_ctrl);
hb_enable(&hb_ctrl);
// Init display backlight
dsp_init_ctrl(&dsp_logic_ctrl);
backlight = dsp_backlight(1);
led_dsp_backligth_set(backlight);
while(1)
{
// Read buttons
btn_ch_process(BTN_1, &btn_mode);
btn_ch_process(BTN_2, &btn_down);
btn_ch_process(BTN_3, &btn_up);
btn_ch_process(BTN_4, &btn_dimm);
btn_ch_process(BTN_5, &btn_brakes);
btn_ch_process(BTN_6, &btn_handbrake);
btn_ch_process(BTN_6N, &btn_handbrake_dir);
// Process user force changes
if((btn_up.new_state)||(btn_down.new_state))
{
uint8_t up_act = btn_up.new_state & btn_up.state;
uint8_t down_act = btn_down.new_state & btn_down.state;
user_force = user_force_btn(user_force, up_act, down_act, user_force_step);
btn_up.new_state = 0;
btn_down.new_state = 0;
};
// Process brake mode changes
if(btn_mode.new_state)
{
if(btn_mode.state) bmode = force_cycle_bmode(bmode);
btn_mode.new_state = 0;
};
// Calculate next force
next_force = force_next(btn_handbrake.state, btn_brakes.state, bmode, user_force, btn_handbrake.state_time);
// Calculate next coil target
next_target = coil_target(next_force, btn_handbrake.state);
// Read Half-bridge status and apply next target
hb_process(next_target, &hb_feedback, &hb_ctrl);
// Generate image of current force
uint8_t img = 0x00;
if(hb_feedback.fused) img = 0xAA;
else img = dsp_img_percent(next_force, LED_DSP_DOT10);
// Apply image
led_dsp_set_image(img);
// Process display backlight
if(btn_dimm.new_state)
{
backlight = dsp_backlight(btn_dimm.state);
led_dsp_backligth_set(backlight);
btn_dimm.new_state = 0;
};
}
return 0;
}
/**** Private function definitions ****/

71
firmware/src/main.cpp
View File

@@ -1,71 +0,0 @@
/**** Includes ****/
#include "utils/utils.h"
#include "bsp/mcu/mcu_hal.h"
#include "bsp/ain.h"
#include "bsp/din.h"
#include "bsp/dout.h"
#include "bsp/dio.h"
#include "bsp/halfbridge.h"
#include "bsp/pwm.h"
#include "hw/button.h"
#include "hw/potentiometer.h"
#include "hw/display_led.h"
#include "hw/cv_output.h"
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
static bsp::AnalogIn dccd_i(mcu::ADC0);
static bsp::AnalogIn dccd_u(mcu::ADC1);
static bsp::AnalogIn bat_u(mcu::ADC2);
static bsp::AnalogIn bat_i(mcu::ADC3);
static bsp::Hafbridge hbridge(mcu::PWM0, mcu::GPIO15, 95);
static bsp::AnalogIn ain1(mcu::ADC5); // mode
static bsp::AnalogIn ain2(mcu::ADC4); // pot
static bsp::DigitalIn din1(mcu::GPIO0, 0, bsp::DIN_HIGH); //mode
static bsp::DigitalIn din2(mcu::GPIO1, 0, bsp::DIN_HIGH); //pot
static bsp::DigitalIn din3(mcu::GPIO2, 0, bsp::DIN_HIGH); //down
static bsp::DigitalIn din4(mcu::GPIO3, 0, bsp::DIN_HIGH); //up
static bsp::DigitalIn hvdin1(mcu::GPIO4, 1, bsp::DIN_LOW); //dimm
static bsp::DigitalIn hvdin2(mcu::GPIO5, 1, bsp::DIN_LOW); //brakes
static bsp::DigitalIn hvdin3(mcu::GPIO6, 1, bsp::DIN_LOW); //hbrake
static bsp::DigitalIO hvdin3_pull(mcu::GPIO7, bsp::DIN_HIGH); //hbrake pull
static bsp::DigitalOut odout1(mcu::GPIO9, 1);
static bsp::DigitalOut odout2(mcu::GPIO10, 1);
static bsp::DigitalOut odout3(mcu::GPIO11, 1);
static bsp::DigitalOut odout4(mcu::GPIO12, 1);
static bsp::DigitalOut odout5(mcu::GPIO13, 1);
static bsp::DigitalOut odout6(mcu::GPIO14, 1);
static bsp::PWMout od_pwm(mcu::PWM1);
static hw::Button btn_mode(&din1, bsp::DIN_LOW, 10, hw::BUTTON_OFF);
static hw::Button btn_up(&din4, bsp::DIN_LOW, 10, hw::BUTTON_OFF);
static hw::Button btn_down(&din3, bsp::DIN_LOW, 10, hw::BUTTON_OFF);
static hw::Button sw_dimm(&hvdin1, bsp::DIN_HIGH, 10, hw::BUTTON_OFF);
static hw::Button sw_brakes(&hvdin2, bsp::DIN_HIGH, 10, hw::BUTTON_OFF);
static hw::Button sw_hbrake(&hvdin3, bsp::DIN_LOW, 10, hw::BUTTON_OFF);
static hw::Potentiometer pot(&ain2, 500, 4500);
static hw::DisplayLed display(&odout1, &odout2, &odout3, &odout4, &odout5, &odout6, &od_pwm);
static hw::CVoutput cvout(&hbridge, &bat_u);
/**** Private function declarations ****/
/**** Public function definitions ****/
int main(void)
{
// Super loop
while(1)
{
continue; // End of super loop
}
// Escape the matrix
return 0;
}
/**** Private function definitions ***/

2
firmware/src/uDCCD.atsln → firmware/src/uDCCD_Controller.atsln
View File

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Atmel Studio Solution File, Format Version 11.00
VisualStudioVersion = 14.0.23107.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{E66E83B9-2572-4076-B26E-6BE79FF3018A}") = "uDCCD", "uDCCD.cppproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}"
Project("{54F91283-7BC4-4236-8FF9-10F437C3AD48}") = "uDCCD_Controller", "uDCCD_Controller.cproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution

4
firmware/src/uDCCD.componentinfo.xml → firmware/src/uDCCD_Controller.componentinfo.xml
View File

@@ -41,7 +41,7 @@
<Attribute>template</Attribute>
<Category>source</Category>
<Condition>C Exe</Condition>
<FileContentHash>KjvOcFWd++tbnsEMfVPd/w==</FileContentHash>
<FileContentHash>YLr2MkKo6ZooP7MhARWYNA==</FileContentHash>
<FileVersion></FileVersion>
<Name>templates/main.c</Name>
<SelectString>Main file (.c)</SelectString>
@@ -52,7 +52,7 @@
<Attribute>template</Attribute>
<Category>source</Category>
<Condition>C Exe</Condition>
<FileContentHash>w5aB/d0+DbxGZ7yY0aMMjw==</FileContentHash>
<FileContentHash>mkKaE95TOoATsuBGv6jmxg==</FileContentHash>
<FileVersion></FileVersion>
<Name>templates/main.cpp</Name>
<SelectString>Main file (.cpp)</SelectString>

205
firmware/src/uDCCD.cppproj → firmware/src/uDCCD_Controller.cproj
View File

@@ -3,47 +3,63 @@
<PropertyGroup>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>7.0</ProjectVersion>
<ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
<ToolchainName>com.Atmel.AVRGCC8.C</ToolchainName>
<ProjectGuid>dce6c7e3-ee26-4d79-826b-08594b9ad897</ProjectGuid>
<avrdevice>ATmega328PB</avrdevice>
<avrdeviceseries>none</avrdeviceseries>
<OutputType>Executable</OutputType>
<Language>CPP</Language>
<Language>C</Language>
<OutputFileName>$(MSBuildProjectName)</OutputFileName>
<OutputFileExtension>.elf</OutputFileExtension>
<OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
<AssemblyName>uDCCD</AssemblyName>
<Name>uDCCD</Name>
<RootNamespace>uDCCD</RootNamespace>
<AssemblyName>uDCCD_Controller</AssemblyName>
<Name>uDCCD_Controller</Name>
<RootNamespace>uDCCD_Controller</RootNamespace>
<ToolchainFlavour>Native</ToolchainFlavour>
<KeepTimersRunning>true</KeepTimersRunning>
<OverrideVtor>false</OverrideVtor>
<CacheFlash>true</CacheFlash>
<ProgFlashFromRam>true</ProgFlashFromRam>
<RamSnippetAddress />
<RamSnippetAddress>0x20000000</RamSnippetAddress>
<UncachedRange />
<preserveEEPROM>true</preserveEEPROM>
<OverrideVtorValue />
<OverrideVtorValue>exception_table</OverrideVtorValue>
<BootSegment>2</BootSegment>
<ResetRule>0</ResetRule>
<eraseonlaunchrule>0</eraseonlaunchrule>
<eraseonlaunchrule>1</eraseonlaunchrule>
<EraseKey />
<AsfFrameworkConfig>
<framework-data xmlns="">
<framework-data>
<options />
<configurations />
<files />
<documentation help="" />
<offline-documentation help="" />
<dependencies>
<content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.52.0" />
<content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.44.1" />
</dependencies>
</framework-data>
</AsfFrameworkConfig>
<avrtool>com.atmel.avrdbg.tool.atmelice</avrtool>
<avrtoolserialnumber>J42700001490</avrtoolserialnumber>
<avrdeviceexpectedsignature>0x1E9516</avrdeviceexpectedsignature>
<com_atmel_avrdbg_tool_atmelice>
<ToolOptions>
<InterfaceProperties>
<IspClock>125000</IspClock>
</InterfaceProperties>
<InterfaceName>debugWIRE</InterfaceName>
</ToolOptions>
<ToolType>com.atmel.avrdbg.tool.atmelice</ToolType>
<ToolNumber>J42700001490</ToolNumber>
<ToolName>Atmel-ICE</ToolName>
</com_atmel_avrdbg_tool_atmelice>
<avrtoolinterface>debugWIRE</avrtoolinterface>
<avrtoolinterfaceclock>125000</avrtoolinterfaceclock>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<ToolchainSettings>
<AvrGccCpp>
<AvrGcc>
<avrgcc.common.Device>-mmcu=atmega328pb -B "%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\gcc\dev\atmega328pb"</avrgcc.common.Device>
<avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
<avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
@@ -66,38 +82,22 @@
<avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
<avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
<avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcccpp.compiler.symbols.DefSymbols>
<ListValues>
<Value>NDEBUG</Value>
</ListValues>
</avrgcccpp.compiler.symbols.DefSymbols>
<avrgcccpp.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\include\</Value>
</ListValues>
</avrgcccpp.compiler.directories.IncludePaths>
<avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
<avrgcccpp.compiler.optimization.PackStructureMembers>True</avrgcccpp.compiler.optimization.PackStructureMembers>
<avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
<avrgcccpp.linker.libraries.Libraries>
<avrgcc.linker.libraries.Libraries>
<ListValues>
<Value>libm</Value>
</ListValues>
</avrgcccpp.linker.libraries.Libraries>
<avrgcccpp.assembler.general.IncludePaths>
</avrgcc.linker.libraries.Libraries>
<avrgcc.assembler.general.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\include\</Value>
</ListValues>
</avrgcccpp.assembler.general.IncludePaths>
</AvrGccCpp>
</avrgcc.assembler.general.IncludePaths>
</AvrGcc>
</ToolchainSettings>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<ToolchainSettings>
<AvrGccCpp>
<AvrGcc>
<avrgcc.common.Device>-mmcu=atmega328pb -B "%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\gcc\dev\atmega328pb"</avrgcc.common.Device>
<avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
<avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
@@ -116,130 +116,161 @@
<Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\include\</Value>
</ListValues>
</avrgcc.compiler.directories.IncludePaths>
<avrgcc.compiler.optimization.level>Optimize debugging experience (-Og)</avrgcc.compiler.optimization.level>
<avrgcc.compiler.optimization.PackStructureMembers>True</avrgcc.compiler.optimization.PackStructureMembers>
<avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcc.compiler.optimization.DebugLevel>Default (-g2)</avrgcc.compiler.optimization.DebugLevel>
<avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
<avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcccpp.compiler.symbols.DefSymbols>
<ListValues>
<Value>DEBUG</Value>
</ListValues>
</avrgcccpp.compiler.symbols.DefSymbols>
<avrgcccpp.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\include\</Value>
</ListValues>
</avrgcccpp.compiler.directories.IncludePaths>
<avrgcccpp.compiler.optimization.level>Optimize debugging experience (-Og)</avrgcccpp.compiler.optimization.level>
<avrgcccpp.compiler.optimization.PackStructureMembers>True</avrgcccpp.compiler.optimization.PackStructureMembers>
<avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcccpp.compiler.optimization.DebugLevel>Default (-g2)</avrgcccpp.compiler.optimization.DebugLevel>
<avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
<avrgcccpp.linker.libraries.Libraries>
<avrgcc.linker.libraries.Libraries>
<ListValues>
<Value>libm</Value>
</ListValues>
</avrgcccpp.linker.libraries.Libraries>
<avrgcccpp.assembler.general.IncludePaths>
</avrgcc.linker.libraries.Libraries>
<avrgcc.assembler.general.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\atmel\ATmega_DFP\1.7.374\include\</Value>
</ListValues>
</avrgcccpp.assembler.general.IncludePaths>
<avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
</AvrGccCpp>
</avrgcc.assembler.general.IncludePaths>
<avrgcc.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcc.assembler.debugging.DebugLevel>
</AvrGcc>
</ToolchainSettings>
</PropertyGroup>
<ItemGroup>
<Compile Include="bsp\ain.cpp">
<Compile Include="hw\analog.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\ain.h">
<Compile Include="hw\analog.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\din.cpp">
<Compile Include="hw\board\config.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\din.h">
<Compile Include="hw\board\dout.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\dio.cpp">
<Compile Include="hw\board\dout.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\dio.h">
<Compile Include="hw\board\setup.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\halfbridge.cpp">
<Compile Include="hw\board\setup.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\halfbridge.h">
<Compile Include="hw\board\utils\faults.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\mcu\mcu_hal.h">
<Compile Include="hw\board\utils\faults.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\mcu\mcu_hal_r8.cpp">
<Compile Include="hw\board\utils\fuses.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\dout.cpp">
<Compile Include="hw\board\utils\fuses.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\dout.h">
<Compile Include="hw\buttons.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\pwm.cpp">
<Compile Include="hw\buttons.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="bsp\pwm.h">
<Compile Include="hw\board\ain.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\button.cpp">
<Compile Include="hw\board\ain.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\button.h">
<Compile Include="hw\board\din.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\cv_otput.cpp">
<Compile Include="hw\board\din.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\cv_output.h">
<Compile Include="hw\board\halfbridge.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\display_led.cpp">
<Compile Include="hw\board\halfbridge.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\display_led.h">
<Compile Include="hw\board\mcu\mcu_hal.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\potentiometer.cpp">
<Compile Include="hw\board\mcu\mcu_hal_r8.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\potentiometer.h">
<Compile Include="hw\board\odout.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="main.cpp">
<Compile Include="hw\board\odout.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="utils\interpolate.cpp">
<Compile Include="hw\board\utils\utils.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="utils\interpolate.h">
<Compile Include="hw\board\utils\utils.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="utils\utils.cpp">
<Compile Include="hw\config.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="utils\utils.h">
<Compile Include="hw\hb_control.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\hb_control.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\led_display.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\led_display.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\startup.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="hw\startup.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\coil.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\coil.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\display.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\display.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\force.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\force.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\pot.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\pot.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\user_force.c">
<SubType>compile</SubType>
</Compile>
<Compile Include="logic\user_force.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="main.c">
<SubType>compile</SubType>
</Compile>
</ItemGroup>
<ItemGroup>
<Folder Include="bsp" />
<Folder Include="bsp\mcu" />
<Folder Include="hw" />
<Folder Include="utils" />
<Folder Include="hw\board" />
<Folder Include="hw\board\mcu" />
<Folder Include="hw\board\utils" />
<Folder Include="logic" />
</ItemGroup>
<Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
</Project>

163
firmware/src/utils/interpolate.cpp
View File

@@ -1,163 +0,0 @@
/**** Includes ****/
#include "utils.h"
#include "interpolate.h"
using namespace util;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
/**** Public function definitions ****/
uint16_t util::interpolate_1d(uint16_t x, uint16_t* x_axis, uint16_t* y_values, uint8_t len_axis)
{
// validate axis length
if(len_axis==0) return 0; // Empty data set
if(len_axis==1) return y_values[0]; // Only one data point
uint16_t y;
uint8_t i = find_interval_end_index(x, x_axis, len_axis);
if(i==0)
{
//Less then start
y = y_values[0];
}
else if(i==len_axis)
{
//More than end
y = y_values[len_axis-1];
}
else
{
// Do interpolate
y = interpolate(x, x_axis[i-1], x_axis[i], y_values[i-1], y_values[i]);
}
return y;
}
uint16_t util::interpolate_2d(uint16_t x, uint16_t y, uint16_t* x_axis, uint8_t len_x_axis, uint16_t* y_axis, uint8_t len_y_axis, uint16_t* z_values)
{
// validate axis length
if((len_x_axis==0)&&(len_y_axis==0)) return 0; // Empty data set
if((len_x_axis==1)&&(len_y_axis==1)) return z_values[0]; // Only one data point
uint8_t ix = find_interval_end_index(x, x_axis, len_x_axis);
uint8_t iy = find_interval_end_index(y, y_axis, len_y_axis);
// Check corners - easy answers
if((ix==0)&&(iy==0))
{
return z_values[0]; //[0][0] [Y][X]
}
else if((ix==len_x_axis)&&(iy==0))
{
return z_values[len_x_axis-1]; //[0][end]
}
else if((ix==0)&&(iy==len_y_axis))
{
uint16_t i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
return z_values[i]; //[end][0]
}
else if((ix==len_x_axis)&&(iy==len_y_axis))
{
uint16_t i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
return z_values[i]; //[end][end]
};
// Check boundaries - 1D interpolation
if(ix==0)
{
// On ix=0 line
uint16_t i = 0;
uint16_t z0 = z_values[i];
i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate(y, y_axis[0], y_axis[len_y_axis-1], z0, z1);
}
else if(ix==len_x_axis)
{
// On ix=END line
uint16_t i = len_x_axis-1;
uint16_t z0 = z_values[i];
i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate(y, y_axis[0], y_axis[len_y_axis-1], z0, z1);
}
else if(iy==0)
{
// On iy=0 line
uint16_t i = 0;
uint16_t z0 = z_values[i];
i = len_x_axis-1;
uint16_t z1 = z_values[i];
return interpolate(x, x_axis[0], x_axis[len_x_axis-1], z0, z1);
}
else if(iy==len_y_axis)
{
// On iy=END line
uint16_t i = index2d_to_index1d(0, len_y_axis-1, len_x_axis);
uint16_t z0 = z_values[i];
i = index2d_to_index1d(len_x_axis-1, len_y_axis-1, len_x_axis);
uint16_t z1 = z_values[i];
return interpolate(x, x_axis[0], x_axis[len_x_axis-1], z0, z1);
}
// Do interpolation
// Get axis values
uint16_t x0 = x_axis[ix-1];
uint16_t x1 = x_axis[ix];
uint16_t y0 = y_axis[iy-1];
uint16_t y1 = y_axis[iy];
// Do y0 line calculation
// Get z values at x0 and x1 points on y0 line
uint16_t i = index2d_to_index1d(ix-1, iy-1, len_x_axis);
uint16_t z0 = z_values[i];
uint16_t z1 = z_values[i+1];
// Interpolate z value on y0 line
uint16_t zy0 = interpolate(x, x0, x1, z0, z1);
// Do y1 line calculation
// Get z values at x0 and x1 points on y1 line
i = index2d_to_index1d(ix-1, iy, len_x_axis);
z0 = z_values[i];
z1 = z_values[i+1];
// Interpolate z value on y0 line
uint16_t zy1 = interpolate(x, x0, x1, z0, z1);
// Do calculation in y axis on xz line
return interpolate(y, y0, y1, zy0, zy1);
}
uint16_t interpolate(uint16_t x, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1)
{
int32_t dy = (int32_t)y1 - (int32_t)y0;
int32_t dx = (int32_t)x1 - (int32_t)x0;
int32_t d = (int32_t)x - (int32_t)x0;
int32_t y = dy * d;
y /= dx;
y += y0;
return util::sat_cast(y);
}
uint8_t find_interval_end_index(uint16_t val, uint16_t* axis_values, uint8_t len_axis)
{
for(uint8_t i=0; i<len_axis; i++)
{
if(val < axis_values[i]) return i;
continue;
}
return len_axis;
}
uint16_t index2d_to_index1d(uint8_t ix, uint8_t iy, uint8_t len_x)
{
return ((uint16_t)len_x * iy) + ix;
}
/**** Private function definitions ****/

23
firmware/src/utils/interpolate.h
View File

@@ -1,23 +0,0 @@
#ifndef UTILS_INTERPOLATE_H_
#define UTILS_INTERPOLATE_H_
/**** Includes ****/
#include <stdint.h>
namespace util {
/**** Public definitions ****/
/**** Public function declarations ****/
uint16_t interpolate_1d(uint16_t x, uint16_t* x_axis, uint16_t* y_values, uint8_t len_axis);
uint16_t interpolate_2d(uint16_t x, uint16_t y, uint16_t* x_axis, uint8_t len_x_axis, uint16_t* y_axis, uint8_t len_y_axis, uint16_t* z_values);
uint8_t find_interval_end_index(uint16_t val, uint16_t* axis_values, uint8_t len_axis);
uint16_t interpolate(uint16_t x, uint16_t x0, uint16_t x1, uint16_t y0, uint16_t y1);
uint16_t index2d_to_index1d(uint8_t ix, uint8_t iy, uint8_t len_x);
#ifdef TESTING
#endif
} //namespace
#endif /* UTILS_INTERPOLATE_H_ */

137
firmware/src/utils/utils.cpp
View File

@@ -1,137 +0,0 @@
/**** Includes ****/
#include "utils.h"
using namespace util;
/**** Private definitions ****/
/**** Private constants ****/
/**** Private variables ****/
/**** Private function declarations ****/
#ifndef TESTING
#endif
/**** Public function definitions ****/
uint8_t util::invert(uint8_t x)
{
if(x!=0) return 0;
else return 1;
}
uint8_t util::sat_add(uint8_t x, uint8_t y)
{
uint8_t z = x + y;
// Check for overflow
if((z < x)||(z < y)) return 0xFF;
else return z;
}
uint16_t util::sat_add(uint16_t x, uint16_t y)
{
uint16_t z = x + y;
// Check for overflow
if((z < x)||(z < y)) return 0xFF;
else return z;
}
uint32_t util::sat_add(uint32_t x, uint32_t y)
{
uint32_t z = x + y;
// Check for overflow
if((z < x)||(z < y)) return 0xFF;
else return z;
}
uint8_t util::sat_subtract(uint8_t x, uint8_t y)
{
uint8_t z = x - y;
// Check for underflow
if(z > x) return 0;
else return z;
}
uint16_t util::sat_subtract(uint16_t x, uint16_t y)
{
uint16_t z = x - y;
// Check for underflow
if(z > x) return 0;
else return z;
}
uint32_t util::sat_subtract(uint32_t x, uint32_t y)
{
uint32_t z = x - y;
// Check for underflow
if(z > x) return 0;
else return z;
}
uint16_t util::sat_cast(uint32_t x)
{
if(x > 0x0000FFFF) return 0xFFFF;
else return (uint16_t)x;
}
uint16_t util::sat_cast(int32_t x)
{
if(x < 0) return 0x0000;
else if(x > 0x0000FFFF) return 0xFFFF;
else return (uint16_t)x;
}
uint16_t util::convert_muldivoff(uint16_t raw, uint8_t mul, uint8_t div, int16_t offset)
{
int32_t temp = (int32_t)raw;
temp = temp * mul;
if(div>1) temp /= div;
temp += offset;
return sat_cast(temp);
}
uint16_t util::sat_mul_kilo(uint16_t xk, uint16_t yk)
{
uint32_t temp = (uint32_t)xk * (uint32_t)yk;
temp /= 1000;
return sat_cast(temp);
}
uint16_t util::sat_div_kilo(uint16_t top, uint16_t bot)
{
//Sanity check bot
if(bot==0) return 0xFFFF; //aka infinity
uint32_t temp = (uint32_t)top * 1000;
temp /= (uint32_t)bot;
return sat_cast(temp);
}
uint16_t util::sat_ratio(uint16_t top, uint16_t bot)
{
//Sanity check bot
if(bot==0) return 0xFFFF; //aka infinity
//Easy option
if(top>=bot) return 0xFFFF;
uint32_t temp = (uint32_t)top * 0x0000FFFF;
temp /= (uint32_t)bot;
return sat_cast(temp);
}
uint16_t util::percent_to_16b(uint8_t percent)
{
uint32_t temp = (uint32_t)percent * 0x0000FFFF;
temp /= 100;
// Limit to 16 bits
uint16_t pwm = sat_cast(temp);
return pwm;
}
/**** Private function definitions ****/

38
firmware/src/utils/utils.h
View File

@@ -1,38 +0,0 @@
#ifndef UTILS_H_
#define UTILS_H_
/**** Includes ****/
#include <stdint.h>
namespace util {
/**** Public definitions ****/
/**** Public function declarations ****/
uint8_t invert(uint8_t x);
uint16_t sat_cast(uint32_t x);
uint16_t sat_cast(int32_t x);
uint16_t convert_muldivoff(uint16_t raw, uint8_t mul, uint8_t div, int16_t offset);
uint16_t sat_mul_kilo(uint16_t xk, uint16_t yk);
uint16_t sat_div_kilo(uint16_t top, uint16_t bot);
uint16_t sat_ratio(uint16_t top, uint16_t bot);
uint16_t percent_to_16b(uint8_t percent);
uint8_t sat_add(uint8_t x, uint8_t y);
uint16_t sat_add(uint16_t x, uint16_t y);
uint32_t sat_add(uint32_t x, uint32_t y);
uint8_t sat_subtract(uint8_t x, uint8_t y);
uint16_t sat_subtract(uint16_t x, uint16_t y);
uint32_t sat_subtract(uint32_t x, uint32_t y);
uint16_t interpolate_1d(uint16_t x, uint16_t* x_axis, uint16_t* y_values, uint8_t len_axis);
uint16_t interpolate_2d(uint16_t x, uint16_t y, uint16_t* x_axis, uint8_t len_x_axis, uint16_t* y_axis, uint8_t len_y_axis, uint16_t* z_values);
#ifdef TESTING
#endif
} //namespace
#endif /* UTILS_H_ */

8
firmware/tests/Units_Tests.workspace Normal file
View File

@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_workspace_file>
<Workspace title="Workspace">
<Project filename="uDCCD_Unit_Tests_BSP.cbp" />
<Project filename="uDCCD_Unit_Tests_HW.cbp" />
<Project filename="uDCCD_Unit_Tests_Logic.cbp" />
</Workspace>
</CodeBlocks_workspace_file>

6
firmware/tests/Units_Tests.workspace.layout Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_workspace_layout_file>
<FileVersion major="1" minor="0" />
<ActiveProject path="uDCCD_Unit_Tests_Logic.cbp" />
<PreferredTarget name="Debug" />
</CodeBlocks_workspace_layout_file>

147
firmware/tests/bsp_main.c Normal file
View File

@@ -0,0 +1,147 @@
#include <stdio.h>
#include <stdlib.h>
#include "ut_utils/ut_utils.h"
#include "ut_utils/ut_fault.h"
#include "ut_utils/ut_fuses.h"
#include "ut_board/ut_ain.h"
#include "ut_board/ut_din.h"
#include "ut_board/ut_dout.h"
#include "ut_board/ut_halfbridge.h"
#include "ut_board/ut_odout.h"
#include "ut_board/ut_setup.h"
int main()
{
int tr;
int pass = 1;
/* UTILITIES TESTS */
printf("******************************************************\n");
tr = ut_util_invert_8b_test();
if(!tr) pass = 0;
tr = ut_util_sat_add_8b_test();
if(!tr) pass = 0;
tr = ut_util_sat_subtract_8b_test();
if(!tr) pass = 0;
tr = ut_util_sat_util_sat_add_16b_test();
if(!tr) pass = 0;
tr = ut_util_sat_subtract_16b_test();
if(!tr) pass = 0;
tr = ut_util_limit_u32b_to_u16b_test();
if(!tr) pass = 0;
tr = ut_util_limit_s32b_to_u16b_test();
if(!tr) pass = 0;
tr = ut_util_convert_muldivoff_test();
if(!tr) pass = 0;
tr = ut_util_sat_mul_kilo_test();
if(!tr) pass = 0;
tr = ut_util_sat_div_kilo_test();
if(!tr) pass = 0;
tr = ut_util_sat_ratio_16b_test();
if(!tr) pass = 0;
tr = ut_util_percent_to_16b_test();
if(!tr) pass = 0;
/* FAULT TESTS */
printf("******************************************************\n");
tr = ut_fault_process_test();
if(!tr) pass = 0;
tr = ut_fault_is_active_test();
if(!tr) pass = 0;
tr = ut_fault_is_warning_test();
if(!tr) pass = 0;
tr = ut_fault_reset_test();
if(!tr) pass = 0;
/* FUSE TESTS */
printf("******************************************************\n");
tr = ut_fuse_reset_test();
if(!tr) pass = 0;
/* AIN TESTS */
printf("******************************************************\n");
tr = ut_bsp_ain_read_test();
if(!tr) pass = 0;
/* DIN TESTS */
printf("******************************************************\n");
tr = ut_bsp_din_read_test();
if(!tr) pass = 0;
/* DOUT TESTS */
printf("******************************************************\n");
tr = ut_bsp_dout_write_test();
if(!tr) pass = 0;
/* HALFBRIDGE TESTS */
printf("******************************************************\n");
tr = ut_bsp_hb_write_low_test();
if(!tr) pass = 0;
tr = ut_bsp_hb_write_pwm_test();
if(!tr) pass = 0;
tr = ut_bsp_hb_read_meas_test();
if(!tr) pass = 0;
/* ODOUT TESTS */
printf("******************************************************\n");
tr = ut_bsp_odout_write_test();
if(!tr) pass = 0;
tr = ut_bsp_odout_write_common_test();
if(!tr) pass = 0;
/* SETUP TESTS */
printf("******************************************************\n");
tr = ut_bsp_startup_test();
if(!tr) pass = 0;
/* FINAL RESULT */
printf("******************************************************\n");
tr = ut_util_interpolate_1d_u16b_test();
if(!tr) pass = 0;
tr = ut_util_interpolate_2d_u16b_test();
if(!tr) pass = 0;
if(pass)
{
printf("ALL PASS\n\n");
return 1;
}
else
{
printf("SOME FAIL\n\n");
return 0;
}
return 0;
}

102
firmware/tests/hw_main.c Normal file
View File

@@ -0,0 +1,102 @@
#include <stdio.h>
#include <stdlib.h>
#include "ut_hw/ut_analog.h"
#include "ut_hw/ut_buttons.h"
#include "ut_hw/ut_hb_control.h"
#include "ut_hw/ut_led_display.h"
#include "ut_hw/ut_startup.h"
int main()
{
int tr;
int pass = 1;
int t_cnt = 0;
int f_cnt = 0;
/* ANALOG TESTS */
printf("******************************************************\n");
tr = ut_analog_ch_get_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* BUTTON TESTS */
printf("******************************************************\n");
tr = ut_btn_reset_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_btn_process_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_btn_ch_process_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_btn_ch_set_pull_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* HALFBRIDGE CONTROL TESTS */
printf("******************************************************\n");
tr = ut_hb_is_equal_fb_struct_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_hb_is_equal_ctrl_struct_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_hb_init_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_hb_enable_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_hb_disable_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_hb_process_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* DISPLAY TESTS */
printf("******************************************************\n");
tr = ut_led_dsp_set_image_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_led_dsp_backligth_set_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* STARTUP TESTS */
printf("******************************************************\n");
tr = ut_hw_startup_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
printf("******************************************************\n");
printf("\n%d TESTS DONE\n", t_cnt);
if(pass)
{
printf("ALL PASS\n\n");
return 1;
}
else
{
printf("%d FAILED\n\n", f_cnt);
return 0;
}
return 0;
}

98
firmware/tests/logic_main.c Normal file
View File

@@ -0,0 +1,98 @@
#include <stdio.h>
#include <stdlib.h>
#include "ut_logic/ut_coil.h"
#include "ut_logic/ut_display.h"
#include "ut_logic/ut_force.h"
#include "ut_logic/ut_pot.h"
#include "ut_logic/ut_user_force.h"
int main()
{
int tr;
int pass = 1;
int t_cnt = 0;
int f_cnt = 0;
/* COIL TESTS */
printf("******************************************************\n");
tr = ut_coil_target_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* DISPLAY TESTS */
printf("******************************************************\n");
tr = ut_dsp_init_ctrl_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_set_lock_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_reset_lock_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_img_percent_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_img_raw_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_get_act_img_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_dsp_backlight_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* FORCE TESTS */
printf("******************************************************\n");
tr = ut_force_cycle_bmode_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_force_next_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* POT TESTS */
printf("******************************************************\n");
tr = ut_pot_mv_to_percent_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
/* USER FORCE TESTS */
printf("******************************************************\n");
tr = ut_user_force_btn_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
tr = ut_user_force_pot_test();
t_cnt++;
if(!tr){ pass = 0; f_cnt++;};
printf("******************************************************\n");
printf("\n%d TESTS DONE\n", t_cnt);
if(pass)
{
printf("ALL PASS\n\n");
return 1;
}
else
{
printf("%d FAILED\n\n", f_cnt);
return 0;
}
return 0;
}

32
firmware/tests/mock_board/mock_board_ain.c Normal file
View File

@@ -0,0 +1,32 @@
#include "mock_board_ain.h"
#define AIN_CH_CNT 5
static uint8_t ain_ch = 0;
static uint16_t ain_data[AIN_CH_CNT+1];
uint16_t bsp_ain_read(uint8_t ch)
{
if(ch > AIN_CH_CNT) return 0;
ain_ch = ch;
return ain_data[ch];
}
uint8_t mock_board_ain_read_ch(void)
{
return ain_ch;
}
void mock_board_ain_write_ch(uint8_t ch)
{
ain_ch = ch;
}
uint16_t mock_board_ain_read_data(uint8_t ch)
{
return ain_data[ch];
}
void mock_board_ain_write_data(uint8_t ch, uint16_t value)
{
ain_data[ch] = value;
}

14
firmware/tests/mock_board/mock_board_ain.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef MOCK_BOARD_AIN_
#define MOCK_BOARD_AIN_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\ain.h"
uint8_t mock_board_ain_read_ch(void);
void mock_board_ain_write_ch(uint8_t ch);
uint16_t mock_board_ain_read_data(uint8_t ch);
void mock_board_ain_write_data(uint8_t ch, uint16_t value);
#endif /* MOCK_BOARD_AIN_ */

32
firmware/tests/mock_board/mock_board_din.c Normal file
View File

@@ -0,0 +1,32 @@
#include "mock_board_din.h"
#define DIN_CH_CNT 9
static uint8_t din_ch = 0;
static uint8_t din_data[DIN_CH_CNT];
uint8_t bsp_din_read(uint8_t ch)
{
if(ch >= DIN_CH_CNT) return BSP_DIN_LOW;
din_ch = ch;
return din_data[ch];
}
uint8_t mock_board_din_read_ch(void)
{
return din_ch;
}
void mock_board_din_write_ch(uint8_t ch)
{
din_ch = ch;
}
uint8_t mock_board_din_read_data(uint8_t ch)
{
return din_data[ch];
}
void mock_board_din_write_data(uint8_t ch, uint8_t value)
{
din_data[ch] = value;
}

14
firmware/tests/mock_board/mock_board_din.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef MOCK_BOARD_DIN_
#define MOCK_BOARD_DIN_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\din.h"
uint8_t mock_board_din_read_ch(void);
void mock_board_din_write_ch(uint8_t ch);
uint8_t mock_board_din_read_data(uint8_t ch);
void mock_board_din_write_data(uint8_t ch, uint8_t value);
#endif /* MOCK_BOARD_DIN_ */

31
firmware/tests/mock_board/mock_board_dout.c Normal file
View File

@@ -0,0 +1,31 @@
#include "mock_board_dout.h"
#define DOUT_CH_CNT 7
static uint8_t dout_ch = 0;
static int8_t dout_data[DOUT_CH_CNT];
void bsp_dout_write(uint8_t ch, int8_t lvl)
{
if(ch < DOUT_CH_CNT) dout_data[ch] = lvl;
dout_ch = ch;
}
uint8_t mock_board_dout_read_ch(void)
{
return dout_ch;
}
void mock_board_dout_write_ch(uint8_t ch)
{
dout_ch = ch;
}
int8_t mock_board_dout_read_data(uint8_t ch)
{
return dout_data[ch];
}
void mock_board_dout_write_data(uint8_t ch, int8_t lvl)
{
dout_data[ch] = lvl;
}

14
firmware/tests/mock_board/mock_board_dout.h Normal file
View File

@@ -0,0 +1,14 @@
#ifndef MOCK_BOARD_DOUT_
#define MOCK_BOARD_DOUT_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\dout.h"
uint8_t mock_board_dout_read_ch(void);
void mock_board_dout_write_ch(uint8_t ch);
int8_t mock_board_dout_read_data(uint8_t ch);
void mock_board_dout_write_data(uint8_t ch, int8_t lvl);
#endif /* MOCK_BOARD_DOUT_ */

76
firmware/tests/mock_board/mock_board_halfbridge.c Normal file
View File

@@ -0,0 +1,76 @@
#include "mock_board_halfbridge.h"
#define DOUT_CH_CNT 6
static uint8_t low_ctrl = 0;
static uint16_t pwm_ctrl = 0;
static hb_meas_t feedback;
void bsp_hb_write_low(uint8_t state)
{
low_ctrl = state;
}
void bsp_hb_write_pwm(uint16_t pwm)
{
pwm_ctrl = pwm;
}
void bsp_hb_read_meas(hb_meas_t* measurements)
{
measurements->out_voltage = feedback.out_voltage;
measurements->out_current = feedback.out_current;
measurements->sup_voltage = feedback.sup_voltage;
measurements->sup_current = feedback.sup_current;
measurements->out_power = feedback.out_power;
measurements->sup_power = feedback.sup_power;
measurements->out_impedance = feedback.out_impedance;
measurements->low_side_ctrl = feedback.low_side_ctrl;
measurements->pwm = feedback.pwm;
}
uint8_t mock_board_halfbridge_read_low(void)
{
return low_ctrl;
}
void mock_board_halfbridge_write_low(uint8_t state)
{
low_ctrl = state;
}
uint16_t mock_board_halfbridge_read_pwm(void)
{
return pwm_ctrl;
}
void mock_board_halfbridge_write_pwm(uint16_t pwm)
{
pwm_ctrl = pwm;
}
void mock_board_halfbridge_read_feedback(hb_meas_t* measurements)
{
measurements->out_voltage = feedback.out_voltage;
measurements->out_current = feedback.out_current;
measurements->sup_voltage = feedback.sup_voltage;
measurements->sup_current = feedback.sup_current;
measurements->out_power = feedback.out_power;
measurements->sup_power = feedback.sup_power;
measurements->out_impedance = feedback.out_impedance;
measurements->low_side_ctrl = feedback.low_side_ctrl;
measurements->pwm = feedback.pwm;
}
void mock_board_halfbridge_write_feedback(hb_meas_t* new_fb)
{
feedback.out_voltage = new_fb->out_voltage;
feedback.out_current = new_fb->out_current;
feedback.sup_voltage = new_fb->sup_voltage;
feedback.sup_current = new_fb->sup_current;
feedback.out_power = new_fb->out_power;
feedback.sup_power = new_fb->sup_power;
feedback.out_impedance = new_fb->out_impedance;
feedback.low_side_ctrl = new_fb->low_side_ctrl;
feedback.pwm = new_fb->pwm;
}

18
firmware/tests/mock_board/mock_board_halfbridge.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef MOCK_BOARD_HALFBRIDGE_
#define MOCK_BOARD_HALFBRIDGE_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\halfbridge.h"
uint8_t mock_board_halfbridge_read_low(void);
void mock_board_halfbridge_write_low(uint8_t state);
uint16_t mock_board_halfbridge_read_pwm(void);
void mock_board_halfbridge_write_pwm(uint16_t pwm);
void mock_board_halfbridge_read_feedback(hb_meas_t* measurements);
void mock_board_halfbridge_write_feedback(hb_meas_t* new_fb);
#endif /* MOCK_BOARD_HALFBRIDGE_ */

47
firmware/tests/mock_board/mock_board_odout.c Normal file
View File

@@ -0,0 +1,47 @@
#include "mock_board_odout.h"
#define ODOUT_CH_CNT 7
static uint8_t odout_ch = 0;
static int8_t odout_data[ODOUT_CH_CNT];
static uint8_t common_pwm = 0;
void bsp_odout_write(uint8_t ch, int8_t lvl)
{
if(ch < ODOUT_CH_CNT) odout_data[ch] = lvl;
odout_ch = ch;
}
void bsp_odout_write_common(uint8_t percent)
{
common_pwm = percent;
}
uint8_t mock_board_odout_read_ch(void)
{
return odout_ch;
}
void mock_board_odout_write_ch(uint8_t ch)
{
odout_ch = ch;
}
int8_t mock_board_odout_read_data(uint8_t ch)
{
return odout_data[ch];
}
void mock_board_odout_write_data(uint8_t ch, int8_t lvl)
{
odout_data[ch] = lvl;
}
uint8_t mock_board_odout_read_pwm(void)
{
return common_pwm;
}
void mock_board_odout_write_pwm(uint8_t percent)
{
common_pwm = percent;
}

16
firmware/tests/mock_board/mock_board_odout.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef MOCK_BOARD_ODOUT_
#define MOCK_BOARD_ODOUT_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\odout.h"
uint8_t mock_board_odout_read_ch(void);
void mock_board_odout_write_ch(uint8_t ch);
int8_t mock_board_odout_read_data(uint8_t ch);
void mock_board_odout_write_data(uint8_t ch, int8_t lvl);
uint8_t mock_board_odout_read_pwm(void);
void mock_board_odout_write_pwm(uint8_t percent);
#endif /* MOCK_BOARD_ODOUT_ */

18
firmware/tests/mock_board/mock_board_setup.c Normal file
View File

@@ -0,0 +1,18 @@
#include "mock_board_setup.h"
static uint8_t setup_called = 0;
void bsp_startup(void)
{
setup_called = 1;
}
uint8_t mock_board_setup_read_called(void)
{
return setup_called;
}
void mock_board_setup_reset_called(void)
{
setup_called = 0;
}

12
firmware/tests/mock_board/mock_board_setup.h Normal file
View File

@@ -0,0 +1,12 @@
#ifndef MOCK_BOARD_SETUP_
#define MOCK_BOARD_SETUP_
#include <stdio.h>
#include <stdlib.h>
#include "..\..\src\hw\board\setup.h"
uint8_t mock_board_setup_read_called(void);
void mock_board_setup_reset_called(void);
#endif /* MOCK_BOARD_SETUP_ */

178
firmware/tests/mock_mcu/mock_mcu_hal_r8.c Normal file
View File

@@ -0,0 +1,178 @@
#include "..\..\src\hw\board\mcu\mcu_hal.h"
#include "mock_mcu_hal_r8.h"
// Startup-Configuration functions
static startupCfg_t saved_hwCfg;
void mcu_startup(startupCfg_t* hwCfg)
{
saved_hwCfg.adc_clk = hwCfg->adc_clk;
saved_hwCfg.pwm_clk = hwCfg->pwm_clk;
saved_hwCfg.pwm_top = hwCfg->pwm_top;
saved_hwCfg.pwm_chb_en = hwCfg->pwm_chb_en;
}
void mock_mcu_startup_read_cfg(startupCfg_t* cfg_out)
{
cfg_out->adc_clk = saved_hwCfg.adc_clk;
cfg_out->pwm_clk = saved_hwCfg.pwm_clk;
cfg_out->pwm_top = saved_hwCfg.pwm_top;
cfg_out->pwm_chb_en = saved_hwCfg.pwm_chb_en;
}
void mock_mcu_startup_write_cfg(startupCfg_t* cfg_in)
{
saved_hwCfg.adc_clk = cfg_in->adc_clk;
saved_hwCfg.pwm_clk = cfg_in->pwm_clk;
saved_hwCfg.pwm_top = cfg_in->pwm_top;
saved_hwCfg.pwm_chb_en = cfg_in->pwm_chb_en;
}
// ADC Interface functions
#define ADC_CH_CNT 16
static uint8_t adc_ch = 0;
static uint16_t adc_raw[ADC_CH_CNT];
uint16_t mcu_adc_read(uint8_t ch)
{
adc_ch = ch;
//Safe guard mux
if(ch > (ADC_CH_CNT-1)) return 0xFFFF;
// Not available channels
if((ch > 8) && (ch<14)) return 0xFFFF;
return adc_raw[ch];
}
uint8_t mock_mcu_adc_read_ch(void)
{
return adc_ch;
}
void mock_mcu_adc_set_ch(uint8_t new_ch)
{
adc_ch = new_ch;
}
uint16_t mock_mcu_adc_read_raw(uint8_t ch)
{
return adc_raw[ch];
}
void mock_mcu_adc_set_raw(uint16_t new_adc_out, uint8_t ch)
{
adc_raw[ch] = new_adc_out;
}
// PWM Timer Interface functions
#define PWM_CH_CNT 2
static uint8_t pwm_ch = 0;
static uint16_t pwm_raw[PWM_CH_CNT];
void mcu_pwm_write(uint8_t ch, uint16_t dc)
{
pwm_ch = ch;
if(ch < PWM_CH_CNT) pwm_raw[ch] = dc;
}
uint16_t mcu_pwm_read(uint8_t ch)
{
pwm_ch = ch;
if(ch < PWM_CH_CNT) return pwm_raw[ch];
else return 0;
}
uint8_t mock_mcu_pwm_read_ch(void)
{
return pwm_ch;
}
void mock_mcu_pwm_set_ch(uint8_t new_ch)
{
pwm_ch = new_ch;
}
uint16_t mock_mcu_pwm_read_raw(uint8_t ch)
{
return pwm_raw[ch];
}
void mock_mcu_pwm_set_raw(uint16_t new_pwm, uint8_t ch)
{
pwm_raw[ch] = new_pwm;
}
// GPIO Functions
#define GPIO_CH_CNT 18
static uint8_t gpio_ch = 0;
static uint8_t gpio_input_lvl[GPIO_CH_CNT];
static int8_t gpio_output_lvl[GPIO_CH_CNT];
uint8_t mcu_gpio_read(uint8_t ch)
{
gpio_ch = ch;
if(ch < GPIO_CH_CNT) return gpio_input_lvl[ch];
else return 0;
}
void mcu_gpio_write(uint8_t ch, int8_t lvl)
{
gpio_ch = ch;
if(ch < GPIO_CH_CNT) gpio_output_lvl[ch] = lvl;
}
uint8_t mock_mcu_gpio_read_ch(void)
{
return gpio_ch;
}
void mock_mcu_gpio_set_ch(uint8_t new_ch)
{
gpio_ch = new_ch;
}
int8_t mock_mcu_gpio_read_output_lvl(uint8_t ch)
{
return gpio_output_lvl[ch];
}
void mock_mcu_gpio_set_output_lvl(int8_t new_output_lvl, uint8_t ch)
{
gpio_output_lvl[ch] = new_output_lvl;
}
void mock_mcu_gpio_set_input_lvl(uint8_t new_in_lvl, uint8_t ch)
{
gpio_input_lvl[ch] = new_in_lvl;
}
// EEPROM functions
uint8_t mcu_ee_read8b(uint16_t address)
{
return 0x00;
}
uint16_t mcu_ee_read16b(uint16_t address)
{
return 0x0000;
}
uint32_t mcu_ee_read32b(uint16_t address)
{
return 0x00000000;
}
void mcu_ee_write8b(uint16_t address, uint8_t value)
{
}
void mcu_ee_write16b(uint16_t address, uint16_t value)
{
}
void mcu_ee_write32b(uint16_t address, uint32_t value)
{
}

28
firmware/tests/mock_mcu/mock_mcu_hal_r8.h Normal file
View File

@@ -0,0 +1,28 @@
#ifndef MOCK_MCU_HAL_R8_
#define MOCK_MCU_HAL_R8_
#include <stdio.h>
#include <stdlib.h>
#include "../../src/hw/board/mcu/mcu_hal.h"
void mock_mcu_startup_read_cfg(startupCfg_t* cfg_out);
void mock_mcu_startup_write_cfg(startupCfg_t* cfg_in);
uint8_t mock_mcu_adc_read_ch(void);
void mock_mcu_adc_set_ch(uint8_t ch);
uint16_t mock_mcu_adc_read_raw(uint8_t ch);
void mock_mcu_adc_set_raw(uint16_t new_adc_out, uint8_t ch);
uint8_t mock_mcu_pwm_read_ch(void);
void mock_mcu_pwm_set_ch(uint8_t new_ch);
uint16_t mock_mcu_pwm_read_raw(uint8_t ch);
void mock_mcu_pwm_set_raw(uint16_t new_pwm, uint8_t ch);
uint8_t mock_mcu_gpio_read_ch(void);
void mock_mcu_gpio_set_ch(uint8_t new_ch);
int8_t mock_mcu_gpio_read_output_lvl(uint8_t ch);
void mock_mcu_gpio_set_output_lvl(int8_t new_output_lvl, uint8_t ch);
void mock_mcu_gpio_set_input_lvl(uint8_t new_in_lvl, uint8_t ch);
#endif /* MOCK_MCU_HAL_R8_ */

106
firmware/tests/uDCCD_Unit_Tests_BSP.cbp Normal file
View File

@@ -0,0 +1,106 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="uDCCD_Unit_Tests_BSP" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/uDCCD_Unit_Tests_BSP" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
</Compiler>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
</Compiler>
<Unit filename="../src/hw/board/ain.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/ain.h" />
<Unit filename="../src/hw/board/din.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/din.h" />
<Unit filename="../src/hw/board/dout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/dout.h" />
<Unit filename="../src/hw/board/halfbridge.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/halfbridge.h" />
<Unit filename="../src/hw/board/mcu/mcu_hal.h" />
<Unit filename="../src/hw/board/odout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/odout.h" />
<Unit filename="../src/hw/board/setup.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/setup.h" />
<Unit filename="../src/hw/board/utils/faults.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/faults.h" />
<Unit filename="../src/hw/board/utils/fuses.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/fuses.h" />
<Unit filename="../src/hw/board/utils/utils.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/utils.h" />
<Unit filename="bsp_main.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_mcu/mock_mcu_hal_r8.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_mcu/mock_mcu_hal_r8.h" />
<Unit filename="ut_board/ut_ain.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_ain.h" />
<Unit filename="ut_board/ut_din.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_din.h" />
<Unit filename="ut_board/ut_dout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_dout.h" />
<Unit filename="ut_board/ut_halfbridge.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_halfbridge.h" />
<Unit filename="ut_board/ut_odout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_odout.h" />
<Unit filename="ut_board/ut_setup.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_board/ut_setup.h" />
<Unit filename="ut_utils/ut_fault.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_utils/ut_fault.h" />
<Unit filename="ut_utils/ut_fuses.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_utils/ut_fuses.h" />
<Unit filename="ut_utils/ut_utils.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_utils/ut_utils.h" />
<Extensions>
<lib_finder disable_auto="1" />
</Extensions>
</Project>
</CodeBlocks_project_file>

348
firmware/tests/uDCCD_Unit_Tests_BSP.depend Normal file
View File

@@ -0,0 +1,348 @@
# depslib dependency file v1.0
1698696655 source:f:\microrally\udccd_controller\src\hw\board\ain.c
"utils/utils.h"
"mcu/mcu_hal.h"
"ain.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\utils.h
<stdint.h>
1698776270 f:\microrally\udccd_controller\src\hw\board\mcu\mcu_hal.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\board\ain.h
<stdint.h>
1698336545 source:f:\microrally\udccd_controller\src\hw\board\din.c
"utils/utils.h"
"mcu/mcu_hal.h"
"din.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\din.h
<stdint.h>
1698740890 source:f:\microrally\udccd_controller\src\hw\board\dout.c
"utils/utils.h"
"mcu/mcu_hal.h"
"dout.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\dout.h
<stdint.h>
1698575529 source:f:\microrally\udccd_controller\src\hw\board\halfbridge.c
"utils/utils.h"
"mcu/mcu_hal.h"
"halfbridge.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\halfbridge.h
<stdint.h>
1697628825 source:f:\microrally\udccd_controller\src\hw\board\odout.c
"utils/utils.h"
"mcu/mcu_hal.h"
"odout.h"
1699197585 f:\microrally\udccd_controller\src\hw\board\odout.h
<stdint.h>
1698336545 source:f:\microrally\udccd_controller\src\hw\board\setup.c
"utils/utils.h"
"mcu/mcu_hal.h"
"setup.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\setup.h
<stdint.h>
1699031869 source:f:\microrally\udccd_controller\src\hw\board\utils\faults.c
"faults.h"
"utils.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\faults.h
<stdint.h>
1699031869 source:f:\microrally\udccd_controller\src\hw\board\utils\fuses.c
"fuses.h"
"utils.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\fuses.h
<stdint.h>
1699031869 source:f:\microrally\udccd_controller\src\hw\board\utils\utils.c
"utils.h"
1699205020 source:f:\microrally\udccd_controller\tests\bsp_main.c
<stdio.h>
<stdlib.h>
"ut_utils/ut_utils.h"
"ut_utils/ut_fault.h"
"ut_utils/ut_fuses.h"
"ut_board/ut_ain.h"
"ut_board/ut_din.h"
"ut_board/ut_dout.h"
"ut_board/ut_halfbridge.h"
"ut_board/ut_odout.h"
"ut_board/ut_setup.h"
1699204674 f:\microrally\udccd_controller\tests\ut_utils\ut_utils.h
<stdio.h>
<stdlib.h>
1698870535 f:\microrally\udccd_controller\tests\ut_utils\ut_fault.h
<stdio.h>
<stdlib.h>
1698959419 f:\microrally\udccd_controller\tests\ut_utils\ut_fuses.h
<stdio.h>
<stdlib.h>
1699031869 f:\microrally\udccd_controller\tests\ut_board\ut_ain.h
<stdio.h>
<stdlib.h>
1699041803 f:\microrally\udccd_controller\tests\ut_board\ut_din.h
<stdio.h>
<stdlib.h>
1699042443 f:\microrally\udccd_controller\tests\ut_board\ut_dout.h
<stdio.h>
<stdlib.h>
1699051096 f:\microrally\udccd_controller\tests\ut_board\ut_halfbridge.h
<stdio.h>
<stdlib.h>
1699200555 source:f:\microrally\udccd_controller\tests\mock_mcu\mock_mcu_hal_r8.c
"..\..\src\hw\board\mcu\mcu_hal.h"
"mock_mcu_hal_r8.h"
1699200561 f:\microrally\udccd_controller\tests\mock_mcu\mock_mcu_hal_r8.h
<stdio.h>
<stdlib.h>
"../../src/hw/board/mcu/mcu_hal.h"
1699196285 source:f:\microrally\udccd_controller\tests\ut_board\ut_ain.c
"ut_ain.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\ain.h"
1699196304 source:f:\microrally\udccd_controller\tests\ut_board\ut_din.c
"ut_din.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\din.h"
1699196320 source:f:\microrally\udccd_controller\tests\ut_board\ut_dout.c
"ut_dout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\dout.h"
1699196359 source:f:\microrally\udccd_controller\tests\ut_board\ut_halfbridge.c
"ut_dout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\halfbridge.h"
1699196427 source:f:\microrally\udccd_controller\tests\ut_utils\ut_fault.c
"ut_fault.h"
"..\..\src\hw\board\utils\faults.h"
1699196445 source:f:\microrally\udccd_controller\tests\ut_utils\ut_fuses.c
"ut_fuses.h"
"..\..\src\hw\board\utils\fuses.h"
1699203820 source:f:\microrally\udccd_controller\tests\ut_utils\ut_utils.c
"ut_utils.h"
"..\..\src\hw\board\utils\utils.h"
1699200030 f:\microrally\udccd_controller\tests\ut_board\ut_odout.h
<stdio.h>
<stdlib.h>
1699200020 source:f:\microrally\udccd_controller\tests\ut_board\ut_odout.c
"ut_odout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\odout.h"
1699201018 f:\microrally\udccd_controller\tests\ut_board\ut_setup.h
<stdio.h>
<stdlib.h>
1699201095 source:f:\microrally\udccd_controller\tests\ut_board\ut_setup.c
"ut_odout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\setup.h"
1699018375 source:d:\microrally\udccd_controller\src\hw\board\ain.c
"utils/utils.h"
"mcu/mcu_hal.h"
"ain.h"
1699007962 d:\microrally\udccd_controller\src\hw\board\utils\utils.h
<stdint.h>
1699017409 d:\microrally\udccd_controller\src\hw\board\mcu\mcu_hal.h
<stdint.h>
1699535273 d:\microrally\udccd_controller\src\hw\board\ain.h
<stdint.h>
"config.h"
1698333216 source:d:\microrally\udccd_controller\src\hw\board\din.c
"utils/utils.h"
"mcu/mcu_hal.h"
"din.h"
1699535289 d:\microrally\udccd_controller\src\hw\board\din.h
<stdint.h>
1698673847 source:d:\microrally\udccd_controller\src\hw\board\dout.c
"utils/utils.h"
"mcu/mcu_hal.h"
"dout.h"
1699535296 d:\microrally\udccd_controller\src\hw\board\dout.h
<stdint.h>
1698656931 source:d:\microrally\udccd_controller\src\hw\board\halfbridge.c
"utils/utils.h"
"mcu/mcu_hal.h"
"halfbridge.h"
1699535318 d:\microrally\udccd_controller\src\hw\board\halfbridge.h
<stdint.h>
"config.h"
1697618884 source:d:\microrally\udccd_controller\src\hw\board\odout.c
"utils/utils.h"
"mcu/mcu_hal.h"
"odout.h"
1699257917 d:\microrally\udccd_controller\src\hw\board\odout.h
<stdint.h>
1698328348 source:d:\microrally\udccd_controller\src\hw\board\setup.c
"utils/utils.h"
"mcu/mcu_hal.h"
"setup.h"
1699017683 d:\microrally\udccd_controller\src\hw\board\setup.h
<stdint.h>
1699007034 source:d:\microrally\udccd_controller\src\hw\board\utils\faults.c
"faults.h"
"utils.h"
1699007033 d:\microrally\udccd_controller\src\hw\board\utils\faults.h
<stdint.h>
1699007093 source:d:\microrally\udccd_controller\src\hw\board\utils\fuses.c
"fuses.h"
"utils.h"
1699007094 d:\microrally\udccd_controller\src\hw\board\utils\fuses.h
<stdint.h>
1699264217 source:d:\microrally\udccd_controller\src\hw\board\utils\utils.c
"utils.h"
1699257917 source:d:\microrally\udccd_controller\tests\bsp_main.c
<stdio.h>
<stdlib.h>
"ut_utils/ut_utils.h"
"ut_utils/ut_fault.h"
"ut_utils/ut_fuses.h"
"ut_board/ut_ain.h"
"ut_board/ut_din.h"
"ut_board/ut_dout.h"
"ut_board/ut_halfbridge.h"
"ut_board/ut_odout.h"
"ut_board/ut_setup.h"
1699257917 d:\microrally\udccd_controller\tests\ut_utils\ut_utils.h
<stdio.h>
<stdlib.h>
1698921312 d:\microrally\udccd_controller\tests\ut_utils\ut_fault.h
<stdio.h>
<stdlib.h>
1699004735 d:\microrally\udccd_controller\tests\ut_utils\ut_fuses.h
<stdio.h>
<stdlib.h>
1699018575 d:\microrally\udccd_controller\tests\ut_board\ut_ain.h
<stdio.h>
<stdlib.h>
1699257917 d:\microrally\udccd_controller\tests\ut_board\ut_din.h
<stdio.h>
<stdlib.h>
1699257917 d:\microrally\udccd_controller\tests\ut_board\ut_dout.h
<stdio.h>
<stdlib.h>
1699257917 d:\microrally\udccd_controller\tests\ut_board\ut_halfbridge.h
<stdio.h>
<stdlib.h>
1699257917 d:\microrally\udccd_controller\tests\ut_board\ut_odout.h
<stdio.h>
<stdlib.h>
1699257917 d:\microrally\udccd_controller\tests\ut_board\ut_setup.h
<stdio.h>
<stdlib.h>
1699257917 source:d:\microrally\udccd_controller\tests\mock_mcu\mock_mcu_hal_r8.c
"..\..\src\hw\board\mcu\mcu_hal.h"
"mock_mcu_hal_r8.h"
1699257917 d:\microrally\udccd_controller\tests\mock_mcu\mock_mcu_hal_r8.h
<stdio.h>
<stdlib.h>
"../../src/hw/board/mcu/mcu_hal.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_ain.c
"ut_ain.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\ain.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_din.c
"ut_din.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\din.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_dout.c
"ut_dout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\dout.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_halfbridge.c
"ut_dout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\halfbridge.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_odout.c
"ut_odout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\odout.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_board\ut_setup.c
"ut_odout.h"
"..\mock_mcu\mock_mcu_hal_r8.h"
"..\..\src\hw\board\setup.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_utils\ut_fault.c
"ut_fault.h"
"..\..\src\hw\board\utils\faults.h"
1699257917 source:d:\microrally\udccd_controller\tests\ut_utils\ut_fuses.c
"ut_fuses.h"
"..\..\src\hw\board\utils\fuses.h"
1699264250 source:d:\microrally\udccd_controller\tests\ut_utils\ut_utils.c
"ut_utils.h"
"..\..\src\hw\board\utils\utils.h"
1699535389 d:\microrally\udccd_controller\src\hw\board\config.h
<stdint.h>

90
firmware/tests/uDCCD_Unit_Tests_BSP.layout Normal file
View File

@@ -0,0 +1,90 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<FileVersion major="1" minor="0" />
<ActiveTarget name="Debug" />
<File name="ut_utils\ut_utils.c" open="0" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="-1" zoom_2="0">
<Cursor>
<Cursor1 position="30322" topLine="1293" />
</Cursor>
</File>
<File name="ut_board\ut_ain.c" open="0" top="0" tabpos="5" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="1582" topLine="41" />
</Cursor>
</File>
<File name="ut_board\ut_odout.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="169" topLine="0" />
</Cursor>
</File>
<File name="mock_mcu\mock_mcu_hal_r8.c" open="0" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
<Cursor>
<Cursor1 position="2789" topLine="117" />
</Cursor>
</File>
<File name="ut_board\ut_dout.c" open="0" top="0" tabpos="7" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="4236" topLine="87" />
</Cursor>
</File>
<File name="..\src\hw\board\mcu\mcu_hal.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="844" topLine="0" />
</Cursor>
</File>
<File name="mock_mcu\mock_mcu_hal_r8.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="231" topLine="0" />
</Cursor>
</File>
<File name="ut_board\ut_setup.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
<Cursor>
<Cursor1 position="715" topLine="0" />
</Cursor>
</File>
<File name="..\src\hw\board\utils\utils.c" open="0" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="1" zoom_2="0">
<Cursor>
<Cursor1 position="5492" topLine="188" />
</Cursor>
</File>
<File name="ut_utils\ut_utils.h" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="4" zoom_2="0">
<Cursor>
<Cursor1 position="664" topLine="0" />
</Cursor>
</File>
<File name="ut_utils\ut_fuses.c" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="1650" topLine="24" />
</Cursor>
</File>
<File name="ut_board\ut_setup.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="8" zoom_2="0">
<Cursor>
<Cursor1 position="122" topLine="0" />
</Cursor>
</File>
<File name="bsp_main.c" open="0" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="5" zoom_2="0">
<Cursor>
<Cursor1 position="3165" topLine="121" />
</Cursor>
</File>
<File name="ut_board\ut_halfbridge.c" open="0" top="0" tabpos="8" split="0" active="1" splitpos="0" zoom_1="5" zoom_2="0">
<Cursor>
<Cursor1 position="2947" topLine="90" />
</Cursor>
</File>
<File name="ut_utils\ut_fault.c" open="0" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="29993" topLine="896" />
</Cursor>
</File>
<File name="ut_board\ut_odout.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="6" zoom_2="0">
<Cursor>
<Cursor1 position="5245" topLine="172" />
</Cursor>
</File>
<File name="ut_board\ut_din.c" open="0" top="0" tabpos="6" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="815" topLine="135" />
</Cursor>
</File>
</CodeBlocks_layout_file>

105
firmware/tests/uDCCD_Unit_Tests_HW.cbp Normal file
View File

@@ -0,0 +1,105 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="uDCCD_Unit_Tests_HW" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/uDCCD_Unit_Tests_HW" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-DTESTING" />
</Compiler>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
<Add option="-DTESTING" />
</Compiler>
<Unit filename="../src/hw/analog.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/analog.h" />
<Unit filename="../src/hw/board/utils/faults.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/faults.h" />
<Unit filename="../src/hw/board/utils/fuses.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/fuses.h" />
<Unit filename="../src/hw/board/utils/utils.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/board/utils/utils.h" />
<Unit filename="../src/hw/buttons.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/buttons.h" />
<Unit filename="../src/hw/hb_control.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/hb_control.h" />
<Unit filename="../src/hw/led_display.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/led_display.h" />
<Unit filename="../src/hw/startup.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/hw/startup.h" />
<Unit filename="hw_main.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_ain.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_ain.h" />
<Unit filename="mock_board/mock_board_din.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_din.h" />
<Unit filename="mock_board/mock_board_dout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_dout.h" />
<Unit filename="mock_board/mock_board_halfbridge.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_halfbridge.h" />
<Unit filename="mock_board/mock_board_odout.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_odout.h" />
<Unit filename="mock_board/mock_board_setup.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="mock_board/mock_board_setup.h" />
<Unit filename="ut_hw/ut_analog.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_hw/ut_analog.h" />
<Unit filename="ut_hw/ut_buttons.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_hw/ut_buttons.h" />
<Unit filename="ut_hw/ut_hb_control.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_hw/ut_hb_control.h" />
<Unit filename="ut_hw/ut_led_display.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_hw/ut_led_display.h" />
<Unit filename="ut_hw/ut_startup.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_hw/ut_startup.h" />
<Extensions />
</Project>
</CodeBlocks_project_file>

378
firmware/tests/uDCCD_Unit_Tests_HW.depend Normal file
View File

@@ -0,0 +1,378 @@
# depslib dependency file v1.0
1699007034 source:d:\microrally\udccd_controller\src\hw\board\utils\faults.c
"faults.h"
"utils.h"
1699007033 d:\microrally\udccd_controller\src\hw\board\utils\faults.h
<stdint.h>
1699007962 d:\microrally\udccd_controller\src\hw\board\utils\utils.h
<stdint.h>
1699007093 source:d:\microrally\udccd_controller\src\hw\board\utils\fuses.c
"fuses.h"
"utils.h"
1699007094 d:\microrally\udccd_controller\src\hw\board\utils\fuses.h
<stdint.h>
1699264217 source:d:\microrally\udccd_controller\src\hw\board\utils\utils.c
"utils.h"
1698741271 source:d:\microrally\udccd_controller\src\hw\analog.c
"board/utils/utils.h"
"board/ain.h"
"analog.h"
1699535273 d:\microrally\udccd_controller\src\hw\board\ain.h
<stdint.h>
"config.h"
1699017683 d:\microrally\udccd_controller\src\hw\analog.h
<stdint.h>
1699283768 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_dout.c
"mock_board_dout.h"
1699535296 d:\microrally\udccd_controller\src\hw\board\dout.h
<stdint.h>
1699272290 d:\microrally\udccd_controller\tests\mock_board\mock_board_dout.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\dout.h"
1699283776 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_odout.c
"mock_board_odout.h"
1699257917 d:\microrally\udccd_controller\src\hw\board\odout.h
<stdint.h>
1699272272 d:\microrally\udccd_controller\tests\mock_board\mock_board_odout.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\odout.h"
1699272265 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_setup.c
"mock_board_setup.h"
1699017683 d:\microrally\udccd_controller\src\hw\board\setup.h
<stdint.h>
1699272264 d:\microrally\udccd_controller\tests\mock_board\mock_board_setup.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\setup.h"
1699516357 source:d:\microrally\udccd_controller\tests\hw_main.c
<stdio.h>
<stdlib.h>
"ut_hw/ut_analog.h"
"ut_hw/ut_buttons.h"
"ut_hw/ut_hb_control.h"
"ut_hw/ut_led_display.h"
"ut_hw/ut_startup.h"
1699271694 d:\microrally\udccd_controller\tests\ut_hw\ut_analog.h
<stdio.h>
<stdlib.h>
1699272372 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_ain.c
"mock_board_ain.h"
1699272245 d:\microrally\udccd_controller\tests\mock_board\mock_board_ain.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\ain.h"
1699283758 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_din.c
"mock_board_din.h"
1699535289 d:\microrally\udccd_controller\src\hw\board\din.h
<stdint.h>
1699272297 d:\microrally\udccd_controller\tests\mock_board\mock_board_din.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\din.h"
1699535318 d:\microrally\udccd_controller\src\hw\board\halfbridge.h
<stdint.h>
"config.h"
1699272285 source:d:\microrally\udccd_controller\tests\mock_board\mock_board_halfbridge.c
"mock_board_halfbridge.h"
1699287859 d:\microrally\udccd_controller\tests\mock_board\mock_board_halfbridge.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\halfbridge.h"
1699276363 source:d:\microrally\udccd_controller\tests\ut_hw\ut_analog.c
"ut_analog.h"
"..\mock_board\mock_board_ain.h"
"..\..\src\hw\analog.h"
1699284536 source:d:\microrally\udccd_controller\tests\ut_hw\ut_buttons.c
"ut_buttons.h"
"..\mock_board\mock_board_din.h"
"..\mock_board\mock_board_dout.h"
"..\..\src\hw\buttons.h"
1699284495 d:\microrally\udccd_controller\tests\ut_hw\ut_buttons.h
<stdio.h>
<stdlib.h>
1699535453 d:\microrally\udccd_controller\src\hw\buttons.h
<stdint.h>
"config.h"
1699516357 source:d:\microrally\udccd_controller\src\hw\buttons.c
"board/utils/utils.h"
"board/din.h"
"board/dout.h"
"buttons.h"
1699373886 source:d:\microrally\udccd_controller\src\hw\hb_control.c
"board/utils/utils.h"
"board/halfbridge.h"
"hb_control.h"
1699351840 d:\microrally\udccd_controller\src\hw\hb_control.h
<stdint.h>
"board/utils/faults.h"
"board/utils/fuses.h"
"board/halfbridge.h"
1699286008 source:d:\microrally\udccd_controller\src\hw\led_display.c
"board/odout.h"
"led_display.h"
1699017683 d:\microrally\udccd_controller\src\hw\led_display.h
<stdint.h>
1698328349 source:d:\microrally\udccd_controller\src\hw\startup.c
"board/utils/utils.h"
"board/setup.h"
"startup.h"
1699017682 d:\microrally\udccd_controller\src\hw\startup.h
<stdint.h>
1699285771 d:\microrally\udccd_controller\tests\ut_hw\ut_startup.h
<stdio.h>
<stdlib.h>
1699285777 source:d:\microrally\udccd_controller\tests\ut_hw\ut_startup.c
"ut_startup.h"
"..\mock_board\mock_board_setup.h"
"..\..\src\hw\startup.h"
1699286754 source:d:\microrally\udccd_controller\tests\ut_hw\ut_led_display.c
"ut_led_display.h"
"..\mock_board\mock_board_odout.h"
"..\..\src\hw\led_display.h"
1699286570 d:\microrally\udccd_controller\tests\ut_hw\ut_led_display.h
<stdio.h>
<stdlib.h>
1699375169 source:d:\microrally\udccd_controller\tests\ut_hw\ut_hb_control.c
"ut_hb_control.h"
"..\mock_board\mock_board_halfbridge.h"
"..\..\src\hw\hb_control.h"
1699371510 d:\microrally\udccd_controller\tests\ut_hw\ut_hb_control.h
<stdio.h>
<stdlib.h>
1699031869 source:f:\microrally\udccd_controller\src\hw\board\utils\faults.c
"faults.h"
"utils.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\faults.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\utils.h
<stdint.h>
1699031869 source:f:\microrally\udccd_controller\src\hw\board\utils\fuses.c
"fuses.h"
"utils.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\utils\fuses.h
<stdint.h>
1698697335 source:f:\microrally\udccd_controller\src\hw\analog.c
"board/utils/utils.h"
"board/ain.h"
"analog.h"
1699476816 f:\microrally\udccd_controller\src\hw\board\ain.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\analog.h
<stdint.h>
1699298687 source:f:\microrally\udccd_controller\src\hw\board\utils\utils.c
"utils.h"
1699298687 source:f:\microrally\udccd_controller\src\hw\buttons.c
"board/utils/utils.h"
"board/din.h"
"board/dout.h"
"buttons.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\din.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\board\dout.h
<stdint.h>
1699477045 f:\microrally\udccd_controller\src\hw\buttons.h
<stdint.h>
1699298687 source:f:\microrally\udccd_controller\src\hw\led_display.c
"board/odout.h"
"led_display.h"
1699197585 f:\microrally\udccd_controller\src\hw\board\odout.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\led_display.h
<stdint.h>
1698336545 source:f:\microrally\udccd_controller\src\hw\startup.c
"board/utils/utils.h"
"board/setup.h"
"startup.h"
1699031869 f:\microrally\udccd_controller\src\hw\board\setup.h
<stdint.h>
1699031869 f:\microrally\udccd_controller\src\hw\startup.h
<stdint.h>
1699474639 source:f:\microrally\udccd_controller\tests\hw_main.c
<stdio.h>
<stdlib.h>
"ut_hw/ut_analog.h"
"ut_hw/ut_buttons.h"
"ut_hw/ut_hb_control.h"
"ut_hw/ut_led_display.h"
"ut_hw/ut_startup.h"
1699298688 f:\microrally\udccd_controller\tests\ut_hw\ut_analog.h
<stdio.h>
<stdlib.h>
1699298688 f:\microrally\udccd_controller\tests\ut_hw\ut_buttons.h
<stdio.h>
<stdlib.h>
1699298688 f:\microrally\udccd_controller\tests\ut_hw\ut_startup.h
<stdio.h>
<stdlib.h>
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_ain.c
"mock_board_ain.h"
1699298687 f:\microrally\udccd_controller\tests\mock_board\mock_board_ain.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\ain.h"
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_din.c
"mock_board_din.h"
1699298687 f:\microrally\udccd_controller\tests\mock_board\mock_board_din.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\din.h"
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_dout.c
"mock_board_dout.h"
1699298687 f:\microrally\udccd_controller\tests\mock_board\mock_board_dout.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\dout.h"
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_halfbridge.c
"mock_board_halfbridge.h"
1699298687 f:\microrally\udccd_controller\tests\mock_board\mock_board_halfbridge.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\halfbridge.h"
1699476970 f:\microrally\udccd_controller\src\hw\board\halfbridge.h
<stdint.h>
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_odout.c
"mock_board_odout.h"
1699298687 f:\microrally\udccd_controller\tests\mock_board\mock_board_odout.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\odout.h"
1699298687 source:f:\microrally\udccd_controller\tests\mock_board\mock_board_setup.c
"mock_board_setup.h"
1699298688 f:\microrally\udccd_controller\tests\mock_board\mock_board_setup.h
<stdio.h>
<stdlib.h>
"..\..\src\hw\board\setup.h"
1699298688 source:f:\microrally\udccd_controller\tests\ut_hw\ut_analog.c
"ut_analog.h"
"..\mock_board\mock_board_ain.h"
"..\..\src\hw\analog.h"
1699298688 source:f:\microrally\udccd_controller\tests\ut_hw\ut_buttons.c
"ut_buttons.h"
"..\mock_board\mock_board_din.h"
"..\mock_board\mock_board_dout.h"
"..\..\src\hw\buttons.h"
1699298688 source:f:\microrally\udccd_controller\tests\ut_hw\ut_led_display.c
"ut_led_display.h"
"..\mock_board\mock_board_odout.h"
"..\..\src\hw\led_display.h"
1699298688 f:\microrally\udccd_controller\tests\ut_hw\ut_led_display.h
<stdio.h>
<stdlib.h>
1699298688 source:f:\microrally\udccd_controller\tests\ut_hw\ut_startup.c
"ut_startup.h"
"..\mock_board\mock_board_setup.h"
"..\..\src\hw\startup.h"
1699391649 source:f:\microrally\udccd_controller\src\hw\hb_control.c
"board/utils/utils.h"
"board/halfbridge.h"
"hb_control.h"
1699382733 f:\microrally\udccd_controller\src\hw\hb_control.h
<stdint.h>
"board/utils/faults.h"
"board/utils/fuses.h"
"board/halfbridge.h"
1699393539 source:f:\microrally\udccd_controller\tests\ut_hw\ut_hb_control.c
"ut_hb_control.h"
"..\mock_board\mock_board_halfbridge.h"
"..\..\src\hw\hb_control.h"
1699382733 f:\microrally\udccd_controller\tests\ut_hw\ut_hb_control.h
<stdio.h>
<stdlib.h>
1699535389 d:\microrally\udccd_controller\src\hw\board\config.h
<stdint.h>
1699535687 d:\microrally\udccd_controller\src\hw\config.h
<stdint.h>

145
firmware/tests/uDCCD_Unit_Tests_HW.layout Normal file
View File

@@ -0,0 +1,145 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_layout_file>
<FileVersion major="1" minor="0" />
<ActiveTarget name="Debug" />
<File name="mock_board\mock_board_setup.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="228" topLine="0" />
</Cursor>
</File>
<File name="..\src\hw\hb_control.c" open="0" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="5" zoom_2="0">
<Cursor>
<Cursor1 position="5123" topLine="145" />
</Cursor>
</File>
<File name="mock_board\mock_board_odout.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="56" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_odout.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="366" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_hb_control.c" open="0" top="0" tabpos="1" split="0" active="1" splitpos="0" zoom_1="3" zoom_2="0">
<Cursor>
<Cursor1 position="88492" topLine="2027" />
</Cursor>
</File>
<File name="mock_board\mock_board_ain.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="357" topLine="0" />
</Cursor>
</File>
<File name="..\src\hw\buttons.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="1649" topLine="24" />
</Cursor>
</File>
<File name="ut_hw\ut_led_display.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="176" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_analog.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="496" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_led_display.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="2" zoom_2="0">
<Cursor>
<Cursor1 position="856" topLine="60" />
</Cursor>
</File>
<File name="..\src\hw\hb_control.h" open="0" top="0" tabpos="4" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="391" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_startup.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="161" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_dout.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="326" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_analog.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="129" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_halfbridge.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="281" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_din.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="164" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_buttons.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="221" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_din.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="52" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_halfbridge.h" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="529" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_ain.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="550" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_buttons.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="10084" topLine="798" />
</Cursor>
</File>
<File name="hw_main.c" open="0" top="0" tabpos="3" split="0" active="1" splitpos="0" zoom_1="3" zoom_2="0">
<Cursor>
<Cursor1 position="2087" topLine="55" />
</Cursor>
</File>
<File name="..\src\hw\board\utils\utils.h" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="181" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_hb_control.h" open="0" top="0" tabpos="2" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="302" topLine="0" />
</Cursor>
</File>
<File name="ut_hw\ut_startup.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="606" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_setup.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="117" topLine="0" />
</Cursor>
</File>
<File name="..\src\hw\analog.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="588" topLine="0" />
</Cursor>
</File>
<File name="mock_board\mock_board_dout.c" open="0" top="0" tabpos="0" split="0" active="1" splitpos="0" zoom_1="0" zoom_2="0">
<Cursor>
<Cursor1 position="54" topLine="0" />
</Cursor>
</File>
</CodeBlocks_layout_file>

71
firmware/tests/uDCCD_Unit_Tests_Logic.cbp Normal file
View File

@@ -0,0 +1,71 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<CodeBlocks_project_file>
<FileVersion major="1" minor="6" />
<Project>
<Option title="uDCCD_Unit_Tests_Logic" />
<Option pch_mode="2" />
<Option compiler="gcc" />
<Build>
<Target title="Debug">
<Option output="bin/Debug/uDCCD_Unit_Tests_Logic" prefix_auto="1" extension_auto="1" />
<Option object_output="obj/Debug/" />
<Option type="1" />
<Option compiler="gcc" />
<Compiler>
<Add option="-g" />
<Add option="-DTESTING" />
</Compiler>
</Target>
</Build>
<Compiler>
<Add option="-Wall" />
<Add option="-DTESTING" />
</Compiler>
<Unit filename="../src/logic/coil.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/logic/coil.h" />
<Unit filename="../src/logic/display.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/logic/display.h" />
<Unit filename="../src/logic/force.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/logic/force.h" />
<Unit filename="../src/logic/pot.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/logic/pot.h" />
<Unit filename="../src/logic/user_force.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="../src/logic/user_force.h" />
<Unit filename="logic_main.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_coil.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_coil.h" />
<Unit filename="ut_logic/ut_display.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_display.h" />
<Unit filename="ut_logic/ut_force.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_force.h" />
<Unit filename="ut_logic/ut_pot.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_pot.h" />
<Unit filename="ut_logic/ut_user_force.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="ut_logic/ut_user_force.h" />
<Extensions>
<lib_finder disable_auto="1" />
</Extensions>
</Project>
</CodeBlocks_project_file>

80
firmware/tests/uDCCD_Unit_Tests_Logic.depend Normal file
View File

@@ -0,0 +1,80 @@
# depslib dependency file v1.0
1699474847 source:f:\microrally\udccd_controller\src\logic\coil.c
"coil.h"
1699474848 f:\microrally\udccd_controller\src\logic\coil.h
<stdint.h>
1699472530 source:f:\microrally\udccd_controller\src\logic\display.c
"display.h"
1699472535 f:\microrally\udccd_controller\src\logic\display.h
<stdint.h>
1699474995 source:f:\microrally\udccd_controller\src\logic\force.c
"force.h"
1699474996 f:\microrally\udccd_controller\src\logic\force.h
<stdint.h>
1699031869 source:f:\microrally\udccd_controller\src\logic\pot.c
"pot.h"
1699475345 f:\microrally\udccd_controller\src\logic\pot.h
<stdint.h>
1699475089 source:f:\microrally\udccd_controller\src\logic\user_force.c
"user_force.h"
1699475337 f:\microrally\udccd_controller\src\logic\user_force.h
<stdint.h>
1699474661 source:f:\microrally\udccd_controller\tests\logic_main.c
<stdio.h>
<stdlib.h>
"ut_logic/ut_coil.h"
"ut_logic/ut_display.h"
"ut_logic/ut_force.h"
"ut_logic/ut_pot.h"
"ut_logic/ut_user_force.h"
1698869680 f:\microrally\udccd_controller\tests\ut_logic\ut_coil.h
<stdio.h>
<stdlib.h>
1699473947 f:\microrally\udccd_controller\tests\ut_logic\ut_display.h
<stdio.h>
<stdlib.h>
1698869680 f:\microrally\udccd_controller\tests\ut_logic\ut_force.h
<stdio.h>
<stdlib.h>
1698869680 f:\microrally\udccd_controller\tests\ut_logic\ut_pot.h
<stdio.h>
<stdlib.h>
1698869680 f:\microrally\udccd_controller\tests\ut_logic\ut_user_force.h
<stdio.h>
<stdlib.h>
1699474942 source:f:\microrally\udccd_controller\tests\ut_logic\ut_coil.c
"ut_coil.h"
"..\..\src\logic\coil.h"
1699474733 source:f:\microrally\udccd_controller\tests\ut_logic\ut_display.c
"ut_display.h"
"..\..\src\logic\display.h"
1699475023 source:f:\microrally\udccd_controller\tests\ut_logic\ut_force.c
"ut_force.h"
"..\..\src\logic\force.h"
1699195810 source:f:\microrally\udccd_controller\tests\ut_logic\ut_pot.c
"ut_pot.h"
"..\..\src\logic\pot.h"
1699195775 source:f:\microrally\udccd_controller\tests\ut_logic\ut_user_force.c
"ut_user_force.h"
"..\..\src\logic\user_force.h"

Some files were not shown because too many files have changed in this diff Show More