HT16K33 - fix printFloat

Author: RobTillaart

libraries/HT16K33/HT16K33.cpp

@@ -1,80 +1,115 @@
 //
 //    FILE: HT16K33.cpp
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.4
+// VERSION: 0.2.1
 //    DATE: 2019-02-07
-// PURPOSE: Class for HT16K33
+// PURPOSE: Arduino Library for HT16K33 4x7segment display
+//     URL: https://github.com/RobTillaart/HT16K33
 //
 // HISTORY:
-// 0.1.0 - 2019-02-07 initial version
-// 0.1.1 - 2019-02-07 first stable version
-// 0.1.2 - 2019-02-11 optimized performance
-// 0.1.3 - 2019-10-07 fixed clear, added suppressLeadingZeroPlaces();
-// 0.1.4 - 2019-11-28 added displayRaw(), displayVULeft(), displayVURight()
-//
-// Released to the public domain
-//
+// 0.1.0   2019-02-07 initial version
+// 0.1.1   2019-02-07 first stable version
+// 0.1.2   2019-02-11 optimized performance
+// 0.1.3   2019-10-07 fixed clear, added suppressLeadingZeroPlaces();
+// 0.1.4   2019-11-28 added displayRaw(), displayVULeft(), displayVURight()
+// 0.1.5   2019-11-30 refactor,
+// 0.2.0   2020-06-13 ESP32 support; fix brightness bug;
+// 0.2.1   2020-07-15 fix #160 - decimal point
 
 #include "HT16K33.h"
 
-#define HT16K33_ON              0x21 // 0=off 1=on
-#define HT16K33_STANDBY         0x20 // bit xxxxxxx0
-
-#define HT16K33_DISPLAYON       0x81 // 0=off 1=on
-#define HT16K33_DISPLAYOFF      0x80 // bit xxxxxxx0
-
-#define HT16K33_BLINKON1HZ      0x85 // 00=off 01=2Hz 10=1Hz 11=0.5Hz
-#define HT16K33_BLINKOFF        0x81 // bit xxxxx21x
-
-#define HT16K33_BRIGHTNESS      0xE0 // mask to be ored with 0x00 - 0x0F
-
-#define HT16K33_SPACE           16
-#define HT16K33_NONE            17
-
-// TODO PROGMEM ?
-static const uint8_t charmap[] = {
-  0x3F, // 0
-  0x06, // 1
-  0x5B, // 2
-  0x4F, // 3
-  0x66, // 4
-  0x6D, // 5
-  0x7D, // 6
-  0x07, // 7
-  0x7F, // 8
-  0x6F, // 9
-  0x77, // A
-  0x7C, // B
-  0x39, // C
-  0x5E, // D
-  0x79, // E
-  0x71, // F
-  0x00, // space
+// Commands
+#define HT16K33_ON              0x21  // 0=off 1=on
+#define HT16K33_STANDBY         0x20  // bit xxxxxxx0
+
+// bit pattern 1000 0xxy
+// y    =  display on / off
+// xx   =  00=off     01=2Hz     10=1Hz     11=0.5Hz
+#define HT16K33_DISPLAYON       0x81
+#define HT16K33_DISPLAYOFF      0x80
+#define HT16K33_BLINKON0_5HZ    0x87
+#define HT16K33_BLINKON1HZ      0x85
+#define HT16K33_BLINKON2HZ      0x83
+#define HT16K33_BLINKOFF        0x81
+
+// bit pattern 1110 xxxx
+// xxxx    =  0000 .. 1111 (0 - F)
+#define HT16K33_BRIGHTNESS      0xE0
+
+// Special characters
+#define HT16K33_SPACE            16
+#define HT16K33_MINUS            17
+#define HT16K33_NONE             99
+
+//
+//  HEX codes 7 segment
+//
+//      01
+//  20      02
+//      40
+//  10      04
+//      08
+//
+static const uint8_t charmap[] = {  // TODO PROGMEM ?
+
+  0x3F,   // 0
+  0x06,   // 1
+  0x5B,   // 2
+  0x4F,   // 3
+  0x66,   // 4
+  0x6D,   // 5
+  0x7D,   // 6
+  0x07,   // 7
+  0x7F,   // 8
+  0x6F,   // 9
+  0x77,   // A
+  0x7C,   // B
+  0x39,   // C
+  0x5E,   // D
+  0x79,   // E
+  0x71,   // F
+  0x00,   // space
+  0x40,   // minus
 };
 
 ////////////////////////////////////////////////////
 
-HT16K33::HT16K33()
+HT16K33::HT16K33(const uint8_t address)
 {
+  _addr = address;
 }
 
-void HT16K33::begin(const uint8_t address)
+#if defined (ESP8266) || defined(ESP32)
+void HT16K33::begin(uint8_t sda, uint8_t scl)
+{
+  Wire.begin(sda, scl);
+  reset();
+}
+#endif
+
+void HT16K33::begin()
+{
+  Wire.begin();
+  reset();
+}
+
+void HT16K33::reset()
 {
-  _addr = address;
   displayOn();
   displayClear();
   suppressLeadingZeroPlaces(3);
   for (uint8_t i = 0; i < 5; i++)
   {
     _displayCache[i] = HT16K33_NONE;
   }
+  brightness(8);
 }
 
 void HT16K33::displayOn()
 {
   writeCmd(HT16K33_ON);
   writeCmd(HT16K33_DISPLAYON);
-  brightness(8);
+  brightness(_bright);  // TODO needed?
 }
 
 void HT16K33::displayOff()
@@ -85,14 +120,17 @@ void HT16K33::displayOff()
 
 void HT16K33::blink(uint8_t val)
 {
+  // TODO cache blink state too?
   if (val > 0x03) val = 0x00;
   writeCmd(HT16K33_BLINKOFF | (val << 1) );
 }
 
 void HT16K33::brightness(uint8_t val)
 {
-  if (val > 0x0F) val = 0x0F;
-  writeCmd(HT16K33_BRIGHTNESS | val);
+  if (val == _bright) return;
+  _bright = val;
+  if (_bright > 0x0F) _bright = 0x0F;
+  writeCmd(HT16K33_BRIGHTNESS | _bright);
 }
 
 void HT16K33::suppressLeadingZeroPlaces(uint8_t val)
@@ -155,14 +193,16 @@ void HT16K33::displayTime(uint8_t left, uint8_t right)
 // TODO x.yEz
 void HT16K33::displayFloat(float f)
 {
-  int pt = 0;
   // uint8_t neg = 0;
   // if (f < 0) { neg = -1; f = -f; }
   if (f > 9999 || f < 0 ) return;
-  int w = round(f);
-  if (w > 9) pt = 1;
-  if (w > 99) pt = 2;
-  if (w > 999) pt = 3;
+  int w = f;
+
+  int pt = 3;
+  if (w < 1000) pt = 2; 
+  if (w < 100) pt = 1; 
+  if (w < 10) pt = 0;
+
   if (f >= 1)
   {
     while (f < 1000) f *= 10;
@@ -211,15 +251,15 @@ void HT16K33::displayVULeft(uint8_t val)
   {
     if (val >= 2)
     {
-      ar[idx] = 0x36;   	//   ||
+      ar[idx] = 0x36;       //   ||
       val -= 2;
     }
     else if (val == 1)
     {
-      ar[idx] = 0x06;    	//   _|
+      ar[idx] = 0x06;        //   _|
       val = 0;
     }
-    else ar[idx] = 0x00; 	//   __
+    else ar[idx] = 0x00;     //   __
   }
   displayRaw(ar);
 }
@@ -231,15 +271,15 @@ void HT16K33::displayVURight(uint8_t val)
   {
     if (val >= 2)
     {
-      ar[idx] = 0x36;   	//   ||
+      ar[idx] = 0x36;       //   ||
       val -= 2;
     }
     else if (val == 1)
     {
-      ar[idx] = 0x30;    	//   |_
+      ar[idx] = 0x30;        //   |_
       val = 0;
     }
-    else ar[idx] = 0x00; 	//   __
+    else ar[idx] = 0x00;     //   __
   }
   displayRaw(ar);
 }
@@ -262,6 +302,14 @@ void HT16K33::display(uint8_t *arr)
 
 void HT16K33::display(uint8_t *arr, uint8_t pnt)
 {
+  // to debug without display
+  // Serial.print(arr[0]);
+  // Serial.print(arr[1]);
+  // Serial.print(arr[2]);
+  // Serial.print(arr[3]);
+  // Serial.print(" ");
+  // Serial.println(pnt);
+
   writePos(0, charmap[arr[0]], pnt == 0);
   writePos(1, charmap[arr[1]], pnt == 1);
   writePos(3, charmap[arr[2]], pnt == 2);
@@ -274,7 +322,9 @@ void HT16K33::displayColon(uint8_t on)
 }
 
 //////////////////////////////////////////////////////////
-
+//
+// PRIVATE
+//
 void HT16K33::writeCmd(uint8_t cmd)
 {
   Wire.beginTransmission(_addr);
@@ -298,4 +348,4 @@ void HT16K33::writePos(uint8_t pos, uint8_t mask, bool pnt)
   writePos(pos, mask);
 }
 
-// -- END OF FILE --
+// -- END OF FILE --

libraries/HT16K33/HT16K33.h

@@ -1,52 +1,55 @@
+#pragma once
 //
 //    FILE: HT16K33.h
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.4
+// VERSION: 0.2.1
 //    DATE: 2019-02-07
-// PURPOSE: Class for HT16K33 7segment I2C display
+// PURPOSE: Arduino Library for HT16K33 4x7segment display
 //          http://www.adafruit.com/products/1002
-//     URL: https://github.com/RobTillaart/Arduino.git
+//     URL: https://github.com/RobTillaart/HT16K33.git
 //
-// Released to the public domain
-//
-//   TODO: negative values
-//
-
-#ifndef HT16K33_h
-#define HT16K33_h
 
 #include "Arduino.h"
 #include "Wire.h"
 
-#define HT16K33_LIB_VERSION "0.1.4"
+#define HT16K33_LIB_VERSION "0.2.1"
 
 class HT16K33
 {
-  public:
-  HT16K33();
+public:
+  HT16K33(const uint8_t address);           // 0x70 .. 0x77
+
+#if defined (ESP8266) || defined(ESP32)
+  void begin(uint8_t sda, uint8_t scl);
+#endif
+  void begin();
+  void reset();
 
-  void begin(const uint8_t address);        // 0x70 .. 0x77
   void displayOn();
   void displayOff();
+
   void brightness(uint8_t val);             // 0 .. 15
   void blink(uint8_t val);                  // 0 .. 3     0 = off
-  void suppressLeadingZeroPlaces(uint8_t val);  // 0 = off, 1,2,3,4 digits  space iso 0
+
+  // 0 = off, 1,2,3,4 digits  space iso 0
+  void suppressLeadingZeroPlaces(uint8_t val);
 
   void displayClear();
   void displayInt(int n);                   // 0000 .. 9999
   void displayHex(uint16_t n);              // 0000 .. FFFF
   void displayTime(uint8_t left, uint8_t right);    // 00:00 .. 99:99
-  void displayFloat(float f);               // 0.000 .. 9999.
+  void displayFloat(float f);               // 0.000 .. 9999
+
   void display(uint8_t *arr);               // array with 4 elements
   void display(uint8_t *arr, uint8_t pt);   // pt = digit with . (0..3)
   void displayColon(uint8_t on);            // 0 = off
 
-  void displayTest(uint8_t del);
-  void displayRaw(uint8_t *arr);			// control
-  void displayVULeft(uint8_t val);			// 0..8
-  void displayVURight(uint8_t val);			// 0..8
+  void displayTest(uint8_t del);            // debug
+  void displayRaw(uint8_t *arr);            // max control
+  void displayVULeft(uint8_t val);          // 0..8
+  void displayVURight(uint8_t val);         // 0..8
 
-  private:
+private:
 
   void writeCmd(uint8_t cmd);
   void writePos(uint8_t pos, uint8_t mask);
@@ -55,7 +58,7 @@ class HT16K33
   uint8_t _addr;
   uint8_t _displayCache[5];                 // for performance
   uint8_t _leadingZeroPlaces;
+  uint8_t _bright;
 };
 
-#endif
-// -- END OF FILE --
+// -- END OF FILE --

libraries/HT16K33/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2020 Rob Tillaart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.