ElectroYou

Ciao a tutti. Ho cominciato da pochi giorni a prendere confidenza con i PIC programmandoli in C con MPLAB ma non riesco a capire perché il PIC non mi dà segni di vita. Ho provato a fare un programma stupido che mi accende qualche led, mi serve unicamente per capire se è stato programmato correttamente e quindi che funzioni. Tuttavia, il PIC continua a non funzionare, la cosa strana è che la compilazione e scrittura del firmware sul dispositivo va a buon fine. La prima volta l'ho alimentato a 4.5V (per meno di un minuto), non sapevo che sopportasse massimo 3.6V. C'è il rischio che si sia bruciato?

Si

Fire91 ha scritto:Ciao a tutti. Ho cominciato da pochi giorni a prendere confidenza con i PIC programmandoli in C con MPLAB...

Non so se ti può essere utile, ma l'anno scorso ho dovuto fare "al volo" una mini schedina demo con un PIC. Avevo nel cassetto un PIC16F648A (non è c'erto l'ultimo "modello" e non faccio "uso abituale" di PIC...) e così ho usato questo con MPLABX (che è l'ultima versione dell'IDE):



Se sei alle prime armi magari valuta un po'... questo è a 5V... naturalmente molto più basico di un PIC24.

Trovi come realizzarlo e alcuni esempi in assembler e C qui.

Vedi un po' tu...

Ciao.

Ciao SuperFabius! Grazie per avermi suggerito la pagina, la guarderò subito. Comunque una domanda, il pickit2 una volta che programma il PIC può essere anche usato sul momento come fonte di alimentazione per provare il PIC? O una volta finita la programmazione, cessa l'alimentazione?

Sì, può anche alimentare il target, ovviamente nei limiti possibili... non andrei oltre circa 200mA (non ricordo l'esatto valore massimo).

Inoltre ha uno speciale circuito che "sente" se il target è già alimentato di suo e si regola di conseguenza.
Puoi anche stabilire tu la "regola" (se alimentare il target o no) con un opportuno settaggio di MPLABX.

Se ci fai caso nel video la schedina è alimentata solo dal pickit durante i primi test, poi quando aggiungo il modulo LCD e collego l'adattatore seriale-USB, si alimenta solo dalla seriale. Si vede dal led giallo "Target", quando è acceso il target è alimentato dal pickit.

Ciao.

Ho capito, siccome il carico è quasi trascurabile posso alimentarlo con il pickit allora. Comunque, vorrei farti una domanda. Ho provato a fare un programmino che conti il tempo che intercorre tra la pressione consecutiva di un pulsante sfruttando il timer del PIC attraverso un interrupt e provato tramite simulatore PIC Simulator IDE, tuttavia non so cos'è che non vada. Il codice che ho scritto è quello riportato alla fine. Utilizzo un PIC16F873A con quarzo da 20 MHz, ho impostato il registro OPTION_REG in maniera tale che l'incremento di TMR0 avvenga per mezzo del clock interno con un prescaler 1:32. Invece, INTCON è configurato cosicché l'interrupt si verifichi ad ogni overflow del timer rilevandolo tramite il flag T0IF. Ho messo un while infinito al cui interno è presente una if che viene soddisfatta appena invio un livello logico alto al pin RB0. Soddisfatta la condizione, viene posto TMR0 = 100 (in modo che vada in overflow dopo 1 ms). Secondo il mio ragionamento, trascorso 1 ms da questo momento, viene generato un interrupt che incrementa count facendo ritornare il programma da dove l'aveva lasciato. Al millesimo conteggio la if successiva fa incrementare di un'unità la variabile sec. A questo punto, se vado a inviare nuovamente un livello logico alto ad RB0 dovrebbe riportarmi il conteggio dei secondi (sec) su PORTC che corrisponde al tempo trascorso dalla pressione precedente, azzerando subito dopo i contatori. Tuttavia il programma non funziona, cosa c'è che non va?

Codice: Seleziona tutto


#include <htc.h>
#include <stdio.h>
#include <stdlib.h>


__CONFIG(FOSC_XT & WDTE_OFF & PWRTE_OFF & BOREN_ON & LVP_ON & CPD_OFF & WRT_OFF & CP_OFF);

int count=0;
int sec=0;
int csec;


void main(void) {
   
    TRISB = 1;
    TRISC = 0;
    PORTB = 0;
   
    OPTION_REG = 0b00000100;
    // bit7 = abilita (1), disabilita (0) resistenze interne di Pull-Up
    // bit6 = interrupt su RB0 sul fronte di salita (1) o sul fronte di discesa (0)
    // bit5 = TMR0 incrementa da un impulso esterno (1) o dal clk interno (0)
    // bit4 = TMR0 incrementa dal pin T0CKI (esterno) sul fronte di discesa (1) o salita (0)
    // bit3 = prescaler assegnato al WDT (1) o al TMR0 (0)
    // bit2 = rapporto di divisione prescaler (PS2)
    // bit1 = rapporto di divisione prescaler (PS1)
    // bit0 = rapporto di divisione prescaler (PS0)
   
    INTCON = 0b10100100;
    // bit7 = gestione interrupt, "interruttore". Attivo (1), disattivo (0). (GIE)
    // bit6 = Interrupt da periferica esterna. Attivo (1), disattivo (0). (PEIE)
    // bit5 = Interrupt su Timer0. Attivo (1), disattivo (0). (TMR0IE)
    // bit4 = Interrupt su porta RB0/INT. Attivo (1), disattivo (0). (INTE)
    // bit3 = interrupt su porte B. Attivo (1), disattivo (0). (RBIE)
    // bit2 = flag interrupt su TMR0 (T0IF). Attivo (1), disattivo (0). (TMR0IF)
    // bit1 = flag interrupt su RB0/INT. Attivo (1), disattivo (0). (INTF)
    // bit0 = flag interrupt su porte RB7:RB4. Attivo (1), disattivo (0). (RBIF)
   
   
   
    while (1) {
       
        if (RB0 == 1) {
            TMR0 = 100;
            count =0;
            csec = sec;
            sec=0;
            PORTC = csec;
           
        }

        if (count == 1000) {
            sec++;
            count = 0;
        }
    }
}
   

void interrupt ISR(void) {
    if (T0IF) {
        T0IF = 0;
        count++;   
        TMR0 = 100;
    }
}



Ho scritto un nuovo programma usando un altro approccio. Il programma funziona nel seguente modo, se RB0 passa a livello logico alto il timer viene impostato a 100 ed RB0=0. A questo punto parte un ciclo while interno che non si arresta fino a che non sia più soddisfatta la condizione RB0=0, nel ciclo viene incrementata la variabile count ad ogni overflow del timer (1 ms) e la variabile sec ogni volta che count = 1000, cioè ogni secondo. Se RB0 passa di nuovo a livello logico alto, il ciclo while si deve interrompere e il tempo trascorso (dato da sec) viene riportato in uscita con PORTC = sec.
Da simulatore il programma funziona parzialmente. In altre parole, se dopo l'struzione PORTC = sec; pongo nuovamente RB0=0 (vedi commento) il programma funziona (naturalmente solo per una volta). In realtà, RB0 dovrebbe rimanere ad 1 logico in quanto deve fare da fronte per la successiva misura temporale, ma in questo modo smettere di funzionare. Avreste consigli? Vi ringrazio.

Codice: Seleziona tutto

#include <htc.h>
#include <stdio.h>
#include <stdlib.h>


__CONFIG(FOSC_XT & WDTE_OFF & PWRTE_OFF & BOREN_ON & LVP_ON & CPD_OFF & WRT_OFF & CP_OFF);

int count=0;
int sec=0;

void main(void) {

    TRISB = 1;
    TRISC = 0;
    PORTB = 0;
    PORTC = 0;
   
    OPTION_REG = 0b00000100;
 
    while (1) {
       
        if (RB0 == 1) {
            RB0=0;
            TMR0 = 100;
            while (RB0==0) {
                if (TMR0 == 255) {
                    TMR0 = 100;
                    count++;
                }
                if (count == 1000) {
                    sec++;
                    count = 0;
                }
            }
            PORTC = sec;
            sec = 0;
            //RB0 = 0;
        }
           
    }
}


Ma se tu imposti la porta B come ingresso non puoi forzarla a 0 (mi riferisco a RB0=0).
Comunque direi che è molto meglio utilizzare il timer in interrupt, io sinceramente userei il Timer 2 invece del timer 0 perche ha il registro di match (PR2) e l'interrupt scatta ogni qualvolta il timer conta fino a quel numero

Ma se tu imposti la porta B come ingresso non puoi forzarla a 0 (mi riferisco a RB0=0).

Già! Non ci avevo pensato. Proverò presto il timer2, purtroppo sono ancora alle prime armi e ho cominciato dal timer0! Comunque sono riuscito finalmente a realizzare il programma facendo un contatore dentro un ciclo while che incrementa ogni millisecondo. Il pin RB0 l'ho abilitato come ingresso di interrupt; ogni qual volta RB0 va a livello logico alto, l'interrupt generato tiene conto del valore corrente della variabile sec e la copia nella variabile csec determinando l'istante da cui deve iniziare a misurare il tempo. Al successivo impulso su RB0 viene generato un nuovo interrupt che assegna alla variabile val la differenza sec - csec, cioè il tempo trascorso tra una pressione e l'altra. Che ne dite?

Codice: Seleziona tutto

#include <htc.h>
#include <stdio.h>
#include <stdlib.h>

__CONFIG(FOSC_XT & WDTE_OFF & PWRTE_OFF & BOREN_ON & LVP_ON & CPD_OFF & WRT_OFF & CP_OFF);

int count=0;
int sec=0;
int csec;
int val;


void main(void) {

    TRISB = 1;
    TRISC = 0;
   
    PORTC = 0;
   
    OPTION_REG = 0b00000100;
 
    INTCON = 0b10010000;
   
    TMR0 = 100;
    while (1) {
        if (TMR0 == 255) {
            count++;
            if (count==1000) {
                sec++;
                count=0;
            }
            TMR0 = 100;
        }
    }
   
}

void interrupt ISR(void) {
   
    if (INTF) {
        INTF=0;
        if (csec == 0) {
            csec = sec;
        }
        val = sec - csec;
        PORTC = val;
        csec = sec;
    }
}