Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
main.cpp
00001 #include "mbed.h" 00002 #include "ht1632.h" 00003 #include "font3.h" 00004 00005 #define HIGH 1 00006 #define LOW 0 00007 00008 DigitalOut ht1632_wrclk(p23); // For Test : Led1 is Clock 00009 DigitalOut ht1632_data(p22); // Led2 is Data .... 00010 DigitalOut ht1632_cs(p21); // Led3 is CS 00011 00012 typedef unsigned char byte; 00013 00014 void byteOut(byte c); 00015 void ht1632_chipselect(byte chipno); 00016 static void ht1632_sendcmd (byte command); 00017 static void ht1632_senddata (byte address, byte data); 00018 void ht1632_chipfree(byte chipno); 00019 void ht1632_writebits (byte bits, byte firstbit); 00020 void ht1632_plot (int x, int y, char val); 00021 void setup(); 00022 void loop(); 00023 00024 int main() { 00025 setup(); 00026 while(1) { 00027 loop(); 00028 } 00029 } 00030 00031 /*********************************************************************** 00032 * HT1624.pde - Arduino demo program for Holtek HT1632 LED driver chip, 00033 * As implemented on the Sure Electronics DE-DP016 display board 00034 * (16*24 dot matrix LED module.) 00035 * Nov, 2008 by Bill Westfield ("WestfW") 00036 * Copyrighted and distributed under the terms of the Berkely license 00037 * (copy freely, but include this notice of original author.) 00038 * 00039 * Adapted for 8x32 display by FlorinC. 00040 ***********************************************************************/ 00041 00042 // comment out this line for the 8x32 display; 00043 //#define _16x24_ 00044 00045 00046 #ifdef _16x24_ 00047 #define X_MAX 23 00048 #define Y_MAX 15 00049 #else 00050 #define X_MAX 31 00051 #define Y_MAX 7 00052 #endif 00053 00054 #define plot(x,y,v) ht1632_plot(x,y,v) 00055 #define cls ht1632_clear 00056 00057 #define DISPDELAY 0 00058 00059 char* msg = " Guten Morgen liebe Kollegen ! - Alles im Lack ? Noch 20 Tage bis Entwicklungsschluss ....... "; 00060 int crtPos = 0; 00061 00062 /*********************************************************************** 00063 * ht1632_chipselect / ht1632_chipfree 00064 * Select or de-select a particular ht1632 chip. 00065 * De-selecting a chip ends the commands being sent to a chip. 00066 * CD pins are active-low; writing 0 to the pin selects the chip. 00067 ***********************************************************************/ 00068 00069 void ht1632_chipselect(byte chipno) 00070 { 00071 ht1632_cs = 0; 00072 } 00073 00074 void ht1632_chipfree(byte chipno) 00075 { 00076 ht1632_cs = 1; 00077 } 00078 00079 /* 00080 * we keep a copy of the display controller contents so that we can 00081 * know which bits are on without having to (slowly) read the device. 00082 * Note that we only use the low four bits of the shadow ram, since 00083 * we're shadowing 4-bit memory. This makes things faster, and we 00084 * use the other half for a "snapshot" when we want to plot new data 00085 * based on older data... 00086 */ 00087 // (fc) covers the case for 32x8 as well (64 bytes, 4 bits) 00088 byte ht1632_shadowram[96]; // our copy of the display's RAM 00089 00090 /* 00091 * ht1632_writebits 00092 * Write bits (up to <img src="http://timewitharduino.com/wp-includes/images/smilies/icon_cool.gif" alt="8)" class="wp-smiley"> to h1632 on pins HT1632_DATA, HT1632_WRCLK 00093 * Chip is assumed to already be chip-selected 00094 * Bits are shifted out from MSB to LSB, with the first bit sent 00095 * being (bits & firstbit), shifted till firsbit is zero. 00096 */ 00097 void ht1632_writebits (byte bits, byte firstbit) 00098 { 00099 while (firstbit) { 00100 ht1632_wrclk = 0; 00101 if (bits & firstbit) { 00102 ht1632_data = 1; 00103 } 00104 else { 00105 ht1632_data = 0; 00106 } 00107 ht1632_wrclk = 1; 00108 firstbit >>= 1; 00109 } 00110 } 00111 00112 /* 00113 * ht1632_sendcmd 00114 * Send a command to the ht1632 chip. 00115 * A command consists of a 3-bit "CMD" ID, an 8bit command, and 00116 * one "don't care bit". 00117 * Select 1 0 0 c7 c6 c5 c4 c3 c2 c1 c0 xx Free 00118 */ 00119 static void ht1632_sendcmd (byte command) 00120 { 00121 ht1632_chipselect(ht1632_cs); // Select chip 00122 ht1632_writebits(ID_CMD, 1<<2); // send 3 bits of id: COMMMAND 00123 ht1632_writebits(command, 1<<7); // send the actual command 00124 ht1632_writebits(0, 1); /* one extra dont-care bit in commands. */ 00125 ht1632_chipfree(ht1632_cs); //done 00126 } 00127 00128 00129 /* 00130 * ht1632_clear 00131 * clear the display, and the shadow memory, and the snapshot 00132 * memory. This uses the "write multiple words" capability of 00133 * the chipset by writing all 96 words of memory without raising 00134 * the chipselect signal. 00135 */ 00136 void ht1632_clear() 00137 { 00138 char i; 00139 00140 ht1632_chipselect(HT1632_CS); // Select chip 00141 ht1632_writebits(ID_WR, 1<<2); // send ID: WRITE to RAM 00142 ht1632_writebits(0, 1<<6); // Send address 00143 for (i = 0; i < 96/2; i++) // Clear entire display 00144 ht1632_writebits(0, 1<<7); // send 8 bits of data 00145 ht1632_chipfree(HT1632_CS); // done 00146 for (i=0; i < 96; i++) 00147 ht1632_shadowram[i] = 0; 00148 } 00149 00150 /* 00151 * ht1632_senddata 00152 * send a nibble (4 bits) of data to a particular memory location of the 00153 * ht1632. The command has 3 bit ID, 7 bits of address, and 4 bits of data. 00154 * Select 1 0 1 A6 A5 A4 A3 A2 A1 A0 D0 D1 D2 D3 Free 00155 * Note that the address is sent MSB first, while the data is sent LSB first! 00156 * This means that somewhere a bit reversal will have to be done to get 00157 * zero-based addressing of words and dots within words. 00158 */ 00159 static void ht1632_senddata (byte address, byte data) 00160 { 00161 ht1632_chipselect(HT1632_CS); // Select chip 00162 ht1632_writebits(ID_WR, 1<<2); // send ID: WRITE to RAM 00163 ht1632_writebits(address, 1<<6); // Send address 00164 ht1632_writebits(data, 1<<3); // send 4 bits of data 00165 ht1632_chipfree(HT1632_CS); // done 00166 } 00167 00168 void ht1632_setup() 00169 { 00170 ht1632_cs = HIGH; // unselect (active low) 00171 ht1632_sendcmd(CMD_SYSDIS); // Disable system 00172 00173 #ifdef _16x24_ 00174 ht1632_sendcmd(CMD_COMS11); // 16*32, PMOS drivers 00175 #else 00176 // (fc) 00177 ht1632_sendcmd(CMD_COMS10); // 32x8, PMOS drivers 00178 #endif 00179 00180 ht1632_sendcmd(CMD_MSTMD); // Master Mode 00181 ht1632_sendcmd(CMD_SYSON); // System on 00182 ht1632_sendcmd(CMD_LEDON); // LEDs on 00183 00184 for (byte i=0; i<64; i++) 00185 ht1632_senddata(i, 0); // clear the display! 00186 00187 wait(0.1); // ? 00188 } 00189 00190 /* 00191 * Copy a character glyph from the myfont data structure to 00192 * display memory, with its upper left at the given coordinate 00193 * This is unoptimized and simply uses plot() to draw each dot. 00194 */ 00195 void ht1632_putchar(int x, int y, char c) 00196 { 00197 // fonts defined for ascii 32 and beyond (index 0 in font array is ascii 32); 00198 byte charIndex; 00199 00200 // replace undisplayable characters with blank; 00201 if (c < 32 || c > 126) 00202 { 00203 charIndex = 0; 00204 } 00205 else 00206 { 00207 charIndex = c - 32; 00208 } 00209 00210 // move character definition, pixel by pixel, onto the display; 00211 // fonts are defined as one byte per row; 00212 for (byte row=0; row<8; row++) 00213 { 00214 byte rowDots = myfont[charIndex][row]; 00215 for (byte col=0; col<6; col++) 00216 { 00217 if (rowDots & (1<<(5-col))) 00218 plot(x+col, y+row, 1); 00219 else 00220 plot(x+col, y+row, 0); 00221 } 00222 } 00223 } 00224 00225 /* 00226 * plot a point on the display, with the upper left hand corner 00227 * being (0,0), and the lower right hand corner being (23, 15). 00228 * Note that Y increases going "downward" in contrast with most 00229 * mathematical coordiate systems, but in common with many displays 00230 * No error checking; bad things may happen if arguments are out of 00231 * bounds! (The ASSERTS compile to nothing by default 00232 */ 00233 void ht1632_plot (int x, int y, char val) 00234 { 00235 if (x<0 || x>X_MAX || y<0 || y>Y_MAX) 00236 return; 00237 00238 char addr, bitval; 00239 00240 /* 00241 * The 4 bits in a single memory word go DOWN, with the LSB 00242 * (first transmitted) bit being on top. However, writebits() 00243 * sends the MSB first, so we have to do a sort of bit-reversal 00244 * somewhere. Here, this is done by shifting the single bit in 00245 * the opposite direction from what you might expect. 00246 */ 00247 bitval = 8>>(y&3); // compute which bit will need set 00248 00249 #ifdef _16x24_ 00250 addr = (x<<2) + (y>>2); // compute which memory word this is in 00251 #else 00252 // (fc) 00253 addr = (x<<1) + (y>>2); // compute which memory word this is in 00254 #endif 00255 00256 if (val) { // Modify the shadow memory 00257 ht1632_shadowram[addr] |= bitval; 00258 } 00259 else { 00260 ht1632_shadowram[addr] &= ~bitval; 00261 } 00262 // Now copy the new memory value to the display 00263 ht1632_senddata(addr, ht1632_shadowram[addr]); 00264 } 00265 00266 /* 00267 * get_shadowram 00268 * return the value of a pixel from the shadow ram. 00269 */ 00270 byte get_shadowram(byte x, byte y) 00271 { 00272 byte addr, bitval; 00273 00274 bitval = 8>>(y&3); // compute which bit will need set 00275 addr = (x<<2) + (y>>2); // compute which memory word this is in 00276 return (0 != (ht1632_shadowram[addr] & bitval)); 00277 } 00278 00279 /* 00280 * snapshot_shadowram 00281 * Copy the shadow ram into the snapshot ram (the upper bits) 00282 * This gives us a separate copy so we can plot new data while 00283 * still having a copy of the old data. snapshotram is NOT 00284 * updated by the plot functions (except "clear") 00285 */ 00286 void snapshot_shadowram() 00287 { 00288 for (char i=0; i< sizeof ht1632_shadowram; i++) { 00289 ht1632_shadowram[i] = (ht1632_shadowram[i] & 0x0F) | ht1632_shadowram[i] << 4; // Use the upper bits 00290 } 00291 } 00292 00293 /* 00294 * get_snapshotram 00295 * get a pixel value from the snapshot ram (instead of 00296 * the actual displayed (shadow) memory 00297 */ 00298 byte get_snapshotram(byte x, byte y) 00299 { 00300 byte addr, bitval; 00301 00302 bitval = 128>>(y&3); // user upper bits! 00303 00304 #ifdef _16x24_ 00305 addr = (x<<2) + (y>>2); // compute which memory word this is in 00306 #else 00307 // (fc) 00308 addr = (x<<1) + (y>>2); // compute which memory word this is in 00309 #endif 00310 00311 if (ht1632_shadowram[addr] & bitval) 00312 return 1; 00313 return 0; 00314 } 00315 00316 /* 00317 * This works equally well for both 16x24 and 8x32 matrices. 00318 */ 00319 void displayScrollingLine() 00320 { 00321 // shift the whole screen 6 times, one column at a time; 00322 for (int x=0; x < 6; x++) 00323 { 00324 ht1632_putchar(-x, 0, msg[crtPos]); 00325 ht1632_putchar(-x+6, 0, ((crtPos+1 < strlen(msg)) ? msg[crtPos+1] : ' ')); 00326 ht1632_putchar(-x+12, 0, ((crtPos+2 < strlen(msg)) ? msg[crtPos+2] : ' ')); 00327 ht1632_putchar(-x+18, 0, ((crtPos+3 < strlen(msg)) ? msg[crtPos+3] : ' ')); 00328 ht1632_putchar(-x+24, 0, ((crtPos+4 < strlen(msg)) ? msg[crtPos+4] : ' ')); 00329 ht1632_putchar(-x+30, 0, ((crtPos+5 < strlen(msg)) ? msg[crtPos+5] : ' ')); 00330 ht1632_putchar(-x+36, 0, ((crtPos+6 < strlen(msg)) ? msg[crtPos+6] : ' ')); 00331 wait(0.05); 00332 } 00333 00334 crtPos++; 00335 if (crtPos >= strlen(msg)) 00336 { 00337 crtPos = 0; 00338 } 00339 } 00340 00341 /*********************************************************************** 00342 * traditional Arduino sketch functions: setup and loop. 00343 ***********************************************************************/ 00344 00345 void setup () 00346 { 00347 ht1632_setup(); 00348 cls(); 00349 } 00350 00351 void loop () 00352 { 00353 // display line; 00354 displayScrollingLine(); 00355 }
Generated on Sun Jul 17 2022 15:03:58 by
1.7.2