epoll doesn’t differentiate between rising and falling edges – an edge is just an edge. The RPi.GPIO option to specify edge trigger is pointless given epoll doesn’t support it. The RPi.GPIO code has code that calls epoll_wait() twice, thus reading the rising and falling edge when a button is pushed by a human. Perfectly fine solution for “wait for button, then flash LED” type problems.
But for the IMU, the IMU interrupts and the epoll code need to be in sync about working together. So I change both the HoG python- and my GPIO ‘C’ code.
- EPOLLONESHOT detects an edge and then stops watching meaning there’s no backlog of interrupts building up while the python code is processing the corresponding sensor data.
- Don’t call epoll_wait() twice to capture both rising and falling edge of a button – it will block permanently second time round with EPOLLONESHOT
- The MPU6050 is started prior to enabling epoll otherwise epoll blocks waiting for interrupts that IMU has not been configured to send yet
- Probably better to ask the IMU to clear the interrupt only once the data registers have been read – this then means epoll will not be watching for interrupts at the point there is a falling edge.
- Set pull down on the interrupt GPIO pin.
This is what the ‘scope showed as a result:
The rising edge is triggered by the IMU when new data is ready to be read. The falling edge is when the python code reads that data over I2C causing the IMU to drop the interrupt pin.
The screen spans 20ms, with a pulse every 2ms. Hence there should be 10 rising edges, but if you count, there are only 9. The wide pulse in the middle took more than 2ms between raising the interrupt and the data being read: a sample was lost. I didn’t have to take lots of screen shots to capture this; this was the first screen shot I took. The code is set to do motion processing every 5 reads, and I presume that’s the cause of the longer pulse; capturing a sample and doing motion processing takes more than 2ms. Any screen shot will contain at least one wider pulse like this.
Overall, that’s pretty good news: the IMU interrupt, and the GPIO and HoG code are working well together. I clearly need to reduce the time motion processing takes – and it looks like the reduction is relatively small. Also that explains the difference in flight times measured based in interrupt- and time.time(): the HoG code reads only 5 out of 6 samples, so code relying on interrupt timing appears to take less time than it actually does (5 x 2ms < 12ms).
P.S. I’m assuming the mid-width pulse are due to Linux scheduling of my code. That’s no problem as it’s not causing loss of samples – only the motion processing pulse is taking more than 2ms.