Gostaria de saber se alguem sabe se e possivel o arduino ler algum programa e executar pelo Modulo Micro SD.

Exibições: 297

Responder esta

Respostas a este tópico

Bom dia, 

Eu acho que não é possível. 

Existe uma limitação do hardware para endereçamento de código no ATmega 328. 

Se não está tendo espaço para seu código, procure um outro Arduino com maior espaço. 

Qual seria a sua demanda? 

Nao queria mudar de arduino, pois estou com espaço reduzido e utilizando um ENC28j60

Olá.

   Nunca tinha ouvido falar na possibilidade, especialmente por nunca ter precisado de algo assim. 

   Dei um google agora e achei algumas discussões que parecem promissoras:
https://forum.arduino.cc/index.php?topic=610352.15

   Existe alguma coisa funcional para FAT16, que limita em 2Gb o tamanho do cartão.

   Mas de qualquer forma, diga mais sobre o projeto. A intenção é entender para ajudar. As vezes vc está tendo um problema que tem uma solução mais simples, por outro processo.

   Tecnicamente possível é, teria que criar um bootloader que em vez de buscar na serial buscaria um arquivo de nome especifico no SD, mas... Será que é o caminho ? 

Entao amigo, estou tentando rodar o programa Blynk para ligar 4 reles utilizando o ENC28j60. Porem, quando eu boto pra rodar, ele ate liga 1 rele, mas quando eu tento ligar mais de 1, ele simplesmente para de funcionar.

O programa que estou utilizando :

#include <UIPEthernet.h> //INCLUSÃO DE BIBLIOTECA
#include <BlynkSimpleUIPEthernet.h> //INCLUSÃO DE BIBLIOTECA

char auth[] = "aqui vai o token"; //AUTH TOKEN (FORNECIDO PELO PROJETO NO BLYNK E POR E-MAIL)

const int pinoRele1 = 3;
const int pinoRele2 = 4;
const int pinoRele3 = 5;
const int pinoRele4 = 6;
void setup(){
pinMode(pinoRele1, OUTPUT);//DEFINE O PINO COMO SAÍDA
pinMode(pinoRele2, OUTPUT);
pinMode(pinoRele3, OUTPUT);
pinMode(pinoRele4, OUTPUT);

digitalWrite(pinoRele1, HIGH); //MÓDULO RELÉ INICIA DESLIGADO
digitalWrite(pinoRele2, HIGH);
digitalWrite(pinoRele3, HIGH);
digitalWrite(pinoRele4, HIGH);

Blynk.begin(auth); //INICIALIZA A COMUNICAÇÃO BLYNK
}
void loop(){
Blynk.run(); //INICIALIZA O BLYNK
}

Boa tarde Eduardo, 

No forum do Arduino, não vi nada de concreto que possa ser utilizado. 

A arquitetura do ATmega328 não permite endereçamento além da memória Flash interna.

Como poderia ser o endereçamento do código em um SD card? Acho impossível. 

https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-P...

"In order to maximize performance and parallelism, the AVR uses a Harvard architecture – with separate
memories and buses for program and data. Instructions in the program memory are executed with a single level pipelining.

While one instruction is being executed, the next instruction is pre-fetched from the program memory.
This concept enables instructions to be executed in every clock cycle. The program memory is In-System
Reprogrammable Flash memory." 

Imaginei outra coisa, imaginei como que ele colocar um autoexec.bin no cartão que seria lido e rodado, dentro do tamanho da memória. Um bootloader leria o arquivo para a flash toda e executaria. Pode até ser uma boa... Para outros casos, como a atualização remota. O programa principal salva esse arquivo e dá boot, que providencia a troca de programação.

"ler algum programa e executar" me deu essa ideia e não a de fazer como que uma continuidade da memoria de programa em cartão SD. Isso certamente seria impossível.

Mas de qq forma nada disso resolve o caso dele... Que pelo visto não é de tamanho de codigo, vamos ter que descobrir..

olá Samuel.

      É quase certo que está ocorrendo um "crash" entre o "Stack" e o "Heap" (áreas na memória RAM do seu Arduino UNO). Ou seja, não  parece ser um problema da memória de código (a Flash). Vou esclarecer:

      Você relatou que está usando o Shield "ENC28J60", com Lib "UIPEthernet",  além da plataforma do "Blynk" para Arduino.

      Veja:  se a Lib "UIPEthernet"  não for usada adequadamente,  ela consumirá uma grande quantidade de memória RAM, e isto pode estar acontecendo mesmo com o uso do "Blynk", pois esta Lib requer todo o cuidado para o problema não ocorrer.

      Como demonstração do problema, veja um tópico aqui mesmo no LDG, onde ajudei a resolver tal problema, usando adequadamente a Lib "UIPEthernet". O link original começa aqui:  "problema ENC28J60 [RESOLVIDO]"

e aconselho vc ler todas as páginas, para entender melhor a questão (que é um pouco técnica).

      Para aprender mais sobre Memórias do Arduino, veja a página oficial a respeito:  "Memórias do Arduino"

      E há um artigo da Adafruit  que explica de forma simples como ocorre o "crash" entre o "Stack" e o "Heap". É este aqui:   "crash Stack x Heap"   ,  e vc pode ver o arquivo PDF correspondente aqui:  "Memories-of-an-Arduino - Adafruit.pdf"

      O seu Sistema deve estar no limite para o "crash" ocorrer, e provavelmente durante a execução, uma alocação dinâmica a mais ou a chamada de uma função com parâmetros de tamanho significativo, deve estar causando o "crash".

      O problema pode ser resolvido mesmo no seu caso, mas a "Camada de Abstração" do Blynk, dificulta isso um pouco mais.

      Então no seu caso, vc precisa avaliar se vale a pena tentar contornar o problema do "crash", ou então usar um Arduino com mais memória RAM e assim impedir o "crash" de ocorrer.

      Abrçs,

      Elcids

eu mencionei Arduino UNO no post anterior, mas acredito que seja de fato um "Nano" que vc esteja usando, pois vc disse que tem problemas de espaço físico. Então provavelmente vc deve estar usando um Shield ENC28J60 daqueles que encaixam direto no Arduino Nano.

      Mas as considerações que coloquei, aplicam-se tanto ao UNO quanto ao Nano.

.

Amigo, quando eu passo o programa pro meu arduino nano, ele da isso:

O sketch usa 24114 bytes (78%) de espaço de armazenamento para programas. O máximo são 30720 bytes.
Variáveis globais usam 1330 bytes (64%) de memória dinâmica, deixando 718 bytes para variáveis locais. O máximo são 2048 bytes.

Que, teoricamente, nao deveria dar o "crash"

ou estou errado ??

olá novamente Samuel.

      Sim, vc está "errado" e ao mesmo tempo não está. Veja:

      Os 1330 bytes usados da RAM, são a "parte fixa" da RAM usada pelo seu código, ou seja, isto é o mínimo que seu código irá usar. Mas há uma parte do seu código, que irá alocar mais RAM durante a execução do mesmo. Geralmente esta alocação a mais, ocorre nas Bibliotecas, que "criam" variáveis (Buffers, Vetores, tabelas, etc) conforme o código vai sendo executado. E nem sempre esse uso a mais de RAM é otimizado, e geralmente as Bibliotecas não se preocupam com otimização do uso. Esta área alocada a mais, ocorre tanto no Heap quanto no Stack, mas no Stack ela é sempre liberada logo após a função que alocou a área, terminar sua execução. Mas no Heap essa área nem sempre é liberada (embora simples, não vou explicar o motivo aqui para não estender muito), e acabam ficando aqueles "buracos" que vc pode ver no documento PDF da Adafruit que eu postei anteriormente. Quando um "buraco" se forma, a área de RAM ocupada por ele não é mais usada, e assim a memória RAM é desperdiçada. E é um tanto complexo estimar se um código vai causar isso, mas é quase certo que sim, devido à não otimização de uso de RAM que mencionei. Isto ocorre também no seu Computador e no seu Smartphone, porém lá tem memória "sobrando", e isso não constitui um problema (além do fato de que a "Memória Virtual" desses Sistemas, resolve isso).

      Mas no seu Arduino Nano, especificamente no seu código,  está sobrando 718 bytes para a alocação (no Heap e no Stack) durante a execução do código. Essa quantidade é suficiente para a maioria dos códigos para Arduino, mas esse não é o caso do seu código, que usa a Lib "UIPEthernet" para o ENC28J60, e a própria Lib do "Blynk". Ambas Libs, alocam RAM durante a execução do código. A "UIPEthernet" eu já analisei anteriormente naquele post que informei,  e posso garantir que ela aloca memória suficiente para colocar em eminência um "crash" Heap<==>Stack,  ainda mais no seu caso, que sobram 718 bytes. Então um "crash" poderá ocorrer em algum momento. Provavelmente esse momento é quando vc acessa as demais "variáveis" criadas pelo "Blynk". Quando o "crash" ocorre, a CPU do Arduino perde o controle, e passa a executar um código qualquer, podendo inclusive "resetar" automaticamente (reiniciar a execução do código como se tivesse sido ligado naquele momento).

      Há um teste interessante que vc pode fazer:  naquele tópico que mencionei, foi usada uma versão da "UIPEthernet" que foi "ajustada" para usar menos RAM. Então você pode usar essa Lib e assim verificar se a economia é suficiente para seu caso, mesmo sem otimizar o restante do seu código.

      É esta Lib aqui:  "UIPEthernet-2.0.7.rar - ajustada"

      Ao fazer o teste com a Lib acima, tenha certeza de que não deixou a sua Lib original na pasta de LIBs do Arduino, do contrário irá apresentar erros na compilação. E atenção: apesar da versão "2.0.7", esta Lib foi modificada e não é igual a mesma versão para download no sites por aí na Internet.

      Eu posso depois postar algumas otimizações a mais que podem ser feitas no seu código. Mas antes acho interessante vc testar com a Lib que postei aqui.

      E Samuel, tente ler o artigo da Adfruit que postei o PDF, pois vai certamente ajudar vc a entender melhor o problema.

      Abrçs,

      Elcids

Entendi agora.

Realmente quando eu aperto o botao no meu celular, se for apenas 1 ou 2 botoes, ele ainda funciona, mas quando tento acionar os outros 2, ele utiliza mais ram da o "crash" desconectando do celular.

Vou tentar por essa outra biblioteca que vc me mandou.

Espero que funcione.

Amigo, acabei de tentar por a biblioteca e ela ta dando erro.

ja removi a antiga, com o passo a passo daqui do LDG e da erro  na hora de adcionar a biblioteca.

RSS

© 2021   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço