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... ?!??
Tags:
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í!!
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por