Contachilometri Con Pic16f84 - autocostruito...

[Giorgio Demurtas]

voglio fare un contachilometri per il mio scooter usando un pic e tre display a 7 segmenti.

Rilevo i giri della ruota con un sensore hall e poi il pic fa il resto!

Una delle prime perplessità che ho è questa: ho recuperato decine di display a anodo comune, ma tutti i decoder BCD/7seg che ho trovato sono per display a catodo comune. Potete indicarmi una sigla che faccia al caso mio?

appena risolto questo problema inizio a fare il prototipo...

ciao

Giorgio

[mr.fabius]

Bello sto progetto. Spero che lo vorrai pubblicare quando lo hai finito. Sarei interessato anche io... Andrà bene pure per le biciclette giusto? Basta cambiare il diametro unitario...

[Giorgio Demurtas]

hai detto tutto bene, sara disponibile su www.web giorgio.it

ciao

[DOLBYco]

ciao..interessa anche a me.....pensi..che possa essere modificato per visualizzare i giri al minuto.......io userei un lettore ottico....ciao e grazie!

[giacomo56]

Ciao Giorgio,

come decodificatore con uscite attive basse conosco solo il 74LS47, ma con un pic a 18 piedini non riesci a pilotare i display direttamente? Servono 10 uscite e te ne rimangono altre 3.

Ciao.

[Giorgio Demurtas]

Grazie dell'informazione giacomo,

infatti hai ragione, che mi importa di conservare uscite libere inutilizzate?

Ci avevo già pensato, ho anche già fatto il prototipo!

ora i problemi sono di software....

un prog di prova che ho fatto usa una cifra sola e conta da 0 a 9, ho usato l'istruzione delayms() (uso ccs).

ma se devo multiplexare le varie cifre, il pic si ferma a contare il ritardo e smette di multiplexare

in effetti è giusto che sia così... dovrei usare il TMR0 invece del delay giusto? così il conteggio del tempo è indipendente dal ciclo di elaborazione del programma...

giorgio

[Giorgio Demurtas]

ah già che ho parlato di un listato... si trova quì: http://www.plcforum.it/forums/index.php?sh...topic=10257&hl=

ciao

ps. ora vado a farmi lo zaino perchè fra qualche ora parto con gli scout! ci sentiamo fra una settimana..

[Dario Valeri]

premetto che non conosco il pic ma:

la conversione potrebbe farla il pic!! (bcd-7segmenti)

il multiplexing deve essere fatto da un int timer, che ha la facolta' di interrompere le altre

operazione e fare il proprio lavoro per poi ripristinare il tutto.

anche l'ingresso di conteggio , dovrebbe essere "sotto" interrupt altrimenti

rischi di perdere giri ruota.

buon divertimento!!!!

ciao

dario

Modificato: 9 agosto 2004 da Dario Valeri

[Mauro Rubinetti]

Ciao a tutti, anch'io non sono un esperto di PIC ma qualche bel progettino per giochi di luce li ho gia fatto e ora sto lottando con un sistema pic 16f84a in multiplex per N°2 matrici a led 8 per 8 Tot.128 led da pilotare e mi sto divertendo un mondo.

Non conoscendo l'assembler mi appoggio a un compilatore che ha la funzione function char_to_bcd( expression ): char; che mette fuori sulla pota B il valore in BCD.

Per i display e comodissimo, basta dare il valore in decimale nella funzione sopra indicata e sulle pote di uscita mi trovo gia il valore da passare all'integrato che pilota il display.

Spero che possa aiutarti.

E'un bel progetto quello che vuoi fare, io sarei tentato di fate un analizzatore di spettro a led comandato dal PIC, ma no so a cosa vado incontro per l'acquisisione analogica, qualcuno sa dirmi se è teoricamente fattibile?

Scusate se entro con domande che non hanno a che fare con il progetto in corso.

Ciao a tutti

[Dario Valeri]

ciao

si e' fattibile , analizzatore di spettro audio, credo.

se ho capito bene ogni colonna di led dovrebbe essere una frequenza.

ok viste le scarse risorse (vista l'impegnativa applicazione) diquesto micro dovrai multiplexare anche tuttigli ingressi analogigi , cioe' devi costruire un amplificatore ,con un buon filtro passa banda, per ogni frequenza

che devi controllare (visualizzare).

il tuo pic tramite un elettronica esterna dovra' prelevare sequenzialmente i valori da questi amplificatori(tensione)

poi , memorizzarli in alcuni buffer , ed infine mandare alle varie colonne i rispettivi valori .

anche in questo caso , per evitare variazioni di luminosita' dei led (in multiplexing) sarebbe meglio operare sotto interrupt timer .

ciao

dario

[TIGULLIO]

Interessante.Ma hai pensato al consumo dei display a 7 seg. ??

Ciao.

[TIGULLIO]

Quanto sopra detto,ovviamente vale per applicazione su biciclette !!!!!!!

[Dario Valeri]

si certo

ovviamente avrei messo (come ho fatto sulla mia scheda con il mitsubishi) un ULN

ovviamente il micro non puo' erogare quella corrente !

http://www.webalice.it/valeri.da/

su questa scheda io piloto 4 display utilizzando le medesime uscite

nel caso di un dispaly solo , direi che non e' la scelta da fare ma se i display sono tanti

si puo' affrontare.

chiaro la mia era solo una discussione senza pretese di insegnare a nessuno.

ciao

dario

[Mauro Rubinetti]

Ciao a tutti, si intendevo come ha sottolinato Dario una analizzatore di spettro o per iniziare porebbe solo essere un vumeter, per quanto riguarda il fatto di multiplexare gli ingressi analigici oltre il lavoro di multipex per i led ho paura che anche andando a 4 Mhz il 16f84a sia troppo tirato, credo che sarebbe meglio utilizzare un 16f876 o77 che implementa già le analogiche.

Farlo con il 16f84a richiederebbe un sacco di elettronica esterna oltretutto, mentre così anche la parte hardware si alleggerirebbe.

Per ora era un'idea, che sicuramente più avanti cercherò di iniziare, ma ora devo pensare a sincronizzare i buffer per il pilotaggio delle matrici a led che incominciano a funzionare, ma il lavoro è ancora lungo.

Comunque complimenti per l'idea del contachilaometri, vi seguirò per sapere come va, ma sicuramente darà degli ottimi risultati.

Buon lavoro a tutti.

[walterword]

propongo un progetto .... con un pic ed un lcd

ci colleghiamo alla centralina dell'auto , leggiamo la velocita in km/h , tarando il circuito

come riferimento al contakilometri dell'auto stessa ,

poi da lcd impostiamo la velocita massima , e tramite un uscita analogica regoliamo o tagliamo

la valvola proporzionale che alimenta la carburazione

In questa maniera molti automobilisti potrebbero tranquillamente impostare una velocita e tenere

anche il pedale dell'acceleratore al chiodo , tanto il PIC controlla che non superi la soglia impostata

Potrebbe essere interessante nell'automotive , immaginate quante multe in meno che il ns. governo rubera

in meno agli onesti cittadini

cosa ne pensate ???

ciao

walter

[fabri]

Sistemi del genere esistono già anch'io nel mio piccolo ho già creato qualcosa per dei camion

tutti i pedali delle automobili sono collegati a potenziometri lineari, più acceleri più aumenta il valore della resistenza letto dalla centralina e più il motore va su di giri, io ho creato delle schedine con dei poteziometri e dei rele di scambio per mantenere il regime costante, sono in commercio dei dispositivi che fanno esattamente quello che vorresti fare tu dove la scheda si interfaccia tra il potenziometro del pedale e la centralina per ottenere diversi risultati, controllo della velocità ecc. il software del dispositivo applica un pid per avere un buon risultato nella regolazione dei giri

anche a me interesserebbe fare qualcosa del genere ma si tratta oltre al problema di reperire le informazioni sulle centraline dei vari modelli di automobili ( e non sarà facile) di seguire tutte le fasi di omologazione che possono essere necessarie per la legge italiana, (prova a fare un salto in una qualsiasi motorizzazione civile per farti un'idea)

Ciao, Fabrizio

[walterword]

la mia era un'idea senza conoscere la tecnologia delle auto

comunque mi sembra di aver capito di esserci andato molto vicino

Be di questi tempi , con tutte le multe per oltre velocita che si prendono , il mercato dovrebbe tirare mica male

cosa ne dici ?

ciao

walter

[fabri]

Si può provare a studiare qualcosa del genere, il problema è provarla su qualche auto

io ci vedo anche applicazioni nel settore dei veicoli industriali sicuramente ci sarà da lavorare parecchio perchè nel settore l'unica cosa che è standard è il numero delle ruote e fare qualcosa che vada bene per più di un modello non sarà una cosa facile

CIao, Fabrizio

[walterword]

basterebbe sentirci

mangiarci qualcosa e discuterne a titolo informativo

non ho nessun problema

ciao

walter

[Giorgio Demurtas]

hei hei! non divagate in altri argomenti!

Non posso assentarmi neanche 2 settimane?...

Devo dire che ho passato due settimane in vacanza al mare, ma son tronato a casa da qualche ora e già son dinuovo alle prese con il mio contachilomentri!

Tornando a noi...

Io usavo (nel sw che gestisce un solo display) l'istruzione delayms() per generare un ritardo dopo il quale incrementavo la cifra...

Però se devo contemporaneamente multiplexare le 3 cifre, mentre il pic conta il ritardo ferma il resto dell'esecuzione del programma e di conseguenza pure il multiplex...

Credo che la soluzione sia di utilizzare il timer0 del pic; potete darmi qualche drittra sull'algoritmo da implementare per fare il multiplex? (però, mai viste tante parole difficili tutte di fila! ).

ciao

Giorgio

[giacomo56]

Ciao Giorgio,

puoi fare così:

1) definisci una variabile di stato, es. disp_stato, che memorizza il display attualmente acceso (0, 1, 2, ecc.);

2) programmi il timer0 per generare un'interruzione ogni 20 msec o meno;

3) a ogni interruzione spegni il display acceso in base al valore disp_stato, mandi la nuova cifra, aggiorni disp_stato e accendi il display di turno.

Ciao.

[Giorgio Demurtas]

ciao giacomo,

ho defnito la variabile di stato come "cifra_on".

ho programmato il timer in modo che raggiunga lo zero 50 volte al secondo, quindi ogni 20ms.

Ci sono tutta la mattina per capire come usare questo cavolo di tmr0!

Come faccio a rilevare l'interruzione, o meglio come faccio a dire al pic di esegiure un bloccco di istruzioni quando si verifica l'interrupt?

c'è qualche correzione da fare nel listato?

#include "C:\Documenti\pic c\nuovi_progetti\prova_mpx\prova_mpx.h"

#define PIN_RA2 centi
#define PIN_RA3 deci
#define PIN_RA4 uni

void main()
{
int8 numero, cifra_on;
set_tris_a(0x00);
set_tris_b(0x00);
numero=0;
cifra_on=1;

while(1)
{
setup_timer_0 (RTCC_DIV_128|RTCC_INTERNAL);
/* imposto il prescaler a 128 divisioni in modo da ottenere
una frequenza di incremento del registro TMR0 di
1 Mhz/128=7812.5 Hz */
set_timer0(100); //TMR0 passa per lo 0 con una frequenza di 50 Hz
//7812.5/156=50 Hz
enable_interrupts(INT_RTCC); //abilito l'interrupt da tmr0
enable_interrupts(GLOBAL);   //abilito tutti gli interrupts

   if (cifra_on==1) output_bit(centi, 1);
   if (cifra_on==2) output_bit(deci, 1);
   if (cifra_on==3) output_bit(uni, 1);
   
   if (/*come lo rilevo l'interrupt del tmr0?*/) cifra_on++
   if (cifra_on==4) cifra_on=1 


   if (numero==0) output_b(0x03);
   if (numero==1) output_b(0x9F);
   if (numero==2) output_b(0x25);
   if (numero==3) output_b(0x0D);
   if (numero==4) output_b(0x99);
   if (numero==5) output_b(0x49);
   if (numero==6) output_b(0x41);
   if (numero==7) output_b(0x1F);
   if (numero==8) output_b(0x01);
   if (numero==9) output_b(0x09);
   
      
}

[giacomo56]

Premetto che io ho una vecchia versione del C CCS. In questa versione il codice da eseguire va messo in una funzione così definita

#INT_RTCC TimerInt()

{

// Codice eseguito a ogni interruzione del timer0

}

L'istruzione set_timer0(100); non credo faccia quello che vorresti, invece usa un rapporto di divisione di 64 così da avere una frequenza di rinfresco dei display di 61 Hz, se non sbaglio, che va bene.

Ultima cosa, puoi inviare la cifra ai display in questo modo:

#byte PORTB = 0x06

const char cifra[10] = {0x03, 0x9f, 0x25, 0x0D, 0x99, 0x49, 0x41, 0x1F, 0x01, 0x09); //Tabella in ROM

...

PORTB = cifra[numero];

...

ciao.

[Giorgio Demurtas]

comincio subito con il listato. la compilazione è ok.

#include "C:\Documenti\pic c\nuovi_progetti\prova_mpx\prova_mpx.h"

#define centi PIN_A2
#define deci PIN_A3
#define uni PIN_A4

int8 numero, cifra_on, tempoc; //tempoc è il tempo di campionamento. 1000 ms

#int_rtcc noclear //routine di interrupt
void isr()
     {
     cifra_on=cifra_on+1;
     if (cifra_on==4) cifra_on=1;
     tempoc=tempoc+1;
     if (tempoc==50) tempoc=0;
     }
      
void main() { //inizio programma principale

set_tris_a(0x00);
set_tris_b(0x00);
numero=0;
tempoc=0;
cifra_on=1;



while(1) //ciclo continuo
{
setup_timer_0 (RTCC_DIV_128|RTCC_INTERNAL);
/* imposto il prescaler a 128 divisioni in modo da ottenere
una frequenza di incremento del registro TMR0 di
1 Mhz/128=7812.5 Hz */
set_timer0(100); //TMR0 passa per lo 0 con una frequenza di 50 Hz
//7812.5/156=50 Hz
enable_interrupts(INT_RTCC); //abilito l'interrupt da tmr0
enable_interrupts(GLOBAL);   //abilito tutti gli interrupts

   if (cifra_on==1) output_bit(centi, 1);
   if (cifra_on==2) output_bit(deci, 1);
   if (cifra_on==3) output_bit(uni, 1);

} //fine ciclo while
} //fine main

set_timer0(100); mette dentro tmr0 il valore 100 ogni volta che tmr0 va in overflow.

in questo modo ottengo una f di 50Hz. mi serve avere anche una frequenza di 1Hz perchè 1s è i tempo di campionamento per i giri della ruota.

Campionerò per 1s (50 interruzioni di tmr0) poi dopo fatti i calcolo e messo il numero nella variabile "di uscita" ripete il campionamento.

quel modo di scrivere l'uscita non lo conosco, dovrebbe essere con gli array giusto?

al compilatore non piace...ora mi ripasso qualcosa sugli array nel libro di sistemi.

ciao

[Giorgio Demurtas]

cosa vuol dire isr() ?

rimane ancora da pensare alla parte del campionamento che fatica mentale!