Interrupts

[coderatchance]

Hello All,

I am looking to use the interrupt via this library and at tiny 3216.
I have used interrupt on AT Tiny45,85 before to wake up the processor via the interrupt pin on a sensor...
posting the #includes and some code that works.
Before I delve into using it on at3216 wondering, if the " avr " code, etc, should as well work on this tiny ?
For example, are the vectors the same, actually where can those be found?

#include <avr/wdt.h>      // WDT
#include <avr/sleep.h>    // Sleep Mode
#include <avr/power.h>          // Power management
#include <TinyWireM.h>        //global library search

example of working code.

//ISR
ISR (PCINT0_vect)
{
  sleep_disable();
  power_all_enable();    // power everything back on

  // also "wake up" enable the wdt
  wdt_enable(WDTO_2S);

  // *** state machine for measuring time of sensor level ***
  if (Sensor.getProximity() > HT) {
    currentState = WAITING_BELOW;
  }
  else {
    currentState = WAITING_ABOVE;
  }
  // *** end of state machine for measuring time of sensor level ***


  // the wanted state after we wake up with interrupt
  //  1
  myLedState = ledOn50;

} //end of ISR

void goToSleep()
{
  //  // turn off the led sig
  //  analogWrite(ledSigPin, 0);

  //  //  set pins to !HighZ
  //  pinMode(7, OUTPUT);
  //  pinMode(6, OUTPUT);
  //  pinMode(5, OUTPUT);
  //  pinMode(3, OUTPUT);

  Sensor.clearInterrupt(); //this will clear sensor interrupts! 
  Sensor.setProximityContinuous(true); // read prox while sleeping

  // disable wdt while sleeping
  wdt_disable();

  // turin off setting while sleeping
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  ADCSRA = 0;            // turn off ADC cca. 200uA diff
  power_all_disable ();  // power off ADC, Timer 0 and 1, serial interface
  sleep_enable();
  sleep_cpu();
}  // end of goToSleep

[SpenceKonde]

Interrupts are different on the modern AVRs. Better.

First off, power.h does nothing here. I've gone through the code of that line by line and determined that every active line is #ifdef'ed out - there are no PRR's here. All peripherals unless stated otherwise are inactive during power down sleep. In standby sleep, most peripherals can be forced on with RUNSTBY but are otherwise off, so they don't need to be explicitly turned off

Only exception is on the 2-series parts with the new ADC, due to an erratum, you have to turn off the ADC manually and configure LOWLAT before anything it effects. Our ADCPowerOptions api extension for turning LOWLAT on and of re-cycles all the other options when you change that on effected parts. Not necessary on 0 or 1-series parts (though we do still have that function so that there's a unified way to enable and disable the ADC and set wehther it runs in standby - 2 series has 2 additional options, LOWLAT and the one that controls if the PGA is left on.

Secondly, you just use Wire.h not TinyWireM. TinyWireM (and you don't even use if for them with my core because we include universal Wire.h over on ATTinyCore) is for old crappy classics with the Useless Serial Interface.

We have real I2C so we use Wire (and the version of wire we ship with has been improved significantly - it has more accurate baud rate generaion, uses far less flash than the stock modern avr one, and can work in multimaster modes or as slave with 2 addresses or wildcard bits in the address, and it can sleep successfully while acting as slave.

The WDT can only be used to reset, to get the periodic interrupt, you need to use the RTC/PIT; I am working on a library for this. It's an urgent priority, but that's relatively low priority because 2.6.7 is ultra urgent priority, and and i've got half a dozen other superurgent priorities and sleep related tasks for the common wake every XX seconds type tasks and while will make millis approximately correct when you wake up.

Port interrupts are enabled by setting the Input Sense Control (ISC) bits in PINnCTRL appropriately (there's low level, change, rising and falling. Rising and falling can wake the chip only on pins 2 and 6 of a port (and all pins can wake on change and low level), and while you can use attachInterrupt, it's as evil as ever (despite a heroic and ultimately unsuccessful effort to make it less so) and you're better off doing it manually with your own ISR.

the things you need to know are that there's one interrupt per port PORTx_PORT_vect,

It's controlled per pin by the PORTx.PINnCTRL registers' ISC bitfields (that register is Invert, InLevel (where supported), rsvd, rsvd, Pullup enable, ISC2, ISC1, ISC0)

0b000 is normal pin operation
0b100 is input sense disabled (should be set on all potentially floating pins or they should be prevented from floating before sleep, floating pins could always waste power,but effect seems more priominent now)
0b001, 010, 011 and 101 are the other wake options and I'm doing this from memory I forget which is which.
The other options are reserved

The interrupt MUST clear the PORTx.INTFLAG bit, which is done by writing a 1 to it (it's one of those backwards flag bits that are unchanged when written 0 and 0'ed when written 1).

If you only have one kind of interrupt coming in through a port, and the others are disabled, you can neglect handling them, which helps reduce code size and complexity significantly, and it's an ISR so those are extra important (well, execution time is what matters, but that's a function of code size and complexity pretty much). As always try not to call functions that won't be inlined in ISRs, use digitalWriteFast not normal digitalWrite, and so on (we have fast version of all the I/O functions, see Ref_Digital.md) (Which will impose a 40ish clock cycle penalty from the function call to a non-inlined function plus the 100+ clocks that monster uses because it has to turn off pwm). digitalWriteFast on constant pin is 1 clock cycle and 1 instruction. The VPORTs are also insanely useful here (each port has VPORTx.DIR, OUT, IN, and INTFLAGS) - these are just like the normal ones only faster: Setting or clearing a single bit (like one intflag or flipping 1 pin) takes just 1 clock cycle (cbi sbi- these were 2 clock instructions on classic AVR) when done through the VPORTs, and such access is atomic.
Assigning a value is 2 clocks (vs 4 to an arbitrary location in extended I/O section) and flipping more than 1 bit is 3 words 3 clocks (5 words 6 clocks if it were extended I/O) Ofc, neither of these are atomic).

The bare minimum interrupt overhead is 5 clocks in + body + 4 clocks out for a naked ISR, most ISRs should be clothed (naked ones must be written in asm, alter no working registers and perform no mathematical or comparison operation). The prologue and epiliog automatically added to non-naked ISRs adds like 15 clocks to the process. more if lots of temporary variable are used (because it has to save and restore every workign register you use - this is done automatically and reti automatically generated unless you're naked), this can be markedly worse than the minimum.

There's no equivalent of the enable mask. You're expected to use the PINnCFG registers

[coderatchance]

Thanks for the explanation! However, how come the wire.h cannot be used on the 406, while I can compile on the 806 ?
Using the Arduino 1.8.13 / UNO with the megaTinyCore via jtag2updi ...

Any ideas what could be wrong?

Arduino: 1.8.13 (Mac OS X), Board: "ATtiny3226/3216/1626/1616/1606/826/816/806/426/416/406, ATtiny406, 20 MHz internal, 1.8V (5 MHz or less), Disabled/Disabled, EEPROM retained, Enabled (default timer), UPDI (no reset pin), 8ms, Master or Slave (saves flash and RAM), Default (doesn't print floats, 1.4k flash use), On all pins, with new implementation., Disabled (recommended), No delay before window "opens""

Error:

/Users/imac/Library/Arduino15/packages/DxCore/tools/avr-gcc/7.3.0-atmel3.6.1-azduino6/bin/../lib/gcc/avr/7.3.0/../../../../avr/bin/ld: address 0x1092 of RGB_testiram_6.ino.elf section `.text' is not within region `text'
/Users/imac/Library/Arduino15/packages/DxCore/tools/avr-gcc/7.3.0-atmel3.6.1-azduino6/bin/../lib/gcc/avr/7.3.0/../../../../avr/bin/ld: RGB_testiram_6.ino.elf section `.rodata' will not fit in region `text'
/Users/imac/Library/Arduino15/packages/DxCore/tools/avr-gcc/7.3.0-atmel3.6.1-azduino6/bin/../lib/gcc/avr/7.3.0/../../../../avr/bin/ld: address 0x1092 of RGB_testiram_6.ino.elf section `.text' is not within region `text'
/Users/imac/Library/Arduino15/packages/DxCore/tools/avr-gcc/7.3.0-atmel3.6.1-azduino6/bin/../lib/gcc/avr/7.3.0/../../../../avr/bin/ld: region `text' overflowed by 265 bytes
collect2: error: ld returned 1 exit status
exit status 1
Error compiling for board ATtiny3226/3216/1626/1616/1606/826/816/806/426/416/406.


This report would have more information with
"Show verbose output during compilation"
option enabled in File -> Preferences.

[grandaspanna]

Your code is too big to fit in the target flash.

[coderatchance]

Thanks :) I have just realised that 👍

[coderatchance]

Hello!

Finally, this is a short interrupt test, namely pin change. Currently, I am on breadboard with at-tiny806, simply using a cable to enable the interrupt as pin change on pin, this is just a mockup to do the testing before I move to the sensor which will eventually fire the interrupt. Along side I am as well trying to measure the current. Of course, the meter is not perfect, however, current consumption in sleep on the pwr_down mode its sometimes 70uA sometimes 150uA, aded two elcos to the ground to minimize the inductivity... a bit more steady ... around 120uA, anyway, the awake consumption is around 5.8mA ...

Looking at the data-sheet on p. 437 (Table 31-5. Power Consumption in Power-Down, Standby and Reset Mode) and it seems I am not even close, of course, my measurements as way off...due to several factors. Either-way, I am simply measuring the current on the VDD (3.3V)...

Please comment wether this should now work on the proper interrupt pin from the sensor? Of course with the dedicated code for the sensor, instead of using my cable :)

#include <avr/sleep.h>

#define myINT PIN_PA6
#define myLED PIN_PA5

volatile byte myFlags = 0;
volatile bool ledOn;

ISR(PORTA_PORT_vect) {
  uint8_t flags = PORTA.INTFLAGS;   // read which pins triggered the int
  myFlags = flags;                  // store it in the volatile variable for loop to display
  PORTA.INTFLAGS = flags;          // Clear the flags by writing a 1 to them (not a 0);
  //power back?
  sleep_disable();
  //continues with the led on
  ledOn = true;
}

void setup() {
  Serial.begin(115200);
  delay(100);
  Serial.println("hello from setup");

  pinMode(myINT, INPUT_PULLUP); // interrupt pin
  pinMode(myLED, OUTPUT); // led pin

  // Enable the interrupt on change.
  PORTA.PIN6CTRL |= PORT_ISC_FALLING_gc; // int on change namely on PA6 ?

  //check what sleep mode you need!
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);

  //start with the led on
  ledOn = true;
}

void loop() {
  Serial.println("awake, turning on the led ...");
  //start with led “““““““
  if (ledOn == true) {
      digitalWrite(myLED, true);
  }
  //wait 4000ms
  delay(4000);
  //then go to sleep
  Serial.println("going to sleep ...");
  go_to_sleep();
}

void go_to_sleep() {
  //turn off the led
  ledOn = false;
  digitalWrite(myLED, ledOn);
  Serial.flush(); // wait until we're done sending everything, otherwise the serial prints won't come out
  sleep_enable();   //Unlocks the sleep instruction to prevent software bugs from putting the chip top sleep without a way to wake it up
  sleep_cpu();      // after the interrupt that wakes it finishes, you'll be here
}
```

[freemovers]

You are probably seeing the high, unpredictable power consumption since you have pins floating. You should read below 100nA after you fix that issue as follows: https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/PowerSave.md#unused-pins-and-sleep-modes

[coderatchance]

Thanks, will move to consumption part soon, however, according to my understanding interrupts can be used almost on any pin, port, however, if the PIN PA6 is used it works, while it does not on PIN PA7. Any idea, why ?

As far as I understand the sync interrupt goes along the clock, which should be fast as well, when I am on 20MHz,
or is there really such a big difference, for example, the interrupt is fired from the peripheral sensor ...

Best.

[coderatchance]

The consumption is sorted and my consumption in sleep mode, pwrdown is around 120uA along with sensor ...
Anyway, I have added the BOD as well, namely via pull down menu, interestingly, it works rather well, but only in sleep mode.
For example, when in sleep mode, I am fiddling around with the voltage between 1.4 and 3.3V and it powers well back when of course I am on 3.3V, however, if I do the same, while the processor is running, like LED on high (lit), it does not RESET the device and trying to recover, but blocks.

My Arduino dropdown menu settings are as follows:
BOD Voltage level ... : 2,6V
BOD Mode when active, sleeping ... : Enabled/Enabled

The interrupt is used for the sensor, to wake up the uC, while the WDT is used as "software reset", anyway, I am wondering, should not I have as well the RESET on the BOD while the processor is not in sleep...

Thanks for any comments, suggestions ...