Escrevendo na flash em tempo de execução

Olá pessoal,

Alguém sabe como escrever na flash do ATmega328 em tempo de execução? Eu consigo gravar durante o carregamento do programa usando PROGMEM, depois acesso normalmente usando o pgm_read_byte. Mas como eu altero essa memória gravada em tempo de execução?

digamos assim...

PROGMEM prog_char dados[3] = { 'a', 'b' ,'c' };

void setup(){
Serial.begin(9600);
Serial.write("valores antigos = ");
Serial.write(pgm_read_byte(dados + 0));
Serial.write(pgm_read_byte(dados + 1));
Serial.write(pgm_read_byte(dados + 2));
}

void loop(){
// como mudar valor dados[0] para 'd'?
// como mudar valor dados[1] para 'e'?
// como mudar valor dados[2] para 'f'?
Serial.write("valores novos = ");
Serial.write(pgm_read_byte_near(dados + 0));
Serial.write(pgm_read_byte_near(dados + 1));
Serial.write(pgm_read_byte_near(dados + 2));

while(1);
}

Valeu!!!

Exibições: 5959

▶ Responder esta

Respostas a este tópico

Permalink Responder até Milton Vilela em 16 junho 2012 at 0:59

Olá Marcelo,

Eu precisei utilizar parte da memória flash e esbarrei nesse problema, então, testei a biblioteca disponível em

http://arduiniana.org/libraries/flash/  que não disponibiliza uma função para alterar o conteúdo das variáveis na memória.

Imagino que virá uma solução pela frente! rs

No meu caso, decidi armazenar as variáveis no cartão SD.

Abç

Permalink Responder até Pedroso em 16 junho 2012 at 8:34

Olá Marcelo e Milton, 

O Colega Marcos Daniel, fez um tutorial sobre memória EEPROM (muito bom, alias), mas...

Quais são as vantagens e desvantagens de gravar informações na memória flash X EEPROM?

Caberia um tutorial sobre flash tb. (para nós que estamos começando)?

Valeu!

 

Permalink Responder até Marcelo Rodrigues em 16 junho 2012 at 11:07

Milton,

Valeu pela dica, mas eu preciso escrever mesmo, não basta ler. Nesse aspecto, usar PROGMEM vai beleza. Os testes que fiz com o cartão SD decepcionaram no quesito velocidade. Mas vou fuçar mais e ver até que velocidade posso conseguir. Talvez a biblioteca SdFat que estou usando precise de algum ajuste.

Ricardo,

A EEPROM é muito limitada. Usando a flash eu teria uma capacidade de armazenamento muito maior.

A ideia do tutorial é mesmo boa. Podemos fazer sim um tutorial sobre tipos de memória.

Bom, vou verificar se consigo escrever na flash incluindo Assembly no meu código, e verificar melhor porque a velocidade do cartão não está legal.

Valeu!!!

Permalink Responder até Milton Vilela em 16 junho 2012 at 13:49

Marcelo,

Você tem um fragmento do código que você utilizou no teste com o cartão SD e quais tipos de variáveis necessita armazenar? Seria tipo array?

Abç

 

Permalink Responder até Milton Vilela em 16 junho 2012 at 14:26

complementando...

Se desejar gastar apenas dois dólares + impostos, poderá utilizar 32Kb de EEPROM montando o circuito: http://www.emartee.com/Attachment.php?name=41950.pdf

CI disponível para venda:

http://www.sparkfun.com/products/525

ou esquema direto:

http://lusorobotica.com/index.php/topic,461.msg2738.html

ou comprando montado nos links:

http://www.dfrobot.com/wiki/index.php?title=EEPROM_Data_Storage_Mod...)

http://www.emartee.com/product/41950/Arduino-EEPROM-Shield-With-256...

 

Seria bom se o Laboratório de Garagem tivesse o CI disponível para venda!

 

Até +

Permalink Responder até Marcelo Rodrigues em 19 junho 2012 at 20:20

Galera,

Encontrei (eu não conhecia) uma maneira de ler o cartão SD em blocos. Ao invés de se ler byte a byte, você lê um bloco da memória inteiro e armazena em um array. Ainda não alcancei a velocidade que eu preciso, mas já ficou beeeeem mais rápido. Vejam abaixo como usar (trecho referente ao cartão):

#define BUFFSIZE 512 //Define o tamanho do bloco a ser lido. Cuidado com o tamanho da RAM!

//Definicoes para leitura do cartao SD
#include <SdFat.h>
const int chipSelect = 10; //Para o Arduino UNO
SdFat sd;
SdFile arquivo;

byte buff[BUFFSIZE]; //Onde armazenamos o bloco lido

void setup()
{

//Inicializa SdFat ou imprime erro
if (!sd.init(SPI_FULL_SPEED, chipSelect)) sd.initErrorHalt();

// Abre arquivo para leitura
if (!arquivo.open("meuarquivo.txt", O_READ)) {
sd.errorHalt("opening meuarquivo.txt for read failed");
}


}

void loop()
{


arquivo.read((char*)buff, BUFFSIZE); //Carrega o bloco inteiro no array de uma vez

}

Mais ou menos por aí...

Eu estou trabalhando com sinal de video com o Arduino, por isso a necessidade de velocidade.

Nesse esquema, estou lendo a cerca de 150KBytes por seg, o que ainda não está bom para vídeo, mas para muitas aplicações deve servir.

Vou pesquisar mais o uso da Flash do uC. Vamos ver...

Abraços!!

Permalink Responder até Cleiton Bueno de Oliveira em 6 julho 2013 at 19:51

Marcelo conseguiu escrever na flash usando PROGMEM?

Estou no mesmo dilema, consigo ler e tudo mais porém passar o dados apenas no programa mas não em tempo de execução, queria muito utilizar a Flash do Arduino caso contrario terei que salvar no uSD do EthernetShield.

Permalink Responder até Marcelo Rodrigues em 8 julho 2013 at 15:10

Cleiton,

Não consegui. Deve ter um jeito, mas não achei nada ainda.

Se conseguir alguma coisa, avisa a galera aqui. Ok?

Valeu!

Permalink Responder até Samuel Ramirez em 9 julho 2013 at 16:24

Olá Marcelo,

Em essência, para gravar numa memoria Flash de um microcontrolador especifico (incluindo os AVR, ATMEGA, etc) o código que efetua a gravação precisa rodar num área diferente daquela que precisa ser gravada, esse é um dos principais complicadores,  uma das alternativas para resolver isso é rodando o programa de gravação na RAM, e assim que muitos dos bootloaders funcionam. Outra das alternativas que os fabricantes tem usado é dividir a Flash em blocos e então definem áreas de Flash-Boot, Flash-data, Flash-Program.

Nos links abaixo a Atmel explica com realizar essa tarefa. No ultimo dos links você poderá fazer download da biblioteca para gravar na Flash em tempo de execução.

Espero que isso ajude a resolver sua necessidade.

Samuel

AVR109: SELF PROGRAMMING

http://www.atmel.com/Images/doc1644.pdf

AVR 106: C FUNCTIONS FOR READING AND WRITING FLASH MEMORY

Application note:

http://www.atmel.com/images/doc2575.pdf

Biblioteca:

www.atmel.com/Images/AVR106.zip

Permalink Responder até Milton Vilela em 9 julho 2013 at 22:07

Olá Samuel

É possível utilizar essa biblioteca AVR106 no Arduino?

Até +

MIlton

Permalink Responder até Samuel Ramirez em 9 julho 2013 at 23:38

Olá Milton,

A biblioteca que acompanha o documento AV106 foi feita no IAR que é uma `tool suite` completa para desenvolvimento de aplicações porem não é compatível com o Arduino. Já que a biblioteca foi feita em C, é possível usar como referencia para criar uma biblioteca para rodar no Arduino mas isso precisa do trabalho de migração. Outras das possibilidades é criar um objeto em binario IAR que consiga ser integrado no Arduino.

As funções prontas nessa biblioteca são:

- ReadFlashByte() 
- ReadFlashPage() 
- WriteFlashByte()
- WriteFlashPage() 
- RecoverFlash()

Samuel

 

 

Permalink Responder até Milton Vilela em 10 julho 2013 at 3:13

Olá Samuel,

Agradeço pelas explicações que são muito úteis.

Até +

Milton

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço