Skip to content

MemoryHandler

Jump to bottom Edit New page
GregoSwe edited this page Jan 7, 2015 · 3 revisions

#Indice

Componenti Software

PluviometroI2C_Slave

torna su

Questo package ha lo scopo di raggruppare tutte le componenti software dedicate alla gestione della scheda Arduino collegata al pluviometro e all'interrogazione delle componenti hardware connesse tramite I2C :

  • Memoria EEPROM 24LC256 da 32kb;
  • Tiny RTC.

Inoltre vengono fornite funzionalità per l' ottimizzazione dello spazio occupato in memoria dalle informazioni da salvare e un protocollo di interrogazione I2C per il trasferimento dei dati sempre attraverso protocollo I2C.

Componenti software:

MemoryHandler - MH

torna su

Componente software adibita alla gestione, in lettura e scrittura, della memoria interna ed esterna all'interrogazione della RTC per il recupero della data e l'ottimizzazione dello spazio in memoria. Inoltre gestisce la memoria per tenere traccia dei dati che sono già stati letti dalla scheda Master e quelli che devono ancora essere letti.

MH Attributi

torna su

Pubblici:

Privati:

private:
    int MEMORYADD;
    int RTCADD;           
    int unsigned MAXMEMORY;        
    int MAXSTACK;   
    int unsigned currentPosition;      
    int unsigned lastTimestampPosition;
    int unsigned timestampCount; 
    bool interrupted;

MH Descrizione degli attributi

torna su

Pubblici

Privati

  • int MEMORYADD -> intero rappresentante l'indirizzo fisico nel bus della memoria EEPROM esterna;

  • int RTCADD -> intero rappresentante l'indirizzo fisico nel bus della tiny RTC;

  • int unsigned MAXMEMORY*-> intero rappresentante il numero di byte della memoria (32768 per la memoria utilizzata);

  • int MAXSTACK -> intero dipendende da MAXMEMORY e il numero di byte utilizzato per rappresentare un singolo timestamp: in questo caso 6. MAXSTACK = MAXMEMORY/6;

  • *int unsigned currentPosition -> intero che rappresenta sia il numero totale di timestamp salvati in memoria, sia la posizione logica** in cui abbiamo salvato l'ultimo timestamp

  • * int unsigned lastTimestampPosition; -> intero che rappresenta la posizione logica** dell'ultimo timestamp letto dalla scheda Master;

  • * int unsigned timestampCount -> intero che rappresenta il numero di timestamp inseriti dall'ultima lettura effettuata dalla scheda Master;

  • bool interrupted -> booleana rappresentante la necessità di effettuare un salvataggio in memoria del timestamp.

* Questa variabile viene salvata all'interno della memoria EEPROM del microcontrollore della scheda Arduino, aggiornata quando necessario e caricata in memoria alla costruzione della classe.

** posizione_fisica = posizione_logica \* numero_byte_per_timestamp numero_byte_per_timestamp = 6. ##MH Metodi

torna su

Pubblici:

public: 
    MemoryHandlerClass();
    void storeTimestamp();
    int newTimestamp();
    byte* getNewTimestamp(bool _letUnread);
    byte* getNewTimestamp(int _from,int _howmany,bool _letUnread);
    int memoryUsed();
    byte* getMemoryUsed();
    byte *getMemoryUsed(int _from,int _howMany);
    void checkInterrupt();
    void interrupt();
    int eraseMemory();

Privati:

private:
    void ask_time(int * _params);
    void setCounters();
    void compressInformation(byte * _compressedValue, int * _array);
    void writeEEPROM(unsigned int,byte);
    byte readEEPROM(unsigned int);
    byte * getMemory(int _from,int _to); 
    int incrementCounters();
    byte decToBcd(byte _val); 
    byte bcdToDec(byte _val);
    int getInfo(int _position, int _type);
    int getInfo(byte*_byteArray, int _type);
    void updateCounter(int, int, int);

MH Descrizione dei metodi

Pubblici

Costruttore della classe;

  • Metodi usati:

    • setCounters().

  • Variabili direttamente modificate:

    • MEMORYADD;
    • RTCADD;
    • MAXMEMORY;
    • MAXSTACK;
    • interrupted

  • ####void storeTimestamp() torna su

Metodo in cui viene interrogato il componente RTC per recuperare parte delle informazioni del timestamp (giorno, mese, anno, ora, minuti, secondi), ai quali verrà aggiunto un contatore che identifica il numero del timestamp inserito dall'ultima lettura effettuata. Una volta recuperate le informazioni verranno compresse secondo il formato indicato per risparmiare più byte possibili e salvati nella memoria estera correttamente;

  • Metodi usati:

    • ask_time();
    • compressInformation();
    • incrementCounters();
    • writeEEPROM().

  • ####int newTimestamp() torna su

Metodo che ritorna il numero di timestamp inseriti in memoria dall'ultima lettura effettuata dalla scheda Master;

  • ####byte* getNewTimestamp(bool _letUnread) torna su

    Metodo che ritorna un array di byte contenente i timestamp inseriti in memoria dall'ultima lettura effettuata.

    • Parametri:
      • bool _letUnread:
        • true: mantiene i timestamp in memoria come non letti;
        • false: i timestamp ritornati verranno segnati come letti.
    • Metodi usati:
      • updateCounter();
      • getMemory().
    • Variabili direttamente modificatate:
      • timestampCount;
      • lastTimestampPosition.
    • Varie:
      • Memoria HEAP: questo metodo occupa memoria nello HEAP tramite l'operatore NEW.

  • ####byte* getNewTimestamp(int _from,int _howmany,bool _letUnread) torna su

Metodo che ritorna un array di byte grande [_howmany] contenente i timestamp inseriti in memoria non ancora letti compresi in un determinato intervallo;

  • Parametri:

    • bool _letUnread:
      • true: mantiene i timestamp in memoria come non letti;
      • false: i timestamp ritornati verranno segnati come letti.
    • int _from: posizione in memoria da cui iniziare a prelevare i timestamp non letti;
    • int _howMany: intero che identifica il numero di byte da leggere dalla memoria.

  • Metodi usati:

    • updateCounter();
    • getMemory().

  • Variabili direttamente modificate:

    • timestampCount;
    • lastTimestampPosition.

  • Varie:

    • Memoria HEAP: questo metodo occupa memoria nello HEAP tramite l'operatore NEW.
    • Metodo utilizzato per risolvere il problema della RAM limitata di Arduino UNO. Per inviare memoria superiore a 1200byte si faranno più richieste divise in blocchi. *

  • ####int memoryUsed() torna su

    Metodo che ritorna il numero di byte che sono occupati da timestamp in memoria;

  • ####byte* getMemoryUsed() torna su

Metodo che ritorna tutta la memoria utilizzata in memoria;

  • Metodi usati:

    • getMemory().

  • Varie:

    • Memoria HEAP: questo metodo occupa memoria nello HEAP tramite l'operatore NEW.

  • ####byte *getMemoryUsed(int _from,int _howMany) torna su

    Metodo che ritorna un blocco di memoria

    • Parametri:
      • int _from: posizione in memoria da cui iniziare a prelevare i byte;
      • int _howMany: intero che identifica il numero di byte da leggere dalla memoria.
    • Metodi usati:
      • getMemory().
    • Varie:
      • Memoria HEAP: questo metodo occupa memoria nello HEAP tramite l'operatore NEW;
      • Metodo utilizzato per risolvere il problema della RAM limitata di Arduino UNO. Per inviare memoria superiore a 1200byte si faranno più richieste divise in blocchi. *

  • ####void checkInterrupt() torna su

    Metodo che controlla se c'è stata una interrupt che inizia il protocollo di salvataggio di un nuovo timestamp;

    • Metodi usati:
      • storeTimestamp().

  • ####void interrupt() torna su

    Metodo che viene invocato nel momento in cui avviene una interruzione e viene cambiato il valore della variabile che rappresenta questo evento

    • Variabili direttamente modificate:
      • interrupted.

  • ####int eraseMemory() torna su

    Metodo che cancella la memoria, ripristina i contatori a zero e ritorna il numero totale di byte cancellati.

  • Metodi utilizzati:

    • writeEEPROM();
    • updateCounter().

  • Variabili direttamente modificate:

    • currentPosition;
    • lastTimestampPosition;
    • timestampCount.

* Esempio:

1500byte da richiedere
1° blocco -> [1200];
2° blocco -> [300];

1200 byte sono una misura testata, utilizzare sempre multipli di 30 poiché i protocolli di invio dei dati sono da 30byte alla volta.

torna su

Privati

  • ####void ask_time(int * _params) torna su Metodo che interroga la RTC per recuperare le informazioni del timestamp.

    • Parametri:
      • int* _params (modificato all'interno della funzione): puntatore ad un array di interi nel quale verranno salvate le informazioni nel seguente ordine {giorno, mese, anno, ore, minuti, secondi}.

  • ####void setCounters() torna su

    Metodo che legge dalla EEPROM interna al microcontrollore le variabili salvate al suo interno e inizializza le suddette variabili con i valori appropriati.

    • Variabili direttamente modificate:
      • currentPosition;
      • timestampCount;
      • lastTimestampPosition.

  • ####void compressInformation(byte * _compressedValue, int * _array) torna su

    Metodo che trasforma le informazioni a 8byte del timestamp e le comprime in 6byte.

    • Parametri:
      • _compressedValue(modificato all'interno del metodo): puntatore ad un array di byte nel quale verranno inseriti i valori compressi del timestamp;
      • _array: array di interi nel quale sono presenti le informazioni non compresse del timestamp.

  • ####void writeEEPROM(unsigned int,byte) torna su

    Metodo che scrive in memoria EEPROM un byte.

    • Parametri:
      • unsigned int: intero che specifica l'indirizzo di memoria;
      • byte: byte da salvare in memoria.

  • ####byte readEEPROM(unsigned int) torna su

    Metodo che ritorna un byte letto dalla memoria EEPROM

    • Parametri:
      • unsigned int: indirizzo da cui leggere.

  • ####byte * getMemory(int _from,int _to) torna su

    Metodo che ritorna un array di byte letti in memoria. Se _from è maggiore di _to significa che c'è stato un reset della memoria, quindi verrà ritornata la memoria da [_from,MAXMEMORY] a [0,_to].

    • Parametri:
      • int _from: intero che identifica la posizione in memoria da cui iniziare a leggere;
      • int _to: intero che identifica il punto in cui bisogna fermare la lettura.

  • ####int incrementCounters() torna su

    Metodo che ritorna la posizione in cui si può iniziare a scrivere un nuovo timestamp e incrementa i contatori. Se si ha raggiunto il limite massimo di timestamp salvabili nella memoria il contatore (currentPosition) viene riportato a zero.

    • Metodi usati:
      • updateCounter();
    • Variabili direttamente modificate:
      • currentPosition;
      • timestampCount.

  • ####byte decToBcd(byte _val) torna su

    Metodo che converte un valore da decimale in esadecimale

  • ####byte bcdToDec(byte _val) torna su

    Metodo che converte un valore da esadecimale in decimale

  • ####int getInfo(int _position, int _type) torna su

    Metodo che torna un l'informazione {giorno, mese, anno, ore, minuti, secondi, contatore} di un timestamp in una determinata posizione logica nella memoria EEPROM.

    • Parametri:
      • int _position: intero che rappresenta l'indirizzo della memoria che deve essere letto;
      • int _type: intero che rappresenta il tipo di informazione che si intende recuperare
    • Metodi usati:
      • readEEPROM();

  • ####int getInfo(byte*_byteArray, int _type) torna su

    Metodo che ritorna l'informazione {giorno, mese, anno, ore, minuti, secondi, contatore} desiderata di un timestamp passato come array.

    • Parametri:
      • byte* _byteArray: puntatore all'array di byte del timestamp di cui si intende conoscere l'informazione;
      • int _type: intero che rappresenta il tipo di informazione che si intende recuperare
    • Metodi usati:
      • readEEPROM():

  • ####void updateCounter(int, int, int)
    torna su

    Metodo che modifica il valore di un contatore all'interno della memoria EEPROM del microcontrollore

    • Parametri:
      • int: intero rappresentante il vecchio valore della variabile;
      • int: intero rappresentante il nuovo valore da salvare in memoria;
      • int: intero rappresentate il tipo di contatore che si intende modificare.
    • Varie:
      • Questo metodo è ottimizzato per fare meno scritture in memoria possibili: il secondo byte utilizzato per rappresentare l'intero che identifica il contatore viene aggiornato in memoria una volta ogni 256.

MasterComunicationHandler - MCH

torna su

Componente software dedicato alla comunicazione I2C con la scheda Master attraverso un protocollo di istruzioni che prevedono prima la ricezione di un byte con il quale viene deciso il tipo di azione da effettuare e il caricamento in RAM delle varie variabili da inviare e poi su richiesta della scheda Master, i valori precedentemente richiesti vengono inviati. Ogni allocazione di memoria nello HEAP viene liberato al momento opportuno.

Questo componente software utilizza i metodi pubblici di MemoryHandler

MCH Attributi

Pubblici:

Privati:

private:
    byte requestType;
    AbstractAction* action;
    unsigned int buffer;
    unsigned int MAXRAM;

torna su

MCH Descrizione degli attributi

Pubblici:

Privati:

  • byte requestType -> byte che identifica il tipo di azione che deve essere preparata da MasterComunicationHandler, di default è settata a 255 che identifica la mancanza di azioni da effettuare. Questo valore è stato scelto appositamente poiché se ci sono problemi di comunicazione I2C spesso vengono inviati bit a 1, così nel caso di un problema di comunicazione non verrà preparata alcun tipo di azione;
  • AbstractAction* action -> puntatore alla classe astratta che permette di creare un oggetto di tipo Action utilizzato per le comunicazioni con la scheda Master;
  • unsigned int buffer -> intero utilizzato per sapere a che punto la comunicazione a blocchi con il master è arrivata;
  • unsigned int MAXRAM -> itero che rappresenta la massima capacità di RAM dedicata dalla scheda slave per l'invio di un blocco di byte alla scheda Master.

torna su

MCH Metodi

Pubblici:

public:
    MasterComunicationHandlerClass();
    void selectAction(byte _actionType);
    void prepareAction();
    void executeAction();

Privati:

private:
    void sendBytes(byte* _bytes,int _howMany);
    void sendInteger(int _integer);

torna su

MCH Descrizione dei metodi

Pubblici

  • ####MasterComunicationHandlerClass() torna su

    Costruttore della classe

    • Variabili direttamente modificate:
      • action;
      • requestType;
      • buffer;
      • MAXRAM.

  • ####void selectAction(byte _actionType) torna su

    Metodo che imposta il tipo di azione che deve essere programmata

    • Parametri:
      • byte _actionType: byte che rappresenta il tipo di azione che deve essere programmata.

  • ####void prepareAction() torna su

    Metodo che controlla il valore di requestType e crea l'oggetto Action adeguato, così caricando in memoria le informazioni necessarie per rispondere alla richiesta effettuata dal Master. Prima di creare una nuova Action si assicura di eliminare quella precedente.

    • Metodi usati:
      • MemoryHandler.newTimestamp();
      • MemoryHandler.memoryUsed();
      • MemoryHandler.getNewTimestamp();
      • MemoryHandler.getMemoryUsed();
      • MemoryHandler.eraseMemory();
      • sendBytes(byte *_bytes, int _howMany);
      • sendInteger(int _integer);
    • Variabili direttamente modificate:
      • action.

  • ####void executeAction() torna su

    Metodo che esegue il corpo dell'azione preparata in precedenza

Privati:

  • ####void sendBytes(byte* _bytes,int _howMany) torna su

    Metodo che invia tramite protocollo I2C un array di byte.

    • Parametri:
      • byte* _bytes: byte da inviare tramite protocollo I2C;
      • int _howMany: intero che rappresenta il numero di byte che si desidera inviare.

  • ####void sendInteger(int _integer) torna su

    Metodo che invia tramite protocollo I2C un intero.

    • Parametri:
      • int _integer: intero da inviare tramite protocollo I2C.

torna su

email marco.grego[at]hotmail.it

Home

Ottimizzazione Memoria

Test Antirimbalzo

Documentazione Libreria Master

Documentazione Scheda Slave

Clone this wiki locally