Informazioni sulla memoria dei sistemi

Vai all indice del manuale di programmazione

I nostri sistemi programmabili sono realizzati utilizzando microcontrollori ARM Cortex, una famiglia di processori RISC (Reduced Instruction Set Computing) a 32 e 64 bit progettati da Arm Holdings ampiamente utilizzati in molti dispositivi di uso comune e specialmente in dispositivi elettronici a basso consumo energetico.

L’utilizzo di microcontrollori si è reso necessario in quanto integrano in un unico chip CPU, memoria e periferiche, riducendo le dimensioni del sistema ed aumentandone l’affidabilità. Essendo i progettati per essere completi su un singolo chip la loro memoria integrata è generalmente di dimensioni limitate, ma sufficiente per le applicazioni embedded.Nei sistemi sono generalmente presenti più tipi di memoria, alcune memorie sono interne al microcontrollore altre sono esterne vediamo nel dettaglio:

Memoria FLASH: Memoria non volatile utilizzata per programma utente.
Memoria RAM: Memoria volatile per i dati.
Memoria FRAM: Memoria ferromagnetica per i dati ritentivi

Approfondimenti

In questo topic informazioni su passaggio da sistema basato su ARM7 a sistema basato su CortexM7.

Sistema	Definizione memoria
Sistemi ARM standard	Memoria programma (48Kb): A disposizione per programma LogicLab (Opzione per estensione a 96Kb) Memoria dati (12Kb): 8Kb a disposizione per allocazione variabili LogicLab, 4Kb per data block DB100 (Da 0 a 4095 memoria non riportata nel report di LogicLab) Memoria retain (3Kb): 1 Kb per variabili RETAIN LogicLab, 2Kb per storage data block DB100 (Da 2048 a 4095 memoria non riportata nel report di LogicLab)
Cortex M7 compact Standard	Memoria programma (65Kb): A disposizione per programma LogicLab (Opzione per estensione a 262Kb) Memoria dati (12Kb): 8Kb a disposizione per allocazione variabili LogicLab, 4Kb per data block DB100 (Da 0 a 4095 memoria non riportata nel report di LogicLab) (Opzione per estensione a 20Kb) Memoria retain (3Kb): 1 Kb per variabili RETAIN LogicLab, 2Kb per storage data block DB100 (Da 2048 a 4095 questa memoria non è riportata nel report di LogicLab)
Cortex M7 compact Extended	Memoria programma (131Kb): A disposizione per programma LogicLab (Opzione per estensione a 262Kb) Memoria dati (12Kb): 8Kb a disposizione per allocazione variabili LogicLab, 4Kb per data block DB100 (Da 0 a 4095 memoria non riportata nel report di LogicLab) (Opzione per estensione a 20Kb) Memoria retain (3Kb): 1 Kb per variabili RETAIN LogicLab, 2Kb per storage data block DB100 (Da 2048 a 4095 questa memoria non è riportata nel report di LogicLab)
Cortex M7	Memoria programma (131Kb): A disposizione per programma LogicLab (Opzione per estensione a 262Kb) Memoria dati (12Kb): 8Kb a disposizione per allocazione variabili LogicLab, 4Kb per data block DB100 (Da 0 a 4095 memoria non riportata nel report di LogicLab) (Opzione per estensione a 20Kb) Memoria retain (3Kb): 1 Kb per variabili RETAIN LogicLab, 2Kb per storage data block DB100 (Da 2048 a 4095 memoria non riportata nel report di LogicLab)
Cortex M7 extended	Memoria programma (262Kb): A disposizione per programma LogicLab Memoria dati (20Kb): 16Kb a disposizione per allocazione variabili LogicLab, 4Kb per data block DB100 (Da 0 a 4095 memoria non riportata nel report di LogicLab) Memoria retain (3Kb): 1 Kb per variabili RETAIN LogicLab, 2Kb per storage data block DB100 (Da 2048 a 4095 memoria non riportata nel report di LogicLab)

Report di LogicLab

Al termine della compilazione nella finestra di Ouput di LogicLab è riportato il report dell’impiego della memoria.

Nota: per la visualizzazione della dimensione reale della memoria del sistema occorre avere LogicLab connesso al sistema.

Code: Memoria programma. Used:Utilizzata, Free:Libera, Total:Totale. Si intende la memoria FLASH del sistema. In questa memoria LogicLab trasferisce il programma compilato.
Data: Memoria dati, Used:Utilizzata, Free:Libera, Total:Totale. Si intende la memoria RAM del sistema. E’ suddivisa in due aree, un’area in cui LogicLab alloca tutte le variabili automatiche definite nel programma. Un’area per l’allocazione del datablock DB100
Retain: Memoria retain, Used:Utilizzata, Free:Libera, Total:Totale, Si intende la memoria FRAM ritentiva. E’ suddivisa in due aree, un’area in cui LogicLab alloca tutte le variabili automatiche definite con attributo RETAIN. Un’area per l’allocazione delle variabili ritentive del datablock DB100.

Screenshot finestra output di LogicLab con report memoria

Ottimizzazione memoria RAM

I sistemi basati su microcontrollori ARM o Cortex purtroppo dispongono di una ridotta area di memoria RAM dati, quindi nella realizzazione di programmi complessi occorre prestare attenzione all’impegno di memoria. Vediamo alcune linee guida:

Strutture dati

I sistemi base ARM/Cortex allocano le variabili a 2 bytes ad indirizzi divisibili per 2 e le variabili a 4 bytes ad indirizzi divisibili per 4. Quindi nella definizione delle strutture dati evitare di mischiare tipi di variabili, nell’esempio di programma seguente si può vedere come a parità di dati in struttura (10 bytes) in un caso si occupano 16 bytes di memoria mentre nell’altro ne bastano 12.

MYSTRUCT1: STRUCT
    MyBOOL1 : BOOL; (* 3 more bytes are added after *)
    MyREAL1 : REAL;
    MyBYTE1 : BYTE; (* 3 more bytes are added after *)
    MyREAL2 : REAL;
END_STRUCT;

MYSTRUCT2: STRUCT
    MyBOOL1 : BOOL;
    MyBYTE1 : BYTE; (* 2 more bytes are added after *)
    MyREAL1 : REAL;
    MyREAL2 : REAL;
END_STRUCT;

PROGRAM DataStructures
VAR
    SSize : ARRAY[0..1] OF UDINT;
    MStruct1 : MYSTRUCT1;
    MStruct2 : MYSTRUCT2;
END_VAR

    SSize[0]:=SIZEOF(MStruct1); //Size is 16 bytes
    SSize[1]:=SIZEOF(MStruct2); //Size is 12 bytes

// [End of file]

Stringhe caratteri

Se si usano variabili stringa per la gestione di messaggi come nel caso del programma sottoriportato, utilizzare una sola variabile SString per tutti i messaggi. Eventualmente definire una unica variabile stringa globale da utilizzare in tutti i programs (Attenzione tutti i programs che la utilizzano devono essere eseguiti nella stessa task).

PROGRAM Strings
VAR
    i : UDINT; (* Auxiliary variable *)
    Write : BOOL; (* Write command *)
    Fp : eFILEP; (* File pointer *)
    DData : ARRAY[0..2] OF REAL; (* Dividend value *)
    SString1 : STRING[ 32 ]; (* String output *)
    SString2 : STRING[ 32 ]; (* String output *)
    SString3 : STRING[ 32 ]; (* String output *)
END_VAR

    IF (Write) THEN
        Write:=FALSE; //Write command
        Fp:=SysFfopen(ADR('C:/Logs.txt'), ADR('a')); //File pointer

        DData[0]:=SysGetRandom(TRUE)*1000.0; //Dividend value
        DData[1]:=SysGetRandom(TRUE)*1000.0; //Divisor value
        DData[2]:=DData[0]/DData[1]; //Result value

        i:=SysVsnprintf(ADR(SString1), SIZEOF(SString1), ADR('Dividend:%9.3f$r$n'), REAL_TYPE, ADR(DData[0]));
        i:=Sysfwrite(ADR(SString1), TO_INT(LEN(SString1)), 1, Fp);

        i:=SysVsnprintf(ADR(SString2), SIZEOF(SString2), ADR('Divisor:%9.3f$r$n'), REAL_TYPE, ADR(DData[1]));
        i:=Sysfwrite(ADR(SString2), TO_INT(LEN(SString2)), 1, Fp);

        i:=SysVsnprintf(ADR(SString3), SIZEOF(SString3), ADR('Result:%9.3f$r$n'), REAL_TYPE, ADR(DData[2]));
        i:=Sysfwrite(ADR(SString3), TO_INT(LEN(SString3)), 1, Fp);
        Fp:=Sysfclose(Fp);
    END_IF;

// [End of file]

Aree RETAIN e DB preallocate

Oltre alla memoria RAM a disposizione del compilatore esistono altre aree di memoria RAM preallocate che il compilatore non utilizza. Esempio l’area RETAIN, ed i data blocks preallocati come ad esempio il DB100. Nell’esempio sotto si vede come allocando le variabili in area RETAIN ed in DB100 si liberano 1536 bytes di memoria RAM. Naturalmente le due aree se RETAIN vanno inizializzate al primo loop di esecuzione.

VAR_GLOBAL
    DBArea AT %MX100.0 : ARRAY[0..1023] OF BYTE;
END_VAR

VAR_GLOBAL RETAIN
    RArea : ARRAY[0..511] OF BYTE;
END_VAR

PROGRAM UseRetainAndDB
VAR
    i : UDINT; (* Auxiliary variable *)
END_VAR


    IF (SysFirstLoop) THEN
        i:=Sysmemset(ADR(RArea), 16#00, SIZEOF(RArea));
        i:=Sysmemset(ADR(DBArea), 16#00, SIZEOF(DBArea));
    END_IF;

// [End of file]

Memoria allocabile e rilocabile

Oltre alla memoria RAM a disposizione del compilatore esistono ulteriori aree di memoria, memoria allocabile vedere funzione SysMAlloc, memoria rilocabile vedere funzione SysRMAlloc.

Sistema	Dimensione memoria
Sistemi ARM e CortexM7	Dimensione memoria allocabile 4096 bytes Dimensione memoria rilocabile 20Kb

Esempio di utilizzo

MALLOCSTRUCT: STRUCT
    MyVar1 : BOOL;
    MyVar2 : UINT;
    MyVar3 : REAL;
END_STRUCT;

PROGRAM RelocatableMemory
VAR
    MBuffer : @MALLOCSTRUCT;
    RMBuffer : @MALLOCSTRUCT;
END_VAR

    // Allocate the memory.

    IF (MBuffer = eNULL) THEN MBuffer:=SysMAlloc(512); RETURN; END_IF;
    IF (RMBuffer = eNULL) THEN SysRMAlloc(512, ADR(RMBuffer)); RETURN;  END_IF;

    // Use the memory buffers.

    @MBuffer.MyVar2:=@MBuffer.MyVar2+1;
    @MBuffer.MyVar3:=TO_REAL(@MBuffer.MyVar2)/100.0;

    @RMBuffer.MyVar2:=@RMBuffer.MyVar2+1;
    @RMBuffer.MyVar3:=TO_REAL(@RMBuffer.MyVar2)/100.0;

// [End of file]

Was this article helpful?

Yes No