Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Classi esclusivamente statiche
Forum - C/C++ - Classi esclusivamente statiche - Pagina 2

Pagine: [ 1 2 ] Precedente | Prossimo
Avatar
Roby94 (Member)
Guru


Messaggi: 1170
Iscritto: 28/12/2009

Segnala al moderatore
Postato alle 22:03
Venerdì, 19/09/2014
Testo quotato

Postato originariamente da pierotofy:
Mi fermo qui perchè non ho ancora visto una singola riga di codice.


Per rispetto al tuo tempo posto il codice completo, non ne vedevo il bisogno, pero se semplifica la comprensione.

header
Codice sorgente - presumibilmente C++

  1. #ifndef UART_H
  2. #define UART_H
  3.  
  4. #include <avr/io.h>
  5.  
  6. #define UARTRxBufferSize 32
  7. #define UARTTxBufferSize 32
  8.  
  9. class UART
  10. {
  11. protected:
  12.        
  13.         static uint8_t txBufferIndex;
  14.         static uint8_t rxBufferIndex;
  15.        
  16.         static uint8_t txBuffer[UARTRxBufferSize];
  17.         static uint8_t rxBuffer[UARTTxBufferSize];
  18.        
  19. public:
  20.        
  21.         void Init(uint16_t);
  22.        
  23.         void RxInterruptEnabled();
  24.         void RxInterruptDisabled();
  25.         void TxInterruptEnabled();
  26.         void TxInterruptDisabled();
  27.        
  28.         void Tx(uint8_t);
  29.         void Tx(uint16_t);
  30.         void Tx(uint32_t);
  31.         void Tx(char*);
  32.         void Tx(uint8_t*, int);
  33.  
  34.         uint8_t RxAvailable();
  35.  
  36.         void ManagementRxBuffer();
  37.         void ManagementTxBuffer();
  38. };
  39. #endif


C++
Codice sorgente - presumibilmente C++

  1. #include "UART.h"
  2. #include <avr/io.h>
  3. #include <util/delay.h>
  4. #include <avr/interrupt.h>
  5.  
  6. void UART::Init(uint16_t ubrr)
  7. {
  8.        
  9.         UCSR0A = (1<<U2X0);//Raddoppio la velocita di trasmissione
  10.         UCSR0B = (1<<RXEN0) | (1<<TXEN0); //Abilito il pin di ricezione e il pin di trasmissione
  11.         UCSR0C = (1<<UCSZ01) | (1<<UCSZ00);//Imposto a 8 la lunghezza in bit di un carattere
  12.        
  13.         UBRR0H = ubrr >> 8;
  14.         UBRR0L = ubrr;
  15.        
  16.         UART::RxInterruptEnabled();//Abilito l'interrupt per la ricezione di un byte
  17.         UART::TxInterruptEnabled();//Abilito l'interrupt per la conclusione di invio di un byte
  18. }
  19.  
  20. void UART::RxInterruptEnabled()
  21. {
  22.         UCSR0B |= (1 << RXCIE0);
  23. }
  24. void UART::RxInterruptDisabled()
  25. {
  26.         UCSR0B &= ~(1 << RXCIE0);
  27. }
  28. void UART::TxInterruptEnabled()
  29. {
  30.         UCSR0B |= (1 << TXCIE0);
  31. }
  32. void UART::TxInterruptDisabled()
  33. {
  34.         UCSR0B &= ~(1 << TXCIE0);      
  35. }
  36.  
  37. void UART::Tx(uint8_t data)
  38. {
  39.         UART::TxInterruptDisabled();//Disabilito l'interrupt legato alla fine dell'ivio di un byte
  40.        
  41.         UART::txBuffer[UART::txBufferIndex] = data;//Posiziono un byte nel buffer
  42.         UART::txBufferIndex++;
  43.        
  44.         UART::TxInterruptEnabled();
  45.        
  46.         UART::ManagementTxBuffer();
  47. }
  48. void UART::Tx(uint16_t data)
  49. {
  50.         UART::Tx((uint8_t*) &data, 2);
  51. }
  52. void UART::Tx(uint32_t data)
  53. {
  54.         UART::Tx((uint8_t*) &data, 4);
  55. }
  56. void UART::Tx(char* s)
  57. {
  58.         while(*s != '\0')
  59.         {
  60.                 UART::Tx((uint8_t) *s);
  61.                 s++;
  62.         }
  63. }
  64. void UART::Tx(uint8_t* punt, int n)
  65. {
  66.         if(n > 0)
  67.         {
  68.                 UART::Tx(*punt);
  69.                 UART::Tx(punt++, n--);
  70.         }
  71. }
  72.  
  73. uint8_t UART::RxAvailable()
  74. {
  75.         return UART::rxBufferIndex;//Restituisco il numero di byte nel buffer di ricezione
  76. }
  77.  
  78. void UART::ManagementRxBuffer()
  79. {
  80.         uint8_t waste;//Alloco un byte in caso dovessi eliminare dei dati
  81.         if(UART::rxBufferIndex < UARTRxBufferSize)//Verifico che il buffer non sia pieno
  82.         {
  83.                 UART::rxBuffer[UART::rxBufferIndex] = UDR0;//Posiziono il dato nel buffer
  84.                 UART::rxBufferIndex++;//Aumento di uno l'indice che indica il primo elemento disponibile
  85.         }
  86.         else
  87.         {
  88.                 waste = UDR0;//Scarto il valore in arrivo
  89.         }
  90. }
  91. void UART::ManagementTxBuffer()
  92. {
  93.         uint8_t data;//Alloco un byte di memoria per il dato da trasmettere
  94.         if(UART::txBufferIndex != 0)//Verifico che nel buffer di trasmissione vi siano dei dati
  95.         {
  96.                 data = UART::rxBuffer[0];//Salvo il dato da trasmettere
  97.                 for(uint8_t i = 1; i < UART::rxBufferIndex; i++)//Creo un ciclo per spostare di una posizione indietro i dati nel buffer di trasmissione
  98.                 {
  99.                         UART::rxBuffer[i-1] = UART::rxBuffer[i];//Sposto il dato corrente indietro di uno nel buffer
  100.                 }
  101.                 UART::txBufferIndex--;//Decremento la posizione del primo byte disponibile nel buffer di trasmissione
  102.                 while(!(UCSR0A & (1 << UDRE0)));//Attendo che il buffer sia vuoto
  103.                 UDR0 = data;//Inserisco il valore ad 8 bit nel buffer di trasmissione
  104.         }
  105. }
  106.  
  107. ISR(USART_RX_vect) { UART::ManagementRxBuffer(); }
  108. ISR(USART_TX_vect) { UART::ManagementTxBuffer(); }



Devo ancora modificare tutte le chiamate ai metodi, convertire i buffer in buffer circolari ma l'idea generale è questa.
A questo punto pensavo (correggetemi se sbaglio) di posizionare in un namespace la dichiarazione della classe generica, l'inizializzazione per i moduli UART del dispositivo e le chiamate degli interrupt legati ai vari moduli cosi dall'esterno del namespace avrò le classi gia inizializzate, si puo fare? o dentro un namespace non si può inizializzare una classe?

PM Quote
Pagine: [ 1 2 ] Precedente | Prossimo