MegaCoreX is Arduino compatible out of the box, but also includes extra functionality that's not available on the official Arduino "megaavr" core. This is functionality that I personally have been missing in the official Arduino API, and have added to MegaCoreX instead.

My goal isn't to "Arduino wrap" all hardware functionality the megaAVR-0 series brings to the table, but to expose functionality advanced users may benefit from and actually use. If you have a very niche application that utilizes one of the more obscure features the chip has, you're probably better off writing the low-level code yourself. Very spesific needs for ADC readings? Obscure timer needs? Read the approperiate Microchip application note!

• Analog read resolution
• Fast IO
• Peripheral pin swapping
• pinConfigure
• Printf support
• pwmWrite
• pwmPrescaler
• pwmSetResolution

The default analog read resolution for these chips is 10 bit, which gives you values between 0 - 1023. If you need lower resolution you can turn it down to 8 bits instead, which gives you values between 0 - 255. Simply call analogReadResolution like this:

analogReadResolution(8);  // Set resolution to 8 bits
analogReadResolution(10); // Set resolution to 10 bits

For timing critical applications the standard digitalRead() and digitalWrite() functions may be too slow. To solve this, MegaCoreX also includes some improved variants that compiles down to a single instruction. Call digitalReadFast(myPin) or digitalWriteFast(mypin, state) to use these.
Note that the pin number and pin state has to be known at compile time!

uint8_t digitalReadFast(uint8_t pinNumber);
void digitalWriteFast(uint8_t pinNumber, uint8_t state);

The megaAVR-0 microcontrollers support alternative pin assignments for some of their built-in peripherals. This is specified by invoking the swap() or pins() method before begin() for the associated peripheral. They will return true if that swap or pin combination is supported. For Serial peripherals the method is pins(tx,rx), for Wire it's pins(sda,scl) and for SPI it's pins(mosi,miso,sck,ss). (Note that this is the same pin sequence as used for the ESP8266 pins method, but the opposite of the one SoftwareSerial uses.)

Note that swap() and pins() do the exact same thing, but swap() is MUX swap oriented, while pins() is pin oriented.

If you want to use this feature to implement communication with two different external devices connected to different pins using one internal peripheral, note that the proper way to switch is first to invoke end() to cleanly shut down, then swap() or pins() to switch assigned pins, and finally begin() to cleanly start again.

swap() or pins() are called like this. Use either swap() or pins(), not both!

// UART pin swapping
Serial3.swap(1);
Serial3.begin(9600);

// Wire pin swapping
Wire.swap(1);
Wire.begin();

// SPI pin swapping
SPI.swap(1);
SPI.begin();

Available pin combinations for the 48 pin standard pinout are:

Available pin combinations for the 28 pin and 32 pin standard pinouts are:

Available pin combinations for the Uno WiFi pinout are:

Available pin combinations for the Nano Every pinout are:

pinConfigure is a template based function that exposes all functions that can be configured on a per-pin basis. The first argument is the Arduino pin number to configure, and the second to nth parameter are the configuration parameters. The order the arguments has does not matter. The function will set the pin functionality regardless if it "makes sense" or not. If you enable interupts on a pin and there's no interrupt handler in your code, the microcontroller will crash.

template <typename... MODES>
void pinConfigure(const uint8_t digital_pin, const pin_configure_t mode, const MODES&... modes);

// Set pin PA0 to output and drive the pin high
pinConfigure(PIN_PA0, PIN_DIR_OUTPUT, PIN_OUT_HIGH);
// Disable pin PA1 completely to save power
pinConfigure(PIN_PA1, PIN_INPUT_DISABLE);

The following parameters ca be used to set the pinConfigure modes:

Unlike the official Arduino core, MegaCoreX has printf support out of the box. If you're not familiar with printf you should probably read this first. It's added to the Print class and will work with all libraries that inherit Print. Printf is a standard C function that lets you format text much easier than using Arduino's built-in print and println.

Note that the default printf implementation will NOT print floats or doubles by default. This is a limitation of the avr-libc printf implementation on AVR microcontrollers, but can be enabled by setting a build flag. This can easily be done if you're using PlatformIO.

If you're using a serial port, simply use Serial.printf("Milliseconds since start: %ld\n", millis());. Other common libraries that inherit the Print class (and thus supports printf) are SoftwareSerial, the LiquidCrystal LCD library and the u8g2 graphical LCD library.

The Arduino pinout definition and the analogWrite function have the PWM output pins pre-defined, and can't be moved or routed to different pins using the default Arduino API, even though the chip itself supports this. The pwmWrite function lets to use every supported PWM output pin, and you can route the PWM signals as you like. Note that the chip limits which timer output can be routed to which pins, and you also need to make sure you don't route the PWM signal to a pins that's used for something else, like UART or SPI. Also keep in mind that the timer used for millis/micros is occupied and can not be used for PWM generation. For the Nano Every 4809 and Uno Wifi Rev2 this means timer TCB2, and for all the other pinouts TCB2. Also note that low-pinout parts does not have timer TCB3 and all the routing pin options due to the lack of physical IO.

void pwmWrite(pwm_timers_t pwmTimer, uint16_t val, timers_route_t timerRoute);

// Route timer TCB0 PWM output to pin PF4 and set the duty cycle to 50% (128/255)
pwmWrite(TCB_0, 128, ROUTE_TCB0_PF4);
// Set the timer TCB0 duty cycle to 30% but leave the routing as is
pwmWrite(TCB_0, 76);
// Route all TCA0 timer to PORTA, enable the 2nd TCA0 PWM output (PA2 in this case), and set dyty cycle to 50%
pwmWrite(TCA0_2, 128, ROUTE_TCA0_PORTA);

pwmPrescaler sets the clock source that drives timer. Timer TCA0 has the most options, while the TCB timers have fewer. The prescaler direcly affects the PWM frequency, and this is the formula that determines the frequency: F_CPU / resolution / prescaler. For instance, the default TCB PWM prescaler with a system clock of 16 MHz is 1/64, which results in a PWM frequency of just under 1 kHz.

void pwmPrescaler(pwm_timers_t pwmTimer, timers_prescaler_t prescaler);

// Set the TCA0 timer prescaler to 1/64 of the system clock frequency
pwmPrescaler(TCA0_0, TCA_DIV64);
// Set timer TCB0 to run off the TCA0 clock
pwmPrescaler(TCB_0, TCB_CLKTCA);
// Set timer TCB1 prescaler to 1/2 of the system clock frequency
pwmPrescaler(TCB_1, TCB_DIV2);

This function lets you change the PWM resolution in favour of increased PWM frequency. The default PWM range is 0-255, but the upper limit can be set to anything between 1 and 254. The resolution also affects the PWM frequency. The frequency can be calculated using this formula:
F_CPU / resolution / prescaler

void pwmSetResolution(pwm_timers_t pwmTimer, uint8_t maxValue);

// Set TCA0 timer max value to 127
pwmSetResolution(TCA0_0, 127);
// Set TCB0 timer max value to 31
pwmSetResolution(TCB_0, 31);
// Set TCB1 timer max value to 99
pwmSetResolution(TCB_1, 99);