Jack Berkhout
x
Dependencies: AP3000 ARM_RTC Beep BurstSPI FRAMSPI FT813 I2CEEBlockDevice I2CList MCP79412 NMEA0183 PCA9745B SDBlockDevice SPIFBlockDevice SystemClock WDT nmea_parser
Diff: main.cpp
- Revision:
- 0:a3b629f6dab5
diff -r 000000000000 -r a3b629f6dab5 main.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Mon Jul 23 12:32:19 2018 +0000
@@ -0,0 +1,1576 @@
+#include "mbed.h"
+// string::substr
+//#include <iostream>
+//#include <string>
+
+#include "main.h"
+
+#include "AP3000.h"
+#include "SetupPage.h"
+
+// https://github.com/ARMmbed/sd-driver
+// https://github.com/ARMmbed/mbed-os-example-fat-filesystem/blob/master/main.cpp
+// https://github.com/RudolphRiedel/FT800-FT813
+// https://github.com/RudolphRiedel/FT800-FT813/blob/master/FT8_commands.c
+// https://os.mbed.com/components/EVE-FT800/
+// https://os.mbed.com/users/dreschpe/code/FT800_2/file/16e22c789f7d/FT_CoPro_Cmds.cpp/
+// https://os.mbed.com/users/dreschpe/code/FT800_RGB_demo2/
+// https://os.mbed.com/users/dreschpe/code/FT800_RGB_demo2/docs/tip/main_8cpp_source.html
+// https://os.mbed.com/users/dreschpe/code/FT800_2/file/16e22c789f7d/FT_CoPro_Cmds.cpp/
+// https://os.mbed.com/users/dreschpe/code/FT800_JPG/
+// https://os.mbed.com/users/dreschpe/code/FT800_JPG/file/c603024cbd1d/main.cpp/
+// https://os.mbed.com/users/cpm219/code/FT810/rev/2d0ef4830603/
+// https://os.mbed.com/users/davidchilds/code/FT810_RGB_demo/file/7a29cc1298ef/main.cpp/
+// https://os.mbed.com/users/mozillain/code/FT810/
+// https://os.mbed.com/teams/The-Best/code/FT800_3/rev/a69ac4d39afd/
+// https://www.mikrocontroller.net/topic/395608
+// https://os.mbed.com/users/cpm219/code/FT810/docs/ca6a7c6a2f4b/FT__GPU__Hal_8cpp_source.html
+// https://os.mbed.com/users/mozillain/code/FT810/file/74108436751e/src/FT_Hal_Utils.cpp/
+// https://os.mbed.com/teams/mbed-os-examples/code/mbed-os-example-fat-filesystem/rev/ab69df6f1c47/
+// https://os.mbed.com/questions/79055/How-can-I-get-a-library-for-a-SD-card-re/
+// https://docs.mbed.com/docs/mbed-os-api-reference/en/latest/APIs/storage/filesystem/
+// Existing block devices:
+// SDBlockDevice - block device for SD cards.
+// SPIFBlockDevice - block device for NOR based SPI flash devices.
+// I2CEEBlockDevice - block device for EEPROM based I2C devices.
+// HeapBlockDevice - block device backed by the heap for quick testing.
+// https://github.com/armmbed/sd-driver
+// https://github.com/ARMmbed/spif-driver
+// https://github.com/ARMmbed/i2cee-driver
+// https://www.mikroe.com/flash-click
+// https://www.tindie.com/products/Bazinga/micron-1gb-serial-nor-flash-memory-breakout/
+// https://os.mbed.com/teams/Embedded-Artists/wiki/LPC4088DM-Using-Images
+// https://github.com/ARMmbed/spif-driver
+// http://nl.farnell.com/integrated-silicon-solution-issi/is25lp128-jble/nor-flash-memory-128mbit-133mhz/dp/2787056 € 2,36
+// http://nl.farnell.com/cypress-semiconductor/s25fl128lagmfv010/flash-memory-128mbit-133mhz-soic/dp/2771141 € 3,81
+// http://nl.farnell.com/spansion/s25fl256sagmfi011/memory-flash-256mb-16soic/dp/2340545?st=Flash%20Memory%20NOR
+// http://nl.farnell.com/cypress-semiconductor/s25fl512sagmfi011/memory-flash-512mbit-16soic/dp/2136298?st=Flash%20Memory%20NOR%20512mbit
+// http://nl.farnell.com/cypress-semiconductor/s25fl128lagmfm010/flash-memory-aec-q100-128mbit/dp/2771145 € 5,54
+// https://os.mbed.com/users/Decimus/code/FRAMSPI/
+// http://www.ftdicommunity.com/index.php?board=3.0
+// https://github.com/nopnop2002/STM32_GD2/blob/master/STM32_GD2.cpp
+// http://www.ftdichip.com/Support/Documents/AppNotes/AN_269_FT_App_Signature.pdf
+// http://forum.arduino.cc/index.php?topic=296126.0
+// https://www.youtube.com/watch?v=2FKN5UdqCKg
+// https://os.mbed.com/users/Sissors/code/BurstSPI/
+
+
+//#define BAUD_RATE 9600
+//// NUCLEO-F746ZG
+//#define USB_TX SERIAL_TX // PD_8 USART3 TX
+//#define USB_RX SERIAL_RX // PD_9 USART3 RX
+//
+//#define BUFFER_SIZE 8192
+//
+//#define BUTTON_ACCEPT_ALARM_TAG 1
+//#define BUTTON_ACCEPT_HORN_TAG 2
+//#define BUTTON_SET_TAG 3
+//#define BUTTON_DIM_TAG 4
+//
+//#define TFT_MOSI PA_7
+//#define TFT_MISO PA_6
+//#define TFT_SCLK PA_5
+//#define TFT_CS PC_7
+//#define TFT_INT PB_4
+//#define TFT_PD PA_4
+//
+//// Pinout on Nucleo-F746ZG
+//#define SD_MOSI PE_14
+//#define SD_MISO PE_13
+//#define SD_SCLK PE_12
+//#define SD_CS PE_11
+//
+//#define SF_MOSI PB_15
+//#define SF_MISO PC_2
+//#define SF_SCLK PB_13
+//#define SF_CS PB_12
+//
+//#define EE_SDA PB_9
+//#define EE_SCL PB_8
+//#define EE_ADDR 0xa0
+//#define EE_SIZE 32*1024
+//#define EE_BLOCK_SIZE 16
+//
+//#define MBED_CONF_SD_SPI_TRANSFER_FREQ 40000000
+//
+//#define INDICATOR_RUN_STATUS_OFF 0
+//#define INDICATOR_RUN_STATUS_RUNNING 1
+//#define INDICATOR_RUN_STATUS_WARNING 2
+//#define INDICATOR_RUN_STATUS_OFF_RED 3
+//
+//#define INDICATOR_ALARM_STATUS_OFF 0
+//#define INDICATOR_ALARM_STATUS_WARNING 1
+//#define INDICATOR_ALARM_STATUS_FAILURE 2
+//
+Serial pc(USBTX, USBRX);
+
+DigitalOut myled(LED1);
+
+// Setup the watchdog timer
+WDT wdt;
+
+FT813 TFT(TFT_MOSI, TFT_MISO, TFT_SCLK, TFT_CS, TFT_INT, TFT_PD); // mosi, miso, sck, ss, int, pd // the FT813 is connected to SPI 11-13
+
+// PinName io0, PinName io1, PinName io2, PinName io3, PinName sclk, PinName ssel=NC, int mode=0
+//QSPI qspi(PF_8, PF_9, PF_7, PF_6, PF_10, PB_10);
+DigitalOut myledPF8(PF_8);
+
+//HeapBlockDevice bd(128 * 512, 512);
+
+// Instantiate the SDBlockDevice by specifying the SPI pins connected to the SDCard socket.
+SDBlockDevice sd(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS, MBED_CONF_SD_SPI_TRANSFER_FREQ);
+
+// Create flash device on SPI bus with PTE5 as chip select
+SPIFBlockDevice spif(SF_MOSI, SF_MISO, SF_SCLK, SF_CS, 100000); // mosi, miso, sclk, cs, freq
+
+// Create EEPROM device on I2C bus with 32kbytes of memory
+//I2CEEBlockDevice ee(EE_SDA, EE_SCL, EE_ADDR, EE_SIZE, EE_BLOCK_SIZE); // sda, scl, addr, size, block, freq
+
+//I2C i2c(EE_SDA, EE_SCL); // sda, scl
+//
+//I2CList I2C_List(EE_SDA, EE_SCL); // sda, scl
+
+//SPI spi(SF_MOSI, SF_MOSI, SF_SCLK); // mosi, miso, sclk
+//FRAMSPI fram(spi, SF_CS);
+
+BurstSPI bspi(SF_MOSI, SF_MISO, SF_SCLK); // PinName mosi, PinName miso, PinName sclk
+SPI rspi(SF_MOSI, SF_MISO, SF_SCLK); // PinName mosi, PinName miso, PinName sclk
+
+FATFileSystem fs("fs");
+
+//AP3000 ap3000(&TFT);
+
+Timer timer;
+
+NMEA0183 nmea0183;
+
+MCP79412 rtc(EE_SDA, EE_SCL); // sda, scl
+
+uint8_t setting_block_size;
+
+struct t_setting {
+ uint8_t version;
+ char name[32];
+ double value;
+} setting = {
+ 1,
+ "Hello World!",
+ 3.1415926536
+};
+
+//struct button {
+// uint8_t accept_alarm_pressed;
+// uint8_t accept_horn_pressed;
+// uint8_t set_pressed;
+// uint8_t dim_pressed;
+//};
+//
+//struct indicator {
+// uint8_t md_main_running;
+// uint8_t rb_main_phase_fail;
+// uint8_t rb_main_main_power;
+// uint8_t rb_main_ctrl_power;
+// uint8_t rb_main_oil_press;
+// uint8_t rb_main_hydr_lock;
+// uint8_t rb_main_overload;
+// uint8_t rb_main_oil_level;
+// uint8_t rb_main_oil_filter;
+// uint8_t rb_main_oil_temp;
+//
+// uint8_t md_aux_running;
+// uint8_t rb_aux_phase_fail;
+// uint8_t rb_aux_main_power;
+// uint8_t rb_aux_ctrl_power;
+// uint8_t rb_aux_oil_press;
+// uint8_t rb_aux_hydr_lock;
+// uint8_t rb_aux_overload;
+// uint8_t rb_aux_oil_level;
+// uint8_t rb_aux_oil_filter;
+// uint8_t rb_aux_oil_temp;
+//
+// uint8_t rb_fu_failure;
+// uint8_t rb_used;
+// uint8_t rb_main_most_used;
+// uint8_t rb_aux_most_used;
+//};
+//
+//struct button my_button;
+
+typedef struct {
+ char name[64];
+ uint16_t fmt;
+ uint16_t w;
+ uint16_t h;
+} image;
+
+//image images[128];
+
+uint16_t imageCount = 0;
+
+ ft_int16_t x_size,y_size;
+ int err;
+
+void return_error(int ret_val){
+ if (ret_val)
+ printf("\033[1;31mFailure. %d\033[0m\n", ret_val);
+ else
+ printf("\033[1;32mdone.\033[0m\n");
+}
+
+void errno_error(void* ret_val){
+ if (ret_val == NULL)
+ printf(" \033[1;31mFailure. %d\033[0m\n", errno);
+ else
+ printf(" \033[1;32mdone.\033[0m\n");
+}
+
+// global Vars
+unsigned int r,b,g;
+
+
+//int getImageIndexFromName(char *name) {
+// for (int i = 0; i < imageCount; i++) {
+// if(strstr(images[i].name, name) != NULL) {
+// return i;
+// }
+// }
+// return -1;
+//}
+
+
+// function to convert hue , saturation and value to RGB
+// see http://en.wikipedia.org/wiki/HSL_and_HSV
+void hsv2rgb(float H, float S, float V)
+{
+ float f, h, p, q, t;
+ int i;
+ if( S == 0.0) {
+ r = V * 255;
+ g = V * 255;
+ b = V * 255;
+ return;
+ }
+ if(H > 360.0) H = 0.0; // check values
+ if(S > 1.0) S = 1.0;
+ if(S < 0.0) S = 0.0;
+ if(V > 1.0) V = 1.0;
+ if(V < 0.0) V = 0.0;
+
+ h = H / 60.0;
+ i = (int) h;
+ f = h - i;
+ p = V * (1.0 - S);
+ q = V * (1.0 - (S * f));
+ t = V * (1.0 - (S * (1.0 - f)));
+
+ switch(i) {
+ case 0:
+ r = V * 255;
+ g = t * 255;
+ b = p * 255;
+ break;
+ case 1:
+ r = q * 255;
+ g = V * 255;
+ b = p * 255;
+ break;
+ case 2:
+ r = p * 255;
+ g = V * 255;
+ b = t * 255;
+ break;
+ case 3:
+ r = p * 255;
+ g = q * 255;
+ b = V * 255;
+ break;
+ case 4:
+ r = t * 255;
+ g = p * 255;
+ b = V * 255;
+ break;
+ case 5:
+ default:
+ r = V * 255;
+ g = p * 255;
+ b = q * 255;
+ break;
+ }
+}
+
+
+/***************************************************************************/
+/* Show a Screen with Text for 5 seconds */
+/* A spinner shows the delay */
+/***************************************************************************/
+
+ft_void_t Start_Screen(ft_char8_t *str)
+{
+ TFT.DLstart(); // start a new display command list
+ TFT.DL(CLEAR_COLOR_RGB(0xff, 0xff, 0xff)); // set the clear color to white
+ TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+
+ TFT.DL(COLOR_RGB(0x80, 0x80, 0x00)); // set current color
+ TFT.Text((TFT.DispWidth/2), TFT.DispHeight/2, 31, OPT_CENTERX, str); // draw Text with font 31
+ TFT.DL(COLOR_RGB(0xFF, 0x00, 0x00)); // change current color
+ TFT.Spinner((TFT.DispWidth/2), TFT.DispHeight/4, 0, 0); // draw a animated spinner
+
+ TFT.DL(DISPLAY()); // Display the image
+ TFT.Swap(); // Swap the current display list
+ TFT.Flush_Co_Buffer(); // Download the command list into fifo
+
+ TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+ TFT.Sleep(1000); // Wait 5 s to show
+}
+
+void screen_cm3000(void)
+{
+ TFT.DLstart(); // start a new display command list
+ TFT.DL(CLEAR_COLOR_RGB(0x21, 0x21, 0x21)); // set current color to white
+ TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set current color to white
+
+ // Bitmap
+ // BACKGROUND-01.png
+ TFT.DL(TAG(1)); // assign TAG
+ // Narrow On button, 100x132, Address 0-26400
+ TFT.DL(BEGIN(BITMAPS));
+ TFT.DL(BITMAP_SOURCE(TFT.GetBitmapAddress(0)));
+ TFT.DL(BITMAP_LAYOUT(ARGB4, 100*2, 132)); // <------- this distorts the colors
+ TFT.DL(BITMAP_SIZE(NEAREST, BORDER, BORDER, 100, 132));
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // all colors in bitmap at 100%
+ TFT.DL(VERTEX2II(20, 290, 0, 0));
+
+// TFT.SetRotate(0); // Standard landscape
+// TFT.SetRotate(1); // Rotate 180 to landscape (upside down)
+// TFT.SetRotate(2); // Rotate 90 CCW to portrait
+// TFT.SetRotate(3); // Rotate 90 CW to portrait
+// TFT.SetRotate(4); // Mirror over landscape X
+// TFT.SetRotate(5); // Mirror over landscape Y
+// TFT.SetRotate(6); // Rotate 90 CCW to portrait and mirror over portrait X
+// TFT.SetRotate(7); // Rotate 90 CW to portrait and mirror over portrait X
+
+ TFT.DL(DISPLAY()); // Display the image
+ TFT.Swap(); // Swap the current display list
+ TFT.Flush_Co_Buffer(); // Download the command list into fifo
+ TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+}
+
+// construct the screen and downloasd it to the LCD
+void screen_1(unsigned int color, unsigned int bright, unsigned int tagoption1, unsigned int tagoption2, unsigned int tagoption3, unsigned int tagoption4)
+{
+ TFT.DLstart(); // start a new display command list
+ TFT.DL(CLEAR_COLOR_RGB(0x21, 0x21, 0x21)); // set current color to white
+ TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set current color to white
+
+ // Default widget colors
+ TFT.SetThemeDefaultColor();
+// TFT.GradColor(COLOR_RGB(0xff, 0xff, 0xff)); // Default 0xffffff
+// TFT.FgColor(COLOR_RGB(0x00, 0x38, 0x70)); // Default 0x003870 0 56 112
+// TFT.BgColor(COLOR_RGB(0x00, 0x20, 0x40)); // Default 0x002040 0 32 64
+
+ TFT.DL(TAG(1)); // assign TAG value 1
+// TFT.FgColor(COLOR_RGB(0x00, 0x00, 0xff)); // forground color red
+// TFT.BgColor(COLOR_RGB(0x00, 0x00, 0x80));
+ TFT.Dial(249, 86, 55, 0, color); // dial for color
+
+ TFT.DL(TAG(2)); // assign TAG value 2
+// TFT.FgColor(COLOR_RGB(0x00, 0x00, 0xff)); // forground color red
+// TFT.BgColor(COLOR_RGB(0x00, 0x00, 0x80));
+ TFT.Slider(196, 215, 236, 21, 0, bright , 255); // slider for brightness
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set current color to white
+ TFT.Text(22, 84, 30, 0, "Color"); // text Color
+ TFT.Text(22, 208, 30, 0, "Brightness"); // text Brightness
+
+ // TFT.Button(ft_int16_t x, ft_int16_t y, ft_int16_t w, ft_int16_t h, ft_int16_t font, ft_uint16_t options, const ft_char8_t* s);
+ TFT.DL(TAG(3)); // This is tag value for button
+ // 0 = 3D, OPT_FLAT
+ TFT.SetThemeColor(COLOR_RGB(0xff, 0x00, 0x00));
+// TFT.GradColor(COLOR_RGB(0xff, 0xff, 0xff));
+// TFT.FgColor(COLOR_RGB(0x70, 0x00, 0x00));
+// TFT.BgColor(COLOR_RGB(0x38, 0x00, 0x00));
+ TFT.Button(500, 20, 200, 50, 31, tagoption1, "25%");
+
+ TFT.DL(TAG(4)); // This is tag value for button
+ TFT.SetThemeColor(COLOR_RGB(0x00, 0xff, 0x00));
+// TFT.GradColor(COLOR_RGB(0xff, 0xff, 0xff));
+// TFT.FgColor(COLOR_RGB(0x00, 0x70, 0x00));
+// TFT.BgColor(COLOR_RGB(0x00, 0x40, 0x00));
+ TFT.Button(500, 80, 200, 50, 31, tagoption2, "50%");
+
+ TFT.DL(TAG(5)); // This is tag value for button
+ TFT.SetThemeColor(COLOR_RGB(0x00, 0x7f, 0xff));
+// TFT.GradColor(COLOR_RGB(0xff, 0xff, 0xff));
+// TFT.FgColor(COLOR_RGB(0x00, 0x38, 0x70));
+// TFT.BgColor(COLOR_RGB(0x00, 0x20, 0x40));
+ TFT.Button(500, 140, 200, 50, 31, tagoption3, "75%");
+
+// // Default
+// TFT.SetThemeDefaultColor();
+//// TFT.GradColor(COLOR_RGB(0xff, 0xff, 0xff)); // Default 0xffffff
+//// TFT.FgColor(COLOR_RGB(0x00, 0x38, 0x70)); // Default 0x003870
+//// TFT.BgColor(COLOR_RGB(0x00, 0x20, 0x40)); // Default 0x002040
+//
+//
+ TFT.DL(POINT_SIZE(100)); // color point around the dial
+ TFT.DL(BEGIN(POINTS));
+ TFT.DL(COLOR_RGB(0x00, 0x0, 0xff)); // color of next point
+ TFT.DL(VERTEX2II(183, 47, 0, 0)); // set point x,y
+ TFT.DL(COLOR_RGB(0xff, 0x00, 0x00));
+ TFT.DL(VERTEX2II(249, 162, 0, 0));
+ TFT.DL(COLOR_RGB(0xff, 0x00, 0xff));
+ TFT.DL(VERTEX2II(183, 123, 0, 0));
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0x00));
+ TFT.DL(VERTEX2II(317, 123, 0, 0));
+ TFT.DL(COLOR_RGB(0x00, 0xff, 0xff));
+ TFT.DL(VERTEX2II(249, 11, 0, 0));
+ TFT.DL(COLOR_RGB(0x00, 0xff, 0x00));
+ TFT.DL(VERTEX2II(317, 50, 0, 0));
+ TFT.DL(SCISSOR_XY(10, 10)); // define sub area starting at 10,10
+ TFT.DL(SCISSOR_SIZE(50, 50)); // size 50, 50
+ hsv2rgb(color / 65536.0 * 360, 1.0, bright / 255.0); // calculate rgb color from settings
+ TFT.DL(CLEAR_COLOR_RGB(r, b, g)); // set filling color to r,g,b
+ TFT.DL(CLEAR(1, 1, 1)); // fill the area
+
+ // Clipping area
+ TFT.DL(SCISSOR_XY(0, 0)); // define area starting at 380,220
+ TFT.DL(SCISSOR_SIZE(480, 800)); // size 480, 800
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff));
+
+ // Rectangle
+ TFT.DL(TAG(6)); // assign TAG
+ TFT.DL(COLOR_RGB(0x80, 0x00, 0xff)); // set current color to red
+ TFT.Rect(60, 270, 260, 340, 5);
+
+ // Circle
+ TFT.DL(TAG(7)); // assign TAG
+ TFT.DL(COLOR_RGB(0x00, 0xff, 0x00)); // set current color to green
+ TFT.Point(400, 340, 60);
+
+ // Rectangle
+ TFT.DL(TAG(8)); // assign TAG
+ TFT.DL(COLOR_RGB(r, b, g)); // set current color to red
+ TFT.Rect(160, 305, 360, 440, 20);
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0x00)); // set current color to black
+ TFT.Rect(165, 310, 355, 435, 10);
+
+ // Line
+ TFT.DL(TAG(9)); // assign TAG
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0xff)); // set current color to blue
+ TFT.Line(440, 310, 680, 230 + r, 20);
+
+ // Circle
+ TFT.DL(TAG(10)); // assign TAG
+ TFT.DL(COLOR_RGB(0xff, 0x00, 0xff)); // set current color to green
+ TFT.Point(600, 340, 80);
+// TFT.DL(TAG(10)); // assign TAG
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0x00)); // set current color to green
+ TFT.Point(600, 340, 70);
+
+ // Bitmap
+ TFT.DL(TAG(11)); // assign TAG
+ // Narrow On button, 100x132, Address 0-26400
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set the clear color to white
+ TFT.DL(BEGIN(BITMAPS));
+// TFT.DL(BITMAP_SOURCE(TFT.GetBitmapAddress(1)));
+// TFT.DL(BITMAP_LAYOUT(ARGB4, 100*2, 132)); // <------- this distorts the colors
+// TFT.DL(BITMAP_SIZE(NEAREST, BORDER, BORDER, 100, 132));
+// TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // all colors in bitmap at 100%
+// TFT.DL(VERTEX2II(20, 290, 0, 0));
+
+// int index = 0;
+ if (tagoption4 == 0) {
+// index = getImageIndexFromName("SwitchOn_100x132");
+ TFT.ShowBitmapByName("SwitchOn_100x132", 20, 290);
+ }
+ else {
+// index = getImageIndexFromName("SwitchOff_100x132");
+ TFT.ShowBitmapByName("SwitchOff_100x132", 20, 290);
+ }
+// TFT.ShowBitmapAtAddress(images[index].addr, images[index].fmt, 20, 290, images[index].w, images[index].h);
+
+
+// TFT.SetRotate(0); // Standard landscape
+// TFT.SetRotate(1); // Rotate 180 to landscape (upside down)
+// TFT.SetRotate(2); // Rotate 90 CCW to portrait
+// TFT.SetRotate(3); // Rotate 90 CW to portrait
+// TFT.SetRotate(4); // Mirror over landscape X
+// TFT.SetRotate(5); // Mirror over landscape Y
+// TFT.SetRotate(6); // Rotate 90 CCW to portrait and mirror over portrait X
+// TFT.SetRotate(7); // Rotate 90 CW to portrait and mirror over portrait X
+
+ TFT.DL(DISPLAY()); // Display the image
+ TFT.Swap(); // Swap the current display list
+ TFT.Flush_Co_Buffer(); // Download the command list into fifo
+ TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+}
+
+// construct the screen and downloasd it to the LCD
+void screen_2(unsigned int r, unsigned int g, unsigned int b)
+{
+ TFT.DLstart(); // start a new display command list
+ TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+ TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set current color to white
+ TFT.DL(TAG(1)); // assign TAG value 1
+ TFT.FgColor(COLOR_RGB(0xff, 0x00, 0x00)); // forground color red
+ TFT.Slider(140, 81, 310, 14, 0, r, 255); // slider for red
+ TFT.DL(TAG(2)); // assign TAG value 2
+ TFT.FgColor(COLOR_RGB(0x00, 0xff, 0x00)); // forground color green
+ TFT.Slider(140, 133, 310, 14, 0, g, 255); // slider for green
+ TFT.DL(TAG(3)); // assign TAG value 3
+ TFT.FgColor(COLOR_RGB(0x00, 0x00, 0xff)); // forground color blue
+ TFT.Slider(139, 185, 310, 14, 0, b, 255); // slider for blue
+ TFT.DL(COLOR_RGB(0xff, 0x00, 0x00)); // set current color to red
+ TFT.Text(82, 69, 30, 0, "R"); // text R
+ TFT.DL(COLOR_RGB(0x00, 0xff, 0x00)); // set current color to green
+ TFT.Text(82, 120, 30, 0, "G"); // text G
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0xff)); // set current color to blue
+ TFT.Text(82, 174, 30, 0, "B"); // text B
+ TFT.DL(SCISSOR_XY(10, 10)); // define area starting at 10,10
+ TFT.DL(SCISSOR_SIZE(50, 50)); // size 50,50
+ TFT.DL(CLEAR_COLOR_RGB(r, g, b)); // set clear color to r,g,b
+ TFT.DL(CLEAR(1, 1, 1)); // fill the area
+
+ // Clipping area
+ TFT.DL(SCISSOR_XY(0, 220)); // define area starting at 380,220
+ TFT.DL(SCISSOR_SIZE(799, 259)); // size 50,50
+ // Rectangle
+ TFT.DL(COLOR_RGB(0xff, 0x00, 0x00)); // set current color to red
+ TFT.Rect(160, 290, 360, 440, 20);
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0x00)); // set current color to black
+ TFT.Rect(165, 295, 355, 435, 10);
+ // Circle
+ TFT.DL(COLOR_RGB(0x00, 0xff, 0x00)); // set current color to green
+ TFT.Point(400, 260, 40);
+ // Line
+ TFT.DL(COLOR_RGB(0x00, 0x00, 0xff)); // set current color to blue
+ TFT.Line(440, 270, 680, 400, 20);
+
+ TFT.DL(DISPLAY()); // Display the image
+ TFT.Swap(); // Swap the current display list
+ TFT.Flush_Co_Buffer(); // Download the command list into fifo
+ TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+}
+
+void substring(char *s, char *d, int pos, int len) //usage: substring(Src, Dst, Pos, Len);
+{
+//usage: substring(Source, Destination, pos, len);
+ char *t;
+
+ s=s+pos;
+ t=s+len;
+ while (s!=t) {
+ *d=*s;
+ s++;
+ d++;
+ }
+ *d='\0';
+}
+
+int main() {
+ pc.baud(BAUD_RATE);
+ printf("\n\n\n");
+ printf("----------------------------------\n");
+ printf("20180621_FT800_RGB_demo2\n");
+ printf("" __DATE__ " " __TIME__ "\n");
+#if defined(MBED_MAJOR_VERSION)
+ printf("Using \033[1;37mMbed OS %d.%d.%d\033[0m\n", MBED_MAJOR_VERSION, MBED_MINOR_VERSION, MBED_PATCH_VERSION);
+#else
+ printf("Using Mbed OS from master.\n");
+#endif
+ printf("CPU SystemCoreClock: \033[1;37m%d MHz\033[0m\n", SystemCoreClock/1000000);
+ printf("----------------------------------\n");
+
+ // https://www.unixtimestamp.com/
+ set_time(1531525845); // Set RTC time to Wed, 28 Oct 2009 11:35:37
+
+ uint8_t second = 0;
+ uint8_t minute = 0;
+ uint8_t hour = 0;
+ uint8_t dayOfWeek = 1; // Will be determined
+ uint8_t dayOfMonth = 16;
+ uint8_t month = 7;
+ uint8_t year = 18;
+ printf("%02d-%02d-%02d %02d:%02d:%02d\n", dayOfMonth, month, year, hour, minute, second);
+
+// struct tm *t;
+// *t = rtc.setSystemDateTime(second, minute, hour, dayOfMonth, month, year);
+// printf("-> Debug %d %02d-%02d-%03d %02d:%02d:%02d\n", t->tm_wday, t->tm_mday, t->tm_mon, t->tm_year, t->tm_hour, t->tm_min, t->tm_sec);
+
+ struct tm t;
+ t = rtc.setSystemDateTime(second, minute, hour, dayOfMonth, month, year);
+ printf("-> Debug %d %02d-%02d-%03d %02d:%02d:%02d\n", t.tm_wday, t.tm_mday, t.tm_mon, t.tm_year, t.tm_hour, t.tm_min, t.tm_sec);
+
+ time_t secondsEpoch = time(NULL);
+
+ printf("Time as seconds since January 1, 1970 = %d\n", secondsEpoch);
+
+ printf("Time as a basic string = %s", ctime(&secondsEpoch));
+
+ char buffer[32];
+ strftime(buffer, 32, "%a %d-%m-%Y %H:%M:%S\n", localtime(&secondsEpoch));
+ printf("Time: %s", buffer);
+// wait(5);
+ secondsEpoch = time(NULL);
+ strftime(buffer, 32, "%a %d-%m-%Y %H:%M:%S\n", localtime(&secondsEpoch));
+ printf("Time: %s", buffer);
+
+ printf("year %d\n", year);
+ time_t seconds2 = rtc.convertDateTimeToTimestamp(second, minute, hour, dayOfMonth, month, year);
+ printf("seconds2 %d\n", seconds2);
+
+ uint8_t Weekday = rtc.getWeekdayFromDate(dayOfMonth, month, year);
+ printf("Weekday %d\n", Weekday);
+
+ rtc.setRtcFromTm(&t);
+
+// uint8_t second = 0;
+// uint8_t minute = 18;
+// uint8_t hour = 1;
+// uint8_t dayOfWeek = 6;
+// uint8_t dayOfMonth = 14;
+// uint8_t month = 7;
+// uint8_t year = 18;
+// printf("%02d-%02d-%02d %02d:%02d:%02d\n", dayOfMonth, month, year, hour, minute, second);
+// rtc.setSystemDateTime(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
+// wait(5);
+ rtc.getSystemDateTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
+ printf("%d %02d-%02d-%02d %02d:%02d:%02d\n", dayOfWeek, dayOfMonth, month, year, hour, minute, second);
+// wait(5);
+ rtc.getSystemDateTime(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
+ printf("%d %02d-%02d-%02d %02d:%02d:%02d\n", dayOfWeek, dayOfMonth, month, year, hour, minute, second);
+
+
+// https://os.mbed.com/questions/77039/Use-external-clock-signal-HSE-in-Nucleo-/
+
+
+
+ switch (__HAL_RCC_GET_SYSCLK_SOURCE())
+ {
+// case RCC_SYSCLKSOURCE_STATUS_MSI:
+// printf("MSI used as system clock.\r\n");
+// break;
+ case RCC_SYSCLKSOURCE_STATUS_HSI:
+ printf("HSI used as system clock.\r\n");
+ break;
+ case RCC_SYSCLKSOURCE_STATUS_HSE:
+ printf("HSE used as system clock.\r\n");
+ break;
+ case RCC_SYSCLKSOURCE_STATUS_PLLCLK:
+ printf("PLL used as system clock.\r\n");
+// if ((RCC->CFGR & RCC_CFGR_PLLSRC) == RCC_CFGR_PLLSRC_HSE) {
+// printf("HSE oscillator clock selected as PLL input clock.\r\n");
+// }
+// else {
+// printf("HSI16 oscillator clock selected as PLL input clock.\r\n");
+// }
+ break;
+ }
+
+ printf("HCE Information: \r\n");
+
+ if (READ_BIT(RCC->CR, RCC_CR_HSEON)){
+ printf("RCC_CR_HSEON = 1 \r\n");
+ }
+ else{
+ printf("RCC_CR_HSEON = 0 \r\n");
+ }
+
+ if (READ_BIT(RCC->CR, RCC_CR_HSEBYP)){
+ printf("RCC_CR_HSEBYP = 1 \r\n");
+ }
+ else{
+ printf("RCC_CR_HSEBYP = 0 \r\n");
+ }
+
+ if (__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) != RESET) {
+ printf("RCC_FLAG_HSERDY = 1 \r\n");
+ }
+ else {
+ printf("RCC_FLAG_HSERDY = 0 \r\n");
+ }
+
+
+ printf("\n");
+// I2C_List.List();
+
+// printf("Searching for I2C devices...\n");
+// int count = 0;
+// for (int address=0; address<256; address+=2) {
+// if (!i2c.write(address, NULL, 0)) { // 0 returned is ok
+// count++;
+// printf("%2d: 0x%02X\n", count, address);
+// }
+// }
+// printf("%d I2C devices found\n", count);
+
+ wdt.Configure(WDT_TIMEOUT);
+
+ timer.start();
+ double my_time = timer.read();
+
+ int error = 0;
+ printf("Welcome to the FAT32 filesystem example.\n");
+
+// printf("Formatting a FAT, SD-Card filesystem... "); // "Formatting a FAT, RAM-backed filesystem... "
+// fflush(stdout);
+// error = FATFileSystem::format(&sd);
+// return_error(error);
+
+ printf("Mounting the filesystem on \"/fs\"... ");
+ fflush(stdout);
+ // Initialize the SD card device and print the memory layout
+ sd.init();
+ error = fs.mount(&sd);
+ return_error(error);
+ printf("sd size: %llu Bytes.\n", sd.size());
+// printf("sd read size: %llu\n", sd.get_read_size());
+// printf("sd program size: %llu\n", sd.get_program_size());
+// printf("sd erase size: %llu\n", sd.get_erase_size());
+
+// // Initialize the SPI flash device and print the memory layout
+// spif.init();
+// printf("spif size: %llu\n", spif.size());
+// printf("spif read size: %llu\n", spif.get_read_size());
+// printf("spif program size: %llu\n", spif.get_program_size());
+// printf("spif erase size: %llu\n", spif.get_erase_size());
+
+// printf("Mounting the filesystem on \"/eefs\"... ");
+ fflush(stdout);
+
+// // Initialize the EEPROM and print the memory layout
+// ee.init();
+//// error = eefs.mount(&i2cee);
+//// return_error(error);
+// printf("ee size: %llu Bytes.\n", ee.size());
+// printf("ee read size: %llu\n", ee.get_read_size());
+// printf("ee program size: %llu\n", ee.get_program_size());
+// printf("ee erase size: %llu\n", ee.get_erase_size());
+
+// printf("Send 1000 SPI packets as fast as possible...\n");
+// uint8_t data[1000];
+// for (int i = 0; i<1000; i++)
+// data[i] = (uint8_t) (i & 0xff);
+// //Send 1000 SPI packets as fast as possible
+// bspi.setFormat();
+// timer.reset();
+// for (int i = 0; i<1000; i++)
+// bspi.fastWrite(data[i]);
+// my_time = timer.read();
+// bspi.clearRX();
+// printf("Time: %f.\n", my_time);
+//
+// rspi.format(8, 0); // 8 bit spi mode 0
+// rspi.frequency(54000000);
+// timer.reset();
+// for (int i = 0; i<1000; i++)
+// rspi.write(data[i]);
+// my_time = timer.read();
+// printf("Time: %f.\n", my_time);
+
+// printf("----------\n");
+// printf("EEPROM string...\n");
+// timer.reset();
+// // --- Save a string into EEPROM and read it back ---
+// uint8_t block_size = 32;
+// ee.erase(0, block_size);
+// // Write "Hello World!" to the first block
+// char hello[] = "Hello World!";
+// printf("Save \"%s\"\n", hello);
+// char *buffer = (char*)malloc(block_size);
+// sprintf(buffer, "%s", hello);
+// // Program EEPROM
+// ee.program(buffer, 0, block_size);
+// sprintf(buffer, "empty\n"); // empty buffer, not nessesary but helps when debugging
+// // Read back what was stored
+// ee.read(buffer, 0, block_size);
+// printf("Read \"%s\"\n", buffer);
+// my_time = timer.read();
+// printf("Time: %f.\n", my_time);
+//
+//
+// printf("----------\n");
+// printf("EEPROM struct...\n");
+// timer.reset();
+// // --- Save a structure into EEPROM and read it back ---
+// // No. of bytes to be stored, but topped up to be multiplied by block size
+// unsigned int setting_block_size = ceil(sizeof(setting)/(double)EE_BLOCK_SIZE)*EE_BLOCK_SIZE;
+// printf("No. of bytes to be stored: %d\n", setting_block_size);
+// // Temporary buffer
+// char *buffer2 = (char*)malloc(setting_block_size);
+// // Save the struct to EEPROM
+// setting.version = 56;
+// printf("Save struct version: %u, name: %s, value: %3.10lf\n", setting.version, setting.name, setting.value);
+// memcpy(buffer2, &setting, sizeof(setting));
+// // Program EEPROM
+// ee.program(buffer2, 0, setting_block_size);
+// // Read back what was stored
+// t_setting tmp; // Re-make the struct
+// memset(buffer2, 0, sizeof(buffer2)); // empty buffer, not nessesary but helps when debugging
+// // Read the struct from the EEPROM
+// if (ee.read(buffer2, 0, setting_block_size ) == 0) { // get data into buffer
+// // Convert what we read into struct
+// memcpy(&tmp, buffer2, sizeof(tmp)); // copy only size of struct not setting_block_size
+// printf("Read struct version: %u, name: %s, value: %3.10lf\n", tmp.version, tmp.name, tmp.value);
+// } else {
+// printf("Error when reading\n");
+// }
+// my_time = timer.read();
+// printf("Time: %f.\n", my_time);
+
+//
+// char filename[] = "/fs/my_text_file.txt";
+//
+// printf("Opening a new file, \"/%s\"...", filename);
+// fflush(stdout);
+// FILE* fd = fopen(filename, "w");
+// errno_error(fd);
+//
+// printf("Writing text to a file:\n");
+// char text[] = "Hello world!\nThis is just some text...\n";
+// printf("\033[1;37m%s\033[0m", text);
+// fprintf(fd, "%s", text);
+//
+//// for (int i = 0; i < 10; i++) {
+//// printf("%d/20\n", i);
+//// fprintf(fd, "%d\n", i);
+//// }
+//// printf("Writing decimal numbers to a file (10/10) done.\n");
+// printf("Writing text to a file done.\n");
+//
+// printf("Closing file...");
+//// fflush(stdout);
+// fclose(fd);
+// printf(" done.\r\n");
+//
+// printf("Re-opening file read-only...");
+//// fflush(stdout);
+// fd = fopen(filename, "r");
+// errno_error(fd);
+//
+// printf("Dumping file to screen:\n");
+// printf("\033[1;37m");
+// char buff[16] = {0};
+// while (!feof(fd)) {
+// int size = fread(&buff[0], 1, 15, fd);
+// fwrite(&buff[0], 1, size, stdout);
+// }
+// printf("\033[0m");
+// printf("Closing file...");
+//// fflush(stdout);
+// fclose(fd);
+// printf(" done.\r\n");
+//
+// printf("Opening root directory...");
+// fflush(stdout);
+// DIR* dir = opendir("/fs/");
+// errno_error(fd);
+//
+// struct dirent* de;
+// printf("Printing all filenames:\n");
+// printf("\033[1;37m");
+// while((de = readdir(dir)) != NULL) {
+// printf(" %s\r\n", &(de->d_name)[0]);
+// }
+// printf("\033[0m");
+//
+// printf("Closing root directory... ");
+// fflush(stdout);
+// error = closedir(dir);
+// return_error(error);
+// printf("Filesystem Demo complete.\n");
+
+
+// printf("Start FRAM Demo.\n");
+// char wdata[] = "Hello world!";
+// char rdata[14];
+// fram.write(0, wdata, 13); // 12 symbols + zero terminator
+// fram.read(0, rdata, 13);
+// pc.printf("data: %s", rdata);
+// printf("Done.\n");
+
+
+// Set screen rotation
+// TFT.SetRotate(2); // Rotate 90 CCW to portrait
+// TFT.SetRotate(3); // Rotate 90 CW to portrait
+
+// TFT.SetOrientation(FT8_DISPLAY_LANDSCAPE_0);
+ TFT.SetOrientation(FT8_DISPLAY_PORTRAIT_90CW); // CM3000
+// TFT.SetOrientation(FT8_DISPLAY_PORTRAIT_90CCW); // CM3000
+
+// ap3000.SetBacklight((uint16_t)255);
+
+// TFT.Calibrate(); // calibrate the touch screen
+// // Read calibrate registers
+// printf("// Calibration values:\n");
+// printf(" ft_uint32_t canned_calibration_data[] = {\n");
+// for(int i = 0; i < 24; i+=4) {
+// printf(" ");
+// printf("0x%08x", TFT.read_calibrate_reg32(i));
+// if (i < 20)
+// printf(",");
+// printf("\n");
+// }
+// printf(" };\n");
+// printf(" TFT.write_calibrate32(canned_calibration_data);\n");
+
+ // Default
+// ft_uint32_t canned_calibration_data[] = {
+// 0x00000000,
+// 0x00010000,
+// 0x00000000,
+// 0xffff0000,
+// 0x00000000,
+// 0x031f0000
+// };
+// TFT.write_calibrate32(canned_calibration_data);
+
+
+ // Landscape 0
+// ft_uint32_t canned_calibration_data[] = {
+// 0x000109b0, // 68016
+// 0x0000023d, // 573
+// 0x0000fa64, // 64100
+// 0xffffffcf, // -49
+// 0xfffefc9a, // -66406
+// 0x01ee8754 // 32409428
+// };
+// TFT.write_calibrate32(canned_calibration_data);
+
+ // Calibration rotate 90 CCW to portrait
+// ft_uint32_t canned_calibration_data[] = {
+// 0x00000491,
+// 0x0000fd0b,
+// 0xfff6f84b,
+// 0x00010503,
+// 0x000006b7,
+// 0xffeeb0b7
+// };
+// TFT.write_calibrate32(canned_calibration_data);
+
+// // Calibration rotate 90 CW to portrait
+// ft_uint32_t canned_calibration_data[] = {
+// 0xfffff994,
+// 0xffff07d3,
+// 0x01e4b85c,
+// 0xfffef6f5,
+// 0x000002ad,
+// 0x032eb4d4
+// };
+// TFT.write_calibrate32(canned_calibration_data);
+
+// // Read calibrate registers
+// printf("// Calibration values:\n");
+// printf(" ft_uint32_t canned_calibration_data[] = {\n");
+// for(int i = 0; i < 24; i+=4) {
+// printf(" ");
+// printf("0x%08x", TFT.read_calibrate_reg32(i));
+// if (i < 20)
+// printf(",");
+// printf("\n");
+// }
+// printf(" };\n");
+// printf(" TFT.write_calibrate32(canned_calibration_data);\n");
+
+
+
+
+
+
+//
+// TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+// TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set the clear color to white
+// TFT.DL(SAVE_CONTEXT());
+
+// TFT.DL(BEGIN(BITMAPS));
+//
+// TFT.DL(BLEND_FUNC(ONE,ZERO));
+// TFT.DL(COLOR_A(0x55));
+// TFT.DL(VERTEX2II(0, 0, 0, 0));
+// TFT.DL(BLEND_FUNC(ONE,ONE));
+// TFT.DL(COLOR_A(0xAA));
+// TFT.DL(VERTEX2II(0, 0, 0, 1));
+// TFT.DL(COLOR_MASK(1,1,1,0));
+// TFT.Scale(4*65536,4*65536);
+// TFT.SetMatrix();
+// TFT.DL(BLEND_FUNC(DST_ALPHA,ZERO));
+// TFT.DL(VERTEX2II(0, 0, 2, 1));
+// TFT.DL(BLEND_FUNC(ONE_MINUS_DST_ALPHA,ONE));
+// TFT.DL(VERTEX2II(0, 0, 2, 0));
+//
+// TFT.DL(RESTORE_CONTEXT());
+
+
+// // NMEA0183 Test
+
+ int status = nmea0183.CheckParity("$PVMAL,A,R1,F3A8,C000,0030*34");
+ printf("nmea0183.CheckParity %d\n", status);
+
+
+//image images2[] = {
+// {"/fs/BACKGROUND_01_C_20x20_BL.bin", L8, 20, 20},
+// {"/fs/BACKGROUND_01_C_20x20_BR.bin", L8, 20, 20},
+// {"/fs/BACKGROUND_01_C_20x20_TL.bin", L8, 20, 20},
+// {"/fs/BACKGROUND_01_C_20x20_TR.bin", L8, 20, 20},
+//
+// {"/fs/BACKGROUND_01_H_5x4.bin", L8, 5, 4},
+// {"/fs/BACKGROUND_01_H_10x4.bin", L8, 10, 4},
+// {"/fs/BACKGROUND_01_H_25x4.bin", L8, 25, 4},
+// {"/fs/BACKGROUND_01_H_190x4.bin", L8, 190, 4},
+// {"/fs/BACKGROUND_01_V_4x535.bin", L8, 4, 535},
+// {"/fs/BACKGROUND_01_V_4x21.bin", L8, 4, 21},
+//
+// {"/fs/RegularButtonRed_220x51r.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonBlk_220x51r4t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonGray_220x51r0r10t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonRed_220x51r0r10t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonYel_220x51r0r10t.bin", ARGB4, 220, 51},
+//
+// {"/fs/RegulaButtonrBlk_220x51r0t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonGray_220x51r0t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonRed_220x51r0t.bin", ARGB4, 220, 51},
+// {"/fs/RegularButtonYel_220x51r0t.bin", ARGB4, 220, 51},
+//
+// {"/fs/SwitchOn_234x132_blk.bin", L8, 234, 132},
+// {"/fs/SwitchOff_234x132_blk.bin", L8, 234, 132},
+// {"/fs/SwitchOn_100x132_blk.bin", L8, 100, 132},
+// {"/fs/SwitchOff_100x132_blk.bin", L8, 234, 132},
+// {"/fs/SwitchOn_115x66_t.bin", L8, 115, 66},
+// {"/fs/SwitchOff_115x66_t.bin", L8, 115, 66},
+//
+// {"/fs/MD_DISABLED_230x70.bin", ARGB4, 230, 70},
+// {"/fs/MD_OFF_230x70.bin", ARGB4, 230, 70},
+// {"/fs/MD_OFF_GREY_230x70.bin", ARGB4, 230, 70},
+// {"/fs/MD_RUNNING_230x70.bin", ARGB4, 230, 70},
+// {"/fs/MD_WARNING_230x70.bin", ARGB4, 230, 70},
+//
+// {"/fs/RUN_TIME_C_ON_21_X_21.bin", ARGB4, 21, 21},
+// {"/fs/RUN_TIME_C_OFF_21_X_21.bin", ARGB4, 21, 21},
+// {"/fs/RUN_TIME_L_ON_21_X_21.bin", ARGB4, 21, 21},
+// {"/fs/RUN_TIME_L_OFF_21_X_21.bin", ARGB4, 21, 21},
+// {"/fs/RUN_TIME_R_ON_21_X_21.bin", ARGB4, 21, 21},
+// {"/fs/RUN_TIME_R_OFF_21_X_21.bin", ARGB4, 21, 21}
+//};
+// uint16_t entries = sizeof(images2) / sizeof(images2[0]);
+// printf("--- images2[] %d\n", entries);
+// for (int i = 0; i < entries; i++) {
+// printf("%3d - %s, %d, %d, %d\n", i, images2[i].name, images2[i].fmt, images2[i].w, images2[i].h);
+// }
+
+// TFT.SetLoadAddress(0);
+// TFT.SetBitmapCount(0);
+
+
+
+
+
+
+
+
+
+ // ---------------------------------------- Load and show bitmaps ----------------------------------------
+
+
+ // Splash Screen
+// printf("--------------\n");
+// printf("loadSplashScreen...\n");
+// timer.reset();
+// loadSplashScreen();
+// my_time = timer.read();
+// printf("Time: %f Sec.\n", my_time);
+
+ printf("--------------\n");
+ printf("showSplashScreen...\n");
+ timer.reset();
+ showSplashScreen();
+ my_time = timer.read();
+ printf("Time: %f Sec.\n", my_time);
+
+// wait(3);
+
+ printf("--------------\n");
+ printf("loadBitmaps...\n");
+ timer.reset();
+
+ loadBitmaps();
+
+ my_time = timer.read();
+ printf("Time: %f Sec.\n", my_time);
+
+ uint32_t RamUsage = TFT.GetRamUsage();
+ uint16_t GetRamNoOfBitmaps = TFT.GetRamNoOfBitmaps();
+ printf("RAM usage: %d Bytes.\n", RamUsage);
+ printf("RAM no of bitmaps: %d.\n", GetRamNoOfBitmaps);
+
+ printf("--------------\n");
+ printf("showMainPage...\n");
+ timer.reset();
+
+ InitAP3000();
+
+// button my_button;
+// my_button.accept_alarm_pressed = 0;
+// my_button.accept_horn_pressed = 0;
+// my_button.set_pressed = 0;
+// my_button.dim_pressed = 0;
+//
+// indicator my_indicator;
+// my_indicator.rb_used = 1;
+// my_indicator.rb_main_most_used = 1;
+// my_indicator.rb_aux_most_used = 0;
+//
+// // INDICATOR_RUN_STATUS_OFF
+// // INDICATOR_RUN_STATUS_RUNNING
+// // INDICATOR_RUN_STATUS_WARNING
+// // INDICATOR_RUN_STATUS_OFF_RED
+// my_indicator.md_main_running = INDICATOR_RUN_STATUS_RUNNING;
+// my_indicator.md_aux_running = INDICATOR_RUN_STATUS_WARNING;
+//
+// // INDICATOR_ALARM_STATUS_OFF
+// // INDICATOR_ALARM_STATUS_WARNING
+// // INDICATOR_ALARM_STATUS_FAILURE
+// my_indicator.rb_main_phase_fail = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_main_main_power = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_main_ctrl_power = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_main_oil_press = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_main_hydr_lock = INDICATOR_ALARM_STATUS_OFF;
+// my_indicator.rb_main_overload = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_main_oil_level = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_main_oil_filter = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_main_oil_temp = INDICATOR_ALARM_STATUS_WARNING;
+//
+// my_indicator.rb_aux_phase_fail = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_aux_main_power = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_aux_ctrl_power = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_aux_oil_press = INDICATOR_ALARM_STATUS_FAILURE;
+// my_indicator.rb_aux_hydr_lock = INDICATOR_ALARM_STATUS_OFF;
+// my_indicator.rb_aux_overload = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_aux_oil_level = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_aux_oil_filter = INDICATOR_ALARM_STATUS_WARNING;
+// my_indicator.rb_aux_oil_temp = INDICATOR_ALARM_STATUS_WARNING;
+//
+// my_indicator.rb_fu_failure = INDICATOR_ALARM_STATUS_FAILURE;
+
+ showMainPage();
+// wait(1);
+
+// wait(1);
+
+ my_time = timer.read();
+ printf("Time: %f Sec.\n", my_time);
+
+ TFT.Track( 3, 623, 234, 132, BUTTON_ACCEPT_ALARM_TAG);
+ TFT.Track(243, 623, 234, 132, BUTTON_ACCEPT_HORN_TAG);
+ TFT.Track( 5, 553, 115, 66, BUTTON_SET_TAG);
+ TFT.Track(360, 553, 115, 66, BUTTON_DIM_TAG);
+ TFT.Track( 10, 360, 220, 51, 100);
+ TFT.Track(250, 360, 220, 51, 101);
+
+ Timer touchTimer;
+ touchTimer.reset();
+ touchTimer.start();
+
+// setPumpRunningBlinkStatus(MAIN_SYSTEM, STEADY_RUNNING_ON);
+// setPumpRunningBlinkStatus(AUX_SYSTEM, BLINK_WARNING_ON);
+//
+// setAlarmBlinkStatus(MAIN_SYSTEM, OIL_PRESS, BLINK_FAILURE_ON);
+// setAlarmBlinkStatus(AUX_SYSTEM, HYDR_LOCK, BLINK_WARNING_ON);
+// setAlarmBlinkStatus(GLOBAL_SYSTEM, FU_FAILURE, BLINK_FAILURE_ON);
+
+ Timer minutes;
+ minutes.reset();
+ minutes.start();
+ uint32_t noOfMinutes = 0;
+
+ uint32_t secondCount = 0;
+ Timer seconds;
+ seconds.reset();
+ seconds.start();
+ Timer timerWdt;
+ timerWdt.reset();
+ timerWdt.start();
+ uint16_t tagvalOld = TAGVAL_NONE;
+ while(1) {
+ // Watch Dog Timer
+ if (timerWdt.read() >= 1.0f) {
+ timerWdt.reset();
+ wdt.Service();
+ TFT.SetTouchConfig(VAL_TOUCH_CONFIG);
+ }
+
+ // Print time (check stability)
+ if (minutes.read() >= 60.0f) {
+ minutes.reset();
+ noOfMinutes++;
+ secondsEpoch = time(NULL);
+ strftime(buffer, 32, "%a %d-%m-%Y %H:%M\n", localtime(&secondsEpoch));
+ printf("Time: %s", buffer);
+ }
+
+// uint16_t tagval = TFT.GetTouchedTag();
+ uint16_t tagval = TFT.GetTouchTag();
+
+ if(tagval != 0) { // touch -> get new values
+ uint16_t tagX = TFT.GetTouchTagX();
+ uint16_t tagY = TFT.GetTouchTagY();
+ uint16_t TouchConfig = TFT.GetTouchConfig();
+// printf("GetTouchTagXY %d %d\n", tagX, tagY);
+// uint16_t tagval1 = TFT.GetTouchedTag(1);
+ printf("GetTouchTagXY %d %d %04x\n", tagX, tagY, TouchConfig);
+ // The touch screen is touched, the tag value (touch-id) greater than 0
+ // However, we can ocasionally get random (invalid) touch id's
+ // Therfore we validate the touch duration times
+ // Valid touch events take about 0.15 Sec.
+ // Invalid touch events take very short, not longer than about 0.025 Sec.
+ // Now, we can also detect long press
+ my_time = touchTimer.read();
+// printf("d: %f\n", time);
+ if ((tagval != tagvalOld) && (my_time >= 0.035)) {
+ // Execute below only once, if the touched tag (touch-id) changed
+ printf("t %d\n", tagval);
+ processButtonPressed(tagval);
+ touchTimer.reset();
+ showMainPage();
+ tagvalOld = tagval;
+ wait(0.01);
+ }
+ }
+ else
+ {
+ // The touch screen is released, the tag value (touch-id) is 0
+ if (tagvalOld != TAGVAL_NONE) {
+ my_time = touchTimer.read();
+ printf("r: %f\n", my_time);
+ processButtonReleased();
+ showMainPage();
+ tagvalOld = TAGVAL_NONE;
+ wait(0.01);
+ }
+ }
+ updateAlarmLights();
+
+ // Create alarms at time intervals to test it
+ if (seconds.read() >= 1.0f) {
+ seconds.reset();
+ secondCount++;
+
+ if (secondCount == 2) {
+ setPumpRunningBlinkStatus(MAIN_SYSTEM, STEADY_RUNNING_ON);
+ }
+ if (secondCount == 4) {
+ setAlarmBlinkStatus(MAIN_SYSTEM, OIL_PRESS, BLINK_FAILURE_ON);
+ }
+ if (secondCount == 6) {
+ setAlarmBlinkStatus(AUX_SYSTEM, HYDR_LOCK, BLINK_WARNING_ON);
+ }
+ if (secondCount == 8) {
+ setAlarmBlinkStatus(GLOBAL_SYSTEM, FU_FAILURE, BLINK_FAILURE_ON);
+ }
+ if (secondCount == 10) {
+ setPumpRunningBlinkStatus(AUX_SYSTEM, STEADY_WARNING_ON);
+ }
+ if (secondCount == 12) {
+ setAlarmBlinkStatus(MAIN_SYSTEM, OIL_PRESS, STEADY_FAILURE_ON);
+ }
+ if (secondCount == 14) {
+ setAlarmBlinkStatus(AUX_SYSTEM, HYDR_LOCK, STEADY_WARNING_ON);
+ }
+ if (secondCount == 16) {
+ setAlarmBlinkStatus(GLOBAL_SYSTEM, FU_FAILURE, STEADY_FAILURE_ON);
+ }
+ if (secondCount == 18) {
+ setPumpInUse(PUMP_IN_USE_MAIN);
+ }
+ if (secondCount == 20) {
+ setAlarmBlinkStatus(GLOBAL_SYSTEM, FU_FAILURE, BLINK_FAILURE_ON);
+ }
+ }
+ wait(0.01);
+ }
+
+// wait (500);
+//}
+
+
+
+
+
+
+// printf("----------\n");
+// for (int i = 0; i < 4; i++)
+// {
+// printf("Show Bitmap from memory...\n");
+// timer.reset();
+// TFT.DLstart(); // start a new display command list
+//
+// TFT.DL(CLEAR_COLOR_RGB(0x21, 0x21, 0x21)); // set the clear color to white
+// TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+// TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set the clear color to white
+//
+//// TFT.DL(SAVE_CONTEXT());
+//// TFT.DL(BITMAP_HANDLE(0));
+//
+//// TFT.Png("/fs/BACKGROUND-01.png", 0, 0);
+//
+// // TFT.LoadIdentity();
+// TFT.DL(BEGIN(BITMAPS));
+//
+//
+// // Narrow On button, 100x132, Address 0-26400
+// TFT.ShowBitmap(1, ARGB4, 125, 20, 100, 132); // bitmap, x, y, w, h
+// // Narrow Off button, 100x132, Address 26400-52800
+// TFT.ShowBitmap(2, ARGB4, 20, 20, 100, 132); // bitmap, x, y, w, h
+// // Wide On button, 182x132, Address 52800-100848
+// TFT.ShowBitmap(3, ARGB4, 416, 20, 182, 132); // bitmap, x, y, w, h
+// // Wide Off button, 182x132, Address 100848-148896
+// TFT.ShowBitmap(4, ARGB4, 230, 20, 182, 132); // bitmap, x, y, w, h
+//
+//// TFT.DL(END());
+// TFT.DL(DISPLAY()); // Display the image (erases the other images!)
+// TFT.Swap(); // Swap the current display list
+// TFT.Flush_Co_Buffer(); // Download the command list into fifo
+// TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+// time = timer.read();
+// printf("Time: %f.\n", time);
+// wait(0.5);
+//
+//
+//
+// printf("Show Bitmap from memory...\n");
+// timer.reset();
+// TFT.DLstart(); // start a new display command list
+//
+// TFT.DL(CLEAR_COLOR_RGB(0x21, 0x21, 0x21)); // set the clear color to white
+// TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+// TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set the clear color to white
+//
+// TFT.DL(SAVE_CONTEXT());
+// TFT.DL(BITMAP_HANDLE(0));
+//
+// // TFT.LoadIdentity();
+// TFT.DL(BEGIN(BITMAPS));
+//
+// // Narrow On button, 100x132, Address 0-26400
+// TFT.ShowBitmap(1, ARGB4, 20, 20, 100, 132); // bitmap, x, y, w, h
+// // Narrow Off button, 100x132, Address 26400-52800
+// TFT.ShowBitmap(2, ARGB4, 125, 20, 100, 132); // bitmap, x, y, w, h
+// // Wide On button, 182x132, Address 52800-100848
+// TFT.ShowBitmap(3, ARGB4, 230, 20, 182, 132); // bitmap, x, y, w, h
+// // Wide Off button, 182x132, Address 100848-148896
+// TFT.ShowBitmap(4, ARGB4, 416, 20, 182, 132); // bitmap, x, y, w, h
+//
+//// TFT.DL(END());
+// TFT.DL(DISPLAY()); // Display the image (erases the other images!)
+// TFT.Swap(); // Swap the current display list
+// TFT.Flush_Co_Buffer(); // Download the command list into fifo
+// TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+// time = timer.read();
+// printf("Time: %f.\n", time);
+// wait(0.5);
+// }
+
+
+
+// printf("----------\n");
+// printf("Erase screen\n");
+// TFT.DLstart(); // start a new display command list
+// TFT.DL(CLEAR_COLOR_RGB(0x00, 0x00, 0x00)); // set the clear color to black
+// TFT.DL(CLEAR(1, 1, 1)); // clear buffers -> color buffer,stencil buffer, tag buffer
+// TFT.DL(COLOR_RGB(0xff, 0xff, 0xff)); // set the color to white
+// TFT.DL(DISPLAY()); // Display the image
+// TFT.Swap(); // Swap the current display list
+// TFT.Flush_Co_Buffer(); // Download the command list into fifo
+// TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+
+// printf("----------\n");
+// printf("JpgSplash...\n");
+// timer.reset();
+// TFT.JpgSplash("/fs/Damen-shipyards-logo_760x157.jpg", 0xff, 0xff, 0xff);
+// time = timer.read();
+// printf("Time: %f.\n", time);
+// wait(1);
+
+// printf("RGB DEMO START\n");
+// Start_Screen("RGB DEMO START"); // Show start screen
+// TFT.Calibrate(); // calibrate the touch screen
+// /* Set the tracker for the 3 sliders - define the Area for touching */
+// TFT.Track(131, 63, 330, 48, 1); // slider r
+// TFT.Track(131, 116, 330, 48, 2); // slider g
+// TFT.Track(131, 168, 330, 48, 3); // slider b
+// TFT.Flush_Co_Buffer(); // Download the commands into fifo
+// TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+// screen_2(r,g,b); // paint screen
+// /* the demo is updating the screen in a endless loop */
+// while(1) {
+// ft_uint8_t tagval = 0;
+// TrackRegisterVal = TFT.Rd32(REG_TRACKER); // check if one of the tree Slider is touched
+// tagval = TrackRegisterVal & 0xff;
+// if(0 != tagval) { // touch -> get new rgb value
+// if(1 == tagval) { // the red slider is touched
+// r = TrackRegisterVal>>16; // get the new value
+// r = r *255/65536; // scale it down to 255
+// } else if(2 == tagval) { // the green slider is touched
+// g = TrackRegisterVal>>16; // get new slider value
+// g = g * 255/65536; // scale it down to 255
+// } else if(3 == tagval) { // the blue slider is touched
+// b = TrackRegisterVal>>16; // get new slider value
+// b = b * 255/65536; // scale it down to 255
+// }
+// screen_2(r, g, b); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// } // end of display loop
+
+
+
+// unsigned int color = 0;
+// unsigned int bright = 255;
+//// ft_uint32_t TrackRegisterVal = 0; // touch track
+// uint16_t TrackRegisterVal = 0; // touch track
+//
+//// printf("RGB DEMO2 START\n");
+//// Start_Screen("RGB DEMO2 START"); // Show start screen
+//
+//
+// /* Set the tracker for the dial - define the Area for touching */
+// printf("Set the tracker for the dial - define the Area for touching\n");
+//
+//
+// TFT.DL(TAG(2)); // assign TAG value 2
+// //TFT.FgColor(COLOR_RGB(0x00 ,0xff, 0x00)); // forground color green
+//
+// // TFT.Dial(249, 86, 55, 0, color); // dial for color
+// TFT.Track(249, 86, 1, 1, 1); // Dial - dimension 1,1 means rotary
+// // TFT.Slider(196, 215, 236, 21, 0, bright , 255); // slider for brightness
+// TFT.Track(179, 199, 277, 48, 2); // Slider
+// // TFT.Button(500, 63, 200, 50, 31, 0, "Test 1");
+// TFT.Track(500, 20, 200, 50, 3); // Button
+// TFT.Track(500, 80, 200, 50, 4); // Button
+// TFT.Track(500, 140, 200, 50, 5); // Button
+// TFT.Track(20, 290, 100, 132, 11); // Bitmap
+//
+// TFT.Flush_Co_Buffer(); // Download the commands into fifo
+// TFT.WaitCmdfifo_empty(); // Wait till coprocessor completes the operation
+// int tagoption1 = 0;
+// int tagoption2 = 0;
+// int tagoption3 = 0;
+// int tagoption4 = 0;
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint screen
+// /* the demo is updating the screen in a endless loop */
+//
+// Timer t1;
+// t1.start();
+// t1.reset();
+//
+// tagoption1 = 0;
+// tagoption2 = 0;
+// tagoption3 = 0;
+// tagoption4 = 0;
+//// int tagvalOld = -1;
+// tagvalOld = -1;
+// while(1) {
+// ft_uint8_t tagval = 0;
+// TrackRegisterVal = TFT.Rd32(REG_TRACKER); // check if one of the tracking fields is touched
+// tagval = TrackRegisterVal & 0xff;
+// if(tagval != 0) { // touch -> get new values
+// if (tagval != tagvalOld) {
+// printf("t %d\n", tagval);
+// tagvalOld = tagval;
+// }
+// if(tagval == 1) { // the dial touched
+// color = TrackRegisterVal>>16; // get the new value
+// }
+// else if(tagval == 2) { // the slider is touched
+// bright = TrackRegisterVal>>16; // get new slider value
+// bright = bright * 255/65536; // scale it down to 255
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 3) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+// tagoption1 = OPT_FLAT;
+// bright = 64;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 4) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+// tagoption2 = OPT_FLAT;
+// bright = 128;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 5) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+// tagoption3 = OPT_FLAT;
+// bright = 192;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 8) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+//// tagoption2 = OPT_FLAT;
+// bright = 171;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 10) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+//// tagoption3 = OPT_FLAT;
+// bright = 212;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// else if(tagval == 11) { // the button is touched
+//// TFT.SetBacklight(63); // Brightness
+//// tagoption3 = OPT_FLAT;
+// tagoption4 = OPT_FLAT;
+// bright = 230;
+// TFT.SetBacklight(bright); // Brightness
+// }
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// else
+// {
+// tagvalOld = -1;
+//// printf("Tagval %d, tagoption %d\n", tagval, tagoption);
+// if (tagoption1 != 0)
+// {
+// tagoption1 = 0;
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// if (tagoption2 != 0)
+// {
+// tagoption2 = 0;
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// if (tagoption3 != 0)
+// {
+// tagoption3 = 0;
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// if (tagoption4 != 0)
+// {
+// tagoption4 = 0;
+// screen_1(color, bright, tagoption1, tagoption2, tagoption3, tagoption4); // paint new screen
+// TFT.Sleep(10); // wait 10ms for next check
+// }
+// }
+// } // end of display loop
+//
+// while(1) {
+// myled = !myled; // LED is ON
+// wait(0.5); // 500 ms
+// }
+//
+// fs.unmount();
+//
+// // Deinitialize the device
+// sd.deinit();
+
+ // Deinitialize the device
+// spif.deinit();
+
+ // Deinitialize the device
+// ee.deinit();
+
+}