Problema grave in interrupt

[WALTERmwp]

Il clock interno è impostato a 32MHZ,ho provato a ricalcolare il prescaler e tmr0 con il timer calculator di Mikroelektronika e i valori coincidono.

... quello che ho scritto l'ho riferito ad un clock di 4 MHz.
Con 32 MHz invece corrisponde esattamente ad 1 ms.
Grazie.

Saluti

[posta10100]

posta10100, non capisco quando scrivi "Se usi una variabile a 16 bit e il registro ne contiene 8, nei restanti 8 cosa ci metti?"

Hai ragione, ho letto male.
Avevo capito che il valore dentro sys_tick fosse letto (o scritto) dal (nel) registro, da li l'obiezione sul numero di bit.

Però,

Quindi al trascorrere del tempo sys_tick e Timer hanno valori via via crescendo

cosa intendi?
Se continuano ad aumentare entrambi, sicuro che non vanno in overflow?

[WALTERmwp]

L'osservazione che riporta posta10100 mi sembra ragionevole; se non c'è in "giro" più nessun'altra riga di codice, anche una variabile a 32 bit dopo quasi cinque ore, con quei tempi la saturi.
E visto che non esegui un controllo sul limite dei valori (a questo punto si presuppone che non ci fosse nemmeno nella parte di programma che via via sei andato ad eliminare) quel ...

ma con variabili a 16 e 32 bit ogni tanto fa cilecca.

... ogni quanto si verifica con variabili a 16 e poi a 32, ammesso tu abbia un minimo di casistica ?
Alla fin fine potrebbe essere di tutto ma l'ultimo sul quale andrei ad indagare sarebbe l'output del compilatore.

Saluti

[ivanpascolo]

In precedenza ho inserito alcune parti di codice per rendere il tutto piu' comprensibile.
La variabili sono dichiarate come unsigned long e quindi contano fino a 4294967295 ms ovvero circa 1193 ore, quindi l'overflow non centra dal momento che in dieci minuti sbaglia almeno 10/20 volte.

Ora provo a trasferirlo in MikroC dal momento che possiedo il mikroprog e posso fare così ulteriori verifiche per capire se è un problema del compilatore oppure no.
Se volete posso inserire tutte le parti di codice in un singolo file (adesso varie parti si trovano in file .h generati dal c.g. di microchip) e lo posto.

[ivanpascolo]

Di seguito tutto il codice:

Programma principale

Codice: Seleziona tutto

#define _XTAL_FREQ 32000000                               //Used by the XC8 delay_ms(x) macro
#include "mcc_generated_files/mcc.h"
unsigned long sys_tick = 0, t0 = 0, t1 = 0;

void main(void)
{   
    SYSTEM_Initialize();   
    INTERRUPT_GlobalInterruptEnable();               
    INTERRUPT_PeripheralInterruptEnable();     
/**********************************************************
*               PROGRAMMA PRINCIPALE                     *
*********************************************************/   
    while (1){               
        t1 = sys_tick - t0;
        if ((t1) > 100) {
            if ((t1<100)||(t1>101)){               
                LATAbits.LATA5 = ~ LATAbits.LATA5 ;
            }
            else t0=sys_tick;
        }
    }
}

Il file mcc.c

Codice: Seleziona tutto

// Configuration bits: selected in the GUI

// CONFIG1
#pragma config IESO = ON    // Internal/External Switchover Mode->Internal/External Switchover Mode is enabled
#pragma config BOREN = ON    // Brown-out Reset Enable->Brown-out Reset enabled
#pragma config PWRTE = ON    // Power-up Timer Enable->PWRT enabled
#pragma config FOSC = INTOSC    // Oscillator Selection Bits->INTOSC oscillator: I/O function on CLKIN pin
#pragma config FCMEN = ON    // Fail-Safe Clock Monitor Enable->Fail-Safe Clock Monitor is enabled
#pragma config MCLRE = OFF    // MCLR Pin Function Select->MCLR/VPP pin function is digital input
#pragma config CP = ON    // Flash Program Memory Code Protection->Program memory code protection is enabled
#pragma config WDTE = OFF    // Watchdog Timer Enable->WDT disabled
#pragma config CLKOUTEN = OFF    // Clock Out Enable->CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin

// CONFIG2
#pragma config WRT = OFF    // Flash Memory Self-Write Protection->Write protection off
#pragma config ZCDDIS = ON    // Zero-cross detect disable->Zero-cross detect circuit is disabled at POR
#pragma config LPBOR = OFF    // Low-Power Brown Out Reset->Low-Power BOR is disabled
#pragma config PPS1WAY = ON    // Peripheral Pin Select one-way control->The PPSLOCK bit cannot be cleared once it is set by software
#pragma config LVP = OFF    // Low-Voltage Programming Enable->High-voltage on MCLR/VPP must be used for programming
#pragma config STVREN = ON    // Stack Overflow/Underflow Reset Enable->Stack Overflow or Underflow will cause a Reset
#pragma config PLLEN = ON    // Phase Lock Loop enable->4x PLL is always enabled
#pragma config BORV = HI    // Brown-out Reset Voltage Selection->Brown-out Reset Voltage (Vbor), high trip point selected.

#include "mcc.h"

void SYSTEM_Initialize(void)
{
    OSCILLATOR_Initialize();
    PIN_MANAGER_Initialize();
    TMR0_Initialize();
}


void OSCILLATOR_Initialize(void)
{
    // SPLLEN enabled; SCS FOSC; IRCF 8MHz_HF;
    OSCCON = 0xF0;
    // OSTS intosc; HFIOFR disabled; SOSCR disabled; HFIOFS not0.5percent_acc; PLLR disabled; MFIOFR disabled; HFIOFL not2percent_acc; LFIOFR disabled;
    OSCSTAT = 0x00;
    // TUN 0x0;
    OSCTUNE = 0x00;
    // Set the secondary oscillator
   
    // Wait for PLL to stabilize
    while(PLLR == 0)
    {
    }
}
/**
End of File
*/

il file pin_manager.c

Codice: Seleziona tutto

#include <xc.h>
#include "pin_manager.h"

void PIN_MANAGER_Initialize(void)
{
    LATA = 0x00;
    TRISA = 0x17;
    ANSELA = 0x17;
    WPUA = 0x00;

    LATC = 0x00;
    TRISC = 0x30;
    ANSELC = 0x30;
    WPUC = 0x00;

    OPTION_REGbits.nWPUEN = 0x01;
}



il file tmro.c

Codice: Seleziona tutto


#include <xc.h>
#include "tmr0.h"
extern unsigned long sys_tick;
volatile uint8_t timer0ReloadVal;

void TMR0_Initialize(void)
{
   
    OPTION_REG = (OPTION_REG & 0xC0) | 0xD4 & 0x3F;
    TMR0 = 0x06;
    timer0ReloadVal= 6;
    INTCONbits.TMR0IF = 0;
    INTCONbits.TMR0IE = 1;
}


uint8_t TMR0_ReadTimer(void)
{
    uint8_t readVal;

    readVal = TMR0;

    return readVal;
}

void TMR0_WriteTimer(uint8_t timerVal)
{
    // Write to the Timer0 register
    TMR0 = timerVal;
}

void TMR0_Reload(void)
{
    // Write to the Timer0 register
    TMR0 = timer0ReloadVal;
}

void TMR0_ISR(void)
{
    static volatile unsigned int CountCallBack = 0;

    // clear the TMR0 interrupt flag
    INTCONbits.TMR0IF = 0;

    TMR0 += timer0ReloadVal;

    // callback function - called every 1000th pass
    if (++CountCallBack >= TMR0_INTERRUPT_TICKER_FACTOR)
    {
        // ticker function call
        TMR0_CallBack();

        // reset ticker counter
        CountCallBack = 0;
    }

    // add your TMR0 interrupt custom code

    sys_tick++;
    //LATAbits.LATA5 = ~ LATAbits.LATA5 ;                            // toggle FOUT = 500Hz
}

void TMR0_CallBack(void)
{
    // Add your custom callback code here
    // this code executes every 1000 TMR0 periods
}



l'ho messo cos' com'è, spero sia chiaro

[ivanpascolo]

Niente da fare, l'ICD della mikroelektronika non supporta il 16F1704... per il momento devo continuare con XC8.

[ivanpascolo]

Provato anche con il simulatore del MPLAB (ho però dovuto commentare la roga di attesa per la stabilizzazione del PLL) e ... NON FUNZIONA.

[posta10100]

Domanda stupida: sicuro di completare la procedura di interrupt prima che arrivi il successivo?

[WALTERmwp]

quindi l'overflow non centra dal momento che in dieci minuti sbaglia almeno 10/20 volte.

... sulla base di un millisecondo è così, mentre addirittura consideravo come evento quello di incremento del timer0.
Il fatto è che seguire un thread nel quale, per provare a dare una risposta sensata, occorre leggere il codice, diventa dispersivo se tutte le informazioni non vengono subito e chiaramente fornite sin dall'inizio perché poi ti ritrovi a doverti leggere quanto "postato" in precedenza.

Questo ...

Domanda stupida: sicuro di completare la procedura di interrupt prima che arrivi il successivo?

... non mi pare proprio un quesito inopportuno ma io per primo non ho voluto nemmeno dubitare per un istante sul fatto che non vi sia un "return" che non completi la gestione dello "stack" prima del successivo "interrupt", per come viene presentato il codice in "C"; altrimenti veramente potrebbe essere di tutto.

Comunque, provo a scriverne una, anche se potrebbe sembrare un'eresia, così come esercizio anche se poi si dovrebbe trovare la spiegazione nel caso dell'impiego per le variabili a 8 bit: si potrebbe considerare il fatto che con il breakpoint si va a bloccare il flusso del programma mentre rimane escluso il richiamo allo "interrupt" dovuto al fatto che il timer0 evolve nel conteggio, e quindi incrementa la variabile gestita nella routine che risulta sempre(credo) maggiore di t0 ?

Saluti

[ivanpascolo]

Adesso ho messo sys_tick++ in ingresso all'interrupt, prima era in fondo ma continua a non funzionare.

Codice: Seleziona tutto

void TMR0_ISR(void)
{
    sys_tick++;
    static volatile unsigned int CountCallBack = 0;

    // clear the TMR0 interrupt flag
    INTCONbits.TMR0IF = 0;

    TMR0 += timer0ReloadVal;

    // callback function - called every 1000th pass
    if (++CountCallBack >= TMR0_INTERRUPT_TICKER_FACTOR)
    {
        // ticker function call
        TMR0_CallBack();

        // reset ticker counter
        CountCallBack = 0;
    }