Arduino Due Own interrupt routine

[miss_the_girl]

main.cpp (1.7 KB)
Hi!
New to Arduino, I want to build my own interrupt service for an Arduino Due (SAM38XE)
Since I am counting interrupts from an encoder with a list of other functions and
using attachInterrupt() seems to slow for the task.
I assume that I need to setup registers for interrupt handling and write an ISR routine,
so I wrote the code accordingly.
Buuuut I am quite lost.

#include <Arduino.h>
#include "WInterrupts.h"

#define interruptpin PIO_PD10; //pin 32 on board is D register PD10

//https://forum.arduino.cc/t/override-attachinterrupt/203670
//https://forum.arduino.cc/t/isr-on-rising-edge-with-registers/862050/6
//https://forum.arduino.cc/t/isr-on-rising-edge-with-registers/862050
volatile int counts=0;
volatile int flag=0;

typedef void (*interruptCB)(void); //?
static interruptCB callbacksPiod[32]; //?

void counter(){
  
  counts++;
  flag=!flag; //for debugging
}
static void __initialize() {
	int i;
	for (i=0; i<32; i++) {
		callbacksPiod[i] = NULL;
	}
}
void PIOD_Handler(void) __attribute((weak)); //for overriding original fuction
void PIOD_Handler(void)
{
  uint32_t isr = PIOD->PIO_ISR;
  uint32_t i;
  for (i=0; i<32; i++, isr>>=1) {
    if ((isr & 0x1) == 0)
      
      continue;
    
    if (callbacksPiod[i])
      callbacksPiod[i]= counter;
  }
}

void setup() {
  
  pinMode(LED_BUILTIN,OUTPUT); //for debugging instead of serial print
  __initialize();
  pmc_enable_periph_clk(ID_PIOD); //enable clock
	//NVIC_DisableIRQ(PIOD_IRQn);
	//NVIC_ClearPendingIRQ(PIOD_IRQn);
	NVIC_SetPriority(PIOD_IRQn, 0);
	NVIC_EnableIRQ(PIOD_IRQn);

  // Enable aditional interrupt mode
  PIOD -> PIO_AIMER = interruptpin;
  //select edge for interrupt
  PIOD-> PIO_ESR = interruptpin;     // Edge select register
  PIOD -> PIO_FELLSR = interruptpin;  //Falling Edge Low Level Select Register
  //Enable Interrupt
  PIOD -> PIO_IER = interruptpin; //Interrupt Enable Register
  PIOD -> PIO_IMR = interruptpin;  //Interrupt Mask Register

//attachInterrupt(32,counter,FALLING);

}

void loop() {
  //LED for counting, blinks when interrupt 
  digitalWrite(LED_BUILTIN,flag);
}

Thanks in advance.

[Grumpy_Mike]

You may want to read this before you proceed:-
how to get the best out of this forum

It will tell you things like how to post your code. Many members use mobile devices and they will not handle a .ino file, although basically it is only text. That is why the forum has code tags.

Note all variables used inside and outside an interrupt must be declared as volatile.

@miss_the_girl

I want to build my own interrupt service for an Arduino Due

What is an interrupt service?
I am assuming that because you mentioned an encoder you need to decode this, it is normal to use a state machine to do this.

@miss_the_girl

using attachInterrupt() seems to slow for the task.

Do you mean "too slow" to operate, or too much to set up?

[Grumpy_Mike]

@miss_the_girl

New to Arduino,

Although you posted last 6 months ago?

[miss_the_girl]

Thanks man. hm ok let me put it like this: The encoder is wired towards an optocoupler and then to arduino. When Arduino picks up a pulse from the optocoupler it handles it as an interrupt. The ISR for this is just an adding counter. With attachInterrupt() it works fine on it's own, but when put together with all other functions it counts all to many interrupts. So I assume that it is to slow to operate since it's built for a very general purpose and the extra pulses must appear from the function being inefficient?

[miss_the_girl]

yeah quite new...

[Grumpy_Mike]

@miss_the_girl

The encoder is wired towards an optocoupler and then to arduino.

Sorry words do not cut it in electronics. The words "wired towards" convey nothing. As you are a beginner you could be making all sorts of mistakes in your wiring. We need to see a schematic to see exactly what you have.

@miss_the_girl

but when put together with all other functions it counts all to many interrupts.

Do you have difficulty distinguishing the words "to" and "too"? It makes an big difference to the meaning that comes from your words.

@miss_the_girl

So I assume that it is to slow to operate since it's built for a very general purpose and the extra pulses must appear from the function being inefficient?

No you can not conclude that from your observations, in fact exactly the opposite is true. I would say your interrupts are working so fast that they are counting way more pulses from your encoder than you expect from just turning the encoder slowly.

That is why I said that :-

@Grumpy_Mike

it is normal to use a state machine to do this.

That is a natural way of suppressing false values from contact bounce. This is what a state machine looks like for a rotary encoder.

Your code looks a bit odd:-

@miss_the_girl

for (i=0; i<32; i++) {
		callbacksPiod[i] = NULL;

Why are you doing this? Surly there is no need as they are setup already to a suitable default.

@miss_the_girl

if ((isr & 0x1) == 0)
      
      continue;

What ever the result of the if statement it always does the same thing, which is nothing.

I also have no idea what your interrupt routine is actually doing in trying to read your encoder. At the very least if you are not using a state machine you need to generate an interrupt from one encoder signal and in that interrupt look at the state of the other encoder signal.

[sterretje]

@miss_the_girl

using attachInterrupt() seems to slow for the task

The only thing that attachInterrupt() does is setting up some registers related to the desired interrupt so when a pin changes the result is an interrupt and the respective ISR is called. And usually it's only called once in setup().

If you post the problematic code that triggered the need to start digging into interrupts, somebody might point you to mistakes in your code.

[miss_the_girl]

Thank you, I will look into that more before I make another statement:) .
The encoder is built into the motor, drylin® E stepper motor with encoder, NEMA 17. I drew a simple scheme of how my construction is, besides from that for handling the interrupts I just use arduino's attachInterrupt (interruptpin, function, FALLING)
function(){
counter++;
}

[Grumpy_Mike]

@miss_the_girl

I drew a simple scheme of how my construction is

Still doesn't help much. Why are you using opto couplers, you do know these are slow, and the schematic does not show how the encoder is going to power the LEDs in the optos.
You show one wire from the Arduino to the opto couplers. How are you going to get the direction signal to work with only one connection.

I think you need to search the net for an example of how encoders work.

[miss_the_girl]

The A and /A is powering the LED. I don't have any use of estimating if the motor is going cw or ccw since the important thing is just the correct number of pulses per rotation in this particular project. And yes to estimate direction you have to look at both A and B as stated in the diagram. Yes thinking about it now there is probably a lot of other things taking in consideration before optimizing software.

[Grumpy_Mike]

That in one hell of a strange design.

Ignoring any contact bounce you would get two pulses per rotary cycle. That is in the places when one output is high and the other is low.

If you only want one pulse, and no direction, then just take one of the encoder's outputs.