Home Forum MICROCONTROLLORI Ricevere il timemark del gps su un pic24

Questo argomento contiene 6 risposte, ha 2 partecipanti, ed è stato aggiornato da Piero Boccadoro Piero Boccadoro 8 mesi, 1 settimana fa.

Stai vedendo 7 articoli - dal 1 a 7 (di 7 totali)
  • Autore
    Articoli
  • #60471

    Salve a tutti, 

    sono uno studente di ingegneria e devo ricevere su un pic24fj128ga010 il timemark proveniente da un ricevitore GPS attraverso la porta seriale RS232. Il problema è che non so programmare in C..qualcuno può aiutarmi..ve ne sarei molto grato

    #75284
    Piero Boccadoro
    Piero Boccadoro
    Partecipante

    Caspita… direi che è un bel problema.
    Mai fatto? Mai visto? Mai studiato?
    Manco le basi?
    Ti consiglio caldamente di dare uno sguardo agli articoli che abbiamo pubblicato.
    Usa la barra di ricerca per cercare e leggere tutti gli articoli sui pic e i micro in generale.
    Proviamo a darti una mano “pratica”. Leggi quello che c’è scritto e impara almeno come funziona, non dico perchè..
    Così dovresti essere in grado di cavartela.
    Usa i commenti ai singoli articoli ma anche questo post per fare delle domande alla comunità e vedremo di supportarti.
    In bocca al lupo! :D

    #75285
    Piero Boccadoro
    Piero Boccadoro
    Partecipante

    PS: la barra di ricerca la trovi in fondo alla pagina ;)

    #75291

    ciaoo piero,

    mai fatto e visto..sono uno studente di aeronautica e sto facendo una tesi sugli impianti elettrici..ho solo qualche nozione di fortran90 di qualche anno fà..non è che nn lo voglio studiare..ma questa è una piccola parte della mia tesi e il professore mi ha sconsigliato di studiarlo se voglio finire in tempi nn biblici…

    vedo se riesco a trovare qualcosa di utile…grazie

    #75292

    In realtà ho la versione completa dello script, in cui il pic24 campiona un segnale  e ulitizza il timemark del gps come base dei tempi..

    devo capire cosa devo eliminare in modo da ricevere solo il timemark…

    questo è lo script…se vuoi dargli un occhiata te ne sarei grato

    #include <stdio.h>
    #include <htc.h>
    #include "delay.c"
    #include <conio.h>

     

    void USARTInit()
    {
    TRISA=0; 
    U2MODE=0b1000000000000000;  // abilito usart

    TRISF=0;      // tutte le porte F come output, penserà la usart ad aprire le giuste porte di input, output
    U2STAbits.UTXEN=1;   // abilito la trasmissione
    U2BRG=240;     //baud 1200, dalla tabella—->207, tutte le altre: impostazioni di defoult quindi—>1200,8,N,1

    //********************************************************************************************************//
    //********************************************************************************************************//
    }
    void DCInit()     
    {

    AD1PCFGL = 0b0000000000000000;// abilito l'an 8 come analogica. modificato dspic

    AD1CON1 = 0b0000000011100000; 
    AD1CON1bits.ADDMABM=1;  //dma buffer are written in the order of conversion
     
    //finito il campionamento faccio ripartire subito la conversione samc=00000 

    AD1CHS0= 0b0000000000001000; //an8 

    AD1CSSL = 0;
    //*é************************controllare||
    AD1CON3 = 0b0000000000000000;  //Tad = Tcy e 0 Tad oltre i limiti

    //AD1CON2 = 0b0000000000111100;  //interrupt ogni 16 campioni-conversioni
    AD1CON2 = 0b0000000000000000;  //interrupt ogni 1 campioni-conversioni

    //AD1CON4bits.DMABL=4; //16 words of buffer to each analog imput

    AD1CON1bits.ADON = 1; 

    }

    void InitDma()
    {
    LATAbits.LATA0 = 1;

    DMA0CONbits.AMODE=0; //configure dma for register indirect mode with post increment
    DMA0CONbits.MODE=2;  //continuous ping-pong mode

    DMA0PAD=&ADC1BUF0;  //point dma to adcbuf
    //DMA0PAD=(int)&ADC1BUF0;  //point dma to adcbuf
    //DMA0STA=0x0300;  //point dma to adcbuf

    //DMA0CNT=31;
    //DMA0REQ=13;

    DMA0CONbits.CHEN=1; //enable dma
    }

    void InitClock()
    {
    PLLFBD = 38; // M = 40                     per avere fcy=40 MHz. 
    CLKDIVbits.PLLPOST = 0; // N1 = 2
    CLKDIVbits.PLLPRE = 0; // N2 = 2
    }
     

    void putch (char lettera)
    {
    LATAbits.LATA1 = 1;   //invece di fare un controllo sul registro di memoria,sembra che sia meglio aspettare 250Ms 
    DelayMs(250);
    U2TXREG=lettera;
    }

    char getch()
    {
        while(URXISEL1)
    {  
      LATAbits.LATA2 = 0;   //sono solo controlli per vedere se entra (e quando) in questa parte del programma
        //DelayMs(250);
     LATAbits.LATA2 = 1;   ////////////////RIMANE SPENTO
    //DelayMs(250);
    continue;
    }
    {

    LATAbits.LATA3 = 1;    
    //DelayMs(250);
    return U2RXREG;
    }
    }

    //**********************************************************//

    void main(void)
    {
          
    int* puntatore; // punta all'indirizzo del primo buffer, puntatore++punta ai successivi indirizzi ADC1BUF1 ADC1BUF2 ecc…..
    int matrice_valori[10][3]; //vettore di 16 valori (sono i campioni), per 10 (cioe' memorizza i valori dei 16 buffer, per 10 successive acquisizioni)
    int a; // metto qui dentro il valore del buffer 
    int vettore_valori[16];
    int somma=0;
    int max=0;
    int i=0;
    int j=0; //numero che indica la riga/colonna
    int controllo=1; // serve per attendere l'immissione di un carattere non nullo (lo spazio?)
    int k=0;
    char input;     

    USARTInit();
    InitClock();
    InitDma();
    DCInit();

        
    printf("—\r\n");
    printf("scrivi numero\r\n");

    LATAbits.LATA4 = 1;
    input=getch();

    while(controllo)   // sembra che se non si digita nulla, il programma comunque va avanti e non restituisce neulla, con questo controllo si mette in attesa di un carattere
    if (input=='\0')
    input=getch();
    else
    controllo=0;

    //controllo di giusto funzionamento dell'usart
    printf(" ecco numero: %c ", input);
    printf("usart ok");

    LATAbits.LATA5 = 1;   
    //printf("i=%d",i);

    //// campionamento di 3 set di valor/////
    while(i<1)
    {
    LATAbits.LATA7 = 1;
    AD1CON1bits.ASAM = 1; //inizia a campionare
    puntatore=&ADC1BUF0;
    IFS0bits.AD1IF=0;

    while (!IFS0bits.AD1IF);

    // conversione finita? AD1IF=0 non c'è stata interrupt, 1 interrupt avvenuto
    AD1CON1bits.ASAM = 0; 
    }
    // metto i valori campionati, 16 per volta, in una matrice
    j=0;

    while(j<16)
    {

    a=*puntatore++;
    //matrice_valori[i][j]=a;
    j++;
    vettore_valori[k]=a;   //per comodità metto i valori anche in un vettore
    k++;
    }
    i++;
    }

    i=0;  //azzero i contatori per riutilizzarli
    j=0;

    //stampa della matrice
    //while(i<3)
    //{
    //
    //printf("\n\r");
    //printf("set di campionamento %d: \n\r", i);
    //while(j<16)
    //{
    //printf("%d ", matrice_valori[i][j]);
    //j++;
    //}
    //i++;
    //j=0;
    //}

    printf("vettore di valori\r\n");
    i=0;
    j=0;
    k=0;
    // stampa del vettore
    while(k<16)
    {

    printf("%d",vettore_valori[k]);
    printf("\r\n");
    k++;
    }
     

    // valore massimo del campionamento
    k=0;
    while(k<16)
    {
    if(vettore_valori[k]>max)
    max=vettore_valori[k];
    k++;
    }
    printf ("massimo valore=%d",max);

    // valore medio del campionamento
    k=0;
    while(k<16)
    {
    somma=somma+vettore_valori[k];
    k++;
    }
    printf ("valore medio=%f",(int) somma/48);
    // problemi coi valori float

    printf(" fine ");
    while(1);

     

    }

    #75336
    Piero Boccadoro
    Piero Boccadoro
    Partecipante

    Una domanda, per capirci: i commenti non li hai messi tu. Giusto?

    #75355
    Piero Boccadoro
    Piero Boccadoro
    Partecipante

    Ho letto diverse volte il codice però… sinceramente non saprei.
    Sorry.

Stai vedendo 7 articoli - dal 1 a 7 (di 7 totali)

Devi aver eseguito l’accesso per poter rispondere a questa discussione.