66669
外部入力情報を検知しLTE通信にて通知する仕組みを制作してます。  
void setup()にて初回に外部入力情報をLTE通信にて通知し、その後は外部入力の状態が変わった場合に  
通知するようにしたいのですが、起動後数分経過（どれくらいの経過かは傾向を掴めてません）した後に  
外部入力の状態が変わった場合に、void setup()の処理が実行されます。  
void setup()はあくまでも電源ON時のみ実行としたいのですが、どうすればよいでしょうか？  
＜開発環境＞  
・Arduino IDE

＜ソースコード＞  
暫く時間が経過した後にピンの状態を変化させると、void setup()が処理され、// 監視開始、初期通知送信
notify_process();にて初期通知がされます。void setup()の処理はあくまでも初回のみ実行とする方法があるのでしょうか？

```

    #include <ArduinoHttpClient.h>
    #include <SDHCI.h>
    #include <LTE.h>
    
    // APN data
    char lte_apn[50];
    char lte_user_name[50];
    char lte_password[50];
    
    // LINE Token
    String notify_token;
    
    // URL, path & port (for example: httpbin.org)
    char server[] = "notify-api.line.me";
    char postPath[] = "/api/notify";
    int port = 443; // port 443 is the default for HTTPS
    
    #define ROOTCA_FILE "ROOT/line-me.pem"
    #define TOKEN_FILE "TOKEN/token.txt"
    #define APNDATA_FILE "SYS/apndata.txt"
    
    // initialize the library instance
    LTE lteAccess;
    LTETLSClient tlsClient;
    HttpClient client = HttpClient(tlsClient, server, port);
    SDClass theSD;
    
    //ピン入力の前情報を保持
    int prev_PIN_PWM[10];
    
    //ピンヘッダ番号
    const int input0 = 2;
    const int input1 = 6;
    const int input2 = 5;
    const int input3 = 9;
    const int input4 = 3;
    const int input5 = 29;
    const int input6 = 30;
    const int input7 = 31;
    const int input8 = 32;
    const int input9 = 7;
    
    void setup()
    {
      // 初期化
      Serial.begin(115200);
    
      pinMode(LED0, OUTPUT);
      pinMode(input0, INPUT);
      pinMode(input1, INPUT);
      pinMode(input2, INPUT);
      pinMode(input3, INPUT);
      pinMode(input4, INPUT);
      pinMode(input5, INPUT);
      pinMode(input6, INPUT);
      pinMode(input7, INPUT);
      pinMode(input8, INPUT);
      pinMode(input9, INPUT);
    
      prev_PIN_PWM[0] = digitalRead(input0);
      prev_PIN_PWM[1] = digitalRead(input1);
      prev_PIN_PWM[2] = digitalRead(input2);
      prev_PIN_PWM[3] = digitalRead(input3);
      prev_PIN_PWM[4] = digitalRead(input4);
      prev_PIN_PWM[5] = digitalRead(input5);
      prev_PIN_PWM[6] = digitalRead(input6);
      prev_PIN_PWM[7] = digitalRead(input7);
      prev_PIN_PWM[8] = digitalRead(input8);
      prev_PIN_PWM[9] = digitalRead(input9);
    
      while (!theSD.begin()) {
        ; 
      }
    
      // SDカードから証明書ファイルを読み込む
      File rootCertsFile = theSD.open(ROOTCA_FILE, FILE_READ);
      tlsClient.setCACert(rootCertsFile, rootCertsFile.available());
      rootCertsFile.close();
    
      // SDカードからapndata情報を読み込む
      getApndata();  
      // SDカードからTOKEN情報を読み込む
      notify_token = getToken();
    
      // 監視開始、初期通知送信
      notify_process();
    
    }
    
    String getToken(){
    
      // SDカードからTOKEN情報を読み込む
      File tokenDataFile = theSD.open(TOKEN_FILE);
      String str;
      // もしファイルが開けたら
      if (tokenDataFile) {
            //---1byteずつ読み込んだ文字を結合
            while (tokenDataFile.available()) {
                str += char(tokenDataFile.read());
            }
        } else{
            Serial.println("tokenDataFile error");
        }  
      //---ファイルを閉じる
      tokenDataFile.close();
      return(str);
    }
    
    void getApndata(){
    
      // SDカードからapndata情報を読み込む
      File apndataFile = theSD.open(APNDATA_FILE);
      String str;
      String cmds[3] = {"\0"}; // 分割された文字列を格納する配列 
    
      // もしファイルが開けたら
      if (apndataFile) {
            //---1byteずつ読み込んだ文字を結合
            while (apndataFile.available()) {
                str += char(apndataFile.read());
            }
    
            // 分割数 = 分割処理(文字列, 区切り文字, 配列) 
            int index = split(str, ',', cmds);
      } else{
          Serial.println("apndataFile error");
      }
    
      cmds[0].toCharArray(lte_apn, 50);
      cmds[1].toCharArray(lte_user_name, 50);
      cmds[2].toCharArray(lte_password, 50);
    
      //---ファイルを閉じる
      apndataFile.close();
    
    }
    
    int split(String data, char delimiter, String *dst){
        int index = 0;
        int arraySize = (sizeof(data)/sizeof((data)[0]));  
        int datalength = data.length();
        for (int i = 0; i < datalength; i++) {
            char tmp = data.charAt(i);
            if ( tmp == delimiter ) {
                index++;
                if ( index > (arraySize - 1)) return -1;
            }
            else dst[index] += tmp;
        }
        return (index + 1);
    }
    
    void send_line_process(String message)
    {
    
      digitalWrite(LED0, HIGH);  
      send_line_notify(message);
      digitalWrite(LED0, LOW);      
      sleep(1);
    
    }
    
    void send_line_notify(String message) {
    
      // LTE接続開始
      while (true) {
        if (lteAccess.begin() == LTE_SEARCHING) {
          if (lteAccess.attach(lte_apn, lte_user_name, lte_password) == LTE_READY) {
            Serial.println("lte success");
            break;
          }
          Serial.println("lte error");
          lteAccess.shutdown();
          sleep(1);
        }
      }
    
      // 送信データ準備
      String contentType = "application/x-www-form-urlencoded\nAuthorization: Bearer " + String(notify_token);
      String postData = "message=" + String(message);
    
      // HTTPS POST送信
      client.post(postPath, contentType, postData);
    
      // 応答コードを表示
      int statusCode = client.responseStatusCode();
      String response = client.responseBody();
    
      Serial.println("Status code:" + String(statusCode));
      Serial.println("Response:" + response);
    
      // LTE接続停止
      Serial.println("lte disconnecting");
    
      client.stop();
      lteAccess.shutdown();
    
    }
    
    int check_contact(int cur_PIN,int prev_PIN) {
    
      boolean notice_err = false;
      boolean notice_rec = false;
      String msg;
    
      //状態が変化した場合
      if (cur_PIN != prev_PIN) {
        // 接点がON（エラー）またはOFF（復帰）になったら通知
        if (cur_PIN == 0) {
          notice_err = true;
        } else if (cur_PIN == 1) {
          notice_rec = true;
        } 
    
        if (notice_err == true){
          msg = "ERROR NOTIFY";
          send_line_process(msg);
        } else if (notice_rec == true){
          msg = "RETURN NOTIFY";
          send_line_process(msg);
        }
    
        prev_PIN = cur_PIN;
      }
      return prev_PIN;
    }
    
    String check_contact_reg(int cur_PIN) {
    
      boolean notice_err = false;
      boolean notice_rec = false;
      String msg;
    
      if (cur_PIN == 0) {
        notice_err = true;
      } else if (cur_PIN == 1) {
        notice_rec = true;
      } 
    
      if (notice_err == true){
        msg += "ERROR";      
      } else if (notice_err == false) {
        msg += "OK";      
      }    
      return msg;
    }
    
    void notify_process()
    {
    
      String msg;
    
      // curSW 0…ON 1…OFF
      int cur_PIN_PWM[10];
      cur_PIN_PWM[0] = digitalRead(input0);
      cur_PIN_PWM[1] = digitalRead(input1);
      cur_PIN_PWM[2] = digitalRead(input2);
      cur_PIN_PWM[3] = digitalRead(input3);
      cur_PIN_PWM[4] = digitalRead(input4);
      cur_PIN_PWM[5] = digitalRead(input5);
      cur_PIN_PWM[6] = digitalRead(input6);
      cur_PIN_PWM[7] = digitalRead(input7);
      cur_PIN_PWM[8] = digitalRead(input8);
      cur_PIN_PWM[9] = digitalRead(input9);
    
      msg = "INITIAL NOTIFY";    
    
      for(int i = 0; i < 10; i++){
        msg += "\n";
        msg += check_contact_reg(cur_PIN_PWM[i]);
      }
    
      send_line_process(msg); 
    
    }
    
    void loop()
    {
    
      // curSW 0…ON 1…OFF
      int cur_PIN_PWM[10];
      cur_PIN_PWM[0] = digitalRead(input0);
      cur_PIN_PWM[1] = digitalRead(input1);
      cur_PIN_PWM[2] = digitalRead(input2);
      cur_PIN_PWM[3] = digitalRead(input3);
      cur_PIN_PWM[4] = digitalRead(input4);
      cur_PIN_PWM[5] = digitalRead(input5);
      cur_PIN_PWM[6] = digitalRead(input6);
      cur_PIN_PWM[7] = digitalRead(input7);
      cur_PIN_PWM[8] = digitalRead(input8);
      cur_PIN_PWM[9] = digitalRead(input9);
    
      for(int i = 0; i < 10; i++){
        prev_PIN_PWM[i] = check_contact(cur_PIN_PWM[i],prev_PIN_PWM[i]);
      }
    
      sleep(1);
    
    }
    
```
CC BY-SA 4.0
2020-05-15T22:19:17.290
66650
2020-05-16T11:45:40.600
2020-05-16T06:44:55.920
3068
40166
question
spresense
void setup()が繰り返し実行される
setupが実行される、のではなくて、CPUがリセットされる、あるいは、プログラムが暴走して最初から実行される、のではないでしょうか。

信号の変化でそうなるという場合は、まずはそれによりリセット信号が影響されないか、あるいは電源電流の変化などで、電源電圧がドロップしないかなど、ハードウエア上での検討が必要となります。

電源はなにを使ってるのでしょうか。
CC BY-SA 4.0
2020-05-16T11:22:23.693
66669
2020-05-16T11:22:23.693
27481
66650
answer