Bom dia, pessoal.
Sabem quando agente comete um erro que é tão idiota que passa desapercebido?
Pois só assim pra um código simples como esse não funcionar. Ou existe alguma excessão à teoria, ou alguma coisa que ainda não aprendi.
O problema tá resolvido, consegui um jeito de funcionar, mas agora fica a dúvida: porquê esses códigos não funcionaram do jeito que seria esperado?
É um erro no código? Onde? Na lógica ou na sintaxe? Ou existe alguma excessão à teoria que eu não conhećo? Ou algo na teoria que ainda não aprendi?
Se alguém puder esclarescer ajudaria muito, quero entender o que saiu errado, porquê não encontrei uma explicaćão para os erros.
Segue o video:
Tags:
int t=50;
void setup()
{
Serial.begin(9600);
}
void loop()
{
byte a;
for(a=1; a<256; a++)
{
Serial.print("a = ");
Serial.println(a, BIN);
delay(t);
}
Serial.println("__________________________");
for(a=255; a>0; a=a-1)
{
Serial.print("a = ");
Serial.println(a, BIN);
delay(t);
}
Serial.println("__________________________");
}
eu testei aqui e consegui reproduzir o mesmo resultado e penso que o problema seja aqui:
for(a=1; a<256; a++)
observe o que ocorre se usar assim:
for(a=1; a<255; a++)
veja que dessa forma funciona.
Portanto, concluo que o problema com for(a=1; a<256; a++) está no a++, pois quando o último passo do laço ocorrer, "a" está com valor 255 e o comando a++ irá acrescentar 1, fazendo "a" assumir o valor 256, que não existe caso "a" seja byte (deveria ser de 0 até 255)
tanto é verdade que "a" assume valor 256 que, se vc usar o código abaixo, vc conseguirá comprovar isso (ao invés de usar byte, use long ou int para poder comprovar o valor assumido por "a" ao final do loop):
void setup() {
Serial.begin(9600);
}void loop() {
long a;
for (a = 1; a < 256; a++)
{
Serial.print("a = ");
Serial.println(a,BIN);
}Serial.println("________________");
Serial.println(a);
}
A hipótese é boa, mas acho q não se sustentou. Tentei usar um for (a = 1; a < 255; a++) e escrever na serial o resultado. Se ele estivesse incrementando até 255, teria impresso 11111111.
Além disso, depois q terminasse, não deveria imprimir a barra? Pois é, não imprimiu e voltou ao inicio do laćo for.
Testei tb a sugestão do Pedro Ferreira, que tb funcionou:
void loop() {
byte a,b;
for(a=0; a<255; a++ )
{
b=a+1;
Serial.print("b = ");
Serial.println(b, BIN);
delay(t);
}
Serial.println("____________");
for(a=255; a>=0; a-- )
{
Serial.print("a = ");
Serial.println(a, BIN);
delay(t);
}
Serial.println("____________");
}
Se fosse estouro de memória, esse código tb nao deveria funcionar...
vc não obteve o 255 porque vc usou o código do Pedro Ferreira, que manda ir até 254. Ali no código dele, não há estouro porque após o loop o último a++ faz "a" assumir valor 255, porém ele não manda imprimir esse valor 255
Mas veja o estouro de memória ocorrendo no seu código, que transcrevo resumidamente abaixo:
void setup() {
Serial.begin(9600);
}void loop() {
byte a;
for (a = 0; a < 256; a++)
{
Serial.print(a);
Serial.print(" = ");
Serial.println(a,BIN);
}Serial.println("________________");
Serial.println(a);
}
observe que não ocorre exibição da "minhoca" indicadora de final do loop, nem mesmo a exibição do "a" fora do laço. Pra mim, isso é um sinal claro que houve estouro da memória, pois "a" assumirá valor 256
Agora faça exatamente como eu sugeri: troque o byte por int ou long e veja que não há estouro. E comprove vc mesmo que "a" assume valor 256 ao final do laço
Vc tem razão. Estive conversando com o Pedro também, ao q parece o laćo for não executa o valor 256 no bloco de código, mas carrega a=256 como comparador, para saber que a contagem terminou. Mesmo não escrevendo o print do bloco de código, ele carrega um valor maior para comparar com o valor anterior, apenas para saber se a contagem terminou. Mas então estoura a pilha.
Fiz como você falou pra ver isso acontecer, olhe o resultado usando byte:
E usando int:
Agora sim, tá explicado, valeu! Resolvido :D
O problema não sei se se nota no arduino real, mas no simulador nota-se bem, ao escolher a variavel byte ou int a velocidade de processamento e muito diferente...
Só vou escrever aqui para seguir a discussão, e parabenizar o Alexandre pela maneira de expor o assunto e trazer isso aqui pára o forum, todos somos beneficiados desta forma.
Abraços.
Acho que assim resolve o problema...
int t=50;
void setup()
{
Serial.begin(9600);
}
void loop()
{
byte a,b;
for(a=0; a<255; a++ )
{
b=a+1;
Serial.print("a = ");
Serial.println(b, BIN);
delay(t);
}
Serial.println("__________________________");
for(a=255; a>0; a--)
{
Serial.print("a = ");
Serial.println(a, BIN);
delay(t);
}
Serial.println("__________________________");
}
Resolveu aqui tb, mas não explica o problema ainda... pq ele entra em loop qdo a=255?
O problema e a 3 condição, quando faz o a++ assume o valor 256 e reinicia...
No codigo do outro video acontece a mesma coisa, na terceira condição 128+128=256 reinicia... podemos voltar a contornar se não tentarmos resolver no ciclo for... e podemos trabalhar com byte...
byte a,b;
void setup()
{
}
void loop()
{
for(a=128; a>=1; a=a>>1) { Serial.println(a, BIN); delay(10);}
for (a=128; a>=1; a=a>>1) { b=128/a;Serial.println(b, BIN); delay(10);};
}
Ainda tem outra maneira de usar o primeiro codigo do Alexandre e funcionar... kkkk
int t=50;
void setup()
{
Serial.begin(9600);
}
void loop()
{
byte a;
for(a=0; a<255; a++)
{
Serial.print("a = ");
Serial.println(a+1, BIN);
delay(t);
}
Serial.println("__________________________");
for(a=255; a>0; a=a-1)
{
Serial.print("a = ");
Serial.println(a, BIN);
delay(t);
}
Serial.println("__________________________");
}
Olá,
É simples de explicar, a resposta está na capacidade de armazenamento do tipo de variável escolhido.
No arduino o tipo byte tem 8 bits, armazenando valores de 0 a 255, 2^8 = 256 posições possíveis, e o "0" conta.
Por isso um byte nunca ter o valor 256, ok?
No seu programa você escreveu:
byte a;
for(a=1; a<256; a++)
Declarando a variável "a" como sendo byte e o loop for iniciando em 1( a=1) e incrementando a em 1 a cada loop (a++) e o loop deve continuar enquanto a for menor que 256 (a<256).
Ocorre que "a" nunca chegará ao valor 256... pois um byte só vai até 255 em decimal, FF em hexadecimal e 11111111 em binário.
Quando "a" estiver em 255 as linhas:
Serial.print("a = ");
Serial.println(a, BIN);
Irão imprimir no monitor serial o valor:
a = 11111111
E então "a" será incrementado (a++ do loop for) assumindo o próximo valor possível para um byte com valor 255: 0.
Ou seja, estourou a variável... repetindo o loop infinitamente.
Já quando você declarou "a" como do tipo int que comporta valores entre -32,768 a 32,767 não haverá problemas quando estiver em 255 e for incrementado, assumindo o valor de 256, terminando o loop for e imprimindo a linha:
"__________________________"
Explicado agora?
Resumo da ópera, não existem fantasmas... nem exceções a teoria, nem a teoria falhando... apenas a teoria não compreendida ou mal executada.
Abraço.
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues. Ativado por