Core 1 panic'ed (Interrupt wdt timeout on CPU1)

Hi,
Im beginner here. Ive a problem with my thesis, my cod have a problem when dc motor run.

I think the error is in the call " void IRAM_ATTR CONTA_PULSO()" >>line 238

  1. #include <Wire.h> //Utilizado para comunicação I2C

  2. #include <LiquidCrystal_I2C.h> //biblioteca responsável pelo controle do display

  3. #include <Arduino.h> //Bibliotecas arduino

  4. #include <analogWrite.h> //Utilizado para fazer o esp32 poder ter pino analogico

  5. #include “PID_v1.h” //Biblioteca utilizada para fazer controle PID

  6. #include “Adafruit_VL53L0X.h” //Biblioteca com funções do sensor VL53L0X

  7. #include <Servo.h> //Biblioteca responsavel pelo funcionamento do servo motor

  8. Servo myservo; //Definição do nome do servo motor

  9. Adafruit_VL53L0X lox = Adafruit_VL53L0X(); //Definição do sensor

  10. VL53L0X_RangingMeasurementData_t measure; //Modo de utilização do senor VL53L0X

  11. LiquidCrystal_I2C lcd(0x27, 16, 2); //set the LCD address to 0x27 for a 16 chars and 2 line display

  12. //=================================================================

  13. //

  14. // — Mapeamento de Hardware —

  15. //

  16. //=================================================================

  17. #define ZERA_SSD 34

  18. #define PLAY_PAUSE 35

  19. #define EN 25

  20. #define servo_pin 13

  21. #define encoder_C1 32

  22. #define encoder_C2 33

  23. #define servo_pin 13

  24. #define INCLUDE_vTaskDelayUntil 1

  25. #define INCLUDE_vTaskDelay 1

  26. // ===================================================================

  27. //

  28. // —Definição de constantes —

  29. //

  30. // ===================================================================

  31. #define tempo_de_delay 50 //Definição de delay

  32. #define um_segundo 1000 //Definição de um segundo

  33. #define t_captacao 10 //tempo de captação de dados

  34. #define degrau 104 //Entrada r(t)

  35. #define pulsos_por_volta 516 //define pulsos_por_volta 516

  36. #define voltas_maxima 10 //Número de voltas máxima

  37. //=================================================================

  38. //

  39. // — Structs parametros —

  40. //

  41. typedef struct { //Struct com parametros para task MOTOR_ON

  42. uint8_t d_T_CAPTACAO, d_ENABLE, d_DEGRAU, d_VOLTAS_MAXIMA;

  43. uint16_t d_PULSO_POR_VOLTA;

  44. int voltas;

  45. double Setpoint, Input, Output;

  46. long d_pulse_number, aux_pulse_number;

  47. int d_PLAY_PAUSE;

  48. int d_ZERA_SSD;

  49. } d_MOTOR_ON;

  50. typedef struct { //Struct com parametros para task LEITURA

  51. uint8_t v;

  52. int flag_PLAY_PAUSE;

  53. int voltas;

  54. int pos;

  55. } d_LEITURA;

  56. //=================================================================

  57. //

  58. // — Variáveis Globais —

  59. //

  60. //=================================================================

  61. //variaveis que indicam o núcleo

  62. static uint8_t taskCoreZero = 0;

  63. static uint8_t taskCoreOne = 1;

  64. //Posicao inicial sensor

  65. int pos = 0;

  66. //Flags dos botões

  67. int flag_ZERA_SSD = HIGH;

  68. int flag_PLAY_PAUSE = LOW;

  69. //Variáveis de controle do motor

  70. long pulse_number = 0;

  71. int voltas = 0;

  72. //Variáveis do Controlador

  73. double Setpoint, Input, Output;

  74. long aux_pulse_number = 0;

  75. bool flag_pulse_number = false;

  76. //================================================================

  77. //

  78. // — Inicialização myPID —

  79. //

  80. //================================================================

  81. PID myPID(&Input, &Output, &Setpoint, 11.55, 0.1, 0, DIRECT);

  82. //================================================================

  83. //

  84. // — Declaração de funções —

  85. //

  86. //================================================================

  87. void debounce_PLAY_PAUSE( void * pvParameters );

  88. void debounce_ZERA_SSD( void * pvParameters );

  89. void IRAM_ATTR CONTA_PULSO();

  90. void VERIFICA_PULSO();

  91. void motor_ON( void * pvParameters );

  92. void LEITURA(void * pvParameters);

  93. void setup() {

  94. Serial.begin(9600);

  95. while (! Serial) {
    
  96. delay(1);
    
  97. }

  98. Serial.println("Adafruit VL53L0X test");
    
  99. if (!lox.begin()) {

  100. Serial.println(F("Failed to boot VL53L0X"));
    
  101. while(1);
    
  102. }

  103. lcd.init();

  104. lcd.backlight();

  105. pinMode(ZERA_SSD, INPUT); //Resistencia interna

  106. pinMode(PLAY_PAUSE, INPUT); //Resistencia interna

  107. pinMode(EN, OUTPUT); //Pinos do motor

  108. pinMode(encoder_C1, INPUT); //Configura entrada C1 para leitura do encoder

  109. pinMode(encoder_C2, INPUT); //Configura entrada C2 para leitura do encoder

  110. //Interrupção externa por borda de subida

  111. attachInterrupt(encoder_C1,CONTA_PULSO, RISING);

  112. lcd.print(“VOLTAS:”);

  113. lcd.setCursor(8, 0);

  114. lcd.print(voltas);

  115. Setpoint = 10.45; // r(t) ajustado

  116. myPID.SetMode(AUTOMATIC);//Configuração para modo automatico

  117. myPID.SetSampleTime(10); // Computa controlador a cada 10 ms

  118. Input = aux_pulse_number; //Inicializa entrada

  119. myservo.attach(servo_pin); //Pino PWM do servo motor;

  120. d_MOTOR_ON MOTOR = {

  121. .d_T_CAPTACAO = t_captacao,
    
  122. .d_ENABLE = EN,
    
  123. .d_DEGRAU = degrau,
    
  124. .d_VOLTAS_MAXIMA = voltas_maxima,
    
  125. .d_PULSO_POR_VOLTA = pulsos_por_volta,
    
  126. .voltas = voltas,
    
  127. .Setpoint = Setpoint,
    
  128. .Input = Input,
    
  129. .Output = Output,
    
  130. .d_pulse_number = pulse_number,
    
  131. .aux_pulse_number = aux_pulse_number,
    
  132. .d_PLAY_PAUSE = flag_PLAY_PAUSE,
    
  133. .d_ZERA_SSD = flag_ZERA_SSD
    
  134. };

  135. d_LEITURA LEITURA_SENSOR = {

  136. .v = voltas_maxima,
    
  137. .flag_PLAY_PAUSE = flag_PLAY_PAUSE,
    
  138. .voltas = voltas,
    
  139. .pos = pos
    
  140. };

  141. xTaskCreatePinnedToCore(debounce_PLAY_PAUSE, “debounce_PLAY_PAUSE”,10000, &flag_PLAY_PAUSE, 1, NULL, taskCoreZero);

  142. delay(500); //tempo para a tarefa iniciar

  143. xTaskCreatePinnedToCore(debounce_ZERA_SSD, “debounce_ZERA_SSD”, 10000,&flag_ZERA_SSD, 1, NULL, taskCoreZero);

  144. delay(500); //tempo para a tarefa iniciar

  145. xTaskCreatePinnedToCore(LEITURA, “LEITURA”, 20000, &LEITURA_SENSOR, 2, NULL, taskCoreZero);

  146. delay(500); //tempo para a tarefa iniciar

  147. xTaskCreatePinnedToCore(motor_ON, “motor_ON”,20000, &MOTOR,2, NULL, taskCoreOne);

  148. delay(500); //tempo para a tarefa iniciar

  149. Serial.println(“0”);

  150. }

  151. void loop(){

  152. vTaskDelete(NULL);

  153. }

  154. void debounce_PLAY_PAUSE( void * pvParameters ){//OK

  155. static int last_state = HIGH;

  156. static int state;

  157. while(1){

  158. TickType_t xLastWakeTime;

  159. const TickType_t xFrequency = 50;

  160. xLastWakeTime = xTaskGetTickCount();

  161. //Variáveis para debounce

  162. vTaskDelayUntil( &xLastWakeTime, xFrequency );

  163. int reading = digitalRead(PLAY_PAUSE); //guarda leitura do botão A3

  164. static unsigned long guarda_millis = millis();//guarda tempo inicial

  165. if (reading != last_state) { //testa se botao mudou de estado

  166. //inicia contador para debounce
    
  167. guarda_millis = millis();
    
  168. }

  169. //Primeiro degrau

  170. if ((millis() - guarda_millis) > tempo_de_delay) { //testa se deu o

  171. //tempo de delay de 50 milisegundos
    
  172. //Caso verdade
    
  173. if (reading != state) { //Testa se botão mudou
    
  174.   //Caso verdade
    
  175.   state = reading; //Estado recebe leitura
    
  176.   if (state == HIGH) { //Testa se foi borda de subida
    
  177.     //Condição para botão pressionado
    
  178.     flag_PLAY_PAUSE = !flag_PLAY_PAUSE;
    
  179.   }
    
  180. }
    
  181. }

  182. last_state = reading; //Último estado recebe leitura mais recente

  183. }

  184. }

  185. void debounce_ZERA_SSD( void * pvParameters ) {//OK

  186. TickType_t xLastWakeTime;

  187. const TickType_t xFrequency = 50;

  188. xLastWakeTime = xTaskGetTickCount();

  189. static int last_state = HIGH;

  190. static int state;

  191. while(1){

  192. vTaskDelayUntil( &xLastWakeTime, xFrequency );

  193. int reading = digitalRead(ZERA_SSD); //Guarda leitura do botão

  194. static unsigned long guarda_millis = millis();//Guarda tempo

  195. //inicial

  196. if (reading != last_state) { //Testa se botão mudou de estado

  197. //Inicia contador para debounce
    
  198. guarda_millis = millis();
    
  199. }

  200. //Primeiro degrau

  201. if ((millis() - guarda_millis) > tempo_de_delay) { //Testa se deu o

  202. //tempo de delay de 50 milisegundos
    
  203. //Caso verdade
    
  204. if (reading != state) //Testa se botao mudou
    
  205. { //Caso verdade
    
  206.   state = reading; //Estado recebe leitura
    
  207.   if (state == HIGH) { //Testa se foi borda de subida
    
  208.     //Condição para botão pressionado
    
  209.     flag_ZERA_SSD = HIGH;
    
  210.   }
    
  211. }
    
  212. }

  213. last_state = reading;

  214. if (flag_ZERA_SSD == LOW) {

  215. //Abaixa flag que será tratada
    
  216. flag_ZERA_SSD = HIGH;
    
  217. //Reinicia contagem caso motor desativado
    
  218. Serial.println("**5.5**");
    
  219. if (flag_PLAY_PAUSE == HIGH) {
    
  220.   //Zera variáveis
    
  221.   voltas = 0;
    
  222.   pulse_number = 0;
    
  223.   //Zera display
    
  224.   lcd.clear();
    
  225.   lcd.print("VOLTAS:");
    
  226.   lcd.print(voltas);
    
  227.   lcd.setCursor(8, 0);
    
  228.   Serial.println("**5.6**");
    
  229.  }
    
  230. }

  231. }

  232. Serial.println(“6”);

  233. }

  234. void IRAM_ATTR CONTA_PULSO(){//OK

  235. Serial.println(“7.1”);

  236. if(voltas<voltas_maxima){

  237. pulse_number++;//Incrementa número de pulsos

  238. flag_pulse_number = true;

  239. }

  240. if((voltas<voltas_maxima) && (flag_pulse_number == true)){

  241. flag_pulse_number = false;
    
  242. }

  243. }

  244. void VERIFICA_PULSO(){//OK

  245. //variaveis PWM

  246. float PER;

  247. static float PORCENTAGEM = PER; //constante de entrada dada

  248. //em porcentagem, referente

  249. //a saida do Arduino (5V)

  250. int TENSAO = map(PORCENTAGEM, 0, 100, 0, 4096); //Funções que mapeia a variavel

  251. //e converte para resolução

  252. //da saida PWM

  253. //de 2^12 (12 bits)

  254. //

  255. Serial.println(“8”);

  256. }

  257. void motor_ON( void * pvParameters ) {

  258. TickType_t xLastWakeTime;

  259. const TickType_t xFrequency = 100;

  260. xLastWakeTime = xTaskGetTickCount();

  261. static int aux_voltas;

  262. while(1){

  263. Serial.println(“9”);

  264. vTaskDelayUntil( &xLastWakeTime, xFrequency );

  265. //Captação de informações para o controlador

  266. static unsigned long guarda_millis_Input = millis();

  267. if(!flag_PLAY_PAUSE){

  268. Serial.println("**10**");
    
  269. if ((millis() - guarda_millis_Input) >= t_captacao){
    
  270. //reinicia contador
    
  271. guarda_millis_Input = millis();
    
  272. //captação de amostra
    
  273. Input = pulse_number - aux_pulse_number;
    
  274. aux_pulse_number = pulse_number;
    
  275. }
    
  276. myPID.Compute();//Computa controlador
    
  277. int TENSAO = map (degrau, 0,2048, 0,255); //Mapeia a variável e converte para resolução da saída PWM
    
  278. // int TENSAO = degrau/8;

  279. analogWrite(EN,(TENSAO+Output));
    
  280. Serial.println("**11**");
    
  281. if ((pulse_number % pulsos_por_volta) == 0
    
  282. && aux_voltas != pulse_number
    
  283. && pulse_number > 0 && voltas < voltas_maxima) {
    
  284. //Incrementa e mostra no SSD variavel voltas
    
  285. voltas = voltas + 1;
    
  286. lcd.setCursor(8, 0);
    
  287. lcd.print(voltas);
    
  288. //Armazena pulse_number
    
  289. aux_voltas = pulse_number;
    
  290. }

  291. }

  292. if (voltas >= voltas_maxima) {
    
  293. lcd.setCursor(8,0);
    
  294. lcd.print(voltas);
    
  295. pulse_number = 0; //Zera pulse_number
    
  296. flag_PLAY_PAUSE = HIGH;
    
  297. flag_ZERA_SSD = LOW;
    
  298. dacWrite(EN,0);//Desliga motor
    
  299. //Abaixa flag do botão
    
  300. }

  301. }

  302. }

  303. void LEITURA( void * pvParameters ) {//OK

  304. VL53L0X_RangingMeasurementData_t measure;

  305. while(1){

  306. TickType_t xLastWakeTime;

  307. const TickType_t xFrequency = 20;

  308. xLastWakeTime = xTaskGetTickCount();

  309. Serial.println(“13”);

  310. vTaskDelayUntil( &xLastWakeTime, xFrequency );  
    
  311. if(!flag_PLAY_PAUSE && voltas<=voltas_maxima){

  312.     for (pos = 120; pos <= 140; pos += 1) { // goes from 0 degrees to 180 degrees
    
  313. // in steps of 1 degree
    
  314. myservo.write(pos);              // tell servo to go to position in variable 'pos'
    
  315. lox.rangingTest(&measure, false);

  316. if (measure.RangeStatus != 4) { // phase failures have incorrect data

  317. Serial.print("Distance (mm): "); Serial.println(measure.RangeMilliMeter);
    
  318. } else {

  319. Serial.println(" out of range ");
    
  320. }

  321. }

  322. for (pos = 140; pos >= 120; pos -= 1) { // goes from 180 degrees to 0 degrees

  323. myservo.write(pos);              // tell servo to go to position in variable 'pos'
    
  324.                       // waits 15ms for the servo to reach the position
    
  325. }

  326. Serial.println(“14”);

  327. }

  328. }

  329. }

EPC1 : 0x40089aaa EPC2 : 0x00000000 EPC3 : 0x00000000 EPC4 : 0x400d7574