porque Strins de uma função não usada consume memória RAM ?

Olá pessoal, uma coisa que fiquei batendo muita cabeça sem entender , e ainda não entendo completamente...

Perguntando diretamente:

porque Strins de uma função não usada consume memória RAM ? Não era pra consumir só na flash ?

Uma explicação do contexto:

Estava utilizando um Shield GSM, e uma biblioteca para opera-lo. Os exemplos rolavam bacana, mas quando o projeto foi ficando maior... muita coisa estranha aconteceu...

Ou ele resetava, ou o que eu colocava na serial(println()) não aparecia direito, e outros bugs..

um fato que cheguei foi que , que um trecho de código que nem era executado, quando eu comentava o programa ficava bacana, estável...

Não entendia, o código nem se quer era executado, mas se estivesse descomentado bugava tudo..

Era isso:

if(cmd.length() == 8){
Serial.println("DB: CALL TO:");
call.Call(phone);  // < ---- ESSA LINHA AQUI >>>
}

Mas nem se quer ele estava sendo executada.  Ou seja NÃO estava caindo dentro do IF, se eu

comentasse só a linha indicada, funcionava normal.

Depois retirei outra função (checkCallStatus) que tambem NÂO estava sendo usada, e mais memoria foi liberada segundo testes com a LIB: http://arduino.cc/playground/Code/AvailableMemory

O outro método era:

void checkCallStatus(){

byte cs = call.CallStatusWithAuth("00000000", 0, 0);

// Report Status
if(cs != lastCallStatus){
if(cs == CALL_NONE) Serial.println("CallStatus:CALL_NONE");
if(cs == CALL_INCOM_VOICE) Serial.println("CallStatus:CALL_INCOM_VOICE");
if(cs == CALL_ACTIVE_VOICE) Serial.println("CallStatus:CALL_ACTIVE_VOICE");
if(cs == CALL_OUTCOM_VOICE) Serial.println("CallStatus:CALL_OUTCOM_VOICE");
if(cs == CALL_INCOM_VOICE_AUTH) Serial.println("CallStatus:CALL_INCOM_VOICE_AUTH");
if(cs == CALL_INCOM_VOICE_NOT_AUTH) Serial.println("CallStatus:CALL_INCOM_VOICE_NOT_AUTH");
if(cs == CALL_INCOM_DATA_AUTH) Serial.println("CallStatus:CALL_INCOM_DATA_AUTH");
if(cs == CALL_INCOM_DATA_NOT_AUTH) Serial.println("CallStatus:CALL_INCOM_DATA_NOT_AUTH");
if(cs == CALL_ACTIVE_DATA) Serial.println("CallStatus:CALL_ACTIVE_DATA");
if(cs == CALL_OTHERS) Serial.println("CallStatus:CALL_OTHERS");
if(cs == CALL_NO_RESPONSE) Serial.println("CallStatus:CALL_NO_RESPONSE");
if(cs == CALL_COMM_LINE_BUSY) Serial.println("CallStatus:CALL_COMM_LINE_BUSY");
if(cs == CALL_LAST_ITEM) Serial.println("CallStatus:CALL_LAST_ITEM");
}

// Verifica se a ligacao foi atendida.
if(cs == CALL_ACTIVE_VOICE && lastCallStatus != CALL_ACTIVE_VOICE){
handleCallActive();
}

lastCallStatus = cs;

}

 

Queria entender isso... ?!??

Exibições: 831

Responder esta

Respostas a este tópico

Primeiramente quando vc chama uma string mesmo dentro de uma função vc aloca um endereço da memoria para utilização da mesma. 

Por isso em C existe a alocação de memoria dinâmica usando malloc() e free() com ponteiros

e Memoria Flash e Memoria Ram são as mesmas coisas creio eu.

Explicação mais detalhada da alocação de memoria:

Quando vc compila um programa, ele analisa todas as variaveis setadas e calcula a quantidade de memoria a ser alocada para execução do mesmo (isso inclui funções pois faz parte do codigo fonte)

Na chama da função vc apenas utiliza o espaço de memoria alocado na inicialização do mesmo.

 Já no caso de Alocação dinâmica com malloc() vc pede ao sisop alocar uma certa quantidade de memoria p utilização na hora que vc for usar, e ao terminar de usa-lá vc libera usando free(), assim vc so aloca o quanto for usar exatamente e libera quando nao precisar mais, isso só é possível com ponteiros (variaveis que apontam para endereços de memoria)

bom se vc quiser se aprofundar mais no assunto faça uma rápida pesquisa no google sobre ponteiros em C e as funçoes malloc() e free()

No mais, Um forte abraço.

Entendi, eu imaginava que a alocação de memória era dinâmica por padrão, que só que quando o método fosse usado é que a memória fosse alocada...

Mas entendi o fato.

Muito obrigado pela explicação.

Exatamente o que o João falou, até o tipo de veriavel influencia na quantidade de memoria, se declarar um um long, onde só precise de um int, estará reservando espaço além do que precisa, para dispositivos limitados, no arduino procuro usar sempre byte para declarar as portas, mesmo me projetos pequenos, pelas boas praticas mesmo.

Alguém sabe  alguma solução, alguma ideia, sugestão que crie uma alocação dinâmica para escrever uma string ?

ex:

Aloca para escrever (malloc)

escreve ( Serial.println("o texto que consome a memória de x caracteres"); )

libera a memória (  free();  )


Obrigado

acho que para isso você deve usar as funções do PROGMEM, 
http://www.arduino.cc/en/Reference/PROGMEM

Você vai consumir a mesma quantidade de memória, mas será da flash e não da RAM.

Tem razão muito boa solução vou estudar um método e posto aqui 

Muito Obrigado

Já estou testando ela, fiz uma função mas não ficou satisfatória!

Encontrei outra solução estou testando, quando obter um bom sucesso posto aqui! 

Everton Luis

Uma solução  10!! 

Testei e verifiquei todo o uso da memória, sem problema,  não houve uso da memória nos meus teste

Resolveu meu problema, pois tenho um projeto grande com alto uso de memória do Arduino.

Envio o código:

#include <avr/pgmspace.h>


void setup() {
Serial.begin(9600);
}


void loop() {
int sensorValue = analogRead(A0);
Serial.println(sensorValue);
delay(1);

showString(PSTR ("Melhor Solucao , nao ha uso de memoria. "));
showString(PSTR("ex: apos vai pular linha \r \n"));
showString(PSTR("espero que seja util - Everton Luis D. T. "));
}


void showString (PGM_P s) {
char c;
while ((c = pgm_read_byte(s++)) != 0)
Serial.print(c);
}

Se for útil para alguém, posta aí!!

Apos um estudo da documentação, encontrei uma outra solução implementada na Ide1.0 do arduino:

A versão 1.0 da IDE Arduino introduziu o F () sintaxe para armazenamento de strings em memória flash em vez de RAM. por exemplo

Serial.println(F("Essa seqüência serão armazenados na memória flash - Everton Luis"));

Recomendo esta, já nativa da ide!

Até Mais

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço