mon_hw_LPC1768.cpp

00001 /*
00002  * mbed Application program for the mbed LPC1768 Board
00003  * Monitor program Ver.3 for only for LPC1768
00004  *
00005  *  Copyright (c) 2010-2014 Kenji Arai / JH1PJL
00006  *  http://www.page.sannet.ne.jp/kenjia/index.html
00007  *  http://mbed.org/users/kenjiArai/
00008  *      Started: May        9th, 2010
00009  *      Created: May       15th, 2010
00010  *          release as "monitor_01" http://mbed.org/users/kenjiArai/code/monitor_01/
00011  *      restart: September 22nd, 2014
00012  *      Revised: Nobember   2nd, 2014
00013  *
00014  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
00015  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
00016  * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
00017  * DAMAGES OR OTHER  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00018  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00019  */
00020 
00021 #if defined(TARGET_LPC1768)
00022 
00023 //  Include ---------------------------------------------------------------------------------------
00024 #include "mbed.h"
00025 #include "mon_hw_config.h"
00026 #include "mon_hw_common.h"
00027 
00028 //  Object ----------------------------------------------------------------------------------------
00029 
00030 //  Definition ------------------------------------------------------------------------------------
00031 // Define clocks
00032 #define XTAL                (12000000UL)        // Oscillator frequency
00033 #define OSC_CLK             (      XTAL)        // Main oscillator frequency
00034 #define RTC_CLK             (   32000UL)        // RTC oscillator frequency
00035 #define IRC_OSC             ( 4000000UL)        // Internal RC oscillator frequency
00036 
00037 //  RAM -------------------------------------------------------------------------------------------
00038 uint32_t SystemFrequency;
00039 
00040 //  ROM / Constant data ---------------------------------------------------------------------------
00041 #if USE_MEM
00042 //  Memory range data
00043 const uint32_t mem_range[][2] = {   // Memory access range
00044     { 0x00000000, 0x0007ffff },     // On-chip non-volatile memory     // 512KB Flash memory
00045     { 0x10000000, 0x10007fff },     // On-chip SRAM                    // 32KB local RAM
00046     { 0x1fff0000, 0x1fff1fff },     // Boot ROM                        // 8KB Boot ROM
00047     { 0x2007c000, 0x2007ffff },     // On-chip SRAM                    // 16KB AHB SRAM
00048     { 0x20080000, 0x20083fff }      // On-chip SRAM                    // 16KB AHB SRAM
00049 };
00050 #endif // USE_MEM
00051 
00052 char *const mon_msg = "HW monitor only for mbed LPC1768 created on "__DATE__","__TIME__"";
00053 char *const xmsg0 = "Not implimented yet";
00054 
00055 char *const hmsg0 = "m  - Entry Memory Mode";
00056 char *const hmsg1 = "m>? -> Help ";
00057 char *const hmsg2 = "r  - Show PORT,I2C,SPI,UART & other Reg.";
00058 char *const hmsg3 = "r>? -> Help";
00059 char *const hmsg4 = "sf - System Clock";
00060 char *const hmsg5 = "sc - System / CPU information";
00061 char *const hmsg6 = "x  - Special command for Debug";
00062 char *const hmsg7 = "q  - Quit (back to called routine)";
00063 
00064 //  Function prototypes ---------------------------------------------------------------------------
00065 
00066 //-------------------------------------------------------------------------------------------------
00067 //  Control Program
00068 //-------------------------------------------------------------------------------------------------
00069 // No function
00070 static void not_yet_impliment( void )
00071 {
00072     PRINTF(xmsg0);
00073     put_rn();
00074 }
00075 
00076 // No function
00077 #if (USE_MEM==0)||(USE_PORT==0)||(USE_UART==0)||(USE_SPI==0)||(USE_I2C==0)||(USE_SYS==0)
00078 static void not_select( void )
00079 {
00080     PRINTF("Not select the function (refer mon_hw_config.h)");
00081     put_rn();
00082 }
00083 #endif
00084 
00085 //  Help Massage
00086 void msg_hlp_hw (void)
00087 {
00088     PRINTF(mon_msg);
00089     put_rn();
00090     PRINTF(hmsg0);
00091     put_rn();
00092     PRINTF(hmsg1);
00093     put_rn();
00094     PRINTF(hmsg2);
00095     put_rn();
00096     PRINTF(hmsg3);
00097     put_rn();
00098     PRINTF(hmsg4);
00099     put_rn();
00100     PRINTF(hmsg5);
00101     put_rn();
00102     PRINTF(hmsg6);
00103     put_rn();
00104     PRINTF(hmsg7);
00105     put_rn();
00106 }
00107 
00108 #if USE_MEM
00109 char *const rmsg0 = "FLASH     ";
00110 char *const rmsg1 = "SRAM      ";
00111 char *const rmsg2 = "Boot ROM  ";
00112 char *const rmsg3 = "AHB SRAM0 ";
00113 char *const rmsg4 = "AHB SRAM1 ";
00114 
00115 #include "mon_hw_mem.h"
00116 #endif   // USE_MEM
00117 
00118 #if USE_PORT
00119 void io_condition(uint32_t reg0, uint32_t reg1, uint8_t shift)
00120 {
00121     PRINTF("IO->");
00122     if (reg0 & (1UL << shift)) {
00123         PRINTF("Output=");
00124     } else {
00125         PRINTF("Input =");
00126     }
00127     if (reg1 & (1UL << shift)) {
00128         PUTC('1');
00129     } else {
00130         PUTC('0');
00131     }
00132 }
00133 
00134 void port_config_left(void)
00135 {
00136     uint32_t r0,r1;
00137 
00138     // p5(P0.9)
00139     PRINTF("p 5(P0. 9):");
00140     r0 = LPC_PINCON->PINSEL0;
00141     r0 = (r0 >> 18) & 0x03;
00142     switch (r0) {
00143         case 0:
00144             r0 = LPC_GPIO0->FIODIR;
00145             r1 = LPC_GPIO0->FIOPIN;
00146             io_condition(r0, r1, 9);
00147             break;
00148         case 1:
00149             PRINTF("I2STX_SDA");
00150             break;
00151         case 2:
00152             PRINTF("MOSI1");
00153             break;
00154         case 3:
00155             PRINTF("MAT2.3");
00156             break;
00157     }
00158     put_rn();
00159     // p6(P0.8)
00160     PRINTF("p 6(P0. 8):");
00161     r0 = LPC_PINCON->PINSEL0;
00162     r0 = (r0 >> 16) & 0x03;
00163     switch (r0) {
00164         case 0:
00165             r0 = LPC_GPIO0->FIODIR;
00166             r1 = LPC_GPIO0->FIOPIN;
00167             io_condition(r0, r1, 8);
00168             break;
00169         case 1:
00170             PRINTF("I2STX_WS");
00171             break;
00172         case 2:
00173             PRINTF("MISO1");
00174             break;
00175         case 3:
00176             PRINTF("MAT2.2");
00177             break;
00178     }
00179     put_rn();
00180     // p7(P0.7)
00181     PRINTF("p 7(P0. 7):");
00182     r0 = LPC_PINCON->PINSEL0;
00183     r0 = (r0 >> 14) & 0x03;
00184     switch (r0) {
00185         case 0:
00186             r0 = LPC_GPIO0->FIODIR;
00187             r1 = LPC_GPIO0->FIOPIN;
00188             io_condition(r0, r1, 7);
00189             break;
00190         case 1:
00191             PRINTF("I2STX_CLK");
00192             break;
00193         case 2:
00194             PRINTF("SCK1");
00195             break;
00196         case 3:
00197             PRINTF("MAT2.1");
00198             break;
00199     }
00200     put_rn();
00201     // p8(P0.6)
00202     PRINTF("p 8(P0. 6):");
00203     r0 = LPC_PINCON->PINSEL0;
00204     r0 = (r0 >> 12) & 0x03;
00205     switch (r0) {
00206         case 0:
00207             r0 = LPC_GPIO0->FIODIR;
00208             r1 = LPC_GPIO0->FIOPIN;
00209             io_condition(r0, r1, 6);
00210             break;
00211         case 1:
00212             PRINTF("I2SRX_SDA");
00213             break;
00214         case 2:
00215             PRINTF("SSEL1");
00216             break;
00217         case 3:
00218             PRINTF("MAT2.0");
00219             break;
00220     }
00221     put_rn();
00222     // p9(P0.0)
00223     PRINTF("p 9(P0. 0):");
00224     r0 = LPC_PINCON->PINSEL0;
00225     r0 = (r0 >> 0) & 0x03;
00226     switch (r0) {
00227         case 0:
00228             r0 = LPC_GPIO0->FIODIR;
00229             r1 = LPC_GPIO0->FIOPIN;
00230             io_condition(r0, r1, 0);
00231             break;
00232         case 1:
00233             PRINTF("RD1");
00234             break;
00235         case 2:
00236             PRINTF("TXD3");
00237             break;
00238         case 3:
00239             PRINTF("SDA1");
00240             break;
00241     }
00242     put_rn();
00243     // p10(P0.1)
00244     PRINTF("p10(P0. 1):");
00245     r0 = LPC_PINCON->PINSEL0;
00246     r0 = (r0 >> 2) & 0x03;
00247     switch (r0) {
00248         case 0:
00249             r0 = LPC_GPIO0->FIODIR;
00250             r1 = LPC_GPIO0->FIOPIN;
00251             io_condition(r0, r1, 1);
00252             break;
00253         case 1:
00254             PRINTF("TD1");
00255             break;
00256         case 2:
00257             PRINTF("RXD3");
00258             break;
00259         case 3:
00260             PRINTF("SCL1");
00261             break;
00262     }
00263     put_rn();
00264     // p11(P0.18)
00265     PRINTF("p11(P0.18):");
00266     r0 = LPC_PINCON->PINSEL1;
00267     r0 = (r0 >> 4) & 0x03;
00268     switch (r0) {
00269         case 0:
00270             r0 = LPC_GPIO0->FIODIR;
00271             r1 = LPC_GPIO0->FIOPIN;
00272             io_condition(r0, r1, 18);
00273             break;
00274         case 1:
00275             PRINTF("DCD1");
00276             break;
00277         case 2:
00278             PRINTF("MOSI0");
00279             break;
00280         case 3:
00281             PRINTF("MOSI");
00282             break;
00283     }
00284     put_rn();
00285     // p12(P0.17)
00286     PRINTF("p12(P0.17):");
00287     r0 = LPC_PINCON->PINSEL1;
00288     r0 = (r0 >> 2) & 0x03;
00289     switch (r0) {
00290         case 0:
00291             r0 = LPC_GPIO0->FIODIR;
00292             r1 = LPC_GPIO0->FIOPIN;
00293             io_condition(r0, r1, 17);
00294             break;
00295         case 1:
00296             PRINTF("CTS1");
00297             break;
00298         case 2:
00299             PRINTF("MISO0");
00300             break;
00301         case 3:
00302             PRINTF("MISO");
00303             break;
00304     }
00305     put_rn();
00306     // p13(P0.15)
00307     PRINTF("p13(P0.15):");
00308     r0 = LPC_PINCON->PINSEL0;
00309     r0 = (r0 >> 30) & 0x03;
00310     switch (r0) {
00311         case 0:
00312             r0 = LPC_GPIO0->FIODIR;
00313             r1 = LPC_GPIO0->FIOPIN;
00314             io_condition(r0, r1, 15);
00315             break;
00316         case 1:
00317             PRINTF("TXD1");
00318             break;
00319         case 2:
00320             PRINTF("SCK0");
00321             break;
00322         case 3:
00323             PRINTF("SCK");
00324             break;
00325     }
00326     put_rn();
00327     // p14(P0.16)
00328     PRINTF("p14(P0.16):");
00329     r0 = LPC_PINCON->PINSEL1;
00330     r0 = (r0 >> 0) & 0x03;
00331     switch (r0) {
00332         case 0:
00333             r0 = LPC_GPIO0->FIODIR;
00334             r1 = LPC_GPIO0->FIOPIN;
00335             io_condition(r0, r1, 16);
00336             break;
00337         case 1:
00338             PRINTF("RXD1");
00339             break;
00340         case 2:
00341             PRINTF("SSEL0");
00342             break;
00343         case 3:
00344             PRINTF("SSEL");
00345             break;
00346     }
00347     put_rn();
00348     // p15(P0.23)
00349     PRINTF("p15(P0.23):");
00350     r0 = LPC_PINCON->PINSEL1;
00351     r0 = (r0 >> 14) & 0x03;
00352     switch (r0) {
00353         case 0:
00354             r0 = LPC_GPIO0->FIODIR;
00355             r1 = LPC_GPIO0->FIOPIN;
00356             io_condition(r0, r1, 23);
00357             break;
00358         case 1:
00359             PRINTF("AD0.0");
00360             break;
00361         case 2:
00362             PRINTF("I2SRX_CLK");
00363             break;
00364         case 3:
00365             PRINTF("CAP3.0");
00366             break;
00367     }
00368     put_rn();
00369     // p16(P0.24)
00370     PRINTF("p16(P0.24):");
00371     r0 = LPC_PINCON->PINSEL1;
00372     r0 = (r0 >> 16) & 0x03;
00373     switch (r0) {
00374         case 0:
00375             r0 = LPC_GPIO0->FIODIR;
00376             r1 = LPC_GPIO0->FIOPIN;
00377             io_condition(r0, r1, 24);
00378             break;
00379         case 1:
00380             PRINTF("AD0.1");
00381             break;
00382         case 2:
00383             PRINTF("I2SRX_WS");
00384             break;
00385         case 3:
00386             PRINTF("CAP3.1");
00387             break;
00388     }
00389     put_rn();
00390     // p17(P0.25)
00391     PRINTF("p17(P0.25):");
00392     r0 = LPC_PINCON->PINSEL1;
00393     r0 = (r0 >> 18) & 0x03;
00394     switch (r0) {
00395         case 0:
00396             r0 = LPC_GPIO0->FIODIR;
00397             r1 = LPC_GPIO0->FIOPIN;
00398             io_condition(r0, r1, 25);
00399             break;
00400         case 1:
00401             PRINTF("AD0.2");
00402             break;
00403         case 2:
00404             PRINTF("I2SRX_SDA");
00405             break;
00406         case 3:
00407             PRINTF("TXD3");
00408             break;
00409     }
00410     put_rn();
00411     // p18(P0.26)
00412     PRINTF("p18(P0.26):");
00413     r0 = LPC_PINCON->PINSEL1;
00414     r0 = (r0 >> 20) & 0x03;
00415     switch (r0) {
00416         case 0:
00417             r0 = LPC_GPIO0->FIODIR;
00418             r1 = LPC_GPIO0->FIOPIN;
00419             io_condition(r0, r1, 26);
00420             break;
00421         case 1:
00422             PRINTF("AD0.3");
00423             break;
00424         case 2:
00425             PRINTF("AOUT");
00426             break;
00427         case 3:
00428             PRINTF("RXD3");
00429             break;
00430     }
00431     put_rn();
00432     // p19(P1.30)
00433     PRINTF("p19(P1.30):");
00434     r0 = LPC_PINCON->PINSEL3;
00435     r0 = (r0 >> 28) & 0x03;
00436     switch (r0) {
00437         case 0:
00438             r0 = LPC_GPIO1->FIODIR;
00439             r1 = LPC_GPIO1->FIOPIN;
00440             io_condition(r0, r1, 30);
00441             break;
00442         case 1:
00443             PRINTF("Reserved");
00444             break;
00445         case 2:
00446             PRINTF("VBUS");
00447             break;
00448         case 3:
00449             PRINTF("AD0.4");
00450             break;
00451     }
00452     put_rn();
00453     // p20(P1.31)
00454     PRINTF("p20(P1.31):");
00455     r0 = LPC_PINCON->PINSEL3;
00456     r0 = (r0 >> 30) & 0x03;
00457     switch (r0) {
00458         case 0:
00459             r0 = LPC_GPIO1->FIODIR;
00460             r1 = LPC_GPIO1->FIOPIN;
00461             io_condition(r0, r1, 31);
00462             break;
00463         case 1:
00464             PRINTF("Reserved");
00465             break;
00466         case 2:
00467             PRINTF("SCK1");
00468             break;
00469         case 3:
00470             PRINTF("AD0.5");
00471             break;
00472     }
00473     put_rn();
00474 }
00475 
00476 void port_config_right(void)
00477 {
00478     uint32_t r0, r1;
00479 
00480     // p30(P0.4)
00481     PRINTF("p30(P0. 4):");
00482     r0 = LPC_PINCON->PINSEL0;
00483     r0 = (r0 >> 8) & 0x03;
00484     switch (r0) {
00485         case 0:
00486             r0 = LPC_GPIO0->FIODIR;
00487             r1 = LPC_GPIO0->FIOPIN;
00488             io_condition(r0, r1, 4);
00489             break;
00490         case 1:
00491             PRINTF("I2SRX_CLK");
00492             break;
00493         case 2:
00494             PRINTF("RD2");
00495             break;
00496         case 3:
00497             PRINTF("CAP2.0");
00498             break;
00499     }
00500     put_rn();
00501     // p29(P0.5)
00502     PRINTF("p29(P0. 5):");
00503     r0 = LPC_PINCON->PINSEL0;
00504     r0 = (r0 >> 10) & 0x03;
00505     switch (r0) {
00506         case 0:
00507             r0 = LPC_GPIO0->FIODIR;
00508             r1 = LPC_GPIO0->FIOPIN;
00509             io_condition(r0, r1, 5);
00510             break;
00511         case 1:
00512             PRINTF("I2SRX_WS");
00513             break;
00514         case 2:
00515             PRINTF("TD2");
00516             break;
00517         case 3:
00518             PRINTF("CAP2.1");
00519             break;
00520     }
00521     put_rn();
00522     // p28(P0.10)
00523     PRINTF("p28(P0.10):");
00524     r0 = LPC_PINCON->PINSEL0;
00525     r0 = (r0 >> 20) & 0x03;
00526     switch (r0) {
00527         case 0:
00528             r0 = LPC_GPIO0->FIODIR;
00529             r1 = LPC_GPIO0->FIOPIN;
00530             io_condition(r0, r1, 10);
00531             break;
00532         case 1:
00533             PRINTF("TXD2");
00534             break;
00535         case 2:
00536             PRINTF("SDA2");
00537             break;
00538         case 3:
00539             PRINTF("MAT3.0");
00540             break;
00541     }
00542     put_rn();
00543     // p27(P0.11)
00544     PRINTF("p27(P0.11):");
00545     r0 = LPC_PINCON->PINSEL0;
00546     r0 = (r0 >> 22) & 0x03;
00547     switch (r0) {
00548         case 0:
00549             r0 = LPC_GPIO0->FIODIR;
00550             r1 = LPC_GPIO0->FIOPIN;
00551             io_condition(r0, r1, 11);
00552             break;
00553         case 1:
00554             PRINTF("RXD2");
00555             break;
00556         case 2:
00557             PRINTF("SCL2");
00558             break;
00559         case 3:
00560             PRINTF("MAT3.1");
00561             break;
00562     }
00563     put_rn();
00564     // p26(P2.0)
00565     PRINTF("p26(P2. 0):");
00566     r0 = LPC_PINCON->PINSEL4;
00567     r0 = (r0 >> 0) & 0x03;
00568     switch (r0) {
00569         case 0:
00570             r0 = LPC_GPIO2->FIODIR;
00571             r1 = LPC_GPIO2->FIOPIN;
00572             io_condition(r0, r1, 0);
00573             break;
00574         case 1:
00575             PRINTF("PWM1.1");
00576             break;
00577         case 2:
00578             PRINTF("TXD1");
00579             break;
00580         case 3:
00581             PRINTF("Reserved");
00582             break;
00583     }
00584     put_rn();
00585     // p25(P2.1)
00586     PRINTF("p25(P2. 1):");
00587     r0 = LPC_PINCON->PINSEL4;
00588     r0 = (r0 >> 2) & 0x03;
00589     switch (r0) {
00590         case 0:
00591             r0 = LPC_GPIO2->FIODIR;
00592             r1 = LPC_GPIO2->FIOPIN;
00593             io_condition(r0, r1, 1);
00594             break;
00595         case 1:
00596             PRINTF("PWM1.2");
00597             break;
00598         case 2:
00599             PRINTF("RXD1");
00600             break;
00601         case 3:
00602             PRINTF("Reserved");
00603             break;
00604     }
00605     put_rn();
00606     // p24(P2.2)
00607     PRINTF("p24(P2. 2):");
00608     r0 = LPC_PINCON->PINSEL4;
00609     r0 = (r0 >> 4) & 0x03;
00610     switch (r0) {
00611         case 0:
00612             r0 = LPC_GPIO2->FIODIR;
00613             r1 = LPC_GPIO2->FIOPIN;
00614             io_condition(r0, r1, 2);
00615             break;
00616         case 1:
00617             PRINTF("PWM1.3");
00618             break;
00619         case 2:
00620             PRINTF("CTS1");
00621             break;
00622         case 3:
00623             PRINTF("Reserved");
00624             break;
00625     }
00626     put_rn();
00627     // p23(P2.3)
00628     PRINTF("p23(P2. 3):");
00629     r0 = LPC_PINCON->PINSEL4;
00630     r0 = (r0 >> 6) & 0x03;
00631     switch (r0) {
00632         case 0:
00633             r0 = LPC_GPIO2->FIODIR;
00634             r1 = LPC_GPIO2->FIOPIN;
00635             io_condition(r0, r1, 3);
00636             break;
00637         case 1:
00638             PRINTF("PWM1.4");
00639             break;
00640         case 2:
00641             PRINTF("DCD1");
00642             break;
00643         case 3:
00644             PRINTF("Reserved");
00645             break;
00646     }
00647     put_rn();
00648     // p22(P2.4)
00649     PRINTF("p22(P2. 4):");
00650     r0 = LPC_PINCON->PINSEL4;
00651     r0 = (r0 >> 8) & 0x03;
00652     switch (r0) {
00653         case 0:
00654             r0 = LPC_GPIO2->FIODIR;
00655             r1 = LPC_GPIO2->FIOPIN;
00656             io_condition(r0, r1, 4);
00657             break;
00658         case 1:
00659             PRINTF("PWM1.5");
00660             break;
00661         case 2:
00662             PRINTF("DSR1");
00663             break;
00664         case 3:
00665             PRINTF("Reserved");
00666             break;
00667     }
00668     put_rn();
00669     // p21(P2.5)
00670     PRINTF("p21(P2. 5):");
00671     r0 = LPC_PINCON->PINSEL4;
00672     r0 = (r0 >> 10) & 0x03;
00673     switch (r0) {
00674         case 0:
00675             r0 = LPC_GPIO2->FIODIR;
00676             r1 = LPC_GPIO2->FIOPIN;
00677             io_condition(r0, r1, 5);
00678             break;
00679         case 1:
00680             PRINTF("PWM1.6");
00681             break;
00682         case 2:
00683             PRINTF("DTR1");
00684             break;
00685         case 3:
00686             PRINTF("Reserved");
00687             break;
00688     }
00689     put_rn();
00690 }
00691 #endif  // USE_PORT
00692 
00693 //#if USE_SYS
00694 void cpu_inf ( void )
00695 {
00696     unsigned long m1, m2;
00697 
00698     m1 = SCB->CPUID;
00699     m2 = ( m1 >> 24 );
00700     if ( m2 == 0x41 ) {
00701         put_r();
00702         PRINTF("CPU = ARM ");
00703     } else {
00704         put_r();
00705         PRINTF("CPU = NOT ARM ");
00706     }
00707     m2 = ( m1 >> 4 ) & 0xfff;
00708     if ( m2 == 0xc23 ) {
00709         PRINTF("Cortex-M3");
00710         put_rn();
00711     } else {
00712         PRINTF("NOT Cortex-M3");
00713         put_rn();
00714     }
00715     m2 = ( m1 >> 20 ) & 0x0f;
00716     PRINTF("Variant:%x", m2);
00717     put_rn();
00718     m2 = m1 & 0x7;
00719     PRINTF("Revision:%x", m2);
00720     put_rn();
00721 }
00722 //#endif    // USE_SYS
00723 
00724 //  Calculate CPU System Clock Frequency
00725 void get_freq ( int pr )
00726 {
00727     if(pr) {
00728         put_r();
00729         PRINTF("System Clock = %dHz",SystemFrequency );
00730         put_rn();
00731     }
00732     if (((LPC_SC->PLL0STAT >> 24) & 3) == 3) {/* If PLL0 enabled and connected      */
00733         if(pr) {
00734             PRINTF("PLL0 enabled");
00735             put_rn();
00736         }
00737         switch (LPC_SC->CLKSRCSEL & 0x03) {
00738             case 0:                /* Internal RC oscillator => PLL0     */
00739             case 3:                /* Reserved, default to Internal RC   */
00740                 if(pr) {
00741                     PRINTF("Internal RC Oscillator");
00742                     put_rn();
00743                 }
00744                 SystemFrequency = (IRC_OSC *
00745                                    (((2 * ((LPC_SC->PLL0STAT & 0x7FFF) + 1))) /
00746                                     (((LPC_SC->PLL0STAT >> 16) & 0xFF) + 1))   /
00747                                    ((LPC_SC->CCLKCFG & 0xFF)+ 1));
00748                 break;
00749             case 1:                /* Main oscillator => PLL0            */
00750                 if(pr) {
00751                     PRINTF("Xtal Osc Clock = %dHz",XTAL );
00752                     put_rn();
00753                 }
00754                 SystemFrequency = (OSC_CLK *
00755                                    (((2 * ((LPC_SC->PLL0STAT & 0x7FFF) + 1))) /
00756                                     (((LPC_SC->PLL0STAT >> 16) & 0xFF) + 1))   /
00757                                    ((LPC_SC->CCLKCFG & 0xFF)+ 1));
00758                 break;
00759             case 2:                /* RTC oscillator => PLL0             */
00760                 if(pr) {
00761                     PRINTF("RTC Xtal Oscillator f = %dHz", RTC_CLK );
00762                     put_rn();
00763                 }
00764                 SystemFrequency = (RTC_CLK *
00765                                    (((2 * ((LPC_SC->PLL0STAT & 0x7FFF) + 1))) /
00766                                     (((LPC_SC->PLL0STAT >> 16) & 0xFF) + 1))   /
00767                                    ((LPC_SC->CCLKCFG & 0xFF)+ 1));
00768                 break;
00769         }
00770     } else {
00771         if(pr) {
00772             PRINTF("PLL0 disabled");
00773         }
00774         switch (LPC_SC->CLKSRCSEL & 0x03) {
00775             case 0:                /* Internal RC oscillator => PLL0     */
00776             case 3:                /* Reserved, default to Internal RC   */
00777                 if(pr) {
00778                     PRINTF("Internal RC Oscillator");
00779                     put_rn();
00780                 }
00781                 SystemFrequency = IRC_OSC / ((LPC_SC->CCLKCFG & 0xFF)+ 1);
00782                 break;
00783             case 1:                /* Main oscillator => PLL0            */
00784                 if(pr) {
00785                     PRINTF("Xtal Osc Clock = %dHz",XTAL );
00786                     put_rn();
00787                 }
00788                 SystemFrequency = OSC_CLK / ((LPC_SC->CCLKCFG & 0xFF)+ 1);
00789                 break;
00790             case 2:                /* RTC oscillator => PLL0             */
00791                 if(pr) {
00792                     PRINTF("RTC Xtal Oscillator f = %dHz", RTC_CLK );
00793                     put_rn();
00794                 }
00795                 SystemFrequency = RTC_CLK / ((LPC_SC->CCLKCFG & 0xFF)+ 1);
00796                 break;
00797         }
00798     }
00799 }
00800 
00801 #if (USE_UART==1)||(USE_SPI==1)||(USE_I2C==1)
00802 char *const uismsg0 = "is enable";
00803 char *const uismsg1 = "is disable";
00804 char *const uismsg2 = "(mbed pins are not avairable)";
00805 char *const uismsg3 = "Other";
00806 #endif
00807 
00808 #if USE_UART
00809 //  Show 16bit register contents
00810 void reg_print(uint16_t size, uint16_t reg)
00811 {
00812     uint16_t i, j, k, n;
00813 
00814     if (size == 8) {
00815         PRINTF(" 7, 6, 5, 4, 3, 2, 1, 0");
00816         put_rn();
00817         i = 8;
00818         n = 0x80;
00819     } else if (size == 16) {
00820         PRINTF( "15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0" );
00821         put_rn();
00822         i = 16;
00823         n = 0x8000;
00824     } else {
00825         PRINTF("0x%08x", reg);
00826         return;
00827     }
00828     PUTC(' ');
00829     for (; i>0; i--) {
00830         k = n >> (size-i);
00831         j = reg & k;
00832         if (j) {
00833             PUTC('1');
00834         } else {
00835             PUTC('0');
00836         }
00837         PUTC(' ');
00838         PUTC(' ');
00839     }
00840     PRINTF("  (0x%04x)", reg);
00841 }
00842 
00843 void uart_reg(uint8_t uart)
00844 {
00845     uint32_t c_lcr,c_fdr,c_dll,c_dlm;
00846     uint32_t divaddval,mulval,div,baud;
00847 
00848     PRINTF("<Show UART%d status>", uart);
00849     put_rn();
00850     c_lcr = c_fdr = c_dll = c_dlm = 0;
00851     divaddval = mulval = div = baud = 0;
00852     get_freq(0);
00853     switch (uart) {
00854         case 0:
00855             if (LPC_SC->PCONP & (1UL<<3)) {
00856                 c_fdr = LPC_UART0->FDR;
00857                 c_lcr = LPC_UART0->LCR;
00858                 // set LCR[DLAB] to enable writing to divider registers
00859                 LPC_UART0->LCR |= (1 << 7);
00860                 c_dll = LPC_UART0->DLL;
00861                 c_dlm = LPC_UART0->DLM;
00862                 // clear LCR[DLAB]
00863                 LPC_UART0->LCR &= ~(1 << 7);
00864                 div = (LPC_SC->PCLKSEL0 >> 6) & 0x3;
00865             }
00866             break;
00867         case 1:
00868             if (LPC_SC->PCONP & (1UL<<4)) {
00869                 c_fdr = LPC_UART1->FDR;
00870                 c_lcr = LPC_UART1->LCR;
00871                 // set LCR[DLAB] to enable writing to divider registers
00872                 LPC_UART1->LCR |= (1 << 7);
00873                 c_dll = LPC_UART1->DLL;
00874                 c_dlm = LPC_UART1->DLM;
00875                 // clear LCR[DLAB]
00876                 LPC_UART1->LCR &= ~(1 << 7);
00877                 div = (LPC_SC->PCLKSEL0 >> 8) & 0x3;
00878             }
00879             break;
00880         case 2:
00881             if (LPC_SC->PCONP & (1UL<<24)) {
00882                 c_fdr = LPC_UART2->FDR;
00883                 c_lcr = LPC_UART2->LCR;
00884                 // set LCR[DLAB] to enable writing to divider registers
00885                 LPC_UART2->LCR |= (1 << 7);
00886                 c_dll = LPC_UART2->DLL;
00887                 c_dlm = LPC_UART2->DLM;
00888                 // clear LCR[DLAB]
00889                 LPC_UART2->LCR &= ~(1 << 7);
00890                 div = (LPC_SC->PCLKSEL1 >> 16) & 0x3;
00891             }
00892             break;
00893         case 3:
00894             if (LPC_SC->PCONP & (1UL<<25)) {
00895                 c_fdr = LPC_UART3->FDR;
00896                 c_lcr = LPC_UART3->LCR;
00897                 // set LCR[DLAB] to enable writing to divider registers
00898                 LPC_UART3->LCR |= (1 << 7);
00899                 c_dll = LPC_UART3->DLL;
00900                 c_dlm = LPC_UART3->DLM;
00901                 // clear LCR[DLAB]
00902                 LPC_UART3->LCR &= ~(1 << 7);
00903                 div = (LPC_SC->PCLKSEL1 >> 18) & 0x3;
00904             }
00905             break;
00906         default:
00907             break;
00908     }
00909     if ((c_fdr == 0)&&(c_lcr == 0)&&(c_dll == 0)) {
00910         PRINTF("NOT Avairable (power off the UART module)");
00911     } else {
00912         // condition
00913         PRINTF("Word Length: ");
00914         switch ((c_lcr >> 0) & 0x03) {
00915             case 0:
00916                 PUTC('5');
00917                 break;
00918             case 1:
00919                 PUTC('6');
00920                 break;
00921             case 2:
00922                 PUTC('7');
00923                 break;
00924             case 3:
00925                 PUTC('8');
00926                 break;
00927         }
00928         PRINTF("-bit");
00929         put_rn();
00930         PRINTF("Stop bit: ");
00931         if (c_lcr & 0x04) {
00932             PUTC('1');
00933         } else {
00934             PUTC('2');
00935         }
00936         PRINTF("-bit");
00937         put_rn();
00938         PRINTF("Parity: ");
00939         if (c_lcr & 0x08) {
00940             switch ((c_lcr >> 4) & 0x03) {
00941                 case 0:
00942                     PRINTF("Odd");
00943                     break;
00944                 case 1:
00945                     PRINTF("Even");
00946                     break;
00947                 case 2:
00948                     PRINTF("Forced '1'");
00949                     break;
00950                 case 3:
00951                     PRINTF("Forced '0'");
00952                     break;
00953             }
00954             PRINTF(" parity");
00955         } else {
00956             PRINTF("None-Parity");
00957         }
00958         put_rn();
00959         switch (div) {
00960             case 0:
00961                 div = 4;
00962                 break;
00963             case 1:
00964                 div = 1;
00965                 break;
00966             case 2:
00967                 div = 2;
00968                 break;
00969             case 3:
00970                 div = 8;
00971                 break;
00972         }
00973         divaddval = (c_fdr >> 0) & 0x0f;
00974         mulval = (c_fdr >> 4) & 0x0f;
00975         baud =  (SystemCoreClock/div)/(16 * (256 * c_dlm + c_dll) * (1 + divaddval/mulval));
00976         PRINTF("Baud rate: %d bps", baud);
00977         put_rn();
00978         PRINTF(" = PCLK(=Sys/div)/(16 x (256 x DLM + DLL) x (1 + DivAddVal/MulVal)");
00979         put_rn();
00980         PRINTF(" = (%d/%d)/(16 x (256 x %d + %d) x (1 + %d/%d)",
00981                SystemCoreClock,div,c_dlm,c_dll,divaddval,mulval);
00982     }
00983     put_rn();
00984 }
00985 
00986 void uart_io_print (void)
00987 {
00988     PRINTF("<Show IO Pin>");
00989     put_rn();
00990 }
00991 
00992 void uart_io_reg0 (void)
00993 {
00994     uint32_t r0;
00995 
00996     PRINTF("UART0/USBTX(P0.2),USBRX(P0.3):");
00997     // P0.2
00998     r0 = LPC_PINCON->PINSEL0;
00999     r0 = (r0 >> 4) & 0x03;
01000     if (r0 == 1) {
01001         PRINTF("TXD0 ");
01002     } else {
01003         PRINTF(uismsg3);
01004     }
01005     // P0.3
01006     r0 = LPC_PINCON->PINSEL0;
01007     r0 = (r0 >> 6) & 0x03;
01008     if (r0 == 1) {
01009         PRINTF(",RXD0");
01010     } else {
01011         PRINTF(",%s", uismsg3);
01012     }
01013     PRINTF("(connected to PC via USB)");
01014     put_rn();
01015 }
01016 
01017 void uart_io_reg1 (void)
01018 {
01019     uint32_t r0;
01020 
01021     PRINTF("UART1/ p13(P0.15), p14(P0.16):");
01022     // P0.15
01023     r0 = LPC_PINCON->PINSEL0;
01024     r0 = (r0 >> 30) & 0x03;
01025     if (r0 == 1) {
01026         PRINTF("TXD1 ");
01027     } else {
01028         PRINTF(uismsg3);
01029     }
01030     // P0.16
01031     r0 = LPC_PINCON->PINSEL1;
01032     r0 = (r0 >> 2) & 0x03;
01033     if (r0 == 1) {
01034         PRINTF(",RXD1");
01035     } else {
01036         PRINTF(",%s", uismsg3);
01037     }
01038     put_rn();
01039 }
01040 
01041 void uart_io_reg2 (void)
01042 {
01043     uint32_t r0;
01044 
01045     PRINTF("UART2/ p28(P0.10), p27(P0.11):");
01046     // P0.10
01047     r0 = LPC_PINCON->PINSEL0;
01048     r0 = (r0 >> 20) & 0x03;
01049     if (r0 == 1) {
01050         PRINTF("TXD2 ");
01051     } else {
01052         PRINTF(uismsg3);
01053     }
01054     // P0.11
01055     r0 = LPC_PINCON->PINSEL0;
01056     r0 = (r0 >> 22) & 0x03;
01057     if (r0 == 1) {
01058         PRINTF(",RXD2");
01059     } else {
01060         PRINTF(",%s", uismsg3);
01061     }
01062     put_rn();
01063 }
01064 
01065 void uart_io_reg3 (void)
01066 {
01067     uint32_t r0;
01068 
01069     PRINTF("UART3/ p 9(P0. 0), p10(P0. 1):");
01070     // P0.0
01071     r0 = LPC_PINCON->PINSEL0;
01072     r0 = (r0 >> 0) & 0x03;
01073     if (r0 == 2) {
01074         PRINTF("TXD3 ");
01075     } else {
01076         PRINTF(uismsg3);
01077     }
01078     // P0.1
01079     r0 = LPC_PINCON->PINSEL0;
01080     r0 = (r0 >> 2) & 0x03;
01081     if (r0 == 2) {
01082         PRINTF(",RXD3");
01083     } else {
01084         PRINTF(",%s", uismsg3);
01085     }
01086     put_rn();
01087 }
01088 #endif  //USE_UART
01089 
01090 #if USE_SPI
01091 void spi_io_reg (void)
01092 {
01093     uint32_t r0;
01094 
01095     PRINTF("<Show IO Pin>");
01096     put_rn();
01097     //-----------------------------------------------------
01098     PRINTF("SPI /p11(P0.18),p12(P0.17),p13(P0.15):");
01099     // p11(P0.18)
01100     r0 = LPC_PINCON->PINSEL1;
01101     r0 = (r0 >> 4) & 0x03;
01102     if (r0 == 3) {
01103         PRINTF(",MOSI ");
01104     } else {
01105         PRINTF("%s", uismsg3);
01106     }
01107     // p12(P0.17)
01108     r0 = LPC_PINCON->PINSEL1;
01109     r0 = (r0 >> 2) & 0x03;
01110     if (r0 == 3) {
01111         PRINTF(",MISO ");
01112     } else {
01113         PRINTF(",%s", uismsg3);
01114     }
01115     // p13(P0.15)
01116     r0 = LPC_PINCON->PINSEL0;
01117     r0 = (r0 >> 30) & 0x03;
01118     if (r0 == 3) {
01119         PRINTF(",SCK ");
01120     } else {
01121         PRINTF(",%s", uismsg3);
01122     }
01123     put_rn();
01124     //-----------------------------------------------------
01125     PRINTF("SSP0/p11(P0.18),p12(P0.17),p13(P0.15):");
01126     // p11(P0.18)
01127     r0 = LPC_PINCON->PINSEL1;
01128     r0 = (r0 >> 4) & 0x03;
01129     if (r0 == 2) {
01130         PRINTF(",MOSI0");
01131     } else {
01132         PRINTF("%s", uismsg3);
01133     }
01134     // p12(P0.17)
01135     r0 = LPC_PINCON->PINSEL1;
01136     r0 = (r0 >> 2) & 0x03;
01137     if (r0 == 2) {
01138         PRINTF(",MISO0");
01139     } else {
01140         PRINTF(",%s", uismsg3);
01141     }
01142     // p13(P0.15)
01143     r0 = LPC_PINCON->PINSEL0;
01144     r0 = (r0 >> 30) & 0x03;
01145     if (r0 == 2) {
01146         PRINTF(",SCK0 ");
01147     } else {
01148         PRINTF(",%s", uismsg3);
01149     }
01150     put_rn();
01151     //-----------------------------------------------------
01152     PRINTF("SSP1/p 5(P0. 9),p 6(P0. 8),p 7(P0. 7):");
01153     // p5(P0.9)
01154     r0 = LPC_PINCON->PINSEL0;
01155     r0 = (r0 >> 18) & 0x03;
01156     if (r0 == 2) {
01157         PRINTF("MOSI1");
01158     } else {
01159         PRINTF(uismsg3);
01160     }
01161     // p6(P0.8)
01162     r0 = LPC_PINCON->PINSEL0;
01163     r0 = (r0 >> 16) & 0x03;
01164     if (r0 == 2) {
01165         PRINTF(",MISO1");
01166     } else {
01167         PRINTF(",%s", uismsg3);
01168     }
01169     // p7(P0.7)
01170     r0 = LPC_PINCON->PINSEL0;
01171     r0 = (r0 >> 14) & 0x03;
01172     if (r0 == 2) {
01173         PRINTF(",SCK1");
01174     } else {
01175         PRINTF(",%s", uismsg3);
01176     }
01177     put_rn();
01178 }
01179 
01180 void spi_freq (void)
01181 {
01182     uint32_t div, r0, r1;
01183 
01184     get_freq(0);
01185     //-----------------------------------------------------
01186     // SPI
01187     PRINTF("<Show SPI status>");
01188     put_rn();
01189     if (LPC_SC->PCONP & (1UL<<8)) {
01190         div = (LPC_SC->PCLKSEL0 >> 16) & 0x3;
01191         switch (div) {
01192             case 0:
01193                 div = 4;
01194                 break;
01195             case 1:
01196                 div = 1;
01197                 break;
01198             case 2:
01199                 div = 2;
01200                 break;
01201             case 3:
01202                 div = 8;
01203                 break;
01204         }
01205         r0 = LPC_SPI->SPCR;
01206         PRINTF("Data length: ");
01207         if (r0 & 0x04) {
01208             r1 = (r0 >> 8) & 0x0f;
01209             if (r1 == 0) {
01210                 r1 = 16;
01211             }
01212             PRINTF("%d", r1);
01213         } else {
01214             PUTC('8');
01215         }
01216         PRINTF("bit,  ");
01217         PRINTF("CPHA: ");
01218         PRINTF("%d", (r0 >> 3) & 0x01);
01219         PRINTF(",  CPOL: ");
01220         PRINTF("%d", (r0 >> 4) & 0x01);
01221         put_rn();
01222         if ((r0 >> 5) & 0x01) {
01223             PRINTF("Master");
01224         } else {
01225             PRINTF("Slave");
01226         }
01227         PRINTF(" Mode");
01228         put_rn();
01229         if ((r0 >> 6) & 0x01) {
01230             PRINTF("MSB(bit7)");
01231         } else {
01232             PRINTF("LSB(Bit0)");
01233         }
01234         PRINTF(" first");
01235         put_rn();
01236         r1 = LPC_SPI->SPCCR;
01237         PRINTF("CLK = %d Hz", SystemCoreClock/div/r1);
01238         put_rn();
01239         PRINTF("    = PCLK_SPI(=Sys/div)/SPCCR0");
01240         put_rn();
01241         PRINTF("    = (%d/%d)/%d", SystemCoreClock, div, r1, SystemCoreClock/div/r1);
01242     } else {
01243         PRINTF("NOT Avairable (power off the module)");
01244     }
01245     put_rn();
01246     //-----------------------------------------------------
01247     // SSP0
01248     PRINTF("<Show SSP0 status>");
01249     put_rn();
01250     if (LPC_SC->PCONP & (1UL<<21)) {
01251         r0 = LPC_SSP0->CR1;
01252         if (r0 & 0x02) {
01253             div = (LPC_SC->PCLKSEL1 >> 10) & 0x3;
01254             switch (div) {
01255                 case 0:
01256                     div = 4;
01257                     break;
01258                 case 1:
01259                     div = 1;
01260                     break;
01261                 case 2:
01262                     div = 2;
01263                     break;
01264                 case 3:
01265                     div = 8;
01266                     break;
01267             }
01268             r1 = LPC_SSP0->CR0;
01269             PRINTF("SSP Mode: ");
01270             r1 = (r1 >> 4) & 0x03;
01271             switch (r1) {
01272                 case 0:
01273                     PRINTF("SPI");
01274                     break;
01275                 case 1:
01276                     PRINTF("TI");
01277                     break;
01278                 case 2:
01279                     PRINTF("Microwire");
01280                     break;
01281                 case 3:
01282                     PRINTF("Not support");
01283                     break;
01284             }
01285             put_rn();
01286             r1 = LPC_SSP0->CR0;
01287             PRINTF("Data length: ");
01288             PRINTF("%d", r1 & 0x0f);
01289             PRINTF("bit,  ");
01290             PRINTF("CPHA: ");
01291             PRINTF("%d", (r1 >> 7) & 0x01);
01292             PRINTF(",  CPOL: ");
01293             PRINTF("%d", (r1 >> 6) & 0x01);
01294             put_rn();
01295             if ((r0 >> 2) & 0x01) {
01296                 PRINTF("Slave");
01297             } else {
01298                 PRINTF("Master");
01299             }
01300             PRINTF(" Mode");
01301             put_rn();
01302             r1 = LPC_SSP0->CR0;
01303             r1 = (r1 >> 8) & 0xff;
01304             r0 = LPC_SSP0->CPSR;
01305             r0 = (r0 >> 0) & 0x0f;
01306             PRINTF("CLK = %d Hz", SystemCoreClock/div/(r0 * (r1+1)));
01307             put_rn();
01308             PRINTF("    = PCLK_SSP0(=Sys/div)/(CPSDVSR x [SCR+1])");
01309             put_rn();
01310             PRINTF("    = (%d/%d)/(%d x [%d + 1])", SystemCoreClock, div, r0, r1);
01311         } else {
01312             PRINTF("SSP0 is disabled");
01313         }
01314     } else {
01315         PRINTF("NOT Avairable (power off the module)");
01316     }
01317     put_rn();
01318     //-----------------------------------------------------
01319     // SSP1
01320     PRINTF("<Show SSP1 status>");
01321     put_rn();
01322     if (LPC_SC->PCONP & (1UL<<10)) {
01323         r0 = LPC_SSP1->CR1;
01324         if (r0 & 0x02) {
01325             div = (LPC_SC->PCLKSEL0 >> 20) & 0x3;
01326             switch (div) {
01327                 case 0:
01328                     div = 4;
01329                     break;
01330                 case 1:
01331                     div = 1;
01332                     break;
01333                 case 2:
01334                     div = 2;
01335                     break;
01336                 case 3:
01337                     div = 8;
01338                     break;
01339             }
01340             r1 = LPC_SSP1->CR0;
01341             PRINTF("SSP Mode: ");
01342             r1 = (r1 >> 4) & 0x03;
01343             switch (r1) {
01344                 case 0:
01345                     PRINTF("SPI");
01346                     break;
01347                 case 1:
01348                     PRINTF("TI");
01349                     break;
01350                 case 2:
01351                     PRINTF("Microwire");
01352                     break;
01353                 case 3:
01354                     PRINTF("Not support");
01355                     break;
01356             }
01357             put_rn();
01358             r1 = LPC_SSP1->CR0;
01359             PRINTF("Data length: ");
01360             PRINTF("%d", r1 & 0x0f);
01361             PRINTF("bit,  ");
01362             PRINTF("CPHA: ");
01363             PRINTF("%d", (r1 >> 7) & 0x01);
01364             PRINTF(",  CPOL: ");
01365             PRINTF("%d", (r1 >> 6) & 0x01);
01366             put_rn();
01367             if ((r0 >> 2) & 0x01) {
01368                 PRINTF("Slave");
01369             } else {
01370                 PRINTF("Master");
01371             }
01372             PRINTF(" Mode");
01373             put_rn();
01374             r1 = LPC_SSP1->CR0;
01375             r1 = (r1 >> 8) & 0xff;
01376             r0 = LPC_SSP1->CPSR;
01377             r0 = (r0 >> 0) & 0x0f;
01378             PRINTF("CLK = %d Hz", SystemCoreClock/div/(r0 * (r1+1)));
01379             put_rn();
01380             PRINTF("    = PCLK_SSP1(=Sys/div)/(CPSDVSR x [SCR+1])");
01381             put_rn();
01382             PRINTF("    = (%d/%d)/(%d x [%d + 1])", SystemCoreClock, div, r0, r1);
01383         } else {
01384             PRINTF("SSP1 is disabled");
01385         }
01386     } else {
01387         PRINTF("NOT Avairable (power off the module)");
01388     }
01389     put_rn();
01390 }
01391 #endif
01392 
01393 #if USE_I2C
01394 void i2c_io_reg (void)
01395 {
01396     uint32_t r0;
01397 
01398     PRINTF("<Show IO Pin>");
01399     put_rn();
01400     //-----------------------------------------------------
01401     PRINTF("I2C0/pxx(P0.27),pxx(P0.28):");
01402     // P0.27
01403     r0 = LPC_PINCON->PINSEL1;
01404     r0 = (r0 >> 22) & 0x03;
01405     if (r0 == 3) {
01406         PRINTF("SDA0");
01407     } else {
01408         PRINTF(uismsg3);
01409     }
01410     // P0.28
01411     r0 = LPC_PINCON->PINSEL1;
01412     r0 = (r0 >> 24) & 0x03;
01413     if (r0 == 3) {
01414         PRINTF(",SCL0");
01415     } else {
01416         PRINTF(",%s", uismsg3);
01417     }
01418     PRINTF(uismsg2);
01419     put_rn();
01420     //-----------------------------------------------------
01421     PRINTF("I2C1/p 9(P0. 0),p10(P0. 1):");
01422     // P0.0
01423     r0 = LPC_PINCON->PINSEL0;
01424     r0 = (r0 >> 0) & 0x03;
01425     if (r0 == 3) {
01426         PRINTF("SDA1");
01427     } else {
01428         PRINTF(uismsg3);
01429     }
01430     // P0.1
01431     r0 = LPC_PINCON->PINSEL0;
01432     r0 = (r0 >> 2) & 0x03;
01433     if (r0 == 3) {
01434         PRINTF(",SCL1");
01435     } else {
01436         PRINTF(",%s", uismsg3);
01437     }
01438     put_rn();
01439     //-----------------------------------------------------
01440     PRINTF("I2C1/pxx(P0.19),pxx(P0.20):");
01441     // P0.19
01442     r0 = LPC_PINCON->PINSEL1;
01443     r0 = (r0 >> 6) & 0x03;
01444     if (r0 == 3) {
01445         PRINTF("SDA1");
01446     } else {
01447         PRINTF(uismsg3);
01448     }
01449     // P0.20
01450     r0 = LPC_PINCON->PINSEL1;
01451     r0 = (r0 >> 8) & 0x03;
01452     if (r0 == 3) {
01453         PRINTF(",SCL1");
01454     } else {
01455         PRINTF(",%s", uismsg3);
01456     }
01457     PRINTF(uismsg2);
01458     put_rn();
01459     //-----------------------------------------------------
01460     PRINTF("I2C2/p28(P0.10),p27(P0.11):");
01461     // P0.10
01462     r0 = LPC_PINCON->PINSEL0;
01463     r0 = (r0 >> 20) & 0x03;
01464     if (r0 == 3) {
01465         PRINTF("SDA2");
01466     } else {
01467         PRINTF(uismsg3);
01468     }
01469     // P0.11
01470     r0 = LPC_PINCON->PINSEL0;
01471     r0 = (r0 >> 22) & 0x03;
01472     if (r0 == 3) {
01473         PRINTF(",SCL2");
01474     } else {
01475         PRINTF(",%s", uismsg3);
01476     }
01477     put_rn();
01478 }
01479 
01480 char *const msg_cal = "    = I2CPCLK(=Sys/div)/(SCLH+SCLL)";
01481 
01482 void i2c_freq (void)
01483 {
01484     uint32_t r0, r1, r2, r3;
01485 
01486     get_freq(0);
01487     // I2C0
01488     r0 = LPC_I2C0->I2SCLL;
01489     r1 = LPC_I2C0->I2SCLH;
01490     r2 = LPC_I2C0->I2CONSET;
01491     r3 = (LPC_SC->PCLKSEL0 >> 14) & 0x3;
01492     switch (r3) {
01493         case 0:
01494             r3 = 4;
01495             break;
01496         case 1:
01497             r3 = 1;
01498             break;
01499         case 2:
01500             r3 = 2;
01501             break;
01502         case 3:
01503             r3 = 8;
01504             break;
01505     }
01506     PRINTF("<I2C Status>");
01507     put_rn();
01508     //-----------------------------------------------------
01509     PRINTF("I2C0 ");
01510     if (r2 & 0x40) {
01511         PRINTF(uismsg0);
01512         put_rn();
01513         PRINTF("CLK = %d Hz", SystemCoreClock/r3/(r0+r1));
01514         put_rn();
01515         PRINTF(msg_cal);
01516         put_rn();
01517         PRINTF("    = (%d/%d)/(%d+%d)", SystemCoreClock,r3, r0, r1);
01518     } else {
01519         PRINTF(uismsg1);
01520     }
01521     put_rn();
01522     //-----------------------------------------------------
01523     // I2C1
01524     r0 = LPC_I2C1->I2SCLL;
01525     r1 = LPC_I2C1->I2SCLH;
01526     r2 = LPC_I2C1->I2CONSET;
01527     r3 = (LPC_SC->PCLKSEL1 >> 6) & 0x3;
01528     switch (r3) {
01529         case 0:
01530             r3 = 4;
01531             break;
01532         case 1:
01533             r3 = 1;
01534             break;
01535         case 2:
01536             r3 = 2;
01537             break;
01538         case 3:
01539             r3 = 8;
01540             break;
01541     }
01542     PRINTF("I2C1 ");
01543     if (r2 & 0x40) {
01544         PRINTF(uismsg0);
01545         put_rn();
01546         PRINTF("CLK = %d Hz", SystemCoreClock/r3/(r0+r1));
01547         put_rn();
01548         PRINTF(msg_cal);
01549         put_rn();
01550         PRINTF("    = (%d/%d)/(%d+%d)", SystemCoreClock,r3, r0, r1);
01551     } else {
01552         PRINTF(uismsg1);
01553     }
01554     put_rn();
01555     //-----------------------------------------------------
01556     // I2C2
01557     r0 = LPC_I2C2->I2SCLL;
01558     r1 = LPC_I2C2->I2SCLH;
01559     r2 = LPC_I2C2->I2CONSET;
01560     r3 = (LPC_SC->PCLKSEL1 >> 20) & 0x3;
01561     switch (r3) {
01562         case 0:
01563             r3 = 4;
01564             break;
01565         case 1:
01566             r3 = 1;
01567             break;
01568         case 2:
01569             r3 = 2;
01570             break;
01571         case 3:
01572             r3 = 8;
01573             break;
01574     }
01575     PRINTF("I2C2 ");
01576     if (r2 & 0x40) {
01577         PRINTF(uismsg0);
01578         put_rn();
01579         PRINTF("CLK = %d Hz", SystemCoreClock/r3/(r0+r1));
01580         put_rn();
01581         PRINTF(msg_cal);
01582         put_rn();
01583         PRINTF("    = (%d/%d)/(%d+%d)", SystemCoreClock,r3, r0, r1);
01584     } else {
01585         PRINTF(uismsg1);
01586     }
01587     put_rn();
01588 }
01589 #endif
01590 
01591 //-----------------------------------------------------------------------------
01592 //  Monitor Main Program
01593 //-----------------------------------------------------------------------------
01594 int mon_hw(void)
01595 {
01596     char *ptr;
01597 
01598     put_r();
01599     PRINTF("%s [Help:'?' key]", mon_msg);
01600     put_rn();
01601     get_freq(0);
01602     for (;;) {
01603         put_r();
01604         PUTC('>');
01605         ptr = linebuf;
01606         get_line(ptr, buf_size);
01607         put_r();
01608         switch (*ptr++) {
01609                 //---------------------------------------------------------------------------------
01610                 //    Memory
01611                 //---------------------------------------------------------------------------------
01612             case 'm' :
01613 #if USE_MEM
01614                 mem_inf(ptr);
01615                 put_rn();
01616 #else
01617                 not_select();
01618 #endif   // USE_MEM
01619                 break;
01620                 //--------------------------------------------------------------------------------------
01621                 //    Register
01622                 //--------------------------------------------------------------------------------------
01623             case 'r' :
01624                 uint8_t  r_flg;
01625                 put_r();
01626                 PRINTF("Reg. Mode p,u,i,s,t,a,d,l,w,c & ?");
01627                 put_rn();
01628                 r_flg = 0;
01629                 for (; r_flg != 0xff;) {
01630                     PRINTF("r>");
01631                     ptr = linebuf;
01632                     get_line(ptr, buf_size);
01633                     put_r();
01634                     switch(*ptr++) {
01635                         case 'p' :
01636 #if USE_PORT
01637                             put_r();
01638                             switch(*ptr++) {
01639                                 case 'l' :
01640                                     port_config_left();
01641                                     break;
01642                                 case 'r' :
01643                                     port_config_right();
01644                                     break;
01645                                 case '*' :
01646                                     port_config_left();
01647                                     port_config_right();
01648                                     break;
01649                                 case '?' :
01650                                     PRINTF("Enter pl,pr and p* for all");
01651                                     put_rn();
01652                                     break;;
01653                                 default:
01654                                     PUTC('?');
01655                                     put_rn();
01656                                     break;
01657                             }
01658 #else
01659                             not_select();
01660 #endif // USE_PORT
01661                             break;
01662                         case 'u' :
01663 #if USE_UART
01664                             put_r();
01665                             switch(*ptr++) {
01666                                 case '0' :
01667                                     uart_io_print();
01668                                     uart_io_reg0();
01669                                     uart_reg(0);
01670                                     break;
01671                                 case '1' :
01672                                     uart_io_print();
01673                                     uart_io_reg1();
01674                                     uart_reg(1);
01675                                     break;
01676                                 case '2' :
01677                                     uart_io_print();
01678                                     uart_io_reg2();
01679                                     uart_reg(2);
01680                                     break;
01681                                 case '3' :
01682                                     uart_io_print();
01683                                     uart_io_reg3();
01684                                     uart_reg(3);
01685                                     break;
01686                                 case '*' :
01687                                     uart_io_print();
01688                                     uart_io_reg0();
01689                                     uart_io_reg1();
01690                                     uart_io_reg2();
01691                                     uart_io_reg3();
01692                                     break;
01693                                 case '?' :
01694                                     PRINTF("Enter u0,u1,u2,u3 for each UART ");
01695                                     PRINTF("or u* for UART port assignment");
01696                                     put_rn();
01697                                     break;
01698                                 default:
01699                                     PUTC('?');
01700                                     put_rn();
01701                                     break;
01702                             }
01703 #else
01704                             not_select();
01705 #endif // USE_UART
01706                             break;
01707                         case 'i' :
01708 #if USE_I2C
01709                             put_r();
01710                             i2c_io_reg();
01711                             i2c_freq();
01712 #else
01713                             not_select();
01714 #endif // USE_I2C
01715                             break;
01716                         case 's' :
01717 #if USE_SPI
01718                             put_r();
01719                             spi_io_reg();
01720                             spi_freq();
01721 #else
01722                             not_select();
01723 #endif // USE_SPI
01724                             break;
01725                         case 't' :      //
01726                             not_yet_impliment();
01727                             break;
01728                         case 'a' :      //
01729                             not_yet_impliment();
01730                             break;
01731                         case 'd' :      //
01732                             not_yet_impliment();
01733                             break;
01734                         case 'w' :      //
01735                             not_yet_impliment();
01736                             break;
01737                         case 'l' :        //
01738                             not_yet_impliment();
01739                             break;
01740                         case 'c' :      //
01741                             not_yet_impliment();
01742                             break;
01743                         case 'x' :      //
01744                             not_yet_impliment();
01745                             break;
01746                         case 'y' :      //
01747                             not_yet_impliment();
01748                             break;
01749                         case 'q' :        // quit
01750                             r_flg = 0xff;
01751                             break;
01752                         case '?' :
01753                             PRINTF("p - I/O Pin Config. pl(p5 to p20) & pr(p21 to p30)");
01754                             put_rn();
01755                             PRINTF("u - UART u0,1,2,3 or u* (port assignment)");
01756                             put_rn();
01757                             PRINTF("i - I2C");
01758                             put_rn();
01759                             PRINTF("s - SPI/SSP");
01760                             put_rn();
01761                             PRINTF("t - TIMER");
01762                             put_rn();
01763                             PRINTF("a - ADC");
01764                             put_rn();
01765                             PRINTF("d - DAC");
01766                             put_rn();
01767                             PRINTF("l - LDC");
01768                             put_rn();
01769                             PRINTF("w - WWDG");
01770                             put_rn();
01771                             PRINTF("c - COMP");
01772                             put_rn();
01773                             PRINTF("q - Exit mode");
01774                             put_rn();
01775                             break;
01776                         default:
01777                             PUTC('?');
01778                             put_rn();
01779                     }
01780                 }
01781                 PRINTF("Return to All Mode");
01782                 put_rn();
01783                 break;
01784                 //---------------------------------------------------------------------------------
01785                 //    System
01786                 //---------------------------------------------------------------------------------
01787             case 's' :    // System related information
01788 #if USE_SYS
01789                 switch (*ptr++) {
01790                     case 'f' :    // sc - show system clock frequency
01791                         get_freq(1);
01792                         break;
01793                     case 'c' :    // sc - show system CPU information
01794                         cpu_inf();
01795                         break;
01796                     case '?' :
01797                     default:
01798                         put_r();
01799                         PRINTF("sc - System CPU information");
01800                         put_rn();
01801                         PRINTF("sf - System Clock");
01802                         put_rn();
01803                         break;
01804                 }
01805 #else
01806                 not_select();
01807 #endif   // USE_SYS
01808                 break;
01809                 //-----------------------------------------------------------------------------------------
01810                 //    Help
01811                 //-----------------------------------------------------------------------------------------
01812             case '?' :
01813                 msg_hlp_hw();
01814                 break;
01815                 //-----------------------------------------------------------------------------------------
01816                 //    Return to main routine
01817                 //-----------------------------------------------------------------------------------------
01818             case 'q' :        // Quit
01819                 put_r();
01820                 PRINTF("Return to monitor");
01821                 put_rn();
01822                 return 0;
01823                 //-----------------------------------------------------------------------------------------
01824                 //    Special command for DEBUG
01825                 //-----------------------------------------------------------------------------------------
01826             case 'x' :
01827                 not_yet_impliment();
01828                 break;
01829                 //-----------------------------------------------------------------------------------------
01830                 //    no support
01831                 //-----------------------------------------------------------------------------------------
01832             default:
01833                 PUTC('?');
01834                 put_rn();
01835                 break;
01836         }
01837     }
01838 }
01839 #endif  // defined(TARGET_LPC1768)