MySensors/hal/architecture/SAMD/MyHwSAMD.cpp

/*
 * The MySensors Arduino library handles the wireless radio link and protocol
 * between your home built sensors/actuators and HA controller of choice.
 * The sensors forms a self healing radio network with optional repeaters. Each
 * repeater and gateway builds a routing tables in EEPROM which keeps track of the
 * network topology allowing messages to be routed to nodes.
 *
 * Created by Henrik Ekblad <henrik.ekblad@mysensors.org>
 * Copyright (C) 2013-2026 Sensnology AB
 * Full contributor list: https://github.com/mysensors/MySensors/graphs/contributors
 *
 * Documentation: http://www.mysensors.org
 * Support Forum: http://forum.mysensors.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 */

#include "MyHwSAMD.h"

/*
int8_t pinIntTrigger = 0;
void wakeUp()	 //place to send the interrupts
{
	pinIntTrigger = 1;
}
void wakeUp2()	 //place to send the second interrupts
{
	pinIntTrigger = 2;
}

// Watchdog Timer interrupt service routine. This routine is required
// to allow automatic WDIF and WDIE bit clearance in hardware.
ISR (WDT_vect)
{
	// WDIE & WDIF is cleared in hardware upon entering this ISR
	wdt_disable();
}
*/


void hwReadConfigBlock(void *buf, void *addr, size_t length)
{
	uint8_t *dst = static_cast<uint8_t *>(buf);
	const int offs = reinterpret_cast<int>(addr);
	(void)eep.read(offs, dst, length);
}

void hwWriteConfigBlock(void *buf, void *addr, size_t length)
{
	uint8_t *src = static_cast<uint8_t *>(buf);
	const int offs = reinterpret_cast<int>(addr);
	// use update() instead of write() to reduce e2p wear off
	(void)eep.update(offs, src, length);
}

uint8_t hwReadConfig(const int addr)
{
	return eep.read(addr);
}

void hwWriteConfig(const int addr, uint8_t value)
{
	(void)eep.update(addr, value);
}

bool hwInit(void)
{
#if !defined(MY_DISABLED_SERIAL)
	MY_SERIALDEVICE.begin(MY_BAUD_RATE);
#if defined(MY_GATEWAY_SERIAL)
	while (!MY_SERIALDEVICE) {}
#endif
#endif

	SYSCTRL->VREF.reg |= SYSCTRL_VREF_TSEN; // Enable the temperature sensor
	while (ADC->STATUS.bit.SYNCBUSY ==
	        1); // Wait for synchronization of registers between the clock domains

	const uint8_t eepInit = eep.begin(MY_EXT_EEPROM_TWI_CLOCK, &Wire);
#if defined(SENSEBENDER_GW_SAMD_V1)
	// check connection to external EEPROM - only sensebender GW
	return eepInit==0;
#else
	(void)eepInit;
	return true;
#endif
}

void hwWatchdogReset(void)
{
	// TODO: Not supported!
}

void hwReboot(void)
{
	NVIC_SystemReset();
	while (true);
}

int8_t hwSleep(uint32_t ms)
{
	// TODO: Not supported!
	(void)ms;
	return MY_SLEEP_NOT_POSSIBLE;
}

int8_t hwSleep(const uint8_t interrupt, const uint8_t mode, uint32_t ms)
{
	// TODO: Not supported!
	(void)interrupt;
	(void)mode;
	(void)ms;
	return MY_SLEEP_NOT_POSSIBLE;
}

int8_t hwSleep(const uint8_t interrupt1, const uint8_t mode1, const uint8_t interrupt2,
               const uint8_t mode2,
               uint32_t ms)
{
	// TODO: Not supported!
	(void)interrupt1;
	(void)mode1;
	(void)interrupt2;
	(void)mode2;
	(void)ms;
	return MY_SLEEP_NOT_POSSIBLE;
}

bool hwUniqueID(unique_id_t *uniqueID)
{
	// No padding required, as unique ID is already 16 bytes
	(void)memcpy(reinterpret_cast<uint8_t *>(uniqueID), (uint32_t *)0x0080A00C, 4);
	(void)memcpy(reinterpret_cast<uint8_t *>(uniqueID) + 4, (uint32_t *)0x0080A040, 12);
	return true;
}

// Wait for synchronization of registers between the clock domains
static __inline__ void syncADC() __attribute__((always_inline, unused));
static void syncADC()
{
	while (ADC->STATUS.bit.SYNCBUSY);
}

uint16_t hwCPUVoltage(void)
{
	// Set ADC reference to internal 1v
	ADC->INPUTCTRL.bit.GAIN = ADC_INPUTCTRL_GAIN_1X_Val;
	ADC->REFCTRL.bit.REFSEL = ADC_REFCTRL_REFSEL_INT1V_Val;
	syncADC();
	// Set to 10 bits reading resolution
	ADC->CTRLB.reg = ADC_CTRLB_RESSEL_10BIT | ADC_CTRLB_PRESCALER_DIV256;
	syncADC();
	// Select MUXPOS as SCALEDIOVCC/4 channel, and MUXNEG as internal ground
	ADC->INPUTCTRL.bit.MUXPOS = ADC_INPUTCTRL_MUXPOS_SCALEDIOVCC_Val;
	ADC->INPUTCTRL.bit.MUXNEG = ADC_INPUTCTRL_MUXNEG_GND_Val;
	syncADC();
	// enable ADC
	ADC->CTRLA.bit.ENABLE = 1;
	syncADC();
	// start conversion
	ADC->SWTRIG.bit.START = 1;
	// clear the Data Ready flag
	ADC->INTFLAG.bit.RESRDY = 1;
	syncADC();
	// start conversion again, since The first conversion after the reference is changed must not be used.
	ADC->SWTRIG.bit.START = 1;
	// waiting for conversion to complete
	while (!ADC->INTFLAG.bit.RESRDY);
	syncADC();
	const uint32_t valueRead = ADC->RESULT.reg;
	// disable ADC
	ADC->CTRLA.bit.ENABLE = 0;
	syncADC();
	// value is 1/4 scaled, multiply by 4
	return valueRead * 4;
}

uint16_t hwCPUFrequency(void)
{
	// TODO: currently reporting compile time frequency (in 1/10MHz)
	return F_CPU / 100000UL;
}

int8_t hwCPUTemperature(void)
{
	// taken from https://github.com/arduino/ArduinoCore-samd/pull/277
	// Set to 12 bits resolution
	ADC->CTRLB.reg = ADC_CTRLB_RESSEL_12BIT | ADC_CTRLB_PRESCALER_DIV256;
	syncADC();
	// Ensure we are sampling slowly
	ADC->SAMPCTRL.reg = ADC_SAMPCTRL_SAMPLEN(0x3f);
	syncADC();
	// Set ADC reference to internal 1v
	ADC->INPUTCTRL.bit.GAIN = ADC_INPUTCTRL_GAIN_1X_Val;
	ADC->REFCTRL.bit.REFSEL = ADC_REFCTRL_REFSEL_INT1V_Val;
	syncADC();
	// Select MUXPOS as temperature channel, and MUXNEG as internal ground
	ADC->INPUTCTRL.bit.MUXPOS = ADC_INPUTCTRL_MUXPOS_TEMP_Val;
	ADC->INPUTCTRL.bit.MUXNEG = ADC_INPUTCTRL_MUXNEG_GND_Val;
	syncADC();
	// Enable ADC
	ADC->CTRLA.bit.ENABLE = 1;
	syncADC();
	// Start ADC conversion
	ADC->SWTRIG.bit.START = 1;
	// Clear the Data Ready flag
	ADC->INTFLAG.reg = ADC_INTFLAG_RESRDY;
	syncADC();
	// Start conversion again, since The first conversion after the reference is changed must not be used.
	ADC->SWTRIG.bit.START = 1;
	// Wait until ADC conversion is done
	while (!(ADC->INTFLAG.bit.RESRDY));
	syncADC();
	// Get result
	// This is signed so that the math later is done signed
	const int32_t adcReading = ADC->RESULT.reg;
	// Clear result ready flag
	ADC->INTFLAG.reg = ADC_INTFLAG_RESRDY;
	syncADC();
	// Disable ADC
	ADC->CTRLA.bit.ENABLE = 0;
	syncADC();
	// Factory room temperature readings
	const uint8_t roomInteger = (*(uint32_t *)FUSES_ROOM_TEMP_VAL_INT_ADDR &
	                             FUSES_ROOM_TEMP_VAL_INT_Msk)
	                            >> FUSES_ROOM_TEMP_VAL_INT_Pos;
	const uint8_t roomDecimal = (*(uint32_t *)FUSES_ROOM_TEMP_VAL_DEC_ADDR &
	                             FUSES_ROOM_TEMP_VAL_DEC_Msk)
	                            >> FUSES_ROOM_TEMP_VAL_DEC_Pos;
	const int32_t roomReading = ((*(uint32_t *)FUSES_ROOM_ADC_VAL_ADDR & FUSES_ROOM_ADC_VAL_Msk) >>
	                             FUSES_ROOM_ADC_VAL_Pos);
	const int32_t roomTemperature = 1000 * roomInteger + 100 * roomDecimal;
	// Factory hot temperature readings
	const uint8_t hotInteger = (*(uint32_t *)FUSES_HOT_TEMP_VAL_INT_ADDR & FUSES_HOT_TEMP_VAL_INT_Msk)
	                           >>
	                           FUSES_HOT_TEMP_VAL_INT_Pos;
	const uint8_t hotDecimal = (*(uint32_t *)FUSES_HOT_TEMP_VAL_DEC_ADDR & FUSES_HOT_TEMP_VAL_DEC_Msk)
	                           >>
	                           FUSES_HOT_TEMP_VAL_DEC_Pos;
	const int32_t hotReading = ((*(uint32_t *)FUSES_HOT_ADC_VAL_ADDR & FUSES_HOT_ADC_VAL_Msk) >>
	                            FUSES_HOT_ADC_VAL_Pos);
	const int32_t hotTemperature = 1000 * hotInteger + 100 * hotDecimal;
	// Linear interpolation of temperature using factory room temperature and hot temperature
	const int32_t temperature = roomTemperature + ((hotTemperature - roomTemperature) *
	                            (adcReading - roomReading)) / (hotReading - roomReading);
	return static_cast<int8_t>(((temperature / 1000) - MY_SAMD_TEMPERATURE_OFFSET) /
	                           MY_SAMD_TEMPERATURE_GAIN);
}


uint16_t hwFreeMem(void)
{
	// TODO: Not supported!
	return FUNCTION_NOT_SUPPORTED;
}