AVR Freaks

The Event System (EVSYS) basically allows one peripheral to control another. On devices with DMA you can do stuff like have the DMA copy data from a USART when a byte received event is generated, replacing the usual interrupt handler. Since these don't have DMA the system is a bit more limited. You can clock counters from other peripherals, say a pin change event on a GPIO or the custom logic.

TCA has waveform generation (advanced PWM) capability, TCB has the ability to timestamp inputs which lets you measure periods or determine frequency. The latter can be quite handy for stuff like MODBUS where the end of a frame is a gap, which you can use TCB to measure. Actually you can use the pin change event to do that with TCA too I think, I haven't looked at it.

CRC does seem to have been nerfed a bit compared to the XMEGA, you kinda wonder why they bother having it just for flash and not adding a CPU interface that would have been incredibly useful.

USART in SPI mode is master only, so there is no SS pin. The main advantage is that it's buffered, where as the SPI peripherals are not.

This is my thinking on the event system:

On the 328p you might write an interrupt handler, triggered by an "input" peripheral, to change the state of an "output" peripheral.  The event system lets you shortcut the function of the interrupt handler.  And in some cases I believe the behavior is asynchronous.

If anyone is interested I just made my code for running the 4808/4809 available on GitHub: 

https://github.com/flitebits/rclib

This is a basic example of bringing up the ATMega 4808/4809 and enabling the most common hardware. I wrote this so I could use it to control various features in RC aircraft (telemetry and lights mostly).

It has support for:

• SBus protocol (channel information from radio, inverted serial)
• S.Port Protocol (only for volts/amps reporting, bi-directional 1-wire inverted serial)
• DSHOT 600 (bit bang) to set motor speed and get telemetry from newer ESCs
• Analog to Digital conversion (to read battery volts/amps)
• PWM for controlling 'dumb' leds
• APA102 (via SPI) & WS2812 (via bit bang)
• Serial used by several protocols above as well as for debugging
• Some simple RGB functions for LED control
• Very minimal debugging log/print support
• RTC clock
•  

Licensed under the Apache 2.0 license (see the file LICENSE-2.0 for details).

Please let me know if you decide to use it.

I also have some small board designs for the 4808/4809 that I may include as well at some point if there is interest.

Warmest Regards,

Flite Bits flitebits@gmail.com

Product Change Notification - SYST-19FKNH955 - 22 Jun 2020 - Data Sheet - ATmega4808/4809 Data Sheet

"Removed the content of the Instruction Set Summary section. This section now refers to the external Instruction Set Manual instead."

Hmmph.  I like having the summary in the datasheet (although I liked the old and briefer Atmel-style summary better.)

The TCB issue is a bit nasty for PWM mode.  You can't update the duty cycle w/o updating the period at the same time.

WAS:

  /* update duty cycle */
  TCB1.CCMPL = dcc;

IS (using knowledge of how 16-bit writes are implemented by the compiler):

  /* update duty cycle */
  TCB1.CCMPL = dcc;
  TCB1.CCMPH = 255;

You can also preserve the current period if wanted. These 16bit registers are best treated as a 16bit register on reads and writes, so as not to get confused by the temp register. Even if I knew the period in this case, I would still write as a 16bit value-  TCB1.CCMP = (255<<8)|duty; 

Another thing that probably is just a matter of low odds so goes unseen, is the temp register usage in an isr. If you are using a peripheral in an isr that will modify the temp register, and main code is also doing something in the peripheral that uses the temp register (same temp is shared for all 16bit in peripheral), you have the possibility of the isr corrupting the temp register the main code is in the middle of using. The temp register can be backed up and restored in the isr code, or you guard the main code from interrupts. Probably an easily overlooked thing, and may be easier to put the responsibility in the isr code and let main code run without having to remember to interrupt guard.

    //duty=L, period=H
    uint8_t dutyVal = 123;
    TCB1.CCMP = (TCB1.CCMP & 0xFF00) | dutyVal;
    /*
        lds r24,2716        //r24 = L/duty, H/period -> TEMP
        lds r25,2716+1      //r25 = H/period (TEMP)
        clr r24
        ori r24,123         //r24 = 123
        sts 2716,r24        //L/duty (TEMP) = 123
        sts 2716+1,r25      //H/period = r25 (unchanged), TEMP->L/duty
    */