Revision 0:420d710da1c5, committed 2015-02-08

Comitter:

morecat_lab

Date:

Sun Feb 08 11:51:48 2015 +0000

Commit message:

1st release

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Stnseg.cpp	Sun Feb 08 11:51:48 2015 +0000
@@ -0,0 +1,316 @@
+/*
+  Stnseg.cpp - mbed library for 4/6/8 digit Sixteen (16) segment LED driver.
+  Copyright 2015 by morecat_lab
+  
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+*/
+
+#include "Stnseg.h"
+#include <Timer.h>
+
+const uint16_t Stnseg::numConv[] = {
+    NUM_PAT16_0, NUM_PAT16_1, NUM_PAT16_2, NUM_PAT16_3,
+    NUM_PAT16_4, NUM_PAT16_5, NUM_PAT16_6, NUM_PAT16_7,
+    NUM_PAT16_8, NUM_PAT16_9, NUM_PAT16_A, NUM_PAT16_B,
+    NUM_PAT16_C, NUM_PAT16_D, NUM_PAT16_E, NUM_PAT16_F};
+
+
+// 4 digit
+Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
+           PinName d1,PinName d2, PinName d3, PinName d4) :
+           _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
+           _digPins(d1, d2, d3, d4)
+{
+    _numOfDigs = 4;
+    _updateInterval = (8333 / 4);
+    _zeroSupress = true;
+    _kcommon = false;
+}
+
+// 6 digit
+Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
+           PinName d1,PinName d2, PinName d3, PinName d4,
+           PinName d5,PinName d6) :
+           _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
+           _digPins(d1, d2, d3, d4, d5, d6)
+{
+    _numOfDigs = 6;
+    _updateInterval = (8333 / 6);
+    _zeroSupress = true;
+    _kcommon = false;
+}
+
+// 8 digit
+Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
+           PinName d1,PinName d2, PinName d3, PinName d4,
+           PinName d5,PinName d6, PinName d7, PinName d8) :
+           _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
+           _digPins(d1, d2, d3, d4, d5, d6, d7, d8)
+{
+    _numOfDigs = 8;
+    _updateInterval = (8333 / 8);
+    _zeroSupress = true;
+    _kcommon = false;
+}
+
+
+void Stnseg::begin(void) {
+    timer.start();
+    clear();
+}
+
+void Stnseg::setAcommon(void) {
+    _kcommon = false;
+}
+
+void Stnseg::setKcommon(void) {
+    _kcommon = true;
+}
+
+uint16_t Stnseg::segCh(char i) {
+    return numConv[i];
+}
+
+void Stnseg::setDot(int d) {
+    _buffer[d] |= 0x010000;
+}
+
+void Stnseg::clearDot(int d) {
+    _buffer[d] &= 0xfffe0000;
+}
+
+void Stnseg::writeNum(int n) {
+    if (_numOfDigs == 4) {
+        writeNum4(n);
+    } else if (_numOfDigs == 6) {
+        writeNum6(n);
+    } else if (_numOfDigs == 8) {
+        writeNum8((long)n);
+    }
+}
+
+
+void Stnseg::writeNum4(int n) {
+    if (n < 10000) {
+        _buffer[0] = segCh((n % 10000) / 1000);
+        _buffer[1] = segCh((n % 1000) / 100);
+        _buffer[2] = segCh((n % 100) / 10);
+        _buffer[3] = segCh(n % 10);
+        supressZero();
+    } else {
+        _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = NUM_PAT16_MINUS;// overflow
+    }
+}
+
+void Stnseg::writeNum6(int n) {
+    if (n < 10000) {
+        _buffer[0] = segCh((n % 1000000) / 100000);
+        _buffer[1] = segCh((n % 100000) / 10000);
+        _buffer[2] = segCh((n % 10000) / 1000);
+        _buffer[3] = segCh((n % 1000) / 100);
+        _buffer[4] = segCh((n % 100) / 10);
+        _buffer[5] = segCh(n % 10);
+        supressZero();
+    } else {
+        _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = NUM_PAT16_MINUS;// overflow
+    }
+}
+
+void Stnseg::writeNum8(int n) {
+    if (n < 1000000) {
+        _buffer[0] = segCh((n % 100000000) / 10000000);
+        _buffer[1] = segCh((n % 10000000) / 1000000);
+        _buffer[2] = segCh((n % 1000000) / 100000);
+        _buffer[3] = segCh((n % 100000) / 10000);
+        _buffer[4] = segCh((n % 10000) / 1000);
+        _buffer[5] = segCh((n % 1000) / 100);
+        _buffer[6] = segCh((n % 100) / 10);
+        _buffer[7] = segCh(n % 10);
+        supressZero();
+    } else {
+        _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = _buffer[4] = _buffer[5] = NUM_PAT16_MINUS;// overflow
+    }
+}
+
+void Stnseg::writeNum(char d1, char d2) {
+    _buffer[0] = segCh(d1);
+    _buffer[1] = segCh(d2);
+    supressZero();
+}
+
+void Stnseg::writeNum(char d1, char d2, char d3, char d4) {
+    _buffer[0] = segCh(d1);
+    _buffer[1] = segCh(d2);
+    _buffer[2] = segCh(d3);
+    _buffer[3] = segCh(d4);
+    supressZero();
+}
+
+void Stnseg::writeNum(char d1, char d2, char d3, char d4,
+                    char d5, char d6, char d7, char d8)
+{
+    _buffer[0] = segCh(d1);
+    _buffer[1] = segCh(d2);
+    _buffer[2] = segCh(d3);
+    _buffer[3] = segCh(d4);
+    _buffer[4] = segCh(d5);
+    _buffer[5] = segCh(d6);
+    _buffer[6] = segCh(d7);
+    _buffer[7] = segCh(d8);
+    supressZero();
+}
+
+void Stnseg::writeHex(long n) {
+    if (_numOfDigs == 4) {
+        _buffer[0] = segCh((n >> 12) & 0xf);
+        _buffer[1] = segCh((n >> 8) & 0xf);
+        _buffer[2] = segCh((n >> 4) & 0xf);
+        _buffer[3] = segCh(n & 0xf);
+    } else if (_numOfDigs == 6) {
+        _buffer[0] = segCh((n >> 20) & 0xf);
+        _buffer[1] = segCh((n >> 16) & 0xf);
+        _buffer[2] = segCh((n >> 12) & 0xf);
+        _buffer[3] = segCh((n >> 8) & 0xf);
+        _buffer[4] = segCh((n >> 4) & 0xf);
+        _buffer[5] = segCh(n & 0xf);
+    } else if (_numOfDigs == 8) {
+        _buffer[0] = segCh((n >> 28) & 0xf);
+        _buffer[1] = segCh((n >> 24) & 0xf);
+        _buffer[2] = segCh((n >> 20) & 0xf);
+        _buffer[3] = segCh((n >> 16) & 0xf);
+        _buffer[4] = segCh((n >> 12) & 0xf);
+        _buffer[5] = segCh((n >> 8) & 0xf);
+        _buffer[6] = segCh((n >> 4) & 0xf);
+        _buffer[7] = segCh(n & 0xf);
+    }
+    supressZero();
+}
+
+void Stnseg::setZeroSupress(bool t) {
+    _zeroSupress = t;
+}
+
+void Stnseg::supressZero() {
+    int i;
+    if (_zeroSupress ) {
+        for (i = 0 ; i < (_numOfDigs-1) ; i++) {
+            if (_buffer[i] == segCh(0)) {
+                _buffer[i] = _buffer[i] & 0x1000;
+            } else {
+                break;
+            }
+        }
+    }
+}
+
+void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4) {
+    _buffer[0] = d1;
+    _buffer[1] = d2;
+    _buffer[2] = d3;
+    _buffer[3] = d4;
+}
+
+void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4,
+                          uint32_t d5, uint32_t d6) {
+    _buffer[0] = d1;
+    _buffer[1] = d2;
+    _buffer[2] = d3;
+    _buffer[3] = d4;
+    _buffer[4] = d5;
+    _buffer[5] = d6;
+}
+void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4,
+                          uint32_t d5, uint32_t d6, uint32_t d7, uint32_t d8) {
+    _buffer[0] = d1;
+    _buffer[1] = d2;
+    _buffer[2] = d3;
+    _buffer[3] = d4;
+    _buffer[4] = d5;
+    _buffer[5] = d6;
+    _buffer[6] = d7;
+    _buffer[7] = d8;
+}
+
+void Stnseg::write(uint8_t d, uint32_t value) {
+    _buffer[d] = value;
+}
+
+void Stnseg::clear(void) {
+    int i;
+    for(i=0;i<8;i++){
+        _buffer[i] = 0;
+    }
+    _dig = _numOfDigs - 1;
+    _digPins = ( _kcommon) ? 0xff : 0;
+}
+
+void Stnseg::turnOff(void) {
+    if ( _kcommon) {
+        _digPins = 0xff;   // set HIGH
+    } else {
+        _digPins = 0;  // set LOW
+    }
+}
+
+void Stnseg::turnOn(void) {
+    if ( _kcommon) {
+        _digPins = ~(1 << _dig); // set LOW
+    } else {
+        _digPins = (1 << _dig); // set HIGH
+     }
+}
+
+void Stnseg::updateSeg(void) {
+    if( (++_dig) >= _numOfDigs)
+        _dig = 0;
+    _latchPin = 0;
+    for (int col = 0 ; col < 16 ; col++) {  // forward order
+        _clockPin = 0;
+        if(_buffer[_dig] & (1 << col)){
+            _dataPin = 1;
+        } else {
+            _dataPin = 0;
+        }
+        _clockPin = 1;
+    }
+    _latchPin = 1;
+    if ((_buffer[_dig] & 0x10000) != 0) {
+        _dpPin = 1;
+    } else {
+        _dpPin = 0;
+    }
+}
+
+void Stnseg::updateWithDelay(int ms) {
+    timer.reset();  // to avoid overflow 32bit counter  (~=30min)
+    int start = timer.read_ms();
+    _dig = _numOfDigs - 1;
+    turnOff();
+    do {
+        for (int i = 0 ; i < _numOfDigs ; i++) {
+            updateSeg();
+            turnOn();
+            wait(0.001f); // wait 1ms
+            turnOff();
+        }
+        if ((timer.read_ms() - start) >= ms) {
+            break;
+        }
+    } while(1);
+}
+
+void Stnseg::updateOnce(void) {
+    uint8_t i;
+    _dig = _numOfDigs - 1;
+    turnOff();
+    for (i = 0 ; i < _numOfDigs ; i++) {
+        updateSeg();
+        turnOn();
+        wait(0.001f); // wait 1ms
+        turnOff();
+    }
+}
+
+// EOF

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Stnseg.h	Sun Feb 08 11:51:48 2015 +0000
@@ -0,0 +1,326 @@
+/*
+  Stnseg.cpp - mbed library for 2/4/8 digit Sixteen (16) segment LED driver.
+  Copyright 2015 by morecat_lab
+   
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+*/
+
+#ifndef STNSEG_H
+#define STNSEG_H
+
+#include "mbed.h"
+#include <Timer.h>
+
+// the order of segment bit is as follows (16 bit)
+// |             |             |               |            |
+//  A1, A2, B, C, D1, D2, E, F,  G1, G2, H, I,  J, K, L, M
+// note that DP must set independent port
+
+#define NUM_PAT16_0 0xff09
+#define NUM_PAT16_1 0x3000
+#define NUM_PAT16_2 0xeec0
+#define NUM_PAT16_3 0xfcc0
+#define NUM_PAT16_4 0x31c0
+#define NUM_PAT16_5 0xddc0
+#define NUM_PAT16_6 0xdfc0
+#define NUM_PAT16_7 0xf000
+#define NUM_PAT16_8 0xffc0
+#define NUM_PAT16_9 0xfdc0
+#define NUM_PAT16_A 0xf3c0
+#define NUM_PAT16_B 0xfc52
+#define NUM_PAT16_C 0xcf00
+#define NUM_PAT16_D 0xfc12
+#define NUM_PAT16_E 0xcf80
+#define NUM_PAT16_F 0xf310
+
+#define NUM_PAT16_MINUS 0x00c0
+
+/**
+ * Sixteen segment LED driver library
+ */
+class Stnseg
+{
+private:
+    unsigned long _lastUpdateTime;
+    int _updateInterval;
+    DigitalOut _dataPin, _clockPin, _latchPin, _dpPin;
+    BusOut _digPins;
+    uint32_t _buffer[8];
+    int _numOfDigs;
+    int _dig;       // support 4, 6 or 8
+    bool _zeroSupress;
+    bool _kcommon;  // Cathode-common flag
+    Timer timer;
+public:
+    static const uint16_t numConv[16];
+
+    /**
+     * create an 4 digit sixteen segment driver
+     *
+     * @param PinName data (for 74HC959)
+     * @param PinName clock (for 74HC959)
+     * @param PinName latch (for 74HC959)
+     * @param PinName dp Pin No for segment DP
+     * @param PinName d1 Pin No for dight 1
+     * @param PinName d2 Pin No for dight 2
+     * @param PinName d3 Pin No for dight 3
+     * @param PinName d4 Pin No for dight 4
+     */
+    Stnseg(PinName data, PinName clock, PinName latch, PinName dp,
+         PinName d1,PinName d2, PinName d3, PinName d4);
+
+    /**
+     * create an 6 digit sixteen segment driver
+     *
+     * @param PinName data (for 74HC959)
+     * @param PinName clock (for 74HC959)
+     * @param PinName latch (for 74HC959)
+     * @param PinName dp Pin No for segment DP
+     * @param PinName d1 Pin No for dight 1
+     * @param PinName d2 Pin No for dight 2
+     * @param PinName d3 Pin No for dight 3
+     * @param PinName d4 Pin No for dight 4
+     * @param PinName d4 Pin No for dight 5
+     * @param PinName d4 Pin No for dight 6
+     */
+    Stnseg(PinName data, PinName clock, PinName latch, PinName dp,
+         PinName d1,PinName d2, PinName d3, PinName d4,
+         PinName d5, PinName d6);
+
+    /**
+     * create an 8 digit sixteen segment driver
+     *
+     * @param PinName data (for 74HC959)
+     * @param PinName clock (for 74HC959)
+     * @param PinName latch (for 74HC959)
+     * @param PinName dp Pin No for segment DP
+     * @param PinName d1 Pin No for dight 1
+     * @param PinName d2 Pin No for dight 2
+     * @param PinName d3 Pin No for dight 3
+     * @param PinName d4 Pin No for dight 4
+     * @param PinName d5 Pin No for dight 5
+     * @param PinName d6 Pin No for dight 6
+     * @param PinName d7 Pin No for dight 7
+     * @param PinName d8 Pin No for dight 8
+     */
+    Stnseg(PinName data, PinName clock, PinName latch, PinName dp,
+         PinName d1,PinName d2, PinName d3, PinName d4,
+         PinName d5,PinName d6, PinName d7, PinName d8);
+    
+    /**
+     * start driver
+     */
+    void begin(void);
+
+    /**
+     * use Kathode Common LED
+     */
+    void setKcommon(void);
+    
+    /**
+     * use Anode Common LED (default)
+     */
+    void setAcommon(void);
+    
+    /**
+     * get a charcter pattern from a number
+     *
+     * @param i number
+     *
+     * @returns bit pattern of number i
+     *
+     */
+    uint16_t segCh(char i);
+
+    /**
+     * turn on DP 
+     *
+     * @param d dight
+     *
+     */
+    void setDot(int d);
+
+    /**
+     * turn off DP 
+     *
+     * @param d dight
+     *
+     */
+    void clearDot(int d);
+    
+    /**
+     * write a number to LED 
+     *
+     * @param d number
+     *
+     */
+    void writeNum(int n);
+
+    /**
+     * write a number to 4 dight LED 
+     *
+     * @param n number
+     *
+     */
+    void writeNum4(int n);
+
+    /**
+     * write a number to 6 dight LED 
+     *
+     * @param n number
+     *
+     */
+    void writeNum6(int n);
+
+    /**
+     * write a number to 8 dight LED 
+     *
+     * @param n number
+     *
+     */
+    void writeNum8(int n);
+    
+    /**
+     * write numbers to each dight of 2 dight LED 
+     *
+     * @param d1 digit 1 number
+     * @param d2 digit 2 number
+     *
+     */
+    void writeNum(char d1, char d2);
+
+    /**
+     * write numbers to each dight of 4 dight LED 
+     *
+     * @param d1 digit 1 number
+     * @param d2 digit 2 number
+     * @param d3 digit 3 number
+     * @param d4 digit 4 number
+     *
+     */
+    void writeNum(char d1, char d2, char d3, char d4);
+
+    /**
+     * write numbers to each dight of 8 dight LED 
+     *
+     * @param d1 digit 1 number
+     * @param d2 digit 2 number
+     * @param d3 digit 3 number
+     * @param d4 digit 4 number
+     * @param d5 digit 5 number
+     * @param d6 digit 6 number
+     * @param d7 digit 7 number
+     * @param d8 digit 8 number
+     *
+     */
+    void writeNum(char d1, char d2, char d3, char d4, char d5, char d6, char d7, char d8);
+
+    /**
+     * zero supress: tell driver not to display 0 in the left
+     *
+     */
+    void supressZero();
+
+    /**
+     * control zero supress bit
+     *
+     * @param t, 1:supress on, 0:supress off
+     *
+     */
+    void setZeroSupress(bool t);
+
+    /**
+     * write hex number to LED
+     *
+     * @param n (long)number
+     *
+     */
+    void writeHex(long n);
+
+    
+    /**
+     * write patterns to each dight of 4 dight LED 
+     *
+     * @param d1 digit 1 pattern
+     * @param d2 digit 2 pattern
+     * @param d3 digit 3 pattern
+     * @param d4 digit 4 pattern
+     *
+     */
+    void writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4);
+
+    /**
+     * write patterns to each dight of 6 dight LED 
+     *
+     * @param d1 digit 1 pattern
+     * @param d2 digit 2 pattern
+     * @param d3 digit 3 pattern
+     * @param d4 digit 4 pattern
+     * @param d5 digit 5 pattern
+     * @param d6 digit 6 pattern
+     *
+     */
+    void writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4, uint32_t d5, uint32_t d6);
+
+    /**
+     * write patterns to each dight of 8 dight LED 
+     *
+     * @param d1 digit 1 pattern
+     * @param d2 digit 2 pattern
+     * @param d3 digit 3 pattern
+     * @param d4 digit 4 pattern
+     * @param d5 digit 5 pattern
+     * @param d6 digit 6 pattern
+     * @param d7 digit 7 pattern
+     * @param d8 digit 8 pattern
+     *
+     */
+    void writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4, uint32_t d5, uint32_t d6, uint32_t d7, uint32_t d8);
+
+    /**
+     * write patterns to a dight 
+     *
+     * @param d digit
+     *
+     * @param value pattern
+     *
+     */
+    void write(uint8_t d, uint32_t value);
+
+    /**
+     * Clear LED buffer
+     */
+    void clear(void);
+    
+    /**
+     * Turn off LED
+     */
+    void turnOff(void);
+
+    /**
+     * Turn on LED
+     */
+    void turnOn(void);
+
+    /**
+     * Update One dight of LED
+     */
+    void updateSeg(void);
+
+    /**
+     * keep updating LED for specified period
+     *
+     * @param ms period (ms)
+     *
+     */
+    void updateWithDelay(int ms);
+
+    /**
+     * Update LED Once with 1ms delay
+     */
+    void updateOnce(void);
+};
+
+#endif  // Stnseg.h