Starting and Stopping Events Outside of Setup

[dr-rockzo]

Hello,

I have a project where I'm trying to decode a 1200 baud, manchester encoded signal (DALI - Digitally Addressable Lighting Interface) and am trying to use the Event System and TCB0 to decode it. Basically the Event System triggers TCB0 in "single shot" mode, then when it gets to TOP, an ISR runs which reads the input pin and writes a bit to a variable. I have it almost working but cannot for the life of me get it to trigger on the right edge. I need to synchronize to the first falling edge (this is what I can't get working) and then fire the timer every time the pin changes (this part is working).

I thought I would use a FALLING interrupt on the pin to enable the Event0 channel, but that doesn't seem to work because the timer never fires (not on time or later than expected). So my question is, can the Event channels be started and stopped outside of Setup and if so are there any special considerations? I have attached the "almost working" code and "not working" code; please be gentle, I am by no means an expert.

This is the code that sort of works, but synchronizes to the wrong edge (first rising edge):

//Libraries
#include <Event.h>
#include <Event_get_set_alias.h>
#include <Event_parts.h>
#include <Event_tinyAVR.h>

//Defines
#define debugLED PIN_PA6 //physical pin 28
#define daliPin PIN_PA7 //physical pin 1 

//Global variables
volatile byte daliAddress; //decoded address
volatile byte daliData;   //decoded command
volatile byte daliBit;    //current DALI bit 
volatile bool newDali;    //flag for new data 

void setup() {
/*TCB0 will be used to generate a 625us pulse (one-shot) and an interrupt after being trigger by the event system. */
TCB0.CTRLA = 0b00000000;   //unscaled clock, disable timer 
TCB0.CTRLB = 0b01000110;   //ASYNC event trigger, one-shot mode
TCB0.EVCTRL = 0b01010001;  //filter on, both edges, capture enabled
TCB0.INTCTRL = 0b00000001; //enable interrupt on capture (fires when counter reaches top)
TCB0.CCMP = 12700;         //count to 12500 tics, 625uS @20MHz clock (tuned value is roughly 12700 tics)

/*Event channel 0 (Event0) will be used to trigger TCB0 when PIN_PA7 changes state.*/
Event0.set_generator(gen0::pin_pa7); //button input pin
Event0.set_user(user::tcb0_capt);    //TCB0 trigger input
Event0.start();                      //Enable the channel

/*Basic GPIO configueration*/  
pinMode(daliPin, INPUT);
pinMode(debugLED, OUTPUT);

/*Misc final setup*/
attachInterrupt(digitalPinToInterrupt(daliPin), daliIn, CHANGE); //pin driven interrupt for debugging
digitalWrite(debugLED, LOW); //turn off the debugLED
TCB0.CTRLA = 0b00000001;     //enable the timer
Serial.begin(115200);        //open serial port for debugging
}

void loop() {
  if(newDali){
    serialDebug();
    newDali = false;
  }
}

/*This interrupt is generated after TCB0 has overflown*/
ISR(TCB0_INT_vect){
  TCB0.INTFLAGS = TCB_CAPT_bm; // Clear interrupt flag
  digitalWrite(debugLED, LOW);
  
  //if waiting for start bit and the last packet has been read, advance daliBit counter
  if((daliBit == 0) && (newDali == false)){
    daliBit++;
    }
  
  //if daliBits are between 1 and 8 the address is being reiceved, write a 1 or 0 in the varible, then advance the daliBit counter
  else if((daliBit >= 1) && (daliBit <= 8) && digitalReadFast(daliPin)){
    bitSet(daliAddress, (8-daliBit));
    daliBit++;
    }
  else if((daliBit >= 1) && (daliBit <= 8) && !digitalReadFast(daliPin)){
    bitClear(daliAddress, (8-daliBit));
    daliBit++;
    }

  //if daliBits are between 9 and 16 the command is being recieved, write a 1 or 0 in the varible, then advance the daliBit counter
  else if((daliBit >= 9) && (daliBit <= 16) && digitalReadFast(daliPin)){
    bitSet(daliData, (16-daliBit));
    daliBit++;
    }
  else if((daliBit >= 9) && (daliBit <= 16) && !digitalReadFast(daliPin)){
    bitClear(daliData, (16-daliBit));
    daliBit++;
    }

  //if the count is 17 (1 start bit + 16 data bits), set the flag for the non-ISR loop 
  if(daliBit == 17){
    newDali = true;
    daliBit = 0;
    }
  
}


void daliIn(){
  digitalWrite(debugLED, HIGH);
} 

void serialDebug(){
  byte tempA = daliAddress;
  byte tempB = daliData;
  
  Serial.println("New Packet");
  Serial.print("Address: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempA, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");

  Serial.print("   Data: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempB, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");
  Serial.println(" ");
}

This is the code I thought would let me line up on the first falling edge, but it appears Event0 never fires the timer:

//Libraries
#include <Event.h>
#include <Event_get_set_alias.h>
#include <Event_parts.h>
#include <Event_tinyAVR.h>

//Defines
#define debugLED PIN_PA6 //physical pin 28
#define daliPin PIN_PA7 //physical pin 1 

//Global variables
volatile byte daliAddress; //decoded address
volatile byte daliData;   //decoded command
volatile byte daliBit;    //current DALI bit 
volatile bool newDali;    //flag for new data 

void setup() {
/*TCB0 will be used to generate a 625us pulse (one-shot) and an interrupt after being trigger by the event system. */
TCB0.CTRLA = 0b00000000;   //unscaled clock, disable timer 
TCB0.CTRLB = 0b01000110;   //ASYNC event trigger, one-shot mode
TCB0.EVCTRL = 0b01010001;  //filter on, both edges, capture enabled
TCB0.INTCTRL = 0b00000001; //enable interrupt on capture (fires when counter reaches top)
TCB0.CCMP = 12700;         //count to 12500 tics, 625uS @20MHz clock (tuned value is roughly 12700 tics)

/*Event channel 0 (Event0) will be used to trigger TCB0 when PIN_PA7 changes state.*/
Event0.set_generator(gen0::pin_pa7); //button input pin
Event0.set_user(user::tcb0_capt);    //TCB0 trigger input
//Event0.start();                      //Enable the channel

/*Basic GPIO configueration*/  
pinMode(daliPin, INPUT);
pinMode(debugLED, OUTPUT);

/*Misc final setup*/
attachInterrupt(digitalPinToInterrupt(daliPin), daliIn, FALLING); //pin driven interrupt for debugging
digitalWrite(debugLED, LOW); //turn off the debugLED
TCB0.CTRLA = 0b00000001;     //enable the timer
Serial.begin(115200);        //open serial port for debugging
}

void loop() {
  if(newDali){
    serialDebug();
    newDali = false;
  }
}

/*This interrupt is generated after TCB0 has overflown*/
ISR(TCB0_INT_vect){
  TCB0.INTFLAGS = TCB_CAPT_bm; // Clear interrupt flag
  digitalWrite(debugLED, LOW);
  
  //if waiting for start bit and the last packet has been read, advance daliBit counter
  if((daliBit == 0) && (newDali == false)){
    daliBit++;
    }
  
  //if daliBits are between 1 and 8 the address is being reiceved, write a 1 or 0 in the varible, then advance the daliBit counter
  else if((daliBit >= 1) && (daliBit <= 8) && digitalReadFast(daliPin)){
    bitSet(daliAddress, (8-daliBit));
    daliBit++;
    }
  else if((daliBit >= 1) && (daliBit <= 8) && !digitalReadFast(daliPin)){
    bitClear(daliAddress, (8-daliBit));
    daliBit++;
    }

  //if daliBits are between 9 and 16 the command is being recieved, write a 1 or 0 in the varible, then advance the daliBit counter
  else if((daliBit >= 9) && (daliBit <= 16) && digitalReadFast(daliPin)){
    bitSet(daliData, (16-daliBit));
    daliBit++;
    }
  else if((daliBit >= 9) && (daliBit <= 16) && !digitalReadFast(daliPin)){
    bitClear(daliData, (16-daliBit));
    daliBit++;
    }

  //if the count is 17 (1 start bit + 16 data bits), set the flag for the non-ISR loop 
  if(daliBit == 17){
    newDali = true;
    Event0.stop();
    daliBit = 0;
    attachInterrupt(digitalPinToInterrupt(daliPin), daliIn, FALLING);
    }
  
}


void daliIn(){
  digitalWrite(debugLED, HIGH);
  Event0.start();
  detachInterrupt(digitalPinToInterrupt(daliPin));
} 

void serialDebug(){
  byte tempA = daliAddress;
  byte tempB = daliData;
  
  Serial.println("New Packet");
  Serial.print("Address: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempA, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");

  Serial.print("   Data: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempB, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");
  Serial.println(" ");
}

[SpenceKonde]

Wait, I'm looking at that code... Euhm... you have the TCB disabled! It's not going to do anything like that.... (the general formula for configuring any peripheral on a modern AVR is disable it if it's enabled, set up everything else, then finish by clearing the INTFLAGS just in case one is set somehow, then finally set ctrla.

Be sure to set count to top because of what they say about single-shot mode:

The counter will start counting as soon as the peripheral is enabled, even without triggering by an event, or if the
Event Edge (EDGE) bit in the Event Control (TCBn.EVCTRL) register is modified while the peripheral is enabled.
This is prevented by writing TOP to the Counter register. Similar behavior is seen if the Event Edge (EDGE) bit in
the Event Control (TCBn.EVCTRL) register is ‘1’ while the module is enabled. Writing TOP to the Counter register
prevents this as well.

I know nothing about DALI so I'm not entirely sure what you need to do, but with the way the EDGE bit now works ( and which they finally updated the datasheet to account for) one setting is "Rising edge" and the other is "rising or falling edge" But you want "falling edge"? Man it's too bad these parts don't have a way to invert a pin input.... Oh wait, they do! Set the INVEN bit in PINnCTRL either manually or through our pinConfigure function (see Ref_Digital.md); That inverting is the first thing that happens as it comes in, before events and shit. So that gives you an easy way to turn the falling edges that you can't specify as a TCB event trigger into rising ones which you can.

And nope, no restriction on when event channels are configured, you can do it at runtime

[dr-rockzo]

SpenceKonde,

Thanks for replying, i really appreciate how much work you've put into this and how willing you are to help. Please let me clarify what I'm trying to do.

So basically DALI is a 16 bit packet, Manchester encoded serial used to control LED drivers (it's like slow DMX). To decode it, i need to trigger the one-shot which delays 625uS (3/4 of the 1200bd period), then read the pin input pin.

I do have the timer enabled, it happens in the last little chunk of setup() and i know the setup works because, it sets the "debugLED" pin high when the timer starts via the pin interrupt and sets the pin low when the timer ISR fires in the top code i posted.

The top code "works" timing wise, but Event0 starts firing on the first rising edge. I need to ignore the first rising edge of the packet and start the Event/TCB on the first falling edge. So i wrote the second piece of code where i tried to activate Event0 in an ISR trigger by the rising edge of the signal, detaching that interrupt so as not to disturb Event0, then after the packet is received the pin ISR is re attached. The problem is the when i try that, the timer ISR never gets triggered by Event0; i can tell that because only the timer ISR turns off DebugLED and it stays on.

I don't think that activating Event0 from the ISR is working, but I'm also not sure if it should. I'll post a timing diagram tomorrow to make the issue more clear if that would help.

[SpenceKonde]

Ah, well my suggestion of inverting the pin still holds for the one that's triggering on a rising edge or falling edge - invert the pin and set to start timer on rising edge (meaning falling edge since inverted

…

____________ Spence Konde Azzy’S Electronics New products! Check them out at tindie.com/stores/DrAzzy GitHub: github.com/SpenceKonde ATTinyCore: Arduino support for almost every ATTiny microcontroller Contact: ***@***.***

On Wed, Mar 15, 2023, 19:10 dr-rockzo ***@***.***> wrote: SpenceKonde, Thanks for replying, i really appreciate how much work you've put into this and how willing you are to help. Please let me clarify what I'm trying to do. So basically DALI is a 16 bit packet, Manchester encoded serial used to control LED drivers (it's like slow DMX). To decode it, i need to trigger the one-shot which delays 625uS (3/4 of the 1200bd period), then read the pin input pin. I do have the timer enabled, it happens in the last little chunk of setup() and i know the setup works because, it sets the "debugLED" pin high when the timer starts via the pin interrupt and sets the pin low when the timer ISR fires in the top code i posted. The top code "works" timing wise, but Event0 starts firing on the first rising edge. I need to ignore the first rising edge of the packet and start the Event/TCB on the first falling edge. So i wrote the second piece of code where i tried to activate Event0 in an ISR trigger by the rising edge of the signal, detaching that interrupt so as not to disturb Event0, then after the packet is received the pin ISR is re attached. The problem is the when i try that, the timer ISR never gets triggered by Event0; i can tell that because only the timer ISR turns off DebugLED and it stays on. I don't think that activating Event0 from the ISR is working, but I'm also not sure if it should. I'll post a timing diagram tomorrow to make the issue more clear if that would help. — Reply to this email directly, view it on GitHub <#417 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ABTXEW2WBELW2FIMWAGSAMTW4JD4ZANCNFSM6AAAAAAV4NF6W4> . You are receiving this because you commented.Message ID: ***@***.***>

[dr-rockzo]

So i should invert the pin and set Event0 to trigger on the rising edge, next in the timer ISR un-invert pin and change the timer to trigger on both edges? Am i understanding correctly?

[dr-rockzo]

Alright, I got it firing on the right edge for the first packet but for some reason it's like the event and timer don't reset. I know the code is getting to where that should happen because, the flag for a new packet gets set and it sends the packet over serial. It's almost like Event0 is not stopping.

I used pinConfigure to invert the pin and set the pin ISR to RISING.
That ISR starts Event0 and detaches itself from the pin.
Event0 starts TCB0.
When TCB0 overflows, an ISR is called reads the pin and counts the bits.
Once all the bits have been received, EVENT0 should stop and the pin ISR reattached. <something is going wrong here because it never catches the right edge again.

I feel like I'm overlooking something.

//Libraries
#include <Event.h>
#include <Event_get_set_alias.h>
#include <Event_parts.h>
#include <Event_tinyAVR.h>

//Defines
#define debugLED PIN_PA6 //physical pin 28
#define daliPin PIN_PA7 //physical pin 1 

//Global variables
volatile byte daliAddress = 0; //decoded address
volatile byte daliData = 0;   //decoded command
volatile byte daliBit = 0;    //current DALI bit 
volatile bool newDali = false;    //flag for new data 

void setup() {
/*TCB0 will be used to generate a 625us pulse (one-shot) and an interrupt after being trigger by the event system. */
TCB0.CTRLA = 0b00000000;   //unscaled clock, disable timer 
TCB0.CTRLB = 0b01000110;   //ASYNC event trigger, one-shot mode
TCB0.EVCTRL = 0b01000001;  //filter on, rising edge, capture enabled
TCB0.INTCTRL = 0b00000001; //enable interrupt on capture (fires when counter reaches top)
TCB0.CCMP = 12700;         //count to 12500 tics, 625uS @20MHz clock (tuned value is roughly 12700 tics)
TCB0.CTRLA = 0b00000001;   //enable the timer

/*Event channel 0 (Event0) will be used to trigger TCB0 when PIN_PA7 changes state.*/
Event0.set_generator(gen0::pin_pa7); //button input pin
Event0.set_user(user::tcb0_capt);    //TCB0 trigger input
Event0.set_user(user::evouta_pin_pa2);

/*Basic GPIO configueration*/  
pinConfigure(daliPin, PIN_DIR_INPUT, PIN_OUT_LOW, PIN_NOPULLUP, PIN_INVERT_ON);
pinConfigure(debugLED, PIN_DIR_OUTPUT, PIN_OUT_LOW);

/*Misc final setup*/
attachInterrupt(digitalPinToInterrupt(daliPin), daliIn, RISING); //pin driven interrupt for debugging
digitalWrite(debugLED, LOW); //turn off the debugLED
Serial.begin(115200);        //open serial port for debugging
}

void loop() {
  if(newDali){
    serialDebug();
    newDali = false;
  }
}

void daliIn(){
  Event0.start();
  detachInterrupt(digitalPinToInterrupt(daliPin));
} 

/*This interrupt is generated after TCB0 has overflown*/
ISR(TCB0_INT_vect){
  TCB0.INTFLAGS = TCB_CAPT_bm; // Clear interrupt flag
  digitalWriteFast(debugLED, HIGH);

  
  //if waiting for start bit and the last packet has been read, advance daliBit counter
  if((daliBit == 0) && (newDali == false)){
    TCB0.CTRLA  = 0b00000000;
    TCB0.EVCTRL = 0b01010001;
    TCB0.CTRLA  = 0b00000001;
    TCB0.INTFLAGS = TCB_CAPT_bm;
    }
  
  //if daliBits are between 1 and 8 the address is being reiceved, write a 1 or 0 in the varible, then advance the daliBit counter
  if((daliBit >= 0) && (daliBit <= 7) && !digitalReadFast(daliPin)){
    digitalWriteFast(debugLED, LOW);
    bitSet(daliAddress, (daliBit));
    daliBit++;
    }
  else if((daliBit >= 0) && (daliBit <= 7) && digitalReadFast(daliPin)){
    digitalWriteFast(debugLED, LOW);
    bitClear(daliAddress, (daliBit));
    daliBit++;
    }

  //if daliBits are between 9 and 16 the command is being recieved, write a 1 or 0 in the varible, then advance the daliBit counter
  else if((daliBit >= 8) && (daliBit <= 15) && !digitalReadFast(daliPin)){
    digitalWriteFast(debugLED, LOW);
    bitSet(daliData, (daliBit));
    daliBit++;
    }
  else if((daliBit >= 8) && (daliBit <= 15) && digitalReadFast(daliPin)){
    digitalWriteFast(debugLED, LOW);
    bitClear(daliData, (daliBit));
    daliBit++;
    }

  //if the count is 15 (16 data bits), set the flag new data flag
   if(daliBit == 15){
    Event0.stop(); //stop the Event (i don't think this is happening)
    digitalWriteFast(debugLED, LOW);
    newDali = true;
    daliBit = 0;
    TCB0.CTRLA  = 0b00000000;
    TCB0.EVCTRL = 0b01000001;
    TCB0.CTRLA  = 0b00000001;
    TCB0.INTFLAGS = TCB_CAPT_bm;
    attachInterrupt(digitalPinToInterrupt(daliPin), daliIn, RISING);
    }  
}

void serialDebug(){
  byte tempA = daliAddress;
  byte tempB = daliData;
  
  Serial.println("New Packet");
  Serial.print("Address: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempA, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");

  Serial.print("   Data: ");
  for(byte i=8; i>0; i--){
    if(bitRead(tempB, i-1)==1){Serial.print("1");}
    else{Serial.print("0");}
  }
  Serial.println(" ");
  Serial.println(" ");
}

[trimarco232]

Hi dr-rockzo
don't you think input capture (with digital filter) is better suited for decoding manchester like signals ?

[dr-rockzo]

I was trying to follow an old Microchip app note. I ended up achieving the same basic goal by just manually turning the timer on and off, instead of the event system and one-shot mode.

Thanks for the tip, i'll check out the input capture mode too.