Konfiguracja płytki z MAX31865 i PT100 - błąd zakresu pomiaru temperatury

jony napisał:

Co to dokładnie oznacza? Nie wchodzi do przerwania, nie wychodzi?
Masz sprzętowy debuger? (na jakim środowisku procujesz i jaki programator)
I może dodaj sobie diodę do debugowania. Albo wykorzystaj LCD do debugowania.
Aby dowiedzieć się do którego momentu program dochodzi.
Np,wyświetla się napis HOT ON?

A tak swoją drogą to co to ma być?

while(!(SPR_GORA) || !(SPR_DOL) || !(SPR_GORA));
Dwa razy SPR_GORA ?


@ElektrodaBot
Przeanalizuj poniższy kod dla AVR64DD28 pod względem poprawności i logiki działania.
I co może być przyczynom nie wykonywania się przerwań.


/*
* PROBA_AVR64DD.c
* main()
* uC:AVR64DD28
*/
#define F_CPU 8000000uL
#include
#include
#include
#include "cofig_DD.h"
#include "MAX31865.h"
#include "TCA_DD_NormalMode.h"
#include "RTC_DD.h"
#include
#include "LCD1602.h"
#include
#include


uint8_t eeprom_adr = EE_addr_config;

uint8_t pomiar=0;
volatile uint8_t KoniecPomiaru=0;
static uint16_t CMP_temp=0;
uint16_t CMP_MocMinimalna=0;
uint16_t CMP_MocPosrednia=0;
uint16_t CMP_MocMaxymalna=0;
uint16_t CzasGzania=0;
volatile uint16_t LicznikMinut=0;
volatile uint16_t licznik_sekund=0;

bool kontrol_m=FALSE;

float t_sond[]={0.0,0.0}; // Temperatury aktualne sąd
uint16_t RTDmax_min_1[]={0x0000,0x0000}; // [0] temperatura maxymalna, [1] temperatura Minimalna
float t_sond_maxEE[]={0.0,0.0}; // temp zczytane z EEpromu na postawie RTDmax_min_1[]


uint8_t FLASH_0_read_eeprom_byte(uint8_t eeprom_adr)
{
return (*(uint8_t *)(EEPROM_START + eeprom_adr));
}



void FLASH_0_write_eeprom_byte( uint8_t eeprom_adr, uint8_t data)
{
while (NVMCTRL.STATUS & (NVMCTRL_EEBUSY_bm | NVMCTRL_FBUSY_bm));

CCP = CCP_SPM_gc;
NVMCTRL_CTRLA = NVMCTRL_CMD_EEERWR_gc; // erase/write

*(uint8_t *)(EEPROM_START + eeprom_adr) = data;

CCP = CCP_SPM_gc;
NVMCTRL.CTRLA = NVMCTRL_CMD_NONE_gc;
}


void ustaw_bit_EE(uint8_t addrEE,uint8_t bit,uint8_t wart) // (adres EEprom / nr. bitu / wartość bitu
{
uint8_t odczyt;
odczyt= FLASH_0_read_eeprom_byte(addrEE);
if(wart==1) odczyt |= 1< if(wart==0) odczyt &= ~(1< FLASH_0_write_eeprom_byte( addrEE, odczyt);
}


void init_EEprom(void)
{

if ((FLASH_0_read_eeprom_byte(EE_addr_config) & 0x80)) // W założeniu. niniejsze winno wykonać się tylko raz z nowym uC
{
uint8_t i=0;
for(i;i<=30;i++)
{
FLASH_0_write_eeprom_byte( i, 0x00);
}

ustaw_bit_EE(EE_addr_config,ustaw_SondyAktywna_1_bp,1);
ustaw_bit_EE(EE_addr_config,ustaw_SondyAktywna_2_bp,0);


FLASH_0_write_eeprom_byte(CzasGrzaniaG1_L,0x02);
FLASH_0_write_eeprom_byte(CzasGrzaniaG1_H,0x00);
FLASH_0_write_eeprom_byte(TempMAX_Sonda_1_LSB,0xd6);
FLASH_0_write_eeprom_byte(TempMAX_Sonda_1_MSB,0x21);

FLASH_0_write_eeprom_byte(TempMIN_Sonda_1_LSB,0x41);
FLASH_0_write_eeprom_byte(TempMIN_Sonda_1_MSB,0x21);
FLASH_0_write_eeprom_byte(Pojemnosc_1,0x14);
FLASH_0_write_eeprom_byte(MocMin1,0x0A);

}
//if ( !(FLASH_0_read_eeprom_byte(EE_addr_config) & spr_F_CPU_bm)) {
// Przypuszczałem że, jezeli FRQSEL jest zabezpieczone CCP, to jednorazowe wpisanie wartosci FRQSEL_8M_gc pozostanie w pamieci po resecie uC
// Jednak tak nie jest. Więc powyższa linia do wykasowania.

CCP = CCP_IOREG_gc;
CLKCTRL.OSCHFCTRLA = CLKCTRL_FRQSEL_8M_gc;// OK
ustaw_bit_EE( EE_addr_config,ustaw_FCPU_bm,1);

}//end init_EEprom(void)









void TemperaturyDoTabel(void)
{
static uint16_t RTD1=0;
uint16_t temp_x=0;


RTD1 = (FLASH_0_read_eeprom_byte(TempMAX_Sonda_1_MSB)<<8) | FLASH_0_read_eeprom_byte(TempMAX_Sonda_1_LSB ); // odczytane OK
SPIWriteRegister((High_Fault_Threshold_MSB+reg_WRITE),(uint8_t)(RTD1>>8));
SPIWriteRegister((High_Fault_Threshold_LSB+reg_WRITE),(uint8_t)(RTD1));
RTDmax_min_1[0]=RTD1; // temperatura MaX
t_sond_maxEE[0]=MAX31865_get_temperature(RTD1);

RTD1 = (FLASH_0_read_eeprom_byte(TempMIN_Sonda_1_MSB)<<8) | FLASH_0_read_eeprom_byte(TempMIN_Sonda_1_LSB ); //Odczytane OK
SPIWriteRegister((Low_Fault_Threshold_MSB+reg_WRITE), RTD1>>8);
SPIWriteRegister((Low_Fault_Threshold_LSB+reg_WRITE),RTD1);
RTDmax_min_1[1]=RTD1;// temperatura Min
t_sond_maxEE[1]=MAX31865_get_temperature(RTD1);

TCA0.SINGLE.CMP0 =CMP_MocMaxymalna; // CMP_MocMaxymalna stała
CzasGzania = FLASH_0_read_eeprom_byte(CzasGrzaniaG1_H)<<8 | FLASH_0_read_eeprom_byte(CzasGrzaniaG1_L);
temp_x=CzasGzania;
ZnakNaLCD(13,1,CzasGzania,3, LCD_DISP_ON);
CzasGzania= CzasGzania*60*4; // (1/32768)*8192) );
RTC.CMPL = CzasGzania;
RTC.CMPH = CzasGzania>>8;

CzasGzania=temp_x;


/* Minimalna moc Grzałki */

CMP_temp=(TCA0.SINGLE.PERL | TCA0.SINGLE.PERH <<8);
CMP_MocMinimalna=(float)CMP_temp * (1-(FLASH_0_read_eeprom_byte(MocMin1)/100));
if(CMP_MocMinimalna>=0x54C3) CMP_MocMinimalna=0x54C3; // min 21699
}

void init_RTC(void)
{
while (RTC.STATUS > 0);
RTC.CLKSEL = RTC_CLKSEL_OSC32K_gc;
RTC.CTRLA = RTC_PRESCALER_DIV8192_gc;
RTC.PITCTRLA = RTC_PERIOD_CYC32768_gc;
RTC.INTCTRL = RTC_CMP_bm;
RTC.PITINTCTRL = PI_bm; //przerwanie okresowe właczone PIT ON 0.25s
}// init_RTC(void)

void rtc_pit_on(void)
{
while (RTC.PITSTATUS);
RTC_PIT_ON();
}

void rtc_pit_off(void)
{
while (RTC.PITSTATUS);
RTC_PIT_OFF();
}

void rtc_start(void)
{
while (RTC.STATUS & RTC_CTRLABUSY_bm);
RTC.CNTL=0;
RTC.CNTH=0;
RTC_START();
}

void rtc_stop(void)
{
while (RTC.STATUS & RTC_CTRLABUSY_bm);
RTC_STOP();
}


ISR(RTC_CNT_vect)
{
//while(RTC.STATUS & RTC_CTRLABUSY_bm)
RTC.INTFLAGS = RTC_CMP_bm;
KoniecPomiaru=1;
}


ISR(RTC_PIT_vect)
{
//while(RTC.PITSTATUS);
RTC.PITINTFLAGS = RTC_PI_bm;
licznik_sekund++;
if(licznik_sekund>=60){
LicznikMinut++;
licznik_sekund=0;
}
}




int main(void)
{

init_EEprom();
init_SPI();
init_ZCD();
init_RTC();
init_EVSYS();
TCA0_init();
lcd_init();
init_menu();
init_RDRY();

uint16_t RTD_DATA=0;
FaultDetection();
TemperaturyDoTabel();

CMP_MocPosrednia=1099;// tutaj liczyć moc pośrednią wg EEpromu
CMP_MocMaxymalna=200;

sei();
RysojLCD();

while (1)
{

uint16_t RTD=0;
uint16_t Threshold_High=0;
uint16_t Threshold_Low=0;

if(!(SPR_ENTER))
{
/*
Ustawione wartosci: T Max= 35st RTD 8662 0x21D6
T MIN= 30st RTD 8513 0x2141
99 0x0063 wartość minimalna Moc Maxymalna
21699 0x54C3 Wartość Maxymalna Moc Minimalna
*/
TemperaturyDoTabel();


TCA0_Start();
rtc_start();
rtc_pit_on();
pomiar=1;
lcd_gotoxy(0,1);
lcd_puts("HOT ON");

} //SPR_ENTER



if(KoniecPomiaru)
{
TCA0_Stop();
rtc_stop();
rtc_pit_off();
pomiar=0;
KoniecPomiaru=0;
kontrol_m=FALSE;
LicznikMinut=0;
licznik_sekund=0;
lcd_clrscr();
lcd_home();
lcd_puts("KONIEC)");
RysojLCD();
lcd_home();

while(!(SPR_GORA) || !(SPR_DOL) || !(SPR_GORA));


}



RTD_DATA=MierzTemperature();


if(pomiar) // jeśli czas pomiaru minie to :pomiar=0
{
ZnakNaLCD(9,1,licznik_sekund,2,LCD_DISP_ON); // na probe
ZnakNaLCD(13,1,CzasGzania-LicznikMinut,3, LCD_DISP_ON);

RTD=RTD_DATA; //((SPIReadReg(RTD_MSBs)<<8 | SPIReadReg(RTD_LSBs)<<0)>>1);
Threshold_High=(SPIReadReg(High_Fault_Threshold_MSB)<<8 | SPIReadReg(High_Fault_Threshold_LSB)<<0);
Threshold_Low=(SPIReadReg(Low_Fault_Threshold_MSB)<<8 | SPIReadReg(Low_Fault_Threshold_LSB));


if(RTD>=Threshold_High)
TCA0_Stop(); // osiagnięto temperaturę Maxymalną
// tu startować RTC

if(RTD<=Threshold_Low)
TCA0_Start(); // osiagnięto temperaturę Minimalna



uint16_t temp_roznica=0;
temp_roznica=RTDmax_min_1[0]-RTDmax_min_1[1]; //149
//uint16_t temp50=temp_roznica/2; //74
//temp_roznica=temp_roznica-(temp_roznica/5);


if( (RTD >= RTD_wspak(t_sond_maxEE[0] * 0.6)) && kontrol_m )
{
TCA0.SINGLE.CMP0 = CMP_MocPosrednia ;
kontrol_m=TRUE; // temperatura osiągnęła 60% temperatyury Max.
}

if(RTD>= RTDmax_min_1[0]-((temp_roznica * (FLASH_0_read_eeprom_byte(MocMin1)) /100))) // dot temperatury ok 10% mniejszej od zakładanej
{
TCA0.SINGLE.CMP0 =CMP_MocMinimalna;
}

lcd_gotoxy(7,1);
write_znak(' ',4);
lcd_home();

}//end if(pomiar)


// Docelowo pod klawiszami bedzie znajdowało sie menu
if(!(SPR_GORA)) TCA0.SINGLE.CMP0 = TCA0.SINGLE.CMP0+100;

if(!(SPR_DOL)) KoniecPomiaru=1;

} //END WHILE
}// END MAIN()








void FloatNaLCD(uint8_t x,uint8_t y,float liczba ,uint8_t clear, uint8_t command ) // clear-znakow do wyczyszczenia
{

lcd_command(command);
lcd_gotoxy(x,y);
write_znak(' ',clear);
char buf[7];
sprintf(buf,"%4.1f", liczba);
lcd_gotoxy(x,y);
lcd_puts(buf);
lcd_home();
lcd_command(LCD_DISP_ON);
}

void ZnakNaLCD(uint8_t x,uint8_t y,uint8_t liczba, uint8_t clear, uint8_t command)
{
lcd_command(command);
lcd_gotoxy(x,y);
write_znak(' ',clear);
char buf[7];
sprintf(buf,"%u",liczba);
lcd_gotoxy(x,y);
lcd_puts(buf);
lcd_home();
lcd_command(LCD_DISP_ON);


}

void RysojLCD (void)
{
uint16_t x=0;

lcd_clrscr();
lcd_home();

lcd_puts("A Z ");
lcd_gotoxy(0,1);
lcd_puts("L %M h ");
lcd_home();
lcd_command(LCD_DISP_ON);

x=FLASH_0_read_eeprom_byte(Pojemnosc_1);
ZnakNaLCD(2,1,x,3, LCD_DISP_ON); // Pojemność
x=FLASH_0_read_eeprom_byte(MocMin1);
ZnakNaLCD(9,1,x,3, LCD_DISP_ON); // Moc grzałki Minimalna
x = FLASH_0_read_eeprom_byte(CzasGrzaniaG1_H)<<8 | FLASH_0_read_eeprom_byte(CzasGrzaniaG1_L);
ZnakNaLCD(13,1,x,3, LCD_DISP_ON); // czas grzania

}

Krótka odpowiedź
Przerwania z RTC nie wykonują się, ponieważ:
1. Nie włączono samego licznika (bit RTCEN w RTC.CTRLA) ani – w przypadku PIT – bitu PITEN w RTC.PITCTRLA.
2. W funkcjach `rtc_pit_on/off()` i `rtc_start/stop()` użyto pętli oczekujących na bity SYNCBUSY, lecz w wersji bez średników doprowadzają one do zablokowania kodu.
3. Inicjalizacja 32 kHz OSC32K nie została jawnie uaktywniona (OSC32KCTRLA), co może powodować zatrzymanie całego RTC na niektórych rewizjach AVR64DD.

Po poprawieniu powyższego (patrz sekcja „Poprawiona inicjalizacja RTC”) przerwania pojawiają się prawidłowo.

Szczegółowa analiza problemu

1. Inicjalizacja i uruchamianie RTC/PIT

Bez bitów RTCEN/PITEN licznik nie chodzi i żaden z wektorów (`RTC_CNT_vect`, `RTC_PIT_vect`) nie zostanie wywołany.

2. Funkcje „start/stop”

W Twojej wersji przed nawiasem klamrowym brakowało średnika – kompilator łączył następny wiersz z `while` i pętla nigdy nie kończyła się, blokując program.

3. Flagi przerwań w ISR
Samo „zapisz 1, aby wyczyścić” jest poprawne; nie trzeba dodatkowego czekania:


4. Konfiguracja zegara głównego

Warto dopisać `CLKCTRL.MCLKCTRLB = 0;` (dzielnik 1:1) – bywa, że START wygeneruje inną wartość i F_CPU nie zgadza się z `#define F_CPU`.

5. Pętla „czekaj na klawisz”

• „GÓRA” występuje dwa razy.
• Operator `||` powoduje, że warunek jest prawdziwy, gdy dowolny klawisz jest NIE-wciśnięty, więc pętla niemal nigdy się nie kończy. Typowa forma „czekaj, aż wszystkie klawisze puszczone” to:

lub prościej


6. Drobne błędy kompilatora wykryte statycznie
1. `CMP_temp=(TCA0.SINGLE.PERL | TCA0.SINGLE.PERH << 8);`
Brakuje nawiasu – operator `|` ma niższy priorytet niż `<<`. Poprawnie:

2. Zmienna `bool kontrol_m` powinna być `volatile`, skoro modyfikujesz ją w przerwaniach lub innym miejscu równoległym do głównej pętli.

7. Jak szybko sprawdzić, czy ISR wywołuje się w ogóle
• Najprościej skonfigurować pin na wyjście i w ISR przełączać go (`PORTA.OUTTGL = PIN3_bm;`).
• Uruchom debugger (UPDI → MPLAB X / Atmel-ICE / nEDBG na samym Curiosity Nano). Postaw breakpoint w `RTC_CNT_vect`. Jeżeli do niego nie trafisz – licznik stoi.
• Jeśli debuggera brak: wstaw `_NOP();` i w symulatorze zadedykuj czas.

8. Potencjalne pułapki z RTC w AVR Dx
– W rewizjach B i C kontrolera 32 kHz jest domyślnie wyłączony po resecie. Dla pewności dodaj:

– PIT i CNT korzystają z innych źródeł, ale oba wymagają działającego OSC32K.

9. Kolizje EVSYS ⇄ RTC
EVSYS nie używa kanałów 0/1 z definicji RTC, ale jeśli skonfigurowałeś routing RTC→EVSYS i jednocześnie używasz PIT-INT, pamiętaj o odblokowaniu bitu EVSYS.RTCEN w EVSYS.ASYNCCHx – inaczej zdarzenie „zjada” Ci flagę przerwania.

Podsumowanie najważniejszych poprawek
1. `RTC.CTRLA |= RTC_RTCEN_bm;`, `RTC.PITCTRLA |= RTC_PITEN_bm;`
2. Popraw średnik w `rtc_pit_off/on()` i `rtc_start/stop()`.
3. Dopisz inicjalizację OSC32K, jeśli używasz świeżych układów AVR64DD.
4. Zweryfikuj warunek w pętli oczekiwania na klawisze i popraw literówkę z podwójnym `SPR_GORA`.
5. Dodaj debug LED lub breakpoint w `RTC_CNT_vect` – po powyższych zmianach ISR wykonują się co sekundę.

Co dalej?
– Sprawdź wartości rejestrów w debuggerze (CTRLA, PITCTRLA, INTCTRL) tuż po `init_RTC()` i po `rtc_start()` – zobaczysz, czy bity RTCEN/PITEN rzeczywiście są ustawione.
– Rozważ wygenerowanie szkieletu projektu w MPLAB Code Configurator / Atmel START; łatwo porównać, co wygeneruje kreator vs. Twój kod ręczny.
– Jeśli projekt ma iść w stan uśpienia, dodaj `RTC.CTRLA |= RTC_RUNSTDBY_bm;`.

Powodzenia w dalszych testach – po włączeniu licznika i usunięciu blokujących pętli przerwania działają bez zarzutu.