Basic OLED working

* OLED
* Buttons

source/Core/BSP/MHP30/BSP.cpp

@@ -10,18 +10,14 @@
 #include <IRQ.h>
 volatile uint16_t PWMSafetyTimer = 0;
 volatile uint8_t pendingPWM = 0;
-
+uint16_t totalPWM = 255;
 const uint16_t powerPWM = 255;
-static const uint8_t holdoffTicks     = 14; // delay of 8 ms
-static const uint8_t tempMeasureTicks = 14;
 
-uint16_t totalPWM; // htim2.Init.Period, the full PWM cycle
-
-static bool fastPWM;
-
-// 2 second filter (ADC is PID_TIM_HZ Hz)
 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
 // Lookup table for the NTC
 // Stored as ADCReading,Temp in degC
@@ -91,56 +87,22 @@ static const uint16_t NTCHandleLookup[] = {
 		};
 #endif
 
+// These are called by the HAL after the corresponding events from the system
+// timers.
+
+void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
+	// Period has elapsed
+	if (htim->Instance == TIM1) {
+		// STM uses this for internal functions as a counter for timeouts
+		HAL_IncTick();
+	}
+}
 uint16_t getHandleTemperature() {
-#ifdef TEMP_NTC
+	return 250; //TODO
-  // TS80P uses 100k NTC resistors instead
-  // NTCG104EF104FT1X from TDK
-  // For now not doing interpolation
-  int32_t result = getADC(0);
-  for (uint32_t i = 0; i < (sizeof(NTCHandleLookup) / (2 * sizeof(uint16_t))); i++) {
-    if (result > NTCHandleLookup[(i * 2) + 0]) {
-      return NTCHandleLookup[(i * 2) + 1] * 10;
-    }
-  }
-  return 45 * 10;
-#endif
-#ifdef TEMP_TMP36
-  // We return the current handle temperature in X10 C
-  // TMP36 in handle, 0.5V offset and then 10mV per deg C (0.75V @ 25C for
-  // example) STM32 = 4096 count @ 3.3V input -> But We oversample by 32/(2^2) =
-  // 8 times oversampling Therefore 32768 is the 3.3V input, so 0.1007080078125
-  // mV per count So we need to subtract an offset of 0.5V to center on 0C
-  // (4964.8 counts)
-  //
-  int32_t result = getADC(0);
-  result -= 4965; // remove 0.5V offset
-  // 10mV per C
-  // 99.29 counts per Deg C above 0C. Tends to read a tad over across all of my sample units
-  result *= 100;
-  result /= 994;
-  return result;
-#endif
 }
 
 uint16_t getTipInstantTemperature() {
-  uint16_t sum = 0; // 12 bit readings * 8 -> 15 bits
+	return 0; //TODO
-  uint16_t readings[8];
-  // Looking to reject the highest outlier readings.
-  // As on some hardware these samples can run into the op-amp recovery time
-  // Once this time is up the signal stabilises quickly, so no need to reject minimums
-  readings[0] = hadc1.Instance->JDR1;
-  readings[1] = hadc1.Instance->JDR2;
-  readings[2] = hadc1.Instance->JDR3;
-  readings[3] = hadc1.Instance->JDR4;
-  readings[4] = hadc2.Instance->JDR1;
-  readings[5] = hadc2.Instance->JDR2;
-  readings[6] = hadc2.Instance->JDR3;
-  readings[7] = hadc2.Instance->JDR4;
-
-  for (int i = 0; i < 8; i++) {
-    sum += readings[i];
-  }
-  return sum; // 8x over sample
 }
 
 uint16_t getTipRawTemp(uint8_t refresh) {
@@ -181,80 +143,15 @@ uint16_t getInputVoltageX10(uint16_t divisor, uint8_t sample) {
 	}
 	return sum * 4 / divisor;
 }
-
-void setTipPWM(uint8_t pulse) {
-  PWMSafetyTimer = 10; // This is decremented in the handler for PWM so that the tip pwm is
-                       // disabled if the PID task is not scheduled often enough.
-
-  pendingPWM = pulse;
-}
-
-static void switchToFastPWM(void) {
-  fastPWM             = true;
-  totalPWM            = powerPWM + tempMeasureTicks * 2 + holdoffTicks;
-  htim2.Instance->ARR = totalPWM;
-  // ~3.5 Hz rate
-  htim2.Instance->CCR1 = powerPWM + holdoffTicks * 2;
-  // 2 MHz timer clock/2000 = 1 kHz tick rate
-  htim2.Instance->PSC = 2000;
-}
-
-static void switchToSlowPWM(void) {
-  fastPWM             = false;
-  totalPWM            = powerPWM + tempMeasureTicks + holdoffTicks;
-  htim2.Instance->ARR = totalPWM;
-  // ~1.84 Hz rate
-  htim2.Instance->CCR1 = powerPWM + holdoffTicks;
-  // 2 MHz timer clock/4000 = 500 Hz tick rate
-  htim2.Instance->PSC = 4000;
-}
-
 bool tryBetterPWM(uint8_t pwm) {
-  if (fastPWM && pwm == powerPWM) {
+	//We dont need this for the MHP30
-    // maximum power for fast PWM reached, need to go slower to get more
-    switchToSlowPWM();
-    return true;
-  } else if (!fastPWM && pwm < 230) {
-    // 254 in fast PWM mode gives the same power as 239 in slow
-    // allow for some reasonable hysteresis by switching only when it goes
-    // below 230 (equivalent to 245 in fast mode)
-    switchToFastPWM();
-    return true;
-  }
 	return false;
 }
-
+void setTipPWM(uint8_t pulse) {
-// These are called by the HAL after the corresponding events from the system
+	//We can just set the timer directly
-// timers.
+	htim3.Instance->CCR1 = pulse;
-
-void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
-  // Period has elapsed
-  if (htim->Instance == TIM2) {
-    // we want to turn on the output again
-    PWMSafetyTimer--;
-    // We decrement this safety value so that lockups in the
-    // scheduler will not cause the PWM to become locked in an
-    // active driving state.
-    // While we could assume this could never happen, its a small price for
-    // increased safety
-    htim2.Instance->CCR4 = pendingPWM;
-    if (htim2.Instance->CCR4 && PWMSafetyTimer) {
-      HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
-    } else {
-      HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_1);
-    }
-  } else if (htim->Instance == TIM1) {
-    // STM uses this for internal functions as a counter for timeouts
-    HAL_IncTick();
-  }
 }
 
-void HAL_TIM_PWM_PulseFinishedCallback(TIM_HandleTypeDef *htim) {
-  // This was a when the PWM for the output has timed out
-  if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_4) {
-    HAL_TIM_PWM_Stop(&htim3, TIM_CHANNEL_1);
-  }
-}
 void unstick_I2C() {
 	GPIO_InitTypeDef GPIO_InitStruct;
 	int timeout = 100;
@@ -324,11 +221,22 @@ void unstick_I2C() {
 	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) { switchToFastPWM(); }
+void BSPInit(void) {
+}
 
-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);
+}

source/Core/BSP/MHP30/Model_Config.h

@@ -23,8 +23,8 @@
 #define TEMP_NTC
 #define I2C_SOFT
 #define LIS_ORI_FLIP
-#define OLED_FLIP
 #define BATTFILTERDEPTH 8
+#define OLED_I2CBB
 #endif
 
 #endif /* BSP_MINIWARE_MODEL_CONFIG_H_ */

source/Core/BSP/MHP30/Setup.c

@@ -300,14 +300,14 @@ static void MX_TIM2_Init(void) {
 	TIM_OC_InitTypeDef sConfigOC;
 
 	htim2.Instance = TIM2;
-	htim2.Init.Prescaler = 2000; // 2 MHz timer clock/2000 = 1 kHz tick rate
+	htim2.Init.Prescaler = 200; // 2 MHz timer clock/2000 = 1 kHz tick rate
 
 	// pwm out is 10k from tim3, we want to run our PWM at around 10hz or slower on the output stage
 	// These values give a rate of around 3.5 Hz for "fast" mode and 1.84 Hz for "slow"
 	htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
 	// dummy value, will be reconfigured by BSPInit()
 	htim2.Init.Period = 10;
-	htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4; // 8 MHz (x2 APB1) before divide
+	htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 8 MHz (x2 APB1) before divide
 	htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 	htim2.Init.RepetitionCounter = 0;
 	HAL_TIM_Base_Init(&htim2);
@@ -324,13 +324,12 @@ static void MX_TIM2_Init(void) {
 
 	sConfigOC.OCMode = TIM_OCMODE_PWM1;
 	// dummy value, will be reconfigured by BSPInit() in the BSP.cpp
-	sConfigOC.Pulse = 5; // 13 -> Delay of 7 ms
+	sConfigOC.Pulse = 5;
 	sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
 	sConfigOC.OCFastMode = TIM_OCFAST_ENABLE;
 	sConfigOC.Pulse = 0; // default to entirely off
 	HAL_TIM_OC_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_4);
 
-	HAL_TIM_Base_Start_IT(&htim2);
 	HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_4);
 }
 

source/Core/BSP/MHP30/flash.c

@@ -13,6 +13,7 @@
 static uint16_t settings_page[512] __attribute__((section(".settings_page")));
 
 uint8_t flash_save_buffer(const uint8_t *buffer, const uint16_t length) {
+	return; //TODO
 	FLASH_EraseInitTypeDef pEraseInit;
 	pEraseInit.TypeErase = FLASH_TYPEERASE_PAGES;
 	pEraseInit.Banks = FLASH_BANK_1;
@@ -20,7 +21,8 @@ uint8_t flash_save_buffer(const uint8_t *buffer, const uint16_t length) {
 	pEraseInit.PageAddress = (uint32_t) settings_page;
 	uint32_t failingAddress = 0;
 	resetWatchdog();
-  __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR | FLASH_FLAG_BSY);
+	__HAL_FLASH_CLEAR_FLAG(
+			FLASH_FLAG_EOP | FLASH_FLAG_WRPERR | FLASH_FLAG_PGERR | FLASH_FLAG_BSY);
 	HAL_FLASH_Unlock();
 	HAL_Delay(1);
 	resetWatchdog();
@@ -32,10 +34,16 @@ uint8_t flash_save_buffer(const uint8_t *buffer, const uint16_t length) {
 	HAL_FLASH_Unlock();
 	for (uint16_t i = 0; i < (length / 2); i++) {
 		resetWatchdog();
-    HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD, (uint32_t)&settings_page[i], data[i]);
+		HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,
+				(uint32_t) &settings_page[i], data[i]);
 	}
 	HAL_FLASH_Lock();
 	return 1;
 }
 
-void flash_read_buffer(uint8_t *buffer, const uint16_t length) { memcpy(buffer, settings_page, length); }
+void flash_read_buffer(uint8_t *buffer, const uint16_t length) {
+	memset(buffer, 0, length);
+	return; // TODO
+
+	memcpy(buffer, settings_page, length);
+}

source/Core/BSP/MHP30/fusb_user.cpp

@@ -5,6 +5,7 @@
 #include "Setup.h"
 #include "fusb302b.h"
 #include "fusb_user.h"
+#include "Pins.h"
 /*
  * Read a single byte from the FUSB302B
  *
@@ -53,7 +54,7 @@ bool fusb_write_byte(uint8_t addr, uint8_t byte) {
  * buf: The buffer to write
  */
 bool fusb_write_buf(uint8_t addr, uint8_t size, const uint8_t *buf) {
-	return FRToSI2C::Mem_Write(FUSB302B_ADDR, addr, buf, size);
+	return FRToSI2C::Mem_Write(FUSB302B_ADDR, addr, (uint8_t*)buf, size);
 }
 
 uint8_t fusb302_detect() {

source/Core/BSP/MHP30/preRTOS.cpp

@@ -15,6 +15,7 @@
 void preRToSInit() {
 	/* Reset of all peripherals, Initializes the Flash interface and the Systick.
 	 */
+	SCB->VTOR = FLASH_BASE; //Set vector table offset
 	HAL_Init();
 	Setup_HAL(); // Setup all the HAL objects
 	BSPInit();

source/Core/BSP/MHP30/stm32f1xx_it.c

@@ -44,11 +44,7 @@ void ADC1_2_IRQHandler(void) { HAL_ADC_IRQHandler(&hadc1); }
 
 // Timer 1 has overflowed, used for HAL ticks
 void TIM1_UP_IRQHandler(void) { HAL_TIM_IRQHandler(&htim1); }
-// Timer 3 is used for the PWM output to the tip
-void TIM3_IRQHandler(void) { HAL_TIM_IRQHandler(&htim3); }
 
-// Timer 2 is used for co-ordination of PWM & ADC
-void TIM2_IRQHandler(void) { HAL_TIM_IRQHandler(&htim2); }
 
 void I2C1_EV_IRQHandler(void) { HAL_I2C_EV_IRQHandler(&hi2c1); }
 void I2C1_ER_IRQHandler(void) { HAL_I2C_ER_IRQHandler(&hi2c1); }

source/Core/Drivers/I2CBB.cpp

@@ -40,7 +40,8 @@ bool I2CBB::probe(uint8_t address) {
 	return ack;
 }
 
-bool I2CBB::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size) {
+bool I2CBB::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData,
+		uint16_t Size) {
 	if (!lock())
 		return false;
 	start();
@@ -76,7 +77,8 @@ bool I2CBB::Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, u
 	return true;
 }
 
-bool I2CBB::Mem_Write(uint16_t DevAddress, uint16_t MemAddress, const uint8_t *pData, uint16_t Size) {
+bool I2CBB::Mem_Write(uint16_t DevAddress, uint16_t MemAddress,
+		const uint8_t *pData, uint16_t Size) {
 	if (!lock())
 		return false;
 	start();
@@ -154,7 +156,8 @@ void I2CBB::Receive(uint16_t DevAddress, uint8_t *pData, uint16_t Size) {
 	unlock();
 }
 
-void I2CBB::TransmitReceive(uint16_t DevAddress, uint8_t *pData_tx, uint16_t Size_tx, uint8_t *pData_rx, uint16_t Size_rx) {
+void I2CBB::TransmitReceive(uint16_t DevAddress, uint8_t *pData_tx,
+		uint16_t Size_tx, uint8_t *pData_rx, uint16_t Size_rx) {
 	if (Size_tx == 0 && Size_rx == 0)
 		return;
 	if (lock() == false)
@@ -264,7 +267,9 @@ uint8_t I2CBB::read_bit() {
 	return b;
 }
 
-void I2CBB::unlock() { xSemaphoreGive(I2CSemaphore); }
+void I2CBB::unlock() {
+	xSemaphoreGive(I2CSemaphore);
+}
 
 bool I2CBB::lock() {
 	if (I2CSemaphore == NULL) {
@@ -274,6 +279,16 @@ bool I2CBB::lock() {
 	return a;
 }
 
+bool I2CBB::I2C_RegisterWrite(uint8_t address, uint8_t reg, uint8_t data) {
+	return Mem_Write(address, reg, &data, 1);
+}
+
+uint8_t I2CBB::I2C_RegisterRead(uint8_t address, uint8_t reg) {
+	uint8_t temp = 0;
+	Mem_Read(address, reg, &temp, 1);
+	return temp;
+}
+
 void I2CBB::write_bit(uint8_t val) {
 	if (val) {
 		SOFT_SDA_HIGH();
@@ -287,4 +302,16 @@ void I2CBB::write_bit(uint8_t val) {
 	SOFT_SCL_LOW();
 }
 
+bool I2CBB::writeRegistersBulk(const uint8_t address, const I2C_REG *registers,
+		const uint8_t registersLength) {
+	for (int index = 0; index < registersLength; index++) {
+		if (!I2C_RegisterWrite(address, registers[index].reg,
+				registers[index].val)) {
+			return false;
+		}
+		if (registers[index].pause_ms)
+			delay_ms(registers[index].pause_ms);
+	}
+	return true;
+}
 #endif

source/Core/Drivers/I2CBB.hpp

@@ -22,13 +22,24 @@ public:
 	// Probe if device ACK's address or not
 	static bool probe(uint8_t address);
 	// Issues a complete 8bit register read
-  static bool Mem_Read(uint16_t DevAddress, uint16_t MemAddress, uint8_t *pData, uint16_t Size);
+	static bool Mem_Read(uint16_t DevAddress, uint16_t MemAddress,
+			uint8_t *pData, uint16_t Size);
 	// Implements a register write
-  static bool Mem_Write(uint16_t DevAddress, uint16_t MemAddress, const uint8_t *pData, uint16_t Size);
+	static bool Mem_Write(uint16_t DevAddress, uint16_t MemAddress,
+			const uint8_t *pData, uint16_t Size);
 	static void Transmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
 	static void Receive(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
-  static void TransmitReceive(uint16_t DevAddress, uint8_t *pData_tx, uint16_t Size_tx, uint8_t *pData_rx, uint16_t Size_rx);
+	static void TransmitReceive(uint16_t DevAddress, uint8_t *pData_tx,
-
+			uint16_t Size_tx, uint8_t *pData_rx, uint16_t Size_rx);
+	static bool I2C_RegisterWrite(uint8_t address, uint8_t reg, uint8_t data);
+	static uint8_t I2C_RegisterRead(uint8_t address, uint8_t reg);
+	typedef struct {
+		const uint8_t reg;      // The register to write to
+		uint8_t val;      // The value to write to this register
+		const uint8_t pause_ms; // How many ms to pause _after_ writing this reg
+	} I2C_REG;
+	static bool writeRegistersBulk(const uint8_t address,
+			const I2C_REG *registers, const uint8_t registersLength);
 private:
 	static SemaphoreHandle_t I2CSemaphore;
 	static StaticSemaphore_t xSemaphoreBuffer;

source/Core/Drivers/OLED.cpp

@@ -29,7 +29,7 @@ uint8_t            OLED::secondFrameBuffer[OLED_WIDTH * 2];
 /*http://www.displayfuture.com/Display/datasheet/controller/SSD1307.pdf*/
 /*All commands are prefixed with 0x80*/
 /*Data packets are prefixed with 0x40*/
-FRToSI2C::I2C_REG OLED_Setup_Array[] = {
+I2C_CLASS::I2C_REG OLED_Setup_Array[] = {
     /**/
     {0x80, 0xAE, 0}, /*Display off*/
     {0x80, 0xD5, 0}, /*Set display clock divide ratio / osc freq*/
@@ -89,7 +89,7 @@ void OLED::initialize() {
   // initialisation data to the OLED.
 
   for (int tries = 0; tries < 10; tries++) {
-    if (FRToSI2C::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]))) {
+    if (I2C_CLASS::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]))) {
       return;
     }
   }
@@ -238,7 +238,7 @@ void OLED::setRotation(bool leftHanded) {
     OLED_Setup_Array[5].val = 0xC0;
     OLED_Setup_Array[9].val = 0xA0;
   }
-  FRToSI2C::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]));
+  I2C_CLASS::writeRegistersBulk(DEVICEADDR_OLED, OLED_Setup_Array, sizeof(OLED_Setup_Array) / sizeof(OLED_Setup_Array[0]));
 
   inLeftHandedMode = leftHanded;
 

source/Core/Drivers/OLED.hpp

@@ -10,8 +10,8 @@
 #ifndef OLED_HPP_
 #define OLED_HPP_
 #include "Font.h"
-#include "I2C_Wrapper.hpp"
 #include <BSP.h>
+#include "Model_Config.h"
 #include <stdbool.h>
 #include <string.h>
 #ifdef __cplusplus
@@ -21,6 +21,16 @@ extern "C" {
 #ifdef __cplusplus
 }
 #endif
+
+
+#ifdef OLED_I2CBB
+#include "I2CBB.hpp"
+#define I2C_CLASS I2CBB
+#else
+#define I2C_CLASS FRToSI2C
+#include "I2C_Wrapper.hpp"
+#endif
+
 #define DEVICEADDR_OLED   (0x3c << 1)
 #define OLED_WIDTH        96
 #define OLED_HEIGHT       16
@@ -40,7 +50,7 @@ public:
   static bool isInitDone();
   // Draw the buffer out to the LCD using the DMA Channel
   static void refresh() {
-    FRToSI2C::Transmit(DEVICEADDR_OLED, screenBuffer, FRAMEBUFFER_START + (OLED_WIDTH * 2));
+	  I2C_CLASS::Transmit(DEVICEADDR_OLED, screenBuffer, FRAMEBUFFER_START + (OLED_WIDTH * 2));
     // DMA tx time is ~ 20mS Ensure after calling this you delay for at least 25ms
     // or we need to goto double buffering
   }