hwio_a3ides_2209_02.c File Reference

#include "hwio_a3ides.h"
#include <inttypes.h>
#include "config.h"
#include "stm32f4xx_hal.h"
#include "cmsis_os.h"
#include "gpio.h"
#include "adc.h"
#include "sim_nozzle.h"
#include "sim_bed.h"
#include "sim_motion.h"
#include "Arduino.h"
#include "timer_defaults.h"
#include "hwio_pindef.h"
#include "filament_sensor.h"
#include "bsod.h"

Macros
#define	HWIO_ERR_UNINI_DIG_RD   0x01
#define	HWIO_ERR_UNINI_DIG_WR   0x02
#define	HWIO_ERR_UNINI_ANA_RD   0x03
#define	HWIO_ERR_UNINI_ANA_WR   0x04
#define	HWIO_ERR_UNDEF_DIG_RD   0x05
#define	HWIO_ERR_UNDEF_DIG_WR   0x06
#define	HWIO_ERR_UNDEF_ANA_RD   0x07
#define	HWIO_ERR_UNDEF_ANA_WR   0x08
#define	_DI_CNT   (sizeof(_di_pin32) / sizeof(uint32_t))
#define	_DO_CNT   (sizeof(_do_pin32) / sizeof(uint32_t))
#define	_ADC_CNT   (sizeof(_adc_pin32) / sizeof(uint32_t))
#define	_DAC_CNT   (sizeof(_dac_pin32) / sizeof(uint32_t))
#define	_FAN_ID_MIN   HWIO_PWM_FAN1
#define	_FAN_ID_MAX   HWIO_PWM_FAN
#define	_FAN_CNT   (_FAN_ID_MAX - _FAN_ID_MIN + 1)
#define	_HEATER_ID_MIN   HWIO_PWM_HEATER_BED
#define	_HEATER_ID_MAX   HWIO_PWM_HEATER_0
#define	_HEATER_CNT   (_HEATER_ID_MAX - _HEATER_ID_MIN + 1)
#define	_PWM_CNT   (sizeof(_pwm_pin32) / sizeof(uint32_t))

Functions
void	Error_Handler (void)
	This function is executed in case of error occurrence. More...
void	__pwm_set_val (TIM_HandleTypeDef *htim, uint32_t chan, int val)
void	_hwio_pwm_analogWrite_set_val (int i_pwm, int val)
void	_hwio_pwm_set_val (int i_pwm, int val)
uint32_t	_pwm_get_chan (int i_pwm)
TIM_HandleTypeDef *	_pwm_get_htim (int i_pwm)
int	is_pwm_id_valid (int i_pwm)
int	hwio_di_get_cnt (void)
int	hwio_di_get_val (int i_di)
int	hwio_do_get_cnt (void)
int	hwio_do_get_val (int i_do)
void	hwio_do_set_val (int i_do, int val)
int	hwio_adc_get_cnt (void)
int	hwio_adc_get_max (int i_adc)
int	hwio_adc_get_val (int i_adc)
int	hwio_dac_get_cnt (void)
int	hwio_dac_get_max (int i_dac)
void	hwio_dac_set_val (int i_dac, int val)
int	hwio_pwm_get_cnt (void)
int	hwio_pwm_get_max (int i_pwm)
void	hwio_pwm_set_period_us (int i_pwm, int T_us)
int	hwio_pwm_get_period_us (int i_pwm)
void	hwio_pwm_set_prescaler (int i_pwm, int prescaler)
int	hwio_pwm_get_prescaler (int i_pwm)
void	hwio_pwm_set_prescaler_exp2 (int i_pwm, int exp)
int	hwio_pwm_get_prescaler_log2 (int i_pwm)
void	hwio_pwm_set_val (int i_pwm, int val)
int	hwio_fan_get_cnt (void)
void	hwio_fan_set_pwm (int i_fan, int val)
int	hwio_heater_get_cnt (void)
void	hwio_heater_set_pwm (int i_heater, int val)
void	hwio_jogwheel_enable (void)
void	hwio_jogwheel_disable (void)
float	hwio_beeper_get_vol (void)
void	hwio_beeper_set_vol (float vol)
void	hwio_beeper_set_pwm (uint32_t per, uint32_t pul)
void	hwio_beeper_tone (float frq, uint32_t del)
void	hwio_beeper_tone2 (float frq, uint32_t del, float vol)
void	hwio_beeper_notone (void)
void	hwio_update_1ms (void)
void	adc_ready (uint8_t index)
uint8_t	adc_seq2idx (uint8_t seq)
void	hwio_arduino_error (int err, uint32_t pin32)
int	hwio_arduino_digitalRead (uint32_t ulPin)
void	hwio_arduino_digitalWrite (uint32_t ulPin, uint32_t ulVal)
void	hwio_arduino_digitalToggle (uint32_t ulPin)
uint32_t	hwio_arduino_analogRead (uint32_t ulPin)
void	hwio_arduino_analogWrite (uint32_t ulPin, uint32_t ulValue)
void	hwio_arduino_pinMode (uint32_t ulPin, uint32_t ulMode)

Variables
int	HAL_GPIO_Initialized
int	HAL_ADC_Initialized
int	HAL_PWM_Initialized
TIM_HandleTypeDef	htim1
TIM_HandleTypeDef	htim2
TIM_HandleTypeDef	htim3
const uint32_t	_di_pin32 []
const uint32_t	_do_pin32 []
const uint32_t	_adc_pin32 []
const int	_adc_max [] = { 4095, 4095, 4095, 4095, 4095 }
int	_adc_val [] = { 0, 0, 0, 0, 0 }
const uint32_t	_dac_pin32 [] = {}
const int	_dac_max [] = { 0 }
int	_tim1_period_us = GEN_PERIOD_US(TIM1_default_Prescaler, TIM1_default_Period)
int	_tim3_period_us = GEN_PERIOD_US(TIM3_default_Prescaler, TIM3_default_Period)
const uint32_t	_pwm_pin32 []
const uint32_t	_pwm_chan []
TIM_HandleTypeDef *	_pwm_p_htim []
int *const	_pwm_period_us []
const int	_pwm_max [] = { TIM3_default_Period, TIM3_default_Period, TIM1_default_Period, TIM1_default_Period }
const TIM_OC_InitTypeDef	sConfigOC_default
const int	_pwm_analogWrite_max [_PWM_CNT] = { 0xff, 0xff, 0xff, 0xff }
int	_pwm_analogWrite_val [_PWM_CNT] = { 0, 0, 0, 0 }
const int *	_fan_max = &_pwm_analogWrite_max[_FAN_ID_MIN]
int *	_fan_val = &_pwm_analogWrite_val[_FAN_ID_MIN]
const int *	_heater_max = &_pwm_analogWrite_max[_HEATER_ID_MIN]
int *	_heater_val = &_pwm_analogWrite_val[_HEATER_ID_MIN]
int	hwio_jogwheel_enabled = 0
float	hwio_beeper_vol = 1.0F
uint32_t	hwio_beeper_del = 0
const uint8_t	adc_seq [18] = { 4, 1, 4, 1, 4, 0, 4, 1, 4, 1, 4, 2, 4, 1, 4, 1, 4, 3 }

Macro Definition Documentation

HWIO_ERR_UNINI_DIG_RD

#define HWIO_ERR_UNINI_DIG_RD   0x01

HWIO_ERR_UNINI_DIG_WR

#define HWIO_ERR_UNINI_DIG_WR   0x02

HWIO_ERR_UNINI_ANA_RD

#define HWIO_ERR_UNINI_ANA_RD   0x03

HWIO_ERR_UNINI_ANA_WR

#define HWIO_ERR_UNINI_ANA_WR   0x04

HWIO_ERR_UNDEF_DIG_RD

#define HWIO_ERR_UNDEF_DIG_RD   0x05

HWIO_ERR_UNDEF_DIG_WR

#define HWIO_ERR_UNDEF_DIG_WR   0x06

HWIO_ERR_UNDEF_ANA_RD

#define HWIO_ERR_UNDEF_ANA_RD   0x07

HWIO_ERR_UNDEF_ANA_WR

#define HWIO_ERR_UNDEF_ANA_WR   0x08

_DI_CNT

#define _DI_CNT   (sizeof(_di_pin32) / sizeof(uint32_t))

_DO_CNT

#define _DO_CNT   (sizeof(_do_pin32) / sizeof(uint32_t))

_ADC_CNT

#define _ADC_CNT   (sizeof(_adc_pin32) / sizeof(uint32_t))

_DAC_CNT

#define _DAC_CNT   (sizeof(_dac_pin32) / sizeof(uint32_t))

_FAN_ID_MIN

#define _FAN_ID_MIN   HWIO_PWM_FAN1

_FAN_ID_MAX

#define _FAN_ID_MAX   HWIO_PWM_FAN

_FAN_CNT

#define _FAN_CNT   (_FAN_ID_MAX - _FAN_ID_MIN + 1)

_HEATER_ID_MIN

#define _HEATER_ID_MIN   HWIO_PWM_HEATER_BED

_HEATER_ID_MAX

#define _HEATER_ID_MAX   HWIO_PWM_HEATER_0

_HEATER_CNT

#define _HEATER_CNT   (_HEATER_ID_MAX - _HEATER_ID_MIN + 1)

_PWM_CNT

#define _PWM_CNT   (sizeof(_pwm_pin32) / sizeof(uint32_t))

Function Documentation

Error_Handler()

void Error_Handler

(

void

)

This function is executed in case of error occurrence.

Return values

None

                         {
    /* USER CODE BEGIN Error_Handler_Debug */
    /* User can add his own implementation to report the HAL error return state */
    app_error();
    /* USER CODE END Error_Handler_Debug */
}

Here is the caller graph for this function:

__pwm_set_val()

void __pwm_set_val	(	TIM_HandleTypeDef *	htim,
		uint32_t	chan,
		int	val
	)

{
    if (htim->Init.Period) {
        TIM_OC_InitTypeDef sConfigOC = sConfigOC_default;
        if (val)
            sConfigOC.Pulse = val;
        else {
            sConfigOC.Pulse = htim->Init.Period;
            if (sConfigOC.OCPolarity == TIM_OCPOLARITY_HIGH)
                sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
            else
                sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
        }
        if (HAL_TIM_PWM_ConfigChannel(htim, &sConfigOC, pchan) != HAL_OK) {
            Error_Handler();
        }
        HAL_TIM_PWM_Start(htim, pchan);
    } else
        HAL_TIM_PWM_Stop(htim, pchan);

Here is the call graph for this function:

Here is the caller graph for this function:

_hwio_pwm_analogWrite_set_val()

void _hwio_pwm_analogWrite_set_val	(	int	i_pwm,
		int	val
	)

                                                       {
    if (!is_pwm_id_valid(i_pwm))
        return;
 
    if (_pwm_analogWrite_val[i_pwm] != val) {
        int32_t pwm_max = hwio_pwm_get_max(i_pwm);
        uint32_t pulse = (val * pwm_max) / _pwm_analogWrite_max[i_pwm];
        hwio_pwm_set_val(i_pwm, pulse);
        _pwm_analogWrite_val[i_pwm] = val;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_hwio_pwm_set_val()

void _hwio_pwm_set_val	(	int	i_pwm,
		int	val
	)

{
    uint32_t chan = _pwm_get_chan(i_pwm);
    TIM_HandleTypeDef *htim = _pwm_get_htim(i_pwm);
    if ((chan == -1) || htim->Instance == 0) {
        return;
    }
 
    __pwm_set_val(htim, chan, val);

Here is the call graph for this function:

Here is the caller graph for this function:

_pwm_get_chan()

uint32_t _pwm_get_chan

(

int

i_pwm

)

                                  {
    if (!is_pwm_id_valid(i_pwm))
        return -1;
    return _pwm_chan[i_pwm];

Here is the call graph for this function:

Here is the caller graph for this function:

_pwm_get_htim()

TIM_HandleTypeDef * _pwm_get_htim

(

int

i_pwm

)

                                            {
    if (!is_pwm_id_valid(i_pwm))
        i_pwm = 0;
 
    return _pwm_p_htim[i_pwm];

Here is the call graph for this function:

Here is the caller graph for this function:

is_pwm_id_valid()

int is_pwm_id_valid

(

int

i_pwm

)

                               {
    return ((i_pwm >= 0) && (i_pwm < _PWM_CNT));

Here is the caller graph for this function:

hwio_di_get_cnt()

int hwio_di_get_cnt

(

void

)

{ return _DI_CNT; }

hwio_di_get_val()

int hwio_di_get_val

(

int

i_di

)

{
    if ((i_di >= 0) && (i_di < _DI_CNT))
        return gpio_get(_di_pin32[i_di]);
    /*  {
        uint32_t pin32 = ;
        GPIO_TypeDef* gpio = (GPIO_TypeDef*)_gpio[pin32 >> 4];
        uint16_t msk = (1 << (pin32 & 0x0f));
        return HAL_GPIO_ReadPin(gpio, msk)?1:0;
    }*/
    //else //TODO: check
    return 0;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_do_get_cnt()

int hwio_do_get_cnt

(

void

)

{ return _DO_CNT; }

hwio_do_get_val()

int hwio_do_get_val

(

int

i_do

)

{
    if ((i_do >= 0) && (i_do < _DO_CNT))
        return gpio_get(_do_pin32[i_do]);
    return INT32_MAX; // undefined state

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_do_set_val()

void hwio_do_set_val	(	int	i_do,
		int	val
	)

{
    if ((i_do >= 0) && (i_do < _DO_CNT))
        gpio_set(_do_pin32[i_do], val);
    /*  {
        uint32_t pin32 = _do_pin32[i_do];
        GPIO_TypeDef* gpio = (GPIO_TypeDef*)_gpio[pin32 >> 4];
        uint16_t msk = (1 << (pin32 & 0x0f));
        HAL_GPIO_WritePin(gpio, msk, val?GPIO_PIN_SET:GPIO_PIN_RESET);
    }*/
    //else //TODO: check

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_adc_get_cnt()

int hwio_adc_get_cnt

(

void

)

{ return _ADC_CNT; }

hwio_adc_get_max()

int hwio_adc_get_max

(

int

i_adc

)

{ return _adc_max[i_adc]; }

hwio_adc_get_val()

int hwio_adc_get_val

(

int

i_adc

)

{
    if ((i_adc >= 0) && (i_adc < _ADC_CNT))
        return _adc_val[i_adc];
    //else //TODO: check
    return 0;

Here is the caller graph for this function:

hwio_dac_get_cnt()

int hwio_dac_get_cnt

(

void

)

{ return _DAC_CNT; }

hwio_dac_get_max()

int hwio_dac_get_max

(

int

i_dac

)

{ return _dac_max[i_dac]; }

hwio_dac_set_val()

void hwio_dac_set_val	(	int	i_dac,
		int	val
	)

{

hwio_pwm_get_cnt()

int hwio_pwm_get_cnt

(

void

)

{ return _PWM_CNT; }

hwio_pwm_get_max()

int hwio_pwm_get_max

(

int

i_pwm

)

{
    if (!is_pwm_id_valid(i_pwm))
        return -1;
    return _pwm_max[i_pwm];

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_pwm_set_period_us()

void hwio_pwm_set_period_us	(	int	i_pwm,
		int	T_us
	)

{
    if (!is_pwm_id_valid(i_pwm))
        return;
    int *ptr_period_us = _pwm_period_us[i_pwm];
 
    if (T_us == *ptr_period_us)
        return;
 
    int prescaler = T_us * (int32_t)TIM_BASE_CLK_MHZ / (_pwm_max[i_pwm] + 1) - 1;
    hwio_pwm_set_prescaler(i_pwm, prescaler);
    //actualize seconds
    *ptr_period_us = T_us;

Here is the call graph for this function:

hwio_pwm_get_period_us()

int hwio_pwm_get_period_us

(

int

i_pwm

)

                                      {
    if (!is_pwm_id_valid(i_pwm))
        return -1;
    return *_pwm_period_us[i_pwm];

Here is the call graph for this function:

hwio_pwm_set_prescaler()

void hwio_pwm_set_prescaler	(	int	i_pwm,
		int	prescaler
	)

                                                      {
    if (hwio_pwm_get_prescaler(i_pwm) == prescaler)
        return;
 
    TIM_HandleTypeDef *htim = _pwm_get_htim(i_pwm);
 
    //uint32_t           chan = _pwm_get_chan(i_pwm);
    //uint32_t           cmp  = __HAL_TIM_GET_COMPARE(htim,chan);
 
    htim->Init.Prescaler = prescaler;
    //__pwm_set_val(htim, chan, cmp);
 
    __HAL_TIM_SET_PRESCALER(htim, prescaler);
 
    //calculate micro seconds
    int T_us = GEN_PERIOD_US(prescaler, htim->Init.Period);
    //actualize micro
    int *ptr_period_us = _pwm_period_us[i_pwm];
    *ptr_period_us = T_us;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_pwm_get_prescaler()

int hwio_pwm_get_prescaler

(

int

i_pwm

)

                                      {
    if (!is_pwm_id_valid(i_pwm))
        return -1;
    TIM_HandleTypeDef *htim = _pwm_get_htim(i_pwm);
    return htim->Init.Prescaler;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_pwm_set_prescaler_exp2()

void hwio_pwm_set_prescaler_exp2	(	int	i_pwm,
		int	exp
	)

                                                     {
    uint32_t prescaler = (1 << (exp)) - 1;
    hwio_pwm_set_prescaler(i_pwm, prescaler);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_pwm_get_prescaler_log2()

int hwio_pwm_get_prescaler_log2

(

int

i_pwm

)

                                           {
    if (!is_pwm_id_valid(i_pwm))
        return -1;
    uint32_t prescaler = hwio_pwm_get_prescaler(i_pwm) + 1;
    int index = 0;
 
    while (prescaler != 0) {
        ++index;
        prescaler = prescaler >> 1;
    }
 
    return index - 1;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_pwm_set_val()

void hwio_pwm_set_val	(	int	i_pwm,
		int	val
	)

{
    if (!is_pwm_id_valid(i_pwm))
        return;
 
    uint32_t chan = _pwm_get_chan(i_pwm);
    TIM_HandleTypeDef *htim = _pwm_get_htim(i_pwm);
    uint32_t cmp = __HAL_TIM_GET_COMPARE(htim, chan);
 
    if ((_pwm_analogWrite_val[i_pwm] ^ val) || (cmp != val)) {
        _hwio_pwm_set_val(i_pwm, val);
 
        //actualize _pwm_analogWrite_val
        int pwm_max = hwio_pwm_get_max(i_pwm);
        int pwm_analogWrite_max = _pwm_analogWrite_max[i_pwm];
 
        uint32_t pulse = (val * pwm_analogWrite_max) / pwm_max;
        _pwm_analogWrite_val[i_pwm] = pulse; //arduino compatible
    }

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_fan_get_cnt()

int hwio_fan_get_cnt

(

void

)

{ return _FAN_CNT; }

Here is the caller graph for this function:

hwio_fan_set_pwm()

void hwio_fan_set_pwm	(	int	i_fan,
		int	val
	)

                                          {
    i_fan += _FAN_ID_MIN;
    if ((i_fan >= _FAN_ID_MIN) && (i_fan <= _FAN_ID_MAX))
        _hwio_pwm_analogWrite_set_val(i_fan, val);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_heater_get_cnt()

int hwio_heater_get_cnt

(

void

)

{ return _HEATER_CNT; }

Here is the caller graph for this function:

hwio_heater_set_pwm()

void hwio_heater_set_pwm	(	int	i_heater,
		int	val
	)

                                                {
    i_heater += _HEATER_ID_MIN;
    if ((i_heater >= _HEATER_ID_MIN) && (i_heater <= _HEATER_ID_MAX))
        _hwio_pwm_analogWrite_set_val(i_heater, val);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_jogwheel_enable()

void hwio_jogwheel_enable

(

void

)

                                {
    hwio_jogwheel_enabled = 1;

Here is the caller graph for this function:

hwio_jogwheel_disable()

void hwio_jogwheel_disable

(

void

)

                                 {
    hwio_jogwheel_enabled = 0;

Here is the caller graph for this function:

hwio_beeper_get_vol()

float hwio_beeper_get_vol

(

void

)

                                {
    return hwio_beeper_vol;

hwio_beeper_set_vol()

void hwio_beeper_set_vol

(

float

vol

)

                                    {
    if (vol < 0)
        vol *= -1;
    if (vol > 1)
        vol = 1;
    hwio_beeper_vol = vol;

Here is the caller graph for this function:

hwio_beeper_set_pwm()

void hwio_beeper_set_pwm	(	uint32_t	per,
		uint32_t	pul
	)

                                                     {
    TIM_OC_InitTypeDef sConfigOC = { 0 };
    if (per) {
        htim2.Init.Prescaler = 0;
        htim2.Init.CounterMode = TIM_COUNTERMODE_DOWN;
        htim2.Init.Period = per;
        htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
        HAL_TIM_Base_Init(&htim2);
        sConfigOC.OCMode = TIM_OCMODE_PWM1;
        if (pul) {
            sConfigOC.Pulse = pul;
            sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
        } else {
            sConfigOC.Pulse = per;
            sConfigOC.OCPolarity = TIM_OCPOLARITY_LOW;
        }
        sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
        HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1);
        HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
    } else
        HAL_TIM_PWM_Stop(&htim2, TIM_CHANNEL_1);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_beeper_tone()

void hwio_beeper_tone	(	float	frq,
		uint32_t	del
	)

                                               {
    uint32_t per;
    uint32_t pul;
    if (frq && del && hwio_beeper_vol) {
        if (frq < 0)
            frq *= -1;
        if (frq > 100000)
            frq = 100000;
        per = (uint32_t)(84000000.0F / frq);
        pul = (uint32_t)(per * hwio_beeper_vol / 2);
        hwio_beeper_set_pwm(per, pul);
        hwio_beeper_del = del;
    } else
        hwio_beeper_set_pwm(0, 0);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_beeper_tone2()

void hwio_beeper_tone2	(	float	frq,
		uint32_t	del,
		float	vol
	)

                                                           {
    hwio_beeper_set_vol(vol);
    hwio_beeper_tone(frq, del);

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_beeper_notone()

void hwio_beeper_notone

(

void

)

                              {
    hwio_beeper_set_pwm(0, 0);

Here is the call graph for this function:

hwio_update_1ms()

void hwio_update_1ms

(

void

)

                           {
    if ((hwio_beeper_del) && ((--hwio_beeper_del) == 0))
        hwio_beeper_set_pwm(0, 0);

Here is the call graph for this function:

Here is the caller graph for this function:

adc_ready()

void adc_ready

(

uint8_t

index

)

                              {
    _adc_val[index] = adc_val[index] >> 4;

adc_seq2idx()

uint8_t adc_seq2idx

(

uint8_t

seq

)

                            { 4, 1, 4, 1, 4, 0, 4, 1, 4, 1, 4, 2, 4, 1, 4, 1, 4, 3 };
uint8_t adc_seq2idx(uint8_t seq) {
    return adc_seq[seq];
    //  return 2;
    //  if ((seq % 3) != 2) return 2;
    //  if (seq != 8) return 0;
    //  return 1;

hwio_arduino_error()

void hwio_arduino_error	(	int	err,
		uint32_t	pin32
	)

                                                 {
    char text[64];
    if ((err == HWIO_ERR_UNINI_DIG_WR) && (pin32 == PIN_BEEPER))
        return; //ignore BEEPER write
    strcat(text, "HWIO error\n");
    switch (err) {
    case HWIO_ERR_UNINI_DIG_RD:
    case HWIO_ERR_UNINI_DIG_WR:
    case HWIO_ERR_UNINI_ANA_RD:
    case HWIO_ERR_UNINI_ANA_WR:
        strcat(text, "uninitialized\n");
        break;
    case HWIO_ERR_UNDEF_DIG_RD:
    case HWIO_ERR_UNDEF_DIG_WR:
    case HWIO_ERR_UNDEF_ANA_RD:
    case HWIO_ERR_UNDEF_ANA_WR:
        strcat(text, "undefined\n");
        break;
    }
    sprintf(text + strlen(text), "pin #%u (0x%02x)\n", (int)pin32, (uint8_t)pin32);
    switch (err) {
    case HWIO_ERR_UNINI_DIG_RD:
    case HWIO_ERR_UNINI_DIG_WR:
    case HWIO_ERR_UNDEF_DIG_RD:
    case HWIO_ERR_UNDEF_DIG_WR:
        strcat(text, "digital ");
        break;
    case HWIO_ERR_UNINI_ANA_RD:
    case HWIO_ERR_UNINI_ANA_WR:
    case HWIO_ERR_UNDEF_ANA_RD:
    case HWIO_ERR_UNDEF_ANA_WR:
        strcat(text, "analog ");
        break;
    }
    switch (err) {
    case HWIO_ERR_UNINI_DIG_RD:
    case HWIO_ERR_UNDEF_DIG_RD:
    case HWIO_ERR_UNINI_ANA_RD:
    case HWIO_ERR_UNDEF_ANA_RD:
        strcat(text, "read");
        break;
    case HWIO_ERR_UNINI_DIG_WR:
    case HWIO_ERR_UNDEF_DIG_WR:
    case HWIO_ERR_UNINI_ANA_WR:
    case HWIO_ERR_UNDEF_ANA_WR:
        strcat(text, "write");
        break;
    }
    bsod(text);

Here is the caller graph for this function:

hwio_arduino_digitalRead()

int hwio_arduino_digitalRead

(

uint32_t

ulPin

)

                                             {
    if (HAL_GPIO_Initialized) {
        switch (ulPin) {
#ifdef SIM_MOTION
        case PIN_Z_MIN:
            return sim_motion_get_min_end(2);
        case PIN_E_DIAG:
            return sim_motion_get_diag(3);
        case PIN_Y_DIAG:
            return sim_motion_get_diag(1);
        case PIN_X_DIAG:
            return sim_motion_get_diag(0);
        case PIN_Z_DIAG:
            return sim_motion_get_diag(2);
#else //SIM_MOTION
        case PIN_Z_MIN:
            return hwio_di_get_val(_DI_Z_MIN);
        case PIN_E_DIAG:
            return hwio_di_get_val(_DI_E_DIAG);
        case PIN_Y_DIAG:
            return hwio_di_get_val(_DI_Y_DIAG);
        case PIN_X_DIAG:
            return hwio_di_get_val(_DI_X_DIAG);
        case PIN_Z_DIAG:
            return hwio_di_get_val(_DI_Z_DIAG);
#endif //SIM_MOTION
        case PIN_BTN_ENC:
            return hwio_di_get_val(_DI_BTN_ENC) || !hwio_jogwheel_enabled;
        case PIN_BTN_EN1:
            return hwio_di_get_val(_DI_BTN_EN1) || !hwio_jogwheel_enabled;
        case PIN_BTN_EN2:
            return hwio_di_get_val(_DI_BTN_EN2) || !hwio_jogwheel_enabled;
        case PIN_Z_DIR:
            return hwio_do_get_val(_DO_Z_DIR);
        default:
            hwio_arduino_error(HWIO_ERR_UNDEF_DIG_RD, ulPin); //error: undefined pin digital read
        }
    } else
        hwio_arduino_error(HWIO_ERR_UNINI_DIG_RD, ulPin); //error: uninitialized digital read
    return 0;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_arduino_digitalWrite()

void hwio_arduino_digitalWrite	(	uint32_t	ulPin,
		uint32_t	ulVal
	)

                                                               {
    if (HAL_GPIO_Initialized) {
        switch (ulPin) {
        case PIN_BEEPER:
            return;
        case PIN_HEATER_BED:
            //hwio_heater_set_pwm(_HEATER_BED, ulVal?255:0);
#ifdef SIM_HEATER_BED_ADC
            if (adc_sim_msk & (1 << SIM_HEATER_BED_ADC))
                sim_bed_set_power(ulVal ? 100 : 0);
            else
#endif //SIM_HEATER_BED_ADC
                _hwio_pwm_analogWrite_set_val(HWIO_PWM_HEATER_BED, ulVal ? _pwm_analogWrite_max[HWIO_PWM_HEATER_BED] : 0);
            return;
        case PIN_HEATER_0:
            //hwio_heater_set_pwm(_HEATER_0, ulVal?255:0);
#ifdef SIM_HEATER_NOZZLE_ADC
            if (adc_sim_msk & (1 << SIM_HEATER_NOZZLE_ADC))
                sim_nozzle_set_power(ulVal ? 40 : 0);
            else
#endif //SIM_HEATER_NOZZLE_ADC
                _hwio_pwm_analogWrite_set_val(HWIO_PWM_HEATER_0, ulVal ? _pwm_analogWrite_max[HWIO_PWM_HEATER_0] : 0);
            return;
        case PIN_FAN1:
            //hwio_fan_set_pwm(_FAN1, ulVal?255:0);
            //_hwio_pwm_analogWrite_set_val(HWIO_PWM_FAN1, ulVal ? _pwm_analogWrite_max[HWIO_PWM_FAN1] : 0);
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_FAN1, ulVal ? 100 : 0);
            return;
        case PIN_FAN:
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_FAN, ulVal ? _pwm_analogWrite_max[HWIO_PWM_FAN] : 0);
            return;
#ifdef SIM_MOTION
        case PIN_X_DIR:
            sim_motion_set_dir(0, ulVal ? 1 : 0);
            return;
        case PIN_X_STEP:
            sim_motion_set_stp(0, ulVal ? 1 : 0);
            return;
        case PIN_Z_ENABLE:
            sim_motion_set_ena(2, ulVal ? 1 : 0);
            return;
        case PIN_X_ENABLE:
            sim_motion_set_ena(0, ulVal ? 1 : 0);
            return;
        case PIN_Z_STEP:
            sim_motion_set_stp(2, ulVal ? 1 : 0);
            return;
        case PIN_E_DIR:
            sim_motion_set_dir(3, ulVal ? 1 : 0);
            return;
        case PIN_E_STEP:
            sim_motion_set_stp(3, ulVal ? 1 : 0);
            return;
        case PIN_E_ENABLE:
            sim_motion_set_ena(3, ulVal ? 1 : 0);
            return;
        case PIN_Y_DIR:
            sim_motion_set_dir(1, ulVal ? 1 : 0);
            return;
        case PIN_Y_STEP:
            sim_motion_set_stp(1, ulVal ? 1 : 0);
            return;
        case PIN_Y_ENABLE:
            sim_motion_set_ena(1, ulVal ? 1 : 0);
            return;
        case PIN_Z_DIR:
            sim_motion_set_dir(2, ulVal ? 1 : 0);
            return;
#else //SIM_MOTION
        case PIN_X_DIR:
            hwio_do_set_val(_DO_X_DIR, ulVal ? 1 : 0);
            return;
        case PIN_X_STEP:
            hwio_do_set_val(_DO_X_STEP, ulVal ? 1 : 0);
            return;
        case PIN_Z_ENABLE:
            hwio_do_set_val(_DO_Z_ENABLE, ulVal ? 1 : 0);
            return;
        case PIN_X_ENABLE:
            hwio_do_set_val(_DO_X_ENABLE, ulVal ? 1 : 0);
            return;
        case PIN_Z_STEP:
            hwio_do_set_val(_DO_Z_STEP, ulVal ? 1 : 0);
            return;
        case PIN_E_DIR:
            hwio_do_set_val(_DO_E_DIR, ulVal ? 1 : 0);
            return;
        case PIN_E_STEP:
            hwio_do_set_val(_DO_E_STEP, ulVal ? 1 : 0);
            return;
        case PIN_E_ENABLE:
            hwio_do_set_val(_DO_E_ENABLE, ulVal ? 1 : 0);
            return;
        case PIN_Y_DIR:
            hwio_do_set_val(_DO_Y_DIR, ulVal ? 1 : 0);
            return;
        case PIN_Y_STEP:
            hwio_do_set_val(_DO_Y_STEP, ulVal ? 1 : 0);
            return;
        case PIN_Y_ENABLE:
            hwio_do_set_val(_DO_Y_ENABLE, ulVal ? 1 : 0);
            return;
        case PIN_Z_DIR:
            hwio_do_set_val(_DO_Z_DIR, ulVal ? 1 : 0);
            return;
#endif //SIM_MOTION
        default:
            hwio_arduino_error(HWIO_ERR_UNDEF_DIG_WR, ulPin); //error: undefined pin digital write
        }
    } else
        hwio_arduino_error(HWIO_ERR_UNINI_DIG_WR, ulPin); //error: uninitialized digital write

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_arduino_digitalToggle()

void hwio_arduino_digitalToggle

(

uint32_t

ulPin

)

                                                {
    hwio_arduino_digitalWrite(ulPin, !hwio_arduino_digitalRead(ulPin));
    // TODO test me

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_arduino_analogRead()

uint32_t hwio_arduino_analogRead

(

uint32_t

ulPin

)

                                                 {
    if (HAL_ADC_Initialized) {
        switch (ulPin) {
        case PIN_TEMP_BED:
            return hwio_adc_get_val(_ADC_TEMP_BED);
        case PIN_TEMP_0:
            return hwio_adc_get_val(_ADC_TEMP_0);
        case PIN_TEMP_HEATBREAK:
            return hwio_adc_get_val(_ADC_TEMP_HEATBREAK);
        default:
            hwio_arduino_error(HWIO_ERR_UNDEF_ANA_RD, ulPin); //error: undefined pin analog read
        }
    } else
        hwio_arduino_error(HWIO_ERR_UNINI_ANA_RD, ulPin); //error: uninitialized analog read
    return 0;

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_arduino_analogWrite()

void hwio_arduino_analogWrite	(	uint32_t	ulPin,
		uint32_t	ulValue
	)

                                                                {
    if (HAL_PWM_Initialized) {
        switch (ulPin) {
        case PIN_FAN1:
            //hwio_fan_set_pwm(_FAN1, ulValue);
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_FAN1, ulValue);
            return;
        case PIN_FAN:
            //hwio_fan_set_pwm(_FAN, ulValue);
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_FAN, ulValue);
            return;
        case PIN_HEATER_BED:
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_HEATER_BED, ulValue);
            return;
        case PIN_HEATER_0:
            _hwio_pwm_analogWrite_set_val(HWIO_PWM_HEATER_0, ulValue);
            return;
        default:
            hwio_arduino_error(HWIO_ERR_UNDEF_ANA_WR, ulPin); //error: undefined pin analog write
        }
    } else
        hwio_arduino_error(HWIO_ERR_UNINI_ANA_WR, ulPin); //error: uninitialized analog write

Here is the call graph for this function:

Here is the caller graph for this function:

hwio_arduino_pinMode()

void hwio_arduino_pinMode	(	uint32_t	ulPin,
		uint32_t	ulMode
	)

                                                           {
    // not supported, all pins are configured with Cube

Here is the caller graph for this function:

Variable Documentation

HAL_GPIO_Initialized

int HAL_GPIO_Initialized

HAL_ADC_Initialized

int HAL_ADC_Initialized

HAL_PWM_Initialized

int HAL_PWM_Initialized

htim1

TIM_HandleTypeDef htim1

htim2

TIM_HandleTypeDef htim2

htim3

TIM_HandleTypeDef htim3

_di_pin32

const uint32_t _di_pin32[]

Initial value:

= {
    PIN_Z_MIN, 
    PIN_E_DIAG, 
    PIN_Y_DIAG, 
    PIN_X_DIAG, 
    PIN_Z_DIAG, 
    PIN_BTN_ENC, 
    PIN_BTN_EN1, 
    PIN_BTN_EN2, 
}

_do_pin32

const uint32_t _do_pin32[]

Initial value:

= {
    PIN_X_DIR,
    PIN_X_STEP,
    PIN_Z_ENABLE,
    PIN_X_ENABLE,
    PIN_Z_STEP,
    PIN_E_DIR,
    PIN_E_STEP,
    PIN_E_ENABLE,
    PIN_Y_DIR,
    PIN_Y_STEP,
    PIN_Y_ENABLE,
    PIN_Z_DIR,
}

_adc_pin32

const uint32_t _adc_pin32[]

Initial value:

= {
    PIN_HW_IDENTIFY,
    PIN_TEMP_BED,
    PIN_THERM2,
    PIN_TEMP_HEATBREAK,
    PIN_TEMP_0, 
}

_adc_max

const int _adc_max[] = { 4095, 4095, 4095, 4095, 4095 }

_adc_val

int _adc_val[] = { 0, 0, 0, 0, 0 }

_dac_pin32

const uint32_t _dac_pin32[] = {}

_dac_max

const int _dac_max[] = { 0 }

_tim1_period_us

int _tim1_period_us = GEN_PERIOD_US(TIM1_default_Prescaler, TIM1_default_Period)

_tim3_period_us

int _tim3_period_us = GEN_PERIOD_US(TIM3_default_Prescaler, TIM3_default_Period)

_pwm_pin32

const uint32_t _pwm_pin32[]

Initial value:

= {
    PIN_HEATER_0,
    PIN_HEATER_BED,
    PIN_FAN1,
    PIN_FAN
}

_pwm_chan

const uint32_t _pwm_chan[]

Initial value:

= {
    TIM_CHANNEL_3, 
    TIM_CHANNEL_4, 
    TIM_CHANNEL_1, 
    TIM_CHANNEL_2, 
}

_pwm_p_htim

TIM_HandleTypeDef* _pwm_p_htim[]

Initial value:

= {
    &htim3, 
    &htim3, 
    &htim1, 
    &htim1, 
}

_pwm_period_us

int* const _pwm_period_us[]

Initial value:

= {
    &_tim3_period_us, 
    &_tim3_period_us, 
    &_tim1_period_us, 
    &_tim1_period_us, 
}

_pwm_max

const int _pwm_max[] = { TIM3_default_Period, TIM3_default_Period, TIM1_default_Period, TIM1_default_Period }

sConfigOC_default

const TIM_OC_InitTypeDef sConfigOC_default

Initial value:

= {
    TIM_OCMODE_PWM1, 
    0, 
    TIM_OCPOLARITY_HIGH, 
    TIM_OCNPOLARITY_HIGH, 
    TIM_OCFAST_DISABLE, 
    TIM_OCIDLESTATE_RESET, 
    TIM_OCNIDLESTATE_RESET 
}

_pwm_analogWrite_max

const int _pwm_analogWrite_max[_PWM_CNT] = { 0xff, 0xff, 0xff, 0xff }

_pwm_analogWrite_val

int _pwm_analogWrite_val[_PWM_CNT] = { 0, 0, 0, 0 }

_fan_max

const int* _fan_max = &_pwm_analogWrite_max[_FAN_ID_MIN]

_fan_val

int* _fan_val = &_pwm_analogWrite_val[_FAN_ID_MIN]

_heater_max

const int* _heater_max = &_pwm_analogWrite_max[_HEATER_ID_MIN]

_heater_val

int* _heater_val = &_pwm_analogWrite_val[_HEATER_ID_MIN]

hwio_jogwheel_enabled

int hwio_jogwheel_enabled = 0

hwio_beeper_vol

float hwio_beeper_vol = 1.0F

hwio_beeper_del

uint32_t hwio_beeper_del = 0

adc_seq

const uint8_t adc_seq[18] = { 4, 1, 4, 1, 4, 0, 4, 1, 4, 1, 4, 2, 4, 1, 4, 1, 4, 3 }