Timers and Interrupts (to output to Composite or VGA)

[ITDiscovery]

I'm thoroughly hooked on the AVR128DB as a great upgrade to the now venerable ATMega328 and ATMega2560. I have a business card sized circuit board that mostly works, and I am looking to see what else I should put on it. What came immediately to mind was some sort of video output. I discovered quickly that the TVout and VGAx libraries would likely need to be significantly modified to work....so I need to now learn (or relearn) timers and interrupts.

This first sketch was modified from the Ref_Timers documentation, it creates a timer and links it to an interrupt service routine.

/* This sketch creates a timed interrupt which when handled
 * flips PIN_PA0. Good for PA0-7, PD1-7
 */

bool flag = LOW;

void setup() {
  TCA0.SINGLE.PER     = 0x00FF;            // 256 Ticks to TCA0_OVF_vect
  TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;    // enable overflow interrupt
  TCA0.SINGLE.CTRLA   = TCA_SINGLE_ENABLE_bm; // enable the timer with no prescaler
  pinMode(PIN_PA0,OUTPUT);
  }

void loop() { //Nothing here yet

}

// Overflow Code - 55KHz your code must complete before the next interrupt
ISR(TCA0_OVF_vect) {
  digitalWriteFast(PIN_PA0,flag);
  flag = !flag;
  TCA0.SINGLE.INTFLAGS  = TCA_SINGLE_OVF_bm; // Always remember to clear the interrupt flags, otherwise the interrupt will fire continually!
}

This works great as far as it goes as you can only change the period of the clock tick. The following code uses the COMPARE interrupt vector and also kinda doesn't works, but not as I expected. You can change the PER and CMP value and the ISR fires at the same rate. I did also add the required "takeTCA0();"...no difference.

/* This sketch creates a timed interrupt which when handled
 * flips PIN_PA0. Good for PA0-7, PD1-7
 */

bool flag = LOW;

void setup() {
    takeOverTCA0();
    TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV1_gc;
    TCA0.SINGLE.INTCTRL = TCA_SINGLE_CMP0EN_bm;
    TCA0.SINGLE.PER  = 0x00FF;            // 256 Ticks to TCA0_OVF_vect
    TCA0.SINGLE.CMP0 = 0x0080;
    TCA0.SINGLE.CTRLA |= TCA_SINGLE_ENABLE_bm;
    pinMode(PIN_PA0,OUTPUT);
  }

void loop() { //Nothing here yet

}

ISR(TCA0_CMP0_vect) {
  digitalWriteFast(PIN_PA0,flag);
  flag = !flag;
  TCA0.SINGLE.INTFLAGS = TCA_SINGLE_CMP0EN_bm;
}

I'm going to keep pecking away at it, but I am looking for a way to create a timer that I can use for a pixel clock. That's a pretty big ask, as the code in the ISR has to be fast enough to complete before the next pixel.

(Entry updated on 12/4/2021)

[SpenceKonde]

So you say it needs to run at 55 kHz. 55 iterations per ms - 18us is like 430+ clock cycles, even limiting yourself to the rated maximum speed of 24 MHz, (and these parts overclock crazy well, particularly the extended temperature range ones.

What do the signals you need to generate look like? I'm not familiar with that sort of video stuff. I've always been more of a fan of monochrome LCDs for microcontroller output, with nice digital interfaces and an absence of demanding timing constraints...

BTW - a general rule is that if you're "looking for things to add" to a design, you should ask yourself why you're doing that. The impulse to add features is often something that is counterproductive.

[ITDiscovery]

Thanks for the response Spence. Yes, LCDs are definitely easy, and the LiquidCrystal_I2C was one of the first projects I got going on the AVR128DB28 board.

The Resolution on TVout is 128x96 so it looks like that library does 128 clocks within 51.5uSecs, which is the NTSC "visible scan region", which is preceded by a 4.7uSec sync signal and a 5.9uSec "Back Porch" and followed by 1.7uSec "Front Porch". Looks like I need to look at how TVout does this since it doesn't seem like the math works.

The visible scan region is usually shipped out by simple bit shifting on two different ports. I started the task by trying to draw a line down the middle and ignoring vertical sync until I get the line working. I actually got a crude version working using delayMicroseconds and digitalFastWrite that the TV synced on. Doing right means learning timers and interrupts.

On the code side, I feel like I am missing setting and clearing the interrupts properly. I definitely think I didn't clear the compare properly, so I am going to try again next chance I get (which may be a few days). I'll be posting all my working examples.

[SpenceKonde]

You need to takeOverTCA0(); at the start - that does the hard reset, and tells the core to stop fucking with it. The core configures TCA0 for split mode, you're using it as if it were in single mode. , where it acts as two 8-bit timers that only downcount, run from the same oprescaled clock, but can have different periods.

I suspect there are some ways that the hardware could be convinced to make your life a lot easier - do you have any scope tracces of what the signal youwant to get out of it looks liker? these parts have all kinds of ways to do cool stuff without CPU interaction through the event system...

[ITDiscovery]

So having taken up your advice to use the timers in split mode (since I need HSync and VSync anyway)....I am working on modifying example 3 and adding ISRs. I'll post any working code.

[SpenceKonde]

two 8-bit downcounting timers with separate periods but same prescaler is better than a 16-bit one? okay then - I would have assumed the opposite, and that you'd want to use takeOverTCA0 to put it back into single mode.

Depending on what the signal has to look like, there are probably ways that magic could be worked with the CCL (driven from internal sources) or maybe an SPI peripheral running as slave in buffered mode (in slave mode, if you control the clock, you effectively have a shift register and can write bits 8 at a time and shift them out on some other clock. I still haven't gotten around to trying that for neopixels.... I'm pretty confident it will work though.

[ITDiscovery]

Your assumption on that "two down counters with separate periods but same prescaler..." is better than mine, because you understand how they work, and I'm still working my way back from 30 years ago when I had this in college. I've started posting the learning process to share the rare successes and the many failures.

As to SPI....that's exactly how the VGAx and TVout libraries work...the Pixel clock uses SPI to shove the pixels out as fast as possible. I'm very much not there yet.

[SpenceKonde]

Oh neat. I think if you do buffered mode, you want to set SPI0.CTRLB = SPI_BUFEN_bm | SPI_BUFFWR_bm
so that it doesn't need the 8-bit dummy byte. That would mean that DREIF would be set after 8 bits are sent, and you'd then have to have the interrupt fire within the next 8 bits to get another byte loaded.

[ITDiscovery]

I do have my timer -> interrupt example working for Low Undercount interrupt. Practical result is that the service routine runs at the start of and in sync with PD2 going high. Useful for resetting the pixel count on horizontal scan.

void setup() {
  //takeOverTCA0();  Do this and it doesn't work
  // We will be outputting PWM on PD2 amd PD3
  // No need to enable split mode - core has already done that for us.
  pinMode(PIN_PD2, OUTPUT); //PD2 - TCA0 WO1 - Horizontal Sync
  pinMode(PIN_PD3, OUTPUT); //PD3 - TCA0 WO2 - Pixel Clock
  pinMode(PIN_PA5, OUTPUT); /// Green Pixel Out
  PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc;
  TCA0.SPLIT.CTRLB  = TCA_SPLIT_LCMP2EN_bm | TCA_SPLIT_HCMP0EN_bm; //PWM on WO2, WO3
  TCA0.SPLIT.CTRLA  = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm; //Div8 = .4uSec
  TCA0.SPLIT.LPER   = 0x5F; // 95 times .4uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x10; // Count down from only 255 on WO3/WO4/WO5 (176.6KHz)
  TCA0.SPLIT.LCMP2  = 07; // 3% duty cycle
  TCA0.SPLIT.HCMP0  = 07; // 3% duty cycle
 
  TCA0.SPLIT.INTCTRL |= TCA_SPLIT_LUNF_bm; //
}

ISR(TCA0_LUNF_vect) {
  byte intflags = TCA0.SPLIT.INTCTRL;
  TCA0.SPLIT.INTFLAGS = TCA_SPLIT_LUNF_bm;
  digitalWriteFast(PIN_PA5,HIGH);
  digitalWriteFast(PIN_PA5,LOW);
}

void loop() {
  // put your main code here, to run repeatedly:
}

PA5 is on the bottom.
PD2 is on the top.

[SpenceKonde]

Note: takeOverTCA0 turns off split mode, so if you're using that, yeah, it wouldn't work.

confused as to what to objective of the two radically different frequencies which don't divide evenly into eachother is?

[SpenceKonde]

What part are you using, anyway? a 28/32, or a good one with the second TCA?

With the CCL, you can do things like "when this timer compare chanel is high AND some other condition that can be brought to event channel or CCL, this pin should be high otherwise low" using up to 3 inputs, and you can chain them into eachother.

[ITDiscovery]

Objective on a long path to learning timers and interrupts. I'm now working on getting 16-bit single mode with a CMP interrupt (example has OVF).

I'm using the little AVR128DB28. You'll find my circuit board a bit odd....it's in the shape of a business card, and has my work info on it. At least boards that have errors or don't get used don't go to waste.

[SpenceKonde]

I'm using the little AVR128DB28. You'll find my circuit board a bit odd....it's in the shape of a business card, and has my work info on it. At least boards that have errors or don't get used don't go to waste.

I've thought about that - though a board like that would have to (IMO) be absolutely perfect, with nothing even a little questionable about the design, because otherwise you're giving a client or business partner something that may not reflect as well on you as it should - you know what I mean?

[ITDiscovery]

Here's the timer to Overflow interrupt in SINGLE mode. My frequency counter came up with 9.378KHz for PD1. Example 8 will be using a CMP1 interrupt (I hope).

bool flag = 0;

void setup() {
  pinMode(PIN_PD1, OUTPUT);
  pinMode(PIN_PA1, OUTPUT);
  takeOverTCA0(); // this replaces disabling and resettng the timer, required previously.
  PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Set mux to PORTD
  TCA0.SINGLE.CTRLB   = (TCA_SINGLE_CMP1EN_bm | TCA_SINGLE_WGMODE_DSBOTTOM_gc); // Dual slope PWM mode OVF interrupt at BOTTOM, PWM on WO0.
  TCA0.SINGLE.PER     = 0x0500;        // 1280 X .05uSec ??
  TCA0.SINGLE.CMP1    = 07;            // 3% Duty Cycle
  TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;    // enable overflow interrupt
  TCA0.SINGLE.CTRLA   = TCA_SINGLE_CLKSEL_DIV1_gc | TCA_SINGLE_ENABLE_bm; // enable the timer with no prescaler
}

void loop() { // Not even going to do anything in here

}

ISR(TCA0_OVF_vect) {   
  digitalWriteFast(PIN_PA1,flag);
  flag = !flag;
  TCA0.SINGLE.INTFLAGS  = TCA_SINGLE_OVF_bm; // Always remember to clear the interrupt flags, otherwise the interrupt will fire continually!
}

[ITDiscovery]

So Example 8....Timer in Single mode, now configured like an NTSC horizontal sync pulse. Interrupt should be firing when the pulse goes low. What use case this would be for I have no idea, but here you go....Interrupt at CMP1. Sorry that PA0 looks so messy, I bought this scope in 1984.

Next up...two clocks...HSync and Pixel Clock...

bool flag = 0;

void setup() {
  pinMode(PIN_PD1, OUTPUT);
  pinMode(PIN_PA0, OUTPUT);
  takeOverTCA0(); // this replaces disabling and resettng the timer, required previously.
  PORTMUX.TCAROUTEA   = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Set mux to PORTD
  TCA0.SINGLE.CTRLB   = (TCA_SINGLE_CMP1EN_bm | TCA_SINGLE_WGMODE_DSBOTTOM_gc); // Dual slope PWM mode OVF interrupt at BOTTOM, PWM on WO0.
  TCA0.SINGLE.PER     = 0x0180;        // 31.260KHz
  TCA0.SINGLE.CMP1    = 0x0018;            // 4uSec Pulse
  TCA0.SINGLE.INTCTRL = TCA_SINGLE_CMP1_bm;    // enable overflow interrupt
  TCA0.SINGLE.CTRLA   = TCA_SINGLE_CLKSEL_DIV1_gc | TCA_SINGLE_ENABLE_bm; // enable the timer with no prescaler
}

void loop() { // Not even going to do anything in here
  //digitalWriteFast(PIN_PA1,flag);
  //flag =!flag;
}

ISR(TCA0_CMP1_vect) {
  digitalWriteFast(PIN_PA0,flag);
  flag = !flag;
  TCA0.SINGLE.INTFLAGS  = TCA_SINGLE_CMP1_bm; // Always remember to clear the interrupt flags, otherwise the interrupt will fire continually!
}

[ITDiscovery]

Quick side note: I couldn't get the example which this is derived from to work with PORTC. PortD....no problem...I didn't take the time to figure out why.

[SpenceKonde]

My first thought on why it might not have worked on PORTC is this:
PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Set mux to PORTD
That needs to be pointed to PORTC instead. But other than that? No idea.

[ITDiscovery]

Example 9: HSync on PD2, and an interrupt to fire 5 times per HSync....I need a SPI clock however. Example 9 just shows a toggle on PA5...I'll add the SPI push for Example 10.

void setup() {
  //takeOverTCA0();  Don't do this, turns off split mode.
  // We will be outputting PWM on PD2 amd PD3
  // No need to enable split mode - core has already done that for us.
  pinMode(PIN_PD2, OUTPUT); //PD2 - TCA0 WO1 - Horizontal Sync
  pinMode(PIN_PD3, OUTPUT); //PD3 - TCA0 WO2 - Pixel Clock
  pinMode(PIN_PA5, OUTPUT); /// Green Pixel Out
  PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Variety! Also on all parts!
  TCA0.SPLIT.CTRLB  = TCA_SPLIT_LCMP2EN_bm | TCA_SPLIT_HCMP0EN_bm; //PWM on WO2, WO3
  TCA0.SPLIT.CTRLA  = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm; //Div8 = .4uSec
  TCA0.SPLIT.LPER   = 0x5F; // 96 times .4uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x12; // Count to 18 WO3/WO4/WO5 (176.6KHz)
  TCA0.SPLIT.LCMP2  = 0x05; // 4uSec High Pulse
  TCA0.SPLIT.HCMP0  = 0x09; // 50% duty cycle, this can't be higer than HPER
 
  TCA0.SPLIT.INTCTRL |= TCA_SPLIT_HUNF_bm; 
}

ISR(TCA0_HUNF_vect) {
  byte intflags = TCA0.SPLIT.INTCTRL;
  TCA0.SPLIT.INTFLAGS = TCA_SPLIT_HUNF_bm;
  digitalWriteFast(PIN_PA5,HIGH);
  digitalWriteFast(PIN_PA5,LOW);
}

void loop() {
  // put your main code here, to run repeatedly:
}

[SpenceKonde]

What frequency SPI clock do you need again? if you give me a number, I may know some "trick" to it more easily, though I suspect it's going to involve a TCB and one of the other timers.... It's gonna involve 2 timers unless the gods really favor what you're trying to do.

[ITDiscovery]

1. "Why bother reading the intflags...": cleanup issue. I've removed it in Example 10.
2. "What frequency of the SPI clock do I need?" Anything equally divisible by PD2.... I fiddled with the timing from Ex 9...and that gives a good 8 ticks per sync.

  TCA0.SPLIT.LPER   = 0x5F; // 96 times .4uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x07; // Count to 8 WO3/WO4/WO5 (468KHz)
  TCA0.SPLIT.LCMP2  = 0x07; // 4uSec Low Pulse
  TCA0.SPLIT.HCMP0  = 0x04; // 50% duty cycle, this can't be higer than HPER

One byte per frame....nice for understanding what's going on...but terrible for a practical video out. Never mind the fact that I don't need to output the pixel clock for that use case...so using split is kinda stupid also....but handy for checking my timing.

Example 10 is currently not working IMHO because there's just not enough time to run the code before the next interrupt. Doing just this gives a stable output:

  digitalWriteFast(PIN_PA5,flag);
  flag = !flag;

This doesn't:

  digitalWriteFast(PIN_PA5,bitRead(0b01010101,pixclk));
  pixclk++;
  if (pixclk>8) pixclk=0;

Anyway...thanks for the input.

[SpenceKonde]

Okay, 2 things:

digitalWriteFast(pin,CHANGE); // toggles pin in 1 clock cycle.

bitread the least bad of those bit-level macros Arduino provides. but it's still kinda bad.

#define bitRead(value, bit) (((value) >> (bit)) & 0x01)

That will often get rendered as
ldi register, bit // 1 clock
start:
lsr value //1 clock
subi register, 1 // 1 clock
brne start // 2 clocks if register wasn't just zeroed out.

Now if you did
digitalWriteFast(PIN_PA5, !!(0b01010101 & pixclk) );
pixclk << 1;
if (!pixclk) pixclk = 1;
that would probably work much better, because there you're not repeating all the shifting each pass through.

The !! is an ugly way to make sure the value is always 0 or 1 - here it does actually matter because CHANGE is an option.
Another, clearer way is

digitalWriteFast(PIN_PA5, ((0b01010101 & pixclk) ? HIGH : LOW ));
That said, I'm surprised you were running out time doing that.... (you have millis disabled right? You def. need it disabled for this)
There is no way that even doing that inefficiently should be taking anything near 240 clocks...

I see LPER doing 97 counts (probably meant to be 96), but HPER doing 8, has lper = 12 * hper, rather than 8 * hper.....

So the scheme is, you have one timer doing an hsync every x microseconds, and during that time, you output y bits.
What is the longest reasonable value of X that will work? (I just don't have much of a feel for this sort of thing.

But you definitely don't want to be manually generating the pixel clock. nothing good will come of that.
ooh oh ohh

omg! You're using a single clock long pulse! You got this shit in the bag man! Use the event system to connect the HUNF generator to an event channel, and connect an appropriate EVOUT pin to that channel (pin 2 of any port, or pin7 with the portmux engaged; I'm actually currently merging a batch of changes from original author back into the DxCore version. atm). Then during a scanline your code can just relax and poll the SPI DREIF flag to know when to feed more data into it.... You could even count the pixels you've sent with a TCB.....

[ITDiscovery]

Yikes....lots to unpack there.

1. Yup...millis was set to TCB2, so changed to disabled.
2. I put PD2 on a frequency counter, it's getting really close to the magic 31.280KHz and the period is close to the 4uSec required. LPER value is correct, my note is likely wrong.
3. The scheme is that it does an HSync pulse every 64uSec and during that time, I output as many bits as I can (128 pixels is TVout, running on a 16MHz Arduino) during the 51.5uSec that the screen is on. I recall that my ZX81 spent most of it's time shoving bits to the display, and did it's processing during vertical rescan.
4. I'm plucking away at getting your suggestion of shifting the bits out working and post as Example 10.
5. I'll then work on "Use the event system to connect the HUNF generator to an event channel, and connect an appropriate EVOUT pin to that channel (pin 2 of any port, or pin7" which is a whole new area for me, and that will finish up the weekend for me.

I am a little confused on whether when I work towards number 5, whether I should be using SINGLE or SPLIT. That's my unfamiliarity with the Event system. A hint would be welcome...RTFM is also in my future.

[ITDiscovery]

Example 10, now that I have a 21st century scope. My conclusion is there is something else happening that is preventing the shift out of the bits. I'll work on Example 11, to "Use the event system to connect the HUNF....". I suspect this shows why this is the wrong way to do this, but it's a mystery to me as to why.

int pixclk = 12;
int pixdata = 0b000100000000;
bool flag = 0;

void setup() {
  //takeOverTCA0();  Don't do this, turns off split mode.
  // We will be outputting PWM on PD2 amd PD3
  // No need to enable split mode - core has already done that for us.
  pinMode(PIN_PD2, OUTPUT); //PD2 - TCA0 WO1 - Horizontal Sync
  pinMode(PIN_PD3, OUTPUT); //PD3 - TCA0 WO2 - Pixel Clock
  pinMode(PIN_PA5, OUTPUT); /// Green Pixel Out
  PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Variety! Also on all parts!
  TCA0.SPLIT.CTRLB  = TCA_SPLIT_LCMP2EN_bm | TCA_SPLIT_HCMP0EN_bm; //PWM on WO2, WO3
  TCA0.SPLIT.CTRLA  = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm; //Div8 = .4uSec
  TCA0.SPLIT.LPER   = 0x5F; // 96 times .04uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x07; // Count to 8 WO3/WO4/WO5 (187KHz)
  TCA0.SPLIT.LCMP2  = 0x0D; // 4uSec Low Pulse
  TCA0.SPLIT.HCMP0  = 0x04; // 50% duty cycle, this can't be higer than HPER
 
  TCA0.SPLIT.INTCTRL |= TCA_SPLIT_HUNF_bm; 
}

//This should happen 96/8 = 12 times for every Pulse on PD2
ISR(TCA0_HUNF_vect) {
  TCA0.SPLIT.INTFLAGS = TCA_SPLIT_HUNF_bm;
  //digitalWriteFast(PIN_PA5,CHANGE); This works...12 changes
  digitalWriteFast(PIN_PA5, (((pixdata) >> (pixclk)) & 0x01));  //This doesn't seem to work
  pixclk--;
  if (!pixclk) pixclk = 12;
}

void loop() {
  // put your main code here, to run repeatedly:
}

Doing only digitalWriteFast(Change)

Trying to shift out a bit pattern:

[ITDiscovery]

Example 11:

Creating an event that will "follow" PD3 that is running at 325KHz. This uses the "Simple Event" example in the Events library, modified so that it works on an AVR128DB28.

#include <Event.h>

void setup() {
  //takeOverTCA0();  Don't do this, turns off split mode.
  // We will be outputting PWM on PD2 amd PD3
  // No need to enable split mode - core has already done that for us.
  pinMode(PIN_PD2, OUTPUT); //PD2 - TCA0 WO1 - Horizontal Sync
  pinMode(PIN_PD3, OUTPUT); //PD3 - TCA0 WO2 - Pixel Clock
  pinMode(PIN_PA2, OUTPUT); /// Green Pixel Out
  PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Variety! Also on all parts!
  TCA0.SPLIT.CTRLB  = TCA_SPLIT_LCMP2EN_bm | TCA_SPLIT_HCMP0EN_bm; //PWM on WO2, WO3
  TCA0.SPLIT.CTRLA  = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm; //Div8 = .4uSec
  TCA0.SPLIT.LPER   = 0x5F; // 96 times .04uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x07; // Count to 8 WO3/WO4/WO5 (187KHz)
  TCA0.SPLIT.LCMP2  = 0x0D; // 4uSec Low Pulse
  TCA0.SPLIT.HCMP0  = 0x04; // 50% duty cycle, this can't be higer than HPER
 
  Event2.set_generator(gen2::pin_pd3); // Set pin PD3 as event generator
  Event2.set_user(user::evouta_pin_pa2); // Set EVOUTA as event user
  Event2.start();
}

void loop() {
  // put your main code here, to run repeatedly:
}

[ITDiscovery]

So I did change:

Event2.set_generator(gen2::pin_pd3);

to

Event2.set_generator(gen::tca0_hunf);

And it wonderfully gave me a pulse on PA2 on the fall of PD3. Is there a way to create a "servicer" piece of code as an event user, instead of forwarding it to PA2? Such as loading up SPI with a byte. No worries otherwise, I thought someone might find it a useful UC.

[SpenceKonde]

You should TOTALLY check out the logic library..... it is in many ways more poweful

Like, I think this will do much the same thing without the second pin. - only it also gives you two more inputs you could use for control... See also Logic examples like LatchNoSeq where you can use pulse event s to latch a logic block into one position or the other

#include <Logic.h>

void setup() {
  // don't need pinthe dummy pin to follow
  pinMode(PIN_PD3, OUTPUT); //PD3 - TCA0 WO2 - Pixel Clock
  //pinMode(PIN_PA4, OUTPUT); /// Green Pixel Out
  PORTMUX.TCAROUTEA = (PORTMUX.TCAROUTEA & ~(PORTMUX_TCA0_gm)) | PORTMUX_TCA0_PORTD_gc; // Variety! Also on all parts!
  TCA0.SPLIT.CTRLB  = /* NOT NEEDED NOW! TCA_SPLIT_LCMP2EN_bm | */ TCA_SPLIT_HCMP0EN_bm; //PWM on WO2, WO3
  TCA0.SPLIT.CTRLA  = TCA_SPLIT_CLKSEL_DIV8_gc | TCA_SPLIT_ENABLE_bm; //Div8 = .4uSec
  TCA0.SPLIT.LPER   = 0x5F; // 96 times .04uSec on WO0/WO1/WO2 (31.280KHz)
  TCA0.SPLIT.HPER   = 0x07; // Count to 8 WO3/WO4/WO5 (187KHz)
  TCA0.SPLIT.LCMP2  = 0x0D; // 4uSec Low Pulse
  TCA0.SPLIT.HCMP0  = 0x04; // 50% duty cycle, this can't be higer than HPER

  Logic0.enable = true;               // Enable logic block 0
  Logic0.input0 = in::masked;         // mask channel 0 - another input souirce could be used, (like, say, something that was high when this output should be high during thecurrent clock period)
  Logic0.input1 = in::masked;         // mask input 1
  Logic0.input2 = in::tca0;           // TCA0 = input 0 
  Logic0.output = out::enable;        // Enable logic block 0 output pin or PA4 (ATtiny))
  Logic0.filter = filter::disable;    // No output filter enabled // change to filter::sync to get 2 system clock delay betweenm edge on input and edge on output, or filter:filter for tweice that. 
  Logic0.truth = 0x02;                // Set truth table - HIGH if input is HIGH.

  // Initialize logic block 0
  Logic0.init();

  // Start the AVR logic hardware
  Logic::start();

[ITDiscovery]

Will do..I'll check this out.

[SpenceKonde]

SPI0.CTRLB = 0b110000xx where xx is mode, drive SS low while you want to output bytes.... those first two bits enable buffered mode and turn off wairt for resceive so the first byte isn't a dummy byte, then either enable DREIE or poll DREIF to know when there's room in the SPI buffer....

[ITDiscovery]

I got the chance to mess around with SPI to just do raw bit pushing. Here's what I tried to get working (without success):

const int tvsync = PIN_PA4; //1K resistor
const int tvcomp = PIN_PA5; //470 resistor - drive this one (MISO-0)
int sendbyte = 0x55;

void setup() {

 // Line 359 in SPI.C....makes sense that you need to route the signal to the pin,
 PORTMUX.SPIROUTEA = SPI_MUX | (PORTMUX.SPIROUTEA & (~PORTMUX_SPI0_gm));

 // Line 367 in SPI.C
 pinMode(tvcomp,OUTPUT); //MISO
 pinMode(tvsync,OUTPUT); //MOSI
 pinMode(PIN_PA6,OUTPUT); //SCLK

 // SPI0.CTRLA - B7: Not Used
 //              B6: MSb first (Step 5, Data Order)
 //              B5: Master Mode (Step 2, Select Master operation)
 //              B4: Double Clk (Step 3, Clk2X)
 //              B2-1: Prescale DIV/1 (Step 3, Prescale)
 //              B0: Enable SPI  (Step 8: Enable)
 SPI0.CTRLA = 0b0010001;
 
 // SPI0.CTRLB - B7: Buffer On (Step 6: Buffer)
 //              B6: Write goes to register (Step 6: Buffer)
 //              B5-3: Not Used
 //              B2: Enable Slave Select when Master (Step 7: Disable Multi-Master)
 //                  Step 1, If 1, the SPI does not use the !SS pin, and it can be used as a
 //                  regular I/O pin or other peripheral modules.
 //              B1,0: Mode (doesn't look to matter) (Step 4: Mode)
 SPI0.CTRLB = 0b11000100;

 // SPI0.INTCTRL - B7: RX Complete Interupt Enable
 //                B6: TX Competee Interupt Enable
 //                B5: Data Register Empty Interupt Enable
 //                B4: Slave Select Trigger Interupt Enable 
 //                B3-1: Not Used
 //                B0: Interupt Enable
 SPI0.INTCTRL = 0b00100000;
}

ISR(SPI0_INT_vect) {
      //Clear the SPI Flag...
      SPI0.INTFLAGS = 0b00000000;
      //Send another byte
      SPI0.DATA = sendbyte;
}

void loop() {
  // put your main code here, to run repeatedly:
  SPI0.DATA = sendbyte;
}

I'd welcome any input to see where I went astray.

[ITDiscovery]

Using the library, this works perfectly, the problem for me is that it also uses 3 pins that I can't use for anything else, defeating the purpose. Kinda a waste to chew up 3 pins just for that purpose.

int sendbyte = 0x55;
#include <SPI.h>
void setup() {
   pinMode(PIN_PA7, OUTPUT);
   SPI.begin();
}
void loop() {
  // put your main code here, to run repeatedly:
    digitalWrite(PIN_PA7, LOW);
    SPI.transfer(sendbyte);
}

[SpenceKonde]

1. Clearing of INTFLAGS is done by writing a 1 to them, not a 0.
2. You can't clear DRE flags, period, except by putting data into the buffer so that the register is no longher empty. You have to disable the interrupt when there's nothing left to send.
3. Don't write to SPI0.DATA during loop; you know there's no room for the data if loop is executing, otherwise the DRE interrupt would be firing.
4. How are you getting the clock signal to the SCK pin? Are you sure you have a clock coming out?

[SpenceKonde]

Oh and
5. You always lose all 4 SPI pins in slave mode as far as I can tell,
See the start of the second paragraph of section 28.3.2.2.3 of the DB datasheet, because the pdf has copy/paste blocked so I can't quote it here.

[ITDiscovery]

I'm going to wrapper SPIO a small assembler routine (writing assembler is easy, figuring out how to use "asm" not so much) to do the lifting of cranking pixels out, but this what I tweaked to get the timing. I'm working on Vertical Blanking and Sync.

/* This sketch creates loop that sends the correct signal to 
 * create an NTSC white line on the left and right of the screen.
 * Timing is very raw and unpredictable. No vertical sync either.
 */
const int tvsync = PIN_PD4; //1K resistor
const int tvcomp = PIN_PD5; //470 resistor

void setup() {
  // put your setup code here, to run once:
    pinMode(tvsync, OUTPUT);
    pinMode(tvcomp, OUTPUT);
    takeOverTCA0();
    TCA0.SINGLE.PER    = 0x05E0;            // 256 Ticks to TCA0_OVF_vect
    TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;    // enable overflow interrupt
    TCA0.SINGLE.CTRLA   = TCA_SINGLE_ENABLE_bm; // enable the timer with no prescaler
}

ISR(TCA0_OVF_vect)  {
      //Clear the OVF Flag...
      TCA0.SINGLE.INTFLAGS = TCA_SINGLE_OVF_bm;
      //Start of HSync 4.7uSec
      digitalWriteFast(tvsync, LOW);
      digitalWriteFast(tvcomp, LOW);
      delayMicroseconds(5);
      //Breezeway, CBurst, Back Porch 4.7uSec
      digitalWriteFast(tvsync, HIGH);
      digitalWriteFast(tvcomp, LOW);
      delayMicroseconds(1);
      //End Back Porch - Up to Black Level
      digitalWriteFast(tvsync, LOW);
      digitalWriteFast(tvcomp, HIGH);
      delayMicroseconds(6);
      //Begin Picture      

      //Start Left White Bar
      digitalWriteFast(tvsync, HIGH);
      digitalWriteFast(tvcomp, HIGH);
      delayMicroseconds(2);
      //End Left White Bar
      digitalWriteFast(tvsync, HIGH);
      digitalWriteFast(tvcomp, LOW);

      delayMicroseconds(43);
      //Start Right White Bar
      digitalWriteFast(tvsync, HIGH);
      digitalWriteFast(tvcomp, HIGH);
      delayMicroseconds(2);
      //End Right White Bar
      digitalWriteFast(tvsync, HIGH);
      digitalWriteFast(tvcomp, LOW);

      //End of Scan
}

void loop() {
  // put your main code here, to run repeatedly:

}

[ITDiscovery]

Vertical Sync works, and I've established where I can start shuffling out bits that represent pixels, and storing it via making that array bigger.

/* This sketch creates loop that sends the correct signal to 
 * create a bar on the left and right edges of an NTSC screen. 
 * Timing seems stable via the TCA0 overflow. Now has vertical sync.
 */
 

const int tvsync = PIN_PA4; //1K resistor
const int tvcomp = PIN_PA5; //470 resistor
byte scrnmem [526][1];
/* 1,2,3,7,8,9,263,264,265,269,270,271 = Equalize
4,5,6,266,267,268 = Sync
10-20,272-282 = Blanking
*/

int vsync = 0;

void setup() {
  // put your setup code here, to run once:
    pinMode(tvsync, OUTPUT);
    pinMode(tvcomp, OUTPUT);
    takeOverTCA0();
    TCA0.SINGLE.PER    = 0x05E0;            // 256 Ticks to TCA0_OVF_vect
    TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;    // enable overflow interrupt
    TCA0.SINGLE.CTRLA   = TCA_SINGLE_ENABLE_bm; // enable the timer with no prescaler

    pinMode(PIN_PA0,OUTPUT);

    // Screen memory setup
    scrnmem[1][1] = 0x01;
    scrnmem[2][1] = 0x01;
    scrnmem[3][1] = 0x01;
    scrnmem[263][1] = 0x01;
    scrnmem[264][1] = 0x01;
    scrnmem[265][1] = 0x01;
    scrnmem[7][1] = 0x01;
    scrnmem[8][1] = 0x01;
    scrnmem[9][1] = 0x01;
    scrnmem[269][1] = 0x01;
    scrnmem[270][1] = 0x01;
    scrnmem[271][1] = 0x01;
    scrnmem[4][1] = 0x02;
    scrnmem[5][1] = 0x02;
    scrnmem[6][1] = 0x02;
    scrnmem[266][1] = 0x02;
    scrnmem[267][1] = 0x02;
    scrnmem[268][1] = 0x02;
    //Top Blank  
    for (int i = 10; i <= 30; i++) {
      scrnmem[i][1]=0x03;
    }
    for (int i = 272; i <= 292; i++) {
      scrnmem[i][1]=0x03;
    }
    //Bottom Blank
    for (int i = 246; i <= 257; i++) {
      scrnmem[i][1]=0x03;
    }
    for (int i = 508; i <= 519; i++) {
      scrnmem[i][1]=0x03;
    }
}

ISR(TCA0_OVF_vect)  {
      //Clear the OVF Flag...
      TCA0.SINGLE.INTFLAGS = TCA_SINGLE_OVF_bm;
      vsync++;
      if (scrnmem[vsync][1] == 0) {     
             //Normal Video Line        
             //Start of HSync 4.7uSec
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             //Breezeway, CBurst, Back Porch 4.7uSec
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(1);
             //End Back Porch - Up to Black Level
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, HIGH);
             delayMicroseconds(6);
             //Begin Picture      
             //Start Left White Bar
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, HIGH);
             delayMicroseconds(2);
             //End Left White Bar
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(43);
             //Start Right White Bar
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, HIGH);
             delayMicroseconds(2);
             //End Right White Bar
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             //End of Scan
        } else if (scrnmem[vsync][1] == 1)  {
             //Vertical Blanking Interval - Equal
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(30);
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);                          
        } else if (scrnmem[vsync][1] == 2) {
             //Vertical Blanking Interval - Sync
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(30);
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
        } else if (scrnmem[vsync][1] == 3)  {
             //Vertical Blanking Interval - Blanking
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);   
         } else if (vsync==526) {
             vsync=0;
             digitalWriteFast(tvsync, LOW);
             digitalWriteFast(tvcomp, LOW);
             delayMicroseconds(5);
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);  
             }
}

void loop() {
  // put your main code here, to run repeatedly:

}

[ITDiscovery]

Thanks for adding 32MHz internal to 1.4.6 DxCore... I changed the clock to 32MHz and TCA0.SINGLE.PER = 0x07C0 and it works great...I can get 160 bits out without using ASM. I have some new boards coming in 2 weeks that I can up to 40MHz (hopefully), and Spence is sending me a DA board that I'll test out also.

[ITDiscovery]

So I after bumping up the speed to 32MHz, I then just threw on the C++ code for character based rendering....as you can see, um...no....it takes too long to fetch the character and the dot matrix for that row. I'll create some code that does screen based matrix generation (takes way more memory though).

On the positive side, it does kinda work!!

[SpenceKonde]

Neat - are you stil bitbanging it, or are you abusing SPI to pump out the bits? You'd like to be able to work while it's outputting the rows, instead of having to do it between rows.... which I think I calculated above was practical - as in you have enough time between bytes that you need to feed it that you don't spend the majority of your time in the prologue or epilogue of an ISR...

[ITDiscovery]

Bitbanging...I'm going to get that going first. I was really struggling with how to implement that, seems like you are required to use PA4-PA7 to gain that benefit. Another killer was that when I went from 24MHz to 32MHz, I lost the ability to use SPLIT on the timers (resolution), so no pixel clock to drive SPI (at least from TAC0).

~~
Is there an example of using the SPI (without the library) just to send out 8 bits on MOSI (based on SCLK0)?
No rush, I need to re-write the picture display screen anyway. Once that's done via bit-bang, SPI would drop right in.
~~
Nevermind, we covered this above...

Off-topic: Expecting the AVR128DA64 board you sent Monday, will be next weekend before I have much chance to mess with it. Update: recieved 1/27...gotta put pin headers on it..

[ITDiscovery]

I now have the C++ code rendering straight from memory, and now need to convert it to ASM so that I can control the timing. We'll see if I can increase the number of characters...best I can do is 14 columns.

             for (byte dispcol = 0; dispcol < 14; dispcol++) {
                 byte charrow = scrnmem[charmemloc];
                 charmemloc++;
                 for (byte i=0; i<8; i++) {
                    if( (charrow&0x80) ) {
                         digitalWriteFast(tvsync, LOW);
                         digitalWriteFast(tvcomp, HIGH);
                    } else {
                         digitalWriteFast(tvsync, HIGH);
                         digitalWriteFast(tvcomp, HIGH);
                    }
                 charrow<<=1;
                 //asm volatile ("nop");
                 }
             }        
             //End with Black
             digitalWriteFast(tvsync, HIGH);
             digitalWriteFast(tvcomp, LOW);
             charmemloc=charmemloc+6;
             //End of Scan     

[ITDiscovery]

So after 3 weeks (spent reading up how to do and practicing inline ASM), here's is my first UNTESTED run at creating the bit-banging loop:

             asm volatile (
             "     lds r23, (charmemeloc).       ;2 Load the pointer of the first character in the row into R23\n"
             "     add r26,r23                            ;1 Add the offset to the screen memory start \n"
             "     brcc 1f                                   ;2 Branch on a clear carry \n"
             "     inc r27                                  ;1 or add to the high bit \n"
             "     ldi r24, 0x0D                        ;1 Outer loop init (dispcol) \n"
             "1:   ld r25,X+                             ;2 Get the character pointed at by X, inc post fetch \n"
             "     ldi r22, 0x08                       ;1 Inner loop init (i) \n"
             "2:   ldi r21, 0x80                      ;1 Setup for bit compare \n"
             "     and r21,r25                        ;1 Compare for pixel on-off \n"
             "     brne 3f                               ;2 Branch to 3-forward on pixel on \n"             "
             "     cbi VPORTF, VPORTF0    ;2 TVSYNC,LOW \n"
             "     jmp 4f                               ;3 Jump to end of loop \n"
             "3:   sbi VPORTF, VPORTF0   ;2 TVSYC,HIGH \n"
             "4:   lsl r25                               ;1 rotate charrow left \n"
             "     dec r22                            ;1 decrement inner loop counter \n"
             "     nop                                 ;1 add nops to account for space between inner and outer loop \n"
             "     brne 2b                          ;2 branch on not zero back to top of inner loop \n"
             "     dec r24                          ;1 decrement outer loop \n"
             "     brne 1b                          ;2 branch on not zero back to top of outer loop \n"
             : :  "x" (scrnmem) : "r21","r22","r23","r24","r25"
              );
             
             
             //for (byte dispcol = 14; dispcol > 0; dispcol--) {
             //    byte charrow = scrnmem[charmemloc];
             //    charmemloc++;
             //    for (byte i=8; i>0; i--) {
             //       if( (charrow&0x80) ) {
             //            digitalWriteFast(tvsync, LOW);
             //            //digitalWriteFast(tvcomp, HIGH);
             //       } else {
             //            digitalWriteFast(tvsync, HIGH);
             //            //digitalWriteFast(tvcomp, HIGH);
             //       }
             //    charrow<<=1;
             //    //asm volatile ("nop");
             //    }
             //}        
             //End with Black

Note that I've removed the artifact of always writing TVCOMP as a high. I've also added the number of instruction cycles for each instruction, as I'll have to add NOPs to make sure there is no difference in timing as the next character is fetched.

[ITDiscovery]

Ok, this is rubbish.... charmemloc is 16bits not 8.