Can't read pin value from interrupt

haplm · May 14, 2020, 1:57pm

I'm attaching an interrupt to pin D2, which works fine (I can see that the interrupt is being called. However, I'm unable to read the actual pin state (HIGH/LOW) from within the interrupt. Here is the code:

volatile int pwm_value = 0;
volatile int prev_time = 0;
volatile bool lastState;
 
void setup() {
  Serial.begin(115200);
  // when pin D2 goes high, call the rising function
  pinMode( 2, INPUT);
  lastState = digitalRead(2);
  attachInterrupt(digitalPinToInterrupt(2), isr, CHANGE);
}
 
void loop() {
  Serial.print("PWM: ");
  Serial.print(pwm_value);
  Serial.print("\tLAST: ");
  Serial.println(prev_time);
  delay(100);
}
 
void isr() {
  int ts = micros();
  bool state_now = digitalRead(2);
    if (state_now == HIGH) {
      prev_time = ts;
    } else {
      pwm_value = ts - prev_time;
    }
}

The call digitalRead(2) in the ISR always returns HIGH (or it simply doesn't work), so I'm unable to detect the end of the pulse. I hope that I'm not doing something stupid here by reading the pin state right after the interrupt is triggered... If not, well, then there must be some bug.

Console output is following:

PWM: 0	LAST: 3198487
PWM: 0	LAST: 3297425
PWM: 0	LAST: 3396332
PWM: 0	LAST: 3495240
PWM: 0	LAST: 3594178
PWM: 0	LAST: 3693085
PWM: 0	LAST: 3792023

If I'm doing something that isn't right, can someone help me with an approach that works, please? Thank you!

haplm · May 14, 2020, 7:35pm

So this must definitely be a problem with the Nano BLE, as the same code is running just fine on ESP8266. I wonder if anyone had the same issue...

gerrikoio · May 14, 2020, 8:56pm

I used uint32_t instead of int declarations to avoid any unintentional overflows and I added in noInterrupts() at start of isr() code and then Interrupts() at end of the ISR() and it worked (sort of?)... I did try the detachInterrupt() option inside the ISR() but that just froze things up.

haplm · May 15, 2020, 7:50am

gerrikoio:
I used uint32_t instead of int declarations to avoid any unintentional overflows and I added in noInterrupts() at start of isr() code and then Interrupts() at end of the ISR() and it worked (sort of?)... I did try the detachInterrupt() option inside the ISR() but that just froze things up.

Thanks for the tips. With these changes, were you able to correctly read a pin value from inside the interrupt? IMO this is very basic functionality, which one can see in tons of examples, so I'm inclined to think that the behaviour I'm observing is one of the quirks of the Arduino wrapper around the mbed OS. Maybe I should move to programming the board in mbed directly, and get rid of these quirks?

gerrikoio · May 15, 2020, 10:30am

Yes it worked, as in pwm_value was updated. As to whether the values were correct, who knows. Anyway, IMHO, I think it is necessary to use noInterrupts() and Interrupts() as "bookends" in any ISR to ensure it functions correctly.

haplm · May 15, 2020, 8:24pm

Interesting. However, I have decided to do it in mbed OS. I did some reading, and I like its capabilities. Unfortunately there're almost no examples or documentation around on how to interact with mbed OS from Arduino, and Nano 33 BLE can't be connected from mbed ide directly.

Anyway, at the end it wasn't that hard. Here's the code:

#include <Arduino.h>
#include <pins_arduino.h>
#include <mbed.h>
#include <rtos.h>
#include <PinNames.h>

mbed::Timer timer;
mbed::InterruptIn steeringIn(P1_11);

int32_t begin;
int32_t end;
float distance;

void steering_rise(void);
void steering_fall(void);

void setup() {
  Serial.begin(9600);
  steeringIn.rise(mbed::callback(steering_rise));
  steeringIn.fall(mbed::callback(steering_fall));
  Serial.println("Set up");
}

void steering_rise(void) {
    timer.reset();
    timer.start();
    begin = timer.read_us();
}

void steering_fall(void) {
    end = timer.read_us();
    timer.stop();
    distance = end - begin;
}

void loop() {
  Serial.println(distance);
  wait_us(200);
}

I'm not saying that the code is final, but it definitely reads and prints the values.

Oh, and BTW, mbed OS has a very nice way how to generate PWM as well

mbed::PwmOut d2(P1_11);

....

d2.period_ms(200);
d2.pulsewidth_us(1000);

gerrikoio · May 16, 2020, 10:30am

haplm:
Interesting. However, I have decided to do it in mbed OS. I did some reading, and I like its capabilities. Unfortunately there're almost no examples or documentation around on how to interact with mbed OS from Arduino, and Nano 33 BLE can't be connected from mbed ide directly.

Well done. That's really helpful.

I had done some small code experiments using mbed and discovered that many of the #includes you've used such as #include <mbed.h> are already in Arduino.h. Maybe check this out to confirm.

Also you can use namespace, as in "using namespace mbed;", meaning there's no need to use "mbed::" with your mbedos code. I believe, this too may already be included in Arduino. h.

haplm · May 17, 2020, 2:16pm

I'll do some cleanup for sure. In the meantime, here's a completely new approach, which is much safer and faster (using EventQueue):

#include <Arduino.h>
#include <pins_arduino.h>
#include <mbed.h>
#include <rtos.h>
#include <PinNames.h>
#include <mbed_wait_api.h>
#include <mbed_events.h>

//mbed::PwmOut d2(P1_11);
mbed::Timer steeringPulseTimer;
mbed::InterruptIn steeringIn(P1_11);
rtos::Semaphore in_steering_sem(1);
events::EventQueue queue(32 * EVENTS_EVENT_SIZE);
rtos::Thread pwmInCallbackThread;


int32_t in_steering_pulse_start;
int32_t in_steering_pulse_end;
int32_t in_steering_pulse_width;
int32_t in_steering_update_ok;
int32_t in_steering_update_failed;

void steering_rise_isr(void);
void steering_fall_isr(void);
void steering_fall_uc(int width);

void setup() {
  Serial.begin(9600);
  steeringPulseTimer.reset();
  // Setup pin D2 (P1_11) to receive steering input
  steeringIn.rise(mbed::callback(steering_rise_isr));
  steeringIn.fall(mbed::callback(steering_fall_isr));
  in_steering_update_ok = 0;
  in_steering_update_failed = 0;
  pwmInCallbackThread.start(mbed::callback(&queue,&events::EventQueue::dispatch_forever));
}


void steering_rise_isr(void) {
  steeringPulseTimer.reset();
  steeringPulseTimer.start();
}


void steering_fall_isr(void) {
  steeringPulseTimer.stop();
  queue.call(steering_fall_uc, steeringPulseTimer.read_us());
}

void steering_fall_uc(int width) {
  bool acq = in_steering_sem.try_acquire_for(2);
  if (acq) {
    in_steering_pulse_width = width;
    in_steering_sem.release();
    in_steering_update_ok++;
  } else in_steering_update_failed++;
}

void loop() {
  Serial.print("Pulse: ");
  in_steering_sem.acquire();
  Serial.print(in_steering_pulse_width);
  Serial.print("\tacqFails: ");
  Serial.println(in_steering_update_failed);
  in_steering_sem.release();
  wait_us(200000);
}

I won't post further updates into this thread, but I may post something here: RcCarController/main.cpp at master · haplm/RcCarController · GitHub

gerrikoio · May 17, 2020, 3:13pm

Looks good. You've just demonstrated something to me. When reading through your code, I felt that the use of "mbed::" and "rtos::" really helped with understanding where the functions come from.

haplm · May 17, 2020, 4:15pm

Thanks.

Yeah, those mbed, rtos, etc spaces help to understand where the functions are coming from. One flaw of the code is that variables in_steering_update_ok and in_steering_update_failed are not thread safe, but since they are just a temporary debug, I didn't bother.

It is going to be interesting when I'll be reading 2 PWM inputs, 7 digital pins, I2C and SPI interfaces, while having to output 2 PWM channels with minimum latency. Well, we will see.

BTW - I've just found that with a programmer, one can use the board in Mbed Studio directly (Mbed OS on Arduino Nano 33 BLE | Djynet). I guess that this is what I'm going to do once I get a programmer...

dannickalls · May 19, 2020, 6:26pm

I've come across the same problem to the original post. It appears to me that interrupts fire ok when using RISING or FALLING but not CHANGE - here they only fire on a rising edge, therefore always reading 1 when reading the pin in the ISR.

gerrikoio:
I used uint32_t instead of int declarations to avoid any unintentional overflows and I added in noInterrupts() at start of isr() code and then Interrupts() at end of the ISR() and it worked (sort of?)... I did try the detachInterrupt() option inside the ISR() but that just froze things up.

I adapted the code as suggested but still the same result.

I have added a flag so the output is only printed when the interrupt has fired. Input is a 1Hz square wave from a sig gen (later to be a RC receiver).

My code:

volatile uint pwm_value = 0;
volatile uint prev_time = 0;
volatile int FLAG = LOW;
volatile bool lastState;
 
void setup() {
  Serial.begin(115200);
  // when pin D2 goes high, call the rising function
  pinMode(2, INPUT);
  lastState = digitalRead(2);
  attachInterrupt(digitalPinToInterrupt(2), isr, CHANGE);
}
 
void loop() {
  if (FLAG==HIGH){
    FLAG = LOW;
    Serial.print("PWM: ");
    Serial.print(pwm_value);
    Serial.print("\tLAST: ");
    Serial.println(prev_time);
  }

}
 
void isr() {
  noInterrupts();
  FLAG = HIGH;
  int ts = micros();
  bool state_now = digitalRead(2);
    if (state_now == HIGH) {
      prev_time = ts;
    } else {
      pwm_value = ts - prev_time;
    }
  interrupts();
}

Output with timestamps shows only rising edge triggering the interrupt:

19:10:31.469 -> PWM: 0 LAST: 4474823
19:10:32.486 -> PWM: 0 LAST: 5474884
19:10:33.468 -> PWM: 0 LAST: 6474914
19:10:34.483 -> PWM: 0 LAST: 7474975
19:10:35.466 -> PWM: 0 LAST: 8475036
19:10:36.477 -> PWM: 0 LAST: 9475067
19:10:37.488 -> PWM: 0 LAST: 10475128
19:10:38.472 -> PWM: 0 LAST: 11475189
19:10:39.493 -> PWM: 0 LAST: 12475250
19:10:40.476 -> PWM: 0 LAST: 13475311
19:10:41.469 -> PWM: 0 LAST: 14475342
19:10:42.490 -> PWM: 0 LAST: 15475403
19:10:43.477 -> PWM: 0 LAST: 16475464

Am I missing something here? Same problems on other pins as well. Is there a way to get this to work without doing it in mbed OS?

Thanks for any help!

EDIT: Updated with changes since last release in https://github.com/arduino/ArduinoCore-nRF528x

Seems to be working now...

haplm · May 21, 2020, 12:56pm

Ah, nice. So CHANGE is now working? I need to try it... Generally, I have noticed that bugs are being actively worked on, which is good. I have hit something else, and found out that it is already fixed in mbed 6.0 beta 1. Now we just need to wait to ArduinoCore update to mbed 6.0

dannickalls · May 21, 2020, 5:31pm

Works for me. Interestingly I've had a real jitter problem that seems to be caused by erroneous readings on the input (pretty sure caused by I terrupt latency) AND by erroneous outputs from servo.write().
I'm not really sure how it relates to the problems encountered here, but I've started a new thread explaining them as it really doesn't fit under this title.

haplm · May 21, 2020, 5:33pm

Sure, I'll post the solution for Servo issues there. I have pointe you to this thread because I have mentioned it as well up there, but I agree that this thread is a bit mess.

Topic		Replies	Views
Arduino33 BLE external interrupts Nano 33 BLE	14	5220	January 17, 2022
Difficulty with interrupts Nano 33 BLE	9	3491	May 7, 2021
chiarimenti sugli interrupt Generale	78	22692	May 7, 2021
Bot Interrupt Pins quit working. 3rd Party Boards	22	5855	May 6, 2021
Pin Change Interrupt Programming	33	9333	May 5, 2021

Can't read pin value from interrupt

Related topics