Declarar const flash stm32

[Marcelo Jo]

  Pessoal, estou usando gcc aqui e gostaria de saber como posso declarar uma constante na flash em um endereço específico.

  Sei que daria pra fazer via __attribute__((section("section"), used)) mas gostaria de saber uma forma mais simples, sem ter q mexer no linker.

  Preciso de apenas algumas const e talvez achei q fosse possível de se fazer algo meio direto. No gcc do compilador pic a gente pode usar no __attribute__ um campo address que não existe no gcc arm (pelo q eu andei lendo).

  Valeu

  Marcelo

[Paulo Henrique]

Marcelo,

Boa tarde.

Uso o Keil com o STM32.

E no Keil faço assim: 

no *.h

extern unsigned char u8Buff[10] __attribute__((at(0x08004000))); // Flash

 

no *.c

unsigned char u8Buff[10] = 

{

    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A

};

No meu caso altero essa variável da Flash que guarda uma série de configurações do equipamento.

u8Buff é um exemplo, você pode definir como uma struct, union, etc....

Espero ter ajudado.

Atenciosamente, 
Paulo Henrique da Silva Melo

Engenheiro Eletrônico

Especialista em Sistemas Embarcados

Email: phsil...@yahoo.com.br  ;; phsilv...@gmail.com

Linkedin: http://www.linkedin.com/in/phsmelo 

--
Você recebeu essa mensagem porque está inscrito no grupo "sis_embarcados" dos Grupos do Google.
Para cancelar inscrição nesse grupo e parar de receber e-mails dele, envie um e-mail para sis_embarcado...@googlegroups.com.
Para postar nesse grupo, envie um e-mail para sis_emb...@googlegroups.com.
Acesse esse grupo em http://groups.google.com/group/sis_embarcados.
Para mais opções, acesse https://groups.google.com/d/optout.

[Marcelo Jo]

  Valeu Paulo,

  Pois é... queria algo assim..estou usando o openstm32 que usa arm-none-eabi- e por lá não tem o atributo "at" que vc usou.

  Estou lendo aqui os docs pra ver se acho algo! =D

  Se alguma alma caridosa me poupar esse trabalho, agradeço! hehehe

  Marcelo

[Rafael Dias]

Olha só isso: 

http://mcuoneclipse.com/2012/11/01/defining-variables-at-absolute-addresses-with-gcc/

Lembro que no C18 era bem semelhante (ou até igual, não lembro bem...)

[Marcelo Jo]

  Eu vi esse link, mas na verdade eles sempre acabam usando seções.

  Aliás, o problema é q eu tenho que declarar uma constante e gostaria q ela estivesse dentro do .text. Mas se eu crio outra seção, dá erro de linker,entende?

  Digamos que tenho uma flash de 64k e quero colocar uma constante tipo, versão do firmware no endereço 0x10000, mas se eu tentar criar outra seção, como falei vai dar erro de linker já q as duas seções se sobrepõem.

  Valeu

[ala...@bonseletrons.com.br]

Você tem que criar um ponteiro usando recursos comuns do C...
Tem exemplos muito bons nas libs, posso ajudar MAS preciso saber o que você vai fazer com com esse endereço.

É um periférico mapeado em memoria?

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[ala...@bonseletrons.com.br]

Desculpem mas isso é muito enrolado e não é assim que a lib da ST faz...
É muito mais simples, basta um #define

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[Cleiton Bueno]

Bom você já tem uma maneira de fazer, isso já e um bom sinal *rs.

Eu li e lembrei de algo que havia feito a muito tempo Marcelo, e até fiz um exemplo besta para demonstrar.

Não sei se enquadra no que você precisa e no meu caso foi para um binario para Linux Embedded.

Usando dois arquivos fixed.h e fixed.c:

Exemplo tosco:

//fixed.h

#ifndef __THIS_FIXED__

#define __THIS_FIXED__

typedef struct {

  char a;

}Br;

extern Br brfix;

#endif

//fixed.c

#include <stdio.h>

#include "fixed.h"

int main(void)

{

  Br brfix = { .a='A' };

  

  printf("Init App...\n");

  printf("Br->a = %c\n",brfix.a);

  return 0;

}

# Compilando

$ gcc fixed.c -I. -o fixed

$ gcc -Wl,--defsym,brfix=0x2000 -I. fixed.c -o fixed2

# Tamanho

$ ls -l fixed fixed2

-rwxr-xr-x 1 cleiton cleiton 8571 Ago 11 19:55 fixed

-rwxr-xr-x 1 cleiton cleiton 8601 Ago 11 19:55 fixed2

# Executando

$ ./fixed

Init App...

Br->a = A

$ ./fixed2

Init App...

Br->a = A

Vendo os simbolos do binario:

 $ nm fixed

0000000000601048 B __bss_start

0000000000601048 b completed.6718

0000000000601038 D __data_start

0000000000601038 W data_start

00000000004004c0 t deregister_tm_clones

0000000000400530 t __do_global_dtors_aux

0000000000600e18 t __do_global_dtors_aux_fini_array_entry

0000000000601040 D __dso_handle

0000000000600e28 d _DYNAMIC

0000000000601048 D _edata

0000000000601050 B _end

0000000000400654 T _fini

0000000000400550 t frame_dummy

0000000000600e10 t __frame_dummy_init_array_entry

0000000000400780 r __FRAME_END__

0000000000601000 d _GLOBAL_OFFSET_TABLE_

                 w __gmon_start__

0000000000400418 T _init

0000000000600e18 t __init_array_end

0000000000600e10 t __init_array_start

0000000000400660 R _IO_stdin_used

                 w _ITM_deregisterTMCloneTable

                 w _ITM_registerTMCloneTable

0000000000600e20 d __JCR_END__

0000000000600e20 d __JCR_LIST__

                 w _Jv_RegisterClasses

0000000000400650 T __libc_csu_fini

00000000004005c0 T __libc_csu_init

                 U __libc_start_main@@GLIBC_2.2.5

000000000040057c T main

                 U printf@@GLIBC_2.2.5

                 U puts@@GLIBC_2.2.5

00000000004004f0 t register_tm_clones

0000000000400490 T _start

0000000000601048 D __TMC_END__

$ nm fixed2

0000000000002000 A brfix

0000000000601048 B __bss_start

0000000000601048 b completed.6718

0000000000601038 D __data_start

0000000000601038 W data_start

00000000004004c0 t deregister_tm_clones

0000000000400530 t __do_global_dtors_aux

0000000000600e18 t __do_global_dtors_aux_fini_array_entry

0000000000601040 D __dso_handle

0000000000600e28 d _DYNAMIC

0000000000601048 D _edata

0000000000601050 B _end

0000000000400654 T _fini

0000000000400550 t frame_dummy

0000000000600e10 t __frame_dummy_init_array_entry

0000000000400780 r __FRAME_END__

0000000000601000 d _GLOBAL_OFFSET_TABLE_

                 w __gmon_start__

0000000000400418 T _init

0000000000600e18 t __init_array_end

0000000000600e10 t __init_array_start

0000000000400660 R _IO_stdin_used

                 w _ITM_deregisterTMCloneTable

                 w _ITM_registerTMCloneTable

0000000000600e20 d __JCR_END__

0000000000600e20 d __JCR_LIST__

                 w _Jv_RegisterClasses

0000000000400650 T __libc_csu_fini

00000000004005c0 T __libc_csu_init

                 U __libc_start_main@@GLIBC_2.2.5

000000000040057c T main

                 U printf@@GLIBC_2.2.5

                 U puts@@GLIBC_2.2.5

00000000004004f0 t register_tm_clones

0000000000400490 T _start

0000000000601048 D __TMC_END__

# Praticamente idêntico, porém no nm fixed2 temos na primeira linha:

0000000000002000 A brfix

A flag 'A' do nm significa que é um valor global absoluto e não sera alterado por nenhum linker, já usei! 

E esta com o endereço que foi passado no parâmetro -Wl,--defsym,variavel=endereço

Espero que ajude, desculpe se não tem haver com o que precisa, mas é uma outra forma ;)

Infos:

http://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_3.html

http://www.math.utah.edu/docs/info/ld_2.html

[Cleiton Bueno]

PS: Esqueci de comentar, deve passar o extern para a variável que for passar por linha na compilação. Outra coisa, como é um arm você esta passando -fPIC na compilação?

Em terça-feira, 11 de agosto de 2015 15:03:58 UTC-3, Marcelo Jo escreveu:

[Alain Mouette]

A maneira mais simples seria algo como
#define PORTA_X ((volatile uint32_t)0x4002000)

No GCC um endereço pode ser considerado como um ponteiro comum, só precisa lembrar do "volatile" para não otimizar

Alain Mouette
=== Projetos especiais: <http://lnkd.in/dEu8cNq> ===

[Marcelo Jo]

  Valeu aí Cleiton e Alain.. vou primeiro no método preguicoso e mais curto do Alain e se não rolar tento o teu Cleiton!

  Valeu, vcs são demais!

  Marcelo

[Cleiton Bueno]

Legal Marcelo, manda bala.

@Alain, uma duvida no caso de usar:

#define PORTA_X ((volatile uint32_t)0x4002000)

Como 0x4002000 é um endereço eu não deveria usar como:

#define PORTA_X ((volatile uint32_t *)0x4002000)

Ou até mesmo como:

#define PORTA_X (*((volatile uint32_t *) 0x4002000))

Me corrija se estou cometendo um equivoco pensando assim.

No GCC um endereço pode ser considerado como um ponteiro comum, só precisa lembrar do "volatile" para não otimizar 

Em terça-feira, 11 de agosto de 2015 15:03:58 UTC-3, Marcelo Jo escreveu:

[Marcelo Jo]

  Pessoal, só pra deixar claro.. não sei se expliquei direito o meu "probrema".

  Imaginem q eu quero usar uma área da flash pra compartilhar dados com meu bootloader... no meu caso a versão da imagem daria pra ser visto do bootloader a fim de dizer qual é a versão do firmware que está programado.

  Logo, preciso declarar uma const como o Paulo já disse

  const int fw_version __attribute__((at(0x08010000))); // Flash

  SÓ QUE o at não existe no arm-none-eabi.

  Valeu

--

[ala...@bonseletrons.com.br]

Explica melhor o que você vai fazer...
1) acessar io
2) colocar simplesmente uma constantr na flash
3) ter um endereço fixo, por exemplo nos bytes finais da flash que você preenche com dados durante a gravação da flash e consulta depois
4) a imaginação é o limite

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[ala...@bonseletrons.com.br]

Você está certo, mas aí vai depender do que vai fazer com esse ponteiro.
(Por isso eu perguntei...)

Enviado através do AquaMail para Android
http://www.aqua-mail.com

--

[Marcelo Jo]

Itens 2 e 3! =D Preciso colocar algo na flash num enderećo que eu quero! Dois exemplos clássicos: 1) colocar dummy bytes em enderećos específicos no programa pra que possam ser verificados pelo bootloader e 2) Colocar a versão de firmware na imagem num enderećo conhecido pelo bootloader pra que este possa fazer uso de upgrades/downgrades.

  Valeu!

[ala...@bonseletrons.com.br]

Então é 3, porqur 2 pode ser em qualquer lugar...

Acho que então deve funcionar assim:

Int32_t a = *((int32_t*)0x0000fff0);

Lembrando que o compilador reduz isso ao minimo necessário e não precisa se preocupar com detalhes

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[Ronaldo Tomazeli Duarte]

O posicionamento destes valores em endereços fixos na Flash tem que ser feito pelo linker, Os atributos do compilador, por exemplo, at, são facilidades para instruir o linker sem ter que mexer muito nas configurações de seções. Se estes atributos não existem, não vejo muito como escapar de mexer nas seções geradas pelo linker.

Para o bootloader ler o valor gravado, aí é só mapear o ponteiro para o endereço conhecido, como o Alain citou.

[Cleiton Bueno]

É acho que já tem varias coisas para testar ;)

Marcelo uma duvida:

"
Imaginem q eu quero usar uma área da flash pra compartilhar dados com meu bootloader... no meu caso a versão da imagem daria pra ser visto do bootloader a fim de dizer qual é a versão do firmware que está programado.
"

Não sei se imagine errado, mas no seu bootloader você tem um section-start e na sua aplicação outra certo? Depois de um tempo ou como seja definido após alimentar a placa o bootloader "salta" para a aplicação. Você esta querendo que depois de saltar para a section definida pelo linker para aplicação ela acesse endereços setado na sessão do bootloader?

Digo isso porque o range endereço sera diferente, logo se a aplicação começa em 0x2000 este é o 0x00 para a aplicação, como ira acessar a outra sessão da flash que o bootloader esta usando por exemplo?

Foi uma curiosidade isso.

Att,
Cleiton Bueno

Blog | Linkedin | Portal Embarcados

[Marcelo Jo]

  @Alain, sim, 3 então.. entendi errado o 2, pois como disse quero definir uma const na flash (2) mas num endereço específico (3). =D

  No teu exemplo vc tá definindo um ponteiro pra um endereço específico, mas o conteúdo desse endereço nõa está sendo setado em nenhum lugar.

  Trocando em miúdos o q eu preciso era o o Paulo citou SÓ que o compilador aqui não suporta o atributo at.

  Seria isso:

const int fw_version __attribute__((at(0x08010000))) = 0xAABBCCDD;

  @Cleiton, na verdade é o contrário... estando no bootloader eu poderia ver o qual imagem está na flash e com isso passar essas informações ao usuário quando solicitado, sacou a idéia?

 @Ronaldo, pois então, mesmo no linker eu poderia fazer, mas só sei fazer usando sections. Acontece que preciso de alguns valores espalhados na flash e não queria ficar retalhando a flash em várias seções. Digo isso pq se vc tentar criar uma seção dentro de outra, isso gera erro de linker, o que é óbvio. E no meu caso é +- isso q eu precisaria... ter seções definidas em alguns endereços dentro da seção principal.

  Valeu gente

  Marcelo

  

  

[Marcelo Jo]

  Segue o link da página da keil por exemplo:

http://www.keil.com/support/docs/2829.htm

http://www.keil.com/support/man/docs/armccref/armccref_BABGJHDC.htm

[ala...@bonseletrons.com.br]

Existe uma solução simples para colocar os dados em endereço fixo no bootloader: se mexer no módulo do startup, já existe um vetor de endereços se IRQs. É só acrescentar imediatamente depois...

Lembrei de uma outra solução (era usada no PC em DOS: coloca um string de identificação seguido dos dados. Basta varrer a memoria para encontrar

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[ala...@bonseletrons.com.br]

Também é possível alterar o arquivo de configuração do linker e criar uma section especial em um endereço fixo. Precisa reduzir o maximo da text que já existe.
Eu já fiz isso uma vez mas faz tempo demais. Essa é a solução mais difícil e mais perfeita, mas vai ter que ralar muito em cima do manual do linker :(

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[Andre Alexandre]

Cara... desculpe a ignorância, mas pq não usa a EEPROM p/ isso?

Abraço

[Marcelo Jo]

  E aí André, blz?

  Tem configurações que precisam estar na flash, tipo o número de série. O pessoal aqui precisa que qdo vc reprograme o mcu, o numéro de série seja também apagado. Se ficar numa memória externa o número de série sempre vai estar lá.

  Esse número de série deve ser compartilhada entre o bootloader e a aplicação.

  Tem outros motivos também, q não é de ordem técnica, mas ajuda na produção! =D

  Marcelo

[Andre Alexandre]

A principio eu sugeri a EEPROM interna do proprio micro.

Mas entendi ... vai alterar os binarios antes da gravação. A um tempo atrás fiz isso com um programinha em C#.

[Marcelo Jo]

  Meu mcu não tem EEPROM interno! =(

  Mas valeu aí pela ajuda!

[Victor Augusto Furtado Leite]

Marcelo, também acho que não tem jeito de fazer isso sem mexer no linker. Como o pessoal já falou, alguns compiladores facilitam isso com extensões, mas ai seu código acaba não ficando portável (o que, pessoalmente, considero ruim)...

Acho que algo assim no seu script do linker resolveria:

SECTIONS {

/* ... suas outras seções ... */

.shared:

{

__shared_start = .;

*(.shared_data)

__shared_end = .;

} > flash

/* ... suas outras seções ... */

}

E a região de memória de saída definida assim (que já deve ter algo parecido):

MEMORY {

flash: ORIGIN = 0x00000000, LENGTH = 0x10000

}

E ai no seu código você declara suas variáveis usando __attribute__((section("shared_data").

O seu toolchain é baseado no GCC né?! Dá uma olhada no manual do ld, tem muita coisa legal que dá pra fazer...

[]s

Victor

[Marcelo Jo]

  Valeu Victor!

  Então, isso eu já fiz pq eu preciso de uma área separada de qquer forma.

  Mas note que nessa solução vc não tem garantia que a variável esteja num endereço específico. Sim, ela estará na seção, mas pode ser em qquer lugar! =D

  Eu preciso de algumas constantes definidas exatamente num endereço desejado! =D

  Valeu

[Victor Augusto Furtado Leite]

Então eu sugiro algumas coisas:

1 - Pegando como exemplo a seção que eu passei, as variáveis __shared_start e __shared_end são acessíveis de dentro do seu código (declarando como extern char *__shared_start, por exemplo), você poderia guardar uma estrutura com seus dados nessa seção e então fazer o bootloader passar o ponteiro de __shared_start como parâmetro para sua aplicação, e pronto, você usando apenas uma estrutura __shared_start vai apontar para ela; (eu acho essa opção mais versátil)

ou

2 - Use algo assim:

__shared_area = <endereço que você quiser>

.shared: AT(__shared_area)

na declaração da sua seção, e ai coloca ela no início ou no final da sua flash;

ou

3 - Se você sabe exatamente o tamanho do que você vai colocar nessas variáveis, faz algo como o item 2 mas coloca sua seção no início da flash e aí dentro da seção faz algo assim:

.shared: AT(0x0) {

    *(.shared_var1)

    . += 0x8;

    *(.shared_var2)

    . += 0x32;

    *(.shared_var3)

    /* ... */

} > flash

e ai cada variável você declara com uma dessas seções de entrada. A primeira variável vai estar no endereço 0x0000000 e deve ter um tamanho de 8 bytes a segunda vai estar em 0x00000008 e deve ter 32b e por ai vai... funciona! Mas isso sim vai dar um baita trabalho e a manutenção depois não vai ser legal...

[]s

[Marcelo Jo]

  Valeu Victor!

  Olha só.. eu vou ter outros valores que precisam estar na imagem da aplicação, exemplo é o ID do firmware que tem q bater com o ID do hardware. Isso pra evitar de fazer um upgrade de um firmware errado (de um outro módulo, por exemplo).

  O q eu acho de seções é q eu tenoh q usar uma seção ou no começo ou no final da flash pra não ficar retalhando a aplicação principal! =(

  Abraços

[Andre Alexandre]

Que tal escrever uma aplicacao externa que edite o arquivo .hex?

Nele é facil escrever o valor que quiser nesse endereço.

[Marcelo Jo]

  O problema seria se o enderećo desejado já estivesse ocupado, já q não tenho como reservar ele (exceto com sections).

  O problema danado... com certeza existem workarounds, mas mesmo assim, acho estranho não conseguir setar no gcc um enderećo fixo na flash... "Até" o compilador da microchip faz isso! =D

  Valeu

[Alain Mouette]

Nem precisa muita coisa...
É só gerar a linha com os dados no endereço e acrescentar!

Alain Mouette
=== Projetos especiais: <http://lnkd.in/dEu8cNq> ===

[Alain Mouette]

Consegue mas tem que editar o arquivo de linkagem...

Alain Mouette
=== Projetos especiais: <http://lnkd.in/dEu8cNq> ===

[Marcelo Jo]

  Eu estava tentando criar um símbolo no linker e usar declarar extern no meu programa.

  No caso eu coloquei algo assim no linker:

  . = 0x08010000;

  test_variavel = 0xAABBCCDD;

  No main.c eu teria algo assim:

  extern int test_variavel;

  Ele compila, linka e tudo o mais, SÓ QUE, a maldita variável não está definida no enderećo 0x08010000 hehehhe Alguém aí sabe se daria pra fazer algo assim?

  Outra forma q eu estava pensando em fazer era usando um código em assembly. Lembro que na velha época do 8051 eu fazia algo tipo .equ ou .dcd... algo assim... Vcs que programam em assembly em ARM, sabem como poderia fazer? É como criar uma tabela num enderećo específico da flash! =D

  Obrigado a todos!

  Marcelo

[Euripedes Rocha Filho]

Eu fiz isso algum tempo atrás mas foi usando o linker conforme dito por aqui e como apontado aqui
http://mcuoneclipse.com/2012/11/01/defining-variables-at-absolute-addresses-with-gcc/

Outro modo
http://stackoverflow.com/questions/4067811/how-to-place-a-variable-at-a-given-absolute-address-in-memory-with-gcc

Já utilizei as duas formas no xc32 que é o gcc estragado pela Microchip e a primeira no arm-gcc. Faz um tempo que fiz isso pela última vez.

[Marcelo Jo]

  Valeu Eurípedes.. mas de novo, usando section. O problema é q na nossa imagem a gente coloca alguns dummy bytes espalhados no programa pra ser checado pra validar q o firmware é o firmware correto. Claro, além disso calculamos o CRC da imagem!

  O segundo exemplo é apenas um ponteiro pra flash. Com ele vc não consegue definir um valor na flash durante a compilação!

  Valeu

[Victor Augusto Furtado Leite]

Marcelo você não consegue definir um valor pra uma variável pelo linker, você só consegue definir o endereço da variável.

Nesse caso você está dizendo que sua variável estará no endereço 0xAABBCCDD.

[]s

[Euripedes Rocha Filho]

Sim eu sei que usa o linker, não sei se será possível fazer sem.
Vocês podem inverter a estratégia e gravar a verificação com os dummy bytes usando trechos do código e verificar com um hash mais forte, SHA256 por exemplo, salvo em uma seção da flash. A validação usando o hash já é suficiente imho. Sem usar o linker eu acredito que não será possível até porque é ele o responsável por posicionar as coisas na memória não?

Só pra constar a segunda opção só usei pra leitura do que estava na flash, não lembro de ter gravado e acho que nem dá. Mas eram 7 da manhã então deem um desconto.

[ala...@bonseletrons.com.br]

Eu ainda acho que o mais simples seria:
1) colocar logo após os irq vectors
2) colocar um string de ID e fazer uma busca.
Já usei ambos...

Enviado através do AquaMail para Android
http://www.aqua-mail.com

[Alain Mouette]

Só agora que eu pude verificar, isso que ele explica é assim mesmo.

SÓ QUE... para ficar na flash, tem que reduzir o tamanho do "text" no número de bytes desejado e colocar a outra section ali.
Eu já fiz isso para reservar uma área no fim da RAM, usava para recuperar de reset e WDT

Mas ainda acho que os outros 2 métodos que eu indiquei são mais simples.

Alain Mouette
=== Projetos especiais: <http://lnkd.in/dEu8cNq> ===