|
Ciao a tutti.... Ho fatto parecchi programmi per il mitico pic 16f84, ma ormai da un annetto non avevo piu' tempo.... Ieri ho rispolverato il programmatore e ho dato un po di svitor alle rotelline che ho in testa che si erano un po arrugginite, per vedere se mi ricordavo qualche cosa.... Ba dai... qualche cosa mi e' turnata in mente... riesco ancora a far lampeggiare un led :P :P :P Allora.... veniamo al dunque... Mi piaderebbe realizzare un circuitino tipo il cercamodelli, ma completamente programmabile.... Mi spiego meglio... vorrei realizzare un qualche cosa che ad esempio usando un interrutore a tre posizioni mi possa fare con una posiziono una determinata cosa (per esempio un gioco di luci) con un altra posizione (per es. un beep come cercamelli) e cosi' via chi piu' ne ha piu ne metta... A questo punto il dubbio piu' atroce.... Quel'e' il modo piu' semplice e pratico per fare riconoscere al pic il segnale ( o meglio le varie soglie di segnale) in modo da fargli scegliere sa sub da eseguire??? Visto che ad occho mi sembra di riconoscere ancora abbastanza bene le istruzioni, se non avete voglia di spiegarmi potete mandarmi qualche asm di esempio.... Grazie in anticipo a tutti.... |
Penso che bisogna fare varie prove con un oscilloscopio oppure cercare della documentazione ariguardo delle riceventi ppm o pcm. Vorrei esserti di maggiore aiuto, ma nn conosco tali tecniche trasmissive nei dettagli e soprattutto come viene elaborato il segnale ricevuto dalla ricevente prima di darlo in uscita sul canale... |
Citazione:
Ma tu vorresti controllare il circuito, che vuoi ottenere con il pic, con un canale proveniente dalla RX o da un semplice interruttore a tre posizioni ? Se e' la prima hai due soluzioni, fai ciclo molto veloce che controlla per quanto tempo il segnale proveninete dalla RX resta a 1, i dati della lunghezza d'impulso li vedi ben schematizzati nella parte del sito riservata ai progetti elettronici "vedi prova servo 1 e 2". (metodo veloce) Altrimenti dovrai scomodare un timer in modo capture su PIC e farti dare da lui i dati di lunghezza dell'impulso. (un po' vago ma questo metodo e' piu' complicato da realizzare e bisogna addentrarsi un po di piu' in registri ecc...) Se e' la seconda controlla quale di 3 piedini settati come input hai il segnale basso (0V) o Alto (5V) e poi fai un salto ad una parte di codice dove metti il tuo gioco di luci o quant'altro. Non ho del codice da darti pronto ma sicuramente se fai rif. a rivp6 trovi di sicuro un valido aiuto e' lui l'esperto :wink: dei PIC. (V. contagiri fatto in casa con pic) |
Chiarisci un po meglio come dovrebbe funzionare e in che linguaggio lo programmi. PS: il 16f84 è un pò obsoleto, vedi se riesci a passare al 16F876 o 16F628 o ancora meglio alla serie 18F. Tanto non è che costino molto di più. |
Citazione:
Vorrei contollarlo con un canale libero della ricevemte.... Ho pensato al 16f84 anche se e' vecchiotto, perche' ne ho alcuni in casa, e soprattutto ho una vecchia demoboard che per provare solo quello... Si, pensavo proprio a un contatore, ma speravo in qualche dritta per semplificare un po il tutto, visto che mi basterebbero un paio di livelli... (nel senso che magari con un interrutore a tre posizioni sulla radio posso per esempio fare -tutto off-luci- cercamodelli) tantop per dirne una... se poi sono di piu' meglio, ma per cominciare qualche esperimento di massima mi basta... non ho pretese... Come linguaggio solitamente uso l'assembler.... |
Tratto da questo listato per PIC a 8MHz. CH e CL sono due generici registri a 8 bit, PCMCH3 e' l'alias di un pin di ingresso collegato ad un canale della ricevente. Alla fine in W abbiamo un valore pari a 128 con stick al centro e via via +/-4µS per ogni unita' in piu' o in meno. Codice: ;----------------------------------------------------------------------- |
Segui il consiglio di RIVP6 e passa al 628: il vantaggio è che così hai a disposizione un contatore a 16 bit e rilevare la lunghezza dell'impulso diventa molto facile; in alternativa al codice che vedi qui, puoi usare il 16F84 con il timer0; devi però usare i seguenti accorgimenti: 1) azzerare il timer0 quando rilevi il fromte di salita (invece di dare lo start, dato che il timer0 non si può fermare ed avviare) 2) monitorare anche il flag di overflow e, quando lo trovi ad uno, incrementare la parte alta di un contatore a 16 bit di 1 quindi azzerare il flag di overflow 3) leggere il valore del timer0 ed il elativo flag di overflow quando rilevi il fronte negativo (fine impulso). La stessa logica può essere utilizzata gestendo il punto 2 sotto interrupt. Se invece usi il 628 diventa tutto molto più semplice... ;************************************************* ****************** ; Descrizione bit PortA ;************************************************* ****************** ; #DEFINE Inp PORTA,0 ; input #DEFINE Page_1 STATUS,RP0 ; Page 1 bank switch ;************************************************* ****************** ; Start of code ;************************************************* ****************** ; ORG 0 goto Init ;************************************************* ****************** ; Program init ;************************************************* ****************** ; Init movlw 0xFF ; xxOI IOOO Data dir bsf Page_1 ; Set page 1 movwf TRISA ; I/O Port movlw 0xC2 ; 1000 0010 movwf OPTION_REG ; Presc TMR0/4 bcf Page_1 ; Set page 0 clrf PORTA ; Clear output movlw 0x07 movwf CMCON ;************************************************* ****************** ; Main program start ;************************************************* ****************** ; Start movlw 0x00 movwf TMR1L movwf TMR1H ; Azzera timer 1 bcf T1CON,0 ; Stop Timer1 CountLoop btfsc Inp goto $-1 ; Attende linea bassa btfss Inp goto $-1 ; Inizio impulso bsf T1CON,0 ; Start Timer1 btfsc Inp ; Fine impulso goto $-1 bcf T1CON,0 ; Stop Timer1 END Michele |
Ho visto adesso che il listato preso dall'editor MPLAB ha perso tutte le tabulazioni ed un po' più difficile da leggere... Michele |
L'ultimo lavoro che ho fatto con il PIC risale ad un annetto fa, ma adesso mi avete messo in testa idee nuove... Prima di tutto suggerisco di passare dall' Assembly al PicBasic, perchè ? Ho lavorato due anni in assembler, quando mi hanno fatto provare il PicBasic dell'assembler non ne ho voluto sapere più parlare ! Quello che in Basic scrivi in dieci righe, con l'assembly lo devi scrivere in una pagina, e poi ci sono un sacco di funzioni già bell'e pronte da utilizzare... Io pensavo una cosa.... al servo arriva un segnale digitale che comunica la posizione angolare, adesso non so a quanti bit viene codificato questo segnale, ma sicuramente sono più di 3. Si potrebbe mettere sul radiocomando un commutatore ad otto posizioni per esempio (lo si può fare anche a 4 o a 2) collegato in modo che questo ad ogni scatto disinserisca o inserisca resistenze in serie al canale della radio che vogliamo utilizzare. In questo modo per esempio potremmo associare (supponendo che la tensione massima sul canale sia di 5 volt, adesso non so i valori reali) alla funzione 1 il valore di 0.5 volt, alla funzione 2 il valore di 1 volt, alla funzione 3 il valore di 1.5 ....alla funzione n il valore 5 volt (questo si può fare semplicemente tramite dei partitori resistivi, se volete vi invio un semplice schemino) La parte progettuale più complicata sta appunto dal lato ricevente. Il PIC dovrebbe "capire" quale range di tensione il TX sta inviando su quel canale. La questione è abbastanza scomoda perchè il PIC oltre ad eseguire per esempio il gioco di luci, deve costantemente tenere sotto controllo gli impulsi che gli arrivano dalla ricevente, perchè se vogliamo cambiare fuzione, lui deve passare ad un'altra subroutine. La difficoltà principale credo sia quella di sincronizzarsi e analizzare il segnale digitale (treno di impulsi) che esce dalla ricevente, in questi giorni ci penso un pò su, vediamo se ne esce fuori qualcosa.. |
Citazione:
|
la ricevente comunica con il servo tramite un onda quadra compresa tra due ampiezze ben definite, che ora non ricordo, non con un voltaggio... ciaooo! |
Citazione:
http://www.baronerosso.it/Articolo28.html |
Ho appena realizzato e testato su bredboard un semplicissimo circuitino che accende un LED se lo stick del canale 1 sul TX è in posizione centrale, modificandolo e ampliandolo un pochettino dovrei riuscire a fare proprio quello che chiedi tu POWER !!! Sento che ci sono vicino...mi devi die precisamente delle cose però.... Quante funzioni devi implementare ? Devi usare per forza il 16f84? (perchè a casa non ne ho, e non posso provare) |
OK, CI SONO RIUSCITO !!! Devo però prima dire due cosette.... Innanzitutto io non me ne faccio niente di sto circuito perchè la mia radio è 2 canali .... :-) Io ho utilizzato un PIC 18F458 (esagerato per l'applicazione), ma basta anche un semplice 16F84 (a convertitre il programma non ci vuole niente) Ho realizzato un piccolo video, (la qualità è scadente perchè la macchinetta fa veramente schifo) Attualmente al posto dell'interruttore sul radiocomando ho usato lo stick in questo modo: stick tutto in alto => gioco di luci (nel video di esempio lampeggano due led rossi) stick al centro => nessuna operazione (un led verde indica che il TX è acceso) stick tutto in basso => suona il cicalino (inserendo all'uscita del PIC un BC547 collegato opportunamente si può aumentare la potenza sonora del cicalino, poichè la corrente massima che il PIC fornisce è 25 mA) Se volete informazioni più precise chiedete pure |
Prima di tutto voglio ringraziare tutti per l'attenzione e le risposte.... Ho sempre preferito usare l'assembler, , perche anche se piu' complesso da fare il programma una volta trasferito occupa molto meno istruzioni allinterno del pic... Ovviamente parlo di un paio di anni fa quando ho cominciato a interessarmi ai pic... So che oggi esistono dei compilatori ottimizzati abastanza bene anche con altri linguaggi, ma a livello professionale continuano tutti a usare l'assembler.... Quello che volevo fare e' proprio una cosa come quella che hai descritto.... segnale al minimo (nessuna operazione) Segnele a meta' (luci) Segnale al ax (cicalino) Giusto per avere un idea di massima, poi si potra' ampliare a piacimento... Forse usare un registro implica meno componenti esterni... no? |
Come componenti esterni ho usato solo il cicalino e una resistenza sul PIN reset del PIC, la tensione di alimentazione per il PIC la puoi prendere direttamente dal pack batterie della RX, stando ovviamente attento ai consumi vari... :blink: Se mi dai la tua email ti invio il video... ps: A questi livelli credo sia assolutamente conveniente usare l'alto livello, tanto tutta questa memoria non la usi !!! di che registro parlavi ??? |
Citazione:
Ciao, Michele |
Si si... immagino.... infatti ho specificato che come conoscenze sono rimasto a un paio di anni fa quando fare un programma in basic era semplice per l'operatore, ma occupava un casino di istruzioni per il pic... |
Citazione:
Scusa... avevo capito che mettevi un partitore anche sul ricevitore.... Per il compilatore sono d'accordo, per fare cavolate cosi' penso sia meglio usare cose semplici.... |
Citazione:
L'unico problema che un compliatore decente BASIC o C costa un pozzo di soldi, mentre l'assembler è ancora gratis. Comunque per le cavolatine, guarda qui: http://www.mikroelektronika.co.yu/english/...basic/index.htm oppure http://www.mikroelektronika.co.yu/english/...ikroc/index.htm puoi scaricare le demo limitate solo alla dimensione del codice |
Citazione:
moolto interessante..... grazie mille... |
Se vuoi ti posso inviare la demo di PicBasic che è il software che uso io, ovviamente anche questo è limitato in lunghezza del codice, ma ti ripeto, per quello che ci devi fare tu è pi che sufficiente! |
Citazione:
mmmm.... Magari... volentieri, cosi' gli do un occhiata... Se riesci lo puoi spedire per e-mail a ptnlnzsbn@libero.it Grazie mille... |
Purtroppo la comunita' di sviluppatori liberi non ha previsto di sviluppare un compilatore GCC freeware che permetta a tutti gli utilizzatori di Pic di fruire delle potenzialita' dei linguaggi ad alto livello, in ogni caso ci sono dei compilatori C che permettono lo sviluppo limitato e gratis. Compilatori C x pic http://www.picant.com/c2c/c.html la versione C free ha delle limitazione ma compila 2K per 16F e 4 K per 18F riporto in originale "BoostC can be used without registration. Limitations: PIC16 2k code / 2 banks, PIC18 4k code / 2 banks, occasional upgrade info dialog, Non commercial use only" La versione a pagamento partono dai 4,99$ in su naturalmente le limitazioni scendono al salire del prezzo pero' mi pare che con la free si possa gia scrivere qualcosa di buono. http://www.bknd.com/cc5x/download.shtml free solo per 12C e 16F fino a 1024 istruzioni per modulo . Buono sviluppo in C :wink: |
Vorrei postare qui sul forum il listato del programma in BASIC che ho realizzato, ma sto forum non supporta gli allegati in formato Blocco note e nemmeno quelli in formato ZIP !!! |
1 Allegato/i Citazione:
|
Mi dice che non ho il permesso di caricare file*.rar, più tardi provo con i*.zip |
Avrei un ultimo problemino sempre con PIC16F84..... Non sò come si fa a gestire l'interrupt, ora mi spiego...... . Nel codice assembler io sò come programmare i vari PIN in modo che riconoscano un Interrupt, per esempio su RB0 ma poi non sò come fare a specificare quali sono le istruzioni da fare eseguire al PIC in seguito a tale interrupt, ad esempio premo un pulsante-> Interrupt-> Lampeggio di led Come si scrive la routine di lampeggio in modo che il PIC la riconosca come routine di interrupt? Mi pare che sul datasheet c'è scritto che tale routine va chiamata ISR (Interrupt Service Routine), ma se io volessi che premendo un secondo pulsante il PIC legga una seconda routine, diversa dalla prima, come la devo chiamare ISR2? E' possibile implementare un tipo di codice che faccia in modo che mentre il PIC sta eseguendo uno specifico interrupt, alla pressione di un secondo pulsante, interrompa questo interrupt, passi ad un nuovo interrupt, poi finito quest'ultimo torni all'interrupt precedente, e poi torni infine al programma? E come le devo chiamare le varie routine? Spero di essermi spiegato, grazie |
Adesso questo non lo ricordo con precisione, perchè l'interrupt in assemly PIC l'ho fatto al quarto anno delle superiori, ovvero circa 3 anni fa...e poi non l'ho più utilizzato...comunque, da quanto ricordo, al verificarsi dell'interrupt il program couter salta ad una locazione ben precisa...forse era qualcosa del tipo 0004 qindi per gestire un interrupt dovresti fare qualcosa del tipo... 0000H goto yyyy H ........ 0004 H ISR (da qui in poi devi scrivere ciò che si deve fare al verificarsi dell'interupt, ovviamente le istruzioni non devono finire sulla locazione di indirizzo yyyy H) yyyy H programma principale Quando il PIC subisce un reset (quindi anche all'accensione) lui riparte dalla locazione 0000 H, avendo inserito il goto yyyy e come se lui partisse dalla locazione yyyy saltando così all'avvio la ISR Ahhh...dimenticavo...ISR significa (Interrupt Service Routine) praticamente è la routine (ovvero l'insieme di istruzioni) che il PIC deve eseguire al verificarsi di un interrupt Spero di esserti stato utile |
@SoldatoSemplice Guarda che ti ho risposto a proposito dell'interrupt nell'altro post ... http://www.baronerosso.it/forum/index.php...pic=16113&st=10 Ciao, Michele |
| Tutti gli orari sono GMT +2. Adesso sono le 18:30. |
Basato su: vBulletin versione 3.8.11
Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
E' vietata la riproduzione, anche solo in parte, di contenuti e grafica. Copyright 1998/2019 - K-Bits P.I. 09395831002