Kenji Arai
Barometer program : Data Logger function includes Barometer & temperature (BMP180), Humidity & temp. (RHT03), Sunshine (Cds), RTC(M41T62) data. : Logging data saves into EEPROM (AT24C1024) using ring buffer function.
Dependencies: AT24C1024 RHT03 TextLCD BMP180 M41T62
Fork of
mbed_blinky
by 
Mbed
Please see https://mbed.org/users/kenjiArai/notebook/mbed-lpc1114fn28-barometer-with-data-logging/#
Revision 15:065fbeddc305, committed 2014-06-29
- Comitter:
- kenjiArai
- Date:
- Sun Jun 29 06:58:00 2014 +0000
- Parent:
- 14:18a98cad6109
- Child:
- 16:f164f8912201
- Commit message:
- Barometer program / Step by step approach -> final step,; Barometer, Humidity, Sunshine, RTC data into EEPROM (logging)
Changed in this revision
--- a/AT24C1024.lib Sun Jun 22 06:10:57 2014 +0000 +++ b/AT24C1024.lib Sun Jun 29 06:58:00 2014 +0000 @@ -1,1 +1,1 @@ -AT24C1024#b9f5cf0309af +AT24C1024#05012e75c050
--- a/BMP180.lib Sun Jun 22 06:10:57 2014 +0000 +++ b/BMP180.lib Sun Jun 29 06:58:00 2014 +0000 @@ -1,1 +1,1 @@ -BMP180#b81e7659be7a +BMP180#20e0c6b19c24
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/dt_log.h Sun Jun 29 06:58:00 2014 +0000
@@ -0,0 +1,67 @@
+/*
+ * mbed Application program for the mbed LPC1114FN28
+ * Data Logging
+ *
+ * Copyright (c) 2013,'14 Kenji Arai / JH1PJL
+ * http://www.page.sannet.ne.jp/kenjia/index.html
+ * http://mbed.org/users/kenjiArai/
+ * Created: June 16th, 2013
+ * Revised: June 29th, 2014
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// Definition -----------------------------------------------------------------------------------
+// Buffer size
+#define EEP_SIZE 128 * 1024 // 1Mbits = 128 KBytes
+#define PKT_SIZE 16 // Packet size
+#define BLK_NO 8192 // 128KB/16 = 8192
+#define ALL_SIZE (PKT_SIZE) * (BLK_NO)
+#if ALL_SIZ > EEP_SIZE
+#error "Data size in EEPROM is too big!"
+#endif
+#define PTR_SIZE 16
+
+// Buffer control
+#define BUF_HEAD 0x0001
+#define BUF_RD_ALL 0
+#define BLK_SIZE 16
+
+// Buffer Status
+#define BUF_FULL 0xff
+
+// Packet pointer
+#define READ_POINTER() \
+ ((uint16_t)(( buf_pointer[0] << 8) + buf_pointer[1]))
+#define WRITE_POINTER(x) \
+ buf_pointer[0] = (uint8_t)( x >> 8); \
+ buf_pointer[1] = (uint8_t)x;
+#define RD_STATUS() \
+ (buf_pointer[2])
+#define WR_STATUS(x) \
+ buf_pointer[2] = (uint8_t)x;
+
+// Pointer structure
+typedef struct EEPROM_BUF_INF{
+ uint16_t wr_pointer;
+ uint16_t max;
+ uint16_t ptr;
+ uint8_t size;
+ uint8_t status;
+} xEeprom_ptr;
+
+// RAM definition
+extern uint8_t data_pack[PKT_SIZE];
+
+// Function prototypes ---------------------------------------------------------------------------
+void dtlog_data_pack(void);
+void dtlog_one_write(void);
+void dtlog_rd_buf_inf(xEeprom_ptr *);
+void dtlog_clear_all_buff(xEeprom_ptr *);
+void dtlog_block_read(xEeprom_ptr *);
+void dtlog_num_of_block(xEeprom_ptr *);
+uint16_t dtlog_buf_occupation(void);
--- a/main.cpp Sun Jun 22 06:10:57 2014 +0000
+++ b/main.cpp Sun Jun 29 06:58:00 2014 +0000
@@ -1,12 +1,12 @@
/*
* mbed Application program for the mbed LPC1114FN28
- * Test program -> Check I2C line control
+ * Barometer program for only for LPC1114FN28
*
* Copyright (c) 2014 Kenji Arai / JH1PJL
* http://www.page.sannet.ne.jp/kenjia/index.html
* http://mbed.org/users/kenjiArai/
- * Created: June 22nd, 2014
- * Revised: June 22nd, 2014
+ * Created: May 21st, 2014
+ * Revised: June 28th, 2014
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
@@ -14,30 +14,315 @@
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-// You need to select (set 1) only one from blow
-#define TST_NORMAL 1
-#define TST_LCD8x2 0
-#define TST_EEPROM 0
-#define TST_BMP180 0
-#define TST_M41T62 0
-// You need to select (set 1) only one from above
+/*
+ * Function
+ * measure atmospheric pressure and temprerature using Bosch BMP180 pressure sensor
+ * show measured data on AQM0802A LCD and logging such data in EEPROM
+ */
+
+// Include ---------------------------------------------------------------------------------------
+#include "mbed.h"
+#include "BMP180.h" // Own lib. / Pressure sensor
+#include "RHT03.h" // Std. lib./ Humidity sensor
+#include "TextLCD.h" // Std. lib./ LCD control
+#include "m41t62_rtc.h" // Own lib. / RTC control
+#include "dt_log.h"
+
+// Definition ------------------------------------------------------------------------------------
+#define USE_MON 1
+#define USE_BARO 0
+
+#define BOUND 5 // chattering
+
+// Define cyclic period
+#define SHOW_LED 1 // Time for LED on x mS
+#define CNV_WAIT_T 25 // Waiting time for temp. conversion
+#define CNV_WAIT_P 50 // Waiting time for pressure conversion
+#define LOOP_WAIT (1000 - (SHOW_LED + CNV_WAIT_T +CNV_WAIT_P))
+
+// ADC related definition
+#define VREF_VOLT 2.482 // TA76431F Vref real measued data
+#define R_FIX 9930 // 10K ohm <- real measued data
+#define VOL_OFFSET 3 // Offset data ,= real measured data
+#define CDS_TBL_SIZE 13
+
+// Waiting time
+#define STATE_CHANGE_TIME 3
+
+typedef enum {CDS = 0, VREF, VOL} ADC_Select;
+
+// Object ----------------------------------------------------------------------------------------
+Timeout to; // wake-up from sleep()
+I2C i2c(dp5,dp27); // SDA, SCL
+DigitalOut myled0(dp28); // LED for Debug
+DigitalOut myled1(dp14); // Indicate state transition
+DigitalOut analog_pwr(dp6); // VCC for analog interface (vol, cds and vref)
+DigitalOut vref_pwr(dp4); // VCC for Vref
+DigitalIn sw_chng(dp1,PullUp);// SW for select
+DigitalIn sw_mode(dp2,PullUp);// SW for Mode change
+AnalogIn cds(dp11); // Input / CDS data
+AnalogIn vref(dp9); // Input / Bandgap 2.5V
+AnalogIn vol(dp10); // Input / contrast volume
+RHT03 humtemp(dp26); // RHT03 interface
+BMP180 bmp180(i2c); // Bosch sensor
+M41T62 m41t62(i2c); // STmicro RTC(M41T62)
+TextLCD_I2C_N i2clcd(&i2c, 0x7c, TextLCD::LCD8x2); // LCD(Akizuki AQM0802A)
+
+// Function prototypes ---------------------------------------------------------------------------
+extern int mon( void); // only use for debug purpose
+
+// RAM -------------------------------------------------------------------------------------------
+int flag;
+
+// ADC
+float av_cds, av_vref, av_vol, cal_vcc;
+float r_cds, lux;
+uint32_t nor_vol;
+
+// Humidity Sensor
+float humidity_temp, humidity;
+
+// EEPROM
+uint8_t eep_buf[256 + 2];
-#if TST_NORMAL
-#include "main_normal.h"
-#endif
+// Barometer
+float baro;
+float baro_temp;
+
+// EEPROM
+extern xEeprom_ptr log_inf;
+
+// ROM / Constant data ---------------------------------------------------------------------------
+// Cds GL5528 (Dark Resistance 1 Mohm type) SENBA OPTICAL & ELECTRONIC CO.,LTD.
+// Table value referrence: http://homepage3.nifty.com/skomo/f35/hp35_20.htm
+const float lux_cds[CDS_TBL_SIZE][2] =
+ {{50,21194},{100,8356},{200,3294},{400,1299},{800,512},{1600,202},{3200,79.6},{6400,31.4},
+ {12800,12.4},{25600,4.88},{51200,1.92},{102400,0.758},{409600,0.118}};
+
+// LCD screen data
+enum Screen{
+ SCRN_Clear=0, SCRN_Opening, SCRN_Goto_mon, SCRN_Backto_normal
+};
+// Clear Opening Goto_mon Backto_normal
+char scrn_1st[4][10] = { " ", "LPC1114F", "GOTO MON", "Back to"};
+char scrn_2nd[4][10] = { " ", " JH1PJL ", " 9600BPS", " Normal"};
+
+// Disply on LCD
+enum Disp_num{
+ DSP_INIT=0, DSP_BARO, DSP_HUMD, DSP_LUX, DSP_TIME, DSP_LOG, DSP_RTURN
+};
+
+// rule 1) DSP_INIT is top position, 2)DSP_RTURN is end position, 3) Total number 20
+const uint8_t lcd_disp_tbl[20]
+// 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+ = {DSP_INIT, DSP_BARO, DSP_BARO, DSP_BARO, DSP_TIME, DSP_TIME, DSP_HUMD, DSP_HUMD, DSP_LUX, DSP_LUX,
+// 11, 12, 13, 14, 15, 16, 17, 18, 19, 20
+ DSP_BARO, DSP_BARO, DSP_TIME, DSP_TIME, DSP_HUMD, DSP_HUMD, DSP_LUX, DSP_LUX, DSP_LOG, DSP_RTURN};
+
+//-------------------------------------------------------------------------------------------------
+// Control Program
+//-------------------------------------------------------------------------------------------------
+// Normalize ADC data
+void adc_normalize (ADC_Select n){
+int i;
+float x1,y1,dx;
+
+ switch (n){
+ case CDS:
+ // v_adc = Rfix / (Rcds + Rfix) -> Rcds = ( Rfix / v_adc ) - Rfix
+ r_cds = (R_FIX / av_cds) - R_FIX;
+ // CDS resistance to Lux conversion using convertion table (luc_cds[][])
+ for (i =0; i < CDS_TBL_SIZE; i++){ // search table
+ if ( r_cds <= lux_cds[i][0]){ break; }
+ }
+ // Check table position
+ if (i == 0){ lux = lux_cds[0][1]; break;
+ } else if ( i == CDS_TBL_SIZE ){
+ if ( r_cds <= lux_cds[i][0] ){
+ lux = lux_cds[i-1][1];
+ break;
+ }
+ }
+ // Linear interpolation
+ y1 = lux_cds[i-1][1] - lux_cds[i][1];
+ x1 = lux_cds[i][0] - lux_cds[i-1][0];
+ dx = r_cds - lux_cds[i-1][0];
+ lux = lux_cds[i-1][1] - ((dx/x1) * y1);
+ break;
+ case VREF: // vref = VREF_VOLT / VCC -> VCC = VREF_VOLT / vref
+ cal_vcc = VREF_VOLT / vref;
+ break;
+ case VOL: // Vol center = 1.00 (actual 100)
+ nor_vol = (uint32_t)(av_vol * 200) + VOL_OFFSET;
+ break;
+ }
+}
-#if TST_LCD8x2
-#include "main_aqm0802.h"
-#endif
+// Read adc data and averaging
+void adc_all_read (void){
+ if (av_cds == 0){ av_cds = cds.read();
+ } else { av_cds = av_cds *0.5 + cds.read() * 0.5;
+ }
+ if (av_vref == 0){ av_vref = vref.read();
+ } else { av_vref = av_vref *0.9 + vref.read() * 0.1;
+ }
+ if (av_vol == 0){ av_vol = vol.read();
+ } else { av_vol = av_vol *0.2 + vol.read() * 0.8;
+ }
+}
-#if TST_EEPROM
-#include "main_at24c1024.h"
-#endif
+// Read Humidity sensor data
+void hum_RHT03_read (void){
+ while (true){ // wait data
+ if ( humtemp.readData() == RHT_ERROR_NONE ){ break; }
+ }
+ if (humidity_temp == 0){humidity_temp = humtemp.getTemperatureC();
+ } else { humidity_temp = humidity_temp * 0.9 + humtemp.getTemperatureC() * 0.1;
+ }
+ if ( humidity == 0 ){ humidity = humtemp.getHumidity();
+ } else { humidity = humidity * 0.9 + humtemp.getHumidity() * 0.1;
+ }
+}
+
+void set_lcd_screen(int n){
+ i2clcd.locate(0, 0);
+ i2clcd.printf("%s", scrn_1st[n]);
+ i2clcd.locate(0, 1);
+ i2clcd.printf("%s", scrn_2nd[n]);
+}
+
+//-------------------------------------------------------------------------------------------------
+// Application program
+//-------------------------------------------------------------------------------------------------
+// Nothing is done but just wake-up from sleep condition
+void wakeup() {
+ flag = 1;
+ myled1 = !myled1;
+}
+
+// Measure pressure and show it on LCD
+void conv_and_disp(void) {
+tm t;
+uint32_t step = 0;
+uint8_t num;
-#if TST_BMP180
-#include "main_bmp180.h"
-#endif
+ while (true) { // infinit loop for measure and display
+ // Call wakeup()function after specific time
+ to.attach(&wakeup, STATE_CHANGE_TIME); // this is for wake-up
+//---- State Control ----
+ num = lcd_disp_tbl[step++];
+ switch (num){
+ // ---------- Initialize data ----------------------------------------------------------------
+ case DSP_INIT:
+ av_cds = 0;
+ av_vref = 0;
+ av_vol = 0;
+ humidity_temp = 0;
+ humidity = 0;
+ // RTC
+ m41t62.set_sq_wave(RTC_SQW_NONE);
+ break;
+ // ---------- Cds Sensor, Vref, Volume -------------------------------------------------------
+ case DSP_LUX:
+ // Power on / Analog sensor
+ analog_pwr = 1;
+ vref_pwr = 1;
+ wait(0.2);
+ adc_all_read();
+ // Power off / Analog sensor
+ analog_pwr = 0;
+ // Normalize
+ adc_normalize(CDS);
+ adc_normalize(VREF);
+ adc_normalize(VOL);
+ set_lcd_screen(SCRN_Clear);
+ i2clcd.locate(0, 0); // 1st line top
+ // 12345678
+ i2clcd.printf("L:%.1f", lux);
+ i2clcd.locate(0, 1); // 2nd line top
+ i2clcd.printf("V:%.3f", cal_vcc);
+ break;
+ // ---------- Barometer Sensor / BMP180 ------------------------------------------------------
+ case DSP_BARO:
+ bmp180.normalize();
+ baro = bmp180.read_pressure();
+ baro_temp = bmp180.read_temperature();
+ set_lcd_screen(SCRN_Clear);
+ i2clcd.locate(0, 0); // 1st line top
+ i2clcd.printf("P:%.1f", baro);
+ i2clcd.locate(0, 1); // 2nd line top
+ i2clcd.printf("T:%\+-6.1f", baro_temp);
+ break;
+ // ---------- Humidity Sensor / RHT03 --------------------------------------------------------
+ case DSP_HUMD:
+ hum_RHT03_read(); // Read Humidity data then avaraging
+ set_lcd_screen(SCRN_Clear);
+ i2clcd.locate(0, 0); // 1st line top
+ i2clcd.printf("H:%.1f", humidity);
+ i2clcd.locate(0, 1); // 2nd line top
+ i2clcd.printf("T:%\+-6.1f", humidity_temp);
+ break;
+ // ---------- RTC ----------------------------------------------------------------------------
+ case DSP_TIME:
+ m41t62.read_rtc_std(&t);;
+ set_lcd_screen(SCRN_Clear);
+ i2clcd.locate(0, 0); // 1st line top
+ i2clcd.printf("%02d/%02d/%02d", t.tm_year % 100, t.tm_mon + 1, t.tm_mday);
+ i2clcd.locate(0, 1); // 2nd line top
+ i2clcd.printf("%02d:%02d:%02d", t.tm_hour, t.tm_min, t.tm_sec);
+ break;
+ // ---------- EEPROM Logging -----------------------------------------------------------------
+ case DSP_LOG:
+ dtlog_data_pack(); // Get EEPROM resource
+ dtlog_one_write(); // Write data to EEPROM
+ set_lcd_screen(SCRN_Clear);
+ i2clcd.locate(0, 0); // 1st line top
+ i2clcd.printf("Logging");
+ i2clcd.locate(0, 1); // 2nd line top
+ i2clcd.printf("%d.1", dtlog_buf_occupation() / 10);
+ break;
+ // ---------- return (loop) ------------------------------------------------------------------
+ case DSP_RTURN:
+ default:
+ // <State> State change
+ step = 1; // if something wrong, go to reset condition
+ }
+ // ---------- back to top --------------------------------------------------------------------
+ myled0 = !myled0;
+ while (flag == 0){ wait(0.01);}
+ wait(0.1);
+ myled1 = !myled1;
+ flag = 0;
+ }
+}
-#if TST_M41T62
-#include "main_m41t62.h"
-#endif
+// Application program starts here
+int main() {
+ flag = 0;
+ i2clcd.setContrast(25);
+ set_lcd_screen(SCRN_Opening);
+ if (sw_chng == 0){ // SW ON
+ //-- Enter Monitor Mode --
+ myled1 = 1; wait(0.5);
+ myled1 = 0; wait(0.5);
+ myled1 = 1; wait(0.5);
+ if (sw_chng == 0){ // Still SW ON
+ myled1 = 0; wait(0.5);
+ myled1 = 1; wait(0.5);
+ if (sw_mode == 0){ // SW ON
+ set_lcd_screen(SCRN_Clear);
+ set_lcd_screen(SCRN_Goto_mon);
+ myled1 = 0;
+ mon(); // mon.cpp
+ }
+ set_lcd_screen(SCRN_Clear);
+ set_lcd_screen(SCRN_Backto_normal);
+ }
+ }
+ //-- Enter Normal Mode --
+ myled0 = 1;
+ myled1 = 0;
+ while (true) { // Start main program
+ conv_and_disp();
+ }
+}
--- a/main_aqm0802.h Sun Jun 22 06:10:57 2014 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-/*
- * mbed Application program for the mbed LPC1114FN28
- * Test program -> Check RTC module
- *
- * Copyright (c) 2014 Kenji Arai / JH1PJL
- * http://www.page.sannet.ne.jp/kenjia/index.html
- * http://mbed.org/users/kenjiArai/
- * Created: June 22nd, 2014
- * Revised: June 22nd, 2014
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
- * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-#include "mbed.h"
-#include "TextLCD.h" // Std. lib./ LCD control
-
-I2C i2c(dp5,dp27); // SDA, SCL
-TextLCD_I2C_N i2clcd(&i2c, 0x7c, TextLCD::LCD8x2); // LCD(Akizuki AQM0802A)
-
-//-------------------------------------------------------------------------------------------------
-// Control Program
-//-------------------------------------------------------------------------------------------------
-// Clear LCD
-void cls(void){
- i2clcd.locate(0, 0);
- i2clcd.printf(" ");
- i2clcd.locate(0, 1);
- i2clcd.printf(" ");
-}
-
-//-------------------------------------
-// Application program starts here
-//-------------------------------------
-int main() {
-uint16_t no = 0;
-
- i2clcd.setContrast(25);
- i2clcd.locate(0, 0);
- i2clcd.printf("LPC1114F");
- i2clcd.locate(0, 1);
- i2clcd.printf(" JH1PJL ");
- // Show initial screen
- wait(5.0);
- while(1) {
- cls();
- i2clcd.locate(0, 0); // 1st line top
- // 12345678
- i2clcd.printf(" test");
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("%8d", ++no);
- wait(1.0);
- }
-}
--- a/main_at24c1024.h Sun Jun 22 06:10:57 2014 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,151 +0,0 @@
-/*
- * mbed Application program for the mbed LPC1114FN28
- * Test program -> Check RTC module
- *
- * Copyright (c) 2014 Kenji Arai / JH1PJL
- * http://www.page.sannet.ne.jp/kenjia/index.html
- * http://mbed.org/users/kenjiArai/
- * Created: June 22nd, 2014
- * Revised: June 22nd, 2014
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
- * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "mbed.h"
-#include "AT24C1024.h" // Own lib. / EEPROM control
-
-Serial pc(dp16,dp15); // UART (vertual COM)
-#if 1
-AT24C1024 at24c1024(dp5,dp27);// Atmel 1Mbit EE-PROM
-#else
-I2C i2c(dp5,dp27); // SDA, SCL
-AT24C1024 at24c1024(i2c); // Atmel 1Mbit EE-PROM
-#endif
-
-// EEPROM
-uint8_t eep_buf[256 + 2];
-
-// EEPROM test charcters
-const uint8_t eep_char[256] =
-//0 1 2 3 4 5 6 7
-//12345678901234567890123456789012345678901234567890123456789012345678901
- "The AT24C1024 provides 1048576 bits of serial electrically erasable and"
-//7 8 9 10 11 12 13 14 15
-//2345678901234567890123456789012345678901234567890123456789012345678901234567890123
- " programmable read only memory (EEPROM) organized as 131,072 words of 8 bits each."
-//15 16 17 18 19 20 21 22 23 24
-//45678901234567890123456789012345678901234567890123456789012345678901234567890123456789012
- " The devices cascadable feature allows up to four devices to share a common two-wire bus."
-//24 25 256
-//34567890123456
- " JH1PJL Arai"; // eep_char[255] = 0;
-
-//-------------------------------------------------------------------------------------------------
-// Control Program
-//-------------------------------------------------------------------------------------------------
-int main() {
-int no =0;
-uint8_t dt[4];
-AT24C_STATUS status;
-
- pc.baud(9600);
- pc.printf("\r\nmbed LPC1114FN28 EEPROM test by JH1PJL created on "__DATE__"(UTC)\r\n");
- dt[0] = 0; dt[1] = 0; dt[2] = 0; dt[3] = 0; //initialize data
- while(1) {
- // ---------- Check EEPROM ----------------------------------------------------
- if (no == 4) { // check page write mode (part1)
- ++no;
- strcpy((char *)eep_buf,(char *)eep_char); // copy the data
- status = at24c1024.write_page(0x100, eep_buf, sizeof(eep_buf)); // 0x100= page address
- pc.printf("(Status: %d) ", status);
- if (status == AT24C_OK){ // wrote without trouble
- wait(1.0);
- for (int i=0; i < 256; i++){ // clear buffer for read data checking
- eep_buf[i] = 0;
- }
- status = at24c1024.read_page(0x100, eep_buf, sizeof(eep_buf));
- pc.printf("(Status: %d) ", status);
- if (status == AT24C_OK){ // read w/o trouble
- pc.printf("\r\n%s\r\n", eep_buf);
- if (strncmp((char *)eep_buf, (char *)eep_char, 256) == 0){ // equal R/W data
- pc.printf("Page access OK\r\n");
- } else { // Read != Wrote
- pc.printf("Page access Comp NG\r\n");
- }
- } else { // read w/ trouble
- pc.printf("Page access read NG\r\n");
- }
- } else { // write w/ trouble
- pc.printf("Write NG\r\n");
- }
- wait(2.0);
- } else if (no == 5) { // check page write mode (part2)
- no = 0;
- for (int i=0; i < 256; i++){ // set writing data 255,254,,,,,3,2,1,0
- eep_buf[i] = 255 - (uint8_t)i;
- }
- status = at24c1024.write_page(0x1ff00, eep_buf, sizeof(eep_buf));
- pc.printf("(Status: %d) ", status);
- if (status == AT24C_OK){
- wait(1.0);
- for (int i=0; i < 256; i++){ // clear buffer
- eep_buf[i] = 0;
- }
- status = at24c1024.read_page(0x1ff00, eep_buf, sizeof(eep_buf));
- pc.printf("(Status: %d) ", status);
- if (status == AT24C_OK){
- pc.printf("\r\n0:%d, 64:%d, 128:%d, 254:%d, 255:%d\r\n",
- eep_buf[0], eep_buf[64], eep_buf[128], eep_buf[254], eep_buf[255]);
- if ((eep_buf[0] == 255) && (eep_buf[64] == 255 - 64)
- && (eep_buf[128] == 255-128) && (eep_buf[255] == 0)){
- pc.printf("Page access OK\r\n");
- } else {
- pc.printf("Page access Comp NG\r\n");
- }
- } else {
- pc.printf("Page access read NG\r\n");
- }
- } else {
- pc.printf("Write NG\r\n");
- }
- wait(2.0);
- } else { // Write and read (single byte)
- if (no == 0){ // Initial setting
- // Check EEPROM (step0)
- at24c1024.write(0,no);
- wait(0.1);
- at24c1024.write(1,0);
- wait(0.1);
- at24c1024.write(2,0x55);
- wait(0.1);
- at24c1024.write(3,0xaa);
- wait(0.1);
- dt[0] = 0xff;
- dt[1] = 1;
- dt[2] = 2;
- dt[3] = 3;
- }
- // read 4 bytes
- dt[0] = at24c1024.read(0);
- dt[1] = at24c1024.read(1);
- dt[2] = at24c1024.read(2);
- dt[3] = at24c1024.read(3);
- if (dt[0] != no){
- pc.printf("NG\r\n");
- } else {
- if ((dt[1] == 0) && (dt[2] == 0x55) && (dt[3] == 0xaa)){
- pc.printf("OK\r\n");
- } else {
- pc.printf("NG\r\n");
- }
- }
- pc.printf("EEPROM 0x%x,0x%x,0x%x,0x%x\r\n", dt[0],dt[1],dt[2],dt[3]);
- at24c1024.write(0,++no); // write sequence number into EEPROM
- wait(2.0);
- }
- }
-}
--- a/main_bmp180.h Sun Jun 22 06:10:57 2014 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-/*
- * mbed Application program for the mbed LPC1114FN28
- * Test program -> Check RTC module
- *
- * Copyright (c) 2014 Kenji Arai / JH1PJL
- * http://www.page.sannet.ne.jp/kenjia/index.html
- * http://mbed.org/users/kenjiArai/
- * Created: June 22nd, 2014
- * Revised: June 22nd, 2014
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
- * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "mbed.h"
-#include "BMP180.h" // Own lib. / Pressure sensor
-
-Serial pc(dp16,dp15); // UART (vertual COM)
-#if 1
-BMP180 bmp180(dp5,dp27); // Bosch sensor
-#else
-I2C i2c(dp5,dp27); // SDA, SCL
-BMP180 bmp180(i2c); // Bosch sensor
-#endif
-
-//-------------------------------------------------------------------------------------------------
-// Control Program
-//-------------------------------------------------------------------------------------------------
-int main() {
- pc.baud(9600);
- pc.printf("\r\nmbed LPC1114FN28 BMP180 test by JH1PJL created on "__DATE__"(UTC)\r\n");
- while(1) {
- // ---------- Barometer Sensor / BMP180 --------------------------------------------------
- bmp180.normalize();
- pc.printf("Pres:%4.1fhPa, Temp:%\+-0.1fdegC\r\n",
- bmp180.read_pressure(), bmp180.read_temperature());
- wait(1.0);
- }
-}
--- a/main_m41t62.h Sun Jun 22 06:10:57 2014 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +0,0 @@
-/*
- * mbed Application program for the mbed LPC1114FN28
- * Test program -> Check RTC module
- *
- * Copyright (c) 2014 Kenji Arai / JH1PJL
- * http://www.page.sannet.ne.jp/kenjia/index.html
- * http://mbed.org/users/kenjiArai/
- * Created: June 22nd, 2014
- * Revised: June 22nd, 2014
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
- * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "mbed.h"
-#include "m41t62_rtc.h" // Own lib. / RTC control
-
-Serial pc(dp16,dp15); // UART (vertual COM)
-#if 1
-M41T62 m41t62(dp5,dp27); // STmicro RTC(M41T62)
-#else
-I2C i2c(dp5,dp27); // SDA, SCL
-M41T62 m41t62(i2c); // STmicro RTC(M41T62)
-#endif
-
-//-------------------------------------------------------------------------------------------------
-// Control Program
-//-------------------------------------------------------------------------------------------------
-int main() {
- pc.baud(9600);
- pc.printf("\r\nmbed LPC1114FN28 test program by JH1PJL created on "__DATE__"(UTC)\r\n");
- // RTC
- m41t62.set_sq_wave(RTC_SQW_NONE);
- while(1) {
- // ---------- Check RTC ------------------------------------------------------------------
-tm t;
-time_t seconds;
-char buf[40];
-
- m41t62.read_rtc_std(&t);
- seconds = mktime(&t);
- // Show Time with several example
-#if 0
- // ex.1
- pc.printf("Date: %04d/%02d/%02d, %02d:%02d:%02d\r\n",
- t.tm_year + 1900, t.tm_mon, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
-#endif
-#if 0
- // ex.2
- strftime(buf, 40, "%x %X", localtime(&seconds));
- printf("Date: %s\r\n", buf);
-#endif
-#if 1
- // ex.3
- strftime(buf, 40, "%I:%M:%S %p (%Y/%m/%d)", localtime(&seconds));
- printf("Date: %s\r\n", buf);
-#endif
-#if 0
- // ex.4
- strftime(buf, 40, "%B %d,'%y, %H:%M:%S", localtime(&seconds));
- printf("Date: %s\r\n", buf);
-#endif
- wait(1.0);
- }
-}
--- a/main_normal.h Sun Jun 22 06:10:57 2014 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,299 +0,0 @@
-/*
- * mbed Application program for the mbed LPC1114FN28
- * Test program -> same as LPC1114_test_step_7
- *
- * Copyright (c) 2014 Kenji Arai / JH1PJL
- * http://www.page.sannet.ne.jp/kenjia/index.html
- * http://mbed.org/users/kenjiArai/
- * Created: June 13th, 2014
- * Revised: June 22nd, 2014
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
- * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
- * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "mbed.h"
-#include "BMP180.h" // Own lib. / Pressure sensor
-#include "RHT03.h" // Std. lib./ Humidity sensor
-#include "TextLCD.h" // Std. lib./ LCD control
-#include "AT24C1024.h" // Own lib. / EEPROM control
-#include "m41t62_rtc.h" // Own lib. / RTC control
-
-#define USE_C_STD_LIB 1
-
-#define VREF_VOLT 2.482 // TA76431F Vref real measued data
-#define R_FIX 9930 // 10K ohm <- real measued data
-#define VOL_OFFSET 3 // Offset data ,= real measured data
-#define CDS_TBL_SIZE 13
-
-I2C i2c(dp5,dp27); // SDA, SCL
-DigitalOut myled0(dp28); // LED for Debug
-DigitalOut myled1(dp14); // Indicate state transition
-DigitalOut analog_pwr(dp6); // VCC for analog interface (vol, cds and vref)
-DigitalOut vref_pwr(dp4); // VCC for Vref
-DigitalIn sw_chng(dp1,PullUp);// SW for select
-DigitalIn sw_mode(dp2,PullUp);// SW for Mode change
-AnalogIn cds(dp11); // Input / CDS data
-AnalogIn vref(dp9); // Input / Bandgap 2.5V
-AnalogIn vol(dp10); // Input / contrast volume
-RHT03 humtemp(dp26); // RHT03 interface
-Serial pc(dp16,dp15); // UART (vertual COM)
-BMP180 bmp180(i2c); // Bosch sensor
-TextLCD_I2C_N i2clcd(&i2c, 0x7c, TextLCD::LCD8x2); // LCD(Akizuki AQM0802A)
-AT24C1024 at24c1024(i2c); // Atmel 1Mbit EE-PROM
-M41T62 m41t62(i2c); // STmicro RTC(M41T62)
-
-typedef enum {CDS = 0, VREF, VOL} ADC_Select;
-
-// ADC
-float av_cds, av_vref, av_vol, cal_vcc;
-float r_cds, lux;
-uint32_t nor_vol;
-
-// Humidity Sensor
-float humidity_temp, humidity;
-
-// EEPROM
-uint8_t eep_buf[256 + 2];
-
-// Cds GL5528 (Dark Resistance 1 Mohm type) SENBA OPTICAL & ELECTRONIC CO.,LTD.
-// Table value referrence: http://homepage3.nifty.com/skomo/f35/hp35_20.htm
-const float lux_cds[CDS_TBL_SIZE][2] =
- {{50,21194},{100,8356},{200,3294},{400,1299},{800,512},{1600,202},{3200,79.6},{6400,31.4},
- {12800,12.4},{25600,4.88},{51200,1.92},{102400,0.758},{409600,0.118}};
-
-#if USE_C_STD_LIB == 0
-const char week[7][4] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
-#endif
-
-//-------------------------------------------------------------------------------------------------
-// Control Program
-//-------------------------------------------------------------------------------------------------
-// Normalize ADC data
-void adc_normalize (ADC_Select n){
-int i;
-float x1,y1,dx;
-
- switch (n){
- case CDS:
- // v_adc = Rfix / (Rcds + Rfix) -> Rcds = ( Rfix / v_adc ) - Rfix
- r_cds = (R_FIX / av_cds) - R_FIX;
- // CDS resistance to Lux conversion using convertion table (luc_cds[][])
- for (i =0; i < CDS_TBL_SIZE; i++){ // search table
- if ( r_cds <= lux_cds[i][0]){ break; }
- }
- // Check table position
- if (i == 0){
- lux = lux_cds[0][1];
- break;
- } else if ( i == CDS_TBL_SIZE ){
- if ( r_cds <= lux_cds[i][0] ){
- lux = lux_cds[i-1][1];
- break;
- }
- }
- // Linear interpolation
- y1 = lux_cds[i-1][1] - lux_cds[i][1];
- x1 = lux_cds[i][0] - lux_cds[i-1][0];
- dx = r_cds - lux_cds[i-1][0];
- lux = lux_cds[i-1][1] - ((dx/x1) * y1);
- break;
- case VREF:
- // vref = VREF_VOLT / VCC -> VCC = VREF_VOLT / vref
- cal_vcc = VREF_VOLT / vref;
- break;
- case VOL:
- // Vol center = 1.00 (actual 100)
- nor_vol = (uint32_t)(av_vol * 200) + VOL_OFFSET;
- break;
- }
-}
-
-// Read adc data and averaging
-void adc_all_read (void){
- if (av_cds == 0){ av_cds = cds.read();
- } else { av_cds = av_cds *0.5 + cds.read() * 0.5;
- }
- if (av_vref == 0){ av_vref = vref.read();
- } else { av_vref = av_vref *0.9 + vref.read() * 0.1;
- }
- if (av_vol == 0){ av_vol = vol.read();
- } else { av_vol = av_vol *0.2 + vol.read() * 0.8;
- }
-}
-
-// Read Humidity sensor data
-void hum_RHT03_read (void){
- while (true){ // wait data
- if ( humtemp.readData() == RHT_ERROR_NONE ){ break; }
- }
- if (humidity_temp == 0){humidity_temp = humtemp.getTemperatureC();
- } else { humidity_temp = humidity_temp * 0.9 + humtemp.getTemperatureC() * 0.1;
- }
- if ( humidity == 0 ){ humidity = humtemp.getHumidity();
- } else { humidity = humidity * 0.9 + humtemp.getHumidity() * 0.1;
- }
-}
-
-// Clear LCD
-void cls(void){
- i2clcd.locate(0, 0);
- i2clcd.printf(" ");
- i2clcd.locate(0, 1);
- i2clcd.printf(" ");
-}
-
-// Set initial time
-void set_initial_time (void){
- // Set Initial data -> 2014/06/22 10:20:00
-#if USE_C_STD_LIB
-struct tm t;
-
- m41t62.read_rtc_std(&t);
- if ((sw_chng == 0) && (sw_mode == 0)){
- t.tm_sec = 0;
- t.tm_min = 20;
- t.tm_hour = 10;
- t.tm_mday = 22;
- t.tm_wday = 0; // Sun is not 7 but 0
- t.tm_mon = 5; // Jan. = 0
- t.tm_year = 14 + 100; // 1900+x = now
- m41t62.write_rtc_std(&t);
- }
-#else
-rtc_time t;
-
- m41t62.read_rtc_direct(&t);
- if ((sw_chng == 0) && (sw_mode == 0)){
- t.rtc_seconds = 0;
- t.rtc_minutes = 20;
- t.rtc_hours = 10;
- t.rtc_date = 22;
- t.rtc_weekday = RTC_Wk_Sunday;
- t.rtc_month = 6;
- t.rtc_year_raw= 14;
- m41t62.write_rtc_direct(&t);
- }
-#endif
-}
-
-//-------------------------------------
-// Application program starts here
-//-------------------------------------
-int main() {
- pc.baud(9600);
- pc.printf("\r\nmbed LPC1114FN28 test program by JH1PJL created on "__DATE__"(UTC)\r\n");
- i2clcd.setContrast(25);
- i2clcd.locate(0, 0);
- i2clcd.printf("LPC1114F");
- i2clcd.locate(0, 1);
- i2clcd.printf(" JH1PJL ");
- // Initialize data
- av_cds = 0;
- av_vref = 0;
- av_vol = 0;
- humidity_temp = 0;
- humidity = 0;
- // RTC
- m41t62.set_sq_wave(RTC_SQW_NONE);
- set_initial_time();
- // Show initial screen
- wait(5.0);
- while(1) {
- // ---------- Cds Sensor, Vref, Volume ---------------------------------------------------
- // Power on / Analog sensor
- analog_pwr = 1;
- vref_pwr = 1;
- wait(0.2);
- adc_all_read();
- // Power off / Analog sensor
- analog_pwr = 0;
- // Normalize
- adc_normalize(CDS);
- adc_normalize(VREF);
- adc_normalize(VOL);
- cls();
- i2clcd.locate(0, 0); // 1st line top
- // 12345678
- i2clcd.printf("L:%.1f", lux);
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("V:%.3f", cal_vcc);
- myled0 = 1;
- pc.printf( "\r\nCds:%.0fohm->%.1flux, Vcc:%.3fV, Vol:%d\r\n",
- r_cds, lux, cal_vcc, nor_vol );
- myled0 = 0;
- wait(4.0);
- // ---------- Barometer Sensor / BMP180 --------------------------------------------------
- bmp180.normalize();
- cls();
- i2clcd.locate(0, 0); // 1st line top
- i2clcd.printf("P:%.1f", bmp180.read_pressure());
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("T:%\+-6.1f", bmp180.read_temperature());
- myled1 = 1;
- pc.printf("Pres:%4.1fhPa, Temp:%\+-0.1fdegC\r\n",
- bmp180.read_pressure(), bmp180.read_temperature());
- myled1 = 0;
- wait(4.0);
- // ---------- Humidity Sensor / RHT03 ----------------------------------------------------
- hum_RHT03_read(); // Read Humidity data then avaraging
- cls();
- i2clcd.locate(0, 0); // 1st line top
- i2clcd.printf("H:%.1f", humidity);
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("T:%\+-6.1f", humidity_temp);
- myled1 = 1;
- pc.printf("Humid: %0.1f%%RH, Temp:%\+-0.1fdegC\r\n", humidity, humidity_temp);
- myled1 = 0;
- wait(4.0);
- // ---------- Check RTC ------------------------------------------------------------------
-#if USE_C_STD_LIB
-tm t;
-time_t seconds;
-char buf[40];
-
- m41t62.read_rtc_std(&t);
- seconds = mktime(&t);
- cls();
- i2clcd.locate(0, 0); // 1st line top
- i2clcd.printf("%02d/%02d/%02d", t.tm_year % 100, t.tm_mon + 1, t.tm_mday);
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("%02d:%02d:%02d", t.tm_hour, t.tm_min, t.tm_sec);
- myled1 = 1;
- // Show Time with several example
- // ex.1
- pc.printf("Date: %04d/%02d/%02d, %02d:%02d:%02d\r\n",
- t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
- // ex.2
- strftime(buf, 40, "%x %X", localtime(&seconds));
- printf("Date: %s\r\n", buf);
- // ex.3
- strftime(buf, 40, "%I:%M:%S %p (%Y/%m/%d)", localtime(&seconds));
- printf("Date: %s\r\n", buf);
- // ex.4
- strftime(buf, 40, "%B %d,'%y, %H:%M:%S", localtime(&seconds));
- printf("Date: %s\r\n", buf);
- myled1 = 0;
- wait(4.0);
-#else
-rtc_time t;
-
- m41t62.read_rtc_direct(&t);
- cls();
- i2clcd.locate(0, 0); // 1st line top
- i2clcd.printf("%02d/%02d/%02d", t.rtc_year, t.rtc_month, t.rtc_date);
- i2clcd.locate(0, 1); // 2nd line top
- i2clcd.printf("%02d:%02d:%02d", t.rtc_hours, t.rtc_minutes, t.rtc_seconds);
- myled1 = 1;
- pc.printf("Date:%04d/%02d/%02d(%s), Time:%02d:%02d:%02d\r\n",
- t.rtc_year, t.rtc_month, t.rtc_date, &week[t.rtc_weekday-1][0],
- t.rtc_hours, t.rtc_minutes, t.rtc_seconds);
- myled1 = 0;
- wait(4.0);
-#endif
- }
-}
-
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mon.cpp Sun Jun 29 06:58:00 2014 +0000
@@ -0,0 +1,586 @@
+/*
+ * mbed Application program
+ * Data logging & Monitor program for only LPC1114FN28
+ *
+ * Copyright (c) 2010-2014 Kenji Arai / JH1PJL
+ * http://www.page.sannet.ne.jp/kenjia/index.html
+ * http://mbed.org/users/kenjiArai/
+ * Created: May 15th, 2010
+ * Spareted: June 25th, 2014 mon() & mon_hw()
+ * Revised: June 29th, 2014
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// Include ---------------------------------------------------------------------------------------
+#include "mbed.h"
+#include "m41t62_rtc.h" // Own lib. / RTC control
+#include "AT24C1024.h" // Own lib. / EEPROM control
+#include "dt_log.h"
+
+// Object ----------------------------------------------------------------------------------------
+Serial pc(dp16,dp15);
+extern I2C xi2c(dp5,dp27); // SDA, SCL
+extern M41T62 xm41t62(xi2c); // STmicro RTC(M41T62)
+AT24C1024 at24c1024(xi2c); // Atmel 1Mbit EE-PROM
+
+// Definition ------------------------------------------------------------------------------------
+#define BAUD(x) pc.baud(x)
+#define GETC(x) pc.getc(x)
+#define PUTC(x) pc.putc(x)
+#define PRINTF(...) pc.printf(__VA_ARGS__)
+#define READABLE(x) pc.readable(x)
+
+// EEPROM
+#define EEP_TOP 0x0
+
+// RAM -------------------------------------------------------------------------------------------
+char linebuf[64];
+int buf_size = sizeof(linebuf);
+
+// for EEPROM control
+uint8_t buf_pointer[PTR_SIZE];
+xEeprom_ptr log_inf;
+
+struct one_log{
+ uint32_t time;
+ uint16_t vcc;
+ uint16_t baro;
+ int16_t b_temp;
+ uint16_t humi;
+ int16_t h_temp;
+ uint16_t lux;
+}; // 16 bytes total
+
+one_log lg;
+uint8_t bf[PKT_SIZE];
+
+extern float baro;
+extern float baro_temp;
+extern float cal_vcc;
+extern float lux;
+extern float humidity;
+extern float humidity_temp;
+extern float lux;
+
+// ROM / Constant data ---------------------------------------------------------------------------
+static char *const mon_msg = "Monitor for mbed system, created on "__DATE__"";
+
+// $, 2014/6/29,12:43:16,3.293,1004.5,+29.3,45.8,+29.2,1234,*
+char *const log_head = "$,YYYY/MM/DD,HH:MM:SS,Vcc ,Press ,Temp ,Humi,Temp ,Lux ,*";
+char *const msg_emty = "Data empty";
+
+// Function prototypes ---------------------------------------------------------------------------
+extern void mon_hw(void);
+
+//-------------------------------------------------------------------------------------------------
+// Control Program
+//-------------------------------------------------------------------------------------------------
+// Put \r\n
+void put_rn ( void ){ PUTC('\r'); PUTC('\n');}
+
+// Put \r
+void put_r ( void ){ PUTC('\r');}
+
+// Put ", "
+void put_lin ( void ){ PRINTF(", ");}
+
+// Put space n
+void put_spc( uint8_t n){ for(;n > 0; n--){ PUTC(' '); }}
+
+// Change string -> integer
+int xatoi (char **str, unsigned long *res){
+unsigned long val;
+unsigned char c, radix, s = 0;
+
+ while ((c = **str) == ' ') (*str)++;
+ if (c == '-') {
+ s = 1;
+ c = *(++(*str));
+ }
+ if (c == '0') {
+ c = *(++(*str));
+ if (c <= ' ') { *res = 0; return 1; }
+ if (c == 'x') {
+ radix = 16;
+ c = *(++(*str));
+ } else {
+ if (c == 'b') {
+ radix = 2;
+ c = *(++(*str));
+ } else {
+ if ((c >= '0')&&(c <= '9')){ radix = 8;
+ } else { return 0;}
+ }
+ }
+ } else {
+ if ((c < '1')||(c > '9')){ return 0;}
+ radix = 10;
+ }
+ val = 0;
+ while (c > ' ') {
+ if (c >= 'a') c -= 0x20;
+ c -= '0';
+ if (c >= 17) {
+ c -= 7;
+ if (c <= 9) return 0;
+ }
+ if (c >= radix) return 0;
+ val = val * radix + c;
+ c = *(++(*str));
+ }
+ if (s) val = -val;
+ *res = val;
+ return 1;
+}
+
+//-------------------------------------------------------------------------------------------------
+// Data Logging / Save into EEPROM
+//-------------------------------------------------------------------------------------------------
+// Read buffer pointer
+static void dtlog_pointer_read(void){
+uint8_t i;
+uint8_t *addr;
+
+ /* Read EEPROM and save to buf_pointer[] */
+ for ( i = 0; i < PTR_SIZE; i++ ){
+ addr = (uint8_t *)(EEP_TOP + i);
+ buf_pointer[i] = at24c1024.read((int)addr);
+ wait(0.002);
+ }
+}
+
+// Make one data packet data structure
+void dtlog_data_pack(void){
+struct tm t;
+
+ xm41t62.read_rtc_std(&t);
+ lg.time = mktime(&t);
+ bf[0] = (uint8_t)(lg.time >> 24);
+ bf[1] = (uint8_t)(lg.time >> 16);
+ bf[2] = (uint8_t)(lg.time >> 8);
+ bf[3] = (uint8_t)(lg.time >> 0);
+ lg.vcc = (uint16_t)(cal_vcc * 1000);
+ bf[4] = (uint8_t)(lg.vcc >> 8);
+ bf[5] = (uint8_t)(lg.vcc >> 0);
+ lg.baro = (uint16_t)(baro * 10);
+ bf[6] = (uint8_t)(lg.baro >> 8);
+ bf[7] = (uint8_t)(lg.baro >> 0);
+ lg.b_temp = (int16_t)(baro_temp * 10);
+ bf[8] = (uint8_t)(lg.b_temp >> 8);
+ bf[9] = (uint8_t)(lg.b_temp >> 0);
+ lg.humi = (uint16_t)(humidity * 10);
+ bf[10] = (uint8_t)(lg.humi >> 8);
+ bf[11] = (uint8_t)(lg.humi >> 0);
+ lg.h_temp = (int16_t)(humidity_temp * 10);
+ bf[12] = (uint8_t)(lg.h_temp >> 8);
+ bf[13] = (uint8_t)(lg.h_temp >> 0);
+ lg.lux = (uint16_t)lux;
+ bf[14] = (uint8_t)(lg.lux >> 8);
+ bf[15] = (uint8_t)(lg.lux >> 0);
+}
+
+// Print one packet as normalized data
+void print_one_block_data(void){
+struct tm *t;
+time_t seconds;
+uint16_t dt0;
+int16_t dt1;
+
+ put_rn();
+ PUTC( '$' );
+ //--- Time
+ seconds = (time_t)bf[0] * 16777216 + (time_t)bf[1] * 65536 + (time_t)bf[2] * 256 + (time_t)bf[3];
+ //PRINTF(",0x%x,",seconds);
+ t = localtime(&seconds);
+ PRINTF(",%04d/%02d/%02d,%02d:%02d:%02d,",
+ t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec);
+ //--- Vcc
+ dt0 = (uint16_t)bf[4] * 256 + (uint16_t)bf[5];
+ //PRINTF("0x%x,",dt0);
+ PRINTF("%01d.%03d,", dt0/1000, dt0%1000);
+ //--- Pressure
+ dt0 = (uint16_t)bf[6] * 256 + (uint16_t)bf[7];
+ //PRINTF("0x%x,",dt0);
+ PRINTF("%04d.%01d,", dt0/10, dt0%10 );
+ //--- Temp.
+ dt1 = (int16_t)bf[8] * 256 + (int16_t)bf[9];
+ //PRINTF("0x%x,",dt1);
+ PRINTF("%\+-03d.%01d,", dt1/10, abs(dt1)%10 );
+ //--- Humidity
+ dt0 = (uint16_t)bf[10] * 256 + (uint16_t)bf[11];
+ //PRINTF("0x%x,",dt0);
+ PRINTF("%02d.%01d,", dt0/10, dt0%10 );
+ //--- Temp.
+ dt1 = (int16_t)bf[12] * 256 + (int16_t)bf[13];
+ //PRINTF("0x%x,",dt1);
+ PRINTF("%\+-03d.%01d,", dt1/10, abs(dt1)%10 );
+ //--- Lux
+ dt0 = (uint16_t)bf[14] * 256 + (uint16_t)bf[15];
+ //PRINTF("0x%x",dt0);
+ PRINTF("%05d,*", dt0);
+}
+
+// Read block data
+static void dtlog_blk_read(xEeprom_ptr *read_inf){
+uint8_t i;
+uint8_t *addr;
+
+ PRINTF( log_head );
+ for ( ; ; ){
+ /* Read EEPROM and save to data_pack[] */
+ for (i = 0; i < PKT_SIZE; i++){
+ addr = (uint8_t *)(EEP_TOP + (read_inf->ptr * PTR_SIZE) + i);
+ bf[i] =at24c1024.read((int)addr);
+ wait(0.002);
+ }
+ print_one_block_data();
+ wait(0.001);
+ if (++read_inf->ptr >= read_inf->max){
+ break;
+ }
+ if (READABLE() != 0){
+ break;
+ }
+ }
+ put_rn();
+}
+
+// Write one packet
+void dtlog_one_write(void){
+xEeprom_ptr write_inf;
+uint8_t i;
+uint8_t *addr;
+
+ /* Read buffer pointer */
+ dtlog_pointer_read();
+ write_inf.wr_pointer = READ_POINTER();
+ write_inf.status = RD_STATUS();
+ if (write_inf.status == BUF_FULL){ return;}
+ /* Write data_pack[] into EEPROM */
+ for (i = 0; i < PKT_SIZE; i++){
+ addr = (uint8_t *)(EEP_TOP + (write_inf.wr_pointer * PTR_SIZE) + i);
+ at24c1024.write((int)addr, bf[i]);
+ wait(0.008);
+ }
+ /* Write buffer pointer */
+ if (++write_inf.wr_pointer == BLK_NO){
+ write_inf.status = BUF_FULL;
+ } else {
+ write_inf.status = 0;
+ }
+ WRITE_POINTER(write_inf.wr_pointer);
+ WR_STATUS(write_inf.status);
+ for (i = 0; i < PTR_SIZE; i++){
+ addr = (uint8_t *)(EEP_TOP + i);
+ at24c1024.write((int)addr, buf_pointer[i]);
+ wait(0.008);
+ }
+}
+
+// Read Data Pointer Information
+void dtlog_rd_buf_inf(xEeprom_ptr *log_ptr_inf){
+ dtlog_pointer_read();
+ log_ptr_inf->wr_pointer = READ_POINTER();
+ log_ptr_inf->status = RD_STATUS();
+}
+
+// Clear all buffer
+void dtlog_clear_all_buff(xEeprom_ptr *log_ptr_inf){
+uint8_t i;
+uint8_t *addr;
+
+ /* Set initial data */
+ WRITE_POINTER(1);
+ log_ptr_inf->wr_pointer = 1;
+ WR_STATUS(0);
+ log_ptr_inf->status = 0;
+ log_ptr_inf->max = BLK_NO;
+ log_ptr_inf->ptr = 1;
+ log_ptr_inf->size = BLK_SIZE;
+ /* Write buffer pointer */
+ for (i = 0; i < PTR_SIZE; i++){
+ addr = (uint8_t *)(EEP_TOP + i);
+ at24c1024.write((int)addr, buf_pointer[i]);
+ wait(0.008);
+ }
+}
+
+// Read some block from buffer
+void dtlog_block_read(xEeprom_ptr *read_inf){
+ if (read_inf->wr_pointer == BUF_HEAD){ // Check pointer
+ PRINTF(msg_emty);
+ put_rn();
+ return;
+ }
+ if (read_inf->ptr >= read_inf->wr_pointer){
+ PRINTF("Reach to end!");
+ put_rn();
+ return;
+ }
+ if (read_inf->wr_pointer > (read_inf->ptr + read_inf->size)){
+ read_inf->max = read_inf->ptr + read_inf->size;
+ } else {
+ read_inf->max = read_inf->wr_pointer;
+ }
+ dtlog_blk_read(read_inf);
+}
+
+// EEPROM buffer occupation
+uint16_t dtlog_buf_occupation(void){
+ return (uint16_t)(((uint32_t)READ_POINTER() * 1000 )/ BLK_NO);
+}
+
+// Read block number
+void dtlog_num_of_block(xEeprom_ptr *read_inf){
+uint16_t dt;
+
+ if (read_inf->wr_pointer == BUF_HEAD){
+ PRINTF(msg_emty);
+ put_rn();
+ return;
+ }
+ dt = read_inf->wr_pointer - 1;
+ PRINTF("Number of data = %d", dt);
+ put_rn();
+ dt = dtlog_buf_occupation();
+ PRINTF("EEPROM Occupation = %d.%01d%%", dt/10, dt%10);
+ put_rn();
+}
+
+//-------------------------------------------------------------------------------------------------
+// Monitor
+//-------------------------------------------------------------------------------------------------
+// Help Massage
+void msg_hlp (void){
+ PRINTF(mon_msg); put_rn();
+ PRINTF("d - Data logger"); put_rn();
+ PRINTF("t - Check and set RTC"); put_rn();
+ PRINTF("x - Goto HW monitor"); put_rn();
+ PRINTF("q - Return to main"); put_rn();
+}
+
+// Get key input data
+void get_line (char *buff, int len){
+char c;
+int idx = 0;
+
+ for (;;) {
+ c = GETC();
+ // Added by Kenji Arai / JH1PJL May 9th, 2010
+ if (c == '\r') {
+ buff[idx++] = c;
+ break;
+ }
+ if ((c == '\b') && idx) {
+ idx--;
+ PUTC(c);
+ PUTC(' ');
+ PUTC(c);
+ }
+ if (((uint8_t)c >= ' ') && (idx < len - 1)) {
+ buff[idx++] = c;
+ PUTC(c);
+ }
+ }
+ buff[idx] = 0;
+ PUTC('\n');
+}
+
+
+// RTC related subroutines
+void chk_and_set_time(char *ptr){
+unsigned long p1;
+struct tm t;
+
+ if (xatoi(&ptr, &p1)){
+ t.tm_year = (uint8_t)p1 + 100;
+ PRINTF("Year:%d ",p1);
+ xatoi( &ptr, &p1 );
+ t.tm_mon = (uint8_t)p1 - 1;
+ PRINTF("Month:%d ",p1);
+ xatoi( &ptr, &p1 );
+ t.tm_mday = (uint8_t)p1;
+ PRINTF("Day:%d ",p1);
+ xatoi( &ptr, &p1 );
+ t.tm_hour = (uint8_t)p1;
+ PRINTF("Hour:%d ",p1);
+ xatoi( &ptr, &p1 );
+ t.tm_min = (uint8_t)p1;
+ PRINTF("Min:%d ",p1);
+ t.tm_sec = (uint8_t)p1;
+ PRINTF("Sec: %d \r\n",p1);
+ xm41t62.write_rtc_std(&t);
+ }
+ xm41t62.read_rtc_std(&t);
+ // Show Time with several example
+ // ex.1
+ PRINTF("Date: %04d/%02d/%02d, %02d:%02d:%02d\r\n",
+ t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
+#if 0
+time_t seconds;
+char buf[40];
+
+ seconds = mktime(&t);
+ // ex.2
+ strftime(buf, 40, "%x %X", localtime(&seconds));
+ PRINTF("Date: %s\r\n", buf);
+ // ex.3
+ strftime(buf, 40, "%I:%M:%S %p (%Y/%m/%d)", localtime(&seconds));
+ PRINTF("Date: %s\r\n", buf);
+ // ex.4
+ strftime(buf, 40, "%B %d,'%y, %H:%M:%S", localtime(&seconds));
+ PRINTF("Date: %s\r\n", buf);
+#endif
+}
+
+// Data Logger / Check status and Output data
+static void data_logger(char *ptr){
+char c;
+unsigned long dt;
+char *const Msg = "Data Logger Mode, ?[Help]";
+
+ PRINTF(Msg);
+ put_rn();
+ /* Get EEPROM resource */
+ dtlog_rd_buf_inf(&log_inf);
+ while (1){
+ PRINTF("DL>");
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ switch (*ptr++) {
+ case 'a' :
+ put_r();
+ log_inf.ptr = BUF_HEAD;
+ log_inf.size = log_inf.wr_pointer;
+ dtlog_block_read(&log_inf);
+ log_inf.ptr = BUF_HEAD;
+ log_inf.size = BLK_SIZE;
+ break;
+ case 'c' : // Clear data
+ put_r();
+ PRINTF("Delete all data?");
+ put_rn();
+ PRINTF("Enter y/n (n-cancel)");
+ put_rn();
+ c = GETC();
+ PUTC(c);
+ put_rn();
+ if (c == 'y'){
+ PRINTF("Cleared all logging data");
+ dtlog_clear_all_buff(&log_inf);
+ } else {
+ PRINTF("Canceled");
+ }
+ put_rn();
+ break;
+ case 'd' : // d <pointer> [<count>] - Dump buffer
+ put_r();
+ log_inf.size = BLK_SIZE;
+ if (xatoi(&ptr, &dt)){ log_inf.ptr = (uint16_t)dt;
+ } else { log_inf.ptr = BUF_HEAD; }
+ if (xatoi(&ptr, &dt)){ log_inf.size = (uint8_t)dt;
+ } else { log_inf.size = BLK_SIZE; }
+ dtlog_block_read(&log_inf);
+ break;
+ case 0x0d : // CR
+ put_r();
+ log_inf.size = BLK_SIZE;
+ dtlog_block_read(&log_inf);
+ break;
+ case 'b' : // Back
+ put_r();
+ log_inf.size = BLK_SIZE;
+ if (log_inf.ptr > log_inf.size){
+ log_inf.ptr -= log_inf.size;
+ if (log_inf.ptr == 0){
+ log_inf.ptr = 1;
+ --log_inf.size;
+ }
+ } else {
+ log_inf.size = log_inf.ptr - 1;
+ log_inf.ptr = 1;
+ }
+ dtlog_block_read(&log_inf);
+ break;
+ case 'n' :
+ case 's' : // Status
+ put_r();
+ dtlog_num_of_block(&log_inf);
+ break;
+ case 'q' : // exit
+ linebuf[0] = 0;
+ return;
+ case '?' :
+ put_r();
+ PRINTF("d - <pointer> [<count>] Dump one block data"); put_rn();
+ PRINTF("a - Dump all log data"); put_rn();
+ PRINTF("c - Clear log data"); put_rn();
+ PRINTF("s - Logger status"); put_rn();
+ PRINTF("q - Exit DL mode"); put_rn();
+ break;
+ default:
+ PUTC('?');
+ put_rn();
+ break;
+ }
+ }
+}
+
+// ---------- Program starts here! ---------------------------------------------------------------
+int mon(void) {
+char *ptr;
+
+ BAUD(9600);
+ put_rn();
+ put_rn();
+ PRINTF("%s [Help:'?' key]", mon_msg);
+ put_rn();
+ for (;;) {
+ put_r();
+ PUTC('>');
+ ptr = linebuf;
+ get_line(ptr, sizeof(linebuf));
+ switch (*ptr++) {
+ //---------------------------------------------------------------------------------
+ // check and set RTC
+ //---------------------------------------------------------------------------------
+ case 't' :
+ put_r();
+ chk_and_set_time(ptr);
+ break;
+ //---------------------------------------------------------------------------------
+ // check EEPROM status
+ //---------------------------------------------------------------------------------
+ case 'd' :
+ put_r();
+ data_logger(ptr);
+ break;
+ //---------------------------------------------------------------------------------
+ // help
+ //---------------------------------------------------------------------------------
+ case '?' :
+ put_r();
+ msg_hlp();
+ break;
+ //---------------------------------------------------------------------------------
+ // Go to special command
+ //---------------------------------------------------------------------------------
+ case 'x' : //
+ mon_hw();
+ PRINTF("->Came back monitor\r\n");
+ break;
+ //---------------------------------------------------------------------------------
+ // Go back to main()
+ //---------------------------------------------------------------------------------
+ case 'q' : // Quit
+ PRINTF("\rReturn to main\r\n");
+ PRINTF("cannot control anymore from here\r\n");
+ return 0;
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mon_hw.cpp Sun Jun 29 06:58:00 2014 +0000
@@ -0,0 +1,1806 @@
+/*
+ * mbed Application program for the mbed LPC1114FN28
+ * Monitor program Ver.2 for only LPC1114FN28
+ *
+ * Copyright (c) 2010-2014 Kenji Arai / JH1PJL
+ * http://www.page.sannet.ne.jp/kenjia/index.html
+ * http://mbed.org/users/kenjiArai/
+ * Created: May 15th, 2010
+ * Spareted: June 25th, 2014 mon() & mon_hw()
+ * Revised: June 29th, 2014
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/*
+ * Function
+ * Show Memory contents, Digital port, Analog input port, CPU clock and others in the mbed board
+ * Connection
+ * uart USB Vertual com
+ */
+
+// Include ---------------------------------------------------------------------------------------
+#include "mbed.h"
+#include "AT24C1024.h" // Own lib. / EEPROM control
+#include "mon_hw_config.h"
+
+// Object ----------------------------------------------------------------------------------------
+extern Serial pcx(dp16,dp15);
+extern I2C xxi2c(dp5,dp27); // SDA, SCL
+extern AT24C1024 xat24c1024(xxi2c); // Atmel 1Mbit EE-PROM
+
+// Definition ------------------------------------------------------------------------------------
+// Define clocks
+#define __XTAL (12000000UL) // Oscillator frequency
+#define __SYS_OSC_CLK ( __XTAL) // Main oscillator frequency
+#define __IRC_OSC_CLK (12000000UL) // Internal RC oscillator frequency
+
+// Range check status
+#define ERR_NOTHING 0
+#define ERR_MODIFY_SIZ 1
+#define ERR_OUT_OF_RANGE 2
+
+// Reg. Size
+#define SIZE8 32
+#define SIZE16 16
+#define SIZE_FULL 32
+#define SIZE_X 32
+
+// IO Cinfig
+#define IO_ALL 0
+#define IO_I2C 1
+
+#define BAUD(x) pcx.baud(x)
+#define GETC(x) pcx.getc(x)
+#define PUTC(x) pcx.putc(x)
+#define PRINTF(...) pcx.printf(__VA_ARGS__)
+#define READABLE(x) pcx.readable(x)
+
+typedef struct {
+ unsigned long mstr;
+ unsigned long msiz;
+ unsigned long mtmp;
+ unsigned long mold;
+ unsigned char mflg;
+ unsigned char mbhw;
+} MEMO;
+
+#define DW_CHAR sizeof(char)
+#define DW_SHORT sizeof(short)
+#define DW_LONG sizeof(long)
+
+typedef unsigned long DWORD;
+typedef unsigned short WORD;
+typedef unsigned char BYTE;
+typedef unsigned int UINT;
+
+// RAM -------------------------------------------------------------------------------------------
+// Memory management
+unsigned long SystemFrequency;
+
+#if USE_MEM
+// RAM -------------------------------------------------------------------------------------------
+static MEMO mem;
+
+// ROM / Constant data ---------------------------------------------------------------------------
+// Memory range data
+const uint32_t mem_range[][2] = { // Memory access range
+ { 0x00000000, 0x00007fff }, // On-chip non-volatile memory //32KB Flash memory
+ { 0x10000000, 0x10000fff }, // On-chip SRAM //4KB local RAM
+ { 0x1fff0000, 0x1fff3fff }, // Boot ROM //16KB Boot ROM
+ { 0x40000000, 0x4007ffff }, // IO area
+ { 0x50000000, 0x501fffff } // IO area
+};
+
+static char *const rmsg0 = "FLASH ";
+static char *const rmsg1 = "SRAM ";
+static char *const rmsg2 = "BOOT ROM ";
+static char *const rmsg3 = "IO ";
+static char *const rmsg4 = "IO ";
+#endif // USE_MEM
+
+#if USE_EEP
+// RAM -------------------------------------------------------------------------------------------
+static MEMO eepmem;
+
+// ROM / Constant data ---------------------------------------------------------------------------
+const uint32_t eepmem_range[2] = { /* Memory access range */
+ 0x00000, 0x1ffff /* EEPROM 1Mbits 128Kbytes */
+};
+#endif
+
+// ROM / Constant data ---------------------------------------------------------------------------
+static char *const mon_msg_hw = "HW monitor only for mbed LPC1114FN28";
+
+// Function prototypes ---------------------------------------------------------------------------
+extern char linebuf[];
+extern int buf_size;
+
+extern void put_rn ( void );
+extern void put_r ( void );
+extern void put_lin ( void );
+extern void put_spc( uint8_t n);
+extern void get_line (char *buff, int len);
+extern int xatoi (char **str, unsigned long *res);
+
+//-------------------------------------------------------------------------------------------------
+// Control Program
+//-------------------------------------------------------------------------------------------------
+// Help Massage
+void msg_hlp_hw (void){
+ PRINTF(mon_msg_hw);
+ put_rn();
+#if USE_MEM
+ PRINTF("m - Entry Memory Mode");
+ put_rn();
+ PRINTF("m>? -> Help ");
+ put_rn();
+#endif // USE_MEM
+#if USE_EEP
+ PRINTF("e -Enter EEPROM Memory Mode ");
+ put_rn();
+ PRINTF("e>? -> Help ");
+ put_rn();
+#endif // USE_EEP
+#if USE_REG_SPI_UART
+ PRINTF("r - Show SPI & UART Reg.");
+ put_rn();
+ PRINTF("r>? -> Help ");
+ put_rn();
+#endif // USE_REG_SPI_UART
+#if USE_PORT
+ PRINTF("p - Show port configration");
+ put_rn();
+#endif // USE_PORT
+#if USE_REG_I2C
+ PRINTF("i - Show I2C Reg.");
+ put_rn();
+#endif // USE_REG_I2C
+#if USE_SYS
+ PRINTF("sf - System Clock");
+ put_rn();
+ PRINTF("sc - System / CPU information");
+ put_rn();
+#endif // USE_SYS
+#if USE_RPT
+ PRINTF("/ [a],[p] commands every 1 sec Exit =hit any key (not ENTER key) ");
+ put_rn();
+#endif
+#if DEBUG
+ PRINTF("x Special command for Debug ");
+ put_rn();
+#endif // DEBUG
+ PRINTF("q - Quit (back to called routine)");
+ put_rn();
+}
+
+// No function
+static void not_yet_impliment( void ){
+ PRINTF( "Not implimented yet" );
+ put_rn();
+}
+
+char *const imsg2 = "-->Control Reg.";
+char *const imsg3 = "-->Status Reg.";
+char *const imsg4 = "-->Data Reg.";
+//static char *const imsg5 = "-->Baud rate Reg.";
+//static char *const imsg6 = "-->Own address Reg.";
+char *const imsg7 = "-->Clock control Reg.";
+//static char *const imsg8 = "-->TRISE Reg.";
+
+static char *const io_port_name0 = "PIO0_";
+static char *const io_port_name1 = "PIO1_";
+static char *const iomsg0 = "Func->select ";
+static char *const iomsg1 = "IO";
+static char *const iomsg2 = "Reserved";
+static char *const iomsg30 = "B0_MAT";
+static char *const iomsg31 = "B1_MAT";
+static char *const iomsg4 = "Std/F-md I2C";
+static char *const iomsg5 = "func. R";
+static char *const iomsg6 = "D-Mode";
+static char *const iomsg7 = "A-Mode";
+
+// Show 16bit register contents
+void reg_print(uint16_t size, uint16_t reg){
+uint16_t i, j, k, n;
+
+ if (size == 8){
+ PRINTF(" 7, 6, 5, 4, 3, 2, 1, 0");
+ put_rn();
+ i = 8;
+ n = 0x80;
+ } else if (size == 16){
+ PRINTF( "15,14,13,12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0" );
+ put_rn();
+ i = 16;
+ n = 0x8000;
+ } else {
+ PRINTF("0x%08x", reg);
+ return;
+ }
+ PUTC(' ');
+ for (; i>0; i--){
+ k = n >> (size-i);
+ j = reg & k;
+ if (j){
+ PUTC('1');
+ } else {
+ PUTC('0');
+ }
+ PUTC(' ');
+ PUTC(' ');
+ }
+ PRINTF(" (0x%04x)", reg);
+}
+
+#if USE_PORT
+void io_mode(uint32_t reg){
+ PRINTF("MODE->");
+ switch (reg){
+ case 0:
+ PRINTF("Inactive");
+ break;
+ case 1:
+ PRINTF("P-DWN");
+ break;
+ case 2:
+ PRINTF("P-UP");
+ break;
+ case 3:
+ PRINTF("Repeater");
+ break;
+ }
+}
+
+void io_hys(uint32_t reg){
+ PRINTF("HIS->");
+ switch (reg){
+ case 0:
+ PRINTF("Dis");
+ break;
+ case 1:
+ PRINTF("Ena");
+ break;
+ }
+}
+
+void io_od(uint32_t reg){
+ PRINTF("OD->");
+ switch (reg){
+ case 0:
+ PRINTF("no OD");
+ break;
+ case 1:
+ PRINTF("OD");
+ break;
+ }
+}
+
+void io_mode_hys_od(uint32_t reg){
+ io_mode ((reg >> 3) & 0x3);
+ put_lin();
+ io_hys (( reg >> 5) & 0x1);
+ put_lin();
+ io_od (( reg >> 10) & 0x1);
+}
+
+// I/O Config IO0_x
+void io_config0(void){
+uint32_t r0;
+
+ // P0_0
+ r0 = LPC_IOCON->RESET_PIO0_0;
+ PRINTF("RESET_%s0(dp23)", io_port_name0);
+ put_spc(1);
+ reg_print( SIZE_X, r0 );
+ put_spc(2);
+ PRINTF( iomsg0 );
+ if ((r0 & 0x7) == 0){ PRINTF("RESET");
+ } else { PRINTF( iomsg1 ); }
+ put_lin();
+ io_mode_hys_od( r0 );
+ put_rn();
+ // P0_1
+ r0 = LPC_IOCON->PIO0_1;
+ PRINTF("%s1(dp24)", io_port_name0);
+ put_spc(3);
+ reg_print( SIZE_X, r0 );
+ put_spc(2);
+ PRINTF( iomsg0 );
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("CLKOUT"); break;
+ case 2: PRINTF("32%s2", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_2
+ r0 = LPC_IOCON->PIO0_2;
+ PRINTF("%s2(dp25)",io_port_name0);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("SSEL0"); break;
+ case 2: PRINTF("16B0_CAP0"); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_3
+ r0 = LPC_IOCON->PIO0_3;
+ PRINTF("%s3(dp26)",io_port_name0);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_4
+ r0 = LPC_IOCON->PIO0_4;
+ PRINTF("%s4(dp27)",io_port_name0);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("SCL"); break;
+ }
+ put_lin();
+ switch (( r0 >> 8 ) & 0x3){
+ case 0: PRINTF(iomsg4); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("Fast md"); break;
+ case 3: PRINTF(iomsg2 ; break;
+ }
+ put_rn();
+ // P0_5
+ r0 = LPC_IOCON->PIO0_5;
+ PRINTF("%s5(dp5)",io_port_name0);
+ put_spc(4);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("SDA"); break;
+ }
+ put_lin();
+ switch ( ( r0 >> 8 ) & 0x3 ){
+ case 0: PRINTF(iomsg4); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("Fast md"); break;
+ case 3: PRINTF(iomsg2); break;
+ }
+ put_rn();
+ // P0_6
+ r0 = LPC_IOCON->PIO0_6;
+ PRINTF("%s6(dp6)", io_port_name0);
+ put_spc(4);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF(iomsg2); break;
+ case 2: PRINTF("SCK0"); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_7
+ r0 = LPC_IOCON->PIO0_7;
+ PRINTF("%s7(dp28)", io_port_name0);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0 ;
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("CTS"); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_8
+ r0 = LPC_IOCON->PIO0_8;
+ PRINTF("%s8(dp1)", io_port_name0);
+ put_spc(4);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("MISO0"); break;
+ case 2: PRINTF("16%s0", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_9
+ r0 = LPC_IOCON->PIO0_9;
+ PRINTF("%s9(dp2)", io_port_name0);
+ put_spc(4);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("MOSI0"); break;
+ case 2: PRINTF("16%s1", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_10
+ r0 = LPC_IOCON->SWCLK_PIO0_10;
+ PRINTF("SWCLK_%s10(dp3)", io_port_name0);
+ put_spc(1);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7 {
+ case 0: PRINTF("SWCLK"); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("SCK0"); break;
+ case 3: PRINTF("16%s2", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P0_11
+ r0 = LPC_IOCON->R_PIO0_11;
+ PRINTF("R_%s11(dp4)", io_port_name0);
+ put_spc(1);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF( iomsg0 );
+ switch ( r0 & 0x7 ){
+ case 0: PRINTF(iomsg5); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("AD0"); break;
+ case 3: PRINTF("32%s3", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ if ( r0 & 0x80 ){ PRINTF(", %s", iomsg6);
+ } else { PRINTF(", %s", iomsg7);
+ }
+ put_rn();
+}
+
+// I/O Config IO1_x
+void io_config1(void){
+uint32_t r0;
+
+ // P1_0
+ r0 = LPC_IOCON->R_PIO1_0;
+ PRINTF("R_%s0(dp9)", io_port_name1);
+ put_spc(2);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF( iomsg0 );
+ switch ( r0 & 0x7 ){
+ case 0: PRINTF(iomsg5); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("AD1"); break;
+ case 3: PRINTF("32B1_CAP0"); break;
+ }
+ io_mode_hys_od(r0);
+ if (r0 & 0x80){ PRINTF(", %s", iomsg6);
+ } else { PRINTF(", %s", iomsg7);
+ }
+ put_rn();
+ // P1_1
+ r0 = LPC_IOCON->R_PIO1_1;
+ PRINTF("R_%s1(dp10)", io_port_name1);
+ put_spc(1);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg5); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("AD2"); break;
+ case 3: PRINTF("32%s0", iomsg31); break;
+ }
+ io_mode_hys_od(r0);
+ if (r0 & 0x80){ PRINTF(", %s", iomsg6);
+ } else { PRINTF(", %s", iomsg7);
+ }
+ put_rn();
+ // P1_2
+ r0 = LPC_IOCON->R_PIO1_2;
+ PRINTF("R_%s2(dp11)", io_port_name1);
+ put_spc(1);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg5); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("AD3"); break;
+ case 3: PRINTF("32%s1", iomsg31); break;
+ }
+ io_mode_hys_od( r0 );
+ if (r0 & 0x80){ PRINTF(", %s", iomsg6);
+ } else { PRINTF(", %s", iomsg7);
+ }
+ put_rn();
+ // P1_3
+ r0 = LPC_IOCON->SWDIO_PIO1_3;
+ PRINTF("SWDIO_%s3(dp12)",io_port_name1);
+ put_spc(1);
+ reg_print(SIZE_X, r0);
+ put_spc(3);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF("SWDIO"); break;
+ case 1: PRINTF(iomsg1); break;
+ case 2: PRINTF("AD4"); break;
+ case 3: PRINTF("32%s2", iomsg31); break;
+ }
+ io_mode_hys_od(r0);
+ if (r0 & 0x80){ PRINTF(", %s", iomsg6);
+ } else { PRINTF(", %s", iomsg7);
+ }
+ put_rn();
+ // P1_4
+ r0 = LPC_IOCON->PIO1_4;
+ PRINTF("%s4(dp13)",io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF( iomsg0 );
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("AD5"); break;
+ case 2: PRINTF("32%s3", iomsg31); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P1_5
+ r0 = LPC_IOCON->PIO1_5;
+ PRINTF("%s5(dp14)",io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("RTS"); break;
+ case 2: PRINTF("32B0_CAP0"); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P1_6
+ r0 = LPC_IOCON->PIO1_6;
+ PRINTF("%s6(dp15)", io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("RXD"); break;
+ case 2: PRINTF( "32%s0", iomsg30 ); break;
+ }
+ put_lin();
+ io_mode_hys_od( r0 );
+ put_rn();
+ // P1_7
+ r0 = LPC_IOCON->PIO1_7;
+ PRINTF("%s7(dp16)", io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("TXD"); break;
+ case 2: PRINTF("32%s1", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P1_8
+ r0 = LPC_IOCON->PIO1_8;
+ PRINTF("%s8(dp17)", io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("32%s1", iomsg30); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+ // P1_9
+ r0 = LPC_IOCON->PIO1_9;
+ PRINTF("%s9(dp18)", io_port_name1);
+ put_spc(3);
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0: PRINTF(iomsg1); break;
+ case 1: PRINTF("16%s0", iomsg31); break;
+ case 2: PRINTF("MOSI1"); break;
+ }
+ put_lin();
+ io_mode_hys_od(r0);
+ put_rn();
+}
+#endif // USE_PORT
+
+#if USE_REG_SPI_UART
+void spi_reg(int no){
+uint32_t n, r0, r1 ,r2, r3, r4, r5, r6, r7, r8;
+
+ if (no == SPI_0){
+ n = 0;
+ r0 = LPC_SSP0->CR1;
+ r1 = LPC_SSP0->DR;
+ r2 = LPC_SSP0->SR;
+ r3 = LPC_SSP0->CPSR;
+ r4 = LPC_SSP0->IMSC;
+ r5 = LPC_SSP0->RIS;
+ r6 = LPC_SSP0->MIS;
+ r7 = LPC_SSP0->ICR;
+ r8 = LPC_SSP0->CR0;
+ } else if (no == SPI_1){
+ n = 1;
+ r0 = LPC_SSP1->CR1;
+ r1 = LPC_SSP1->DR;
+ r2 = LPC_SSP1->SR;
+ r3 = LPC_SSP1->CPSR;
+ r4 = LPC_SSP1->IMSC;
+ r5 = LPC_SSP1->RIS;
+ r6 = LPC_SSP1->MIS;
+ r7 = LPC_SSP1->ICR;
+ r8 = LPC_SSP1->CR0;
+ } else {
+ return;
+ }
+ PRINTF("Show SSP%1d(SPI%1d) Registers", n, n);
+ put_rn();
+ PRINTF("CR0");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r8);
+ put_rn();
+ PRINTF("CR1");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r0);
+ put_rn();
+ PRINTF("DR");
+ PRINTF(imsg4);
+ reg_print(SIZE8, r1);
+ put_rn();
+ PRINTF("SR");
+ PRINTF(imsg3);
+ reg_print(SIZE8, r2);
+ put_rn();
+ PRINTF("CPSR");
+ PRINTF(imsg7);
+ reg_print(SIZE8, r3);
+ put_rn();
+ PRINTF("IMSC");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r4);
+ put_rn();
+ PRINTF("RIS");
+ PRINTF(imsg3);
+ reg_print(SIZE8, r5);
+ put_rn();
+ PRINTF("MIS");
+ PRINTF(imsg3);
+ reg_print(SIZE8, r6);
+ put_rn();
+ PRINTF("ICR");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r7);
+ put_rn();
+}
+
+void uart_reg(void){
+uint32_t r0,r1,r2,r3,r4,r5,r6;
+
+ // clear LCR[DLAB] to read registers
+ LPC_UART->LCR &= ~(1 << 7);
+ r0 = LPC_UART->RBR;
+ r1 = LPC_UART->IER;
+ r2 = LPC_UART->IIR;
+ r3 = LPC_UART->TER;
+ // set LCR[DLAB] to enable writing to divider registers
+ LPC_UART->LCR |= (1 << 7);
+ r4 = LPC_UART->DLL;
+ r5 = LPC_UART->DLM;
+ r6 = LPC_UART->FDR;
+ // clear LCR[DLAB]
+ LPC_UART->LCR &= ~(1 << 7);
+ // Print each register
+ PRINTF("Show UART Registers");
+ put_rn();
+ PRINTF("RBR");
+ PRINTF(imsg4);
+ reg_print(SIZE8, r0);
+ put_rn();
+ PRINTF("THR--Write only");
+ PRINTF(imsg4);
+ put_rn();
+ PRINTF("DLL");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r4);
+ put_rn();
+ PRINTF("DLM");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r5);
+ put_rn();
+ PRINTF("IER");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r1);
+ put_rn();
+ PRINTF("IIR");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r2);
+ put_rn();
+ PRINTF("FCR--Write only");
+ PRINTF(imsg2);
+ put_rn();
+ PRINTF("LCR,MCR,MSR,SCR,ACR--Not support");
+ put_rn();
+ PRINTF("FDR");
+ PRINTF(imsg2);
+ reg_print(SIZE8, r6);
+ put_rn();
+ PRINTF("TER");
+ PRINTF(imsg3);
+ reg_print(SIZE8, r3);
+ put_rn();
+ PRINTF("RS485CTRL,485ADRMATCH,485DLY--Not support");
+ put_rn();
+}
+#endif //USE_REG_SPI_UART
+
+#if USE_SYS
+void cpu_inf (void){
+ unsigned long m1, m2;
+
+ m1 = SCB->CPUID;
+ m2 = (m1 >> 24);
+ if (m2 == 0x41) {
+ put_r();
+ PRINTF("CPU = ARM ");
+ } else {
+ put_r();
+ PRINTF("CPU = NOT ARM ");
+ }
+ m2 = (m1 >> 4) & 0xfff;
+ if (m2 == 0xc23) {
+ PRINTF("Cortex-M3");
+ put_rn();
+ } else if (m2 == 0xc20){
+ PRINTF("Cortex-M0");
+ put_rn();
+ } else {
+ PRINTF("NOT Cortex-M3,M0");
+ put_rn();
+ }
+ m2 = (m1 >> 20) & 0x0f;
+ PRINTF("Variant:%x", m2);
+ put_rn();
+ m2 = m1 & 0x7;
+ PRINTF("Revision:%x", m2);
+ put_rn();
+}
+
+// Calculate CPU System Clock Frequency /refrence: system_LPCxx.c
+static char *const fmsg0 = "Internal RC Oscillator";
+static char *const fmsg1 = "Xtal Osc Clock";
+static char *const fmsg2 = "Watch dog Osc Clock";
+static char *const fmsg3 = "with PLL";
+static char *const fmsg4 = "System Clock =";
+static char *const fmsg5 = "PLL Post divider ratio =";
+static char *const fmsg6 = "feedback devider =";
+static char *const fmsg7 = "NO Clock ?!";
+
+void get_freq_w_print (void){ // Get Core Clock Frequency
+uint32_t wdt_osc = 0, pll_fct0 = 0, pll_fct1 = 0;
+
+ // Determine clock frequency according to clock register values
+ switch ((LPC_SYSCON->WDTOSCCTRL >> 5) & 0x0F) {
+ case 0: wdt_osc = 400000; break;
+ case 1: wdt_osc = 500000; break;
+ case 2: wdt_osc = 800000; break;
+ case 3: wdt_osc = 1100000; break;
+ case 4: wdt_osc = 1400000; break;
+ case 5: wdt_osc = 1600000; break;
+ case 6: wdt_osc = 1800000; break;
+ case 7: wdt_osc = 2000000; break;
+ case 8: wdt_osc = 2200000; break;
+ case 9: wdt_osc = 2400000; break;
+ case 10: wdt_osc = 2600000; break;
+ case 11: wdt_osc = 2700000; break;
+ case 12: wdt_osc = 2900000; break;
+ case 13: wdt_osc = 3100000; break;
+ case 14: wdt_osc = 3200000; break;
+ case 15: wdt_osc = 3400000; break;
+ }
+ wdt_osc /= ((LPC_SYSCON->WDTOSCCTRL & 0x1F) << 1) + 2;
+ put_r();
+ switch (LPC_SYSCON->MAINCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ SystemCoreClock = __IRC_OSC_CLK;
+ PRINTF("%s = %dHz", fmsg0, SystemCoreClock);
+ break;
+ case 1: // Input Clock to System PLL
+ switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ SystemCoreClock = __IRC_OSC_CLK;
+ PRINTF("%s = %dHz", fmsg0, SystemCoreClock);
+ break;
+ case 1: // System oscillator
+ SystemCoreClock = __SYS_OSC_CLK;
+ PRINTF("%s = %dHz", fmsg1, SystemCoreClock );
+ break;
+ case 2: // WDT Oscillator
+ SystemCoreClock = wdt_osc;
+ PRINTF("%s = %dHz", fmsg2, wdt_osc );
+ break;
+ case 3: // Reserved
+ SystemCoreClock = 0;
+ PRINTF(fmsg7);
+ break;
+ }
+ break;
+ case 2: // WDT Oscillator
+ SystemCoreClock = wdt_osc;
+ PRINTF("%s = %dHz", fmsg2, wdt_osc );
+ break;
+ case 3: // System PLL Clock Out
+ switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = __IRC_OSC_CLK;
+ PRINTF("%s = %dHz", fmsg0, SystemCoreClock);
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = __IRC_OSC_CLK * pll_fct0;
+ PRINTF("Use Internal RC = %dHz", __IRC_OSC_CLK);
+ put_rn();
+ PRINTF("%s %s = %dHz", fmsg0, fmsg3, SystemCoreClock);
+ put_rn();
+ PRINTF("%s %d, %s %d", fmsg5, pll_fct1, fmsg6, pll_fct0);
+ }
+ break;
+ case 1: // System oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = __SYS_OSC_CLK;
+ PRINTF("%s = %dHz", fmsg1, SystemCoreClock );
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = __SYS_OSC_CLK * pll_fct0;
+ PRINTF("Use XTAL = %dHz", __XTAL);
+ put_rn();
+ PRINTF("%s %s = %dHz", fmsg1, fmsg3, SystemCoreClock);
+ put_rn();
+ PRINTF("%s %d, %s %d", fmsg5, pll_fct1, fmsg6, pll_fct0);
+ }
+ break;
+ case 2: // WDT Oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = wdt_osc;
+ PRINTF("%s = %dHz", fmsg2, wdt_osc );
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = wdt_osc * pll_fct0;
+ PRINTF("Use WDT OSC = %dHz", wdt_osc);
+ put_rn();
+ PRINTF("%s %s = %dHz", fmsg2, fmsg3, SystemCoreClock);
+ put_rn();
+ PRINTF("%s %d, %s %d", fmsg5, pll_fct1, fmsg6, pll_fct0);
+ }
+ break;
+ case 3: // Reserved
+ SystemCoreClock = 0;
+ PRINTF("fmsg7");
+ break;
+ }
+ break;
+ }
+ SystemCoreClock /= LPC_SYSCON->SYSAHBCLKDIV;
+ put_rn();
+ PRINTF("%s %dHz", fmsg4, SystemCoreClock);
+ put_rn();
+}
+#endif //USE_SYS
+
+void get_freq (void){ // Get Core Clock Frequency
+uint32_t wdt_osc = 0, pll_fct0 = 0, pll_fct1 = 0;
+
+ // Determine clock frequency according to clock register values
+ switch ((LPC_SYSCON->WDTOSCCTRL >> 5) & 0x0F) {
+ case 0: wdt_osc = 400000; break;
+ case 1: wdt_osc = 500000; break;
+ case 2: wdt_osc = 800000; break;
+ case 3: wdt_osc = 1100000; break;
+ case 4: wdt_osc = 1400000; break;
+ case 5: wdt_osc = 1600000; break;
+ case 6: wdt_osc = 1800000; break;
+ case 7: wdt_osc = 2000000; break;
+ case 8: wdt_osc = 2200000; break;
+ case 9: wdt_osc = 2400000; break;
+ case 10: wdt_osc = 2600000; break;
+ case 11: wdt_osc = 2700000; break;
+ case 12: wdt_osc = 2900000; break;
+ case 13: wdt_osc = 3100000; break;
+ case 14: wdt_osc = 3200000; break;
+ case 15: wdt_osc = 3400000; break;
+ }
+ wdt_osc /= ((LPC_SYSCON->WDTOSCCTRL & 0x1F) << 1) + 2;
+ switch (LPC_SYSCON->MAINCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ SystemCoreClock = __IRC_OSC_CLK;
+ break;
+ case 1: // Input Clock to System PLL
+ switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ SystemCoreClock = __IRC_OSC_CLK;
+ break;
+ case 1: // System oscillator
+ SystemCoreClock = __SYS_OSC_CLK;
+ break;
+ case 2: // WDT Oscillator
+ SystemCoreClock = wdt_osc;
+ break;
+ case 3: // Reserved
+ SystemCoreClock = 0;
+ break;
+ }
+ break;
+ case 2: // WDT Oscillator
+ SystemCoreClock = wdt_osc;
+ break;
+ case 3: // System PLL Clock Out
+ switch (LPC_SYSCON->SYSPLLCLKSEL & 0x03) {
+ case 0: // Internal RC oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = __IRC_OSC_CLK;
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = __IRC_OSC_CLK * pll_fct0;
+ }
+ break;
+ case 1: // System oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = __SYS_OSC_CLK;
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = __SYS_OSC_CLK * pll_fct0;
+ }
+ break;
+ case 2: // WDT Oscillator
+ if (LPC_SYSCON->SYSPLLCTRL & 0x180) {
+ SystemCoreClock = wdt_osc;
+ } else {
+ pll_fct0 = (LPC_SYSCON->SYSPLLCTRL & 0x01F) + 1;
+ pll_fct1 = (LPC_SYSCON->SYSPLLCTRL & 0x060) >> 5UL;
+ SystemCoreClock = wdt_osc * pll_fct0;
+ }
+ break;
+ case 3: // Reserved
+ SystemCoreClock = 0;
+ break;
+ }
+ break;
+ }
+ SystemCoreClock /= LPC_SYSCON->SYSAHBCLKDIV;
+}
+
+#if USE_REG_I2C
+void i2c_io_reg (void){
+uint32_t r0;
+
+ PRINTF("<Show IO Pin>");
+ put_rn();
+ // P0_4
+ r0 = LPC_IOCON->PIO0_4;
+ reg_print(SIZE_X, r0);
+ put_spc(2);
+ PRINTF("%s4(dp27)",io_port_name0);
+ put_spc(2);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0:
+ PRINTF(iomsg1);
+ break;
+ case 1:
+ PRINTF("SCL");
+ break;
+ }
+ put_lin();
+ switch (( r0 >> 8 ) & 0x3){
+ case 0:
+ PRINTF(iomsg4);
+ break;
+ case 1:
+ PRINTF(iomsg1);
+ break;
+ case 2:
+ PRINTF("Fast md");
+ break;
+ case 3:
+ PRINTF(iomsg2);
+ break;
+ }
+ put_rn();
+ // P0_5
+ r0 = LPC_IOCON->PIO0_5;
+ reg_print( SIZE_X, r0 );
+ put_spc(2);
+ PRINTF("%s5(dp5)",io_port_name0);
+ put_spc(3);
+ PRINTF(iomsg0);
+ switch (r0 & 0x7){
+ case 0:
+ PRINTF(iomsg1);
+ break;
+ case 1:
+ PRINTF("SDA");
+ break;
+ }
+ put_lin();
+ switch ((r0 >> 8 ) & 0x3){
+ case 0:
+ PRINTF(iomsg4);
+ break;
+ case 1:
+ PRINTF(iomsg1);
+ break;
+ case 2:
+ PRINTF("Fast md");
+ break;
+ case 3:
+ PRINTF(iomsg2);
+ break;
+ }
+ put_rn();
+}
+
+void i2c_reg (void){
+uint32_t r0,r1,r2,r3,r4,r5,r6,r7;
+
+ r0 = LPC_I2C->CONSET;
+ r1 = LPC_I2C->STAT;
+ r2 = LPC_I2C->DAT;
+ r3 = LPC_I2C->SCLH;
+ r4 = LPC_I2C->SCLL;
+ r5 = LPC_I2C->CONCLR;
+ r6 = LPC_I2C->MMCTRL;
+ r7 = LPC_I2C->DATA_BUFFER;
+
+ PRINTF("<Show I2C Registers>");
+ put_rn();
+ reg_print(SIZE8, r0);
+ put_spc(2);
+ PRINTF("CONSET");
+ PRINTF(imsg2);
+ put_rn();
+ reg_print(SIZE8, r1);
+ put_spc(2);
+ PRINTF("STAT");
+ PRINTF(imsg3);
+ put_rn();
+ reg_print(SIZE8, r2);
+ put_spc(2);
+ PRINTF("DAT");
+ PRINTF(imsg4);
+ put_rn();
+ put_spc(2);
+ PRINTF("ADR0--Not support");
+ put_rn();
+ reg_print(SIZE8, r3);
+ put_spc(2);
+ PRINTF("SCLH");
+ PRINTF(imsg2);
+ put_rn();
+ reg_print(SIZE8, r4);
+ put_spc(2);
+ PRINTF("SCLL");
+ PRINTF(imsg2);
+ put_rn();
+ reg_print(SIZE8, r5);
+ put_spc(2);
+ PRINTF("CONCLR");
+ PRINTF(imsg2);
+ put_rn();
+ reg_print(SIZE8, r6);
+ put_spc(2);
+ PRINTF("MMCTRL");
+ PRINTF(imsg2);
+ put_rn();
+ put_spc(2);
+ PRINTF("ADR1,2,3--Not support");
+ put_rn();
+ reg_print(SIZE8, r7);
+ put_spc(2);
+ PRINTF("DATA_BUFFER");
+ PRINTF(imsg7);
+ put_rn();
+ put_spc(2);
+ PRINTF("MASK0,1,2,3--Not support");
+ put_rn();
+}
+
+void i2c_freq (void){
+uint32_t r0,r1;
+
+ r0 = LPC_I2C->SCLH;
+ r1 = LPC_I2C->SCLL;
+ get_freq();
+ PRINTF("<I2C Status>");
+ put_rn();
+ PRINTF("Freq. = I2CPCLK/(SCLH+SCLL) = %d/(%d+%d) = %d Hz",
+ SystemCoreClock, r0, r1, SystemCoreClock/(r0+r1));
+ put_rn();
+ r0 = LPC_I2C->CONSET;
+ PRINTF("I2C I/F ");
+ if ( r0 & 0x40 ) {
+ PRINTF("Enabled");
+ } else {
+ PRINTF("disabled");
+ }
+ put_rn();
+}
+#endif
+
+#if USE_MEM
+// Range check for Memory dump
+static void check_range (MEMO * mem){
+uint8_t i;
+uint32_t m;
+
+ mem->mflg = ERR_NOTHING;
+ for (i = 0 ; i < 5 ; i++) {
+ if (mem->mstr >= mem_range[i][0]) {
+ if (mem->mstr < mem_range[i][1]) {
+ m = mem->mstr + mem->msiz;
+ if (m < mem_range[i][1]) {
+ return; // no modification
+ } else {
+ m = mem_range[i][1];
+ mem->msiz = m - mem->mstr + 1;
+ mem->mflg = ERR_MODIFY_SIZ;
+ return; // modified size
+ }
+ }
+ }
+ }
+ mem->mflg = ERR_OUT_OF_RANGE;
+ mem->mstr = 0;
+ mem->msiz = 0;
+ return ;
+}
+
+// Memory dump error massage
+void error_print (unsigned char flg){
+ switch (flg) {
+ case ERR_MODIFY_SIZ :
+ put_r();
+ PRINTF("Reach to out of range ");
+ put_rn();
+ break;
+ case ERR_OUT_OF_RANGE :
+ put_r();
+ PRINTF("Not in a memory area ");
+ put_rn();
+ break;
+ case ERR_NOTHING :
+ default :
+ ;
+ }
+}
+
+// Print memory contents
+void put_dump (const unsigned char *buff, unsigned long ofs, int cnt){
+int n;
+
+ PRINTF("%08lX ", ofs);
+ for(n = 0; n < cnt; n++) { PRINTF(" %02X", buff[n]); }
+ PUTC(' ');
+ for(n = 0; n < cnt; n++) {
+ if ((buff[n] < 0x20)||(buff[n] >= 0x7F)) { PUTC('.');
+ } else { PUTC(buff[n]); }
+ }
+ put_rn();
+}
+
+// dump memory with error check
+void dump_w_err_ckeck (char **ptr, MEMO * mem){
+ check_range (mem);
+ for (*ptr=(char*)mem->mstr; mem->msiz >= 16; *ptr += 16, mem->msiz -= 16) {
+ put_r();
+ put_dump((unsigned char*)*ptr, (unsigned int)*ptr, 16);
+ }
+ if (mem->msiz) { put_dump((unsigned char*)*ptr, (unsigned int)*ptr, mem->msiz);
+ }
+ error_print(mem->mflg);
+}
+
+static void mem_inf (char *ptr){
+ put_r();
+ PRINTF("Mem. Mode d <address> [<count>], s, <ret> or f, q, ?");
+ put_rn();
+ mem.mstr = mem_range[0][0]; // default start address = Flash
+ mem.msiz =256;
+ mem.mold = 0;
+ mem.mtmp = 0;
+ mem.mflg = 0;
+ for (; mem.mflg != 0xff;) {
+ PRINTF("m>");
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ put_r();
+ switch(*ptr++){
+ case 'd' : // d <address> [<count>] - Dump memory
+ mem.mtmp = mem.mstr;
+ if (!xatoi(&ptr, &mem.mstr)) {
+ mem.mstr = mem.mtmp;
+ }
+ if (!xatoi(&ptr, &mem.msiz)) {
+ mem.msiz = 256;
+ }
+ mem.mtmp = mem.msiz;
+ dump_w_err_ckeck(&ptr, &mem);
+ mem.mold = mem.mstr;
+ mem.mstr += mem.mtmp;
+ break;
+ case 'f' : // next
+ case 'n' :
+ case 0x0d :
+ mem.msiz = 256;
+ mem.mtmp = mem.msiz;
+ dump_w_err_ckeck(&ptr, &mem);
+ mem.mold = mem.mstr;
+ mem.mstr += 256;
+ break;
+ case 'q' : // quit
+ mem.mflg = 0xff;
+ break;
+ case 'b' : // Back to more
+ if (mem.mold == 0){
+ ;
+ } else {
+ mem.mold -= 256;
+ }
+ case 'k' : // keep previous address
+ mem.mstr = mem.mold;
+ mem.msiz = 256;
+ mem.mtmp = mem.msiz;
+ dump_w_err_ckeck(&ptr, &mem);
+ mem.mstr += 256;
+ break;
+ case 'a' : // start RAM top
+ mem.mstr = mem_range[1][0];
+ mem.msiz =256;
+ mem.mold = 0;
+ mem.mtmp = 0;
+ mem.mflg = 0;
+ dump_w_err_ckeck(&ptr, &mem);
+ mem.mstr += 256;
+ break;
+ case 'o' : // start ROM top
+ mem.mstr = mem_range[0][0];
+ mem.msiz =256;
+ mem.mold = 0;
+ mem.mtmp = 0;
+ mem.mflg = 0;
+ dump_w_err_ckeck(&ptr, &mem);
+ mem.mstr += 256;
+ break;
+ case 's' :
+ PRINTF("Memory Configuration");
+ put_rn();
+ PRINTF("%s0x%08lx to 0x%08lx ", rmsg0, mem_range[0][0], mem_range[0][1]);
+ put_rn();
+ PRINTF("%s0x%08lx to 0x%08lx ", rmsg1, mem_range[1][0], mem_range[1][1]);
+ put_rn();
+ PRINTF("%s0x%08lx to 0x%08lx ", rmsg2, mem_range[2][0], mem_range[2][1]);
+ put_rn();
+ PRINTF("%s0x%08lx to 0x%08lx ", rmsg3, mem_range[3][0], mem_range[3][1]);
+ put_rn();
+ PRINTF("%s0x%08lx to 0x%08lx ", rmsg4, mem_range[4][0], mem_range[4][1]);
+ put_rn();
+ break;
+ case '?' :
+ PRINTF("d <address> [<count>] - Dump memory");
+ put_rn();
+ PRINTF("s - Show memory structure ");
+ put_rn();
+ PRINTF("o - Dump memory / start from ROM top");
+ put_rn();
+ PRINTF("a - Dump memory / start from RAM top");
+ put_rn();
+ PRINTF("k - Dump memory / keep same 256bytes");
+ put_rn();
+ PRINTF("b - Dump memory / before 256bytes");
+ put_rn();
+ PRINTF("<RET> or f, n - Dump memory / next 256bytes");
+ put_rn();
+ PRINTF("q - Exit memory mode");
+ put_rn();
+ break;
+ default:
+ PUTC('?');
+ put_rn();
+ }
+ }
+ PRINTF("Return to Normal Mode");
+}
+#endif //USE_MEM
+
+#if USE_EEP
+static void mem_chk_msg (char mflg){
+ switch (mflg) {
+ case ERR_MODIFY_SIZ :
+ PRINTF(" Reached out of range");
+ put_rn();
+ break;
+ case ERR_OUT_OF_RANGE :
+ PRINTF(" Not in a memory area");
+ put_rn();
+ break;
+ case ERR_NOTHING :
+ default :
+ ;
+ }
+}
+
+void put_eep_dump (
+ uint32_t addr, // Heading address value
+ uint8_t len // Number of items to be dumped
+){
+uint32_t i;
+uint8_t eep[16];
+
+ PRINTF("%08lx ", addr); // address
+ for (i = 0; i < len; i++) { // Hexdecimal dump
+ eep[i] = xat24c1024.read(addr++);
+ PRINTF(" %02x", eep[i]);
+ }
+ PUTC(' ');
+ for (i = 0; i < len; i++){ // ASCII dump
+ PUTC((eep[i] >= ' ' && eep[i] <= '~') ? eep[i] : '.');
+ }
+ put_rn();
+}
+
+static void check_eeprange (MEMO * eepmem){
+uint32_t m;
+
+ m = sizeof(eepmem_range) / sizeof(*eepmem_range);
+ eepmem->mflg = ERR_NOTHING;
+ if (eepmem->mstr >= eepmem_range[0]){
+ if (eepmem->mstr < eepmem_range[1]){
+ m = eepmem->mstr + eepmem->msiz;
+ if (m < eepmem_range[1]){
+ return; // no modification
+ } else {
+ m = eepmem_range[1];
+ eepmem->msiz = m - eepmem->mstr + 1;
+ eepmem->mflg = ERR_MODIFY_SIZ;
+ return; // modified size
+ }
+ }
+ }
+ eepmem->mflg = ERR_OUT_OF_RANGE;
+ eepmem->mstr = 0;
+ eepmem->msiz = 0;
+ return ;
+}
+
+static void eepmem_inf (char *ptr){
+uint8_t c, dt;
+unsigned long p1, p2, p3;
+
+ put_r();
+ PRINTF("Enter EEPROM 1) d <address> 256bytes, 2) s, 3) <ret>, 4) q 5) ?");
+ put_rn();
+ eepmem.mstr = eepmem_range[0]; // start head of table
+ eepmem.msiz =256;
+ eepmem.mold = 0;
+ eepmem.mtmp = 0;
+ eepmem.mflg = 0;
+ eepmem.mbhw = DW_CHAR;
+ for (; eepmem.mflg != 0xff;) {
+ PRINTF("e>");
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ put_r();
+ switch(*ptr++){
+ case 'd' : // d <address> - Dump memory
+ eepmem.mtmp = eepmem.mstr; // save defult start addres
+ if (!xatoi(&ptr, &eepmem.mstr)){
+ eepmem.mstr = eepmem.mtmp; // recover defult address
+ }
+ eepmem.msiz = 256;
+ eepmem.msiz /= eepmem.mbhw;
+ eepmem.mtmp = eepmem.msiz * eepmem.mbhw;
+ check_eeprange (&eepmem);
+ for (ptr=(char*)eepmem.mstr;
+ eepmem.msiz >= 16/eepmem.mbhw;
+ ptr += 16, eepmem.msiz -= 16/eepmem.mbhw)
+ {
+ put_eep_dump((UINT)ptr, 16/eepmem.mbhw);
+ }
+ if (eepmem.msiz){
+ put_eep_dump((UINT)ptr, eepmem.msiz);
+ }
+ mem_chk_msg( eepmem.mflg );
+ eepmem.mold = eepmem.mstr;
+ eepmem.mstr += eepmem.mtmp;
+ break;
+ case 'f' : // next
+ case 'n' :
+ case 0x0d : // CR
+ eepmem.msiz = 256/eepmem.mbhw;
+ eepmem.mtmp = eepmem.msiz;
+ check_eeprange (&eepmem);
+ for (ptr=(char*)eepmem.mstr;
+ eepmem.msiz >= 16/eepmem.mbhw;
+ ptr += 16, eepmem.msiz -= 16/eepmem.mbhw)
+ {
+ put_eep_dump((UINT)ptr, 16/eepmem.mbhw);
+ }
+ mem_chk_msg(eepmem.mflg);
+ eepmem.mold = eepmem.mstr;
+ eepmem.mstr += 256;
+ break;
+ case 'q' : // quit
+ eepmem.mflg = 0xff;
+ break;
+ case 'b' : // Back to more
+ if (eepmem.mold == 0){
+ ;
+ } else {
+ eepmem.mold -= 256;
+ }
+ case 'k' : // keep previous address
+ eepmem.mstr = eepmem.mold;
+ eepmem.msiz = 256/eepmem.mbhw;
+ eepmem.mtmp = eepmem.msiz;
+ check_eeprange (&eepmem);
+ for (ptr=(char*)eepmem.mstr; eepmem.msiz >= 16/eepmem.mbhw; ptr += 16,
+ eepmem.msiz -= 16/eepmem.mbhw){
+ put_eep_dump((UINT)ptr, 16/eepmem.mbhw);
+ }
+ mem_chk_msg(eepmem.mflg);
+ eepmem.mstr += 256;
+ break;
+ case 'e' : // e <address> [<value> ...] - Edit memory
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ p3 = DW_CHAR;
+ if (!xatoi(&ptr, &p1)){
+ PRINTF("? ->e <address> [<value> ...]");
+ put_rn();
+ break; // Get start address
+ }
+ if (xatoi(&ptr, &p2)) { // 2nd parameter is given
+ do {
+ xat24c1024.write((uint16_t)p1, (uint8_t)p2);
+ wait(0.01);
+ dt = xat24c1024.read((uint16_t)p1);
+ if (dt != (uint8_t)p2){
+ PRINTF("?\r\n");
+ }
+ p1 += p3;
+ } while (xatoi(&ptr, &p2)); // Get next value
+ break;
+ }
+ for (;;) {// 2nd parameter is not given (interactive mode)
+ PRINTF("%08x 0x%02x-", p1, *(BYTE*)p1);
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ if (*ptr == '.'){ break;}
+ if (*ptr == 0x1b){ break;}
+ if ((BYTE)*ptr >= ' ') {
+ if (!xatoi(&ptr, &p2)){ continue;}
+ xat24c1024.write((uint16_t)p1, (uint8_t)p2);
+ wait(0.01);
+ dt = xat24c1024.read((uint16_t)p1);
+ if (dt != (uint8_t)p2){
+ PRINTF("?\r\n");
+ }
+ }
+ p1 += p3;
+ }
+ break;
+ case 's' :
+ PRINTF("AT24C1024B");
+ put_rn();
+ PRINTF("EEPROM 0x%08lx to 0x%08lx", eepmem_range[0], eepmem_range[1]);
+ put_rn();
+ break;
+ case '?' :
+ PRINTF("d <address> -Dump memory");
+ PRINTF(" (e.g. >d 0x10f00<RET>)");
+ put_rn();
+ PRINTF("e <address> [<value> ...] - Edit memory");
+ put_rn();
+ PRINTF("s -Show memory structure");
+ put_rn();
+ PRINTF("<RET>-Dump memory, next 256 bytes (also 'f','n')");
+ put_rn();
+ PRINTF("k -Dump memory, same as before 256 bytes ('b' -256)");
+ put_rn();
+ PRINTF("q -Exit EEPROM mode" );
+ put_rn();
+ break;
+ default:
+ PUTC('?');
+ put_rn();
+ }
+ }
+ PRINTF("Return to Normal Mode");
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// Monitor Main Program
+//-----------------------------------------------------------------------------
+int mon_hw (void) {
+char *ptr;
+
+ put_r();
+ PRINTF("%s [Help:'?' key]", mon_msg_hw);
+ put_rn();
+#if USE_SYS
+ get_freq();
+#endif //USE_SYS
+ for (;;) {
+ put_r();
+ PUTC('>');
+ ptr = linebuf;
+ get_line(ptr, buf_size);
+ switch (*ptr++) {
+#if USE_MEM
+ //---------------------------------------------------------------------------------
+ // Memory
+ //---------------------------------------------------------------------------------
+ case 'm' :
+ mem_inf(ptr);
+ put_rn();
+ break;
+#endif // USE_MEM
+#if USE_EEP
+ //---------------------------------------------------------------------------------
+ // EEPROM Memory
+ //---------------------------------------------------------------------------------
+ /* EEPROM Memory */
+ case 'e' :
+ eepmem_inf(ptr);
+ put_rn();
+ break;
+#endif // USE_EEP
+#if USE_REG_SPI_UART
+ //--------------------------------------------------------------------------------------
+ // Register
+ //--------------------------------------------------------------------------------------
+ case 'r' :
+uint8_t r_flg;
+ put_r();
+ PRINTF("Reg. Mode p,u,i,s,t,a,d,l,w,c & ?");
+ put_rn();
+ r_flg = 0;
+ for (; r_flg != 0xff;) {
+ PRINTF("r>");
+ ptr = linebuf;
+ get_line(ptr, sizeof(linebuf));
+ put_r();
+ switch(*ptr++){
+ case 'p' :
+ switch(*ptr++){
+ case '0' :
+ io_config0();
+ break;
+ case '1' :
+ io_config1();
+ break;
+ case '*' :
+ io_config0();
+ put_rn();
+ io_config1();
+ break;
+ case '?' :
+ default:
+ PRINTF("Enter p0,p1 and p* for all");
+ put_rn();
+ }
+ break;;
+ case 'u' :
+ uart_reg();
+ break;
+ //case 'i' :
+ // i2c_reg();
+ // break;
+ case 's' :
+ switch(*ptr++){
+ case '0' :
+ spi_reg(SPI_0);
+ break;
+ case '1' :
+ spi_reg(SPI_1);
+ break;
+ case '*' :
+ spi_reg(SPI_0);
+ put_rn();
+ spi_reg( SPI_1 );
+ break;
+ case '?' :
+ default:
+ PRINTF("Enter s0,s1 and s* for all");
+ put_rn();
+ }
+ break;
+ case 't' : //
+ not_yet_impliment();
+ break;
+ case 'a' : //
+ not_yet_impliment();
+ break;
+ case 'd' : //
+ not_yet_impliment();
+ break;
+ case 'w' : //
+ not_yet_impliment();
+ break;
+ case 'l' : //
+ not_yet_impliment();
+ break;
+ case 'c' : //
+ not_yet_impliment();
+ break;
+ case 'x' : //
+ not_yet_impliment();
+ break;
+ case 'y' : //
+ not_yet_impliment();
+ break;
+ case '?' :
+ PRINTF("p - I/O Pin Config");
+ put_rn();
+ PRINTF("u - UART");
+ put_rn();
+ PRINTF("i - I2C -> separate command 'i'");
+ put_rn();
+ PRINTF("s - SPI");
+ put_rn();
+ PRINTF("t - TIMER");
+ put_rn();
+ PRINTF("a - ADC");
+ put_rn();
+ PRINTF("d - DAC");
+ put_rn();
+ PRINTF("l - LDC");
+ put_rn();
+ PRINTF("w - WWDG");
+ put_rn();
+ PRINTF("c - COMP");
+ put_rn();
+ break;
+ case 'q' : // quit
+ r_flg = 0xff;
+ break;
+ default:
+ PUTC('?');
+ put_rn();
+ }
+ }
+ PRINTF("Return to Normal Mode");
+ put_rn();
+ break;
+#endif // USE_REG_SPI_UART
+#if USE_PORT
+ //---------------------------------------------------------------------------------
+ // Port configration
+ //---------------------------------------------------------------------------------
+ case 'p' : //
+ put_r();
+ switch(*ptr++){
+ case '0' :
+ io_config0();
+ break;
+ case '1' :
+ io_config1();
+ break;
+ case '*' :
+ io_config0();
+ put_rn();
+ io_config1();
+ break;
+ case '?' :
+ default:
+ PRINTF("Enter p0,p1 and p* for all");
+ put_rn();
+ }
+ break;
+#endif // USE_PORT
+#if USE_REG_I2C
+ //---------------------------------------------------------------------------------
+ // I2C register
+ //---------------------------------------------------------------------------------
+ case 'i' : //
+ put_r();
+ i2c_io_reg();
+ i2c_reg();
+ i2c_freq();
+ break;
+#endif // USE_REG_I2C
+#if USE_SYS
+ //---------------------------------------------------------------------------------
+ // System
+ //---------------------------------------------------------------------------------
+ case 's' : // System related information
+ switch (*ptr++) {
+ case 'f' : // sc - show system clock frequency
+ get_freq_w_print();
+ break;
+ case 'c' : // sc - show system CPU information
+ cpu_inf();
+ break;
+ case '?' :
+ default:
+ put_r();
+ PRINTF("sc - System CPU information");
+ put_rn();
+ PRINTF("sf - System Clock");
+ put_rn();
+ break;
+ }
+ break;
+#endif // USE_SYS
+ //---------------------------------------------------------------------------------
+ // Help
+ //---------------------------------------------------------------------------------
+ case '?' :
+ put_r();
+ msg_hlp_hw();
+ break;
+ //---------------------------------------------------------------------------------
+ // Return to main routine
+ //---------------------------------------------------------------------------------
+ case 'q' : // Quit
+ PRINTF("\rReturn to monitor ");
+ return 0;
+ //---------------------------------------------------------------------------------
+ // Special command for DEBUG
+ //---------------------------------------------------------------------------------
+#if DEBUG
+ case 'x' :
+ not_yet_impliment();
+ break;
+#endif
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mon_hw_config.h Sun Jun 29 06:58:00 2014 +0000 @@ -0,0 +1,25 @@ +/* + * mbed Headder file for the mbed LPC1114FN28 + * + * Copyright (c) 2014 Kenji Arai / JH1PJL + * http://www.page.sannet.ne.jp/kenjia/index.html + * http://mbed.org/users/kenjiArai/ + * Created: June 1st, 2014 + * Revised: June 29th, 2014 + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE + * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +// Definition ------------------------------------------------------------------------------------ +#define DEBUG 0 + +#define USE_MEM 0 +#define USE_REG_SPI_UART 0 +#define USE_PORT 0 +#define USE_REG_I2C 1 +#define USE_SYS 1 +#define USE_EEP 1