Revision 0:78de368300ec, committed 2022-06-13

Comitter:

201710861

Date:

Mon Jun 13 13:56:52 2022 +0000

Commit message:

This is the program used on the board with Esp attached when demo

Changed in this revision

diff -r 000000000000 -r 78de368300ec C12832.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/C12832.lib	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,1 @@
+https://mbed.org/users/chris/code/C12832/#7de323fa46fe

diff -r 000000000000 -r 78de368300ec ESP-call.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ESP-call.lib	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,1 @@
+http://os.mbed.com/users/dshin/code/ESP-call/#11487122965a

diff -r 000000000000 -r 78de368300ec FXOS8700Q.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FXOS8700Q.lib	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,1 @@
+http://developer.mbed.org/teams/Freescale/code/FXOS8700Q/#aee7dea904e2

diff -r 000000000000 -r 78de368300ec communication.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/communication.h	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,473 @@
+#include "mbed.h"
+int test;
+using namespace std;
+Thread thread1;
+Thread thread2;
+Thread thread3;
+Mutex mutex;
+#define ligthmultiple 7
+int interval = 0;
+bool ack=false;
+struct ByteData{
+    uint8_t* data;
+    int length;
+    ByteData(uint8_t* Data,int Length):data(Data),length(Length){};
+    ByteData(){};
+};
+struct Datatype{    
+    char* typename4;
+    char* type2name4;
+    Datatype(char* type1,char* type2):typename4(type1),type2name4(type2){};
+    Datatype(){};
+};
+struct Datastorage{
+    uint8_t* data = new uint8_t[3];
+    bool check;
+    Datastorage(uint8_t* Data,bool Check):data(Data),check(Check){};
+    Datastorage(){};
+};
+ByteData DatatoByte(void* data, int length, int typesize, char* typename4, const char* type2name4) {
+    int a = 0;
+    int Extensionlength2 = sizeof(type2name4); // img pdf
+    uint8_t* byte = new uint8_t[length*typesize + 1 + 8 + 2];
+    switch (typesize) {
+    case 1:
+        for (; a < length; a++) {
+            byte[a] = *((uint8_t*)data + sizeof(uint8_t) * a);
+        }
+    case 2:
+        for (; a < length; a++) {
+            byte[a] = *((uint16_t*)data + sizeof(uint8_t) * a);
+            byte[a + 1] = *((uint16_t*)data + sizeof(uint8_t) * a) >> 4;
+            a++;
+        }
+    case 4:
+        for (; a < length; a++) {
+            byte[a] = *((uint32_t*)data + sizeof(uint8_t) * a);
+            byte[a + 1] = *((uint32_t*)data + sizeof(uint8_t) * a) >> 4;
+            byte[a + 2] = *((uint32_t*)data + sizeof(uint8_t) * a) >> 8;
+            byte[a + 3] = *((uint32_t*)data + sizeof(uint8_t) * a) >> 12;
+            a += 3;
+        }
+    case 8:
+        for (; a < length; a++) {
+            byte[a] = *((uint64_t*)data + sizeof(uint8_t) * a);
+            byte[a + 1] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 4;
+            byte[a + 2] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 8;
+            byte[a + 3] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 12;
+            byte[a + 4] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 16;
+            byte[a + 5] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 20;
+            byte[a + 6] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 24;
+            byte[a + 7] = *((uint64_t*)data + sizeof(uint8_t) * a) >> 32;
+            a += 7;
+        }
+    }
+    byte[a++] = uint8_t('.');
+    printf("%0x", uint8_t('.'));
+    for (int i = 0; a < length + 5; a++, i++) {
+        byte[a] = uint8_t((typename4[i]));
+    }
+    for (int i = 0; a < length + 9; a++, i++) {
+        byte[a] = uint8_t((type2name4[i]));
+    }
+    byte[a++] = uint8_t('.');
+    byte[a++] = uint8_t('.');
+    for (int i = 0; i < a; i++) {
+        printf("%02x = %c\n", byte[i],char(byte[i]));
+    }
+    return ByteData(byte, a);
+}
+Datatype ExtractionDatatype(uint8_t* reciveData,int datalength){
+    char *type1 = (char*)malloc(sizeof(char)*4);
+    char *type2 = (char*)malloc(sizeof(char)*4);
+    for(int i = datalength - 8,j=0; i < datalength-4;i++,j++){
+        type1[j] = reciveData[i];
+    }
+    for(int i = datalength - 4,j=0; i < datalength;i++,j++){
+        type2[j] = reciveData[i];
+    }
+    return Datatype(type1,type2);
+}
+void Sending(uint8_t Data1, uint8_t Data2, uint8_t Data3,DigitalOut D) {
+    bool* send = new bool[32];
+    uint8_t checksum = Data1 + Data2 + Data3;
+    printf("%c,%c ,%c\n",(char)Data1,(char)Data2,(char)Data3);
+    uint8_t Data[4] = { Data1, Data2, Data3, checksum};
+    printf("%s",Data);
+    for (int i = 0,j=0; i < 4; i++) {
+        send[j++] = (Data[i] & 1)/1;
+        send[j++] = (Data[i] & 2)/2;
+        send[j++] = (Data[i] & 4)/4;
+        send[j++] = (Data[i] & 8)/8;
+        send[j++] = (Data[i] & 16)/16;
+        send[j++] = (Data[i] & 32)/32;
+        send[j++] = (Data[i] & 64)/64;
+        send[j++] = (Data[i] & 128)/128;
+        /*send[j++] = (Data[i] & 128)/128;
+        send[j++] = (Data[i] & 64)/64;
+        send[j++] = (Data[i] & 32)/32;
+        send[j++] = (Data[i] & 16)/16;
+        send[j++] = (Data[i] & 8)/8;
+        send[j++] = (Data[i] & 4)/4;
+        send[j++] = (Data[i] & 2)/2;
+        send[j++] = (Data[i] & 1)/1;*/
+    }
+    printf("now really sendingready\r\n");
+    D = 1;
+    thread_sleep_for(interval*10);
+    printf("now really sending\r\n");
+    D = 0;
+    thread_sleep_for(interval);
+    for(int j = 31;j >=0;j--){
+        D = send[j];
+        thread_sleep_for(interval);
+    }
+    D = 0;
+        for(int j = 31;j >=0;j--){
+        printf("%d",send[j]);
+    }
+}
+void onoff(DigitalOut* D){
+    while(true){
+        thread_sleep_for(interval);
+        *D = 1;
+        thread_sleep_for(interval);
+        *D = 0;
+    }
+}
+void Recvack(AnalogIn* A){
+    float val[8];
+    bool test = true;
+    uint8_t result = 0;
+    while(true){
+        printf("start recvack\n\r");
+        val[0] = A->read() * ligthmultiple;
+        printf("wow\n\r");
+        for(int i = 0;i<8;i++){
+            val[i] = A->read() * ligthmultiple;
+            thread_sleep_for(interval);
+        }
+        for(int i = 0;i<8;i+=2){
+            test &= (val[i] > 0.5 )? true : false;
+            printf("%d",(bool)val[i]);
+        }
+        if(test)
+            printf("wow3\n\r");
+            return;
+        /*val[0] = (val[0] > 0.5 )? true : false;*/
+        thread_sleep_for(interval*2);    
+        /*if(true == val[0]){
+            printf("==============");
+            for(int i = 0;i<8;i++){
+                val[i] = A->read() * ligthmultiple;
+                val[i] = (val[i] > 0.5 )? true : false;
+                thread_sleep_for(interval);
+            }
+            result |= (int)val[0];
+            result |= (int)val[1]*2;
+            result |= (int)val[2]*4;
+            result |= (int)val[3]*8;
+            result |= (int)val[4]*16;
+            result |= (int)val[5]*32;
+            result |= (int)val[6]*64;
+            result |= (int)val[7]*128;
+            if(result == 0x55){
+                printf("scuuscusc");
+                ack = true;
+                printf("start recvack");
+            }
+        }*/
+    }
+}
+bool Synchronizesender(DigitalOut D,AnalogIn A){
+    thread1.start(callback(onoff, &D));
+    thread2.start(callback(Recvack, &A));
+    printf("nb");
+    thread2.join();
+    D = 0;
+    printf("hie");
+    thread1.terminate();
+    D = 0;
+    return true;
+    /*if(ack == true){
+        ack = false;
+        return true;
+    }else{
+        return false;
+    }    */
+}
+void Findclock(AnalogIn *A){
+    float val;
+    bool start;
+    bool result;
+    int Cycle;
+    int intervaltime;
+    Timer t;
+    t.reset();
+    printf("now find interval\n\r");
+    while(true){
+        val = A->read()  * ligthmultiple;
+        if(val < 0.5){
+            break;
+            }
+    }
+    while(true){
+    val = A->read()  * ligthmultiple;
+        if(val > 0.5){
+            t.start();
+            break;
+        }
+    }
+    while(true){
+        val = A->read()  * ligthmultiple;
+        if(val < 0.5){
+            t.stop();
+            interval = t.read_ms();
+            break;
+        }
+    }
+    t.reset();
+    while(true){
+        val = A->read()  * ligthmultiple;
+        if(val < 0.5){
+            break;
+        }
+    }
+    while(true){
+    val = A->read()  * ligthmultiple;
+    if(val > 0.5){
+            t.start();
+            break;
+        }
+    }
+    while(true){
+        val = A->read()  * ligthmultiple;
+        if(val < 0.5){
+            t.stop();
+            intervaltime = t.read_ms();
+            break;
+        }
+    }
+    printf("interval time = %d,%d\n\r",intervaltime,interval);
+    printf("now find interval suc\n\r");
+    if(intervaltime==interval){
+        interval = interval - (interval %10);
+        printf("return");
+    }
+    else{
+        printf("fail");
+    }
+}
+void Findlight(AnalogIn* A){
+    float val;
+    float val2;
+    while(true){
+        val = A->read()  * ligthmultiple;
+        printf("%2.2f\r\n",val);
+        if(val > 0.5){
+            break;
+        } 
+        thread_sleep_for(100);
+    }
+    /*ack=true*/ // 이거 오류나는데 왜지 ?
+    return;
+}
+void SendAck(DigitalOut *D){
+    printf("start sendack");
+    *D = 0;
+    for(int i = 0;i < 20; i++ ){
+        *D = !(*D);
+        thread_sleep_for(interval);
+    }
+}
+bool Synchronizereciver(DigitalOut D,AnalogIn A){
+    float val[8];
+    Findlight(&A);
+    printf("find!!");
+    printf("now find interval");
+    thread3.start(callback(Findclock, &A)); 
+    /*Findclock(A); //왜 안되징*/
+    thread3.join();
+    printf("error?");//여기가 왜 sendack부터 보내버리고 안에있는걸 출력할까
+    /*SendAck(D);*/
+    printf("now send ack\n\r");
+    thread3.start(callback(SendAck, &D)); 
+    thread3.join();
+    printf("send ack suc\n\r");
+    ack = false;
+    return true;
+}
+Datastorage Recieving(AnalogIn sensor) {
+    float val[32];
+    uint8_t* Data = new uint8_t[4];
+    printf("ready\r\n");
+    printf("now really ready\r\n");
+    while(true){
+        if((sensor.read() * ligthmultiple)> 0.5){
+                break;
+        }
+    }
+    while(true){
+        if((sensor.read() * ligthmultiple)< 0.5){
+                thread_sleep_for(interval*1.5);
+                break;
+        }
+    }
+    for(int i = 0;i < 32;i++){
+        val[i] = sensor.read() * ligthmultiple;
+        thread_sleep_for(interval);    
+    }
+    for(int i = 0;i < 32;i++){
+        val[i] = (val[i] > 0.5 )? true : false;
+    }
+    printf("now receive = ");
+    for(int i = 0;i < 32 ;i++){
+        printf("%d",(int)val[i]);
+    }
+    int j = 4;
+    for (; j >= 0; j--) {
+        Data[j] = 0;
+        Data[j] |= (int)val[j * 8 + 7];
+        Data[j] |= (int)val[j * 8 + 6] * 2;
+        Data[j] |= (int)val[j * 8 + 5] * 4;
+        Data[j] |= (int)val[j * 8 + 4] * 8;
+        Data[j] |= (int)val[j * 8 + 3] * 16;
+        Data[j] |= (int)val[j * 8 + 2] * 32;
+        Data[j] |= (int)val[j * 8 + 1] * 64;
+        Data[j] |= (int)val[j * 8] * 128;
+    }
+    printf("%c%c%c",(char)Data[3],(char)Data[2],(char)Data[1]);
+    printf("=%0x%0x%0x",Data[3],Data[2],Data[1]);
+    if (Data[0] == (Data[1] + Data[2] + Data[3])) {
+        //SendSucData();
+        Datastorage returnvalue;
+        returnvalue.data[0] = Data[3];
+        returnvalue.data[1] = Data[2];
+        returnvalue.data[2] = Data[1];
+        returnvalue.check = true;
+        return returnvalue;
+    }
+    else {
+        return Datastorage(Data,false);
+        //SendFailData();
+    }    
+    //32bit
+}
+void send(DigitalOut D,AnalogIn sensor){
+    interval = 100; //이거 임시
+    char* inputvalue = new char[50];
+    char* name = new char[4];
+    name = (char*)"char";
+    printf("hellow input here\n\r");
+    scanf("%s", inputvalue);
+    printf("input interval speed\n\r");
+    scanf("%d", &interval);
+    printf("success\n");
+    ByteData send = DatatoByte(inputvalue, strlen(inputvalue),sizeof(inputvalue[0]),name,"null");
+    if(!Synchronizesender(D,sensor)){
+        printf("fail sending");
+    }
+    else{
+        int nulldata = send.length%3;
+        printf("now sending\n");
+        thread_sleep_for(interval*5);
+        //scanf("%d",&test);
+        printf("........\n");
+        for(int j = 0; j < send.length;j++){
+           printf("{%d}{%c=%0x}", j,send.data[j],send.data[j]);
+        }
+        printf("........\n");
+        printf("sendlength =%d,cycle = %d",send.length,send.length/3);
+        printf("........\n");
+        int i = 0;
+        for(; i < send.length-nulldata;){
+            printf("==%c,%c,%c-cycle = %d-==",send.data[i],send.data[i+1],send.data[i+2],i);
+            Sending(send.data[i],send.data[i+1],send.data[i+2],D);
+            D = 0;
+            Recvack(&sensor);
+            D = 0;
+            if(ack == false){
+                thread_sleep_for(interval*30);
+                i+=3;
+                continue;
+            }
+            ack = false;
+            i+=3;
+        }
+        for(int j=0;j<1;){
+        switch(nulldata){
+            case 0:
+                Sending(0x00,0x00,0x00,D);   
+                //Sendcheckbit
+                break;
+            case 1:
+                i++;
+                Sending(send.data[i],0x00,0x00,D);   
+                //Sendcheckbit
+                break; 
+            case 2: 
+                i++;   
+                Sending(send.data[i],send.data[i+1],0x00,D);
+                //Sendcheckbit
+                break;
+        }
+        D = 0;
+        Recvack(&sensor);
+        D = 0;
+            if(ack == false){
+                continue;
+            }
+            ack = false;
+        }
+        printf("send suc\n");   
+    }    
+}
+void recv(DigitalOut D,AnalogIn sensor){
+uint8_t* reciveData = (uint8_t*)malloc(sizeof(uint8_t)*256);
+    Datastorage reciveData3;
+    int length;
+    printf("start\n");
+    if(Synchronizereciver(D,sensor)){
+        int i = 0;
+        printf("1now receiveing1\n");
+        thread_sleep_for(interval*7);
+        while(true){
+            printf("start recieve");
+            reciveData3 = Recieving(sensor);
+            if(!(reciveData3.check)){
+                printf("continue");
+                SendAck(&D);
+                continue;//연산으로 시간차이때문에 대기시간도 필요한데
+            }
+            else{
+                SendAck(&D);//sendfail
+            }
+            if(reciveData3.data[0] == 0x00)
+                length = i;
+                break;
+            if(reciveData3.data[1] == 0x00){
+                    reciveData[i++] = reciveData3.data[0];
+                    length = i;
+                    break;
+                }
+            if(reciveData3.data[2] == 0x00){
+                    reciveData[i++] = reciveData3.data[0];
+                    reciveData[i++] = reciveData3.data[1];
+                    length = i;
+                    break;
+                }
+            reciveData[i++] = reciveData3.data[0];
+            reciveData[i++] = reciveData3.data[1];
+            reciveData[i++] = reciveData3.data[2];
+        }
+        Datatype type = ExtractionDatatype(reciveData,length);
+        printf("suc here\n");
+        for(int i = 0;i < length-8;i++){
+            printf("%c",reciveData[i]);
+        }
+        printf("suc here\n");
+        scanf("%d",&test);
+    }else{
+        printf("fail\n");
+    }
+}
\ No newline at end of file

diff -r 000000000000 -r 78de368300ec main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,937 @@
+#include "mbed.h"
+#include "C12832.h"
+#include "ESP-call.h"
+#include "communication.h"
+
+//================================================================
+Serial pc(USBTX, USBRX, 115200);
+
+using namespace std;
+char esp_data;
+char esp_arr[20];
+char arr_time[20] = "0:0:0";
+int index = 0;
+int mbedMode = 0;
+int tempMode = 2;
+bool trans_status = 0;
+PwmOut led_r(D5);
+PwmOut led_g(D9);
+
+AnalogIn sensor(A0);
+DigitalOut led(D3);
+
+Thread thread_led;
+Thread thread_lcd;
+Ticker ticker;
+
+void ledSet();
+
+#define MAIN 0
+#define COM 1
+#define ALARM 2
+#define ALARM_SET 29
+#define PERM 3
+
+#define ALARM_SOUND 21
+#define ALARM_LED 22
+#define ALARM_SOUND_LED 23
+#define ALARM_ERROR 24
+
+#define PERM_SOUND 31
+#define PERM_LED 32
+#define PERM_SOUND_LED 33
+#define PERM_ERROR 34
+
+int send_count = 0;
+
+//================================ LCD ================================
+C12832 lcd(D11, D13, D12, D7, D10); // lcd = (MOSI, SCK, RESET, A0, nCS)
+
+bool alarm_stop_lcd = 0;
+
+// LCD 초기화
+void lcdInit();
+// LCD의 x, y 좌표에 str을 출력
+void writeLcdCLS(const char*, int, int);
+// LCD의 x, y 좌표에 str을 출력 cls (x)
+void writeLcd(const char*, int, int);
+// LCD에 digital clock 출력
+void writeTime();
+// LCD에 alarm 출력
+void writeAlarm();
+
+//================================ Alarm ================================
+Thread thread_Alarm;
+Timer timer;
+Timer trans_timer;
+
+int a_time = 0; // alarm 시간
+int a_time_temp = 0;
+
+int a_tm = 0;
+int a_hour = 0;
+int a_mins = 0;
+int a_sec = 0;
+
+int start_alarm = 0;
+int end_alarm = 0;
+
+
+int a_temp = 0;
+int a_temp_h = 0;
+int a_temp_m = 0;
+int a_temp_s = 0;
+
+// Timer 동작(thread)
+void timerSet();
+// Timer 초기화
+void timerReset();
+// alarm 설정
+void alarmSet();
+void alarmStart();
+void alarmCount();
+
+//================================ Clock ================================
+Thread thread_Clock;
+
+int c_hour = 0;
+int c_mins = 0;
+int c_sec = 0;
+
+//digital clock 초기화
+void clockInit();
+//현재 시각 가져옴
+void getTime();
+//digital clock 출력
+void writeTime();
+
+//================================ Joystick ================================
+InterruptIn up(A2);
+InterruptIn down(A3);
+InterruptIn left(A4);
+InterruptIn rite(A5);
+InterruptIn center(D4);
+InterruptIn sw2(SW2);
+InterruptIn sw3(SW3); // permanent 중지
+
+void ISR_center();
+void ISR_up();
+void ISR_down();
+void ISR_left();
+void ISR_rite();
+void ISR_sw2();
+
+void perm_Stop();
+
+    //main
+bool main_center = 0; 
+    
+    //communication
+bool com_left = 0;
+bool com_right = 0;
+bool com_center = 0;  
+    
+    //alarm set (알람 설정)
+bool alarm_set_up = 0;
+bool alarm_set_down = 0;
+bool alarm_set_left = 0;
+bool alarm_set_right = 0;
+bool alarm_set_center = 0; 
+
+    //alarm(다음 선택)
+bool alarm_left = 0;
+bool alarm_right = 0;
+bool alarm_center = 0;  
+    
+    //permanent
+bool perm_left = 0;
+bool perm_right = 0;
+bool perm_center = 0;  
+    
+    //common (마지막 layer들 뒤로가기 기능 통일)
+bool button_back = 0; //sw2 
+
+    //permanent 송신 중단
+bool perm_stop = 0;
+
+
+//================================ Communication ================================
+
+
+bool alarm_trans_status = 0;
+int alarm_trans_mode = 0;
+
+bool perm_trans_status = 0;
+int perm_trans_mode = 0;
+
+//=====================================
+//LCD
+
+void lcdPrint(){
+    switch(mbedMode){
+        case MAIN:
+            writeLcd("COMMUNICATION DEVICE", 0, 6);
+            writeTime();
+            if(main_center){
+                mbedMode = COM;
+                tempMode = ALARM_SET;
+                main_center = 0;
+                lcd.cls();
+            }
+            break;
+            
+        case COM:
+            if(alarm_stop_lcd){
+                writeLcdCLS("Alarm Mode is finished...", 0, 6);
+                thread_sleep_for(1500);
+                alarm_stop_lcd = 0;
+                lcd.cls();
+            }
+        
+            writeLcd("COMMUNICATION DEVICE", 0, 6);
+            writeLcd("Select", 0, 16);
+            
+            if(com_left || com_right){
+                if(tempMode == ALARM_SET){
+                    writeLcd("Select  Permanent          ", 0, 16);
+                    tempMode = PERM;
+                }else{
+                    writeLcd("Select  Alarm          ", 0, 16);
+                    tempMode = ALARM_SET;
+                }   
+                com_left = 0;
+                com_right = 0;
+            }else if(com_center){
+                mbedMode = tempMode;
+                
+                if(tempMode == ALARM_SET){
+                    if(perm_trans_status){
+                        mbedMode = COM;
+                        writeLcdCLS("Permanent mode is running...", 0, 6);
+                        thread_sleep_for(500);
+                        lcd.cls();
+                    }else if(alarm_trans_status){
+                        mbedMode = alarm_trans_mode;
+                    }else{
+                        tempMode = ALARM_SET;
+                    }
+                }else if(tempMode == PERM){
+                    if(alarm_trans_status){
+                        mbedMode = COM;
+                        writeLcdCLS("Alarm mode is running...", 0, 6);
+                        thread_sleep_for(500);
+                        lcd.cls();
+                    }else if(perm_trans_status){
+                        mbedMode = perm_trans_mode;
+                    }else{
+                        tempMode = PERM_SOUND;
+                    }
+                }
+                
+                lcd.cls();
+                com_center = 0;
+            }else if(button_back){
+                lcd.cls();
+                mbedMode = MAIN;
+                button_back = 0;
+            }
+            break;
+            
+        case ALARM_SET: // alarm_set_~
+            writeLcd("Alarm Set Mode", 0, 6);
+            alarmSet();
+            a_temp_h = a_temp / 3600;
+            a_temp %= 3600;
+            a_temp_m = a_temp / 60;
+            a_temp %= 60;
+            a_temp_s = a_temp;
+            lcd.locate(0, 16);
+            lcd.printf("Time = %d : %d : %d     ", a_temp_h, a_temp_m, a_temp_s);
+            if(alarm_set_center){
+                mbedMode = ALARM;
+                tempMode = ALARM_SOUND;
+                alarm_set_center = 0;
+                lcd.cls();   
+            }else if(button_back){
+                mbedMode = COM;
+                tempMode = ALARM_SET;
+                button_back = 0;
+                lcd.cls();
+            }
+            
+            break;
+        case ALARM: // alarm_~
+            writeLcd("Alarm Mode", 0, 6);
+            writeLcd("Select", 0, 16);
+            
+            if(alarm_left){
+                if(tempMode == ALARM_SOUND){
+                    writeLcd("Select  Sound+Led     ", 0, 16);
+                    tempMode = ALARM_SOUND_LED;   
+                }else if(tempMode == ALARM_LED){
+                    writeLcd("Select  Sound         ", 0, 16);
+                    tempMode = ALARM_SOUND;
+                }else if(tempMode == ALARM_SOUND_LED){
+                    writeLcd("Select  Led           ", 0, 16);
+                    tempMode = ALARM_LED;
+                }
+                alarm_left = 0;   
+            }else if(alarm_right){
+                if(tempMode == ALARM_SOUND){
+                    writeLcd("Select  Led            ", 0, 16);
+                    tempMode = ALARM_LED ;
+                }else if(tempMode == ALARM_LED){
+                    writeLcd("Select  Sound+Led      ", 0, 16);
+                    tempMode = ALARM_SOUND_LED;
+                }else if(tempMode == ALARM_SOUND_LED){
+                    writeLcd("Select  Sound          ", 0, 16);
+                    tempMode = ALARM_SOUND;
+                }
+                alarm_right = 0;
+            }else if(alarm_center){
+                alarmStart();
+                mbedMode = tempMode;
+                alarm_center = 0;
+                lcd.cls();
+            }else if(button_back){
+                mbedMode = ALARM_SET;
+                tempMode = ALARM_SET;
+                button_back = 0;
+                lcd.cls();
+            }
+            break;
+            
+        case PERM:
+            writeLcd("Permanent Mode         ", 0, 6);
+            writeLcd("Select", 0, 16);
+
+            if(button_back){
+                mbedMode = COM;
+                tempMode = PERM;
+                trans_status = 0;
+                button_back = 0;
+                lcd.cls();
+            }else if(perm_left){
+                if(tempMode == PERM_SOUND){
+                    writeLcd("Select  Sound+Led     ", 0, 16);
+                    tempMode = PERM_SOUND_LED;
+                }else if(tempMode == PERM_LED){
+                    writeLcd("Select  Sound         ", 0, 16);
+                    tempMode = PERM_SOUND;
+                }else if(tempMode == PERM_SOUND_LED){
+                    writeLcd("Select  Led           ", 0, 16);
+                    tempMode = PERM_LED;
+                }
+                perm_left = 0;
+            }else if(perm_right){
+                if(tempMode == PERM_SOUND){
+                    writeLcd("Select  Led           ", 0, 16);
+                    tempMode = PERM_LED;
+                }else if(tempMode == PERM_LED){
+                    writeLcd("Select  Sound+Led     ", 0, 16);
+                    tempMode = PERM_SOUND_LED;
+                }else if(tempMode == PERM_SOUND_LED){
+                    writeLcd("Select  Sound         ", 0, 16);
+                    tempMode = PERM_SOUND;
+                }
+                perm_right = 0;
+            }else if(perm_center){
+                mbedMode = tempMode;
+                lcd.cls();
+                perm_center = 0;   
+            }
+            break;
+        
+        case ALARM_SOUND:
+            writeLcd("Alarm Sound Mode      ", 0, 6);
+            writeAlarm();
+            
+            if(!alarm_trans_status){
+                alarm_trans_status = 1;
+                alarm_trans_mode = ALARM_SOUND;
+                thread_sleep_for(1000);
+                writeLcdCLS("Not Supported", 0, 6);
+                alarmStart();
+            }
+            
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = ALARM_SET;
+                lcd.cls();
+                button_back = 0;
+            }
+            break;
+            
+        case ALARM_LED:
+            writeLcd("Alarm Led Mode        ", 0, 6);
+            writeAlarm();
+            
+            if(!alarm_trans_status){  
+                alarm_trans_status = 1;
+                alarm_trans_mode = ALARM_LED;
+                alarmStart();
+                //send_count = 1;
+                //if(!send_count){
+                    //mutex.lock();
+                    //send_count=1;
+                    send(led, sensor);
+                    //mutex.unlock();
+                //}
+
+            }
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = ALARM_SET;
+                lcd.cls();
+                button_back = 0;   
+            }
+            
+            break;
+            
+        case ALARM_SOUND_LED:
+            writeLcd("Alarm Sound+Led Mode      ", 0, 6);
+            writeAlarm();
+        
+            if(!alarm_trans_status){ 
+                alarm_trans_status = 1;
+                alarm_trans_mode = ALARM_SOUND_LED;
+                alarmStart();
+                thread_sleep_for(1000);
+                writeLcdCLS("Not Supported      ", 0, 6);
+            }
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = ALARM_SET;
+                lcd.cls();
+                button_back = 0;
+            }
+            break;
+            
+        case ALARM_ERROR:
+            writeLcd("Error                 ", 0, 6);
+            writeLcd("Please Push Back Button", 0, 16);
+            if(button_back){
+                tempMode = ALARM_SET;
+                mbedMode = COM;
+                button_back = 0;
+            }
+            break;
+            
+        case PERM_SOUND:
+            writeLcd("Permanent Sound Mode      ", 0, 6);
+            
+            if(!perm_trans_status){
+                perm_trans_status = 1;
+                perm_trans_mode = PERM_SOUND;
+                writeLcd("Not Supported         ", 0, 16);
+            }
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = PERM;
+                button_back = 0;
+                lcd.cls();   
+            }
+            
+            if(perm_stop){
+                perm_Stop();
+                perm_stop = 0;
+            }
+            
+            break;
+            
+        case PERM_LED:
+            writeLcd("Permanent Led Mode        ", 0, 6);
+            
+            if(!perm_trans_status){
+                perm_trans_status = 1;
+                perm_trans_mode = PERM_LED; 
+                mutex.lock();  
+                writeLcd("Receiving...          ", 0, 16);
+                recv(led, sensor); 
+                mutex.unlock();
+            }
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = PERM;
+                button_back = 0;
+                lcd.cls();   
+            }
+            
+            if(perm_stop){
+                perm_Stop(); 
+                perm_stop = 0;
+            }
+            
+            break;
+            
+        case PERM_SOUND_LED:
+            writeLcd("Permanent Sound+Led Mode  ", 0, 6);
+            
+            if(!perm_trans_status){
+                perm_trans_status = 1;
+                perm_trans_mode = PERM_SOUND_LED; 
+                writeLcd("Not Supported         ", 0, 16);
+            }
+            
+            if(button_back){
+                mbedMode = COM;
+                tempMode = PERM;
+                button_back = 0;
+                lcd.cls();   
+            }
+            
+            if(perm_stop){
+                perm_Stop();   
+                perm_stop = 0;
+            }
+            
+            break;
+            
+        case PERM_ERROR:
+            writeLcd("Error                 ", 0, 6);
+            writeLcd("Please Push Back Button", 0, 16);
+            if(button_back){
+                tempMode = PERM;
+                mbedMode = COM;
+                button_back = 0;
+            }
+            break;
+            
+        default:
+            break;   
+    }        
+}
+
+void writeLcdCLS(const char* str, int x, int y){
+    lcd.locate(x, y);
+    lcd.cls();
+    lcd.printf("%s", str);
+}
+
+void writeLcd(const char* str, int x, int y){
+    lcd.locate(x, y);
+    lcd.printf("%s", str);   
+}
+
+
+void lcdStart(){
+    while(true){
+        lcdPrint();
+    }   
+}
+
+//=====================================
+//ALARM
+
+void alarmSet(){
+    a_temp = a_time;
+    if(alarm_set_up){// +1시간
+        if(a_time < 82800){
+            a_time += 3600;
+        }else{
+            a_time -= 86400;
+            a_time += 3600;
+        }
+        alarm_set_up = 0;
+    }else if(alarm_set_down){// -1시간
+        if(a_time >= 3600){
+            a_time -= 3600;   
+        }else{
+            a_time += 86400;
+            a_time -= 3600;
+        }
+        alarm_set_down = 0;
+    }else if(alarm_set_left){// +1분
+        if(a_time < 86340){
+            a_time += 60;
+        }else{
+            a_time -= 86400;
+            a_time += 60;          
+        }
+        alarm_set_left = 0;
+    }else if(alarm_set_right){// -1분
+        if(a_time >= 60){
+            a_time -= 60;   
+        }else{
+            a_time += 86400;
+            a_time -= 60;
+        }
+        alarm_set_right = 0;
+    }
+}
+
+void alarmReset(){
+    a_time = 0;
+    a_hour = 0;
+    a_mins = 0;
+    a_sec = 0;
+    a_tm = 0;
+    a_temp = 0;
+    a_time_temp = 0;
+    end_alarm = 0;
+    start_alarm = 0;
+    send_count = 0;
+    alarm_trans_status = 0;
+    alarm_trans_mode = 0;
+    mbedMode = COM;
+    tempMode = ALARM_SET;
+    alarm_stop_lcd = 1;
+    timer.stop();
+    timer.reset();
+}
+
+
+void alarmCount(){
+    while(true){
+        if(alarm_trans_status){
+            a_tm = timer.read();
+            a_time_temp = a_time - a_tm - (end_alarm - start_alarm);
+            
+            
+            if(a_time_temp > 0 && alarm_trans_status){
+                a_hour = a_time_temp / 3600;
+                a_time_temp = a_time_temp % 3600;
+                a_mins = a_time_temp / 60;
+                a_time_temp = a_time_temp % 60;
+                a_sec = a_time_temp;
+                thread_sleep_for(1000);           
+            }else if(a_time_temp == 0 && alarm_trans_status){
+                alarmReset();
+            }
+            
+        }
+    }
+}
+
+void alarmStart(){
+    timer.reset();
+    timer.start();
+    thread_sleep_for(100);
+    thread_Alarm.start(alarmCount);
+}
+
+void writeAlarm(){
+    lcd.locate(0, 16);
+    lcd.printf("Time Left: %d:%d:%d             ", a_hour, a_mins, a_sec);
+}
+
+//=====================================
+//CLOCK
+
+void clockInit(){
+    //thread_Clock.start(getTime);
+}
+
+int i;
+int j;
+
+void getTime(){
+
+        PC.printf("%s\r\n", esp_arr);
+    
+        for(i = 0; i < 10; i++){
+            if(esp_arr[i] == 't' && esp_arr[i+1] == 'i' && esp_arr[i+2] == 'm' && esp_arr[i+3] == 'e'){
+                j = 0;
+                while(esp_arr[i] != 'H' && esp_arr[i] !='\0' && i != 20){
+                    arr_time[j++] = esp_arr[i++];
+                }
+                arr_time[j] = '\0';
+                break;
+            }
+        }
+        
+        PC.printf("%s\r\n", arr_time);
+    
+}
+
+void writeTime(){
+    getTime();
+    lcd.locate(0, 16);
+    lcd.printf("%s", arr_time);
+    thread_sleep_for(500);
+}
+
+
+//=====================================
+//JOYSTICK
+
+void ISR_center(){
+    switch(mbedMode){
+        case MAIN:
+            main_center = 1;
+            break;
+        case COM:
+            com_center = 1;
+            break;
+        case ALARM:
+            alarm_center = 1;
+            break;
+        case ALARM_SET:
+            alarm_set_center = 1;
+            break;
+        case PERM:
+            perm_center = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+void ISR_up(){
+    switch(mbedMode){
+        case ALARM_SET:
+            alarm_set_up = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+void ISR_down(){
+    switch(mbedMode){
+        case ALARM_SET:
+            alarm_set_down = 1;
+            break;
+        default:
+            break;   
+    }
+}
+
+void ISR_left(){
+    switch(mbedMode){
+        case COM:
+            com_left = 1;
+            break;
+        case ALARM:
+            alarm_left = 1;
+            break;
+        case ALARM_SET:
+            alarm_set_left = 1;
+            break;
+        case PERM:
+            perm_left = 1;
+            break;
+        default:
+            break;   
+    }
+}
+
+void ISR_rite(){
+    switch(mbedMode){
+        case COM:
+            com_right = 1;
+            break;
+        case ALARM_SET:
+            alarm_set_right = 1;
+            break;
+        case ALARM:
+            alarm_right = 1;
+            break;
+        case PERM:
+            perm_right = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+void ISR_sw2(){
+    switch(mbedMode){
+        case COM:
+        case ALARM:
+        case ALARM_SET:
+        case ALARM_SOUND:
+        case ALARM_LED:
+        case ALARM_SOUND_LED:
+        case PERM:
+        case PERM_SOUND:
+        case PERM_LED:
+        case PERM_SOUND_LED:
+            button_back = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+void ISR_sw3(){
+    switch(mbedMode){
+        case PERM_SOUND:
+        case PERM_LED:
+        case PERM_SOUND_LED:
+            perm_stop = 1;
+            break;
+        default:
+            break;
+    }
+}
+
+void joyInit(){
+     up.rise(&ISR_up);
+     down.rise(&ISR_down);
+     left.rise(&ISR_left);
+     rite.rise(&ISR_rite);
+     center.rise(&ISR_center);
+     
+     sw2.fall(&ISR_sw2);  
+     sw3.fall(&ISR_sw3);
+}
+
+void perm_Stop(){
+    mbedMode = COM;
+    tempMode = PERM;
+    perm_stop = 1;
+    writeLcdCLS("Permanent Stop...", 0, 16);
+    perm_trans_status = 0;
+    perm_trans_mode = 0;
+    thread_sleep_for(1500);
+    lcd.cls();   
+}
+
+//================================ NodeMCU program ================================
+NodeMCU_PGM http_server[] = { 
+    "", 1,
+    "wifi.setmode(wifi.STATION)", 1,
+    "", 1,
+    "station_cfg={}", 1,
+    "station_cfg.ssid=\"IP_S\"", 1,
+    "station_cfg.pwd=\"1kokrjg3un7i4\"", 1,
+    "station_cfg.save=false", 1,
+    "wifi.sta.config(station_cfg)", 1,
+    "", 1,
+    "wifi.sta.connect()", 80,
+    "", 1,
+    "print(wifi.sta.status())", 1,
+    "print(wifi.sta.getip())", 1,
+    "", 1,
+    "", 1,
+    "http_resp = \"HTTP/1.0 200 OK\\r\\nContent-Type: text/html\\r\\n\\r\\n\"", 1,    
+    "html_1 = \"<!DOCTYPE html>\"", 1,
+    "html_2 = \"<html lang=\\\"ko\\\">\"", 1,
+    "html_3 = \"<head>\"", 1,
+    "html_4 = \"    <meta charset=\\\"UTF-8\\\">\"", 1,
+    "html_5 = \"    <title>clock1</title>\"", 1,
+    "html_6 = \"</head>\"", 1,
+    "html_7 = \"<body>\"", 1,
+    "html_8 = \"    <h1 id=\\\"clock\\\" style=\\\"color:black;\\\">clock</h1>\"", 1,
+    "", 1,
+    "html_9 = \"    <script>\"", 1,
+    "html_10 = \"       function clock() {\"", 1,
+    "html_11 = \"           var time = new Date();\"", 1,
+    "", 1,
+    "html_12 = \"           var hours = time.getHours();\"", 1,
+    "html_13 = \"           var minutes = time.getMinutes();\"", 1,
+    "html_14 = \"           var seconds = time.getSeconds();\"", 1,
+    "", 1,
+    "html_text = \"         Target.innerText = `${hours < 10 ? `0${hours}` : hours}:${minutes < 10 ? `0${minutes}` : minutes}:${seconds < 10 ? `0${seconds}` : seconds}`;\"", 1,
+    "html_15 = \"           location.replace(\\\"http://172.20.10.6\\\"+\\\"/?time=\\\"+hours.toString()+\\\":\\\"+minutes.toString()+\\\":\\\"+seconds.toString());\"", 1,
+    "", 1,         
+    "html_16 = \"        }\"", 1,
+    "html_17 = \"        setInterval(clock, 1000);\"", 1,
+    "html_18 = \"    </script>\"", 1,
+    "html_19 = \"</body>\"", 1,
+    "html_20 = \"</html>\"", 1,
+    "", 1,
+    "", 1,
+    "srv = net.createServer(net.TCP)", 1,
+    "srv:listen(80, function(conn)", 1,
+    "   conn:on(\"receive\", function(sck, payload)", 1,
+    "       print(payload)", 1,
+    "       sck:send(http_resp)", 1,
+    "       sck:send(html_1)", 1,
+    "       sck:send(html_2)", 1,
+    "       sck:send(html_3)", 1,
+    "       sck:send(html_4)", 1,
+    "       sck:send(html_5)", 1,
+    "       sck:send(html_6)", 1,
+    "       sck:send(html_7)", 1,
+    "       sck:send(html_8)", 1,
+    "       sck:send(html_9)", 1,
+    "       sck:send(html_10)", 1,
+    "       sck:send(html_11)", 1,
+    "       sck:send(html_12)", 1,
+    "       sck:send(html_13)", 1,
+    "       sck:send(html_14)", 1,
+    //"       sck:send(html_text)", 1,
+    "       sck:send(html_15)", 1,
+    "       sck:send(html_16)", 1,
+    "       sck:send(html_17)", 1,
+    "       sck:send(html_18)", 1,
+    "       sck:send(html_19)", 1,
+    "       sck:send(html_20)", 1,
+    "       end)", 1,
+    "   conn:on(\"sent\", function(sck) sck:close() end)", 1,
+    "end)", 1,
+    NULL, 0,
+};
+
+void receive_Data(){
+    
+    esp_data = ESP.getc();
+    
+    if(index < 20){
+        esp_arr[index++] = esp_data;    
+    }else if(index == 20){
+        esp_arr[index] = '\0';
+    }
+
+}
+
+void time_get(){
+    
+    index = 0;
+}
+
+void ledSet(){
+    while(true){
+        while(perm_trans_status || alarm_trans_status){
+            led_r = 1;
+            led_g = 0;
+            thread_sleep_for(100);
+            led_g = 1;
+            thread_sleep_for(100);
+        }
+        led_r = 0;
+        led_g = 1; 
+    }   
+}
+
+//==========================================================================
+//main
+int main(){
+    
+    writeLcdCLS("Starting...           ", 24, 6);
+    
+    ESP.baud(115200);
+    PC.baud(115200);
+    
+    pc.printf("\r\nReset ESP...\r\n"); 
+    ESP_reset();
+
+    PC.printf("Setup ESP noecho...\r\n"); 
+    ESP_noecho();
+    
+    PC.printf("Execute a NodeMCU program...\r\n"); 
+    ESP_call_multi(http_server);
+    
+    PC.printf("\r\nESP receive mode...\r\n");
+    ESP.attach(receive_Data, Serial::RxIrq);
+    
+    ticker.attach(&time_get, 1.0);
+    
+    clockInit();
+    thread_led.start(ledSet);
+    thread_lcd.start(lcdStart);
+    joyInit();
+ 
+    thread_sleep_for(500);
+
+    while(true){  
+        
+    }
+}
\ No newline at end of file

diff -r 000000000000 -r 78de368300ec mbed-os.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-os.lib	Mon Jun 13 13:56:52 2022 +0000
@@ -0,0 +1,1 @@
+https://github.com/armmbed/mbed-os/#cf4f12a123c05fcae83fc56d76442015cb8a39e9