PIC32 RTCC corriendo demasiado rápido 1min = 10 seg

Navega tus respuestas
0

Tengo problemas con la configuración del reloj en mi PIC32.

Un minuto tiene una duración de 10 segundos con la configuración actual.

¿Alguien sabe dónde debo cambiar mi configuración?

Aquí está el código: 

// Master header file for all peripheral library includes
#include 

// configuration settings
#pragma config FNOSC = PRIPLL, POSCMOD = HS, FPLLMUL = MUL_18, FPLLIDIV = DIV_2, FPBDIV = DIV_2, FPLLODIV = DIV_1
#pragma config FWDTEN = OFF

// pin definitions
#define PPEins      LATFbits.LATF4
#define PPZwei      LATDbits.LATD15
#define PPDrei      LATDbits.LATD14
#define PPVier      LATBbits.LATB15
#define MHUhr       LATBbits.LATB3      // provisorisch
#define PMFuenf     LATBbits.LATB11
#define PMZehn      LATBbits.LATB10
#define PMViertel   LATAbits.LATA15
#define PMZwanzig   LATAbits.LATA1
#define PMVor       LATAbits.LATA14
#define PMNach      LATAbits.LATA5
#define PMHalb      LATFbits.LATF13
#define PHEins      LATAbits.LATA4
#define PHZwei      LATAbits.LATA3
#define PHDrei      LATFbits.LATF12
#define PHVier      LATAbits.LATA2
#define PHFuenf     LATBbits.LATB13
#define PHSechs     LATBbits.LATB12
#define PHSieben    LATFbits.LATF8
#define PHAcht      LATFbits.LATF2
#define PHNeun      LATBbits.LATB14
#define PHZehn      LATFbits.LATF5
#define PHElf       LATBbits.LATB5      // provisorisch
#define PHZwoelf    LATEbits.LATE9      // provisorisch


// + BUTTON SETTINGS
// D2 Als output für (5V Ersatz) für Buttons definieren
// und auch gleich als high setzen
// + BUZZER SETTINGS


int main(void) {

    // PORT SETTINGS
    DDPCONbits.JTAGEN = 0; // disable JTAGport, free up PORTA
    TRISFbits.TRISF4 = 0;       // PPEins
    TRISDbits.TRISD15 = 0;      // PPZwei
    TRISDbits.TRISD14 = 0;      // PPDrei
    TRISBbits.TRISB15 = 0;      // PPVier
    // TODO: TRIS für PMUhr
    TRISBbits.TRISB11 = 0;      // PMFuenf
    TRISBbits.TRISB10 = 0;      // PMZehn
    TRISAbits.TRISA15 = 0;      // PMViertel
    TRISAbits.TRISA1 = 0;       // PMZwanzig
    TRISAbits.TRISA14 = 0;      // PMVor
    TRISAbits.TRISA5 = 0;       // PMNach
    TRISFbits.TRISF13 = 0;      // PMHalb
    TRISAbits.TRISA4 = 0;       // PHEins
    TRISAbits.TRISA3 = 0;       // PHZwei
    TRISFbits.TRISF12 = 0;      // PHDrei
    TRISAbits.TRISA2 = 0;       // PHVier
    TRISBbits.TRISB13 = 0;      // PHFuenf
    TRISBbits.TRISB12 = 0;      // PHSechs
    TRISFbits.TRISF8 = 0;       // PHSieben
    TRISFbits.TRISF2 = 0;       // PHAcht
    TRISBbits.TRISB14 = 0;      // PHNeun
    TRISFbits.TRISF5 = 0;       // PHZehn
    // TODO: elf
    // TODO: zwölf

    // Initial pin settings
    PPEins = 0;
    PPZwei = 0;
    PPDrei = 0;
    PPVier = 0;
    MHUhr = 0;
    PMFuenf = 0;
    PMZehn = 0;
    PMViertel = 0;
    PMZwanzig = 0;
    PMVor = 0;
    PMNach = 0;
    PMHalb = 0;
    PHEins = 0;
    PHZwei = 0;
    PHDrei = 0;
    PHVier = 0;
    PHFuenf = 0;
    PHSechs = 0;
    PHSieben = 0;
    PHAcht = 0;
    PHNeun = 0;
    PHZehn = 0;
    PHElf = 0;
    PHZwoelf = 0;

    rtccTime    tm, tAlrm;          // time structure
    rtccDate    dt, dAlrm;          // date structure

    // Configure the device for maximum performance.
    // This macro sets flash wait states, PBCLK divider and DRM wait states based on the specified
    // clock frequency. It also turns on the cache mode if avaialble.
    // Based on the current frequency, the PBCLK divider will be set at 1:2. This knoweldge
    // is required to correctly set UART baud rate, timer reload value and other time sensitive
    // setting.
    SYSTEMConfigPerformance(72000000L);

    PPEins = 1;
    delay_us(1000000); // TEST 1
    PPEins = 0;

    RtccInit();   // init the RTCC

    while(RtccGetClkStat()!=RTCC_CLK_ON);   // wait for the SOSC to be actually running and RTCC to have its clock source
                                            // could wait here at most 32ms
    PPZwei = 1;
    delay_us(1000000); // TEST 2
    PPZwei = 0;

    RtccOpen(0x10073000, 0x07011602, 0);

    PPDrei = 1;
    delay_us(1000000); // TEST 3
    PPDrei = 0;

    while(1){

        RtccGetTimeDate(&tm, &dt);

        // update single minutes
        int singleminutes = (int) (unbcd(tm.min)%5);
        switch(singleminutes){
            case 0:
                PPEins = 0;
                PPZwei = 0;
                PPDrei = 0;
                PPVier = 0;
                break;
            case 1:
                PPEins = 1;
                PPZwei = 0;
                PPDrei = 0;
                PPVier = 0;
                break;
            case 2:
                PPEins = 1;
                PPZwei = 1;
                PPDrei = 0;
                PPVier = 0;
                break;
            case 3:
                PPEins = 1;
                PPZwei = 1;
                PPDrei = 1;
                PPVier = 0;
                break;
            case 4:
                PPEins = 1;
                PPZwei = 1;
                PPDrei = 1;
                PPVier = 1;
                break;
        }

        // update 5 minutes
        int nfminutes = (int) (unbcd(tm.min)/5);
        switch(nfminutes){
            case 0:
                MHUhr       = 1;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 0;
                PMHalb      = 0;
                break;
            case 1:
                MHUhr       = 0;
                PMFuenf     = 1;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 1;
                PMHalb      = 0;
                break;
            case 2:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 1;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 1;
                PMHalb      = 0;
                break;
            case 3:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 1;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 1;
                PMHalb      = 0;
                break;
            case 4:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 1;
                PMVor       = 0;
                PMNach      = 1;
                PMHalb      = 0;
                break;
            case 5:
                MHUhr       = 0;
                PMFuenf     = 1;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 1;
                PMNach      = 0;
                PMHalb      = 1;
                break;
            case 6:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 0;
                PMHalb      = 1;
                break;
            case 7:
                MHUhr       = 0;
                PMFuenf     = 1;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 0;
                PMNach      = 1;
                PMHalb      = 1;
                break;
            case 8:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 1;
                PMVor       = 1;
                PMNach      = 0;
                PMHalb      = 0;
                break;
            case 9:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 0;
                PMViertel   = 1;
                PMZwanzig   = 0;
                PMVor       = 1;
                PMNach      = 0;
                PMHalb      = 0;
                break;
            case 10:
                MHUhr       = 0;
                PMFuenf     = 0;
                PMZehn      = 1;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 1;
                PMNach      = 0;
                PMHalb      = 0;
                break;
            case 11:
                MHUhr       = 0;
                PMFuenf     = 1;
                PMZehn      = 0;
                PMViertel   = 0;
                PMZwanzig   = 0;
                PMVor       = 1;
                PMNach      = 0;
                PMHalb      = 0;
                break;
        }

        // update hours
        int hours = (int) (unbcd(tm.hour)%12);
        if(nfminutes>=5) hours++;
        switch(hours){
            case 0:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 1;
                break;
            case 1:
                PHEins      = 1;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 2:
                PHEins      = 0;
                PHZwei      = 1;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 3:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 1;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 4:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 1;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 5:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 1;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 6:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 1;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 7:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 1;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 8:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 1;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 9:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 1;
                PHZehn      = 0;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 10:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 1;
                PHElf       = 0;
                PHZwoelf    = 0;
                break;
            case 11:
                PHEins      = 0;
                PHZwei      = 0;
                PHDrei      = 0;
                PHVier      = 0;
                PHFuenf     = 0;
                PHSechs     = 0;
                PHSieben    = 0;
                PHAcht      = 0;
                PHNeun      = 0;
                PHZehn      = 0;
                PHElf       = 1;
                PHZwoelf    = 0;
                break;
        }

        // BUTTON CHECKING

    } // end: while(1)

}

int unbcd(int bcd) {
    return ((bcd>>4)*10)+bcd%16;
}

int bcd(int dec) {
    return ((dec/10)
    
pregunta ndrizza

2 respuestas

2

Esto no responde a tu pregunta, pero podría hacer que el código sea un poco más fácil para tu depuración. Las declaraciones de casos son realmente largas y pueden no ser la mejor manera de explicar lo que está haciendo con sus resultados. No garantizo que el código sea operativo (no lo he ejecutado en absoluto), pero esto debería hacer que piense en el tamaño y la legibilidad del archivo.

La declaración de su caso de singleminutes tiene una tabla de verdad como esta: 

//    | out
//  in| 0 1 2 3 4
// ---------------
//  0 | 0 0 0 0 0
//  1 | 0 1 0 0 0
//  2 | 0 1 1 0 0
//  3 | 0 1 1 1 0
//  4 | 0 1 1 1 1

que podría estar mejor representado con un código centrado en la salida como este: 

if (singleminutes >= 1)
    PPEins = 1;
else
    PPEins = 0;

if (singleminutes >= 2)
    PPZwei = 1;
else
    PPZwei = 0;

if (singleminutes >= 3)
    PPDrei = 1;
else
    PPDrei = 0;

if (singleminutes >= 4)
    PPVier = 1;
else
    PPVier = 0;

Los nfminutes son un poco más complicados, pero aquí está la Tabla de la Verdad: 

//   | MHUhr PMFuenf PMZehn PMViertel PMZwanzig PMVor PMNach PMHalb |        |
// --|--------------------------------------------------------------|--------|-----
// 0 | 1     0       0      0         0         0     0      0      | 1000 0 |  000
// 1 | 0     1       0      0         0         0     1      0      | 0100 0 |  010
// 2 | 0     0       1      0         0         0     1      0      | 0010 0 |  010
// 3 | 0     0       0      1         0         0     1      0      | 0001 0 |  010
// 4 | 0     0       0      0         1         0     1      0      | 0000 1 |  010
// 5 | 0     1       0      0         0         1     0      1      | 0000 0 |  101
// 6 | 0     0       0      0         0         0     0      1      | 0000 0 |  001
// 7 | 0     1       0      0         0         0     1      1      | 0100 0 |  011
// 8 | 0     0       0      0         1         1     0      0      | 0000 1 |  100
// 9 | 0     0       0      1         0         1     0      0      | 0001 0 |  100
//10 | 0     0       1      0         0         1     0      0      | 0010 0 |  100
//11 | 0     1       0      0         0         1     0      0      | 0100 0 |  100

y nuevamente un código centrado en la salida: 

    // MHUhr PMFuenf PMZehn PMViertel PMZwanzig
if( nfminutes == 0 )
    MHUhr = 1;
else
    MHUhr = 0;

if(( nfminutes == 1 ) || (nfminutes == 5) || (nfminutes == 7) || (nfminutes == 11))
    PMFuenf = 1;
else
    PMFuenf = 0;

if(( nfminutes == 2 ) || (nfminutes == 10) )
    PMZehn = 1;
else
    PMZehn = 0;
if(( nfminutes == 3 ) || (nfminutes == 9) )
    PMViertel = 1;
else
    PMViertel = 0;

if(( nfminutes == 4 ) || (nfminutes == 8) )
    PMZwanzig = 1;
else
    PMZwanzig = 0;


// PMVor PMNach PMHalb
if( ((nfminutes >= 1 ) && (nfminutes <= 4 )) || (nfminutes == 7))
    PMNach = 1;
else
    PMNach = 0;

if( (nfminutes >= 5) && (nfminutes <= 7 )
    PMHalb = 1;
    else
        PMHalb = 0;
if(nfminutes >=8)
    PMVor  = 1;
else
    PMVor  = 0;

El código anterior también podría funcionar bien con algunos #defines 

#define UHR     0
#define PHUENF_NACH 1
#define ZEHN_NACH   2
...
if(nfminutes == UHR)

De nuevo durante horas. Tabla de la verdad: 

      | 12  1  2  3  4  5  6  7  8  9 10 11
//----|------------------------------------
// 0  | 1  0  0  0  0  0  0  0  0  0  0  0 
// 1  | 0  1  0  0  0  0  0  0  0  0  0  0 
// 2  | 0  0  1  0  0  0  0  0  0  0  0  0 
// 3  | 0  0  0  1  0  0  0  0  0  0  0  0 
// 4  | 0  0  0  0  1  0  0  0  0  0  0  0 
// 5  | 0  0  0  0  0  1  0  0  0  0  0  0 
// 6  | 0  0  0  0  0  0  1  0  0  0  0  0 
// 7  | 0  0  0  0  0  0  0  1  0  0  0  0 
// 8  | 0  0  0  0  0  0  0  0  1  0  0  0 
// 9  | 0  0  0  0  0  0  0  0  0  1  0  0 
// 10 | 0  0  0  0  0  0  0  0  0  0  1  0 
// 11 | 0  0  0  0  0  0  0  0  0  0  0  1

y el código. Estructura ligeramente diferente con todas las salidas borradas, entonces solo se activa la salida correcta. 

// one-hot, clear all will not cause a glitch
PHZwoelf    = 0;
PHEins      = 0;
PHZwei      = 0;
PHDrei      = 0;
PHVier      = 0;
PHFuenf     = 0;
PHSechs     = 0;
PHSieben    = 0;
PHAcht      = 0;
PHNeun      = 0;
PHZehn      = 0;
PHElf       = 0;

if( hours == 0 )
    PHZwoelf = 1;   
if( hours == 1 )
    PHEins = 1;
if( hours == 2 )
    PHZwei = 1; 
if( hours == 3 )
    PHDrei = 1; 
if( hours == 4 )
    PHVier = 1; 
if( hours == 5 )
    PHFuenf = 1;    
if( hours == 6 )
    PHSechs = 1;    
if( hours == 7 )
    PHSieben = 1;   
if( hours == 8 )
    PHAcht = 1; 
if( hours == 9 )
    PHNeun = 1; 
if( hours == 10 )
    PHZehn = 1; 
if( hours == 11 )
    PHElf = 1;

Todo esto también le permite hacer sus cálculos de entrada juntos antes de las declaraciones de su caso. 

// update single minutes
int singleminutes = (int) (unbcd(tm.min)%5);    // 1, 2, 3, 4
// update 5 minutes
int nfminutes = (int) (unbcd(tm.min)/5);    // Fuenf Nach, Zehn Nach, ...
// update hours
int hours = (int) (unbcd(tm.hour)%12);      // 12, 1, 2, 3, 4...
if(nfminutes>=5) hours++;           // 7:25 = Fuenf Vor Halb Acht (8)
    
respondido por el spearson
0

Como creo que ya se mencionó, debe asegurarse de que haya un cristal de 32 kHz conectado a los pines SOSCO y SOSCI. Para implementar un reloj en tiempo real utilizando el hardware disponible del PIC32, Timer 1 es la mejor opción ya que está conectado a este circuito de oscilador secundario en el microcontrolador.

El siguiente código configurará el Temporizador 1 para usar este oscilador secundario como fuente de reloj y generará una interrupción cada milisegundo. En la interrupción simplemente incremento una variable de contador.

El PIC32 también tiene una fuente de reloj interna de 32 kHz basada en un circuito RC, pero esto (por lo que puedo recordar) solo puede reemplazar la fuente del oscilador principal, lo que significa que todo luego se ejecutará en 32kHz y no solo el temporizador de hardware elegido.

Hay otras soluciones, pero sugeriría probar esta primero.

Nota: el siguiente ejemplo utiliza el PLIB proporcionado con el compilador C32 de Microchip. Recomiendo encarecidamente el uso de PBLIB: facilita mucho la vida cuando se utilizan periféricos e interrupciones de mediana a alta complejidad.

Creo que OpenTimer1(T1_ON|T1_IDLE_CON|T1_GATE_OFF|T1_PS_1_1|T1_SOURCE_EXT, 0x8000); debería darte una interrupción una vez por segundo.

¡Buena suerte! Saludos cordiales, Stuart 

#include <plib.h>

/*******************************************************************************
* Summary:
*   Local private variable used to count number of milliseconds passed since
*  module was initialised
*******************************************************************************/
static volatile unsigned int timer1Count = 0;

/*******************************************************************************
* timer32khzStart()
*
* Summary: 
*   Initialises the 32kHz Timer with TIMER1 for use
*
* See also:
*
* Arguments: 
*   None
*
* Returns: 
*   None
*
* Callers: 
*   Main application code
*
* Notes : 
*   None
*******************************************************************************/
void timer32khzStart(void)
{
                                        /* Enable 32kHz secondary oscillator  */
    mOSCEnableSOSC();
                                        /* Enable timer 1 using sec. osc.     */
                                        /* Period is equivalent to 1ms        */
    OpenTimer1(T1_ON|T1_IDLE_CON|T1_GATE_OFF|T1_PS_1_1|T1_SOURCE_EXT, 0x0020);
                                        /* Enable interrupts for timer 1      */
                                        /* with priority level 7              */
    ConfigIntTimer1(T1_INT_ON | T1_INT_PRIOR_7);

}

/*******************************************************************************
* timer32khzWaitMs()
*
* Summary:
*   Waits desired time in milliseconds.
*
* See also:
*
* Arguments:
*   unsigned int    - desired time delay in milliseconds
*
* Returns:
*   None
*
* Callers:
*   Main application code
*
* Notes :
*   1. This function is blocking.
*   2. The delay will be the desired time or slightly longer, but never shorter
*******************************************************************************/
void timer32khzWaitMs(unsigned int delay)
{
    unsigned int countFinish;
    int countEnd;
                                        /* Calculate end count value based    */
                                        /* upon the current timer value plus  */
                                        /* the desired delay                  */
    countFinish = timer1Count + delay;

    do
    {
                                        /* Wait until the desired time or     */
                                        /* more has passed - signed           */
                                        /* arithmetic here handles potential  */
                                        /* overflow of timer1Count variable   */
        countEnd = (int) (timer1Count - countFinish);
    } while(countEnd < 0);
}

/*******************************************************************************
* timer32khzGetTimerValue()
*
* Summary:
*   Returns current timer value counting in milliseconds
*
* See also:
*
* Arguments:
*   None
*
* Returns:
*   unsigned int    - time in milliseconds
*
* Callers:
*   Main application code
*
* Notes :
*
*******************************************************************************/
unsigned int timer32khzGetTimerValue(void)
{
    return timer1Count;
}

/*******************************************************************************
* __ISR(_TIMER_1_VECTOR, ipl7)Timer1Handler()
*
* Summary: 
*   Interrupt handler for Timer 1
*
* See also:
*
* Arguments: 
*   None
*
* Returns: 
*   None
*
* Callers: 
*   Timer 1 hardware exception every millisecond
*
* Notes : 
*   None
*******************************************************************************/
void  __ISR(_TIMER_1_VECTOR, ipl7)Timer1Handler(void) 
{
                                    /* Clear the interrupt flag               */
    mT1ClearIntFlag();
                                    /* Count another millisecond              */
    timer1Count++;
}
    
respondido por el Stuart Cording

Lea otras preguntas en las etiquetas

Dónde comprar un SR Latch [cerrado] ¿Cómo saber si el motor paso a paso funciona o no?