Retune PID, improve response rate slightly. (But slightly more oscillation)

Better button auto-repeat
More explicit left handed checks
2025-02-26 07:53:55 +00:00 · 2017-08-02 21:38:42 +10:00 · 2017-07-30 21:25:27 +10:00 · 2017-07-30 20:02:58 +10:00 · 2017-07-27 20:29:17 +10:00 · 2017-07-27 11:52:28 +10:00
23 changed files with 777 additions and 258 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -39,4 +39,5 @@ workspace/ts100/.settings/language.settings.xml
 workspace/ts100/.cproject
 TS100/KiCad/TS100.bak
 Logo GUI/TS100 Logo Editor/TS100 Logo Editor/obj/
-Logo GUI/TS100 Logo Editor/TS100 Logo Editor/bin/
+Logo GUI/TS100 Logo Editor/TS100 Logo Editor/bin/
+workspace/ts100/ts100.xml
--- a/Editor.userprefs
+++ b/Editor.userprefs
@@ -0,0 +1,8 @@
+<Properties StartupItem="TS100 Logo Editor/TS100 Logo Editor.csproj">
+  <MonoDevelop.Ide.Workspace ActiveConfiguration="Debug" />
+  <MonoDevelop.Ide.Workbench />
+  <MonoDevelop.Ide.DebuggingService.Breakpoints>
+    <BreakpointStore />
+  </MonoDevelop.Ide.DebuggingService.Breakpoints>
+  <MonoDevelop.Ide.DebuggingService.PinnedWatches />
+</Properties>
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # TS100
-This is a complete re*write of the open source software for the ts100 soldering iron.
+This is a complete rewrite of the open source software for the ts100 soldering iron.
 This project is feature complete for use as a soldering iron, *so please suggest any feature improvements you would like!*
+A short(ish) video that goes through every single menu option in the firmware is available [over here](https://www.youtube.com/watch?v=WlnpboYfxNk)

 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.
@@ -23,6 +24,7 @@ Please calibrate your irons voltage reading when you are using a lithium battery
 * Boost mode lets you temporarily change the temperature when soldering
 * Battery charge level indicatior if power source set to a lipo cell count.
 * Custom bootup logo support
+* Automatic LCD rotation based on orientation

 # Upgrading your ts100 iron

@@ -46,8 +48,9 @@ There is a complete device flash backup included in this repository. (Note this
 This firmware uses a different method of updating the bootup image.
 This removes the need for emulating a USB drive on the iron just to allow for a bootup image to be setup.
 At this point in time you will need a windows machine to make the required .hex file for you image.
+*If you know what your doing, this program will run fine through mono on other systems*

-1. On the [releases page](https://github.com/Ralim/ts100/releases) you will need to download the latest copy of the GUI Tool (*TS100 Logo Editor.exe*).
+1. On the [releases page](https://github.com/Ralim/ts100/releases) you will need to download the latest copy of the GUI Tool (*TS100.Logo.Editor.exe*).
 2. Launch the TS100 Logo Editor, you will need to have .NET 4.0 installed on your machine
 3. On the tool open the source image that you would like to use as your bootup screen. A resolution of 96x16 is ideal, but you can fill or stretch your logo to fit
 4. Colour images are okay, the software will convert them to B&W for you.
@@ -86,7 +89,7 @@ If you leave the unit alone (ie don't press any buttons) on a setting, after 3 s
 * 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
+* DSPROT -> Display rotation mode, Automatic, Left handed or Right handed
 * BOOST -> Enable boost mode
 * BTMP -> Set the temperature for the boost mode

@@ -144,8 +147,18 @@ This allows you to change the front key (one near the tip) to become a boost but

 The boost temperature is set in the settings menu.

+## Commercial Use
+
+This software is provided as-is, so I cannot provide any commercial support for the firmware. However you are more than welcome to distribute links to the firmware, or provide irons with this software on them. 
+Please do not re-host the files, but rather link to this page, so that there are not old versions of the firmware hanging around. If this firmware does make you money, it would be nice to recieve a donation, however I dont enforce this.
+
 ## Version Changes

+V1.16
+
+* Added automatic rotation support
+* Added power display graph
+
 V1.15

 * Added support for a custom bootup logo to be programmed via the DFU bootloader.
@@ -212,4 +225,4 @@ 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).

-If you love this firmware and want to continue my caffine addiction, you can do so here (or email me) : https://paypal.me/RalimTek
+If you love this firmware and want to continue my caffine addiction, you can do so here (or email me for other options) : https://paypal.me/RalimTek
--- a/workspace/ts100/.cproject
+++ b/workspace/ts100/.cproject
@@ -28,7 +28,7 @@
 							</builder>
 							<tool id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.1500724168" name="MCU GCC Compiler" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler">
 								<option id="fr.ac6.managedbuild.gnu.c.compiler.option.optimization.level.963224364" name="Optimization Level" superClass="fr.ac6.managedbuild.gnu.c.compiler.option.optimization.level" useByScannerDiscovery="false" value="fr.ac6.managedbuild.gnu.c.optimization.level.more" valueType="enumerated"/>
-								<option id="gnu.c.compiler.option.debugging.level.400507088" name="Debug Level" superClass="gnu.c.compiler.option.debugging.level" useByScannerDiscovery="false" value="gnu.c.debugging.level.max" valueType="enumerated"/>
+								<option id="gnu.c.compiler.option.debugging.level.400507088" name="Debug Level" superClass="gnu.c.compiler.option.debugging.level" useByScannerDiscovery="false" value="gnu.c.debugging.level.none" valueType="enumerated"/>
 								<option id="gnu.c.compiler.option.include.paths.1436405353" name="Include paths (-I)" superClass="gnu.c.compiler.option.include.paths" useByScannerDiscovery="false" valueType="includePath">
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/inc}&quot;"/>
 									<listOptionValue builtIn="false" value="&quot;${workspace_loc:/${ProjName}/StdPeriph_Driver/inc}&quot;"/>
@@ -50,6 +50,8 @@
 								<option id="gnu.c.compiler.option.dialect.std.1983627145" name="Language standard" superClass="gnu.c.compiler.option.dialect.std" useByScannerDiscovery="true" value="gnu.c.compiler.dialect.c11" valueType="enumerated"/>
 								<option id="gnu.c.compiler.option.warnings.nowarn.1227270879" name="Inhibit all warnings (-w)" superClass="gnu.c.compiler.option.warnings.nowarn" useByScannerDiscovery="false" value="false" valueType="boolean"/>
 								<option id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.fdata.1556802580" name="Place the data in their own section (-fdata-sections)" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.fdata" useByScannerDiscovery="false" value="true" valueType="boolean"/>
+								<option id="gnu.c.compiler.option.warnings.extrawarn.826041739" name="Extra warnings (-Wextra)" superClass="gnu.c.compiler.option.warnings.extrawarn" useByScannerDiscovery="false" value="true" valueType="boolean"/>
+								<option id="fr.ac6.managedbuid.gnu.c.compiler.option.misc.other.1256666959" superClass="fr.ac6.managedbuid.gnu.c.compiler.option.misc.other" useByScannerDiscovery="false" value="-fmessage-length=0 -fno-common" valueType="string"/>
 								<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c.1635097739" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.c"/>
 								<inputType id="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s.211510996" superClass="fr.ac6.managedbuild.tool.gnu.cross.c.compiler.input.s"/>
 							</tool>
@@ -186,4 +188,5 @@
 			<resource resourceType="PROJECT" workspacePath="/ts100"/>
 		</configuration>
 	</storageModule>
+	<storageModule moduleId="org.eclipse.cdt.make.core.buildtargets"/>
 </cproject>
--- a/workspace/ts100/StdPeriph_Driver/inc/stm32f10x_i2c.h
+++ b/workspace/ts100/StdPeriph_Driver/inc/stm32f10x_i2c.h
@@ -406,12 +406,12 @@ typedef struct
  * 1) In normal case (only one address managed by the slave), when the address 
  *   sent by the master matches the own address of the peripheral (configured by 
  *   I2C_OwnAddress1 field) the I2C_EVENT_SLAVE_XXX_ADDRESS_MATCHED event is set 
-  *   (where XXX could be TRANSMITTER or RECEIVER).
+  *   (where XX could be TRANSMITTER or RECEIVER).
  *    
  * 2) In case the address sent by the master matches the second address of the 
  *   peripheral (configured by the function I2C_OwnAddress2Config() and enabled 
  *   by the function I2C_DualAddressCmd()) the events I2C_EVENT_SLAVE_XXX_SECONDADDRESS_MATCHED 
-  *   (where XXX could be TRANSMITTER or RECEIVER) are set.
+  *   (where XX could be TRANSMITTER or RECEIVER) are set.
  *   
  * 3) In case the address sent by the master is General Call (address 0x00) and 
  *   if the General Call is enabled for the peripheral (using function I2C_GeneralCallCmd()) 
--- a/workspace/ts100/inc/Font.h
+++ b/workspace/ts100/inc/Font.h
@@ -132,6 +132,139 @@ const uint8_t extendedFont[] = {

 		0x00,0x00,0xF8,0xF8,0xFE,0xF2,0xF2,0xFE,0xF8,0xF8,0x00,0x00,
 		0x00,0x00,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x00,0x00,/*Battery 10*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xFF,/*Bar Graph empty (0)*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFF,/*Bar 1*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xFF,/*Bar 2*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xFF,/*Bar 3*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xFF,/*Bar 4*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFF,/*Bar 5*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFF,/*Bar 6*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 7*/
+
+		0xFF,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 8*/
+
+		0xFF,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 9*/
+
+		0xFF,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 10*/
+
+		0xFF,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 11*/
+
+		0xFF,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 12*/
+
+		0xFF,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 13*/
+
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*Bar 14*/
+};
+const uint8_t DoubleWidthChars[]={
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0xFF,/*Bar 0*/
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xC0,0x80,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xE0,0xC0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xF0,0xE0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xF8,0xF0,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFC,0xF8,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFE,0xFC,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,0xFE,0xFF,
+
+		0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0x81,0x01,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xC1,0x81,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xC1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xE1,0xC1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xE1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xF1,0xE1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xF1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xF9,0xF1,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xF9,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFD,0xF9,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFD,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,0xFD,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+		0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
 };
 const uint8_t Iron_Base[] ={
 		0x00,0x20,0x60,0x60,0x60,0x60,0x60,0x60,0x90,0x90,0x90,0x90,
--- a/workspace/ts100/inc/I2C.h
+++ b/workspace/ts100/inc/I2C.h
@@ -11,6 +11,7 @@

 void I2C_Configuration(void);
 void I2C_PageWrite(u8* pbuf, u8 numbyte, u8 deviceaddr);
-void I2C_PageRead(u8* pbuf, u8 numbyte, u8 deviceaddr, u8 readaddr);
+int I2C_Master_Read(uint8_t deviceAddr, uint8_t readAddr, uint8_t* pBuffer,
+		uint16_t numByteToRead);
 #endif
 /******************************** END OF FILE *********************************/
--- a/workspace/ts100/inc/Interrupt.h
+++ b/workspace/ts100/inc/Interrupt.h
@@ -8,41 +8,23 @@
 /* Functions for access to data */
 extern volatile uint32_t system_Ticks;
 void delayMs(uint32_t ticks);
-volatile extern uint32_t lastKeyPress;
-volatile extern uint32_t lastMovement;
+extern volatile uint32_t lastMovement;

-volatile extern uint8_t keyState;
-volatile extern uint8_t rawKeys;
+extern volatile uint8_t rawKeys;

 inline uint32_t millis() {
 	return system_Ticks;
 }

-inline uint32_t getLastButtonPress() {
-	return lastKeyPress;
-}
-inline void resetLastButtonPress() {
-	lastKeyPress = millis();
-
-}
-inline void resetButtons() {
-	keyState = 0;
-}
-
 inline uint32_t getLastMovement() {
 	return lastMovement;
 }

-inline uint16_t getButtons() {
-	return keyState;
-}
+uint8_t getButtons();
+uint32_t getLastButtonPress();
 inline uint16_t getRawButtons() {
 	return rawKeys;
 }
-inline void restoreButtons()
-{
-	keyState=getRawButtons();
-}

 /*IRQ prototypes*/
 void NMI_Handler(void);
--- a/workspace/ts100/inc/MMA8652FC.h
+++ b/workspace/ts100/inc/MMA8652FC.h
@@ -14,9 +14,8 @@
 #ifndef __MMA8652FC__H
 #define __MMA8652FC__H

-
-void StartUp_Accelerometer(uint8_t sensitivity);//This is the only function we expose
-
+void StartUp_Accelerometer(uint8_t sensitivity); //This is the only function we expose
+uint8_t getOrientation();
 //--------------MMA8652 Device ID----------------------------------------------//

 #define DEVICE_ADDR     0X1D        
@@ -99,8 +98,6 @@ void StartUp_Accelerometer(uint8_t sensitivity);//This is the only function we e
 #define INT_SOURCE    0X0C
 #define DEVICE_ID     0X0D

-
-
 //-----STATUS_REG(0X00)-----Bit Define----------------------------------------//
 #define ZYXDR_BIT     0X08
 //----XYZ_DATA_CFG_REG(0xE)-Bit Define----------------------------------------//
@@ -123,7 +120,7 @@ void StartUp_Accelerometer(uint8_t sensitivity);//This is the only function we e
 //---------CTRL_REG2(0X2B)Bit Define------------------------------------------// 
 #define MODS_MASK     0x03     //Oversampling Mode 4 
 #define Normal_Mode   0x0      //Normal=0,Low Noise Low Power MODS=1,
-                               //HI RESOLUTION=2,LOW POWER MODS = 11 
+//HI RESOLUTION=2,LOW POWER MODS = 11
 //----CTRL_REG4---Interrupt Enable BIT ---------------------------------------//   
 //0 interrupt is disabled (default) 
 //1 interrupt is enabled     
--- a/workspace/ts100/inc/Modes.h
+++ b/workspace/ts100/inc/Modes.h
@@ -16,8 +16,10 @@
 #include "PID.h"
 #include "Settings.h"
 #include "Analog.h"
+#include "MMA8652FC.h"
 #include <string.h>
-enum {
+
+typedef enum {
 	STARTUP, 		//we are sitting on the prompt to push a button
 	SOLDERING, 		//Normal operating mode
 	TEMP_ADJ,		//Adjust the set temperature
@@ -29,10 +31,14 @@ enum {
 	DCINDISP,		//Disp the input voltage && Cal the DCin voltage divider
 	TEMPCAL,		//Cal tip temp offset

-} operatingMode;
-#define SETTINGSOPTIONSCOUNT 10 /*Number of settings in the settings menu*/
-
-enum {
+} operatingModeEnum;
+//#define PIDTUNING
+#ifdef PIDTUNING
+#define SETTINGSOPTIONSCOUNT (11+3) /*Number of settings in the settings menu*/
+#else
+#define SETTINGSOPTIONSCOUNT (11) /*Number of settings in the settings menu*/
+#endif
+typedef enum {
 	UVCO = 0,
 	SLEEP_TEMP,
 	SLEEP_TIME,
@@ -41,10 +47,16 @@ enum {
 	TEMPDISPLAY,
 	TEMPROUNDING,
 	DISPUPDATERATE,
-	LEFTY,
+	SCREENROTATION,
 	BOOSTMODE,
 	BOOSTTEMP,
-} settingsPage;
+	POWERDISPLAY,
+#ifdef PIDTUNING
+	PIDP,
+	PIDI,
+	PIDD,
+#endif
+} settingsPageEnum;

 void ProcessUI();
 void DrawUI();
--- a/workspace/ts100/inc/Oled.h
+++ b/workspace/ts100/inc/Oled.h
@@ -14,21 +14,24 @@
 void Oled_DisplayOn(void);
 void Oled_DisplayOff(void);

-const u8* Oled_DrawArea(u8 x0, u8 y0, u8 wide, u8 high,const u8* ptr);
+const u8* Oled_DrawArea(u8 x0, u8 y0, u8 wide, u8 high, const u8* ptr);
 void Set_ShowPos(u8 x, u8 y);
 void Oled_DisplayFlip();
 void GPIO_Init_OLED(void);
 void Init_Oled(uint8_t leftHanded);
-const u8* Data_Command(u8 len,const u8* ptr);
-void Clear_Screen(void);//Clear the screen
+const u8* Data_Command(u8 len, const u8* ptr);
+void Clear_Screen(void); //Clear the screen
 /*Functions for writing to the screen*/
 void OLED_DrawString(const char* string, const uint8_t length);
 void OLED_DrawChar(char c, uint8_t x);
 void OLED_DrawExtendedChar(uint8_t id, uint8_t x);
+void OLED_DrawWideChar(uint8_t id, uint8_t x);
 void OLED_DrawTwoNumber(uint8_t in, uint8_t x);
-void OLED_BlankSlot(uint8_t xStart,uint8_t width);
+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);
+void OLED_DrawSymbol(uint8_t x, uint8_t symbol);
+const u8* Oled_DrawArea(u8 x0, u8 y0, u8 wide, u8 high, const u8* ptr);
+void OLED_SetOrientation(uint8_t ori);
+uint8_t OLED_GetOrientation();
 #endif
-/******************************** END OF FILE *********************************/
--- a/workspace/ts100/inc/PID.h
+++ b/workspace/ts100/inc/PID.h
@@ -12,10 +12,11 @@
 #include "Analog.h"
 #include "Interrupt.h"

-struct {
+typedef struct {
 	uint32_t kp, ki, kd; //PID values
-} pidSettings;
+} pidSettingsType;

 int32_t computePID(uint16_t setpoint);
 void setupPID(void);
+extern pidSettingsType pidSettings;
 #endif /* PID_H_ */
--- a/workspace/ts100/inc/Settings.h
+++ b/workspace/ts100/inc/Settings.h
@@ -11,7 +11,8 @@
 #define SETTINGS_H_
 #include <stdint.h>
 #include "stm32f10x_flash.h"
-#define SETTINGSVERSION 13 /*Change this if you change the struct below to prevent people getting out of sync*/
+#include "Oled.h"
+#define SETTINGSVERSION 14 /*Change this if you change the struct below to prevent people getting out of sync*/
 //Display Speeds
 #define DISPLAYMODE_FAST 	(0x00)
 #define DISPLAYMODE_MEDIUM 	(0x01)
@@ -24,14 +25,15 @@
 /*
 * This struct must be a multiple of 2 bytes as it is saved / restored from flash in uint16_t chunks
 */
-struct {
+typedef struct {
 	uint16_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 cutoutSetting:5; 		//(3 bits) The voltage we cut out at for under voltage
+	uint8_t cutoutSetting:3; 		//(3 bits) The voltage we cut out at for under voltage
+	uint8_t powerDisplay:1;			//Toggle to swap the arrows with a power readout instead
 	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 OrientationMode:2;		//If true we want to invert the display for lefties
 	uint8_t sensitivity:6;			//Sensitivity of accelerometer (5 bits)
 	uint8_t ShutdownTime:6;			//Time until unit shuts down if left alone
 	uint8_t displayUpdateSpeed:2;	//How fast the display updates / temp showing mode
@@ -40,7 +42,9 @@ struct {
 	uint16_t tempCalibration;		//Temperature calibration value
 	uint16_t voltageDiv;			//Voltage divisor factor
 	uint16_t BoostTemp; 			//Boost mode set point for the iron
-} systemSettings;
+} systemSettingsType;
+
+extern systemSettingsType systemSettings;

 void saveSettings();
 void restoreSettings();
--- a/workspace/ts100/src/Analog.c
+++ b/workspace/ts100/src/Analog.c
@@ -23,7 +23,7 @@ uint16_t readDCVoltage(uint16_t divFactor) {
 //This allows us to read it in X10 mode
 //Returns temperature in C X10 mode
 int16_t readTipTemp() {
-	static uint32_t rollingAverage[16];
+	static uint32_t rollingAverage[8];
 	static uint8_t rIndex = 0;

 	/*The head has a thermocouple inline with the heater
@@ -54,13 +54,10 @@ 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) % 16;
+	rIndex = (rIndex + 1) % 8;
 	return (rollingAverage[0] + rollingAverage[1] + rollingAverage[2]
 			+ 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
+			+ rollingAverage[6] + rollingAverage[7]) / 8;

 }

--- a/workspace/ts100/src/Bios.c
+++ b/workspace/ts100/src/Bios.c
@@ -250,7 +250,7 @@ void Clear_Watchdog(void) {

 //TIM3_ISR handles the tick of the timer 3 IRQ
 void TIM3_ISR(void) {
-	volatile static u8 heat_flag = 0;
+	static volatile u8 heat_flag = 0;
 	//heat flag == used to make the pin toggle
 	//As the output is passed through a cap, the iron is on whilever we provide a square wave drive output

--- a/workspace/ts100/src/I2C.c
+++ b/workspace/ts100/src/I2C.c
@@ -4,6 +4,19 @@
 */
 #include "I2C.h"

+/* I2C STOP mask */
+#define CR1_STOP_Set            ((uint16_t)0x0200)
+#define CR1_STOP_Reset          ((uint16_t)0xFDFF)
+
+/* I2C ACK mask */
+#define CR1_ACK_Set             ((uint16_t)0x0400)
+#define CR1_ACK_Reset           ((uint16_t)0xFBFF)
+
+/* I2C POS mask */
+#define CR1_POS_Set             ((uint16_t)0x0800)
+#define CR1_POS_Reset           ((uint16_t)0xF7FF)
+
+#define NULL ((void *)0)
 /*
 * Configure the I2C port hardware
 */
@@ -60,89 +73,222 @@ void I2C_PageWrite(u8* buf, u8 nbyte, u8 deviceaddr) {
 	}

 }
+//Based on code from http://iamjustinwang.blogspot.com.au/2016/03/stm32f103-i2c-master-driver.html
+int I2C_Master_Read(uint8_t deviceAddr, uint8_t readAddr, uint8_t* pBuffer,
+		uint16_t numByteToRead) {

-/*
- * Read Page of data using I2C1 peripheral
- */
+	__IO uint32_t temp = 0;
+	volatile int I2C_TimeOut = 0;

-void I2C_PageRead(u8* buf, u8 nbyte, u8 deviceaddr, u8 readaddr) {
-	I2C_GenerateSTART(I2C1, ENABLE);
-	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_SB) == RESET)
-		;
-	I2C_Send7bitAddress(I2C1, deviceaddr << 1, I2C_Direction_Transmitter);
-	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR) == RESET)
-		;
-	I2C_GetFlagStatus(I2C1, I2C_FLAG_MSL);
-	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_TXE) == RESET)
-		;
-	// Send an 8bit byte address
-	I2C_SendData(I2C1, readaddr);
+	// /* While the bus is busy * /
+	I2C_TimeOut = 1000;
 	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY)) {
-	}
-	I2C_AcknowledgeConfig(I2C1, DISABLE);
-	I2C_NACKPositionConfig(I2C1, I2C_NACKPosition_Current);
-	I2C_GenerateSTART(I2C1, ENABLE);
-	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) {
-	}
-	I2C_Send7bitAddress(I2C1, deviceaddr << 1, I2C_Direction_Receiver);
-	while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_ADDR)) {
-	}
-	if (nbyte == 1) {
-		// Clear Ack bit
-		I2C_AcknowledgeConfig(I2C1, DISABLE);
-		// EV6_1 -- must be atomic -- Clear ADDR, generate STOP
-		__disable_irq();
-		(void) I2C1->SR2;
-		I2C_GenerateSTOP(I2C1, ENABLE);
-		__enable_irq();
-		// Receive data   EV7
-		while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_RXNE)) {
-		}
-		*buf++ = I2C_ReceiveData(I2C1);
-	} else if (nbyte == 2) {
-		// Set POS flag
-		I2C_NACKPositionConfig(I2C1, I2C_NACKPosition_Next);
-		// EV6_1 -- must be atomic and in this order
-		__disable_irq();
-		(void) I2C1->SR2;                           // Clear ADDR flag
-		I2C_AcknowledgeConfig(I2C1, DISABLE);       // Clear Ack bit
-		__enable_irq();
-		// EV7_3  -- Wait for BTF, program stop, read data twice
-		while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF)) {
-		}
-		__disable_irq();
-		I2C_GenerateSTOP(I2C1, ENABLE);
-		*buf++ = I2C1->DR;
-		__enable_irq();
-		*buf++ = I2C1->DR;
-	} else {
-		(void) I2C1->SR2;                           // Clear ADDR flag
-		while (nbyte-- != 3) {
-			// EV7 -- cannot guarantee 1 transfer completion time, wait for BTF
-			//        instead of RXNE
-			while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF)) {
-			}
-			*buf++ = I2C_ReceiveData(I2C1);
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
 		}
+	}

-		while (!I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF)) {
+	// * Send START condition * /
+	I2C_GenerateSTART(I2C1, ENABLE);
+
+	// / * Test on EV5 and clear it * /
+	I2C_TimeOut = 1000;
+	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) {
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
 		}
-		// EV7_2 -- Figure 1 has an error, doesn't read N-2 !
-		I2C_AcknowledgeConfig(I2C1, DISABLE);           // clear ack bit
+	}
+
+	// / * Send  address for write  * /
+	I2C_Send7bitAddress(I2C1, deviceAddr, I2C_Direction_Transmitter);
+
+	// / * Test on EV6 and clear it * /
+	I2C_TimeOut = 1000;
+	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)) {
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
+		}
+	}
+
+	// / * Send the internal address to read from: Only one byte address  * /
+	I2C_SendData(I2C1, readAddr);
+
+	/// * Test on EV8 and clear it * /
+	I2C_TimeOut = 1000;
+	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED)) {
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
+		}
+	}
+
+	/// * Send STRAT condition a second time * /
+	I2C_GenerateSTART(I2C1, ENABLE);
+
+	/// * Test on EV5 and clear it * /
+	I2C_TimeOut = 1000;
+	while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT)) {
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
+		}
+	}
+
+	// * Send  address for read * /
+	I2C_Send7bitAddress(I2C1, deviceAddr, I2C_Direction_Receiver);
+
+	if (numByteToRead == 1) {
+		/* Wait until ADDR is set */
+		I2C_TimeOut = 1000;
+		while ((I2C1->SR1 & 0x0002) != 0x0002) {
+			if (I2C_TimeOut-- <= 0) {
+				return 1;
+			}
+		}
+		/* Clear ACK bit */
+		I2C1->CR1 &= CR1_ACK_Reset;
+		/* Disable all active IRQs around ADDR clearing and STOP programming because the EV6_3
+		 software sequence must complete before the current byte end of transfer */
 		__disable_irq();
-		*buf++ = I2C_ReceiveData(I2C1);             // receive byte N-2
-		I2C_GenerateSTOP(I2C1, ENABLE);                  // program stop
+		/* Clear ADDR flag */
+		temp = I2C1->SR2;
+		/* Program the STOP */
+		I2C_GenerateSTOP(I2C1, ENABLE);
+		/* Re-enable IRQs */
 		__enable_irq();
-		*buf++ = I2C_ReceiveData(I2C1);             // receive byte N-1
-		// wait for byte N
-		while (!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED)) {
+		/* Wait until a data is received in DR register (RXNE = 1) EV7 */
+		I2C_TimeOut = 1000;
+		while ((I2C1->SR1 & 0x00040) != 0x000040) {
+			if (I2C_TimeOut-- <= 0) {
+				return 1;
+			}
 		}
-		*buf++ = I2C_ReceiveData(I2C1);
-		nbyte = 0;
+		/* Read the data */
+		*pBuffer = I2C1->DR;
+
+	} else if (numByteToRead == 2) {
+
+		/* Set POS bit */
+		I2C1->CR1 |= CR1_POS_Set;
+		/* Wait until ADDR is set: EV6 */
+		I2C_TimeOut = 1000;
+		while ((I2C1->SR1 & 0x0002) != 0x0002) {
+			if (I2C_TimeOut-- <= 0) {
+				return 1;
+			}
+		}
+		/* EV6_1: The acknowledge disable should be done just after EV6,
+		 that is after ADDR is cleared, so disable all active IRQs around ADDR clearing and
+		 ACK clearing */
+		__disable_irq();
+		/* Clear ADDR by reading SR2 register  */
+		temp = I2C1->SR2;
+		/* Clear ACK */
+		I2C1->CR1 &= CR1_ACK_Reset;
+		/*Re-enable IRQs */
+		__enable_irq();
+		/* Wait until BTF is set */
+		I2C_TimeOut = 1000;
+		while ((I2C1->SR1 & 0x00004) != 0x000004) {
+			if (I2C_TimeOut-- <= 0) {
+				return 1;
+			}
+		}
+		/* Disable IRQs around STOP programming and data reading */
+		__disable_irq();
+		/* Program the STOP */
+		I2C_GenerateSTOP(I2C1, ENABLE);
+		/* Read first data */
+		*pBuffer = I2C1->DR;
+		/* Re-enable IRQs */
+		__enable_irq();
+		/**/
+		pBuffer++;
+		/* Read second data */
+		*pBuffer = I2C1->DR;
+		/* Clear POS bit */
+		I2C1->CR1 &= CR1_POS_Reset;
 	}
-	// Wait for stop
-	while (I2C_GetFlagStatus(I2C1, I2C_FLAG_STOPF)) {
+
+	else { //numByteToRead > 2
+		   // * Test on EV6 and clear it * /
+		I2C_TimeOut = 1000;
+		while (!I2C_CheckEvent(I2C1,
+		I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)) {
+			if (I2C_TimeOut-- <= 0) {
+				return 1;
+			}
+		}
+		// * While there is data to be read * /
+		while (numByteToRead) {
+			/* Receive bytes from first byte until byte N-3 */
+			if (numByteToRead != 3) {
+				/* Poll on BTF to receive data because in polling mode we can not guarantee the
+				 EV7 software sequence is managed before the current byte transfer completes */
+				I2C_TimeOut = 1000;
+				while ((I2C1->SR1 & 0x00004) != 0x000004) {
+					if (I2C_TimeOut-- <= 0) {
+						return 1;
+					}
+				}
+				/* Read data */
+				*pBuffer = I2C1->DR;
+				pBuffer++;
+				/* Decrement the read bytes counter */
+				numByteToRead--;
+			}
+
+			/* it remains to read three data: data N-2, data N-1, Data N */
+			if (numByteToRead == 3) {
+				/* Wait until BTF is set: Data N-2 in DR and data N -1 in shift register */
+				I2C_TimeOut = 1000;
+				while ((I2C1->SR1 & 0x00004) != 0x000004) {
+					if (I2C_TimeOut-- <= 0) {
+						return 1;
+					}
+				}
+				/* Clear ACK */
+				I2C1->CR1 &= CR1_ACK_Reset;
+
+				/* Disable IRQs around data reading and STOP programming */
+				__disable_irq();
+				/* Read Data N-2 */
+				*pBuffer = I2C1->DR;
+				/* Increment */
+				pBuffer++;
+				/* Program the STOP */
+				I2C1->CR1 |= CR1_STOP_Set;
+				/* Read DataN-1 */
+				*pBuffer = I2C1->DR;
+				/* Re-enable IRQs */
+				__enable_irq();
+				/* Increment */
+				pBuffer++;
+				/* Wait until RXNE is set (DR contains the last data) */
+				I2C_TimeOut = 1000;
+				while ((I2C1->SR1 & 0x00040) != 0x000040) {
+					if (I2C_TimeOut-- <= 0) {
+						return 1;
+					}
+				}
+				/* Read DataN */
+				*pBuffer = I2C1->DR;
+				/* Reset the number of bytes to be read by master */
+				numByteToRead = 0;
+			}
+		}
 	}
-	return;
+
+	/* Make sure that the STOP bit is cleared by Hardware before CR1 write access */
+	I2C_TimeOut = 1000;
+	while ((I2C1->CR1 & 0x200) == 0x200) {
+		if (I2C_TimeOut-- <= 0) {
+			return 1;
+		}
+	}
+
+	// * Enable Acknowledgment to be ready for another reception * /
+	I2C_AcknowledgeConfig(I2C1, ENABLE);
+
+	return 0;
+
 }

--- a/workspace/ts100/src/Interrupt.c
+++ b/workspace/ts100/src/Interrupt.c
@@ -3,9 +3,10 @@
 #include "I2C.h"

 volatile uint32_t system_Ticks;
-volatile uint32_t lastKeyPress; //millis() at the last button event
-volatile uint8_t keyState; //tracks the button status
+volatile uint32_t BkeyChange; //millis() at the last button event
+volatile uint32_t AkeyChange;
 volatile uint8_t rawKeys;
+volatile uint8_t LongKeys;
 volatile uint32_t lastMovement; //millis() at last movement event

 //Delay in milliseconds using systemTick
@@ -14,6 +15,89 @@ void delayMs(uint32_t ticks) {
 	while (millis() < endtime)
 		;
 }
+uint32_t getLastButtonPress() {
+	if (BkeyChange > AkeyChange)
+		return BkeyChange;
+	return AkeyChange;
+}
+uint8_t getButtons() {
+	//We want to check the times for the lat buttons & also the rawKeys state
+	//If a key has just gone down, rawKeys & KEY ==1
+	uint8_t out = 0;
+	if (millis() - AkeyChange > 100) {
+		if (LongKeys & BUT_A) {
+			if (rawKeys & BUT_A) {
+				if (millis() - AkeyChange > 800) {
+					out |= BUT_A;
+					AkeyChange = millis();
+					LongKeys &= ~BUT_A;
+
+					LongKeys |= (BUT_A << 2);
+				}
+			} else {
+				LongKeys &= ~BUT_A;
+				LongKeys &= ~(BUT_A << 2);
+			}
+
+		} else if (LongKeys & (BUT_A << 2)) {
+			if (rawKeys & BUT_A) {
+				if (millis() - AkeyChange > 100) {
+					out |= BUT_A;
+					AkeyChange = millis();
+				}
+			} else {
+				LongKeys &= ~BUT_A;
+				LongKeys &= ~(BUT_A << 2);
+			}
+		} else {
+			if (rawKeys & BUT_A) {
+				//The key is down
+				out |= BUT_A;
+				LongKeys |= BUT_A;
+			} else {
+				//The key has been lifted
+				LongKeys &= ~BUT_A;
+				LongKeys &= ~(BUT_A << 2);
+			}
+		}
+	}
+	if (millis() - BkeyChange > 100) {
+		if (LongKeys & BUT_B) {
+			if (rawKeys & BUT_B) {
+				if (millis() - BkeyChange > 800) {
+					out |= BUT_B;
+					BkeyChange = millis();
+					LongKeys |= (BUT_B << 2);
+					LongKeys &= ~BUT_B;
+				}
+			} else {
+				LongKeys &= ~BUT_B;
+				LongKeys &= ~(BUT_B << 2);
+			}
+		} else if (LongKeys & (BUT_B << 2)) {
+			if (rawKeys & BUT_B) {
+				if (millis() - BkeyChange > 100) {
+					out |= BUT_B;
+					BkeyChange = millis();
+				}
+			} else {
+				LongKeys &= ~BUT_B;
+				LongKeys &= ~(BUT_B << 2);
+			}
+		} else {
+			if (rawKeys & BUT_B) {
+				//The key is down
+				out |= BUT_B;
+				LongKeys |= BUT_B;
+			} else {
+				//The key has been lifted
+				LongKeys &= ~BUT_B;
+				LongKeys &= ~(BUT_B << 2);
+			}
+		}
+	}
+	return out;
+}

 void NMI_Handler(void) {
 	;
@@ -57,23 +141,19 @@ void EXTI9_5_IRQHandler(void) {
 	//Line 5 == movement
 	if (EXTI_GetITStatus(EXTI_Line9) != RESET) {
 		if (GPIO_ReadInputDataBit(GPIOA, KEY_A) == SET) {
-			keyState &= ~(BUT_A);
 			rawKeys &= ~BUT_A;
 		} else {
-			keyState |= BUT_A;
 			rawKeys |= BUT_A;
-			lastKeyPress = millis();
 		}
+		AkeyChange = millis();
 		EXTI_ClearITPendingBit(EXTI_Line9);
 	} else if (EXTI_GetITStatus(EXTI_Line6) != RESET) {
 		if (GPIO_ReadInputDataBit(GPIOA, KEY_B) == SET) {
-			keyState &= ~(BUT_B);
 			rawKeys &= ~BUT_B;
 		} else {
-			keyState |= BUT_B;
 			rawKeys |= BUT_B;
-			lastKeyPress = millis();
 		}
+		BkeyChange = millis();
 		EXTI_ClearITPendingBit(EXTI_Line6);
 	} else if (EXTI_GetITStatus(EXTI_Line5) != RESET) {	//Movement Event
 		lastMovement = millis();
--- a/workspace/ts100/src/MMA8652FC.c
+++ b/workspace/ts100/src/MMA8652FC.c
@@ -23,24 +23,38 @@ void I2C_RegisterWrite(uint8_t reg, uint8_t data) {
 }

 uint8_t I2C_RegisterRead(uint8_t reg) {
-	u8 tx_data[3];
-	tx_data[0] = reg;
-	I2C_PageRead(tx_data, 1, DEVICE_ADDR, reg);
+	u8 tx_data[1];
+	I2C_Master_Read(DEVICE_ADDR << 1, reg, tx_data, 1);
 	return tx_data[0];
 }

+uint8_t getOrientation() {
+//First read the PL_STATUS register
+	uint8_t plStatus = I2C_RegisterRead(PL_STATUS_REG);
+	plStatus >>= 1; //We dont need the up/down bit
+	plStatus &= 0x03; //mask to the two lower bits
+	//0 == left handed
+	//1 == right handed
+
+	return plStatus;
+}
+
 void StartUp_Accelerometer(uint8_t sensitivity) {
 	I2C_RegisterWrite(CTRL_REG2, 0); //Normal mode
 	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
-	uint8_t sens = 9 * 7 + 5;
-	sens -= 7 * sensitivity;
+	uint8_t sens = 9 * 6 + 5;
+	sens -= 6 * sensitivity;

 	I2C_RegisterWrite(FF_MT_THS_REG, 0x80 | sens);		// Set threshold
 	I2C_RegisterWrite(FF_MT_COUNT_REG, 0x02);	// Set debounce to 100ms
-
+	I2C_RegisterWrite(PL_CFG_REG, 0x40);	//Enable the orientation detection
+	I2C_RegisterWrite(PL_COUNT_REG, 200);	//200 count debounce
+	I2C_RegisterWrite(PL_BF_ZCOMP_REG, 0b01000111);	//Set the threshold to 42 degrees
+	I2C_RegisterWrite(P_L_THS_REG, 0b10011100);//Up the trip angles
 	I2C_RegisterWrite( CTRL_REG4, 0x04);		// Enable motion interrupt
 	I2C_RegisterWrite( CTRL_REG5, 0x04);// Route motion interrupts to INT1 ->PB5 ->EXTI5
 	I2C_RegisterWrite( CTRL_REG1, 0x11);		// ODR=800 Hz, Active mode
+
 }
--- a/workspace/ts100/src/Main.c
+++ b/workspace/ts100/src/Main.c
@@ -18,7 +18,7 @@ int main(void) {
 		Clear_Watchdog(); //reset the Watch dog timer
 		ProcessUI();
 		DrawUI();
-		delayMs(50); //Slow the system down a little bit
+		delayMs(30); //Slow the system down a little bit
 		if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_5) == Bit_RESET) {
 			lastMovement = millis();
 			//This is a workaround for the line staying low as the user is still moving. (ie sensitivity is too high for their amount of movement)
@@ -38,10 +38,14 @@ void setup() {
 	StartUp_Accelerometer(systemSettings.sensitivity); //Start the accelerometer
 	setupPID(); 										//Init the PID values
 	readIronTemp(systemSettings.tempCalibration, 0, 0); //load the default calibration value
-	Init_Oled(systemSettings.flipDisplay); 				//Init the OLED display
+	if (systemSettings.OrientationMode == 2)
+		Init_Oled(0); 									//Init the OLED display in RH mode, since accel wont have started up yet
+	else
+		Init_Oled(systemSettings.OrientationMode); 		//Init the OLED display

-	OLED_DrawString("VER 1.15", 8); 					//Version Number
-	delayMs(300);								//Pause to show version number
+	OLED_DrawString("VER 1.16", 8); 					//Version Number
+	delayMs(400);						//Pause to show version number
 	showBootLogoIfavailable();
-	Start_Watchdog(1000); 		//start the system watch dog as 1 second timeout
+	Start_Watchdog(5000); //start the system watch dog as 5 second timeout
+
 }
--- a/workspace/ts100/src/Modes.c
+++ b/workspace/ts100/src/Modes.c
@@ -5,33 +5,31 @@
 *      Author: Ralim <ralim@ralimtek.com>
 */
 #include "Modes.h"
-const char *SettingsLongNames[] = {
-		"      Power source. Sets cutoff voltage. <DC 10V> <S 3.3V per cell>",
-		"      Sleep Temperature <C>", "      Sleep Timeout <Minutes>",
-		"      Shutdown Timeout <Minutes>",
-		"      Motion Sensitivity <0.Off 1.least sensitive 9.most sensitive>",
-		"      Temperature Unit", "      Temperature Rounding Amount",
-		"      Temperature Display Update Rate",
-		"      Flip Display for Left Hand",
-		"      Enable front key boost 450C mode when soldering",
-		"      Temperature when in boost mode" };
+const char *SettingsLongNames[] =
+		{ "      Power source. Sets cutoff voltage. <DC 10V> <S 3.3V per cell>",
+				"      Sleep Temperature <C>", "      Sleep Timeout <Minutes>",
+				"      Shutdown Timeout <Minutes>",
+				"      Motion Sensitivity <0.Off 1.least sensitive 9.most sensitive>",
+				"      Temperature Unit", "      Temperature Rounding Amount",
+				"      Temperature Display Update Rate",
+				"      Display Orientation <A. Automatic L. Left Handed R. Right Handed>",
+				"      Enable front key boost 450C mode when soldering",
+				"      Temperature when in boost mode",
+				"      Changes the arrows to a power display when soldering" };
 uint8_t StatusFlags = 0;
 uint32_t temporaryTempStorage = 0;
+
+operatingModeEnum operatingMode;
+settingsPageEnum settingsPage;
+
 //This does the required processing and state changes
 void ProcessUI() {
 	uint8_t Buttons = getButtons(); //read the buttons status
 	static uint32_t lastModeChange = 0;
-	if (getRawButtons() && ((millis() - getLastButtonPress()) > 1000)) {
-		lastKeyPress = millis() - 600;
-		Buttons = getRawButtons();
-	} else if (millis() - getLastButtonPress() < 80) {
-		Buttons = 0;
-	} else if (Buttons != 0) {
-		resetButtons();
-	}

 	switch (operatingMode) {
 	case STARTUP:
+
 		if (Buttons == (BUT_A | BUT_B)) {
 			operatingMode = THERMOMETER;
 		} else if (Buttons == BUT_A) {
@@ -104,23 +102,47 @@ void ProcessUI() {
 		}
 		break;
 	case TEMP_ADJ:
-		if (Buttons == BUT_A) {
-			//A key pressed so we are moving down in temp
+		if (OLED_GetOrientation() == 1) {
+			if (Buttons == BUT_B) {
+				//A key pressed so we are moving down in temp

-			if (systemSettings.SolderingTemp > 1000)
-				systemSettings.SolderingTemp -= 100;
-		} else if (Buttons == BUT_B) {
-			//B key pressed so we are moving up in temp
-			if (systemSettings.SolderingTemp < 4500)
-				systemSettings.SolderingTemp += 100;
+				if (systemSettings.SolderingTemp > 1000)
+					systemSettings.SolderingTemp -= 100;
+			} else if (Buttons == BUT_A) {
+				//B key pressed so we are moving up in temp
+				if (systemSettings.SolderingTemp < 4500)
+					systemSettings.SolderingTemp += 100;
+			} else {
+				//we check the timeout for how long the buttons have not been pushed
+				//if idle for > 3 seconds then we return to soldering
+				//Or if both buttons pressed
+				if (Buttons == (BUT_A | BUT_B)) {
+					operatingMode = STARTUP;
+					saveSettings();
+				} else if ((millis() - getLastButtonPress() > 2000)) {
+					operatingMode = SOLDERING;
+				}
+
+			}
 		} else {
-			//we check the timeout for how long the buttons have not been pushed
-			//if idle for > 3 seconds then we return to soldering
-			//Or if both buttons pressed
-			if ((millis() - getLastButtonPress() > 2000)
-					|| Buttons == (BUT_A | BUT_B)) {
-				operatingMode = SOLDERING;
-				saveSettings();
+			if (Buttons == BUT_A) {
+				//A key pressed so we are moving down in temp
+
+				if (systemSettings.SolderingTemp > 1000)
+					systemSettings.SolderingTemp -= 100;
+			} else if (Buttons == BUT_B) {
+				//B key pressed so we are moving up in temp
+				if (systemSettings.SolderingTemp < 4500)
+					systemSettings.SolderingTemp += 100;
+			} else {
+				//we check the timeout for how long the buttons have not been pushed
+				//if idle for > 3 seconds then we return to soldering
+				//Or if both buttons pressed
+				if ((millis() - getLastButtonPress() > 2000)
+						|| Buttons == (BUT_A | BUT_B)) {
+					operatingMode = SOLDERING;
+					saveSettings();
+				}
 			}
 		}
 		break;
@@ -152,7 +174,7 @@ void ProcessUI() {
 				case SLEEP_TEMP:
 					systemSettings.SleepTemp += 100;	//Go up 10C at a time
 					if (systemSettings.SleepTemp > 3000)
-						systemSettings.SleepTemp = 1000;//cant sleep higher than 300
+						systemSettings.SleepTemp = 500;	//cant sleep higher than 300 or less than 50
 					break;
 				case SLEEP_TIME:
 					++systemSettings.SleepTime;		//Go up 1 minute at a time
@@ -169,8 +191,11 @@ void ProcessUI() {
 					systemSettings.displayTempInF =
 							!systemSettings.displayTempInF;
 					break;
-				case LEFTY:
-					systemSettings.flipDisplay = !systemSettings.flipDisplay;
+				case SCREENROTATION:
+					systemSettings.OrientationMode++;
+					systemSettings.OrientationMode =
+							systemSettings.OrientationMode % 3;
+
 					break;
 				case MOTIONSENSITIVITY:
 					systemSettings.sensitivity++;
@@ -197,6 +222,23 @@ void ProcessUI() {
 					if (systemSettings.BoostTemp > 4500)
 						systemSettings.BoostTemp = 2500;	//loop back at 250
 					break;
+				case POWERDISPLAY:
+					systemSettings.powerDisplay = !systemSettings.powerDisplay;
+					break;
+#ifdef PIDTUNING
+					case PIDP:
+					pidSettings.kp++;
+					pidSettings.kp %= 20;
+					break;
+					case PIDI:
+					pidSettings.ki++;
+					pidSettings.ki %= 10;
+					break;
+					case PIDD:
+					pidSettings.kd++;
+					pidSettings.kd %= 30;
+					break;
+#endif
 				default:
 					break;
 				}
@@ -297,12 +339,12 @@ void ProcessUI() {
 		} else {
 			//User is calibrating the dc input
 			if (Buttons == BUT_A) {
-				if (!systemSettings.flipDisplay)
+				if (!systemSettings.OrientationMode)
 					systemSettings.voltageDiv++;
 				else
 					systemSettings.voltageDiv--;
 			} else if (Buttons == BUT_B) {
-				if (!systemSettings.flipDisplay)
+				if (!systemSettings.OrientationMode)
 					systemSettings.voltageDiv--;
 				else
 					systemSettings.voltageDiv++;
@@ -371,11 +413,15 @@ void drawTemp(uint16_t temp, uint8_t x, uint8_t roundingMode) {
 */
 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);
+	if (systemSettings.OrientationMode == 2) {
+		//Automatic mode
+		OLED_SetOrientation(!getOrientation());
+	}
 	switch (operatingMode) {
 	case STARTUP:
 		//We are chilling in the idle mode
@@ -427,28 +473,41 @@ void DrawUI() {
 			if (cellV < 33)
 				cellV = 33;
 			cellV -= 33;			//Should leave us a number of 0-9
+			if (cellV > 9)
+				cellV = 9;
 			OLED_DrawExtendedChar(cellV + 1, 5);
 		} else {
 			OLED_DrawChar(' ', 5);
 		}
-		OLED_BlankSlot(6 * 12 + 16, 24 - 16);//blank out the tail after the arrows
-		if (getIronTimer() == 0
-				&& (temp / 10) > (systemSettings.SolderingTemp / 10)) {
-			//Cooling
-			OLED_DrawSymbol(6, 5);
-		} else {
-			if (getIronTimer() < 1500) {
-				//Maintaining
-				OLED_DrawSymbol(6, 7);
-			} else {		//we are heating
-				OLED_DrawSymbol(6, 6);
-			}
-		}
 		if (systemSettings.displayTempInF) {
 			OLED_DrawChar('F', 3);
 		} else {
 			OLED_DrawChar('C', 3);
 		}
+		//Optionally draw the arrows, or draw the power instead
+		if (systemSettings.powerDisplay) {
+			//We want to draw in a neat little bar graph of power being pushed to the tip
+			//ofset 11
+			uint16_t count = getIronTimer() / (1000 / 28);
+			if (count > 28)
+				count = 28;
+			OLED_DrawWideChar((count), 6);
+		} else {
+			//Draw in the arrows if the user has the power display turned off
+			OLED_BlankSlot(6 * 12 + 16, 24 - 16);//blank out the tail after the arrows
+			if (getIronTimer() == 0
+					&& (temp / 10) > (systemSettings.SolderingTemp / 10)) {
+				//Cooling
+				OLED_DrawSymbol(6, 5);
+			} else {
+				if (getIronTimer() < 1500) {
+					//Maintaining
+					OLED_DrawSymbol(6, 7);
+				} else {		//we are heating
+					OLED_DrawSymbol(6, 6);
+				}
+			}
+		}

 	}
 		break;
@@ -518,12 +577,19 @@ void DrawUI() {
 				else
 					OLED_DrawString("TMPUNT C", 8);
 				break;
-			case LEFTY:
+			case SCREENROTATION:

-				if (systemSettings.flipDisplay)
-					OLED_DrawString("FLPDSP T", 8);
-				else
-					OLED_DrawString("FLPDSP F", 8);
+				switch (systemSettings.OrientationMode) {
+				case 0:
+					OLED_DrawString("DSPROT R", 8);
+					break;
+				case 1:
+					OLED_DrawString("DSPROT L", 8);
+					break;
+				case 2:
+					OLED_DrawString("DSPROT A", 8);
+					break;
+				}
 				break;
 			case MOTIONSENSITIVITY:
 				OLED_DrawString("MSENSE ", 7);
@@ -579,7 +645,32 @@ void DrawUI() {
 				OLED_DrawString("BTMP ", 5);
 				OLED_DrawThreeNumber(systemSettings.BoostTemp / 10, 5);
 				break;
+			case POWERDISPLAY:
+				switch (systemSettings.powerDisplay) {
+				case 1:
+					OLED_DrawString("PWRDSP T", 8);
+					break;
+				case 0:
+					OLED_DrawString("PWRDSP F", 8);
+					break;
+				}
+				break;
+#ifdef PIDTUNING
+				case PIDP:
+				OLED_DrawString("PIDP ", 5);
+				OLED_DrawThreeNumber(pidSettings.kp, 5);
+				break;
+				case PIDI:
+				OLED_DrawString("PIDI ", 5);
+				OLED_DrawThreeNumber(pidSettings.ki, 5);
+				break;
+				case PIDD:
+				OLED_DrawString("PIDD ", 5);
+				OLED_DrawThreeNumber(pidSettings.kd, 5);
+				break;
+#endif
 			default:
+
 				break;
 			}
 		}
@@ -587,7 +678,7 @@ void DrawUI() {
 	case SLEEP:
 		//The iron is in sleep temp mode
 		//Draw in temp and sleep
-		OLED_DrawString("SLP", 3);
+		OLED_DrawString("SLP ", 4);
 		drawTemp(temp, 4, systemSettings.temperatureRounding);
 		OLED_BlankSlot(84, 96 - 85);		//blank out after the temp

--- a/workspace/ts100/src/Oled.c
+++ b/workspace/ts100/src/Oled.c
@@ -14,10 +14,12 @@

 #include "Font.h"
 int8_t displayOffset = 32;
+uint8_t currentOrientation = 0;
 /*Setup params for the OLED screen*/
 /*http://www.displayfuture.com/Display/datasheet/controller/SSD1307.pdf*/
 /*All commands are prefixed with 0x80*/
-u8 OLED_Setup_Array[46] = { 0x80, 0xAE,/*Display off*/
+u8 OLED_Setup_Array[46] = { /**/
+0x80, 0xAE,/*Display off*/
 0x80, 0xD5,/*Set display clock divide ratio / osc freq*/
 0x80, 0x52,/*Unknown*/
 0x80, 0xA8,/*Set Multiplex Ratio*/
@@ -60,31 +62,25 @@ void Oled_DisplayOff(void) {

 	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;

-}
 /*
 Description: write a command to the Oled display
 Input: number of bytes to write, array to write
 Output:
 */
-const u8* Data_Command(u8 length,const u8* data) {
+const u8* Data_Command(u8 length, const u8* data) {
 	int i;
 	u8 tx_data[129];
 	//here are are inserting the data write command at the beginning
 	tx_data[0] = 0x40;
 	length++;
 	for (i = 1; i < length; i++) //Loop through the array of data
-		tx_data[i] = *data++;
+			{
+		if (data == 0)
+			tx_data[i] = 0;
+		else
+			tx_data[i] = *data++;
+	}
 	I2C_PageWrite(tx_data, length, DEVICEADDR_OLED); //write out the buffer
 	return data;
 }
@@ -107,7 +103,7 @@ void Set_ShowPos(u8 x, u8 y) {
 Inputs:(x,y) start point, (width,height) of enclosing rect, pointer to data
 Output: pointer to the last byte written out
 *******************************************************************************/
-const u8* Oled_DrawArea(u8 x0, u8 y0, u8 wide, u8 high,const u8* ptr) {
+const u8* Oled_DrawArea(u8 x0, u8 y0, u8 wide, u8 high, const u8* ptr) {
 	u8 m, n, y;

 	n = y0 + high;
@@ -145,17 +141,22 @@ void GPIO_Init_OLED(void) {
 Description: Initializes the Oled screen
 *******************************************************************************/
 void Init_Oled(uint8_t leftHanded) {
-	u8 param_len;

+	currentOrientation = leftHanded;
+	u8 param_len;
 	OLED_RST();
 	delayMs(5);
 	OLED_ACT(); //Toggling reset to reset the oled
 	delayMs(5);
 	param_len = 46;
-	if (leftHanded) {
+	if (leftHanded == 1) {
 		OLED_Setup_Array[11] = 0xC8;
 		OLED_Setup_Array[19] = 0xA1;
 		displayOffset = 0;
+	} else if (leftHanded == 0) {
+		OLED_Setup_Array[11] = 0xC0;
+		OLED_Setup_Array[19] = 0x40;
+		displayOffset = 32;
 	}
 	I2C_PageWrite((u8 *) OLED_Setup_Array, param_len, DEVICEADDR_OLED);
 }
@@ -216,6 +217,14 @@ void OLED_DrawExtendedChar(uint8_t id, uint8_t x) {

 	Oled_DrawArea(x, 0, FONT_WIDTH, 16, (u8*) ptr);
 }
+
+void OLED_DrawWideChar(uint8_t id, uint8_t x) {
+	u8* ptr = (u8*) DoubleWidthChars;
+	ptr += (id) * (FONT_WIDTH * 4);
+	x *= FONT_WIDTH; //convert to a x coordinate
+
+	Oled_DrawArea(x, 0, FONT_WIDTH * 2, 16, (u8*) ptr);
+}
 void OLED_BlankSlot(uint8_t xStart, uint8_t width) {
 	u8* ptr = (u8*) FONT;
 	ptr += (36) * (FONT_WIDTH * 2);
@@ -274,3 +283,15 @@ void OLED_DrawIDLELogo() {
 void OLED_DrawSymbol(uint8_t x, uint8_t symbol) {
 	Oled_DrawArea(x * FONT_WIDTH, 0, 16, 16, SymbolTable + (symbol * 32));
 }
+
+void OLED_SetOrientation(uint8_t ori) {
+	if (ori > 1)
+		return;
+	if (ori != currentOrientation) {
+		Init_Oled(ori);
+	}
+}
+
+uint8_t OLED_GetOrientation() {
+	return currentOrientation;
+}
--- a/workspace/ts100/src/PID.c
+++ b/workspace/ts100/src/PID.c
@@ -7,35 +7,40 @@

 #include "PID.h"
 #define MAXPIDOUTPUT 50000
+//MAXPIDOUTPUT is the maximum time duration we can support for the irons output, as anything longer than this will be cut off by the next PID iteration
+
+pidSettingsType pidSettings;
+
 //This function computes the new value for the ON time of the system
 //This is the return value from this function
 int32_t computePID(uint16_t setpoint) {
-	int32_t ITerm = 0;
-	static int16_t lastReading = 0;
-	uint16_t currentReading = readIronTemp(0, 1,setpoint); //get the current temp of the iron
+	static int32_t ITerm = 0; //Used to store the integral error
+	static int16_t lastError = 0;
+	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/2)
-		ITerm = MAXPIDOUTPUT/2;
-	else if (ITerm < 0)
-		ITerm = 0; //cap at 0 since we cant force the iron to cool itself :)
+	int16_t DInput = (error - lastError) / 10; //compute the input to the D term

-	int16_t DInput = (currentReading - lastReading); //compute the input to the D term
-	int32_t output = (pidSettings.kp * error) + (ITerm)
+	ITerm += ((error) / 20);
+	if (ITerm > 300)
+		ITerm = 0; //Prevents this accumulating too much during inital heatup
+	else if (ITerm < 0)
+		ITerm = 0; //Cap at 0 as we can't force cool
+	if (DInput > 1000)
+		DInput = 0;
+	int32_t output = (pidSettings.kp * error) + (ITerm * pidSettings.ki)
 			- (pidSettings.kd * DInput);
 	if (output > MAXPIDOUTPUT)
 		output = MAXPIDOUTPUT;
 	else if (output < 0)
 		output = 0;
-
-	lastReading = currentReading; //storing values for next iteration of the loop
+	lastError = error;
 	return output;

 }
-/*Sets up the pid values*/
+/*Sets up the pid values to  defaults*/
 void setupPID(void) {
-	pidSettings.kp = 15;
-	pidSettings.ki = 2;
-	pidSettings.kd = 3;
+	pidSettings.kp = 8;
+	pidSettings.ki = 1;
+	pidSettings.kd = 0; //Not using D atm

 }
--- a/workspace/ts100/src/Settings.c
+++ b/workspace/ts100/src/Settings.c
@@ -10,6 +10,9 @@
 #include "Settings.h"
 #define FLASH_ADDR 		(0x8000000|0xBC00)/*Flash start OR'ed with the maximum amount of flash - 1024 bytes*/
 #define FLASH_LOGOADDR 	(0x8000000|0xB800) /*second last page of flash set aside for logo image*/
+
+systemSettingsType systemSettings;
+
 void saveSettings() {
 	//First we erase the flash
 	FLASH_Unlock(); //unlock flash writing
@@ -61,7 +64,7 @@ void resetSettings() {
 	systemSettings.cutoutSetting = 0;			//default to no cut-off voltage
 	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
+	systemSettings.OrientationMode = 2;				//Default to automatic
 	systemSettings.sensitivity = 6;				//Default high sensitivity
 	systemSettings.tempCalibration = 239;	//Default to their calibration value
 	systemSettings.voltageDiv = 144;			//Default divider from schematic
@@ -70,6 +73,7 @@ void resetSettings() {
 	systemSettings.temperatureRounding = 0;	//How the temperature is rounded off
 	systemSettings.boostModeEnabled = 0;//Default to safe, with no boost mode
 	systemSettings.BoostTemp = 4000;				//default to 400C
+	systemSettings.powerDisplay = 0;		//default to power display being off
 }

 void showBootLogoIfavailable() {
@@ -87,16 +91,16 @@ void showBootLogoIfavailable() {

 	}
 	/*char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
-			'C', 'D', 'E', 'F' };
+	 'C', 'D', 'E', 'F' };

-	OLED_DrawChar(hex[(temp8[0] >> 4) & 0x0F], 0);
-	OLED_DrawChar(hex[(temp8[0] >> 0) & 0x0F], 1);
-	OLED_DrawChar(hex[(temp8[1] >> 4) & 0x0F], 2);
-	OLED_DrawChar(hex[(temp8[1] >> 0) & 0x0F], 3);
-	OLED_DrawChar(hex[(temp8[2] >> 4) & 0x0F], 4);
-	OLED_DrawChar(hex[(temp8[2] >> 0) & 0x0F], 5);
-	OLED_DrawChar(hex[(temp8[3] >> 4) & 0x0F], 6);
-	OLED_DrawChar(hex[(temp8[3] >> 0) & 0x0F], 7);*/
+	 OLED_DrawChar(hex[(temp8[0] >> 4) & 0x0F], 0);
+	 OLED_DrawChar(hex[(temp8[0] >> 0) & 0x0F], 1);
+	 OLED_DrawChar(hex[(temp8[1] >> 4) & 0x0F], 2);
+	 OLED_DrawChar(hex[(temp8[1] >> 0) & 0x0F], 3);
+	 OLED_DrawChar(hex[(temp8[2] >> 4) & 0x0F], 4);
+	 OLED_DrawChar(hex[(temp8[2] >> 0) & 0x0F], 5);
+	 OLED_DrawChar(hex[(temp8[3] >> 4) & 0x0F], 6);
+	 OLED_DrawChar(hex[(temp8[3] >> 0) & 0x0F], 7);*/
 	if (temp8[0] != 0xAA)
 		return;
 	if (temp8[1] != 0x55)
@@ -106,7 +110,6 @@ void showBootLogoIfavailable() {
 	if (temp8[3] != 0x0D)
 		return;

-
 	Oled_DrawArea(0, 0, 96, 16, (uint8_t*) (temp8 + 4));

 	delayMs(1000);
Author	SHA1	Message	Date
Ben V. Brown	90599a8ae6	Retune PID, improve response rate slightly. (But slightly more oscillation)	2017-08-02 21:38:42 +10:00
Ben V. Brown	b0264be3c5	Better button auto-repeat	2017-07-30 21:25:27 +10:00
Ben V. Brown	4fb7a70e3c	More explicit left handed checks	2017-07-30 20:02:58 +10:00
Ben V. Brown	535a1b3aa9	Making the auto-flip less sensitive #34	2017-07-27 20:29:17 +10:00
Ben V. Brown	5a26bf413a	Update README.md	2017-07-27 11:52:28 +10:00
Ben V. Brown	1cbcba924f	Adding auto-rotation to the screen Adds auto rotation support using the proper orientation detection. (Not using raw values). Should Fix and close #29	2017-07-27 11:46:04 +10:00
Ben V. Brown	af9b8dca29	Working rough indicator of power	2017-07-26 22:05:54 +10:00
Ben V. Brown	965a0890cb	Add toggle for power display	2017-07-26 09:47:26 +10:00
mkninc	2e823b6594	Quick fix for multiple definition of structs (#33 )	2017-07-26 09:18:41 +10:00
Ben V. Brown	56f31b02aa	pre-work for power display	2017-07-26 09:18:07 +10:00
Ben V. Brown	2d260bd62c	Add youtube link	2017-07-25 10:08:01 +10:00
Ben V. Brown	379eb68ce4	Update README.md	2017-07-25 09:48:22 +10:00
Ben V. Brown	f077c0241f	Fix order of definitions for some variables	2017-07-25 08:28:33 +10:00
Ben V. Brown	7bedad5d51	Fix readme error	2017-07-24 23:08:08 +10:00
Ben V. Brown	8a503f84e2	Cleaning up files Fixing warnings Add powerDisplayToggle	2017-07-24 23:03:56 +10:00
Ben V. Brown	f89fd5c651	Merge branch 'master' of github.com:Ralim/ts100	2017-07-24 22:55:49 +10:00
Ben V. Brown	3983bf8590	Fix buttons in left handed mode when user is changing the temperature. As pointed out in #29 Clear the leftover temperature unit on the sleep screen.	2017-07-24 22:54:30 +10:00
Ben V. Brown	c1fb867fa9	Update README.md	2017-07-23 17:22:01 +10:00
Ben V. Brown	2c5a83c134	Tiny patch for as mentioned in #30	2017-07-23 17:03:17 +10:00