me/IronOS
1
0
Fork 1
mirror of https://github.com/Ralim/IronOS.git synced 2025-02-26 07:53:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removing timer as wont work & replace with bit bang

Browse Source 
Cant keep up with irq
This commit is contained in:
Ben V. Brown
2021-05-03 21:52:18 +10:00
parent dd5714fa17
commit 5ea2908fa2
8 changed files with 1239 additions and 1292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
source/Core/BSP/MHP30/BSP.cpp
View File

@@ -18,7 +18,9 @@ uint16_t totalPWM = 255;
const uint16_t powerPWM = 255; const uint16_t powerPWM = 255;
history<uint16_t, PID_TIM_HZ> rawTempFilter = { { 0 }, 0, 0 }; history<uint16_t, PID_TIM_HZ> rawTempFilter = { { 0 }, 0, 0 };
void resetWatchdog() { HAL_IWDG_Refresh(&hiwdg); } void resetWatchdog() {
HAL_IWDG_Refresh(&hiwdg);
}
#ifdef TEMP_NTC #ifdef TEMP_NTC
// Lookup table for the NTC // Lookup table for the NTC
@@ -186,7 +188,8 @@ static const uint16_t NTCHandleLookup[] = {
29104, 20, // 29104, 20, //
29272, 10, // 29272, 10, //
}; };
const int NTCHandleLookupItems = sizeof(NTCHandleLookup) / (2 * sizeof(uint16_t)); const int NTCHandleLookupItems = sizeof(NTCHandleLookup)
/ (2 * sizeof(uint16_t));
#endif #endif
// These are called by the HAL after the corresponding events from the system // These are called by the HAL after the corresponding events from the system
@@ -201,10 +204,13 @@ void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
} }
uint16_t getHandleTemperature() { uint16_t getHandleTemperature() {
int32_t result = getADC(0); int32_t result = getADC(0);
return Utils::InterpolateLookupTable(NTCHandleLookup, NTCHandleLookupItems, result); return Utils::InterpolateLookupTable(NTCHandleLookup, NTCHandleLookupItems,
result);
} }
uint16_t getTipInstantTemperature() { return getADC(2); } uint16_t getTipInstantTemperature() {
return getADC(2);
}
uint16_t getTipRawTemp(uint8_t refresh) { uint16_t getTipRawTemp(uint8_t refresh) {
if (refresh) { if (refresh) {
@@ -322,14 +328,26 @@ void unstick_I2C() {
HAL_I2C_Init(&hi2c1); HAL_I2C_Init(&hi2c1);
} }
uint8_t getButtonA() { return HAL_GPIO_ReadPin(KEY_A_GPIO_Port, KEY_A_Pin) == GPIO_PIN_RESET ? 1 : 0; } uint8_t getButtonA() {
uint8_t getButtonB() { return HAL_GPIO_ReadPin(KEY_B_GPIO_Port, KEY_B_Pin) == GPIO_PIN_RESET ? 1 : 0; } return HAL_GPIO_ReadPin(KEY_A_GPIO_Port, KEY_A_Pin) == GPIO_PIN_RESET ?
1 : 0;
}
uint8_t getButtonB() {
return HAL_GPIO_ReadPin(KEY_B_GPIO_Port, KEY_B_Pin) == GPIO_PIN_RESET ?
1 : 0;
}
void BSPInit(void) {} void BSPInit(void) {
WS2812::init();
}
void reboot() { NVIC_SystemReset(); } void reboot() {
NVIC_SystemReset();
}
void delay_ms(uint16_t count) { HAL_Delay(count); } void delay_ms(uint16_t count) {
HAL_Delay(count);
}
void setPlatePullup(bool pullingUp) { void setPlatePullup(bool pullingUp) {
GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitTypeDef GPIO_InitStruct;
@@ -338,11 +356,13 @@ void setPlatePullup(bool pullingUp) {
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
if (pullingUp) { if (pullingUp) {
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
HAL_GPIO_WritePin(PLATE_SENSOR_PULLUP_GPIO_Port, PLATE_SENSOR_PULLUP_Pin, GPIO_PIN_SET); HAL_GPIO_WritePin(PLATE_SENSOR_PULLUP_GPIO_Port,
PLATE_SENSOR_PULLUP_Pin, GPIO_PIN_SET);
} else { } else {
// Hi-z // Hi-z
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG; GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
HAL_GPIO_WritePin(PLATE_SENSOR_PULLUP_GPIO_Port, PLATE_SENSOR_PULLUP_Pin, GPIO_PIN_RESET); HAL_GPIO_WritePin(PLATE_SENSOR_PULLUP_GPIO_Port,
PLATE_SENSOR_PULLUP_Pin, GPIO_PIN_RESET);
} }
HAL_GPIO_Init(PLATE_SENSOR_PULLUP_GPIO_Port, &GPIO_InitStruct); HAL_GPIO_Init(PLATE_SENSOR_PULLUP_GPIO_Port, &GPIO_InitStruct);
} }
@@ -361,7 +381,8 @@ bool isTipDisconnected() {
bool tipDisconnected = getADC(2) > 4090; bool tipDisconnected = getADC(2) > 4090;
// We have to handle here that this ^ will trip while measuring the gain resistor // We have to handle here that this ^ will trip while measuring the gain resistor
if (xTaskGetTickCount() - lastMeas < (TICKS_100MS * 2 + (TICKS_100MS / 2))) { if (xTaskGetTickCount() - lastMeas
< (TICKS_100MS * 2 + (TICKS_100MS / 2))) {
tipDisconnected = false; tipDisconnected = false;
} }
@@ -389,15 +410,19 @@ bool isTipDisconnected() {
} else { } else {
// We have taken reading one // We have taken reading one
uint16_t adcReadingPD1Cleared = getADC(3); uint16_t adcReadingPD1Cleared = getADC(3);
uint32_t a = ((int)adcReadingPD1Set - (int)adcReadingPD1Cleared); uint32_t a = ((int) adcReadingPD1Set
- (int) adcReadingPD1Cleared);
a *= 10000; a *= 10000;
uint32_t b = ((int)adcReadingPD1Cleared + (32768 - (int)adcReadingPD1Set)); uint32_t b = ((int) adcReadingPD1Cleared
+ (32768 - (int) adcReadingPD1Set));
if (b) { if (b) {
tipSenseResistancex10Ohms = a / b; tipSenseResistancex10Ohms = a / b;
} else { } else {
tipSenseResistancex10Ohms = adcReadingPD1Set = lastMeas = 0; tipSenseResistancex10Ohms = adcReadingPD1Set =
lastMeas = 0;
} }
if (tipSenseResistancex10Ohms > 1100 || tipSenseResistancex10Ohms < 900) { if (tipSenseResistancex10Ohms > 1100
|| tipSenseResistancex10Ohms < 900) {
tipSenseResistancex10Ohms = 0; // out of range tipSenseResistancex10Ohms = 0; // out of range
adcReadingPD1Set = 0; adcReadingPD1Set = 0;
lastMeas = 0; lastMeas = 0;
@@ -412,6 +437,27 @@ bool isTipDisconnected() {
} }
void setStatusLED(const enum StatusLED state) { void setStatusLED(const enum StatusLED state) {
WS2812::led_set_color(0, 0xFF, 0, 0); static enum StatusLED lastState = LED_UNKNOWN;
WS2812::led_update(1); if (lastState != state) {
switch (state) {
case LED_UNKNOWN:
case LED_OFF:
WS2812::led_set_color(0, 0, 0, 0);
break;
case LED_STANDBY:
WS2812::led_set_color(0, 0, 0xFF, 0); //green
break;
case LED_HEATING:
WS2812::led_set_color(0, 0, 0, 0xFF); //Blue
break;
case LED_HOT:
WS2812::led_set_color(0, 0xFF, 0, 0); //red
break;
case LED_COOLING_STILL_HOT:
WS2812::led_set_color(0, 0xFF, 0xFF, 0xFF); //white
break;
}
WS2812::led_update();
lastState = state;
}
} }

80
source/Core/BSP/MHP30/Setup.c
View File

@@ -16,8 +16,6 @@ DMA_HandleTypeDef hdma_i2c1_rx;
DMA_HandleTypeDef hdma_i2c1_tx; DMA_HandleTypeDef hdma_i2c1_tx;
IWDG_HandleTypeDef hiwdg; IWDG_HandleTypeDef hiwdg;
TIM_HandleTypeDef htim1;
DMA_HandleTypeDef hdma_tim1_ch1;
TIM_HandleTypeDef htim2; TIM_HandleTypeDef htim2;
TIM_HandleTypeDef htim3; TIM_HandleTypeDef htim3;
#define ADC_CHANNELS 4 #define ADC_CHANNELS 4
@@ -31,7 +29,6 @@ static void MX_I2C1_Init(void);
static void MX_IWDG_Init(void); static void MX_IWDG_Init(void);
static void MX_TIM3_Init(void); static void MX_TIM3_Init(void);
static void MX_TIM2_Init(void); static void MX_TIM2_Init(void);
static void MX_TIM1_Init(void);
static void MX_DMA_Init(void); static void MX_DMA_Init(void);
static void MX_GPIO_Init(void); static void MX_GPIO_Init(void);
static void MX_ADC2_Init(void); static void MX_ADC2_Init(void);
@@ -47,7 +44,6 @@ void Setup_HAL() {
MX_ADC2_Init(); MX_ADC2_Init();
MX_TIM3_Init(); MX_TIM3_Init();
MX_TIM2_Init(); MX_TIM2_Init();
MX_TIM1_Init();
MX_IWDG_Init(); MX_IWDG_Init();
HAL_ADC_Start(&hadc2); HAL_ADC_Start(&hadc2);
HAL_ADCEx_MultiModeStart_DMA(&hadc1, ADCReadings, HAL_ADCEx_MultiModeStart_DMA(&hadc1, ADCReadings,
@@ -91,7 +87,7 @@ void SystemClock_Config(void) {
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2; RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV16; // TIM RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; // TIM
// 2,3,4,5,6,7,12,13,14 // 2,3,4,5,6,7,12,13,14
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; // 64 mhz to some peripherals and adc RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; // 64 mhz to some peripherals and adc
@@ -222,70 +218,6 @@ static void MX_IWDG_Init(void) {
#endif #endif
} }
/* TIM1 init function */
void MX_TIM1_Init(void) {
/* USER CODE BEGIN TIM1_Init 0 */
/* USER CODE END TIM1_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
/* USER CODE BEGIN TIM1_Init 1 */
/* USER CODE END TIM1_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 42;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
HAL_TIM_Base_Init(&htim1);
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);
HAL_TIM_PWM_Init(&htim1);
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0;
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = 0;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_LOW;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct;
/**TIM1 GPIO Configuration
PA8 ------> TIM1_CH1
*/
GPIO_InitStruct.Pin = WS2812_Pin;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(WS2812_GPIO_Port, &GPIO_InitStruct);
__HAL_AFIO_REMAP_TIM1_DISABLE();
}
/* TIM3 init function */ /* TIM3 init function */
static void MX_TIM3_Init(void) { static void MX_TIM3_Init(void) {
TIM_ClockConfigTypeDef sClockSourceConfig; TIM_ClockConfigTypeDef sClockSourceConfig;
@@ -382,9 +314,6 @@ static void MX_DMA_Init(void) {
/* DMA1_Channel1_IRQn interrupt configuration */ /* DMA1_Channel1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 10, 0); HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 10, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn); HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
/* DMA1_Channel1_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 2, 0); // DMA 1 ch2 is used from TIM CH1 for WS2812
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
/* DMA1_Channel6_IRQn interrupt configuration */ /* DMA1_Channel6_IRQn interrupt configuration */
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 5, 0); HAL_NVIC_SetPriority(DMA1_Channel6_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn); HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
@@ -438,8 +367,13 @@ static void MX_GPIO_Init(void) {
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(OLED_RESET_GPIO_Port, &GPIO_InitStruct); HAL_GPIO_Init(OLED_RESET_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_WritePin(OLED_RESET_GPIO_Port, OLED_RESET_Pin, GPIO_PIN_RESET);
GPIO_InitStruct.Pin = WS2812_Pin;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(WS2812_GPIO_Port, &GPIO_InitStruct);
HAL_GPIO_WritePin(WS2812_GPIO_Port, WS2812_Pin, GPIO_PIN_RESET);
// Pull down LCD reset // Pull down LCD reset
HAL_GPIO_WritePin(OLED_RESET_GPIO_Port, OLED_RESET_Pin, GPIO_PIN_RESET); HAL_GPIO_WritePin(OLED_RESET_GPIO_Port, OLED_RESET_Pin, GPIO_PIN_RESET);
HAL_Delay(30); HAL_Delay(30);

11
source/Core/BSP/MHP30/postRTOS.cpp
View File

@@ -3,7 +3,6 @@
#include "I2C_Wrapper.hpp" #include "I2C_Wrapper.hpp"
#include "QC3.h" #include "QC3.h"
#include "Settings.h" #include "Settings.h"
#include "WS2812.h"
#include "cmsis_os.h" #include "cmsis_os.h"
#include "fusbpd.h" #include "fusbpd.h"
#include "main.hpp" #include "main.hpp"
@@ -13,13 +12,5 @@
// Initialisation to be performed with scheduler active // Initialisation to be performed with scheduler active
void postRToSInit() { void postRToSInit() {
WS2812::init();
WS2812::led_set_color(0, 0xAA, 0x00, 0x00);
while (true) {
// osDelay(1);
// WS2812::led_set_color(0, 0xFF, 0xFF, 0xFF);
// WS2812::led_update(1);
osDelay(10);
WS2812::led_update(1);
}
} }

15
source/Core/BSP/MHP30/stm32f1xx_hal_msp.c
View File

@@ -126,20 +126,7 @@ void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c) {
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) { void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) {
if (htim_base->Instance == TIM1) { if (htim_base->Instance == TIM3) {
__HAL_RCC_TIM1_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
hdma_tim1_ch1.Instance = DMA1_Channel2;
hdma_tim1_ch1.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_tim1_ch1.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_tim1_ch1.Init.MemInc = DMA_MINC_ENABLE;
hdma_tim1_ch1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_tim1_ch1.Init.MemDataAlignment = DMA_PDATAALIGN_HALFWORD;
hdma_tim1_ch1.Init.Mode = DMA_CIRCULAR;
hdma_tim1_ch1.Init.Priority = DMA_PRIORITY_VERY_HIGH;
HAL_DMA_Init(&hdma_tim1_ch1);
__HAL_LINKDMA(htim_base, hdma[TIM_DMA_ID_CC1], hdma_tim1_ch1);
} else if (htim_base->Instance == TIM3) {
__HAL_RCC_TIM3_CLK_ENABLE(); __HAL_RCC_TIM3_CLK_ENABLE();
} else if (htim_base->Instance == TIM2) { } else if (htim_base->Instance == TIM2) {
__HAL_RCC_TIM2_CLK_ENABLE(); __HAL_RCC_TIM2_CLK_ENABLE();

5
source/Core/BSP/MHP30/stm32f1xx_it.c
View File

@@ -42,14 +42,11 @@ void DMA1_Channel1_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_adc1); }
// ADC interrupt used for DMA // ADC interrupt used for DMA
void ADC1_2_IRQHandler(void) { HAL_ADC_IRQHandler(&hadc1); } void ADC1_2_IRQHandler(void) { HAL_ADC_IRQHandler(&hadc1); }
// Timer 1 has overflowed, used for HAL ticks //used for hal ticks
void TIM1_UP_IRQHandler(void) { HAL_TIM_IRQHandler(&htim1); }
void TIM4_IRQHandler(void) { HAL_TIM_IRQHandler(&htim4); } void TIM4_IRQHandler(void) { HAL_TIM_IRQHandler(&htim4); }
void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); } void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); }
void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); } void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); }
void DMA1_Channel2_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_tim1_ch1); }
void DMA1_Channel6_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_tx); } void DMA1_Channel6_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_tx); }
void DMA1_Channel7_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_rx); } void DMA1_Channel7_IRQHandler(void) { HAL_DMA_IRQHandler(&hdma_i2c1_rx); }

236
source/Core/Drivers/WS2812.cpp
View File

@@ -5,178 +5,106 @@
* Author: Ralim * Author: Ralim
*/ */
#include "FreeRTOS.h"
#include "task.h"
#include <WS2812.h> #include <WS2812.h>
#include "Pins.h"
#include <string.h> #include <string.h>
uint8_t WS2812::leds_colors[WS2812_LED_CHANNEL_COUNT * WS2812_LED_COUNT]; uint8_t WS2812::leds_colors[WS2812_LED_CHANNEL_COUNT * WS2812_LED_COUNT];
volatile uint16_t WS2812::tmp_led_data[2 * WS2812_RAW_BYTES_PER_LED];
volatile uint8_t WS2812::is_reset_pulse; /*!< Status if we are sending reset pulse or led data */
volatile uint8_t WS2812::is_updating; /*!< Is updating in progress? */
volatile uint32_t WS2812::current_led; /*!< Current LED number we are sending */
void WS2812::init(void) { void WS2812::init(void) {
memset(leds_colors, 0, sizeof(leds_colors)); memset(leds_colors, 0, sizeof(leds_colors));
hdma_tim1_ch1.XferHalfCpltCallback = DMAHalfComplete;
hdma_tim1_ch1.XferCpltCallback = DMAComplete;
htim1.Instance->CCR1 = htim1.Instance->ARR / 2 - 1;
htim1.Instance->DIER |= TIM_DIER_CC1DE;
} }
uint8_t WS2812::led_update(uint8_t block) { void WS2812::led_update() {
if (is_updating) { /* Check if update in progress already */ __disable_irq();
return 0; //Bitbang it out as our cpu irq latency is too high
} for (unsigned int i = 0; i < sizeof(leds_colors); i++) {
is_updating = 1; /* We are now updating */ //Shove out MSB first
for (int x = 0; x < 8; x++) {
WS2812_GPIO_Port->BSRR = WS2812_Pin;
if ((leds_colors[i] & (1 << (7 - x))) == (1 << (7 - x))) {
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
} else {
led_start_reset_pulse(1); /* Start reset pulse */ __asm__ __volatile__("nop");
if (block) { __asm__ __volatile__("nop");
while (!led_is_update_finished()) { __asm__ __volatile__("nop");
vTaskDelay(1); __asm__ __volatile__("nop");
}; /* Wait to finish */ __asm__ __volatile__("nop");
__asm__ __volatile__("nop");
} }
return 1; WS2812_GPIO_Port->BSRR = (uint32_t) WS2812_Pin << 16u;
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
__asm__ __volatile__("nop");
}
}
__enable_irq();
} }
void WS2812::led_set_color(size_t index, uint8_t r, uint8_t g, uint8_t b) { void WS2812::led_set_color(size_t index, uint8_t r, uint8_t g, uint8_t b) {
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = r; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = g;
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = g; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = r;
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b;
} }
void WS2812::led_set_color_all(uint8_t r, uint8_t g, uint8_t b) { void WS2812::led_set_color_all(uint8_t r, uint8_t g, uint8_t b) {
for (int index = 0; index < WS2812_LED_COUNT; index++) { for (int index = 0; index < WS2812_LED_COUNT; index++) {
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = r; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 0] = g;
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = g; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 1] = r;
leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b; leds_colors[index * WS2812_LED_CHANNEL_COUNT + 2] = b;
} }
} }
uint8_t WS2812::led_is_update_finished(void) { return !is_updating; }
void WS2812::led_start_reset_pulse(uint8_t num) {
is_reset_pulse = num; /* Set reset pulse flag */
memset((void *)tmp_led_data, 0, sizeof(tmp_led_data)); /* Set all bytes to 0 to achieve 50us pulse */
if (num == 1) {
tmp_led_data[0] = (htim1.Instance->ARR * 2) / 3; // start with half width pulse
}
/* Set DMA to normal mode, set memory to beginning of data and length to 40 elements */
/* 800kHz PWM x 40 samples = ~50us pulse low */
hdma_tim1_ch1.Instance->CCR &= (~DMA_CCR_CIRC); // clear circular flag -> normal mode
hdma_tim1_ch1.State = HAL_DMA_STATE_READY;
HAL_DMA_Start_IT(&hdma_tim1_ch1, (uint32_t)tmp_led_data, (uint32_t)&htim1.Instance->CCR1, 2 * WS2812_RAW_BYTES_PER_LED);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
}
void WS2812::DMAHalfComplete(DMA_HandleTypeDef *hdma) { led_update_sequence(0); }
void WS2812::DMAComplete(DMA_HandleTypeDef *hdma) { led_update_sequence(1); }
void WS2812::led_update_sequence(uint8_t tc) {
tc = !!tc; /* Convert to 1 or 0 value only */
/* Check for reset pulse at the end of PWM stream */
if (is_reset_pulse == 2) { /* Check for reset pulse at the end */
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
HAL_DMA_Abort(&hdma_tim1_ch1);
is_updating = 0; /* We are not updating anymore */
return;
}
/* Check for reset pulse on beginning of PWM stream */
if (is_reset_pulse == 1) { /* Check if we finished with reset pulse */
/*
* When reset pulse is active, we have to wait full DMA response,
* before we can start modifying array which is shared with DMA and PWM
*/
if (!tc) { /* We must wait for transfer complete */
return; /* Return and wait to finish */
}
/* Disable timer output and disable DMA stream */
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
HAL_DMA_Abort(&hdma_tim1_ch1);
is_reset_pulse = 0; /* Not in reset pulse anymore */
current_led = 0; /* Reset current led */
} else {
/*
* When we are not in reset mode,
* go to next led and process data for it
*/
current_led++; /* Go to next LED */
}
/*
* This part is used to prepare data for "next" led,
* for which update will start once current transfer stops in circular mode
*/
if (current_led < WS2812_LED_COUNT) {
/*
* If we are preparing data for first time (current_led == 0)
* or if there was no TC event (it was HT):
*
* - Prepare first part of array, because either there is no transfer
* or second part (from HT to TC) is now in process for PWM transfer
*
* In other case (TC = 1)
*/
if (current_led == 0 || !tc) {
led_fill_led_pwm_data(current_led, &tmp_led_data[0]);
} else {
led_fill_led_pwm_data(current_led, &tmp_led_data[WS2812_RAW_BYTES_PER_LED]);
}
/*
* If we are preparing first led (current_led = 0), then:
*
* - We setup first part of array for first led,
* - We have to prepare second part for second led to have one led prepared in advance
* - Set DMA to circular mode and start the transfer + PWM output
*/
if (current_led == 0) {
current_led++; /* Go to next LED */
led_fill_led_pwm_data(current_led, &tmp_led_data[WS2812_RAW_BYTES_PER_LED]); /* Prepare second LED too */
hdma_tim1_ch1.Instance->CCR |= (DMA_CCR_CIRC); // set circular flag for circular mode
hdma_tim1_ch1.State = HAL_DMA_STATE_READY;
HAL_DMA_Start_IT(&hdma_tim1_ch1, (uint32_t)tmp_led_data, (uint32_t)&htim1.Instance->CCR1, 2 * WS2812_RAW_BYTES_PER_LED);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
}
/*
* When we reached all leds, we have to wait to transmit data for all leds before we can disable DMA and PWM:
*
* - If TC event is enabled and we have EVEN number of LEDS (2, 4, 6, ...)
* - If HT event is enabled and we have ODD number of LEDS (1, 3, 5, ...)
*/
} else if ((!tc && (WS2812_LED_COUNT & 0x01)) || (tc && !(WS2812_LED_COUNT & 0x01))) {
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
HAL_DMA_Abort(&hdma_tim1_ch1);
/* It is time to send final reset pulse, 50us at least */
led_start_reset_pulse(2); /* Start reset pulse at the end */
}
}
void WS2812::led_fill_led_pwm_data(size_t ledx, volatile uint16_t *ptr) {
size_t i;
uint16_t OnOffValues[] = {2 * htim1.Instance->ARR / 3, (4 * htim1.Instance->ARR) / 3};
if (ledx < WS2812_LED_COUNT) {
for (i = 0; i < 8; i++) {
// Also unmux RGB -> GRB in the index order here
ptr[i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 1] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
ptr[8 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 0] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
ptr[16 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 2] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
#if WS2812_LED_CHANNEL_COUNT == 4
ptr[24 + i] = (leds_colors[WS2812_LED_CHANNEL_COUNT * ledx + 3] & (1 << (7 - i))) ? OnOffValues[1] : OnOffValues[0];
#endif
}
} else {
// Fill with zero?
}
}

15
source/Core/Drivers/WS2812.h
View File

@@ -11,7 +11,7 @@
#ifndef CORE_DRIVERS_WS2812_H_ #ifndef CORE_DRIVERS_WS2812_H_
#define CORE_DRIVERS_WS2812_H_ #define CORE_DRIVERS_WS2812_H_
#ifndef WS2812_LED_COUNT #ifndef WS2812_LED_COUNT
#define WS2812_LED_COUNT 3 #define WS2812_LED_COUNT 2
#endif #endif
#ifndef WS2812_LED_CHANNEL_COUNT #ifndef WS2812_LED_CHANNEL_COUNT
#define WS2812_LED_CHANNEL_COUNT 3 #define WS2812_LED_CHANNEL_COUNT 3
@@ -20,22 +20,13 @@
class WS2812 { class WS2812 {
public: public:
static void init(void); static void init(void);
static uint8_t led_update(uint8_t block); static void led_update();
static void led_set_color(size_t index, uint8_t r, uint8_t g, uint8_t b); static void led_set_color(size_t index, uint8_t r, uint8_t g, uint8_t b);
static void led_set_color_all(uint8_t r, uint8_t g, uint8_t b); static void led_set_color_all(uint8_t r, uint8_t g, uint8_t b);
private: private:
static uint8_t led_is_update_finished(void);
static void led_start_reset_pulse(uint8_t num);
static void DMAHalfComplete(DMA_HandleTypeDef *hdma);
static void DMAComplete(DMA_HandleTypeDef *hdma);
static void led_update_sequence(uint8_t tc);
static void led_fill_led_pwm_data(size_t ledx, volatile uint16_t *ptr);
static uint8_t leds_colors[WS2812_LED_CHANNEL_COUNT * WS2812_LED_COUNT]; static uint8_t leds_colors[WS2812_LED_CHANNEL_COUNT * WS2812_LED_COUNT];
static volatile uint16_t tmp_led_data[2 * WS2812_RAW_BYTES_PER_LED];
static volatile uint8_t is_reset_pulse; /*!< Status if we are sending reset pulse or led data */
static volatile uint8_t is_updating; /*!< Is updating in progress? */
static volatile uint32_t current_led; /*!< Current LED number we are sending */
}; };
#endif /* CORE_DRIVERS_WS2812_H_ */ #endif /* CORE_DRIVERS_WS2812_H_ */

179
source/Core/Threads/GUIThread.cpp
View File

@@ -199,11 +199,14 @@ static void gui_solderingTempAdjust() {
return; return;
break; break;
case BUTTON_B_LONG: case BUTTON_B_LONG:
if (xTaskGetTickCount() - autoRepeatTimer + autoRepeatAcceleration > PRESS_ACCEL_INTERVAL_MAX) { if (xTaskGetTickCount() - autoRepeatTimer
+ autoRepeatAcceleration> PRESS_ACCEL_INTERVAL_MAX) {
if (systemSettings.ReverseButtonTempChangeEnabled) { if (systemSettings.ReverseButtonTempChangeEnabled) {
systemSettings.SolderingTemp += systemSettings.TempChangeLongStep; systemSettings.SolderingTemp +=
systemSettings.TempChangeLongStep;
} else } else
systemSettings.SolderingTemp -= systemSettings.TempChangeLongStep; systemSettings.SolderingTemp -=
systemSettings.TempChangeLongStep;
autoRepeatTimer = xTaskGetTickCount(); autoRepeatTimer = xTaskGetTickCount();
autoRepeatAcceleration += PRESS_ACCEL_STEP; autoRepeatAcceleration += PRESS_ACCEL_STEP;
@@ -211,31 +214,40 @@ static void gui_solderingTempAdjust() {
break; break;
case BUTTON_B_SHORT: case BUTTON_B_SHORT:
if (systemSettings.ReverseButtonTempChangeEnabled) { if (systemSettings.ReverseButtonTempChangeEnabled) {
systemSettings.SolderingTemp += systemSettings.TempChangeShortStep; systemSettings.SolderingTemp +=
systemSettings.TempChangeShortStep;
} else } else
systemSettings.SolderingTemp -= systemSettings.TempChangeShortStep; systemSettings.SolderingTemp -=
systemSettings.TempChangeShortStep;
break; break;
case BUTTON_F_LONG: case BUTTON_F_LONG:
if (xTaskGetTickCount() - autoRepeatTimer + autoRepeatAcceleration > PRESS_ACCEL_INTERVAL_MAX) { if (xTaskGetTickCount() - autoRepeatTimer
+ autoRepeatAcceleration> PRESS_ACCEL_INTERVAL_MAX) {
if (systemSettings.ReverseButtonTempChangeEnabled) { if (systemSettings.ReverseButtonTempChangeEnabled) {
systemSettings.SolderingTemp -= systemSettings.TempChangeLongStep; systemSettings.SolderingTemp -=
systemSettings.TempChangeLongStep;
} else } else
systemSettings.SolderingTemp += systemSettings.TempChangeLongStep; systemSettings.SolderingTemp +=
systemSettings.TempChangeLongStep;
autoRepeatTimer = xTaskGetTickCount(); autoRepeatTimer = xTaskGetTickCount();
autoRepeatAcceleration += PRESS_ACCEL_STEP; autoRepeatAcceleration += PRESS_ACCEL_STEP;
} }
break; break;
case BUTTON_F_SHORT: case BUTTON_F_SHORT:
if (systemSettings.ReverseButtonTempChangeEnabled) { if (systemSettings.ReverseButtonTempChangeEnabled) {
systemSettings.SolderingTemp -= systemSettings.TempChangeShortStep; // add 10 systemSettings.SolderingTemp -=
systemSettings.TempChangeShortStep; // add 10
} else } else
systemSettings.SolderingTemp += systemSettings.TempChangeShortStep; // add 10 systemSettings.SolderingTemp +=
systemSettings.TempChangeShortStep; // add 10
break; break;
default: default:
break; break;
} }
if ((PRESS_ACCEL_INTERVAL_MAX - autoRepeatAcceleration) < PRESS_ACCEL_INTERVAL_MIN) { if ((PRESS_ACCEL_INTERVAL_MAX - autoRepeatAcceleration)
autoRepeatAcceleration = PRESS_ACCEL_INTERVAL_MAX - PRESS_ACCEL_INTERVAL_MIN; < PRESS_ACCEL_INTERVAL_MIN) {
autoRepeatAcceleration = PRESS_ACCEL_INTERVAL_MAX
- PRESS_ACCEL_INTERVAL_MIN;
} }
// constrain between 10-450 C // constrain between 10-450 C
if (systemSettings.temperatureInF) { if (systemSettings.temperatureInF) {
@@ -258,9 +270,13 @@ static void gui_solderingTempAdjust() {
#else #else
if (OLED::getRotation()) { if (OLED::getRotation()) {
#endif #endif
OLED::print(systemSettings.ReverseButtonTempChangeEnabled ? SymbolPlus : SymbolMinus, FontStyle::LARGE); OLED::print(
systemSettings.ReverseButtonTempChangeEnabled ?
SymbolPlus : SymbolMinus, FontStyle::LARGE);
} else { } else {
OLED::print(systemSettings.ReverseButtonTempChangeEnabled ? SymbolMinus : SymbolPlus, FontStyle::LARGE); OLED::print(
systemSettings.ReverseButtonTempChangeEnabled ?
SymbolMinus : SymbolPlus, FontStyle::LARGE);
} }
OLED::print(SymbolSpace, FontStyle::LARGE); OLED::print(SymbolSpace, FontStyle::LARGE);
@@ -276,9 +292,13 @@ static void gui_solderingTempAdjust() {
#else #else
if (OLED::getRotation()) { if (OLED::getRotation()) {
#endif #endif
OLED::print(systemSettings.ReverseButtonTempChangeEnabled ? SymbolMinus : SymbolPlus, FontStyle::LARGE); OLED::print(
systemSettings.ReverseButtonTempChangeEnabled ?
SymbolMinus : SymbolPlus, FontStyle::LARGE);
} else { } else {
OLED::print(systemSettings.ReverseButtonTempChangeEnabled ? SymbolPlus : SymbolMinus, FontStyle::LARGE); OLED::print(
systemSettings.ReverseButtonTempChangeEnabled ?
SymbolPlus : SymbolMinus, FontStyle::LARGE);
} }
OLED::refresh(); OLED::refresh();
GUIDelay(); GUIDelay();
@@ -287,12 +307,14 @@ static void gui_solderingTempAdjust() {
static bool shouldShutdown() { static bool shouldShutdown() {
if (systemSettings.ShutdownTime) { // only allow shutdown exit if time > 0 if (systemSettings.ShutdownTime) { // only allow shutdown exit if time > 0
if (lastMovementTime) { if (lastMovementTime) {
if (((TickType_t)(xTaskGetTickCount() - lastMovementTime)) > (TickType_t)(systemSettings.ShutdownTime * TICKS_MIN)) { if (((TickType_t) (xTaskGetTickCount() - lastMovementTime))
> (TickType_t) (systemSettings.ShutdownTime * TICKS_MIN)) {
return true; return true;
} }
} }
if (lastHallEffectSleepStart) { if (lastHallEffectSleepStart) {
if (((TickType_t)(xTaskGetTickCount() - lastHallEffectSleepStart)) > (TickType_t)(systemSettings.ShutdownTime * TICKS_MIN)) { if (((TickType_t) (xTaskGetTickCount() - lastHallEffectSleepStart))
> (TickType_t) (systemSettings.ShutdownTime * TICKS_MIN)) {
return true; return true;
} }
} }
@@ -311,9 +333,18 @@ static int gui_SolderingSleepingMode(bool stayOff, bool autoStarted) {
return 1; // return non-zero on error return 1; // return non-zero on error
#endif #endif
if (systemSettings.temperatureInF) { if (systemSettings.temperatureInF) {
currentTempTargetDegC = stayOff ? 0 : TipThermoModel::convertFtoC(min(systemSettings.SleepTemp, systemSettings.SolderingTemp)); currentTempTargetDegC =
stayOff ?
0 :
TipThermoModel::convertFtoC(
min(systemSettings.SleepTemp,
systemSettings.SolderingTemp));
} else { } else {
currentTempTargetDegC = stayOff ? 0 : min(systemSettings.SleepTemp, systemSettings.SolderingTemp); currentTempTargetDegC =
stayOff ?
0 :
min(systemSettings.SleepTemp,
systemSettings.SolderingTemp);
} }
// draw the lcd // draw the lcd
uint16_t tipTemp; uint16_t tipTemp;
@@ -326,9 +357,11 @@ static int gui_SolderingSleepingMode(bool stayOff, bool autoStarted) {
OLED::clearScreen(); OLED::clearScreen();
OLED::setCursor(0, 0); OLED::setCursor(0, 0);
if (systemSettings.detailedSoldering) { if (systemSettings.detailedSoldering) {
OLED::print(translatedString(Tr->SleepingAdvancedString), FontStyle::SMALL); OLED::print(translatedString(Tr->SleepingAdvancedString),
FontStyle::SMALL);
OLED::setCursor(0, 8); OLED::setCursor(0, 8);
OLED::print(translatedString(Tr->SleepingTipAdvancedString), FontStyle::SMALL); OLED::print(translatedString(Tr->SleepingTipAdvancedString),
FontStyle::SMALL);
OLED::printNumber(tipTemp, 3, FontStyle::SMALL); OLED::printNumber(tipTemp, 3, FontStyle::SMALL);
if (systemSettings.temperatureInF) if (systemSettings.temperatureInF)
OLED::print(SymbolDegF, FontStyle::SMALL); OLED::print(SymbolDegF, FontStyle::SMALL);
@@ -340,7 +373,8 @@ static int gui_SolderingSleepingMode(bool stayOff, bool autoStarted) {
printVoltage(); printVoltage();
OLED::print(SymbolVolts, FontStyle::SMALL); OLED::print(SymbolVolts, FontStyle::SMALL);
} else { } else {
OLED::print(translatedString(Tr->SleepingSimpleString), FontStyle::LARGE); OLED::print(translatedString(Tr->SleepingSimpleString),
FontStyle::LARGE);
OLED::printNumber(tipTemp, 3, FontStyle::LARGE); OLED::printNumber(tipTemp, 3, FontStyle::LARGE);
if (systemSettings.temperatureInF) if (systemSettings.temperatureInF)
OLED::drawSymbol(0); OLED::drawSymbol(0);
@@ -359,7 +393,8 @@ static int gui_SolderingSleepingMode(bool stayOff, bool autoStarted) {
// If we have moved recently; in the last second // If we have moved recently; in the last second
// Then exit soldering mode // Then exit soldering mode
if (((TickType_t)(xTaskGetTickCount() - lastMovementTime)) < (TickType_t)(TICKS_SECOND)) { if (((TickType_t) (xTaskGetTickCount() - lastMovementTime))
< (TickType_t) (TICKS_SECOND)) {
currentTempTargetDegC = 0; currentTempTargetDegC = 0;
return 1; return 1;
} }
@@ -486,11 +521,13 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
case BUTTON_BOTH_LONG: case BUTTON_BOTH_LONG:
// Unlock buttons // Unlock buttons
buttonsLocked = false; buttonsLocked = false;
warnUser(translatedString(Tr->UnlockingKeysString), TICKS_SECOND); warnUser(translatedString(Tr->UnlockingKeysString),
TICKS_SECOND);
break; break;
case BUTTON_F_LONG: case BUTTON_F_LONG:
// if boost mode is enabled turn it on // if boost mode is enabled turn it on
if (systemSettings.BoostTemp && (systemSettings.lockingMode == 1)) { if (systemSettings.BoostTemp
&& (systemSettings.lockingMode == 1)) {
boostModeOn = true; boostModeOn = true;
} }
break; break;
@@ -500,7 +537,8 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
case BUTTON_F_SHORT: case BUTTON_F_SHORT:
case BUTTON_B_SHORT: case BUTTON_B_SHORT:
// Do nothing and display a lock warming // Do nothing and display a lock warming
warnUser(translatedString(Tr->WarningKeysLockedString), TICKS_SECOND / 2); warnUser(translatedString(Tr->WarningKeysLockedString),
TICKS_SECOND / 2);
break; break;
default: default:
break; break;
@@ -530,12 +568,14 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
if (oldTemp != systemSettings.SolderingTemp) { if (oldTemp != systemSettings.SolderingTemp) {
saveSettings(); // only save on change saveSettings(); // only save on change
} }
} break; }
break;
case BUTTON_BOTH_LONG: case BUTTON_BOTH_LONG:
if (systemSettings.lockingMode != 0) { if (systemSettings.lockingMode != 0) {
// Lock buttons // Lock buttons
buttonsLocked = true; buttonsLocked = true;
warnUser(translatedString(Tr->LockingKeysString), TICKS_SECOND); warnUser(translatedString(Tr->LockingKeysString),
TICKS_SECOND);
} }
break; break;
default: default:
@@ -549,9 +589,11 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
if (systemSettings.detailedSoldering) { if (systemSettings.detailedSoldering) {
OLED::print(translatedString(Tr->SolderingAdvancedPowerPrompt), OLED::print(translatedString(Tr->SolderingAdvancedPowerPrompt),
FontStyle::SMALL); // Power: FontStyle::SMALL); // Power:
OLED::printNumber(x10WattHistory.average() / 10, 2, FontStyle::SMALL); OLED::printNumber(x10WattHistory.average() / 10, 2,
FontStyle::SMALL);
OLED::print(SymbolDot, FontStyle::SMALL); OLED::print(SymbolDot, FontStyle::SMALL);
OLED::printNumber(x10WattHistory.average() % 10, 1, FontStyle::SMALL); OLED::printNumber(x10WattHistory.average() % 10, 1,
FontStyle::SMALL);
OLED::print(SymbolWatts, FontStyle::SMALL); OLED::print(SymbolWatts, FontStyle::SMALL);
#ifndef NO_SLEEP_MODE #ifndef NO_SLEEP_MODE
if (systemSettings.sensitivity && systemSettings.SleepTime) { if (systemSettings.sensitivity && systemSettings.SleepTime) {
@@ -560,7 +602,8 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
} }
#endif #endif
OLED::setCursor(0, 8); OLED::setCursor(0, 8);
OLED::print(translatedString(Tr->SleepingTipAdvancedString), FontStyle::SMALL); OLED::print(translatedString(Tr->SleepingTipAdvancedString),
FontStyle::SMALL);
gui_drawTipTemp(true, FontStyle::SMALL); gui_drawTipTemp(true, FontStyle::SMALL);
if (boostModeOn) { if (boostModeOn) {
@@ -609,13 +652,15 @@ static void gui_solderingMode(uint8_t jumpToSleep) {
// Update the setpoints for the temperature // Update the setpoints for the temperature
if (boostModeOn) { if (boostModeOn) {
if (systemSettings.temperatureInF) if (systemSettings.temperatureInF)
currentTempTargetDegC = TipThermoModel::convertFtoC(systemSettings.BoostTemp); currentTempTargetDegC = TipThermoModel::convertFtoC(
systemSettings.BoostTemp);
else { else {
currentTempTargetDegC = (systemSettings.BoostTemp); currentTempTargetDegC = (systemSettings.BoostTemp);
} }
} else { } else {
if (systemSettings.temperatureInF) if (systemSettings.temperatureInF)
currentTempTargetDegC = TipThermoModel::convertFtoC(systemSettings.SolderingTemp); currentTempTargetDegC = TipThermoModel::convertFtoC(
systemSettings.SolderingTemp);
else { else {
currentTempTargetDegC = (systemSettings.SolderingTemp); currentTempTargetDegC = (systemSettings.SolderingTemp);
} }
@@ -653,27 +698,36 @@ void showDebugMenu(void) {
break; break;
case 1: case 1:
// High water mark for GUI // High water mark for GUI
OLED::printNumber(uxTaskGetStackHighWaterMark(GUITaskHandle), 5, FontStyle::SMALL); OLED::printNumber(uxTaskGetStackHighWaterMark(GUITaskHandle), 5,
FontStyle::SMALL);
break; break;
case 2: case 2:
// High water mark for the Movement task // High water mark for the Movement task
OLED::printNumber(uxTaskGetStackHighWaterMark(MOVTaskHandle), 5, FontStyle::SMALL); OLED::printNumber(uxTaskGetStackHighWaterMark(MOVTaskHandle), 5,
FontStyle::SMALL);
break; break;
case 3: case 3:
// High water mark for the PID task // High water mark for the PID task
OLED::printNumber(uxTaskGetStackHighWaterMark(PIDTaskHandle), 5, FontStyle::SMALL); OLED::printNumber(uxTaskGetStackHighWaterMark(PIDTaskHandle), 5,
FontStyle::SMALL);
break; break;
case 4: case 4:
// system up time stamp // system up time stamp
OLED::printNumber(xTaskGetTickCount() / TICKS_100MS, 5, FontStyle::SMALL); OLED::printNumber(xTaskGetTickCount() / TICKS_100MS, 5,
FontStyle::SMALL);
break; break;
case 5: case 5:
// Movement time stamp // Movement time stamp
OLED::printNumber(lastMovementTime / TICKS_100MS, 5, FontStyle::SMALL); OLED::printNumber(lastMovementTime / TICKS_100MS, 5,
FontStyle::SMALL);
break; break;
case 6: case 6:
// Raw Tip // Raw Tip
{ OLED::printNumber(TipThermoModel::convertTipRawADCTouV(getTipRawTemp(0), true), 6, FontStyle::SMALL); } {
OLED::printNumber(
TipThermoModel::convertTipRawADCTouV(getTipRawTemp(0),
true), 6, FontStyle::SMALL);
}
break; break;
case 7: case 7:
// Temp in C // Temp in C
@@ -689,7 +743,8 @@ void showDebugMenu(void) {
break; break;
case 10: case 10:
// Print PCB ID number // Print PCB ID number
OLED::printNumber(DetectedAccelerometerVersion, 2, FontStyle::SMALL); OLED::printNumber(DetectedAccelerometerVersion, 2,
FontStyle::SMALL);
break; break;
case 11: case 11:
// Power negotiation status // Power negotiation status
@@ -717,7 +772,8 @@ void showDebugMenu(void) {
break; break;
case 12: case 12:
// Max deg C limit // Max deg C limit
OLED::printNumber(TipThermoModel::getTipMaxInC(), 3, FontStyle::SMALL); OLED::printNumber(TipThermoModel::getTipMaxInC(), 3,
FontStyle::SMALL);
break; break;
default: default:
break; break;
@@ -752,7 +808,8 @@ void showWarnings() {
if (systemSettings.accelMissingWarningCounter < 2) { if (systemSettings.accelMissingWarningCounter < 2) {
systemSettings.accelMissingWarningCounter++; systemSettings.accelMissingWarningCounter++;
saveSettings(); saveSettings();
warnUser(translatedString(Tr->NoAccelerometerMessage), 10 * TICKS_SECOND); warnUser(translatedString(Tr->NoAccelerometerMessage),
10 * TICKS_SECOND);
} }
} }
#ifdef POW_PD #ifdef POW_PD
@@ -761,7 +818,8 @@ void showWarnings() {
if (systemSettings.pdMissingWarningCounter < 2) { if (systemSettings.pdMissingWarningCounter < 2) {
systemSettings.pdMissingWarningCounter++; systemSettings.pdMissingWarningCounter++;
saveSettings(); saveSettings();
warnUser(translatedString(Tr->NoPowerDeliveryMessage), 10 * TICKS_SECOND); warnUser(translatedString(Tr->NoPowerDeliveryMessage),
10 * TICKS_SECOND);
} }
} }
#endif #endif
@@ -784,7 +842,8 @@ void startGUITask(void const *argument __unused) {
// flipped is generated by flipping each row // flipped is generated by flipping each row
for (int row = 0; row < 2; row++) { for (int row = 0; row < 2; row++) {
for (int x = 0; x < 84; x++) { for (int x = 0; x < 84; x++) {
idleScreenBGF[(row * 84) + x] = idleScreenBG[(row * 84) + (83 - x)]; idleScreenBGF[(row * 84) + x] = idleScreenBG[(row * 84)
+ (83 - x)];
} }
} }
} }
@@ -856,7 +915,11 @@ void startGUITask(void const *argument __unused) {
currentTempTargetDegC = 0; // ensure tip is off currentTempTargetDegC = 0; // ensure tip is off
getInputVoltageX10(systemSettings.voltageDiv, 0); getInputVoltageX10(systemSettings.voltageDiv, 0);
uint32_t tipTemp = TipThermoModel::getTipInC(); uint32_t tipTemp = TipThermoModel::getTipInC();
if (tipTemp > 55) {
setStatusLED(LED_COOLING_STILL_HOT);
} else {
setStatusLED(LED_OFF);
}
// Preemptively turn the display on. Turn it off if and only if // Preemptively turn the display on. Turn it off if and only if
// the tip temperature is below 50 degrees C *and* motion sleep // the tip temperature is below 50 degrees C *and* motion sleep
// detection is enabled *and* there has been no activity (movement or // detection is enabled *and* there has been no activity (movement or
@@ -864,7 +927,11 @@ void startGUITask(void const *argument __unused) {
// This is zero cost really as state is only changed on display updates // This is zero cost really as state is only changed on display updates
OLED::setDisplayState(OLED::DisplayState::ON); OLED::setDisplayState(OLED::DisplayState::ON);
if ((tipTemp < 50) && systemSettings.sensitivity && (((xTaskGetTickCount() - lastMovementTime) > MOVEMENT_INACTIVITY_TIME) && ((xTaskGetTickCount() - lastButtonTime) > BUTTON_INACTIVITY_TIME))) { if ((tipTemp < 50) && systemSettings.sensitivity
&& (((xTaskGetTickCount() - lastMovementTime)
> MOVEMENT_INACTIVITY_TIME)
&& ((xTaskGetTickCount() - lastButtonTime)
> BUTTON_INACTIVITY_TIME))) {
OLED::setDisplayState(OLED::DisplayState::OFF); OLED::setDisplayState(OLED::DisplayState::OFF);
} }
// Clear the lcd buffer // Clear the lcd buffer
@@ -872,16 +939,21 @@ void startGUITask(void const *argument __unused) {
OLED::setCursor(0, 0); OLED::setCursor(0, 0);
if (systemSettings.detailedIDLE) { if (systemSettings.detailedIDLE) {
if (isTipDisconnected()) { if (isTipDisconnected()) {
OLED::print(translatedString(Tr->TipDisconnectedString), FontStyle::SMALL); OLED::print(translatedString(Tr->TipDisconnectedString),
FontStyle::SMALL);
} else { } else {
OLED::print(translatedString(Tr->IdleTipString), FontStyle::SMALL); OLED::print(translatedString(Tr->IdleTipString),
FontStyle::SMALL);
gui_drawTipTemp(false, FontStyle::SMALL); gui_drawTipTemp(false, FontStyle::SMALL);
OLED::print(translatedString(Tr->IdleSetString), FontStyle::SMALL); OLED::print(translatedString(Tr->IdleSetString),
OLED::printNumber(systemSettings.SolderingTemp, 3, FontStyle::SMALL); FontStyle::SMALL);
OLED::printNumber(systemSettings.SolderingTemp, 3,
FontStyle::SMALL);
} }
OLED::setCursor(0, 8); OLED::setCursor(0, 8);
OLED::print(translatedString(Tr->InputVoltageString), FontStyle::SMALL); OLED::print(translatedString(Tr->InputVoltageString),
FontStyle::SMALL);
printVoltage(); printVoltage();
} else { } else {
@@ -927,7 +999,8 @@ void startGUITask(void const *argument __unused) {
// If we have a tip connected draw the temp, if not we leave it blank // If we have a tip connected draw the temp, if not we leave it blank
if (!tipDisconnectedDisplay) { if (!tipDisconnectedDisplay) {
// draw in the temp // draw in the temp
if (!(systemSettings.coolingTempBlink && (xTaskGetTickCount() % 260 < 160))) if (!(systemSettings.coolingTempBlink
&& (xTaskGetTickCount() % 260 < 160)))
gui_drawTipTemp(false, FontStyle::LARGE); // draw in the temp gui_drawTipTemp(false, FontStyle::LARGE); // draw in the temp
} else { } else {
// Draw in missing tip symbol // Draw in missing tip symbol