Stnseg.cpp

00001 /*
00002   Stnseg.cpp - mbed library for 4/6/8 digit Sixteen (16) segment LED driver.
00003   Copyright 2015 by morecat_lab
00004   
00005   This library is distributed in the hope that it will be useful,
00006   but WITHOUT ANY WARRANTY; without even the implied warranty of
00007   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
00008 */
00009 
00010 #include "Stnseg.h"
00011 #include <Timer.h>
00012 
00013 const uint16_t Stnseg::numConv[] = {
00014     NUM_PAT16_0, NUM_PAT16_1, NUM_PAT16_2, NUM_PAT16_3,
00015     NUM_PAT16_4, NUM_PAT16_5, NUM_PAT16_6, NUM_PAT16_7,
00016     NUM_PAT16_8, NUM_PAT16_9, NUM_PAT16_A, NUM_PAT16_B,
00017     NUM_PAT16_C, NUM_PAT16_D, NUM_PAT16_E, NUM_PAT16_F};
00018 
00019 
00020 // 4 digit
00021 Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
00022            PinName d1,PinName d2, PinName d3, PinName d4) :
00023            _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
00024            _digPins(d1, d2, d3, d4)
00025 {
00026     _numOfDigs = 4;
00027     _updateInterval = (8333 / 4);
00028     _zeroSupress = true;
00029     _kcommon = false;
00030 }
00031 
00032 // 6 digit
00033 Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
00034            PinName d1,PinName d2, PinName d3, PinName d4,
00035            PinName d5,PinName d6) :
00036            _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
00037            _digPins(d1, d2, d3, d4, d5, d6)
00038 {
00039     _numOfDigs = 6;
00040     _updateInterval = (8333 / 6);
00041     _zeroSupress = true;
00042     _kcommon = false;
00043 }
00044 
00045 // 8 digit
00046 Stnseg::Stnseg(PinName data,PinName clock, PinName latch,PinName dp,
00047            PinName d1,PinName d2, PinName d3, PinName d4,
00048            PinName d5,PinName d6, PinName d7, PinName d8) :
00049            _dataPin(data), _clockPin(clock), _latchPin(latch), _dpPin(dp), 
00050            _digPins(d1, d2, d3, d4, d5, d6, d7, d8)
00051 {
00052     _numOfDigs = 8;
00053     _updateInterval = (8333 / 8);
00054     _zeroSupress = true;
00055     _kcommon = false;
00056 }
00057 
00058 
00059 void Stnseg::begin(void) {
00060     timer.start();
00061     clear();
00062 }
00063 
00064 void Stnseg::setAcommon(void) {
00065     _kcommon = false;
00066 }
00067 
00068 void Stnseg::setKcommon(void) {
00069     _kcommon = true;
00070 }
00071 
00072 uint16_t Stnseg::segCh(char i) {
00073     return numConv[i];
00074 }
00075 
00076 void Stnseg::setDot(int d) {
00077     _buffer[d] |= 0x010000;
00078 }
00079 
00080 void Stnseg::clearDot(int d) {
00081     _buffer[d] &= 0xfffe0000;
00082 }
00083 
00084 void Stnseg::writeNum(int n) {
00085     if (_numOfDigs == 4) {
00086         writeNum4(n);
00087     } else if (_numOfDigs == 6) {
00088         writeNum6(n);
00089     } else if (_numOfDigs == 8) {
00090         writeNum8((long)n);
00091     }
00092 }
00093 
00094 
00095 void Stnseg::writeNum4(int n) {
00096     if (n < 10000) {
00097         _buffer[0] = segCh((n % 10000) / 1000);
00098         _buffer[1] = segCh((n % 1000) / 100);
00099         _buffer[2] = segCh((n % 100) / 10);
00100         _buffer[3] = segCh(n % 10);
00101         supressZero();
00102     } else {
00103         _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = NUM_PAT16_MINUS;// overflow
00104     }
00105 }
00106 
00107 void Stnseg::writeNum6(int n) {
00108     if (n < 10000) {
00109         _buffer[0] = segCh((n % 1000000) / 100000);
00110         _buffer[1] = segCh((n % 100000) / 10000);
00111         _buffer[2] = segCh((n % 10000) / 1000);
00112         _buffer[3] = segCh((n % 1000) / 100);
00113         _buffer[4] = segCh((n % 100) / 10);
00114         _buffer[5] = segCh(n % 10);
00115         supressZero();
00116     } else {
00117         _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = NUM_PAT16_MINUS;// overflow
00118     }
00119 }
00120 
00121 void Stnseg::writeNum8(int n) {
00122     if (n < 1000000) {
00123         _buffer[0] = segCh((n % 100000000) / 10000000);
00124         _buffer[1] = segCh((n % 10000000) / 1000000);
00125         _buffer[2] = segCh((n % 1000000) / 100000);
00126         _buffer[3] = segCh((n % 100000) / 10000);
00127         _buffer[4] = segCh((n % 10000) / 1000);
00128         _buffer[5] = segCh((n % 1000) / 100);
00129         _buffer[6] = segCh((n % 100) / 10);
00130         _buffer[7] = segCh(n % 10);
00131         supressZero();
00132     } else {
00133         _buffer[0] = _buffer[1] = _buffer[2] = _buffer[3] = _buffer[4] = _buffer[5] = NUM_PAT16_MINUS;// overflow
00134     }
00135 }
00136 
00137 void Stnseg::writeNum(char d1, char d2) {
00138     _buffer[0] = segCh(d1);
00139     _buffer[1] = segCh(d2);
00140     supressZero();
00141 }
00142 
00143 void Stnseg::writeNum(char d1, char d2, char d3, char d4) {
00144     _buffer[0] = segCh(d1);
00145     _buffer[1] = segCh(d2);
00146     _buffer[2] = segCh(d3);
00147     _buffer[3] = segCh(d4);
00148     supressZero();
00149 }
00150 
00151 void Stnseg::writeNum(char d1, char d2, char d3, char d4,
00152                     char d5, char d6, char d7, char d8)
00153 {
00154     _buffer[0] = segCh(d1);
00155     _buffer[1] = segCh(d2);
00156     _buffer[2] = segCh(d3);
00157     _buffer[3] = segCh(d4);
00158     _buffer[4] = segCh(d5);
00159     _buffer[5] = segCh(d6);
00160     _buffer[6] = segCh(d7);
00161     _buffer[7] = segCh(d8);
00162     supressZero();
00163 }
00164 
00165 void Stnseg::writeHex(long n) {
00166     if (_numOfDigs == 4) {
00167         _buffer[0] = segCh((n >> 12) & 0xf);
00168         _buffer[1] = segCh((n >> 8) & 0xf);
00169         _buffer[2] = segCh((n >> 4) & 0xf);
00170         _buffer[3] = segCh(n & 0xf);
00171     } else if (_numOfDigs == 6) {
00172         _buffer[0] = segCh((n >> 20) & 0xf);
00173         _buffer[1] = segCh((n >> 16) & 0xf);
00174         _buffer[2] = segCh((n >> 12) & 0xf);
00175         _buffer[3] = segCh((n >> 8) & 0xf);
00176         _buffer[4] = segCh((n >> 4) & 0xf);
00177         _buffer[5] = segCh(n & 0xf);
00178     } else if (_numOfDigs == 8) {
00179         _buffer[0] = segCh((n >> 28) & 0xf);
00180         _buffer[1] = segCh((n >> 24) & 0xf);
00181         _buffer[2] = segCh((n >> 20) & 0xf);
00182         _buffer[3] = segCh((n >> 16) & 0xf);
00183         _buffer[4] = segCh((n >> 12) & 0xf);
00184         _buffer[5] = segCh((n >> 8) & 0xf);
00185         _buffer[6] = segCh((n >> 4) & 0xf);
00186         _buffer[7] = segCh(n & 0xf);
00187     }
00188     supressZero();
00189 }
00190 
00191 void Stnseg::setZeroSupress(bool t) {
00192     _zeroSupress = t;
00193 }
00194 
00195 void Stnseg::supressZero() {
00196     int i;
00197     if (_zeroSupress ) {
00198         for (i = 0 ; i < (_numOfDigs-1) ; i++) {
00199             if (_buffer[i] == segCh(0)) {
00200                 _buffer[i] = _buffer[i] & 0x1000;
00201             } else {
00202                 break;
00203             }
00204         }
00205     }
00206 }
00207 
00208 void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4) {
00209     _buffer[0] = d1;
00210     _buffer[1] = d2;
00211     _buffer[2] = d3;
00212     _buffer[3] = d4;
00213 }
00214 
00215 void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4,
00216                           uint32_t d5, uint32_t d6) {
00217     _buffer[0] = d1;
00218     _buffer[1] = d2;
00219     _buffer[2] = d3;
00220     _buffer[3] = d4;
00221     _buffer[4] = d5;
00222     _buffer[5] = d6;
00223 }
00224 void Stnseg::writeRawData(uint32_t d1, uint32_t d2, uint32_t d3, uint32_t d4,
00225                           uint32_t d5, uint32_t d6, uint32_t d7, uint32_t d8) {
00226     _buffer[0] = d1;
00227     _buffer[1] = d2;
00228     _buffer[2] = d3;
00229     _buffer[3] = d4;
00230     _buffer[4] = d5;
00231     _buffer[5] = d6;
00232     _buffer[6] = d7;
00233     _buffer[7] = d8;
00234 }
00235 
00236 void Stnseg::write(uint8_t d, uint32_t value) {
00237     _buffer[d] = value;
00238 }
00239 
00240 void Stnseg::clear(void) {
00241     int i;
00242     for(i=0;i<8;i++){
00243         _buffer[i] = 0;
00244     }
00245     _dig = _numOfDigs - 1;
00246     _digPins = ( _kcommon) ? 0xff : 0;
00247 }
00248 
00249 void Stnseg::turnOff(void) {
00250     if ( _kcommon) {
00251         _digPins = 0xff;   // set HIGH
00252     } else {
00253         _digPins = 0;  // set LOW
00254     }
00255 }
00256 
00257 void Stnseg::turnOn(void) {
00258     if ( _kcommon) {
00259         _digPins = ~(1 << _dig); // set LOW
00260     } else {
00261         _digPins = (1 << _dig); // set HIGH
00262      }
00263 }
00264 
00265 void Stnseg::updateSeg(void) {
00266     if( (++_dig) >= _numOfDigs)
00267         _dig = 0;
00268     _latchPin = 0;
00269     for (int col = 0 ; col < 16 ; col++) {  // forward order
00270         _clockPin = 0;
00271         if(_buffer[_dig] & (1 << col)){
00272             _dataPin = 1;
00273         } else {
00274             _dataPin = 0;
00275         }
00276         _clockPin = 1;
00277     }
00278     _latchPin = 1;
00279     if ((_buffer[_dig] & 0x10000) != 0) {
00280         _dpPin = 1;
00281     } else {
00282         _dpPin = 0;
00283     }
00284 }
00285 
00286 void Stnseg::updateWithDelay(int ms) {
00287     timer.reset();  // to avoid overflow 32bit counter  (~=30min)
00288     int start = timer.read_ms();
00289     _dig = _numOfDigs - 1;
00290     turnOff();
00291     do {
00292         for (int i = 0 ; i < _numOfDigs ; i++) {
00293             updateSeg();
00294             turnOn();
00295             wait(0.001f); // wait 1ms
00296             turnOff();
00297         }
00298         if ((timer.read_ms() - start) >= ms) {
00299             break;
00300         }
00301     } while(1);
00302 }
00303 
00304 void Stnseg::updateOnce(void) {
00305     uint8_t i;
00306     _dig = _numOfDigs - 1;
00307     turnOff();
00308     for (i = 0 ; i < _numOfDigs ; i++) {
00309         updateSeg();
00310         turnOn();
00311         wait(0.001f); // wait 1ms
00312         turnOff();
00313     }
00314 }
00315 
00316 // EOF