Fantasmas no código: quanto a teoria falha.

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:

http://youtu.be/Fy3xTyjD0Ns

Exibições: 628

▶ Responder esta

Respostas a este tópico

Permalink Responder até Alexandre em 20 março 2015 at 9:02

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("__________________________");
}

Permalink Responder até imhugo em 20 março 2015 at 9:30

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);
}

Permalink Responder até Alexandre em 20 março 2015 at 10:22

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...

Permalink Responder até imhugo em 20 março 2015 at 11:10

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

Permalink Responder até Alexandre em 20 março 2015 at 13:57

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

Permalink Responder até Pedro Ferreira em 20 março 2015 at 14:21

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...

Permalink Responder até Carlos kwiek em 20 março 2015 at 9:51

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.

Permalink Responder até Pedro Ferreira em 20 março 2015 at 10:17

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("__________________________");
}

Permalink Responder até Alexandre em 20 março 2015 at 10:38

Resolveu aqui tb, mas não explica o problema ainda... pq ele entra em loop qdo a=255?

Permalink Responder até Pedro Ferreira em 20 março 2015 at 11:11

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);};
}

Permalink Responder até Pedro Ferreira em 20 março 2015 at 11:29

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("__________________________");
}

Permalink Responder até Wiechert em 20 março 2015 at 22:59

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.

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço