[ing. Informazione] - Ing. E Tecnologia Dei Sist. Di Controllo, con il prof. Bonfè Opzioni

[Ale83]

Ciao, per il mese prossimo (diciamo a cavallo tra maggio e giugno) vorrei preparare l'esame di Bonfè, Ingegneria e Tecnologia dei Sistemi di Controllo. C'è qualcuno che ha in programma di darlo? In particolare, potendo sostituire una buona fetta di teoria con una tesina/progettino a scelta da un elenco di temi proposti, qualcuno sarebbe interessato? C'è la possibilità di fare la tesina in coppia, per questo chiedo (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_smile.gif)

Link al sito ufficiale del corso.

[pasqui]

Tu cosa avresti intenzione di fare?
Fai bene a fare una tesina(per fare un pò di pratica in laborat e imparare ad usare i pic) anke se conviene fare solo lo scritto!
Io la feci l'anno scorso e ho perso 1pò di tempo ,ma ne vale la pena!Poi Bonfè è una gran brava persona!

[Ale83]

Pensavo ad una tesina con labview: il motivo è che se faccio prima l'esame di Foddis (e quindi imparo un pò ad usare labview) poi non dovrei perdere troppo tempo per fare quella di Bonfè. Che dici?
Perchè converrebbe solo lo scritto? Sembra piuttosto lungo da studiare... la teoria è un fiume! (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_smile.gif)

[pasqui]

Si, potresti fare anke così per risparmiare un pò di tempo,poi dipende sempre da quello ke hai intenzione di fare!Tipo io insieme ad un altro ragazzo facemmo il controllo di un pannello solare che ruotava ,in base al movimento del sole(come un girasole),tramite due termoresistenze montate sul pannello,grazie ad un motorino in dc!Il controllo era gestito da un pic16f876 e tutto il firmware è stato scritto in assembler(500 righe di codice,roba da matti!!)!Tutta la parte hardware era on board,infatti facemmo la basetta con l'orcad!Abbiamo lavorato per circa due mesi ogni giorno nel lab di elettronica!Poi preparammo una parte di orale anke, relativa ai bus!Quella la concordi tu con il docente in base alla tesina ke fai!
Fu dura,ma ti servono queste esperienze perkè ti fanno fare poca pratica a mio avviso!
Oro sto facendo la tesi con Bonfè,stiamo progettando un mobile robot insieme ad un altro ingegnere : è una cosa strapesa e sono solo agli inizi!
In bocca al lupo per l'esame!

[Ale83]

Ah tu sei di automazione quindi... questo giustifica i due mesi che ci hai speso su (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_smile.gif) io lo ho scelto come opzionale alla specialistica di telecomunicazioni, giusto per avere un'idea più precisa di sensori/PIC & co.
Cercherò di non andare oltre le 3 settimane per prepararlo... in ogni caso ho deciso di fare prima l'esame di labview e poi vedo se posso riciclare le conoscenze utili (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_wink.gif)

[pasqui]

No, sono di Elettronica e Tlc!!!!!

[Ale83]

Bene bene, alla fine ho fatto slittare ITSC come penultimo esame... ora sono alle prese con PIC 16F877A su scheda PICDEM Mechatronics. Ecco cosa sto cercando di combinare...

Uso, come ingressi analogici, i due forniti dai sensori di temperatura e luminosità rispettivamente, che poi converto in numeri ed invio al computer tramite seriale (RS-232), e coinvolgo in qualche modo l'accensione dei LED della scheda. Al momento, per visualizzare su monitor quel che spedisco sulla seriale, uso HyperTerminal ma provvederò ad implementare l'interfaccia grafica in LabVIEW.

Ho due problemi, al momento.

1) Ho notato che i valori di luminosità e temperatura sono "accoppiati": se copro con un dito il light sensor, i valori di temperatura vanno giù di testa... fluttuano di 30 unità! e da 27 °C vanno fino a -5°C...
Così ho misurato con il multimetro la tensione sui pin che forniscono il segnale in tensione, PRIMA di venire convertito dall'ADC del PIC, e ho notato che i sensori funzionano bene: i volt misurati NON sono affatto dipendenti da cosa rileva l'altro sensore.
Quindi è colpa del PIC che digitalizza. Ma cosa può essere???
Interferenze all'interno del microcontrollore?
I pin su cui entrano i due segnali in tensione sono adiacenti... il max che posso provare è metterli su pin più lontani così magari non si influenzano.
Che ne pensate?

2) Per comunicare con la seriale, uso le funzioni definite in uart.h e uart.c
Ad es., è molto semplice usare UartPuts(string) per spedire una stringa alla seriale oppure Uartputc('X') per spedire il carattere X, ma per leggere da scheda la roba che arriva da pc?
Ho visto che c'è solo Uartgetc(carattere) e in rete la documentazione su queste funzioni è incredibilmente ridotta.
Uartgetc come funziona? se devo farle leggere una stringa, la devo per forza inviare carattere per carattere... ma come fa a sapere quando è finita la stringa?
Funziona come le pipe di unix, magari? che sono bloccanti in lettura?

ciao!

[axettone]

Domanda preliminare prima di scendere nel tecnico: non è che da qualche parte si fa paciugo tra gradi Fahrenheit e Celsius?
x quanto riguarda uart: non ho mai usato quelle librerie, ma di solito quelle porte sono bufferizzate, quindi per leggere dovresti fare un while() che verifichi che il carattere non sia un terminatore ('\0', EOF..).
Spero di non aver detto delle castronerie eccessive...

[graograman]

probabilmente l'accoppiamento sensore luce e temp è dovuto alle dita, se copri con un dito il light sensor e questo è vicino al termometro, ti stai avvicinando con una sorgente di 36° (il dito) al sensore, e questo sbirilla.
Ma è un'ipotesi.

Un'altra ipotesi è che i cavi non siano schermati, se hai i sensori lontani, usa un accoppiamento cavo segnale-massa per pulirti da eventuali loop elettromagnetici.

Non sò cosa tu stia facendo, non posso essere molto esplicativo.

L'idea dei pin lontani è valida.

Posta la descrizione di Uartgetc

ogni stringa finisce con il carattere "/0"

ci dovrebbe essere una funzione che girà + o - così:

if(char!='/0')
getchar;
else endofastring;

axettone ha ragione no /0 si \0

[Ale83]

Domanda preliminare prima di scendere nel tecnico: non è che da qualche parte si fa paciugo tra gradi Fahrenheit e Celsius?
x quanto riguarda uart: non ho mai usato quelle librerie, ma di solito quelle porte sono bufferizzate, quindi per leggere dovresti fare un while() che verifichi che il carattere non sia un terminatore ('\0', EOF..).
Spero di non aver detto delle castronerie eccessive...

Con variabili e calcoli opportuni, mappo correttamente la tensione in gradi C, seguendo pari pari le caratteristiche del datasheet. Finchè non intervengo sui sensori, dà anche dei risultati giusti o cmq consistenti (es.: dice 27 gradi quando in lab ce ne sono 25-26).

Per la lettura, pensavo proprio a un

CODICE

while ( (c=Uartgetc()) =! '\0' ) {//istruzioni}

però ora non posso provarlo, la scheda è in lab e posso lavorarci solo lì...

probabilmente l'accoppiamento sensore luce e temp è dovuto alle dita

Magari fosse così semplice... ho provato coprendo con un foglio di carta anzichè il dito, e non cambia assolutamente niente. Inoltre, la tensione (quindi quando i valori dei sensori sono ancora ANALOGICI) ai pin di uscita del sensore di temperatura non fluttua se uso il dito per oscurare il light sensor (o fluttua di pochissimo, ma nell'ordine della frazione di grado)

Un'altra ipotesi è che i cavi non siano schermati, se hai i sensori lontani, usa un accoppiamento cavo segnale-massa per pulirti da eventuali loop elettromagnetici.

I sensori sono vicinissimi, ma la tensione che ciascuno da in output è giusta (misurato in diverse condizioni col multimetro), e fatto la conversione in °C con calcoli a mano: è giusta, e comunque le due tensioni non si mostrano accoppiate.


Un attimo che cerco uartgetc e simili.

Intanto, grazie mille.

EDIT

Il registro ADCON0 configura alcune cose, in particolare dice al convertitore A/D quale ingresso analogico usare (ce ne sono 8 di ingressi, da AN0 a AN7)

I registri ADRESH e ADRESL sono entrambi a 8 bit.

Il convertitore A/D è a 10 bit e, per come l'ho impostato, mette i primi 8 bit in ADRESL e i rimanenti 2 bit occupano le due posizioni meno significative di ADRESH. Chiaro?

CODICE

while(1)
    {
        ADCON0 = 0b01000001;    //f_clock di ADC = 1/8 f_clock di sistema
                                //Ora imposto AN0 (da reimpostare con anche AN1!!)
                                //Convertitore abilitato
                                
        ADRESH = ADRESL = 0b00000000;
        
        /*CONVERSIONE DEL SEGNALE DI TEMPERATURA*/
        ADGO = 1;
        while(ADGO)        // Attesa della fine di ADC
            continue;

        temp = ADRESL + (ADRESH<<8);    // Salvo nella variabile temp
        /****************************************/
        
        ADRESH = ADRESL = 0b00000000;
        
        /*CONVERSIONE DEL SEGNALE DI LUMINOSITA'*/
        ADCON0 = 0b01001001;    //Switch dell'ingresso da AN0 a AN1
        
        ADGO = 1;        // Partenza ADC
        while(ADGO)        // Attesa della fine di ADC
            continue;

        light = ADRESL + (ADRESH<<8);    // Salvo nella variabile light
        /****************************************/
        
        // SEGUE L'OPPORTUNA CONVERSIONE DI TEMP E LIGHT IN GRADI E IRRADIANZA SECONDO LE INDICAZIONI DEI DATASHEET...

Ho anche provato a ripulire i registri ADRES dopo la conversione (con ADRESH = ADRESL = 0b00000000; ) per sicurezza, ma.... nada.

Mi pare proprio un problema di interferenza tra le linee del pic.

Messaggio modificato da Ale83 il 30 Nov 2007 - 17:42

[axettone]

Non è che si è rotto il PIC? Scusa, non ho proprio esperienza in questo campo. E se tu anziché collegare quelle linee ai sensori li collegassi ad un generatore di segnali?

[Ale83]

Generatore di segnali attaccato alle linee di ingresso al PIC dici? posso anche farlo ma non so a cosa possa servire... a vedere se si comporta male anche con ingressi analogici diversi dai sensori?

comunque, ecco la Uartgetch:

CODICE

// ---------------------------------------------------------------------------------------
// Legge un carattere dalla seriale senza limiti di Timeout
// ---------------------------------------------------------------------------------------
unsigned char UartGetch(void) {
    
    while(!RCIF) {
//        CLRWDT();
        UartClearErrors();
    }
    return RCREG;
}

con RCIF: receive interrupt flag
CLRWDT(): Clear Watchdog Timer

Messaggio modificato da Ale83 il 30 Nov 2007 - 18:10

[axettone]

Scusa...ma facendo uno shift di 8 bit non cancelli tutto il registro? (IMG:http://www.ferraraforum.it/style_emoticons/default/piero.gif)
----------------------------------------
HO DETTO UNA CAZZATA! Lascia perdere... (nn ho usato molto lo shift di recente)
Però c'è un fondo di realtà: dato che stai misurando temperature basse, perché non eviti per un attimo quello shift? Non è che lo hai calcolato male? Non mi torna perché fai <<8.
-----------------------------------------
In realtà adesso mi torna... scusa ma proprio lo shift non ce l'ho fresco. Sicuro che sia tutto little endian?

Messaggio modificato da axettone il 30 Nov 2007 - 18:34

[graograman]

più che altro, sicuro che uno <<8 sia uno shift di 8 posizioni (1 bit) perchè se scrivi 8 bit saltandone 8 rischi di sovrapporlo, allora meglio shiftare di 15 (con lo zero incluso)

ma è roba che non tocco da due anni buoni

[Ale83]

b<<n significa moltiplicare per 2^n un numero binario b, quindi aggiungergli n zeri

Es.: 11 << 4 dà 110000 come risultato (infatti, in base dieci, 3*2^4 = 48)

Quello va bene, nel codice.

[pasqui]

Bene bene, alla fine ho fatto slittare ITSC come penultimo esame... ora sono alle prese con PIC 16F877A su scheda PICDEM Mechatronics. Ecco cosa sto cercando di combinare...

Uso, come ingressi analogici, i due forniti dai sensori di temperatura e luminosità rispettivamente, che poi converto in numeri ed invio al computer tramite seriale (RS-232), e coinvolgo in qualche modo l'accensione dei LED della scheda. Al momento, per visualizzare su monitor quel che spedisco sulla seriale, uso HyperTerminal ma provvederò ad implementare l'interfaccia grafica in LabVIEW.

Ho due problemi, al momento.

1) Ho notato che i valori di luminosità e temperatura sono "accoppiati": se copro con un dito il light sensor, i valori di temperatura vanno giù di testa... fluttuano di 30 unità! e da 27 °C vanno fino a -5°C...
Così ho misurato con il multimetro la tensione sui pin che forniscono il segnale in tensione, PRIMA di venire convertito dall'ADC del PIC, e ho notato che i sensori funzionano bene: i volt misurati NON sono affatto dipendenti da cosa rileva l'altro sensore.
Quindi è colpa del PIC che digitalizza. Ma cosa può essere???
Interferenze all'interno del microcontrollore?
I pin su cui entrano i due segnali in tensione sono adiacenti... il max che posso provare è metterli su pin più lontani così magari non si influenzano.
Che ne pensate?

Ciao Ale, NON penso ke all'interno del micro ci siano problemi, secondo me questi accoppiamenti potrebbero essere dovuti forse ad un mancato pull-up digitale(da fare via software andando a settare il registro della porta che stai usando!) dei pin stessi(io in passato ho avuto un problema simile ) e mettere i segnali su 2 pin lontani non ti cambia il problema.
Hai configurato bene il registro TRISA (se nn sbaglio dovresti trovare qui il bit da settare per il pull up)corrispondente alla PORTA su cui prendi gli ingressi AN0 e AN1?(Fai attenzione perchè i pin sono multiplexati!!) (Per avere degli ingressi analogici il bit TRISA=1)
Escludo che siano problemi dovuti ad accoppiamenti elettromegnetici perchè nn stai usando segnali ad alta freq!Cmq prova a smanettare un pò anke perchè lavorare con i pic nn è banale e ti fa perdere molto tempo!!SE hai bisogna del codice per convertire le variabili temp e light in stringa per spararle sulla seriale fammelo sapere!
Poi un'altra cosa:
/*CONVERSIONE DEL SEGNALE DI LUMINOSITA'*/
ADCON0 = 0b01001001; //Switch dell'ingresso da AN0 a AN1

sei sicuro ke sia corretto?Se nn sbaglio ADCON1configura le funzioni di porta! ( ADCON0 controlla solo le operazioni del modulo A/D)
Cmq la maggior parte del tempo si perde sul firmware!
Se hai bisogno di altre cose fammelo sapere sperando di esserti di aiuto! (IMG:http://www.ferraraforum.it/style_emoticons/default/yuppi2.gif)

[Ale83]

Ciao pasqui, e grazie anche a te per essere intervenuto (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_smile.gif)

Penso che TRISA vada bene... ecco di seguito tutto quello che c'è fino a giusto prima di iniziare il ciclo while(1). Occhio che i registri ADCON vanno settati in modo diverso a seconda del PIC, e questo è il 16F877A, credo che vadano bene così. Lo puoi vedere alle pagine 2 e 3 di questo allegato:
 progetto3.pdf ( 290.58k ) Numero di download: 3045


Mi spiegheresti il pull-up digitale che non so cosa sia, detto così ( ignorantone.. )?

CODICE

// ACQUISIZIONE DI SEGNALI ANALOGICI (TEMPERATURA E LUMINOSITA')
// DA SCHEDA PICdem Mechatronics --- PIC TARGET = 16F877A

/******************************
*      TEMP  --> RA0          *
*      LIGHT --> RA1          *
*   RB0… RB7 --> LED1… LED8   *
*                             *
******************************/


#define XTAL_FREQ 20MHZ

#include <pic.h>
#include "delay.h"
#include "macro.h"
#include "ascii.h"
#include "uart.h"

// CONFIGURATION BITS
__CONFIG(HS & WDTDIS & PWRTEN & BORDIS & LVPDIS & DUNPROT & WRTEN & UNPROTECT);


// PROGRAMMA PRINCIPALE
main(void)
{
    // DICHIARAZIONE VARIABILI
    int temp, light, i;
    unsigned char clock;
    unsigned long baudrate;
    char c,tempstr[4], lightstr[5];

    //INIZIALIZZAZIONE PORTE E REGISTRI
    PORTA = 0b00000000;                // Azzero la porta A
    PORTB = 0b00000000;                // Azzero la porta B

    TRISA = 0b00000011;                // Porta A con ingressi AN0, AN1 (temp, light)
    TRISB = 0b00000000;                // Porta B come uscita    
        
    //CONFIGURAZIONE ADC    
    ADCON1 = 0b10000000;    // Risultato giustificato a destra (bit ADFM = 1)
                            // f_clock di ADC come impostata in ADCON0
                            // AN0... AN7 tutti ingressi analogici
    
    // INIZIALIZZAZIONE SERIALE    
       clock = 20;              
       baudrate = 9600;
       UartInit(clock, baudrate, UART_CFG_BITSTOP_1);

Scrivere sulla seriale mi viene semplice, faccio:

CODICE

UartPutch('-');
UartPuts("Temperature level: ");
int2dec(temp,tempstr);
UartPuts(tempstr);
UartPuts(" C-\r\n\n");

Tu ha mai letto da seriale cose che provenivano dal computer, con uartgetch o simili?

[pasqui]

Mi spiegheresti il pull-up digitale che non so cosa sia, detto così ( ignorantone.. )?


Tu ha mai letto da seriale cose che provenivano dal computer, con uartgetch o simili?

In pratica il pull up ti serve per nn lasciare i pin flottanti e dare un certo riferimento al segnale che stai acquisendo!Leggendo il codice mi sembra ke vada bene, anke se sul data sheet, se vai alla sezione relativa alle porte, trovi (specialmente per PORTB) il fatto del pull up che può essere attivato o disattivato tramite il settaggio di un bit di un registro OPTION_REG<7> (prova a vedere cosa succede se lo modifichi)
Poi, sulla tua scheda ci dovrebbero essere degli switch che controllano gli ingressi( se nn sbaglio lo switch SW1 è relativo ad AN0 e SW2 ad AN1), prova a mettere SW1 e SW2 su ON e vedi se hai ancora quel problema dell'accoppiamento!

Per l'acquisizione seriale da PC->micro conosco solo la uartgetch e penso che sia sufficiente!Poi ti conviene comunicare sia in RX che TX tramite interrupt, ma nn so se il pic che usi ti permette di fare questo!

[Ale83]

Ma settando a 0000 i 4 bit meno significativi di ADCON1 non dovrei già sistemare anche il discorso dei riferimenti? (pag. 3 del pdf che ho allegato prima: prima riga della tabella dice Vref+ = Vdd e Vref- = Vss, in pratica alimentazione e massa)
Forse non ho le idee chiare sulla faccenda dai riferimenti?

Gli switch (ce ne sono 4: SW1, SW2, SW3, SW4) non sono collegati a niente, di per sè, è tramite i jumper che li colleghi tu agli ingressi che vuoi per implementare varie cosine basate sull'uso di pulsanti/interrutori (IMG:http://www.ferraraforum.it/style_emoticons/default/icon_smile.gif)

Se hai un esempio di uso della uartgetc potresti postarlo? io non l'ho ancora provata, devo aspettare di essere in lab domattina...

grazie cmq, eh!

[pasqui]

Se hai un esempio di uso della uartgetc potresti postarlo?

grazie cmq, eh!

Una parte di firmware che ho usato per comunicare con la seriale è questa!Solo ke io usavo un dsPic30F a 16 bit e ho sfruttato alcune librerie che il compilatore (il C30) mi forniva!Penso ke per il 16f877a ci sarà sicuramente qualcosa di simile:


#define __dsPIC30F4011__
#include<p30fxxxx.h>
#include<uart.h>


/* I dati ricevuti vengono caricati in array Buf */
char Buf[80];
char * Receiveddata = Buf;
/* Interrupt service routine di trasmissione */
void __attribute__((__interrupt__)) _U1TXInterrupt(void)
{
IFS0bits.U1TXIF = 0;
}
/* Interrupt service routine di RX */
void __attribute__((__interrupt__)) _U1RXInterrupt(void)
{
IFS0bits.U1RXIF = 0;
/* Leggo dal buffer di ricezione finchè ci sono caratteri disponibili
*/
while( DataRdyUART1())
{
( *( Receiveddata)++) = ReadUART1();
}
}
int main(void)
{
/* Esempio di dato da trasmettere */
char Txdata[200] = {'R','e','a','d','y','','T','X','/0'};
/* Holds the value of baud register */
unsigned int baudvalue;
/* Holds the value of uart config reg */
unsigned int U1MODEvalue;
/* Holds the information regarding uart
TX & RX interrupt modes */
unsigned int U1STAvalue;
/* Turn off UART1module */
CloseUART1();

/* Configuro uart1 per poter trasmettere e ricevere */

ConfigIntUART1(UART_RX_INT_EN & UART_RX_INT_PR6 &
UART_TX_INT_DIS & UART_TX_INT_PR2);
/* Configuro UART1 per trasmettere/ricevere 8 bit di dato e 1 bit di stop.

baudvalue = 5;
U1MODEvalue = UART_EN & UART_IDLE_CON &
UART_DIS_WAKE & UART_EN_LOOPBACK &
UART_EN_ABAUD & UART_NO_PAR_8BIT &
UART_1STOPBIT;
U1STAvalue = UART_INT_TX_BUF_EMPTY &
UART_TX_PIN_NORMAL &
UART_TX_ENABLE & UART_INT_RX_3_4_FUL &
UART_ADR_DETECT_DIS &
UART_RX_OVERRUN_CLEAR;
/* Apro il modulo */
OpenUART1(U1MODEvalue, U1STAvalue, baudvalue);
/* Trasmetto il dato finchè nn incontro il carattere terminatore */
putsUART1 ((unsigned int *)Txdata);
/* Aspetto che la trasmissione termini */
while(BusyUART1());
/* Leggo I dati presenti nel buffer di ricezione */
while(DataRdyUART1())
{
(*( Receiveddata)++) = ReadUART1() ;
}
/* Chiudo il modulo */
CloseUART1();
return 0;
}

Oppure potrai usare una funzione simile che penso potrai trovare nella libreria del tuo compilatore
unsigned int getsUART1(unsigned int length,unsigned int *buffer,
unsigned int uart_data_wait)
• unsigned int length: lunghezza della stringa che si vuol ricevere
• unsigned int *buffer: puntatore alla prima locazione in cui cominci a caricare il dato
• unsigned int uart_data_wait: tempo che devi aspettare prima di terminare la ricezione

Il valore di ritorno è ‘0’ se se l’intera stringa è stata letta, oppure un num diverso da zero che indica il num di byte mancanti.
Es:

d = getsUART1(7, RX_data, 30); /* la puoi utilizzare in modo efficiente all’interno di cicli alla stessa stregua della ReadUART1 dell’esempio sopra!*/

[Ale83]

Ok, ho capito come funziona! Grazie 1000.