Increase pre PID filtering, reducing display flicker

Also improve movement sensitivities to be less extreme ramp up

README.md

@@ -1,35 +1,33 @@
 # TS100
-This is a complete open source re-write of the software for the ts100 soldering iron.
+This is a complete re-write of the open source software for the ts100 soldering iron.
 This project is feature complete for use as a soldering iron, but is still open to ideas and suggestions.
 
-
 This project was started to remove the need for USB for changing system settings.
 In the latest official firmware they have also added a settings menu system, so it is still worth comparing the two firmwares to select your preferred option.
 
-## Features Working
+## Features
 * Soldering / Temperature control
 * Full PID iron temperature control
-* Adjusting temperature
-* Automatic sleep
+* Automatic sleep with selectable sensitivity
 * Motion wake support
 * Settings menu
-* Input voltage UVLO measurement
-* Saving settings to flash for persistence
-* Improved GUI Fonts
-* Use hardware I2C for communications
+* Input voltage UVLO measurement for battery powered use
+* All settings saved
+* Improved readability Fonts
+* Use hardware features to improve reliability
 * Can disable movement detection if desired
+* Calibration of the temperature offset
 
 # Upgrading your ts100 iron
 This is completely safe, if it goes wrong just put the .hex file from the official website onto the unit and your back to the old firmware. Downloads for the hex files to flash are available on the [releases page.](https://github.com/Ralim/ts100/releases)
-**You will need a windows computer (7,8,10 tested), using the normal windows explorer to load the firmware.
-The bootloader does not appear to work under mac or linux at the moment.**
+Officially the bootloader on the iron only works under windows. However, users have reported that it does work under Mac, and can be made to work under Linux. Details over on the [wiki page](https://github.com/Ralim/ts100/wiki/Upgrading-Firmware).
 
 1. Hold the button closest to the tip, and plug in the USB to the computer.
 2. The unit will appear as a USB drive.
 3. Drag the .hex file onto the USB drive.
 4. The unit will disconnect and reconnect.
-5. The filename will have changed to end in .RDY or .ERR .
-6. If it ends with .RDY your done! Otherwise something went wrong.
+5. The filename will have changed to end in .RDY or .ERR 
+6. If it ends with .RDY you're done! Otherwise something went wrong.
 7. Disconnect the USB and power up the iron. You're good to go.
 
 For the more adventurerous out there, you can also load this firmware onto the device using a SWD programmer.
@@ -38,11 +36,69 @@ There is a complete device flash backup included in this repository. (Note this
 
 # New Menu System
 This new firmware uses a new menu system to allow access to the settings on the device.
-This menu can be accessed as shown in following flow chart, in the settings numbers roll over from top to bottom.
-![TS100: Software Menu](TS100.png "Fairly easy to learn")
+When on the main screen, the unit shows prompts for the two most common operations.
+-> Pressing the button near the tip enters soldering mode
+-> Pressing the button near the power input enters the settings menu.
+-> Pressing both buttons together enters the Extras menu
+## Soldering mode
+In this mode the iron works as you would expect, pressing either button will take you to a temperature change screen. Use each button to go up and down in temperature. Pressing both buttons will exit you from the temperature menu (or wait 3 seconds and it will time out).
+Pressing both buttons will also exit the soldering mode.
 
+## Settings Menu
+This menu allows you to cycle through all the options and set their values.
+The button near the tip cycles through the options, and the one near the usb changes the selected option.
+Note that settings are not saved until you exit the menu, and some settings such as screen flip do not apply until a power cycle is applied.
+If you leave the unit alone (ie don't press any buttons) on a setting, after 3 seconds the screen will scroll a longer version of the name
+
+* UVCO -> Undervoltage cut out level, settable in 1V increments from 10-24V
+* STMP -> The temperature the unit drops to in sleep mode
+* SLTME -> Sleep time, how long it takes before the unit goes to sleep
+* SHTME -> Shutdown Time, how long the unit will wait after movement before shutting down completely
+* MOTION -> Wether motion detection is enabled or not
+* SENSE -> Motion Sensitivity, H is more sensitive. L is lowest sensitivity (ie takes more movement to trigger)
+* TMPUNIT -> Temperature unit, C or F
+* TMPRND -> Temperature Rounding, {1,5,10}
+* TMPSPD -> How fast the temperature should update in the soldering status screen.
+* FLPDSP -> Flip display for left handed users
+
+Temperature rounding means that the unit will round off the temperature before displaying. This can helpt to reduce the flickering of the temperature when the unit oscillates between two temperatures.
+## Extras Menu
+This menu defaults to showing the current temperature on the tip. 
+Pressing the button near the iron tip will show the current input voltage. Pressing the other button while this is show will allow you to calibrate the reading if your iron is like mine and is not overly accurate out of the factory. (Press buttons to change measurement up and down, press both to exit and save). 
+
+Pressing the button near the usb enters the temperature offset setting menu, when the iron is cold, pressing the other button will start the unit calibrating for any offset in the tip temperature.
 
 # Version Changes:
+V1.10
+-Adds help text to settings
+- Improves settings for the display update rate
+
+V1.09
+- Adds display modes, for slowing down or simplifying the display
+
+V1.08
+- Fix settings menu not showing flip display
+
+V1.07
+- Adds shutdown time to automatically shutdown the iron after inactivity
+
+V1.06
+- Changes H and C when the iron is heating to the minidso chevron like images
+
+V1.05
+- Adds ability to calibrate the input voltage measurement
+
+V1.04
+- Increased accuracy of the temperature control
+- Improved PID response slightly
+- Allows temperature offset calibration
+- Nicer idle screen
+
+V1.03 
+- Improved Button handling
+- Ability to set motion sensitivity
+- DC voltmeter page shows input voltage
+
 V1.02
-	- Adds hold both buttons on IDLE to access the therometer mode.
-	- Changes the exit soldering mode to be holding both buttons (Like original firmware).
+- Adds hold both buttons on IDLE to access the therometer mode.
+- Changes the exit soldering mode to be holding both buttons (Like original firmware).

workspace/ts100/inc/Analog.h

@@ -16,5 +16,5 @@ extern volatile uint16_t ADC1ConvertedValue[2];
 
 uint16_t Get_ADC1Value(uint8_t i);
 uint16_t readIronTemp(uint16_t calibration_temp, uint8_t read,uint16_t setPointTemp); //read the iron temp in C X10
-uint16_t readDCVoltage();/*Get the system voltage X10*/
+uint16_t readDCVoltage(uint16_t divFactor);/*Get the system voltage X10*/
 #endif /* ANALOG_H_ */

workspace/ts100/inc/Font.h

@@ -163,4 +163,30 @@ const uint8_t Iron_RightArrow_DOWN[] = {
 		0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 };
 
+const uint8_t SymbolTable[]={
+
+		0x0E,0x11,0x11,0x0E,0xE0,0xF8,0x0C,0x06,0x03,0x01,0x01,0x01,0x01,0x02,0x1E,0x00,
+		0x00,0x00,0x00,0x00,0x0F,0x3F,0x70,0xC0,0x80,0x80,0x80,0x80,0x80,0x40,0x20,0x00,	// Degrees C
+
+		0x08,0x14,0x22,0x14,0x08,0x02,0x02,0xFE,0x06,0x02,0x02,0x02,0xC2,0x02,0x06,0x1E,
+		0x00,0x00,0x00,0x00,0x00,0x80,0x80,0xFF,0x81,0x81,0x01,0x01,0x03,0x00,0x00,0x00,	// Degrees F
+
+		0xC0,0x30,0x08,0x04,0x04,0x02,0xFA,0xAA,0xFA,0x02,0x04,0x04,0x08,0x30,0xC0,0x00,
+	 	0x07,0x18,0x20,0x40,0x58,0xA4,0xDB,0xDE,0xDB,0xA4,0x58,0x40,0x20,0x18,0x07,0x00, 	// Temp symbol
+
+		0x00,0xF0,0xF0,0x00,0x00,0xF0,0xF0,0xF0,0x00,0x00,0xFC,0xF8,0xF0,0xE0,0xC0,0x80, 	//Right Arrow
+		0x00,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x0F,0x00,0x00,0x3F,0x1F,0x0F,0x07,0x03,0x01,
+
+		0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0x00,0x00,0xF0,0xF0,0xF0,0x00,0x00,0xF0,0xF0,0x00,	//Left Arrow
+		0x01,0x03,0x07,0x0F,0x1F,0x3F,0x00,0x00,0x0F,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,
+
+		0x11,0x33,0x66,0xCC,0x98,0x30,0x60,0xC0,0xC0,0x60,0x30,0x98,0xCC,0x66,0x33,0x11,
+		0x01,0x03,0x06,0x0C,0x19,0x33,0x66,0xCC,0xCC,0x66,0x33,0x19,0x0C,0x06,0x03,0x01,	//Down Chevron
+
+		0x80,0xC0,0x60,0x30,0x98,0xCC,0x66,0x33,0x33,0x66,0xCC,0x98,0x30,0x60,0xC0,0x80,
+		0x88,0xCC,0x66,0x33,0x19,0x0C,0x06,0x03,0x03,0x06,0x0C,0x19,0x33,0x66,0xCC,0x88,	//Up Chevron
+
+		0x00,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C,0x00, 	// Flat Lines
+		0x00,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x00,
+};
 #endif /* FONT_H_ */

workspace/ts100/inc/Modes.h

@@ -17,25 +17,30 @@
 #include "Settings.h"
 #include "Analog.h"
 enum {
-	STARTUP, //we are sitting on the prompt to push a button
-	SOLDERING,
-	TEMP_ADJ,
-	SETTINGS,
-	SLEEP,
-	COOLING,
-	UVLOWARN,
-	THERMOMETER,
-	DCINDISP,
-	TEMPCAL,
+	STARTUP, 		//we are sitting on the prompt to push a button
+	SOLDERING, 		//Normal operating mode
+	TEMP_ADJ,		//Adjust the set temperature
+	SETTINGS,		//Settings menu
+	SLEEP,			//Iron is snoozing due to lack of use
+	COOLING,		//Iron is cooling down -> Warning screen
+	UVLOWARN,		//Unit tripped low voltage
+	THERMOMETER,	//Read the tip temp
+	DCINDISP,		//Disp the input voltage && Cal the DCin voltage divider
+	TEMPCAL,		//Cal tip temp offset
+
 } operatingMode;
+#define SETTINGSOPTIONSCOUNT 9 /*Number of settings in the settings menu*/
 
 enum {
 	UVCO = 0,
 	SLEEP_TEMP,
 	SLEEP_TIME,
+	SHUTDOWN_TIME,
 	MOTIONDETECT,
 	MOTIONSENSITIVITY,
 	TEMPDISPLAY,
+	TEMPROUNDING,
+	DISPUPDATERATE,
 	LEFTY,
 } settingsPage;
 

workspace/ts100/inc/Oled.h

@@ -25,7 +25,9 @@ void Clear_Screen(void);//Clear the screen
 void OLED_DrawString(char* string, uint8_t length);
 void OLED_DrawChar(char c, uint8_t x);
 void OLED_DrawTwoNumber(uint8_t in, uint8_t x);
+void OLED_BlankSlot(uint8_t xStart,uint8_t width);
 void OLED_DrawThreeNumber(uint16_t in, uint8_t x);
 void OLED_DrawIDLELogo();
+void OLED_DrawSymbol(uint8_t x,uint8_t symbol);
 #endif
 /******************************** END OF FILE *********************************/

workspace/ts100/inc/Settings.h

@@ -11,25 +11,39 @@
 #define SETTINGS_H_
 #include <stdint.h>
 #include "stm32f10x_flash.h"
-#define SETTINGSVERSION 0x03 /*Change this if you change the struct below to prevent people getting out of sync*/
-#define SETTINGSOPTIONSCOUNT 6 /*Number of settings in the settings menu*/
-#define MOTION_HIGH (0x00)
-#define MOTION_MED  (0x10)
-#define MOTION_LOW  (0x20)
+#define SETTINGSVERSION 0x08 /*Change this if you change the struct below to prevent people getting out of sync*/
+//Motion Sensitivity
+#define MOTION_HIGH 		(0x00)
+#define MOTION_MED  		(0x01)
+#define MOTION_LOW  		(0x02)
+//Display Speeds
+#define DISPLAYMODE_FAST 	(0x00)
+#define DISPLAYMODE_MEDIUM 	(0x01)
+#define DISPLAYMODE_SLOW	(0x02)
+//Rounding Modes
+#define ROUNDING_NONE			(0x00)
+#define ROUNDING_FIVE			(0x01)
+#define ROUNDING_TEN			(0x02)
+
+
 /*
  * This struct must be a multiple of 2 bytes as it is saved / restored from flash in uint16_t chunks
  */
 struct {
-	uint32_t SolderingTemp; 		//current setpoint for the iron
+	uint32_t SolderingTemp; 		//current set point for the iron
 	uint32_t SleepTemp; 			//temp to drop to in sleep
 	uint8_t version;				//Used to track if a reset is needed on firmware upgrade
 	uint8_t SleepTime; 				//minutes timeout to sleep
-	uint8_t cutoutVoltage:5; 		//The voltage we cutout at for undervoltage
+	uint8_t cutoutVoltage:5; 		//The voltage we cut out at for under voltage
 	uint8_t movementEnabled:1;		//If movement is enabled
 	uint8_t displayTempInF:1;		//If we need to convert the C reading to F
 	uint8_t flipDisplay:1;			//If true we want to invert the display for lefties
-	uint8_t sensitivity:7;			//Sensitivity of accelerometer
+	uint8_t sensitivity:6;			//Sensitivity of accelerometer
+	uint8_t ShutdownTime:6;			//Time until unit shuts down if left alone
+	uint8_t displayUpdateSpeed:2;	//How fast the display updates / temp showing mode
+	uint8_t temperatureRounding:2;	//Rounding mode for the temperature
 	uint16_t tempCalibration;		//Temperature calibration value
+	uint16_t voltageDiv;			//Voltage divisor factor
 } systemSettings;
 
 void saveSettings();

workspace/ts100/src/Analog.c

@@ -10,12 +10,12 @@
 
 //Reads the dc input and returns it as X10 voltage (ie 236 = 23.6V)
 //Seems unstable below 9.5V input
-uint16_t readDCVoltage() {
+uint16_t readDCVoltage(uint16_t divFactor) {
 	uint16_t reading = 0;
 	for (u8 i = 0; i < 10; i++) {
 		reading += ADC_GetConversionValue(ADC2);
 	}
-	reading /= 144; //take the average and convert to X10 voltage
+	reading /= divFactor; //take the average and convert to X10 voltage
 	return reading; //return the read voltage
 }
 
@@ -23,7 +23,7 @@ uint16_t readDCVoltage() {
 //This allows us to read it in X10 mode
 //Returns temperature in C X10 mode
 int16_t readTipTemp() {
-	static uint32_t rollingAverage[4];
+	static uint32_t rollingAverage[16];
 	static uint8_t rIndex = 0;
 
 	/*The head has a thermocouple inline with the heater
@@ -54,9 +54,13 @@ int16_t readTipTemp() {
 	ad_sum = ad_sum - max - min; //remove the two outliers
 	avg_data = ad_sum / 8; //take the average
 	rollingAverage[rIndex] = avg_data;
-	rIndex = (rIndex + 1) % 4;
+	rIndex = (rIndex + 1) % 16;
 	return (rollingAverage[0] + rollingAverage[1] + rollingAverage[2]
-			+ rollingAverage[3]) / 4; //get the average
+			+ rollingAverage[3] + rollingAverage[4] + rollingAverage[5]
+			+ rollingAverage[6] + rollingAverage[7] + rollingAverage[8]
+			+ rollingAverage[9] + rollingAverage[10] + rollingAverage[11]
+			+ rollingAverage[12] + rollingAverage[13] + rollingAverage[14]
+			+ rollingAverage[15]) / 16; //get the average
 
 }
 
@@ -110,7 +114,7 @@ uint16_t readIronTemp(uint16_t calibration_temp, uint8_t read,
 	static uint16_t calTemp = 0;
 	static uint16_t lastVal = 0;
 	static uint16_t lastSetTemp;
-	if(setPointTemp!=0xFFFF)
+	if (setPointTemp != 0xFFFF)
 		lastSetTemp = setPointTemp;
 	if (calibration_temp != 0)
 		calTemp = calibration_temp;

workspace/ts100/src/MMA8652FC.c

@@ -34,7 +34,20 @@ void StartUp_Accelerometer(uint8_t sensitivity) {
 	I2C_RegisterWrite( CTRL_REG2, 0x40);	// Reset all registers to POR values
 	delayMs(2);		// ~1ms delay
 	I2C_RegisterWrite(FF_MT_CFG_REG, 0x78);	// Enable motion detection for X and Y axis, latch enabled
-	I2C_RegisterWrite(FF_MT_THS_REG, sensitivity|0x0F);		// Set threshold
+	uint8_t sens =0x0F;
+	switch(sensitivity)
+	{
+	case 0:
+		sens=0x1A;
+		break;
+	case 1:
+		sens=0x20;
+		break;
+	case 2:
+		sens=0x2A;
+		break;
+	}
+	I2C_RegisterWrite(FF_MT_THS_REG, sens);		// Set threshold
 	I2C_RegisterWrite(FF_MT_COUNT_REG, 0x01);	// Set debounce to 100ms
 
 	I2C_RegisterWrite( CTRL_REG4, 0x04);		// Enable motion interrupt

workspace/ts100/src/Main.c

@@ -37,7 +37,7 @@ void setup() {
 	readIronTemp(systemSettings.tempCalibration, 0,0); 	//load the default calibration value
 	Init_Oled(systemSettings.flipDisplay); 				//Init the OLED display
 
-	OLED_DrawString("VER 1.04", 8); 					//
-	delayMs(800);										//Pause to show version number
+	OLED_DrawString("VER 1.10", 8); 					//Version Number
+	delayMs(500);										//Pause to show version number
 	Start_Watchdog(1000); 								//start the system watch dog as 1 second timeout
 }

workspace/ts100/src/Modes.c

@@ -5,7 +5,16 @@
  *      Author: Ralim <ralim@ralimtek.com>
  */
 #include "Modes.h"
-uint8_t tempCalStatus = 0;
+const char *SettingsLongNames[] = { "      Undervoltage Cutout (V)",
+		"      Sleep Temperature (C)", "      Sleep Timeout (Minutes)",
+		"      Shutdown Timeout (Minutes)", "      Motion Detection",
+		"      Motion Sensitivity", "      Temperature Unit",
+		"      Temperature Rounding Amount",
+		"      Temperature Display Update Rate",
+		"      Flip Display for Left Hand" };
+const uint8_t SettingsLongNamesLengths[] = { 29, 27, 29, 32, 22, 24, 22, 33, 37,
+		25 };
+uint8_t CalStatus = 0;
 //This does the required processing and state changes
 void ProcessUI() {
 	uint8_t Buttons = getButtons(); //read the buttons status
@@ -51,7 +60,7 @@ void ProcessUI() {
 						return;
 					}
 				}
-			uint16_t voltage = readDCVoltage(); //get X10 voltage
+			uint16_t voltage = readDCVoltage(systemSettings.voltageDiv); //get X10 voltage
 			if ((voltage / 10) < systemSettings.cutoutVoltage) {
 				operatingMode = UVLOWARN;
 				lastModeChange = millis();
@@ -93,10 +102,10 @@ void ProcessUI() {
 				settingsPage = 0;				//reset
 				operatingMode = STARTUP;		//reset back to the startup
 				saveSettings();					//Save the settings
-			} else
+			} else {
 				++settingsPage;					//move to the next option
+			}
 		} else if (Buttons & BUT_B) {
-			resetLastButtonPress();
 			//B changes the value selected
 			switch (settingsPage) {
 			case UVCO:
@@ -106,7 +115,7 @@ void ProcessUI() {
 					systemSettings.cutoutVoltage = 10;
 				break;
 			case SLEEP_TEMP:
-				systemSettings.SleepTemp += 100;		//Go up 10c at a time
+				systemSettings.SleepTemp += 100;		//Go up 10C at a time
 				if (systemSettings.SleepTemp > 3000)
 					systemSettings.SleepTemp = 1000;//cant sleep higher than 300
 				break;
@@ -116,6 +125,11 @@ void ProcessUI() {
 					systemSettings.SleepTime = 1;	//cant set time over 30 mins
 				//Remember that ^ is the time of no movement
 				break;
+			case SHUTDOWN_TIME:
+				++systemSettings.ShutdownTime;
+				if (systemSettings.ShutdownTime > 60)
+					systemSettings.ShutdownTime = 0;			//wrap to off
+				break;
 			case MOTIONDETECT:
 				systemSettings.movementEnabled =
 						!systemSettings.movementEnabled;
@@ -127,11 +141,21 @@ void ProcessUI() {
 				systemSettings.flipDisplay = !systemSettings.flipDisplay;
 				break;
 			case MOTIONSENSITIVITY:
-				systemSettings.sensitivity += 0x10;
-				if (systemSettings.sensitivity > 0x20)
-					systemSettings.sensitivity = 0;		//reset to high on wrap
+				systemSettings.sensitivity++;
+				systemSettings.sensitivity = systemSettings.sensitivity % 3;
 
 				break;
+			case TEMPROUNDING:
+				systemSettings.temperatureRounding++;
+				systemSettings.temperatureRounding =
+						systemSettings.temperatureRounding % 3;
+				break;
+			case DISPUPDATERATE:
+				systemSettings.displayUpdateSpeed++;
+				systemSettings.displayUpdateSpeed =
+						systemSettings.displayUpdateSpeed % 3;
+				break;
+
 			default:
 				break;
 			}
@@ -142,16 +166,29 @@ void ProcessUI() {
 		if (Buttons & BUT_A) {
 			//A Button was pressed so we are moving back to soldering
 			operatingMode = SOLDERING;
+			Oled_DisplayOn();
 			return;
 		} else if (Buttons & BUT_B) {
 			//B Button was pressed so we are moving back to soldering
 			operatingMode = SOLDERING;
+			Oled_DisplayOn();
 			return;
 		} else if (systemSettings.movementEnabled)
 			if (millis() - getLastMovement() < 1000) {//moved in the last second
 				operatingMode = SOLDERING; //Goto active mode again
+				Oled_DisplayOn();
 				return;
 			}
+		if (systemSettings.movementEnabled) {
+			//Check if we should shutdown
+			if ((millis() - getLastMovement()
+					> (systemSettings.ShutdownTime * 60000))
+					|| (millis() - getLastButtonPress()
+							> systemSettings.ShutdownTime * 60000)) {
+				operatingMode = COOLING; //shutdown the tip
+				Oled_DisplayOn();
+			}
+		}
 		//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);
@@ -180,9 +217,10 @@ void ProcessUI() {
 
 		if (Buttons == BUT_A) {
 			//Single button press, cycle over to the DC display
+			CalStatus = 0;
 			operatingMode = DCINDISP;
 		} else if (Buttons == BUT_B) {
-			tempCalStatus = 0;
+			CalStatus = 0;
 			operatingMode = TEMPCAL;
 		} else if (Buttons == (BUT_A | BUT_B)) {
 			//If the user is holding both button, exit the  screen
@@ -193,13 +231,37 @@ void ProcessUI() {
 		break;
 	case DCINDISP: {
 		//This lets the user check the input voltage
-
-		if (Buttons == BUT_A) {
-			//Single button press, cycle over to the temp display
-			operatingMode = THERMOMETER;
-		} else if (Buttons == (BUT_A | BUT_B)) {
-			//If the user is holding both button, exit the  screen
-			operatingMode = STARTUP;
+		if (CalStatus == 0) {
+			if (Buttons == BUT_A) {
+				//Single button press, cycle over to the temp display
+				operatingMode = THERMOMETER;
+			} else if (Buttons == BUT_B) {
+				//dc cal mode
+				CalStatus = 1;
+			} else if (Buttons == (BUT_A | BUT_B)) {
+				//If the user is holding both button, exit the  screen
+				operatingMode = STARTUP;
+			}
+		} else {
+			//User is calibrating the dc input
+			if (Buttons == BUT_A) {
+				if (!systemSettings.flipDisplay)
+					systemSettings.voltageDiv++;
+				else
+					systemSettings.voltageDiv--;
+			} else if (Buttons == BUT_B) {
+				if (!systemSettings.flipDisplay)
+					systemSettings.voltageDiv--;
+				else
+					systemSettings.voltageDiv++;
+			} else if (Buttons == (BUT_A | BUT_B)) {
+				CalStatus = 0;
+				saveSettings();
+			}
+			if (systemSettings.voltageDiv < 120)
+				systemSettings.voltageDiv = 160;
+			else if (systemSettings.voltageDiv > 160)
+				systemSettings.voltageDiv = 120;
 		}
 
 	}
@@ -210,13 +272,13 @@ void ProcessUI() {
 			operatingMode = THERMOMETER;
 		} else if (Buttons == BUT_A) {
 			//Try and calibrate
-			if (tempCalStatus == 0) {
+			if (CalStatus == 0) {
 				if ((readTipTemp() < 300) && (readSensorTemp() < 300)) {
-					tempCalStatus = 1;
+					CalStatus = 1;
 					systemSettings.tempCalibration = readTipTemp();
 					saveSettings();
 				} else {
-					tempCalStatus = 2;
+					CalStatus = 2;
 				}
 			}
 		} else if (Buttons == (BUT_A | BUT_B)) {
@@ -233,18 +295,34 @@ void ProcessUI() {
 /*
  * Draws the temp with temp conversion if needed
  */
-void drawTemp(uint16_t temp, uint8_t x) {
+void drawTemp(uint16_t temp, uint8_t x, uint8_t roundingMode) {
 	if (systemSettings.displayTempInF)
 		temp = (temp * 9 + 1600) / 5;/*Convert to F -> T*(9/5)+32*/
 	if (temp % 10 > 5)
-		temp += 10;//round up
-	OLED_DrawThreeNumber(temp / 10, x);
+		temp += 10;		//round up
+	temp /= 10;
+	//handle rounding modes
+	if (roundingMode == ROUNDING_FIVE) {
+		if (temp % 10 < 5)
+			temp = (temp / 10) * 10;
+		else
+			temp = ((temp / 10) * 10) + 5;
+	} else if (roundingMode == ROUNDING_TEN) {
+		temp = (temp / 10) * 10;
+	}
+
+	OLED_DrawThreeNumber(temp, x);
 }
 
 /*
  * Performs all the OLED drawing for the current operating mode
  */
 void DrawUI() {
+	static uint32_t lastOLEDDrawTime = 0;
+	static uint16_t lastSolderingDrawnTemp1 = 0;
+	static uint16_t lastSolderingDrawnTemp2 = 0;
+
+	static uint8_t settingsLongTestScrollPos = 0;
 	uint16_t temp = readIronTemp(0, 0, 0xFFFF);
 	switch (operatingMode) {
 	case STARTUP:
@@ -256,110 +334,203 @@ void DrawUI() {
 			Oled_DisplayOff();
 		} else {
 			Oled_DisplayOn();
-			//OLED_DrawString("  IDLE  ", 8);		//write the word IDLE
-			OLED_DrawIDLELogo();
+			OLED_DrawIDLELogo();		//Draw the icons for prompting the user
 		}
 		break;
 	case SOLDERING:
 		//The user is soldering
 	{
-		if (getIronTimer() == 0) {
-			OLED_DrawChar('C', 5);
+		if (systemSettings.displayUpdateSpeed == DISPLAYMODE_SLOW
+				&& (millis() - lastOLEDDrawTime < 200))
+			return;
+		else if (systemSettings.displayUpdateSpeed == DISPLAYMODE_MEDIUM
+				&& (millis() - lastOLEDDrawTime < 100))
+			return;
+		else if (systemSettings.displayUpdateSpeed == DISPLAYMODE_FAST
+				&& (millis() - lastOLEDDrawTime < 50))
+			return;
+
+		uint32_t tempavg = (temp + lastSolderingDrawnTemp1
+				+ lastSolderingDrawnTemp2);
+		tempavg /= 3;
+		drawTemp(tempavg, 0, systemSettings.temperatureRounding);
+		lastSolderingDrawnTemp1 = temp;
+		lastSolderingDrawnTemp2 = lastSolderingDrawnTemp1;
+		lastOLEDDrawTime = millis();
+		//Now draw symbols
+		OLED_DrawChar(' ', 3);
+		OLED_BlankSlot(6 * 12 + 16, 24 - 16);//blank out the tail after the arrows
+		OLED_BlankSlot(4 * 12 + 16, 24 - 16);//blank out the tail after the temp
+		if (getIronTimer() == 0
+				&& (temp / 10) > (systemSettings.SolderingTemp / 10)) {
+			//Cooling
+			OLED_DrawSymbol(6, 5);
 		} else {
-			if (getIronTimer() < 900) {
-				OLED_DrawChar(' ', 5);
+			if (getIronTimer() < 1500) {
+				//Maintaining
+				OLED_DrawSymbol(6, 7);
 			} else {		//we are heating
-				OLED_DrawChar('H', 5);
+				OLED_DrawSymbol(6, 6);
 			}
 		}
-		drawTemp(temp, 0);
-		OLED_DrawChar(' ', 3);
-		OLED_DrawChar(' ', 4);
-		OLED_DrawChar(' ', 6);
-		OLED_DrawChar(' ', 7);
+		if (systemSettings.displayTempInF) {
+			OLED_DrawSymbol(4, 1);
+		} else {
+			OLED_DrawSymbol(4, 0);
+		}
 
 	}
 		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_DrawChar('<', 1);
-		drawTemp(systemSettings.SolderingTemp, 2);
+		drawTemp(systemSettings.SolderingTemp, 2, 0);
 		OLED_DrawChar(' ', 5);
-		OLED_DrawChar(' ', 6);
-		OLED_DrawChar('>', 7);
-
+		OLED_DrawChar(' ', 7);
+		OLED_DrawChar('>', 6);
 		break;
 	case SETTINGS:
 		//We are prompting the user the setting name
-
-		switch (settingsPage) {
-		case UVCO:
-			OLED_DrawString("UVCO ", 5);
-			OLED_DrawTwoNumber(systemSettings.cutoutVoltage, 5);
-			OLED_DrawChar('V', 7);
-			break;
-		case SLEEP_TEMP:
-			OLED_DrawString("STMP ", 5);
-			OLED_DrawThreeNumber(systemSettings.SleepTemp / 10, 5);
-			break;
-		case SLEEP_TIME:
-			OLED_DrawString("STIME ", 6);
-			OLED_DrawTwoNumber(systemSettings.SleepTime, 6);
-			break;
-		case MOTIONDETECT:/*Toggle the mode*/
-			if (systemSettings.movementEnabled)
-				OLED_DrawString("MOTION T", 8);
-			else
-				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;
-		case MOTIONSENSITIVITY:
-			switch (systemSettings.sensitivity) {
-			case MOTION_HIGH:
-				OLED_DrawString("SENSE H ", 8);
+		if (millis() - getLastButtonPress() > 3000) {
+			//If the user has idled for > 3 seconds, show the long name for the selected setting instead
+			//draw from settingsLongTestScrollPos through to end of screen
+			uint8_t lengthLeft = SettingsLongNamesLengths[settingsPage]
+					- settingsLongTestScrollPos;
+			if (lengthLeft < 1)
+				settingsLongTestScrollPos = 0;
+			//^ Reset once not much left
+			if (lengthLeft > 8)
+				lengthLeft = 8;
+			OLED_DrawString(
+					SettingsLongNames[(uint8_t) settingsPage]
+							+ settingsLongTestScrollPos, lengthLeft);
+			if (lengthLeft < 8)
+				for (uint8_t i = lengthLeft; i < 8; i++)
+					OLED_DrawChar(' ', i);
+			if (millis() - lastOLEDDrawTime > 120) {
+				settingsLongTestScrollPos++;
+				lastOLEDDrawTime = millis();
+			}
+		} else {
+			settingsLongTestScrollPos = 0;
+			switch (settingsPage) {
+			case UVCO:
+				OLED_DrawString("UVCO ", 5);
+				OLED_DrawTwoNumber(systemSettings.cutoutVoltage, 5);
+				OLED_DrawChar('V', 7);
 				break;
-			case MOTION_MED:
-				OLED_DrawString("SENSE M ", 8);
+			case SLEEP_TEMP:
+				OLED_DrawString("STMP ", 5);
+				OLED_DrawThreeNumber(systemSettings.SleepTemp / 10, 5);
 				break;
-			case MOTION_LOW:
-				OLED_DrawString("SENSE L ", 8);
+			case SLEEP_TIME:
+				OLED_DrawString("SLTME ", 6);
+				OLED_DrawTwoNumber(systemSettings.SleepTime, 6);
+				break;
+			case SHUTDOWN_TIME:
+				OLED_DrawString("SHTME ", 6);
+				OLED_DrawTwoNumber(systemSettings.ShutdownTime, 6);
+				break;
+			case MOTIONDETECT:/*Toggle the mode*/
+				if (systemSettings.movementEnabled)
+					OLED_DrawString("MOTION T", 8);
+				else
+					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;
+			case MOTIONSENSITIVITY:
+				switch (systemSettings.sensitivity) {
+				case MOTION_HIGH:
+					OLED_DrawString("SENSE H ", 8);
+					break;
+				case MOTION_MED:
+					OLED_DrawString("SENSE M ", 8);
+					break;
+				case MOTION_LOW:
+					OLED_DrawString("SENSE L ", 8);
+					break;
+				default:
+					OLED_DrawString("SENSE   ", 8);
+					break;
+				}
+
+				break;
+			case TEMPROUNDING:
+				//We are prompting the user about their display mode preferences
+			{
+				switch (systemSettings.temperatureRounding) {
+				case ROUNDING_NONE:
+					OLED_DrawString("TMPRND 1", 8);
+					break;
+				case ROUNDING_FIVE:
+					OLED_DrawString("TMPRND 5", 8);
+					break;
+				case ROUNDING_TEN:
+					OLED_DrawString("TMPRND10", 8);
+					break;
+				default:
+					OLED_DrawString("TMPRND 1", 8);
+					break;
+				}
+			}
+				break;
+			case DISPUPDATERATE:
+				//We are prompting the user about their display mode preferences
+			{
+				switch (systemSettings.displayUpdateSpeed) {
+				case DISPLAYMODE_FAST:
+					OLED_DrawString("TMPSPD F", 8);
+					break;
+				case DISPLAYMODE_SLOW:
+					OLED_DrawString("TMPSPD S", 8);
+					break;
+				case DISPLAYMODE_MEDIUM:
+					OLED_DrawString("TMPSPD M", 8);
+					break;
+
+				}
+			}
 				break;
 			default:
-				OLED_DrawString("SENSE   ", 8);
 				break;
 			}
-
-			break;
-		default:
-			break;
 		}
 		break;
 	case SLEEP:
 		//The iron is in sleep temp mode
 		//Draw in temp and sleep
 		OLED_DrawString("SLP", 3);
-		drawTemp(temp, 4);
+		drawTemp(temp, 4, systemSettings.temperatureRounding);
+		OLED_BlankSlot(84, 96 - 85);		//blank out after the temp
+
+		if (millis() - getLastMovement() > (10 * 60 * 1000)
+				&& (millis() - getLastButtonPress() > (10 * 60 * 1000))) {
+			//OLED off
+			Oled_DisplayOff();
+		} else {
+			Oled_DisplayOn();
+		}
+
 		break;
 	case COOLING:
 		//We are warning the user the tip is cooling
-		OLED_DrawString("COOL", 4);
-		drawTemp(temp, 5);
+		OLED_DrawString("COOL ", 5);
+		drawTemp(temp, 5, systemSettings.temperatureRounding);
 		break;
 	case UVLOWARN:
 		OLED_DrawString("LOW VOLT", 8);
@@ -367,29 +538,33 @@ void DrawUI() {
 	case THERMOMETER:
 		temp = readIronTemp(0, 1, 0xFFFF);	//Force a reading as heater is off
 		OLED_DrawString("TEMP ", 5);//extra one to it clears the leftover 'L' from IDLE
-		drawTemp(temp, 5);
+		drawTemp(temp, 5, 0);
 		break;
 	case DCINDISP: {
-		uint16_t voltage = readDCVoltage(); //get X10 voltage
-		OLED_DrawString("IN", 2);
-		OLED_DrawChar((voltage / 100) % 10, 2);
-		voltage -= (voltage / 100) * 100;
-		OLED_DrawChar((voltage / 10) % 10, 3);
-		voltage -= (voltage / 10) * 10;
-		OLED_DrawChar('.', 4);
-		OLED_DrawChar(voltage % 10, 5);
-		OLED_DrawChar('V', 6);
-		OLED_DrawChar(' ', 7);
+		uint16_t voltage = readDCVoltage(systemSettings.voltageDiv); //get X10 voltage
 
+		if (CalStatus == 0 || ((millis() % 1000) > 500)) {
+			OLED_DrawString("IN", 2);
+			OLED_DrawChar((voltage / 100) % 10, 2);
+			voltage -= (voltage / 100) * 100;
+			OLED_DrawChar((voltage / 10) % 10, 3);
+			voltage -= (voltage / 10) * 10;
+			OLED_DrawChar('.', 4);
+			OLED_DrawChar(voltage % 10, 5);
+			OLED_DrawChar('V', 6);
+			OLED_DrawChar(' ', 7);
+		} else {
+			OLED_DrawString("IN      ", 8);
+		}
 	}
 		break;
 	case TEMPCAL: {
 
-		if (tempCalStatus == 0) {
+		if (CalStatus == 0) {
 			OLED_DrawString("CAL TEMP", 8);
-		} else if (tempCalStatus == 1) {
+		} else if (CalStatus == 1) {
 			OLED_DrawString("CAL OK  ", 8);
-		} else if (tempCalStatus == 2) {
+		} else if (CalStatus == 2) {
 			OLED_DrawString("CAL FAIL", 8);
 		}
 	}
@@ -398,4 +573,5 @@ void DrawUI() {
 	default:
 		break;
 	}
+
 }

workspace/ts100/src/Oled.c

@@ -188,7 +188,9 @@ void OLED_DrawChar(char c, uint8_t x) {
 	x *= FONT_WIDTH; //convert to a x coordinate
 
 	u8* ptr = (u8*) FONT;
-	if (c >= 'A' && c <= 'Z') {
+	if (c >= 'a' && c <= 'z') {
+		ptr += (c - 'a' + 10) * (FONT_WIDTH * 2); //alpha is ofset 10 chars into the array
+	} else 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);
@@ -207,6 +209,14 @@ void OLED_DrawChar(char c, uint8_t x) {
 
 	Oled_DrawArea(x, 0, FONT_WIDTH, 16, (u8*) ptr);
 }
+
+void OLED_BlankSlot(uint8_t xStart, uint8_t width) {
+	u8* ptr = (u8*) FONT;
+	ptr += (36) * (FONT_WIDTH * 2);
+
+	Oled_DrawArea(xStart, 0, width, 16, (u8*) ptr);
+}
+
 /*
  * Draw a 2 digit number to the display at letter slot x
  */
@@ -254,3 +264,7 @@ void OLED_DrawIDLELogo() {
 	}
 
 }
+
+void OLED_DrawSymbol(uint8_t x, uint8_t symbol) {
+	Oled_DrawArea(x * FONT_WIDTH, 0, 16, 16, SymbolTable + (symbol * 32));
+}

workspace/ts100/src/PID.c

@@ -15,8 +15,8 @@ int32_t computePID(uint16_t setpoint) {
 	uint16_t currentReading = readIronTemp(0, 1,setpoint); //get the current temp of the iron
 	int16_t error = (int16_t) setpoint - (int16_t) currentReading; //calculate the error term
 	ITerm += (pidSettings.ki * error);
-	if (ITerm > MAXPIDOUTPUT)
-		ITerm = MAXPIDOUTPUT;
+	if (ITerm > MAXPIDOUTPUT/2)
+		ITerm = MAXPIDOUTPUT/2;
 	else if (ITerm < 0)
 		ITerm = 0; //cap at 0 since we cant force the iron to cool itself :)
 
@@ -34,8 +34,8 @@ int32_t computePID(uint16_t setpoint) {
 }
 /*Sets up the pid values*/
 void setupPID(void) {
-	pidSettings.kp = 25;
-	pidSettings.ki = 7;
-	pidSettings.kd = 2;
+	pidSettings.kp = 15;
+	pidSettings.ki = 2;
+	pidSettings.kd = 3;
 
 }

workspace/ts100/src/Settings.c

@@ -51,6 +51,10 @@ void resetSettings() {
 	systemSettings.flipDisplay=0;				//Default to right handed mode
 	systemSettings.sensitivity=0x00;			//Default high sensitivity
 	systemSettings.tempCalibration=239;			//Default to their calibration value
+	systemSettings.voltageDiv=144;				//Default divider from schematic
+	systemSettings.ShutdownTime=30;				//How many minutes until the unit turns itself off
+	systemSettings.displayUpdateSpeed=0;		//How fast the LCD updates
+	systemSettings.temperatureRounding=0;		//How the temperature is rounded off
 
 }
 

workspace/ts100/ts100.xml

@@ -4,6 +4,6 @@
     <name>ts100</name>
     <mcuId>stm32f103t8ux</mcuId>
     <dbgIF>SWD</dbgIF>
-    <dbgDEV>ST-LinkV2</dbgDEV>
+    <dbgDEV>ST-Link</dbgDEV>
   </board>
 </targetDefinitions>