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

Add FlipDisplay, Fahrenheit, Better Font

Browse Source
This commit is contained in:
Ben V. Brown
2016-10-03 19:01:57 +11:00
parent acb97f1d46
commit 0bbdda5b55
9 changed files with 310 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
workspace/ts100/src/I2C.c
View File

@@ -22,7 +22,7 @@ void I2C_Configuration(void) {
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = 100000; //100k
I2C_InitStructure.I2C_ClockSpeed = 400000; //400k
I2C_Init(I2C1, &I2C_InitStructure);
I2C_Cmd(I2C1, ENABLE);
}

43
workspace/ts100/src/Main.c
View File

@@ -12,30 +12,31 @@
void setup();
int main(void) {
setup();
setup();/*Setup the system*/
while (1) {
Clear_Watchdog(); //reset the Watchdog
Clear_Watchdog(); //reset the Watchdog timer
ProcessUI();
DrawUI();
delayMs(50);
delayMs(50); //Slow the system down a little bit
}
}
void setup()
{
RCC_Config(); //setup system clock
NVIC_Config(0x4000); //this shifts the NVIC table to be offset, for the usb bootloader's size
GPIO_Config(); //setup all the GPIO pins
Init_EXTI(); //init the EXTI inputs
Init_Timer3(); //Used for the soldering iron tip
Adc_Init(); //init adc and dma
I2C_Configuration(); //Start the I2C hardware
GPIO_Init_OLED(); //Init the GPIO ports for the OLED
StartUp_Accelerometer(); //start the accelerometer
Init_Oled(); //init the OLED display
Clear_Screen(); //clear the display buffer to black
setupPID(); //init the PID values
readIronTemp(239, 0); //load the default calibration value
restoreSettings(); //Load settings
Start_Watchdog(1000); //start the system watchdog as 1 seconds timeout
void setup() {
RCC_Config(); //setup system clock
NVIC_Config(0x4000); //this shifts the NVIC table to be offset, for the usb bootloader's size
GPIO_Config(); //setup all the GPIO pins
Init_EXTI(); //init the EXTI inputs
Init_Timer3(); //Used for the soldering iron tip
Adc_Init(); //init adc and dma
I2C_Configuration(); //Start the I2C hardware
GPIO_Init_OLED(); //Init the GPIO ports for the OLED
StartUp_Accelerometer(); //start the accelerometer
Init_Oled(); //init the OLED display
setupPID(); //init the PID values
readIronTemp(239, 0); //load the default calibration value
restoreSettings(); //Load settings
if (systemSettings.flipDisplay)
Oled_DisplayFlip();
OLED_DrawString("VER 1.01",8);
delayMs(800);
Start_Watchdog(1000); //start the system watchdog as 1 seconds timeout
}

124
workspace/ts100/src/Modes.c
View File

@@ -63,7 +63,7 @@ void ProcessUI() {
//If no buttons pushed we need to perform the PID loop for the iron temp
int32_t newOutput = computePID(systemSettings.SolderingTemp);
setIronTimer(newOutput);
setIronTimer(newOutput);
}
break;
@@ -81,37 +81,37 @@ void ProcessUI() {
} else {
//we check the timeout for how long the buttons have not been pushed
//if idle for > 3 seconds then we return to soldering
if (millis() - getLastButtonPress() > 3000)
if (millis() - getLastButtonPress() > 3000) {
operatingMode = SOLDERING;
saveSettings();
}
}
break;
case SETTINGS:
//Settings is the mode with the most logic
//Here we are in the menu so we need to increment through the sub menus / increase the value
if (millis() - getLastButtonPress() < 400)
if (millis() - getLastButtonPress() < 300)
return;
if (Buttons & BUT_A) {
resetLastButtonPress();
//A key iterates through the menu
if (settingsPage == 3) {
if (settingsPage == SETTINGSOPTIONSCOUNT) {
//Roll off the end
settingsPage = 0; //reset
operatingMode = STARTUP;
saveSettings(); //Save the settings
settingsPage = 0; //reset
operatingMode = STARTUP; //reset back to the startup
saveSettings(); //Save the settings
} else
++settingsPage; //move to the next option
++settingsPage; //move to the next option
} else if (Buttons & BUT_B) {
resetLastButtonPress();
//B changes the value selected
switch (settingsPage) {
case UVLO:
case UVCO:
//we are incrementing the cutout voltage
systemSettings.cutoutVoltage += 1; //Go up 1V at a jump
if (systemSettings.cutoutVoltage > 24)
systemSettings.cutoutVoltage = 9;
else if (systemSettings.cutoutVoltage < 9)
systemSettings.cutoutVoltage = 9; //cant set UVLO below 9V
systemSettings.cutoutVoltage = 10;
break;
case SLEEP_TEMP:
systemSettings.SleepTemp += 100; //Go up 10c at a time
@@ -120,14 +120,20 @@ void ProcessUI() {
break;
case SLEEP_TIME:
++systemSettings.SleepTime; //Go up 1 minute at a time
if (systemSettings.SleepTime > 60)
systemSettings.SleepTime = 2; //cant set time over an hour
if (systemSettings.SleepTime > 30)
systemSettings.SleepTime = 1; //cant set time over 30 mins
//Remember that ^ is the time of no movement
break;
case MOTIONDETECT:
systemSettings.movementEnabled =
!systemSettings.movementEnabled;
break;
case TEMPDISPLAY:
systemSettings.displayTempInF = !systemSettings.displayTempInF;
break;
case LEFTY:
systemSettings.flipDisplay = !systemSettings.flipDisplay;
break;
default:
break;
}
@@ -155,7 +161,7 @@ void ProcessUI() {
//else if nothing has been pushed we need to compute the PID to keep the iron at the sleep temp
int32_t newOutput = computePID(systemSettings.SleepTemp);
setIronTimer(newOutput);
setIronTimer(newOutput);
break;
case COOLING: {
@@ -190,9 +196,20 @@ void ProcessUI() {
break;
}
}
/*
* Draws the temp with temp conversion if needed
*/
void drawTemp(uint16_t temp, uint8_t x) {
if (systemSettings.displayTempInF)
temp = (temp * 9 + 1600) / 5;/*Convert to F -> T*(9/5)+32*/
OLED_DrawThreeNumber(temp / 10, x);
}
/*
* Performs all the OLED drawing for the current operating mode
*/
void DrawUI() {
uint16_t temp = readIronTemp(0, 0) / 10;
uint16_t temp = readIronTemp(0, 0);
switch (operatingMode) {
case STARTUP:
//We are chilling in the idle mode
@@ -203,60 +220,77 @@ void DrawUI() {
Oled_DisplayOff();
} else {
Oled_DisplayOn();
OLED_DrawString("IDLE ", 7); //write the word IDLE
OLED_DrawString(" IDLE ", 8); //write the word IDLE
}
break;
case SOLDERING:
//The user is soldering
{
if (getIronTimer() == 0) {
OLED_DrawChar('C', 14 * 4);
OLED_DrawChar('C', 5);
} else {
if (getIronTimer() < 500) {
OLED_DrawChar(' ', 14 * 4);
OLED_DrawChar(' ', 5);
} else { //we are heating
OLED_DrawChar('H', 14 * 4);
OLED_DrawChar('H', 5);
}
}
OLED_DrawThreeNumber(temp, 0);
OLED_DrawChar(' ', 14 * 3);
OLED_DrawChar(' ', 14 * 5);
OLED_DrawChar(' ', 14 * 6);
drawTemp(temp, 0);
OLED_DrawChar(' ', 3);
OLED_DrawChar(' ', 4);
OLED_DrawChar(' ', 6);
OLED_DrawChar(' ', 7);
}
break;
case TEMP_ADJ:
//We are prompting the user to change the temp so we draw the current setpoint temp
//With the nifty arrows
OLED_DrawChar('<', 0);
OLED_DrawThreeNumber(systemSettings.SolderingTemp / 10, 14 * 1);
OLED_DrawChar(' ', 14 * 4);
OLED_DrawChar('>', 14 * 5);
OLED_DrawChar(' ', 0);
OLED_DrawChar('<', 1);
drawTemp(systemSettings.SolderingTemp, 2);
OLED_DrawChar(' ', 5);
OLED_DrawChar(' ', 6);
OLED_DrawChar('>', 7);
break;
case SETTINGS:
//We are prompting the user the setting name
switch (settingsPage) {
case UVLO:
OLED_DrawString("UVLO", 4);
OLED_DrawTwoNumber(systemSettings.cutoutVoltage, 14 * 4);
//OLED_DrawChar('V', 14 * 5);
case UVCO:
OLED_DrawString("UVCO ", 5);
OLED_DrawTwoNumber(systemSettings.cutoutVoltage, 5);
OLED_DrawChar('V', 7);
break;
case SLEEP_TEMP:
OLED_DrawString("STMP", 4);
OLED_DrawThreeNumber(systemSettings.SleepTemp / 10, 14 * 4);
//OLED_DrawChar('V', 14 * 5);
OLED_DrawString("STMP ", 5);
OLED_DrawThreeNumber(systemSettings.SleepTemp / 10, 5);
break;
case SLEEP_TIME:
OLED_DrawString("STME ", 5);
OLED_DrawTwoNumber(systemSettings.SleepTime, 14 * 5);
OLED_DrawString("STIME ", 6);
OLED_DrawTwoNumber(systemSettings.SleepTime, 6);
break;
case MOTIONDETECT:/*Toggle the mode*/
if (systemSettings.movementEnabled)
OLED_DrawString("MOTN T", 7);
OLED_DrawString("MOTION T", 8);
else
OLED_DrawString("MOTN F", 7);
OLED_DrawString("MOTION F", 8);
break;
case TEMPDISPLAY:/*Are we showing in C or F ?*/
if (systemSettings.displayTempInF)
OLED_DrawString("TMPUNT F", 8);
else
OLED_DrawString("TMPUNT C", 8);
break;
case LEFTY:
if (systemSettings.flipDisplay)
OLED_DrawString("FLPDSP T", 8);
else
OLED_DrawString("FLPDSP F", 8);
break;
default:
break;
@@ -266,15 +300,15 @@ void DrawUI() {
//The iron is in sleep temp mode
//Draw in temp and sleep
OLED_DrawString("SLP", 3);
OLED_DrawThreeNumber(temp, 14 * 3);
drawTemp(temp, 3);
break;
case COOLING:
//We are warning the user the tip is cooling
OLED_DrawString("COL", 3);
OLED_DrawThreeNumber(temp, 14 * 3);
OLED_DrawString("COOL", 3);
drawTemp(temp, 4);
break;
case UVLOWARN:
OLED_DrawString("UND VL", 6);
OLED_DrawString("LOW VOLT", 8);
break;
default:
break;

145
workspace/ts100/src/Oled.c
View File

@@ -13,38 +13,70 @@
#include "I2C.h"
#include "Font.h"
u8 displayOffset = 32;
/*Setup params for the OLED screen*/
u8 OLED_Setup_Array[46] = { 0x80, 0xAE, 0x80, 0xD5, 0x80, 0x52, 0x80, 0xA8,
0x80, 0x0f, 0x80, 0xC0, 0x80, 0xD3, 0x80, 0x00, 0x80, 0x40, 0x80, 0xA0,
0x80, 0x8D, 0x80, 0x14, 0x80, 0xDA, 0x80, 0x02, 0x80, 0x81, 0x80, 0x33,
0x80, 0xD9, 0x80, 0xF1, 0x80, 0xDB, 0x80, 0x30, 0x80, 0xA4, 0x80, 0XA6,
0x80, 0xAF };
/*http://www.displayfuture.com/Display/datasheet/controller/SSD1307.pdf*/
/*All commands are prefixed with 0x80*/
u8 OLED_Setup_Array[46] = { 0x80, 0xAE,/*Display off*/
0x80, 0xD5,/*Set display clock divide ratio / osc freq*/
0x80, 0b01010001,/**/
0x80, 0xA8,/*Set Multiplex Ratio*/
0x80, 16, /*16 == max brightness,39==dimmest*/
0x80, 0xC0,/*Set COM Scan direction*/
0x80, 0xD3,/*Set Display offset*/
0x80, 0x00,/*0 Offset*/
0x80, 0x40,/*Set Display start line to 0*/
0x80, 0xA0,/*Set Segment remap to normal*/
0x80, 0x8D,/*Unknown*/
0x80, 0x14,/**/
0x80, 0xDA,/*Set VCOM Pins hardware config*/
0x80, 0x02,/*Combination 2*/
0x80, 0x81,/*Contrast*/
0x80, 0x33,/*51*/
0x80, 0xD9,/*Set pre-charge period*/
0x80, 0xF1,/**/
0x80, 0xDB,/*Adjust VCOMH regulator ouput*/
0x80, 0x30,/**/
0x80, 0xA4,/*Enable the display GDDR*/
0x80, 0XA6,/*Normal display*/
0x80, 0xAF /*Dispaly on*/
};
/*******************************************************************************
/*
Function: Oled_DisplayOn
Description:Turn on the Oled display
*******************************************************************************/
*/
void Oled_DisplayOn(void) {
u8 data[6] = { 0x80, 0X8D, 0x80, 0X14, 0x80, 0XAF };
I2C_PageWrite(data, 6, DEVICEADDR_OLED);
}
/*******************************************************************************
/*
Function: Oled_DisplayOff
Description:Turn off the Oled display
*******************************************************************************/
*/
void Oled_DisplayOff(void) {
u8 data[6] = { 0x80, 0X8D, 0x80, 0X10, 0x80, 0XAE };
I2C_PageWrite(data, 6, DEVICEADDR_OLED);
}
/*
* This sets the OLED screen to invert the screen (flip it vertically)
* This is used if the unit is set to left hand mode
*/
void Oled_DisplayFlip() {
u8 data[2] = { 0x80, 0XC8 };
I2C_PageWrite(data, 2, DEVICEADDR_OLED);
data[1] = 0xA1;
I2C_PageWrite(data, 2, DEVICEADDR_OLED);
displayOffset=0;
/*******************************************************************************
Function: Data_Command
}
/*
Description: write a command to the Oled display
Input: number of bytes to write, array to write
Output:
*******************************************************************************/
*/
u8* Data_Command(u8 length, u8* data) {
int i;
u8 tx_data[128];
@@ -62,8 +94,9 @@ u8* Data_Command(u8 length, u8* data) {
Input:x,y co-ordinates
*******************************************************************************/
void Set_ShowPos(u8 x, u8 y) {
u8 pos_param[8] = { 0x80, 0xB0, 0x80, 0x21, 0x80, 0x20, 0x80, 0x7F };
pos_param[5] = x + 32;
u8 pos_param[8] = { 0x80, 0xB0, 0x80, 0x21, 0x80, 0x00, 0x80, 0x7F };
//page 0, start add = x(below) through to 0x7F (aka 127)
pos_param[5] = x + displayOffset;/*Display offset ==0 for Lefty, == 32 fo righty*/
pos_param[1] += y;
I2C_PageWrite(pos_param, 8, DEVICEADDR_OLED);
}
@@ -133,51 +166,67 @@ void Clear_Screen(void) {
Oled_DrawArea(0, i * 8, 128, 8, tx_data);
}
}
/*
* Draws a string onto the screen starting at the left
*/
void OLED_DrawString(char* string, uint8_t length) {
for (uint8_t i = 0; i < length; i++) {
OLED_DrawChar(string[i], i * 14);
OLED_DrawChar(string[i], i);
}
}
void OLED_DrawChar(char c, uint8_t x) {
if ((x) > (128 - 14))
return; //Rudimentary clipping to not draw off screen
u8* ptr;
ptr = (u8*) FONT;
if (c >= 'A' && c <= 'Z') {
ptr += (c - 'A' + 10) * (14 * 2); //alpha is ofset 10 chars into the array
} else if (c >= '0' && c <= '9')
ptr += (c - '0') * (14 * 2);
else if (c < 10)
ptr += (c) * (14 * 2);
else if (c == ' ') {
//blank on space bar
ptr += (36) * (14 * 2);
} else if (c == '<') {
ptr += (37) * (14 * 2);
} else if (c == '>') {
ptr += (38) * (14 * 2);
}
Oled_DrawArea(x, 0, 14, 16, (u8*) ptr);
}
/*
* Draw a 2 digit number to the display
* */
void OLED_DrawTwoNumber(uint8_t in, uint8_t x) {
OLED_DrawChar((in / 10) % 10, x);
OLED_DrawChar(in % 10, x + 14);
* Draw a char onscreen at letter index x
*/
void OLED_DrawChar(char c, uint8_t x) {
if (x > 7)
return; //clipping
x *= FONT_WIDTH; //convert to a x coordinate
u8* ptr = (u8*) FONT;
if (c >= 'A' && c <= 'Z') {
ptr += (c - 'A' + 10) * (FONT_WIDTH * 2); //alpha is ofset 10 chars into the array
} else if (c >= '0' && c <= '9')
ptr += (c - '0') * (FONT_WIDTH * 2);
else if (c < 10)
ptr += (c) * (FONT_WIDTH * 2);
else if (c == ' ') {
//blank on space bar
ptr += (36) * (FONT_WIDTH * 2);
} else if (c == '<') {
ptr += (37) * (FONT_WIDTH * 2);
} else if (c == '>') {
ptr += (38) * (FONT_WIDTH * 2);
}else if (c=='.')
{
ptr += (39) * (FONT_WIDTH * 2);
}
Oled_DrawArea(x, 0, FONT_WIDTH, 16, (u8*) ptr);
}
/*
* Draw a 2 digit number to the display at letter slot x
*/
void OLED_DrawTwoNumber(uint8_t in, uint8_t x) {
OLED_DrawChar((in / 10) % 10, x);
OLED_DrawChar(in % 10, x + 1);
}
/*
* Draw a 3 digit number to the display at letter slot x
*/
void OLED_DrawThreeNumber(uint16_t in, uint8_t x) {
OLED_DrawChar((in / 100) % 10, x);
OLED_DrawChar((in / 10) % 10, x + 14);
OLED_DrawChar(in % 10, x + 28);
OLED_DrawChar((in / 10) % 10, x + 1);
OLED_DrawChar(in % 10, x + 2);
}
/*
* Draw a 4 digit number to the display at letter slot x
*/
void OLED_DrawFourNumber(uint16_t in, uint8_t x) {
OLED_DrawChar((in / 1000) % 10, x);
OLED_DrawChar((in / 100) % 10, x + 14);
OLED_DrawChar((in / 10) % 10, x + 28);
OLED_DrawChar(in % 10, x + 42);
OLED_DrawChar((in / 100) % 10, x + 1);
OLED_DrawChar((in / 10) % 10, x + 2);
OLED_DrawChar(in % 10, x + 3);
}

23
workspace/ts100/src/Settings.c
View File

@@ -8,9 +8,9 @@
*/
#include "Settings.h"
#define FLASH_ADDR (0x8000000|48896)
#define FLASH_ADDR (0x8000000|48896)/*Flash start OR'ed with the maximum amount of flash - 256 bytes*/
void saveSettings() {
//First we erase the flash
//First we erase the flash
FLASH_Unlock(); //unlock flash writing
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
while (FLASH_ErasePage(FLASH_ADDR) != FLASH_COMPLETE)
@@ -26,9 +26,8 @@ void saveSettings() {
void restoreSettings() {
//We read the flash
uint16_t *data = (uint16_t*) &systemSettings;
for(uint8_t i=0;i<(sizeof(systemSettings)/2);i++)
{
data[i] = *(uint16_t *)(FLASH_ADDR + (i*2));
for (uint8_t i = 0; i < (sizeof(systemSettings) / 2); i++) {
data[i] = *(uint16_t *) (FLASH_ADDR + (i * 2));
}
//if the version is correct were done
//if not we reset and save
@@ -42,11 +41,13 @@ void restoreSettings() {
void resetSettings() {
systemSettings.SleepTemp = 900;
systemSettings.SleepTime = 1;
systemSettings.SolderingTemp = 3200;
systemSettings.movementEnabled = 1; //we use movement detection
systemSettings.cutoutVoltage = 9;
systemSettings.version=SETTINGSVERSION;
systemSettings.SleepTemp = 1500; //Temperature the iron sleeps at - default 150.0 C
systemSettings.SleepTime = 1; //How many minutes we wait until going to sleep - default 1 min
systemSettings.SolderingTemp = 3200; //Default soldering temp is 320.0 C
systemSettings.movementEnabled = 1; //we use movement detection by default
systemSettings.cutoutVoltage = 10; //10V is the minium cutout voltage as the unit V measurement is unstable below 9.5V
systemSettings.version = SETTINGSVERSION; //Store the version number to allow for easier upgrades
systemSettings.displayTempInF =0; //default to C
systemSettings.flipDisplay=0; //Default to right handed mode
}