Revision 0:2e2716e8edb3, committed 2020-04-28

Comitter:

Photonium

Date:

Tue Apr 28 12:10:04 2020 +0000

Commit message:

d

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BD_SD_DISCO_F746NG.lib	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/Photonium/code/BD_SD_DISCO_F746NG/#77f8ecef87fd

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/BSP_DISCO_F746NG.lib	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,1 @@
+https://developer.mbed.org/teams/ST/code/BSP_DISCO_F746NG/#df2ea349c37a

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LCD_DISCO_F746NG.lib	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,1 @@
+https://developer.mbed.org/teams/ST/code/LCD_DISCO_F746NG/#d44525b1de98

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TS_DISCO_F746NG.lib	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,1 @@
+https://developer.mbed.org/teams/ST/code/TS_DISCO_F746NG/#fe0cf5e2960f

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,640 @@
+#include "mbed.h"
+#include "FATFileSystem.h"
+#include "SDBlockDeviceDISCOF746NG.h"
+#include <stdio.h>
+#include <errno.h>
+#include "TS_DISCO_F746NG.h"
+#include "LCD_DISCO_F746NG.h"
+#include <string>
+#include <fstream> //library für file streams
+//#include <iostream> //für input/output von streams
+LCD_DISCO_F746NG lcd;
+TS_DISCO_F746NG ts;
+TS_StateTypeDef TS_State;
+I2C i2c(I2C_SDA, I2C_SCL );
+SDBlockDeviceDISCOF746NG bd;
+FATFileSystem fs ("fs");
+uint32_t linecheck(uint8_t Channel); //Function to Check a wire connection 
+uint8_t channel;
+uint8_t g=0,lc=0,gmax=0;
+uint8_t channel_max =32;
+char channel_result[32]; //Array for test-result
+string Result = "NOK";
+uint8_t mode=0,quad=0,cp=0,bc=0; //Modus of program (1:1==1, Load from SDCard==2, Learn==3)
+uint8_t escrep=0;//escape=1 or repeat=2 same mode?
+uint8_t trippelchoose (uint8_t mode);
+uint8_t quadchoose (uint8_t quad);
+uint8_t readCabletext();
+uint16_t x, y,temp_count;
+uint32_t rv,cv; //32Bitvariable rv=resultvector cv=channelvector
+uint8_t idx;
+uint8_t prev_nb_touches = 0;
+uint8_t cleared = 0;
+string ws,sz,ls;
+//#################
+struct Cable  {
+    string internal_name; // Kabelname und Bezeichnung ggf. interne Nummer
+    string navision_number;
+    char wiring_in[32];
+    char wiring_out[32];
+} CableIndex [127];
+
+
+void
+return_error (int ret_val)
+{
+    if(ret_val)
+        printf ("Failure. %d\r\n", ret_val);
+    else
+        printf ("done.\r\n");
+}
+
+void
+errno_error (void* ret_val)
+{
+    if(ret_val == NULL)
+        printf (" Failure. %d \r\n", errno);
+    else
+        printf (" done.\r\n");
+}
+
+int main()
+{
+
+    Serial pc (SERIAL_TX, SERIAL_RX);
+    pc.baud(115200);
+//################ INIT I2C devices
+const int I2C_ChOut  = 0x20<<1; //  I2C address for input devices
+     char cmd [2]; //Variable for commandstring (send / read )input
+
+    for(int i=0;i<4;i++) { //set all I2C output to LOW 
+    cmd[0] = 0x03;//configuration-register I2C device
+    cmd[1] = 0x00;//sets this device for output
+    i2c.write(I2C_ChOut+2*i, cmd, 2);//send 2 configbyte to I2C device
+    cmd[0] = 0x01;// I2C device for output
+    cmd[1] = 0x00;//bitpattern == 8bit LOW
+    i2c.write(I2C_ChOut+2*i, cmd, 2);//Send bitpattern for output
+    }
+
+//################ Init Touchsreen and LCD
+    TS_StateTypeDef TS_State;
+    char text[30];
+    uint8_t status;
+    uint8_t idx;
+    //uint32_t PURPLE=0xffC800C8; //Colorcode
+    uint32_t DBLUE=0xff000064; //Colorcode
+    uint8_t channel_idx;
+    //uint8_t escrep;//escape=1 or repeat=2 same mode?
+
+    lcd.SetFont(&Font20);
+    status = ts.Init(lcd.GetXSize(), lcd.GetYSize());
+    if (status != TS_OK) {
+        lcd.Clear(LCD_COLOR_RED);
+        lcd.SetBackColor(LCD_COLOR_RED);
+        lcd.SetTextColor(LCD_COLOR_WHITE);
+        lcd.DisplayStringAt(0, LINE(5), (uint8_t *)"TOUCHSCREEN INIT FAIL", CENTER_MODE);
+    } else {
+        lcd.Clear(LCD_COLOR_GREEN);
+        lcd.SetBackColor(LCD_COLOR_GREEN);
+        lcd.SetTextColor(LCD_COLOR_WHITE);
+        lcd.DisplayStringAt(0, LINE(5), (uint8_t *)"TOUCHSCREEN INIT OK", CENTER_MODE);
+    }
+    lcd.Clear(DBLUE);
+    lcd.SetBackColor(DBLUE);
+    lcd.SetTextColor(LCD_COLOR_WHITE);
+    lcd.SetFont(&Font24);
+    sprintf((char*)text, "Advanced Cable Tester");
+    lcd.DisplayStringAt(0, LINE(2), (uint8_t *)&text, CENTER_MODE);
+    lcd.SetBackColor(DBLUE);
+    lcd.SetTextColor(LCD_COLOR_WHITE);
+    lcd.SetFont(&Font20);
+    lcd.DisplayStringAt(0, LINE(5), (uint8_t *)"Reading cabledata from sd-card...", CENTER_MODE);
+
+    printf("Start\n");
+    int error = 0;
+    return_error(error);
+
+    printf("Mounting the filesystem on \"/fs\". ");
+    error = fs.mount(&bd);
+    return_error(error);
+    gmax=readCabletext();
+    sprintf((char*)text, "Read %d cables from file", gmax);
+    lcd.DisplayStringAt(0, LINE(6), (uint8_t *)&text, CENTER_MODE);
+    printf("Read %d cables from file \r\n", gmax); //
+    wait(2);
+    do {
+        mode=0;
+
+        lcd.Clear(DBLUE);
+        lcd.SetBackColor(DBLUE);
+        lcd.SetTextColor(LCD_COLOR_WHITE);
+        lcd.SetFont(&Font24);
+        sprintf((char*)text, "Advanced Cable Tester");
+        lcd.DisplayStringAt(0, LINE(2), (uint8_t *)&text, CENTER_MODE);
+        sprintf((char*)text, "choose Mode");
+        lcd.DisplayStringAt(0, LINE(3), (uint8_t *)&text, CENTER_MODE);
+        lcd.SetFont(&Font16);
+        // lcd.DisplayStringAt(0, LINE(10), (uint8_t *)"IPG", CENTER_MODE);
+
+        while(mode==0) {
+
+            mode=trippelchoose (mode);
+            //printf("Modus=%d \r\n",mode);
+        }
+        switch(mode) {
+            case 1: {
+                // Check of 1:1 Cable here (32 Positions)
+                lcd.DisplayStringAt(20, LINE(1), (uint8_t *)&text, LEFT_MODE);
+                lcd.Clear(DBLUE);
+                lcd.SetBackColor(DBLUE);
+                lcd.SetFont(&Font16);
+                lcd.SetTextColor(LCD_COLOR_WHITE);
+                sprintf((char*)text, "+++++++++ 1:1 Test running +++++++++");
+                lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, CENTER_MODE);
+                lcd.SetTextColor(LCD_COLOR_RED);
+                lcd.FillRect(200, 15, 50, 250);
+                //lcd.Clear(LCD_COLOR_BLUE);
+                lcd.SetBackColor(LCD_COLOR_RED);
+                lcd.SetTextColor(LCD_COLOR_WHITE);
+                lcd.SetFont(&Font24);
+                sprintf((char*)text, "E");
+                lcd.DisplayStringAt(216, LINE(3), (uint8_t *)&text, LEFT_MODE);
+                sprintf((char*)text, "S");
+                lcd.DisplayStringAt(216, LINE(4), (uint8_t *)&text, LEFT_MODE);
+                sprintf((char*)text, "C");
+                lcd.DisplayStringAt(216, LINE(5), (uint8_t *)&text, LEFT_MODE);
+                sprintf((char*)text, "A");
+                lcd.DisplayStringAt(216, LINE(6), (uint8_t *)&text, LEFT_MODE);
+                sprintf((char*)text, "P");
+                lcd.DisplayStringAt(216, LINE(7), (uint8_t *)&text, LEFT_MODE);
+                sprintf((char*)text, "E");
+                lcd.DisplayStringAt(216, LINE(8), (uint8_t *)&text, LEFT_MODE);
+                lcd.SetFont(&Font16);
+                lcd.SetBackColor(DBLUE);
+                while(mode==1) {
+                     for (channel_idx = 0 ; channel_idx < channel_max/2; channel_idx++) {
+                        rv=linecheck(channel_idx); //Line check (#)
+                        cv=1<<channel_idx; 
+                        printf ("Index%d CV:%d RV:%d \r\n",channel_idx,cv,rv);
+                        if (channel_idx <16) {
+                            if(rv==cv) {
+                                lcd.SetTextColor(LCD_COLOR_GREEN);
+                                Result = "Okay";
+                            } else {
+                                lcd.SetTextColor(LCD_COLOR_RED);
+                                Result = "Error";
+                            }
+                            sprintf(text,"Line(%d)=%s",channel_idx+1,"     ");
+                            lcd.DisplayStringAt(35, LINE(channel_idx+1), (uint8_t *)&text, LEFT_MODE);
+                            wait(.005);
+                            sprintf(text,"Line(%d)=%s",channel_idx+1,Result.c_str());
+                            lcd.DisplayStringAt(35, LINE(channel_idx+1), (uint8_t *)&text, LEFT_MODE);
+                        }
+                        rv=linecheck(channel_idx+16); //Line check (#)
+                        cv=1<<channel_idx+16; 
+                        if (channel_idx+16 >15) {
+                             if(rv==cv)  {
+                                lcd.SetTextColor(LCD_COLOR_GREEN);
+                                Result = "Okay";
+                            } else {
+                                lcd.SetTextColor(LCD_COLOR_RED);
+                                Result = "Error";
+                            }
+                            sprintf((char*)text,"Line(%d)=%s",channel_idx+16+1,"     ");
+                            lcd.DisplayStringAt(260, LINE(channel_idx+16-16+1), (uint8_t *)&text, LEFT_MODE);
+                            wait(.005);
+                            sprintf((char*)text,"Line(%d)=%s",channel_idx+16+1,Result.c_str());
+                            lcd.DisplayStringAt(260, LINE(channel_idx+16-16+1), (uint8_t *)&text, LEFT_MODE);
+                        }
+                        ts.ResetTouchData(&TS_State);
+                        ts.GetState(&TS_State);
+                        if (TS_State.touchDetected) {
+                            x = TS_State.touchX[idx];
+                            y = TS_State.touchY[idx];
+                            if (y>15 and y<275) {
+                                if (x>200 and x<250)   {
+                                    printf("Stop running 1:1 checking");
+                                    mode=0;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    wait (.1);
+                }
+            }
+            case 2: {
+                while(mode==2) {
+                    lcd.Clear(DBLUE);
+                    lcd.SetBackColor(DBLUE);
+                    lcd.SetFont(&Font16);
+                    lcd.SetTextColor(LCD_COLOR_WHITE);
+                    sprintf((char*)text, "++++++++++++ Choose Cable ++++++++++++");
+                    lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, CENTER_MODE);
+                    //printf("gmax= %d, g= %d CP=%d \r\n",gmax,g,g+10*bc);
+                    cp=1; //Cablepointer inside this codeblock (--> point actuell index onto cabledata )
+                    bc=0; //blockcounter (usage for second decimal value 10th)
+                    for (g=0; g<10; g++) {
+                        //.substr(0, myString.size()-2);
+                        //sprintf((char*)text,"(%d) %s\n",g+1,CableIndex[g].internal_name.c_str());
+                        sprintf((char*)text,"(%d) %s", g+1,CableIndex[g].internal_name.substr(0, CableIndex[g].internal_name.size()-1).c_str());
+                        lcd.DisplayStringAt(25, LINE(g+1), (uint8_t *)&text, LEFT_MODE);
+                        lcd.SetTextColor(LCD_COLOR_GREEN);
+                        lcd.DisplayStringAt(5, LINE(cp), (uint8_t *)"=>", LEFT_MODE);
+                        lcd.SetTextColor(LCD_COLOR_WHITE);
+                    }
+                    do {
+                        quad=quadchoose (quad);
+                        //printf("Quad=%c ",quad);
+                        if (quad=='>') {
+                            for(int n=1; n<11; n++) {
+                                lcd.DisplayStringAt(5, LINE(n), (uint8_t *)"  ", LEFT_MODE);
+                            } //Clear of old ">" indicator
+                            cp++;
+                            if (cp==11) {
+                                if (gmax > cp+10*bc) {
+                                    bc++;
+                                    cp=1;
+                                } else {
+                                    cp=10;
+                                }
+                                lcd.Clear(DBLUE);
+                                lcd.SetBackColor(DBLUE);
+                                sprintf((char*)text, "++++++++++++ Choose Cable ++++++++++++");
+                                lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, CENTER_MODE);
+                                for (g=0; g<10; g++) {
+                                    //sprintf((char*)text,"(%d) %s",(bc*10+g+1),CableIndex[(bc*10)+g].internal_name.c_str());
+                                    sprintf((char*)text,"(%d) %s", (bc*10+g+1),CableIndex[(bc*10)+g].internal_name.substr(0, CableIndex[(bc*10)+g].internal_name.size()-1).c_str());
+                                    lcd.DisplayStringAt(25, LINE(g+1), (uint8_t *)&text, LEFT_MODE);
+                                    printf("(%d) %s",(bc*10+g+1),CableIndex[(bc*10)+g].internal_name.c_str());
+                                }
+                            }
+                            lcd.SetTextColor(LCD_COLOR_GREEN);
+                            lcd.DisplayStringAt(5, LINE(cp), (uint8_t *)"=>", LEFT_MODE);
+                            lcd.SetTextColor(LCD_COLOR_WHITE);
+                        }
+                        if (quad=='<') {
+                            for(int n=1; n<11; n++) {
+                             
+                                lcd.DisplayStringAt(5, LINE(n), (uint8_t *)"  ", LEFT_MODE);
+                            } //Clear of old ">" indicator
+                            cp--;
+                              printf("cp=%d\r\n",cp);
+                            if (cp==0) {
+                                if(bc>0) {
+                                    bc--;
+                                    cp=10;
+                                } else {
+                                    cp=1;
+                                }
+                                lcd.Clear(DBLUE);
+                                lcd.SetBackColor(DBLUE);
+                                sprintf((char*)text, "++++++++++++ Choose Cable ++++++++++++");
+                                lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, CENTER_MODE);
+                                for (g=0; g<10; g++) {
+                                    printf("g=%d, bc=%d \r\n",g,bc);
+                                    //sprintf((char*)text,"(%d) %s",(bc*10+g+1),CableIndex[bc*10+g].internal_name.c_str());
+                                    sprintf((char*)text,"(%d) %s", (bc*10+g+1),CableIndex[(bc*10)+g].internal_name.substr(0, CableIndex[(bc*10)+g].internal_name.size()-1).c_str());
+                                    lcd.DisplayStringAt(25, LINE(g+1), (uint8_t *)&text, LEFT_MODE);
+                                }
+                            }
+                            lcd.SetFont(&Font16);
+                            lcd.SetTextColor(LCD_COLOR_GREEN);
+                            lcd.DisplayStringAt(5, LINE(cp), (uint8_t *)"=>", LEFT_MODE);
+                            lcd.SetTextColor(LCD_COLOR_WHITE);
+                        }
+
+
+                        if (quad==13) {
+                            printf("ENTER DETECTED");
+                            mode=0;
+                            
+                            //Testfunktion aufrufen
+                            //break;
+                        }
+                        if (quad==27) {
+                            printf("Escape DETECTED");
+                            mode=0;
+                            break;
+                        }
+
+                        printf("CableIndex=%d \r\n",cp+10*bc);
+                        printf("---->Quad=%d \r\n",quad);
+
+                        wait(.1);
+                    } while ((quad!=0x13)or(quad!=0x1b));
+                }
+
+                break;
+                //escrep=1;
+            }
+            default : 
+                printf("Switch/Case default code here");
+                break;
+        }
+
+
+        /*wait(1);
+        lcd.SetFont(&Font20);
+        lcd.SetBackColor(DBLUE);
+        lcd.SetTextColor(LCD_COLOR_WHITE);
+        sprintf((char*)text,"ENDE ? Advanced Cable Tester" );
+        lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, LEFT_MODE);
+        while(1) {
+            lcd.SetFont(&Font24);
+            sprintf((char*)text, "Advanced Cable Tester");
+            lcd.DisplayStringAt(60, LINE(4), (uint8_t *)&text, LEFT_MODE);
+            sprintf((char*)text, "(Touch to start test)");
+            lcd.DisplayStringAt(60, LINE(6), (uint8_t *)&text, LEFT_MODE);
+            lcd.SetFont(&Font16);
+            ts.GetState(&TS_State);
+            if (TS_State.touchDetected) {
+                // Clear lines corresponding to old touches coordinates
+                if (TS_State.touchDetected < prev_nb_touches) {
+                    for (idx = (TS_State.touchDetected + 1); idx <= 5; idx++) {
+                        lcd.ClearStringLine(idx);
+                    }
+                }
+                prev_nb_touches = TS_State.touchDetected;
+                cleared = 0;
+                lcd.SetBackColor(DBLUE);
+                lcd.SetTextColor(LCD_COLOR_WHITE);
+                wait(1);
+                x = TS_State.touchX[idx];
+                y = TS_State.touchY[idx];
+            } else {
+                if (!cleared) {
+                    lcd.Clear(DBLUE);
+                    //sprintf((char*)text, "Touches: 0");
+                    //lcd.DisplayStringAt(0, LINE(0), (uint8_t *)&text, LEFT_MODE);
+                    cleared = 1;
+                }
+            }
+        }
+        */
+    } while (1);
+}
+
+uint32_t linecheck(uint8_t channel)
+{
+    //####################################################################
+    //Strategy: set only ONE bit ON of 32 channels and read all 32channel input
+    //Save result in Array
+    //then repeat that for next bit
+    const int I2C_ChOut  = 0x20<<1; //  I2C address for input devices
+    const int I2C_ChIn = 0x24<<1; //  I2C address for output devices
+    char channel_set [8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
+    char cmd [2]; //Variable for commandstring (send / read )input
+
+    char channel_result[4]; //Array for test-result
+    uint8_t  ChOffset=0;
+    //uint8_t text[30];
+    uint8_t channel_idx;
+    //uint8_t channel_result=0;
+   
+    channel_idx = channel;//-1;
+    //wait (.005);
+    ChOffset = abs(channel_idx/8);
+    cmd[0] = 0x03;//configuration-register I2C device
+    cmd[1] = 0x00;//sets this device for output
+    i2c.write(I2C_ChOut+2*ChOffset, cmd, 2);//send 2 configbyte to I2C device
+    cmd[0] = 0x01;// I2C device for output
+    //cmd[1] = 0xFF & (channel_set[channel_idx%8]); //set bit for channel
+    cmd[1] = channel_set[channel_idx%8];//bitpattern
+    i2c.write(I2C_ChOut+2*ChOffset, cmd, 2);//Send bitpattern for output
+    //wait(0.001);// on for 5ms !!!!!!!!!!! modified
+    /////cmd[0] = 0x03;//configurationregister I2C device 
+    /////cmd[1] = 0xFF;//set this 8Bit device for Input
+    /////i2c.write(I2C_ChIn, cmd, 2);//send 2 configbyte to I2C device 
+    cmd[0] = 0x00;
+    i2c.write(I2C_ChIn+0, cmd, 1);
+    i2c.read(I2C_ChIn+0, cmd, 1);
+    channel_result[0]=cmd[0];
+    //printf ("R=%d ch=%d \r\n", cmd[0],channel_idx);
+    cmd[0] = 0x00;
+    i2c.write(I2C_ChIn+2, cmd, 1);
+    i2c.read(I2C_ChIn+2, cmd, 1);
+    channel_result[1]=cmd[0];
+    //printf ("R=%d ch=%d \r\n", cmd[0],channel_idx);
+    cmd[0] = 0x00;
+    i2c.write(I2C_ChIn+4, cmd, 1);
+    i2c.read(I2C_ChIn+4, cmd, 1);
+    channel_result[2]=cmd[0];
+    //printf ("R=%d ch=%d \r\n", cmd[0],channel_idx);
+    cmd[0] = 0x00;
+    i2c.write(I2C_ChIn+6, cmd, 1);
+    i2c.read(I2C_ChIn+6, cmd, 1);
+    channel_result[3]=cmd[0];
+    printf ("Ch:%d R%d %d %d %d \r\n",channel_idx,channel_result[0],channel_result[1],channel_result[2],channel_result[3]);
+    /////////------ read
+    /*cmd[0] = 0x03;//configurationregister I2C device 
+    cmd[1] = 0xFF;//sets 8bit of this device for intput
+    i2c.write(I2C_ChIn+2*0, cmd, 2);//send config I2C device for output
+    cmd[0]= 0x0;
+    i2c.write(I2C_ChIn+2*0, cmd, 1);// prepare to read 
+    i2c.read(I2C_ChIn+2*0, cmd, 1);
+    printf ("R=%d ch=%d \r\n", cmd[0],channel_idx);*/
+    //channel_result=cmd[0];
+    ////////
+    
+    cmd[0] = 0x03;
+    cmd[1] = 0x00;//config to out
+    i2c.write(I2C_ChOut+2*ChOffset, cmd, 2);
+    cmd[0] = 0x01;
+    cmd[1] = 0x00; //bitpattern
+    i2c.write(I2C_ChOut+2*ChOffset, cmd, 2);
+    //wait (.001);
+    rv=256*256*256*channel_result[3]+256*256*channel_result[2]+256*channel_result[1]+channel_result[0];
+    printf ("RV: %d \r\n",rv);
+    return rv; // 32Bit in 4 Byte
+}
+
+uint8_t trippelchoose (uint8_t mode)
+{
+
+    lcd.DrawRect(13, 185, 135, 40);
+    lcd.DisplayStringAt(25, LINE(12), (uint8_t *)"1:1 Cable", LEFT_MODE);
+
+    lcd.DrawRect(173, 185, 135, 40);
+    lcd.DisplayStringAt(180, LINE(12), (uint8_t *)"Choose from", LEFT_MODE);
+    lcd.DisplayStringAt(180, LINE(13), (uint8_t *)"  SD-Card", LEFT_MODE);
+
+    lcd.DrawRect(333, 185, 135, 40);
+    lcd.DisplayStringAt(340, LINE(12), (uint8_t *)"Learn new", LEFT_MODE);
+    wait(.1);
+    //printf("#####\r\n");
+    ts.ResetTouchData(&TS_State);
+    ts.GetState(&TS_State);
+    if (TS_State.touchDetected) {
+        x = TS_State.touchX[idx];
+        y = TS_State.touchY[idx];
+
+        if (y>185 and y<185+40) {
+            if (x>13 and x<135+13)   {
+                mode=1;
+            }
+            if (x>173 and x<173+135) {
+                mode=2;
+            }
+            if (x>333 and x<333+135) {
+                mode=3;
+            }
+        }
+        printf("X=%d Y=%d Modus=%d \r\n",TS_State.touchX[idx],y,mode);
+        //prev_nb_touches = TS_State.touchDetected;
+        //cleared = 0;
+    }
+
+    return mode;
+}
+uint8_t readCabletext()
+   {
+   //Read and Parsing of intput file "cable.txt"  from SD-Card
+     printf("Opening file read-only.");
+//FILE* fd = fopen("/fs/numbers5.txt", "w");    
+//FILE* fd = fopen("/fs/cable.txt", "r");
+    
+    std::ifstream fd("/fs/cable.txt"); //öffnet die Datei als c++ stream. fd = name der variable 
+    std::string line; //variable für die aktuelle Zeile
+        printf("geoeffnet ?\n");
+    while(std::getline(fd, line)) { //solange die zeilen gelesen werden können
+        printf("%s\n", line.c_str());   //gelesene zeile als c-string ausgeben
+        //printf("inWhile ?\n");
+    }
+    //Der zweite Teil ist C++ aber mit ein bisschen C an einigen Stellen
+    FILE* fd2 = fopen("/fs/cable.txt", "r"); //datei zum "lesen als textdatei" öffnen
+    std::string line2;
+      printf("geoeffnet ?\r\n");
+      int lc=0;
+    while(!feof(fd2)) {
+        char buffer[1] = {0}; //buffer für das zu lesende byte
+        int bytes_read = fread(&buffer, 1, sizeof(char), fd2); // 1 byte (zeichen) lesen
+        if (*buffer != '\n') { //wenn buffer nicht '\n' (neue zeile) ist
+            line2 = line2 + &buffer[0]; //string um aktuelles zeichen erweitern
+        }
+        if (*buffer == '\n') { //wenn neue zeile gefunden
+            //printf("(%d) %s\n",lc%4, line2.c_str()); //zeile ausgeben
+            switch(lc%4) {
+                case 0:{
+                    CableIndex[g].internal_name=line2.c_str();
+                    printf("(g=%d)(lc=%d) Internal-Name= %s\r\n",g,lc, CableIndex[g].internal_name.c_str());
+                    line2 = ""; //zeile löschen
+                    lc++;
+                    break;
+                    }
+                case 1:{
+                    CableIndex[g].navision_number=line2.c_str();
+                    printf("(g=%d) (lc=%d) Navision-Number= %s\r\n", g,lc,CableIndex[g].navision_number.c_str());
+                    line2 = ""; //zeile löschen
+                    lc++;
+                    break;
+                    }
+         case 2:{
+                    string hs=line2.c_str(); 
+                    string::iterator zg;
+                    uint8_t cf=0;
+                        for (zg=hs.begin();zg<hs.end(); zg++) {                        
+                               if ((*zg>47)&&(*zg<59)) {
+                        CableIndex[g].wiring_in[cf] = (*(zg)-48)*10+(*(zg+1)-48);
+                        zg=zg+2;
+                        cf++;
+                        }//end_if
+                        }// end_for
+                        line2 = ""; //zeile löschen
+                        for (int ci = 0; ci < 32; ci++) //Fertige Zeile einmal ausgeben
+                        {
+                        printf("[%d]", CableIndex[g].wiring_in[ci]);
+                        } //end_for
+                        printf("\r\n");
+                    line2 = ""; //zeile löschen
+                    lc++;
+                    break;
+                      }
+                case 3:{
+                    string hs=line2.c_str(); 
+                    string::iterator zg;
+                    uint8_t cf=0;
+                        for (zg=hs.begin();zg<hs.end(); zg++) {                        
+                               if ((*zg>47)&&(*zg<59)) {
+                        CableIndex[g].wiring_out[cf] = (*(zg)-48)*10+(*(zg+1)-48);
+                        zg=zg+2;
+                        cf++;
+                        }//end_if
+                        }// end_for
+                        line2 = ""; //zeile löschen
+                        for (int ci = 0; ci < 32; ci++) //Fertige Zeile einmal ausgeben
+                        {
+                        printf("(%d)", CableIndex[g].wiring_out[ci]);
+                        } //end_for
+                        printf("\r\n");
+                    
+                    line2 = ""; //zeile löschen
+                    lc++;
+                    break;
+                      }
+                
+           
+                   
+            
+            
+        }
+         
+            line2 = ""; //zeile löschen
+            
+            if (lc==4) {
+                lc=0;
+                g++;}
+    }   
+        }
+    fclose(fd2);//datei nach dem lesen schließen
+    //return 0;
+    
+    //fd.close(); //datei nach lesen schließen
+    //errno_error(fd);
+        
+    gmax=g;
+    return gmax;
+    
+    }
+
+uint8_t quadchoose (uint8_t quad)
+{
+    quad =0;
+    lcd.SetFont(&Font24);
+    lcd.DrawRect(15, 200, 90, 60);
+    lcd.DisplayStringAt(45, LINE(9), (uint8_t *)"<", LEFT_MODE);
+
+    lcd.DrawRect(135, 200, 90,60);
+    lcd.DisplayStringAt(155, LINE(9), (uint8_t *)"ESC", LEFT_MODE);
+
+    lcd.DrawRect(255, 200, 90, 60);
+    lcd.DisplayStringAt(275, LINE(9), (uint8_t *)"ENT", LEFT_MODE);
+
+    lcd.DrawRect(375, 200, 90, 60);
+    lcd.DisplayStringAt(405, LINE(9), (uint8_t *)">", LEFT_MODE);
+
+    lcd.SetFont(&Font16);
+    do {
+        ts.ResetTouchData(&TS_State);
+        ts.GetState(&TS_State);
+        if (TS_State.touchDetected) {
+            x = TS_State.touchX[idx];
+            y = TS_State.touchY[idx];
+            if (y>200 and y<200+60) {
+                if (x>15 and x<15+90)   {
+                    quad='<';//back
+                }
+                if (x>135 and x<135+90) {
+                    quad=0x1b;//escape
+                }
+                if (x>255 and x<255+90) {
+                    quad=0x0d;//enter
+                }
+                if (x>375 and x<375+90)   {
+                    quad='>';//forward
+                }
+            }
+        }
+    }   while (quad==0);
+    return quad;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-os.lib	Tue Apr 28 12:10:04 2020 +0000
@@ -0,0 +1,1 @@
+https://github.com/ARMmbed/mbed-os/#16bac101a6b7b4724023dcf86ece1548e3a23cbf