main.cpp

00001 /* mbed TM1637 Test program, for TM1637 LED controller
00002  * Copyright (c) 2016, v01: WH, Initial version
00003  *               2017, v02: WH, Added RobotDyn 6 Digit module,
00004  *                          Added Eyewink 6 Digit + 5 Keys module,
00005  *                          Constructor adapted to 2 pins: dio, clk    
00006  *
00007  * Permission is hereby granted, free of charge, to any person obtaining a copy
00008  * of this software and associated documentation files (the "Software"), to deal
00009  * in the Software without restriction, including without limitation the rights
00010  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00011  * copies of the Software, and to permit persons to whom the Software is
00012  * furnished to do so, subject to the following conditions:
00013  *
00014  * The above copyright notice and this permission notice shall be included in
00015  * all copies or substantial portions of the Software.
00016  *
00017  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00018  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00019  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00020  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00021  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00022  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00023  * THE SOFTWARE.
00024  */
00025 #include "mbed.h"
00026 #include "TM1637.h"
00027 
00028 #if (CATALEX_TEST == 1)
00029 // CATALEX TM1637 4 Digit display test
00030 #include "Font_7Seg.h"
00031 
00032 Serial pc(USBTX, USBRX);
00033 DigitalOut myled(LED1);  //NOTE: On F401 LED1 is Pin D13, which is SCK!
00034 
00035 // DisplayData_t size is 4 bytes (4 Grids @ 8 Segments) 
00036 TM1637::DisplayData_t all_str   = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};  
00037 TM1637::DisplayData_t cls_str   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};  
00038 TM1637::DisplayData_t hello_str = {C7_H, C7_I, 0x00, 0x00, 0x00, 0x00};
00039 TM1637::DisplayData_t bye_str   = {C7_B, C7_Y, C7_E, 0x00, 0x00, 0x00};
00040 
00041 // KeyData_t size is 1 bytes  
00042 TM1637::KeyData_t keydata; 
00043 
00044 //TM1637_CATALEX declaration
00045 #if(SPI==1)
00046 //Old Constructor
00047 TM1637_CATALEX CATALEX(p5, p6, p7);   //LPC1768
00048 //TM1637_CATALEX CATALEX(D8, D9, D10);  //F401
00049 #else
00050 //New Constructor
00051 TM1637_CATALEX CATALEX(p6, p7);       //LPC1768
00052 //TM1637_CATALEX CATALEX(D9, D10);      //F401
00053 #endif
00054 
00055 void show_menu() {
00056 //    pc.printf("0:   Exit\n\r");
00057     pc.printf("1:   All\n\r");    
00058     pc.printf("2:   Show all segs\r\n");
00059     pc.printf("3:   Show all chars\n\r");
00060     pc.printf("4:   Show all digits\n\r");
00061     pc.printf("5:   Show all icons\n\r");
00062     pc.printf("6:   Counter\n\r");
00063     pc.printf("7:   Floats\n\r");
00064     pc.printf("8:   Kitt\n\r");
00065     pc.printf("9:   Cls\n\r");    
00066     pc.printf("A:   Bye\n\r");    
00067     pc.printf("k:   Key\n\r");
00068 }
00069 
00070 
00071 char cmd, bits;
00072 int main() {
00073     
00074     pc.printf("Hello World\r\n"); //    
00075     
00076     CATALEX.cls(); 
00077     CATALEX.writeData(all_str);
00078     wait(2);
00079     CATALEX.setBrightness(TM1637_BRT3);    
00080     wait(1);
00081     CATALEX.setBrightness(TM1637_BRT0);        
00082     wait(1);
00083     CATALEX.setBrightness(TM1637_BRT4);            
00084 
00085     wait(1);
00086     CATALEX.cls(true); 
00087     CATALEX.writeData(hello_str); 
00088     
00089     char cmd2 = '0';
00090     while (1) {
00091       
00092       show_menu();
00093       cmd2 = pc.getc();
00094 
00095       switch (cmd2) {
00096         case '1' : {
00097                       pc.printf("all\r\n");
00098                       CATALEX.cls(); 
00099                       CATALEX.writeData(all_str);
00100                       break;
00101         }
00102 
00103         case '2' : {
00104 #if(1)
00105 //test to show all segs
00106           pc.printf("Show all segs\r\n");
00107           wait(1);          
00108           CATALEX.cls(); 
00109          
00110           for (int i=0; i<TM1637_DISPLAY_MEM; i++) {            
00111             for (int bit=0; bit<8; bit++) {
00112               CATALEX.cls(); 
00113 
00114               bits = 0x01 << bit;              
00115               CATALEX.writeData(bits, i);
00116 
00117               pc.printf("Idx = %d, Bits = 0x%02x\r\n", i, bits);              
00118 //              wait(0.5);
00119               cmd = pc.getc(); // wait for key
00120             }  
00121           }
00122           pc.printf("\r\nShow all segs done\r\n");                    
00123 #endif 
00124           break;          
00125         }
00126 
00127         case '3' : {
00128 
00129 #if(1)
00130 //test to show all chars
00131           pc.printf("Show all alpha chars\r\n");
00132           wait(1);          
00133           CATALEX.cls(); 
00134          
00135           for (int i=0; i<26; i++) {
00136             CATALEX.printf("%c", char(i + 'A'));
00137 //            CATALEX.printf("%c", char(i + 'a'));            
00138             wait(0.25);                      
00139           }
00140           pc.printf("Show all alpha chars done\r\n");                    
00141 #endif            
00142 
00143 #if(0)
00144 //test to show all chars
00145           pc.printf("Show all chars\r\n");
00146           wait(1);          
00147           CATALEX.cls(); 
00148 
00149           for (int i=FONT_7S_START; i<FONT_7S_END; i++) {
00150             CATALEX.printf("%c", char(i));
00151 //            wait(0.25);
00152             cmd = pc.getc(); // wait for key            
00153           }
00154           pc.printf("Show all chars done\r\n");                    
00155 #endif            
00156           break;          
00157         }
00158         case '4': {
00159 #if(0)
00160 //test to show all digits (base is 10)
00161           pc.printf("Show all digits\r\n");
00162           wait(1);          
00163           CATALEX.cls(); 
00164 
00165           for (int i=0; i<CATALEX_NR_DIGITS; i++) {
00166 
00167             for (int cnt=0; cnt<10; cnt++) {
00168               CATALEX.locate(i);
00169               CATALEX.printf("%0d", cnt);
00170 
00171 //              wait(0.5);
00172               cmd = pc.getc(); // wait for key
00173             }  
00174           }
00175           pc.printf("\r\nShow all digits done\r\n");                    
00176 #endif                
00177 
00178 #if(1)
00179 //test to show all digits (base is 0x10)
00180           pc.printf("Show all hex digits\r\n");
00181           wait(1);          
00182           CATALEX.cls(); 
00183 
00184           CATALEX.printf("%04x", 0x01AB);
00185           cmd = pc.getc(); // wait for key                                     
00186           CATALEX.printf("%04x", 0x0);
00187                     
00188           for (int i=0; i<CATALEX_NR_DIGITS; i++) {
00189 
00190             for (int cnt=0; cnt<0x10; cnt++) {
00191               CATALEX.locate(i);
00192               CATALEX.printf("%0x", cnt);
00193 
00194 //              wait(0.5);
00195               cmd = pc.getc(); // wait for key
00196             }  
00197           }
00198           pc.printf("\r\nShow all hex digits done\r\n");          
00199 #endif                
00200           break;          
00201         }
00202         case '5':  { 
00203 #if(1)
00204 //test to show all icons
00205           pc.printf("Show all icons\r\n");
00206           CATALEX.cls(true); // Also clear all Icons
00207           
00208           float delay=0.1;
00209           // Icons on, Note that some versions do not have decimal points, but a
00210           // a double colon on the second digit to show hours:min
00211           CATALEX.setIcon(TM1637_CATALEX::DP1); wait(delay);
00212           CATALEX.setIcon(TM1637_CATALEX::DP2); wait(delay);
00213 //          CATALEX.setIcon(TM1637_CATALEX::COL2); wait(delay);
00214           CATALEX.setIcon(TM1637_CATALEX::DP3); wait(delay);
00215           CATALEX.setIcon(TM1637_CATALEX::DP4); wait(delay);
00216 
00217           wait(delay);
00218  
00219           // Icons off
00220           CATALEX.clrIcon(TM1637_CATALEX::DP4); wait(delay);
00221           CATALEX.clrIcon(TM1637_CATALEX::DP3); wait(delay);
00222           CATALEX.clrIcon(TM1637_CATALEX::DP2); wait(delay);
00223 //          CATALEX.clrIcon(TM1637_CATALEX::COL2); wait(delay);
00224           CATALEX.clrIcon(TM1637_CATALEX::DP1); wait(delay);
00225 
00226 //          wait(1);
00227 //          CATALEX.cls(); // clear all, preserve Icons
00228           pc.printf("Show all icons done\r\n");                    
00229 #endif           
00230           break;
00231         }                          
00232 
00233         case '6': {
00234           CATALEX.cls(); // clear all, preserve Icons
00235 
00236 #if(1)
00237           CATALEX.locate(0);
00238          
00239           for (int cnt=0; cnt<=0xFF; cnt++) {
00240             CATALEX.locate(2);
00241             CATALEX.printf("%02x", cnt);           
00242             wait(0.2);
00243           }  
00244 #endif
00245 
00246 //          CATALEX.writeData(hello_str);
00247 //          CATALEX.printf("hello");                  
00248 
00249           break;          
00250         }
00251         case '7': {
00252           CATALEX.cls(); // clear all, preserve Icons
00253           CATALEX.printf("%1.2f", -0.12);  // test decimal point display                    
00254           wait(0.5);
00255           CATALEX.cls(); // clear all, preserve Icons          
00256           CATALEX.printf("%1.3f", 1.234);  // test decimal point display
00257           break;          
00258         }
00259 
00260         case '8': {
00261 
00262 #if(1)
00263 //test to show KITT
00264           pc.printf("Show KITT scanner\r\n");
00265 
00266           
00267 //                          0123
00268 const char KITT[][5]   = {{"8   "},
00269                           {"38  "},
00270                           {" 38 "},
00271                           {"  38"},
00272                           {"   3"},
00273                           {"    "},
00274                           {"   8"},
00275                           {"  8E"},
00276                           {" 8E "},
00277                           {"8E  "},
00278                           {"E   "},
00279                           {"    "}
00280                         };     
00281          
00282           CATALEX.cls(); // clear all, preserve Icons
00283           
00284           while (!pc.readable()) { // wait for key            
00285             for (int i=0; i < (sizeof(KITT) / 5) ; i++) {
00286               CATALEX.locate(0);
00287               CATALEX.printf("%s", KITT[i]);
00288               wait(0.05);
00289             }
00290           }
00291           cmd = pc.getc(); // read key           
00292           pc.printf("Show KITT done\r\n");
00293 #endif
00294           break;
00295         }  
00296 
00297         case '9': {
00298 //          CATALEX.cls(); // clear all, preserve Icons
00299           CATALEX.cls(true); // clear all, including Icons                
00300           break;
00301         }  
00302 
00303         case 'A': {
00304 
00305           CATALEX.cls(); // clear all, preserve Icons
00306 //          CATALEX.writeData(bye_str);
00307           CATALEX.printf("Bye");          
00308        
00309           break;
00310         }  
00311 
00312         case 'k': {
00313           if (CATALEX.getKeys(&keydata)) {
00314             pc.printf("Keydata = 0x%02x\r\n", keydata);
00315           } 
00316           break;
00317         }
00318           
00319         default : {
00320           break;
00321         }         
00322      
00323       } //switch cmd
00324 
00325 #if(1)
00326       // Check and read keydata
00327       if (CATALEX.getKeys(&keydata)) {
00328         pc.printf("Keydata = 0x%02x\r\n", keydata);
00329 
00330         CATALEX.cls(); 
00331         switch (keydata) {
00332           case TM1637_SW9_BIT : { //sw9, 0xF7
00333                                   CATALEX.printf("--09");
00334                                   break;
00335                                 }
00336 
00337           case TM1637_SW10_BIT: { //sw10, 0x77
00338                                   CATALEX.printf("--10");
00339                                   break;
00340                                 }
00341 
00342           default :             {
00343                                   CATALEX.printf("----");
00344                                   break;
00345                                 }         
00346         }  
00347 
00348       } // Check keydata
00349 #endif
00350 
00351       myled = !myled;
00352       wait(0.3);      
00353     } //while
00354 }
00355 #endif
00356 
00357 
00358 #if (ROBOTDYN_TEST == 1)
00359 // ROBOTDYN TM1637 6 Digit display test
00360 #include "Font_7Seg.h"
00361 
00362 Serial pc(USBTX, USBRX);
00363 DigitalOut myled(LED1); //NOTE: On F401 LED1 is Pin D13, which is SCK!
00364 
00365 // DisplayData_t size is 6 bytes (6 Grids @ 8 Segments) 
00366 TM1637::DisplayData_t all_str   = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};  
00367 TM1637::DisplayData_t cls_str   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};  
00368 TM1637::DisplayData_t hello_str = {0x00, 0x00, 0x00, C7_I, C7_H, 0x00};
00369 TM1637::DisplayData_t bye_str   = {0x00, 0x00, 0x00, C7_E, C7_Y, C7_B};
00370 
00371 // KeyData_t size is 1 bytes  
00372 TM1637::KeyData_t keydata; 
00373 
00374 //TM1637_ROBOTDYN declaration
00375 //New Constructor
00376 TM1637_ROBOTDYN ROBOTDYN(p6, p7);       //LPC1768
00377 //TM1637_ROBOTDYN ROBOTDYN(D9, D10);      //F401
00378 
00379 void show_menu() {
00380 //    pc.printf("0:   Exit\n\r");
00381     pc.printf("1:   All\n\r");    
00382     pc.printf("2:   Show all segs\r\n");
00383     pc.printf("3:   Show all chars\n\r");
00384     pc.printf("4:   Show all digits\n\r");
00385     pc.printf("5:   Show all icons\n\r");
00386     pc.printf("6:   Counter\n\r");
00387     pc.printf("7:   Floats\n\r");
00388     pc.printf("8:   Kitt\n\r");
00389     pc.printf("9:   Cls\n\r");
00390     pc.printf("A:   Bye\n\r");
00391 }
00392 
00393 
00394 char cmd, bits;
00395 int main() {
00396     
00397     pc.printf("Hello World\r\n"); //    
00398     
00399     ROBOTDYN.cls(); 
00400     ROBOTDYN.writeData(all_str);
00401     wait(2);
00402     ROBOTDYN.setBrightness(TM1637_BRT3);    
00403     wait(1);
00404     ROBOTDYN.setBrightness(TM1637_BRT0);        
00405     wait(1);
00406     ROBOTDYN.setBrightness(TM1637_BRT4);            
00407 
00408     wait(1);
00409     ROBOTDYN.cls(true); 
00410     ROBOTDYN.writeData(hello_str); 
00411     
00412     char cmd2 = '0';
00413     while (1) {
00414       
00415       show_menu();
00416       cmd2 = pc.getc();
00417 
00418       switch (cmd2) {
00419         case '1' : {
00420                       pc.printf("all\r\n");
00421                       ROBOTDYN.cls(); 
00422                       ROBOTDYN.writeData(all_str);
00423                       break;
00424         }
00425 
00426         case '2' : {
00427 #if(1)
00428 //test to show all segs
00429           pc.printf("Show all segs\r\n");
00430           wait(1);          
00431           ROBOTDYN.cls(); 
00432          
00433           for (int i=0; i<TM1637_DISPLAY_MEM; i++) {            
00434             for (int bit=0; bit<8; bit++) {
00435               ROBOTDYN.cls(); 
00436 
00437               bits = 0x01 << bit;              
00438               ROBOTDYN.writeData(bits, i);
00439 
00440               pc.printf("Idx = %d, Bits = 0x%02x\r\n", i, bits);              
00441 //              wait(0.5);
00442               cmd = pc.getc(); // wait for key
00443             }  
00444           }
00445           pc.printf("\r\nShow all segs done\r\n");                    
00446 #endif 
00447           break;          
00448         }
00449 
00450         case '3' : {
00451 
00452 #if(1)
00453 //test to show all chars
00454           pc.printf("Show all alpha chars\r\n");
00455           wait(1);          
00456           ROBOTDYN.cls(); 
00457          
00458           for (int i=0; i<26; i++) {
00459             ROBOTDYN.printf("%c", char(i + 'A'));
00460 //            ROBOTDYN.printf("%c", char(i + 'a'));            
00461             wait(0.25);                      
00462           }
00463           pc.printf("Show all alpha chars done\r\n");                    
00464 #endif            
00465 
00466 #if(0)
00467 //test to show all chars
00468           pc.printf("Show all chars\r\n");
00469           wait(1);          
00470           ROBOTDYN.cls(); 
00471 
00472           for (int i=FONT_7S_START; i<FONT_7S_END; i++) {
00473             ROBOTDYN.printf("%c", char(i));
00474 //            wait(0.25);
00475             cmd = pc.getc(); // wait for key            
00476           }
00477           pc.printf("Show all chars done\r\n");                    
00478 #endif            
00479           break;          
00480         }
00481         case '4': {
00482 #if(0)
00483 //test to show all digits (base is 10)
00484           pc.printf("Show all digits\r\n");
00485           wait(1);          
00486           ROBOTDYN.cls(); 
00487 
00488           for (int i=0; i<ROBOTDYN_NR_DIGITS; i++) {
00489 
00490             for (int cnt=0; cnt<10; cnt++) {
00491               ROBOTDYN.locate(i);
00492               ROBOTDYN.printf("%0d", cnt);
00493 
00494 //              wait(0.5);
00495               cmd = pc.getc(); // wait for key
00496             }  
00497           }
00498           pc.printf("\r\nShow all digits done\r\n");                    
00499 #endif                
00500 
00501 #if(1)
00502 //test to show all digits (base is 0x10)
00503           pc.printf("Show all hex digits\r\n");
00504           wait(1);          
00505           ROBOTDYN.cls(); 
00506 
00507           ROBOTDYN.printf("%06x", 0x01ABCD);
00508           cmd = pc.getc(); // wait for key                                     
00509           ROBOTDYN.printf("%06x", 0x0);
00510                     
00511           for (int i=0; i<ROBOTDYN_NR_DIGITS; i++) {
00512 
00513             for (int cnt=0; cnt<0x10; cnt++) {
00514               ROBOTDYN.locate(i);
00515               ROBOTDYN.printf("%0x", cnt);
00516 
00517 //              wait(0.5);
00518               cmd = pc.getc(); // wait for key
00519             }  
00520           }
00521           pc.printf("\r\nShow all hex digits done\r\n");          
00522 #endif                
00523           break;          
00524         }
00525         case '5':  { 
00526 #if(1)
00527 //test to show all icons
00528           pc.printf("Show all icons\r\n");
00529           ROBOTDYN.cls(true); // Also clear all Icons
00530           
00531           float delay=0.1;
00532           // Icons on             
00533           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP1); wait(delay);
00534           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP2); wait(delay);
00535           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP3); wait(delay);
00536           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP4); wait(delay);
00537           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP5); wait(delay);
00538           ROBOTDYN.setIcon(TM1637_ROBOTDYN::DP6); wait(delay);                                                  
00539 
00540           wait(delay);
00541  
00542           // Icons off      
00543           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP6); wait(delay);
00544           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP5); wait(delay);
00545           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP4); wait(delay);
00546           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP3); wait(delay);
00547           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP2); wait(delay);
00548           ROBOTDYN.clrIcon(TM1637_ROBOTDYN::DP1); wait(delay);                                        
00549 
00550 //          wait(1);          
00551 //          ROBOTDYN.cls(); // clear all, preserve Icons
00552           pc.printf("Show all icons done\r\n");                    
00553 #endif           
00554           break;
00555         }                          
00556 
00557         case '6': {
00558           ROBOTDYN.cls(); // clear all, preserve Icons
00559 
00560 #if(1)
00561           ROBOTDYN.locate(0);
00562          
00563           for (int cnt=0; cnt<=0xFF; cnt++) {
00564             ROBOTDYN.locate(4);
00565             ROBOTDYN.printf("%02x", cnt);           
00566             wait(0.2);
00567           }  
00568 #endif
00569 
00570 //          ROBOTDYN.writeData(hello_str);
00571 //          ROBOTDYN.printf("hello");                  
00572 
00573           break;          
00574         }
00575         case '7': {
00576           ROBOTDYN.cls(); // clear all, preserve Icons
00577           ROBOTDYN.printf("%1.4f", -0.1234);  // test decimal point display
00578           wait(0.5);
00579           ROBOTDYN.cls(); // clear all, preserve Icons          
00580           ROBOTDYN.printf("%3.3f", 123.456);  // test decimal point display
00581           break;          
00582         }
00583 
00584         case '8': {
00585 
00586 #if(1)
00587 //test to show KITT
00588           pc.printf("Show KITT scanner\r\n");
00589 
00590           
00591 //                          012345
00592 const char KITT[][7]   = {{"8     "},
00593                           {"38    "},
00594                           {" 38   "},
00595                           {"  38  "},
00596                           {"   38 "},
00597                           {"    38"},
00598                           {"     3"},
00599                           {"      "},
00600                           {"     8"},
00601                           {"    8E"},
00602                           {"   8E "},
00603                           {"  8E  "},
00604                           {" 8E   "},
00605                           {"8E    "},
00606                           {"E     "},
00607                           {"      "}
00608                         };     
00609          
00610           ROBOTDYN.cls(); // clear all, preserve Icons
00611           
00612           while (!pc.readable()) { // wait for key            
00613             for (int i=0; i < (sizeof(KITT) / 7) ; i++) {
00614               ROBOTDYN.locate(0);
00615               ROBOTDYN.printf("%s", KITT[i]);
00616               wait(0.1);
00617             }
00618           }
00619           cmd = pc.getc(); // read key           
00620           pc.printf("Show KITT done\r\n");
00621 #endif
00622           break;
00623         }  
00624 
00625 
00626         case '9': {
00627           ROBOTDYN.cls(true); // clear all, including Icons      
00628           break;
00629         }  
00630 
00631         case 'A': {
00632 
00633           ROBOTDYN.cls(); // clear all, preserve Icons
00634 //          ROBOTDYN.writeData(bye_str);
00635           ROBOTDYN.printf("Bye");          
00636        
00637           break;
00638         } 
00639 
00640         default : {
00641           break;
00642         }         
00643      
00644       } //switch cmd
00645 
00646       myled = !myled;
00647       wait(0.3);      
00648     } //while
00649 }
00650 #endif
00651 
00652 
00653 #if (EYEWINK_TEST == 1)
00654 // EYEWINK TM1637 6 Digit display with 5 keys test
00655 #include "Font_7Seg.h"
00656 
00657 Serial pc(USBTX, USBRX);
00658 DigitalOut myled(LED1); //NOTE: On F401 LED1 is Pin D13, which is SCK!
00659 
00660 // DisplayData_t size is 6 bytes (6 Grids @ 8 Segments) 
00661 TM1637::DisplayData_t all_str   = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};  
00662 TM1637::DisplayData_t cls_str   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};  
00663 TM1637::DisplayData_t hello_str = {C7_H, C7_I, 0x00, 0x00, 0x00, 0x00};
00664 TM1637::DisplayData_t bye_str   = {C7_B, C7_Y, C7_E, 0x00, 0x00, 0x00};
00665 
00666 // KeyData_t size is 1 bytes  
00667 TM1637::KeyData_t keydata; 
00668 
00669 //TM1637_EYEWINK declaration
00670 //New Constructor
00671 TM1637_EYEWINK EYEWINK(p6, p7);       //LPC1768
00672 //TM1637_EYEWINK EYEWINK(D9, D10);      //F401
00673 
00674 void show_menu() {
00675 //    pc.printf("0:   Exit\n\r");
00676     pc.printf("1:   All\n\r");    
00677     pc.printf("2:   Show all segs\r\n");
00678     pc.printf("3:   Show all chars\n\r");
00679     pc.printf("4:   Show all digits\n\r");
00680     pc.printf("5:   Show all icons\n\r");
00681     pc.printf("6:   Counter\n\r");
00682     pc.printf("7:   Floats\n\r");
00683     pc.printf("8:   Kitt\n\r");
00684     pc.printf("9:   Cls\n\r");
00685     pc.printf("A:   Bye\n\r");
00686     pc.printf("k:   Key\n\r");    
00687 }
00688 
00689 
00690 char cmd, bits;
00691 int main() {
00692     
00693     pc.printf("Hello World\r\n"); //    
00694     
00695     EYEWINK.cls(); 
00696     EYEWINK.writeData(all_str);
00697     wait(2);
00698     EYEWINK.setBrightness(TM1637_BRT3);    
00699     wait(1);
00700     EYEWINK.setBrightness(TM1637_BRT0);        
00701     wait(1);
00702     EYEWINK.setBrightness(TM1637_BRT4);            
00703 
00704     wait(1);
00705     EYEWINK.cls(true); 
00706     EYEWINK.writeData(hello_str); 
00707     
00708     char cmd2 = '0';
00709     while (1) {
00710       
00711       show_menu();
00712       cmd2 = pc.getc();
00713 
00714       switch (cmd2) {
00715         case '1' : {
00716                       pc.printf("all\r\n");
00717                       EYEWINK.cls(); 
00718                       EYEWINK.writeData(all_str);
00719                       break;
00720         }
00721 
00722         case '2' : {
00723 #if(1)
00724 //test to show all segs
00725           pc.printf("Show all segs\r\n");
00726           wait(1);          
00727           EYEWINK.cls(); 
00728          
00729           for (int i=0; i<TM1637_DISPLAY_MEM; i++) {            
00730             for (int bit=0; bit<8; bit++) {
00731               EYEWINK.cls(); 
00732 
00733               bits = 0x01 << bit;              
00734               EYEWINK.writeData(bits, i);
00735 
00736               pc.printf("Idx = %d, Bits = 0x%02x\r\n", i, bits);              
00737 //              wait(0.5);
00738               cmd = pc.getc(); // wait for key
00739             }  
00740           }
00741           pc.printf("\r\nShow all segs done\r\n");                    
00742 #endif 
00743           break;          
00744         }
00745 
00746         case '3' : {
00747 
00748 #if(1)
00749 //test to show all chars
00750           pc.printf("Show all alpha chars\r\n");
00751           wait(1);          
00752           EYEWINK.cls(); 
00753          
00754           for (int i=0; i<26; i++) {
00755             EYEWINK.printf("%c", char(i + 'A'));
00756 //            EYEWINK.printf("%c", char(i + 'a'));            
00757             wait(0.25);                      
00758           }
00759           pc.printf("Show all alpha chars done\r\n");                    
00760 #endif            
00761 
00762 #if(0)
00763 //test to show all chars
00764           pc.printf("Show all chars\r\n");
00765           wait(1);          
00766           EYEWINK.cls(); 
00767 
00768           for (int i=FONT_7S_START; i<FONT_7S_END; i++) {
00769             EYEWINK.printf("%c", char(i));
00770 //            wait(0.25);
00771             cmd = pc.getc(); // wait for key            
00772           }
00773           pc.printf("Show all chars done\r\n");                    
00774 #endif            
00775           break;          
00776         }
00777         case '4': {
00778 #if(0)
00779 //test to show all digits (base is 10)
00780           pc.printf("Show all digits\r\n");
00781           wait(1);          
00782           EYEWINK.cls(); 
00783 
00784           for (int i=0; i<EYEWINK_NR_DIGITS; i++) {
00785 
00786             for (int cnt=0; cnt<10; cnt++) {
00787               EYEWINK.locate(i);
00788               EYEWINK.printf("%0d", cnt);
00789 
00790 //              wait(0.5);
00791               cmd = pc.getc(); // wait for key
00792             }  
00793           }
00794           pc.printf("\r\nShow all digits done\r\n");                    
00795 #endif                
00796 
00797 #if(1)
00798 //test to show all digits (base is 0x10)
00799           pc.printf("Show all hex digits\r\n");
00800           wait(1);          
00801           EYEWINK.cls(); 
00802 
00803           EYEWINK.printf("%06x", 0x01ABCD);
00804           cmd = pc.getc(); // wait for key                                     
00805           EYEWINK.printf("%06x", 0x0);
00806                     
00807           for (int i=0; i<EYEWINK_NR_DIGITS; i++) {
00808 
00809             for (int cnt=0; cnt<0x10; cnt++) {
00810               EYEWINK.locate(i);
00811               EYEWINK.printf("%0x", cnt);
00812 
00813 //              wait(0.5);
00814               cmd = pc.getc(); // wait for key
00815             }  
00816           }
00817           pc.printf("\r\nShow all hex digits done\r\n");          
00818 #endif                
00819           break;          
00820         }
00821         case '5':  { 
00822 #if(1)
00823 //test to show all icons
00824           pc.printf("Show all icons\r\n");
00825           EYEWINK.cls(true); // Also clear all Icons
00826           
00827           float delay=0.1;
00828           // Icons on             
00829           EYEWINK.setIcon(TM1637_EYEWINK::DP1); wait(delay);
00830           EYEWINK.setIcon(TM1637_EYEWINK::DP2); wait(delay);
00831           EYEWINK.setIcon(TM1637_EYEWINK::DP3); wait(delay);
00832           EYEWINK.setIcon(TM1637_EYEWINK::DP4); wait(delay);
00833           EYEWINK.setIcon(TM1637_EYEWINK::DP5); wait(delay);
00834           EYEWINK.setIcon(TM1637_EYEWINK::DP6); wait(delay);                                                  
00835 
00836           wait(delay);
00837  
00838           // Icons off      
00839           EYEWINK.clrIcon(TM1637_EYEWINK::DP6); wait(delay);
00840           EYEWINK.clrIcon(TM1637_EYEWINK::DP5); wait(delay);
00841           EYEWINK.clrIcon(TM1637_EYEWINK::DP4); wait(delay);
00842           EYEWINK.clrIcon(TM1637_EYEWINK::DP3); wait(delay);
00843           EYEWINK.clrIcon(TM1637_EYEWINK::DP2); wait(delay);
00844           EYEWINK.clrIcon(TM1637_EYEWINK::DP1); wait(delay);                                        
00845 
00846 //          wait(1);          
00847 //          EYEWINK.cls(); // clear all, preserve Icons
00848           pc.printf("Show all icons done\r\n");                    
00849 #endif           
00850           break;
00851         }                          
00852 
00853         case '6': {
00854           EYEWINK.cls(); // clear all, preserve Icons
00855 
00856 #if(1)
00857           EYEWINK.locate(0);
00858          
00859           for (int cnt=0; cnt<=0xFF; cnt++) {
00860             EYEWINK.locate(4);
00861             EYEWINK.printf("%02x", cnt);           
00862             wait(0.2);
00863           }  
00864 #endif
00865 
00866 //          EYEWINK.writeData(hello_str);
00867 //          EYEWINK.printf("hello");                  
00868 
00869           break;          
00870         }
00871         case '7': {
00872           EYEWINK.cls(); // clear all, preserve Icons
00873           EYEWINK.printf("%1.4f", -0.1234);  // test decimal point display
00874           wait(0.5);
00875           EYEWINK.cls(); // clear all, preserve Icons          
00876           EYEWINK.printf("%3.3f", 123.456);  // test decimal point display
00877           break;          
00878         }
00879 
00880         case '8': {
00881 
00882 #if(1)
00883 //test to show KITT
00884           pc.printf("Show KITT scanner\r\n");
00885 
00886           
00887 //                          012345
00888 const char KITT[][7]   = {{"8     "},
00889                           {"38    "},
00890                           {" 38   "},
00891                           {"  38  "},
00892                           {"   38 "},
00893                           {"    38"},
00894                           {"     3"},
00895                           {"      "},
00896                           {"     8"},
00897                           {"    8E"},
00898                           {"   8E "},
00899                           {"  8E  "},
00900                           {" 8E   "},
00901                           {"8E    "},
00902                           {"E     "},
00903                           {"      "}
00904                         };     
00905          
00906           EYEWINK.cls(); // clear all, preserve Icons
00907           
00908           while (!pc.readable()) { // wait for key            
00909             for (int i=0; i < (sizeof(KITT) / 7) ; i++) {
00910               EYEWINK.locate(0);
00911               EYEWINK.printf("%s", KITT[i]);
00912               wait(0.1);
00913             }
00914           }
00915           cmd = pc.getc(); // read key           
00916           pc.printf("Show KITT done\r\n");
00917 #endif
00918           break;
00919         }  
00920 
00921 
00922         case '9': {
00923           EYEWINK.cls(true); // clear all, including Icons      
00924           break;
00925         }  
00926 
00927         case 'A': {
00928 
00929           EYEWINK.cls(); // clear all, preserve Icons
00930 //          EYEWINK.writeData(bye_str);
00931           EYEWINK.printf("Bye");          
00932        
00933           break;
00934         } 
00935 
00936         case 'k': {
00937           if (EYEWINK.getKeys(&keydata)) {
00938             pc.printf("Keydata = 0x%02X\r\n", keydata);
00939           } 
00940           break;
00941         }       
00942 
00943         default : {
00944           break;
00945         }         
00946      
00947       } //switch cmd
00948 
00949 #if(1)
00950       // Check and read keydata
00951       if (EYEWINK.getKeys(&keydata)) {
00952         pc.printf("Keydata = 0x%02X\r\n", keydata);
00953 
00954         if (keydata == TM1637_SW1_BIT) { //sw1 0xEF 
00955           EYEWINK.cls(); 
00956           EYEWINK.printf("----01");
00957         }  
00958 
00959         if (keydata == TM1637_SW2_BIT) { //sw2  0x6F
00960           EYEWINK.cls(); 
00961           EYEWINK.printf("----02");          
00962         }  
00963 
00964         if (keydata == TM1637_SW3_BIT) { //sw3 0xAF 
00965           EYEWINK.cls(); 
00966           EYEWINK.printf("----03");
00967         }  
00968 
00969         if (keydata == TM1637_SW4_BIT) { //sw4 0x2F
00970           EYEWINK.cls(); 
00971           EYEWINK.printf("----04");          
00972         }  
00973 
00974         if (keydata == TM1637_SW5_BIT) { //sw5 0xCF 
00975           EYEWINK.cls(); 
00976           EYEWINK.printf("----05");
00977         }  
00978 
00979         if (keydata == TM1637_SW6_BIT) { //sw6 0x4F
00980           EYEWINK.cls(); 
00981           EYEWINK.printf("----06");          
00982         }  
00983 
00984       } // Check keydata
00985 #endif
00986 
00987 
00988       myled = !myled;
00989       wait(0.3);      
00990     } //while
00991 }
00992 #endif
00993 
00994 
00995 
00996 #if (TM1637_TEST == 1)
00997 // Direct TM1637 Test
00998 
00999 Serial pc(USBTX, USBRX);
01000 DigitalOut myled(LED1);
01001 
01002 // DisplayData_t size is 6 bytes (6 Grids @ 8 Segments) 
01003 TM1637::DisplayData_t all_str   = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};  
01004 TM1637::DisplayData_t cls_str   = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};  
01005 
01006 // KeyData_t size is 1 bytes  
01007 TM1637::KeyData_t keydata; 
01008 
01009 // TM1637 declaration
01010 //Old Constructor
01011 //TM1637 TM1637(p5,p6,p7);  //LPC1768
01012 //New Constructor
01013 TM1637 TM1637(p6,p7);     //LPC1768
01014 
01015 void show_menu() {
01016 //    pc.printf("0:   Exit\n\r");
01017     pc.printf("1:   All\n\r");    
01018     pc.printf("2:   Cls\n\r");        
01019     pc.printf("3:   Show all segs\r\n");
01020 }
01021 
01022 
01023 char cmd, bits;
01024 int main() {
01025     
01026     pc.printf("Hello World\r\n"); //    
01027     
01028     TM1637.cls(); 
01029     TM1637.writeData(all_str);
01030     wait(2);
01031     TM1637.setBrightness(TM1637_BRT3);    
01032     wait(1);
01033     TM1637.setBrightness(TM1637_BRT0);        
01034     wait(1);
01035     TM1637.setBrightness(TM1637_BRT4);            
01036     
01037     while (1) {
01038      
01039       cmd = pc.getc();
01040 
01041       switch (cmd) {
01042         case '1' : 
01043           TM1637.cls(); 
01044           TM1637.writeData(all_str);
01045          break;    
01046                
01047         case '2' :       
01048           TM1637.cls(); 
01049           TM1637.writeData(cls_str);
01050          break;    
01051                
01052         case '3' :
01053 
01054 #if(1)
01055 //test to show all segs
01056           pc.printf("Show all segs\r\n");
01057           wait(1);          
01058           TM1637.cls(); 
01059          
01060           for (int i=0; i<TM1637_DISPLAY_MEM; i++) {            
01061             for (int bit=0; bit<8; bit++) {
01062               TM1637.cls(); 
01063 
01064               bits = 0x01 << bit;              
01065               TM1637.writeData(bits, i);
01066 
01067               pc.printf("Idx = %d, Bits = 0x%02x\r\n", i, bits);              
01068 //              wait(0.5);
01069               cmd = pc.getc(); // wait for key
01070             }  
01071           }
01072           pc.printf("Show all segs done\r\n");                    
01073 #endif 
01074          break;    
01075                        
01076         default : 
01077           break;          
01078      
01079       } //switch cmd
01080 
01081       // Check and read keydata
01082       if (TM1637.getKeys(&keydata)) {
01083         pc.printf("Keydata = 0x%02x\r\n", keydata);
01084  
01085         if (keydata == TM1637_SW9_BIT) { //sw9  
01086           TM1637.cls(); 
01087           TM1637.writeData(0xFF, 1);
01088           TM1637.writeData(0xFF, 2);          
01089         }  
01090       } // Check keydata
01091 
01092       myled = !myled;
01093       wait(0.3);      
01094     } //while
01095 }
01096 #endif