Arduino colaborativo/Tutorial Arduino - Lição 4

Tutorial Arduino

Arduino cresce e aprende a falar!

Ah, Arduino, eu me lembro quando você estava apenas engatinhando e piscando LEDs. Agora você está pronto para aprender a falar! Nesta lição vamos aprender como usar a biblioteca Serial para se comunicar a placa Arduino ao computador através da porta USB. Então vamos aprender a manipular números e dados.

Para esta lição que não vai usar o Shield, então simplesmente remova-o. O Shield não contém quaisquer programas ou dados, é apenas a nossa maneira de conectar os LEDs e resistores. Vamos usar o Shield novamente, mas por agora, podemos examinar os LEDs RX e TX na placa Arduino principal, que irá ajudá-lo com a depuração.

O que é um Biblioteca?

Bibliotecas são ótimos lugares, e ainda não ilegal nos Estados Unidos! Se você precisar de aprender a fazer alguma coisa, como dizem consertar uma motocicleta, você pode ir a sua biblioteca local e retirar um livro. Claro que você pode comprar o livro mas a biblioteca é agradável porque como um recurso que você pode obter o livro sempre que precisar, manter sua casa organizada.

Bibliotecas de software são muito semelhantes. Já estudamos o que é um procedimento, na lição 3: um procedimento é uma lista de coisas a fazer. Uma biblioteca é uma grande coleção de procedimentos, onde todos os procedimentos estão relacionados! Se você, por exemplo, quiser controlar um motor, você pode querer encontrar uma biblioteca de Controle Motor: uma coleção de procedimentos que já foram escritas para você que você pode usar sem ter que fazer o trabalho sujo de aprender as nuances de motores.

A biblioteca que usaremos é a Biblioteca Serial, que permite que o Arduino para envie dados de volta para o computador:

Biblioteca Serial

O que é Serial?

Serial pode soar como um alimento saboroso, mas na verdade é muito diferente. A palavra série significa "um após o outro." Por exemplo, um serial killer que não para com um assassinato, mas apunhala muitas pessoas, uma após a outra. Transferência de dados em série é quando a transferência de dados acontece um bit por vez, um após o outro.

Informação é passada para trás e para frente entre o computador e Arduino configurando um pino em nível alto ou baixo. Assim como usamos essa técnica para virar um LED ligado e desligado, podemos também enviar dados. Um lado define o pino e outro lê. É um pouco como o código Morse, onde você pode usar dits e dahs para enviar mensagens por telegrama. Neste caso, em vez de um cabo longo, são apenas alguns metros.

(Agora, as pessoas que são totalmente NERDs provavelmente ficarão com raiva neste momento, porque eu estou simplificando as coisas. Bem, adivinhem, isto é tutorial sobre Arduino, e não um tutorial OSI Arquitetura física de rede.)

Bits & Bytes

O mundo não é mais gerido por armas, ou energia, ou dinheiro. É administrada por pequenos uns e zeros, pequenos pedaços de dados. São apenas elétrons.

Agora é um bom momento para rever como os dados são medidos. Por exemplo, podemos medir o peso com a "onça" e "libras" (ou gramas e quilogramas) e distâncias com "polegadas", "pés", e "milhas" (ou centímetros, metros e quilômetros). Informação tem seu próprio sistema de medidas:

Um único bit é zero ou um um. Você pode agrupar pedaços juntos em 8 bits, que é 1 byte. 1024 bytes (8192 bits) é um Kilobyte (por vezes escrito KB). 1024 KB (1.048.576 bytes) é um Megabyte (MB) 1024 MB é de 1 Gigabyte (GB)

Uma coisa interessante a se notar é que enquanto 1000 gramas é um quilo, quase todos os sistemas de computador consideram 1024 bytes a ser um kilobyte. Isto é, um arquivo de 1.0 Kilobyte no seu computador é de 1024 bytes:

Propriedades

Teste rápido!

Se o disco rígido é de 200 Gigabytes, quantos bytes é isso? Use uma calculadora com muitos dígitos! Realce o texto abaixo para a resposta 200 GB * 1024 = 204.800 MB 204.800 MB * 1024 = 209715200 KB 209715200 KB * 1024 = 214748364800 bytes!

Fabricantes de disco rígido são muito subservientes, você vai perceber que eles definem como sendo GB 1000 MB e 1 MB = 1000 KB, etc. Dado este fato, quantos bytes você pode realmente armazenar em seu disco de 200GB? Realce o texto abaixo para a resposta 200 GB * 1000 = 200.000 MB 200.000 MB * 1000 = 200000000 KB

Quanto menos espaço de armazenamento você consegue graças à cara de marketing que surgiu com este truque? Realce o texto abaixo para a resposta Cerca de 4,6% a menos do que você esperaria Um amigo familiar?

Nós realmente já usamos um pouco da capacidade de comunicação Serial ... é assim que enviaremos desenhos para o Arduino! Quando você Compilar / Verificar, o que você estará realmente fazendo é transformando o sketch em dados binários (uns e zeros). Quando você carregá-lo para o Arduino, os bits são empurrados para fora um de cada vez através do cabo USB para o Arduino, onde eles são armazenados no chip principal.

Na próxima vez que você carregar um sketch, olhe atentamente para os dois LEDs perto do conector USB, eles vão piscar quando dados estiverem sendo transmitidos. Um pisca quando o Arduino está recebendo dados (RX) e um pisca quando o Arduino está transmitindo dados (TX).

Hora do nosso primeiro sketch

Suficiente conversado entre nós, é hora de começar a falar Arduino. Nosso primeiro sketch vai ser o programa hello world!. Quando ele iniciar, ele vai dizer "Hello world!"

Crie um novo sketch... e salve-o como HelloWorld

Janela

Dentro do novo sketch, copie e cole o seguinte cógico, então salve-o:

/*

* Hello World!
*
* This is the Hello World! for Arduino. 
* It shows how to send data to the computer
*/

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps
 
 Serial.println("Hello world!");  // prints hello with ending line break

}

void loop() // run over and over again {

                                 // do nothing!

}

OK, a primeira coisa a notar é que não há nada no procedimento loop! Mesmo se não temos nada nos procedimentos de configuração ou loop, o Arduino os obriga a estar lá. Dessa forma, ele sabe que você realmente quer dizer para não fazer nada, ao contrário de esquecer de incluí-los!

A primeira linha de código no procedimento de instalação é esta:

  Serial.begin(9600);           // set up Serial library at 9600 bps

Nós definitivamente vemos que existe uma coisa Serial acontecendo, e parece que há uma chamada de procedimento também. Esta é uma chamada de procedimento da biblioteca. A biblioteca é chamada de Serial e dentro da biblioteca há um procedimento chamado begin.

Se não há nenhum nome da biblioteca, isso significa que o procedimento está no conjunto 'default' de procedimentos que usamos. Por exemplo, delay () é tão comum que os projetistas do software Arduino não se incomodaram em colocá-lo em uma biblioteca.

Portanto, havendo um procedimento misterioso chamado começar, não é muito difícil descobrir o que ele poderia fazer. É o procedimento que recebe o material Serial pronto. Mas o que é o 9600? O comentário diz 9600 bps, e só assim você sabe bps significa bits por segundo (vamos nos referir a isso como a taxa de transmissão). Se você tiver conexão de banda larga, você pode lembrar de ter lido em algum lugar que ele tem, digamos 350 kbps taxa de download. Este é o quão rápido a conexão pode ler e escrever bits no fio. (Escusado será dizer que a sua conexão de banda larga pode transferir dados muito mais rápido que um Arduino!)

OK, então Serial.begin configura o Arduino com a taxa de transferência que queremos, neste caso 9600 bits por segundo.

Vamos passar para a próxima linha.

Serial.println ("Hello World!") / / Imprime hello com quebra de linha

Esta linha também usa a biblioteca Serial, desta vez ocorra a chamada de um procedimento chamado println, que é apenas uma abreviação de "linha de impressão". Note que a 6 ª letra em println é a letra L, não o número 1. Desta vez, a entrada é uma citação, a linha de texto gostaríamos de imprimir. Nós usamos dois "'s (entre aspas) para indicar o início e o fim de uma linha de texto.

Teste rápido!

Se o Arduino transfere dados a 9600 bits por segundo e que você está enviando 12 bytes de dados, quanto tempo leva para enviar mais esta informação? 12 bytes de dados é igual a 12 * 8 = 96 bits de dados. Se podemos transferir 9600 bits por segundo, então 96 bits leva 1/100th de um segundo!

Se o Arduino transfere dados a bits de 19.200 por segundo (19200) e você está enviando 12 bytes de dados, quanto tempo leva para enviar mais esta informação? Isso é duas vezes mais rápido como antes, por isso vai demorar metade do tempo, cerca de 1/200th de um segundo.

Bom, agora compile o sketch e envie-o para o seu Arduino .... E depois ... nada??

Parece que não há muita coisa acontecendo aqui. Um pouco decepcionante, já que me diverti muito com luzes coloridas piscando antes. O truque aqui é que enquanto você pode ver luzes piscando muito facilmente, ver dados serial requer um monitor, o qual como o seu monitor irá nos mostrar o que os dados estão sendo transferidos.

Sorte para nós, há um monitor serial embutido no software Arduino!

Hello World!

Eu não tenho certeza do que significa o ícone, mas de qualquer maneira se você clicar nesse botão, você irá substituir a área de notificação preto Programa com um monitor de série.

Então ... clique nele! Hello ... World?

O que acontece a seguir é, infelizmente, muito depende de qual tipo de Arduino você tem.

No caso muito comum de ter um Arduino Diecimila, o monitor de série resetará automaticamente o Arduino. O sketch será iniciado após alguns segundos.

Caso contrário, o Arduino não vai se reinicializar. De qualquer maneira, uma vez que você mudou para o monitor serial, pressione o botão reset. Se você tem um Arduino NG você vai ter que esperar 7 segundos para o sketch para começar.

Sketch 1

Voalá! Esse é o nosso sketch!

Se você sempre achar que está recebendo um monte de rabiscos em vez de texto adequado, certifique-se que você tem a taxa de transmissão correta selecionada no menu drop-down do Serial Monitor. Note que esta comunicação baud rate é indepedente do processo de upload, que é fixado em 19.200 bps.

Em seguida, tente pressionar o botão de reset algumas vezes para fazer mais Hello World! aparecerem. Se você tem um NG, isto pode ser um pouco chato, mas faça de qualquer maneira.

Sketch 2

Cada vez que você reiniciar o Arduino, ele executa o procedimento de configuração, e imprime Hello! novamente. Se você olhar atentamente para a Arduino, você também vai ver o pequeno LED TX piscar da mesma forma que imprime essa mensagem. Essa é a sua indicação de que os dados foram enviados.

Enviar o quê?

Quando você println que você está enviando os dados do Arduino para o computador. O botão Enviar (e a entrada de texto ao lado) são usados para enviar dados para o Arduino. Nós não vamos usá-lo nesta lição para não ser surpreendido que não faz nada quando você clicar nele! 10 PRINT HELLO 20 GOTO 10

Nosso próximo desenho será uma pequena modificação de um presente. Em vez de imprimir Hello World! apenas uma vez, nós gostaríamos que imprimí-lo mais e mais e mais uma vez.

Teste rápido!

Que simples modificação devemos executar para imprimir Hello World! mais e mais vezes? Basta mover a declaração Serial.println ("Hello World"); do procedimento de instalação para o procedimento de loop.

Realizar esta modificação e, em seguida, compilar e fazer o upload do novo sketch hiper-Hello!. Em seguida, iniciar o Monitor Serial. Você verá Hello World! rolar rapidamente!

Sketch 3

Teste rápido!

O que está acontecendo com o LED TX? É iluminado, não pisca. Tente agitar o Arduino em torno de um quarto escuro, o que você vê? Há poucas trilhas leves pontilhadas. O que está acontecendo aqui? Dica: Lembre-se a lição 2? Os dados estão sendo transmitidos tão rápido que não podemos ver o LED TX piscando ... é o envio de dados muitas vezes por segundo! Faça o Arduino se acalmar um pouco com a adição de um segundo de atraso para o sketch, para que ele só imprima Hello World! uma vez por segundo.

/*

* Hello World!
*
* This is the Hello World! for Arduino. 
* It shows how to send data to the computer
*/

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

}

void loop() // run over and over again {

 Serial.println("Hello world!");  // prints hello with ending line break
 delay(1000);

}

Agora você deve gastar algum tempo brincando com println e fazê-lo exibir uma mensagem de sua escolha! Que tal acrescentar mais algumas declarações println, a fim de tornar a mensagem maior? A matemática é difícil, vamos tentar a programação!

Brincamos de imprimir frases, mas acontece que também podemos imprimir números facilmente.

/*

* Math is fun!
*/

int a = 5; int b = 10; int c = 20;

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

 Serial.println("Here is some math: ");

 Serial.print("a = ");
 Serial.println(a);
 Serial.print("b = ");
 Serial.println(b);
 Serial.print("c = ");
 Serial.println(c);

 Serial.print("a + b = ");       // add
 Serial.println(a + b);

 Serial.print("a * c = ");       // multiply
 Serial.println(a * c);
 
 Serial.print("c / b = ");       // divide
 Serial.println(c / b);
 
 Serial.print("b - c = ");       // subtract
 Serial.println(b - c);

}

void loop() // we need this to be here even though its empty { }

Tente usar esse sketch no seu Arduino.

Sketch 4

Note que estamos usando dois procedimentos aqui, o println original e agora também de impressão. O procedimento de impressão é como println, só que não imprime um "retorno de carro" no final, iniciando uma nova linha. Você pode experimentar mudar o de impressão para println e olhar o monitor de saída serial para verificar isso por si mesmo.

Segue o que está acontecendo no Arduino com este sketch. Por exemplo, vamos olhar para esta linha:

Serial.println (a);

Nós vimos que, se você usar uma linha de texto citado como entrada para procedimento println, ele irá mostrar o texto. Neste caso, você pode ver que se você usar uma variável em println, ele vai olhar o que essa variável contém e imprimirá isso!

Acontece que o Arduino é inteligente o suficiente para também fazer matemática quando perguntou:

Serial.println (a + b);

Neste caso, o Arduino olha o que a entrada é para println e encontra cálculo verdadeiro. Ele percebe que “a” é (5) e que “b” é (10) e, em seguida, soma-os (+) e depois usa esse como o valor para enviar para println.

Note que, por enquanto, só podemos calcular usando inúmeros inteiros. Isso significa que ainda não podemos imprimir números como 3,14 ou 1,5.

Eu poderia seguir falando sobre operadores a todos os seus tópicos muito importantes, mas muitas pessoas já escreveram bons tutoriais sobre este tema. Então vou enviá-los e leiam por lá!

Um C++ tutorial Um tutorial sobre os operadores C A lista de todos os operadores matemáticos

Grupo pitagoreano

Triângulo Retângulo

Vamos fazer nossa primeira máquina de cálculo simples, para calcular a hipotenusa. Se você recordar do ensino medio se tem um triângulo retângulo, a hipotenusa h pode ser calculada a partir do comprimento dos dois lados c1 e c2 (que chamaremos de a & b) a2 + b 2 = h 2 h = √(a2 + b2) /*

* Math is fun!
*/

include "math.h"

int a = 3; int b = 4; int h;

void setup() {

 Serial.begin(9600);

 Serial.println("Lets calculate a hypoteneuse");

 Serial.print("a = ");
 Serial.println(a);

 Serial.print("b = ");
 Serial.println(b);
 
 h = sqrt( a*a + b*b );
 
 Serial.print("h = ");
 Serial.println(h);

}

void loop()

empty

{ }

A primeira coisa que é nova é esta linha logo no início do esboço:

include "math.h" // incluir o cabeçalho Math Library

Que basicamente diz: "Nós gostaríamos de usar os procedimentos matemáticos, que estão em um programa que nos obriga a incluir o arquivo math.h onde o procedimento sqrt permanece". Apenas ignore por enquanto, não é importante. A segunda coisa que é diferente aqui é que quando nós criamos a variável h nós não atribuimos a ele um valor.

int h; Acontece que isso é totalmente OK, isso significa apenas que não sabemos ainda o que h irá armazenar, porque que vamos calculá-lo mais tarde. Já que não é atribuído a ele um valor o inicio, o Arduino apenas cria a caixa, o material dentro é tudo aquilo que estava sobrou na memória.

valores padrão Se você não atribuir um valor a uma variável, pode ser qualquer valor. Certifique-se de não tentar utilizar a variável antes de atribuir um valor a ela! Mais tarde no esboço, vamos atribuir-lhe o valor.

  h = sqrt( a*a + b*b );

Nesta linhaelevamos a e b ao quadradp _e , em seguida, adicionamo-los juntos, então nós chamamos de procedimento sqrt () (que faz exatamente o que você possa pensar), para tirar a raiz quadrada. Então vamos atribuir isso à variável h.

Variável = Valor

Tudo o que era em h antes é perdido, substituído pelo novo valor. Você pode colocar em procedimentos e funções tudo que você quiser chamando um procedimento sobre o valor de retorno de outro procedimento.

Prova rápida Vamos dizer que você tem uma variável "foo", que contém um número. Você gostaria de encontrar a raiz quadrada da raiz quadrada deste número. Que linha de de código poderia imprimir este valor?

Serial.println( sqrt( sqrt(foo) );

Procure primeiramente a raiz quadrada de foo, depois tome a raiz quadrada deste último e, depois use esse valor como entrada para println

Agora é sua vez de criar uma calculadora.

Você vai criar uma calculadora da Lei de Ohm. A lei de Ohm diz que Voltagem = resistência * corrente. (Esta é uma lei muito útil que constitui a base da eletrônica, e vamos estudá-lo em profundidade mais tarde.) Começando com duas variáveis, i para o corrente e r para resistência, imprimir a quantidade de tensão que pode ser medido através do resistor.

Calculadora do tamanho da unidade (HD)

Vamos escrever um programa que vai fazer o cálculo do tamanho do disco rígido que fizemos antes. Vamos começar com o tamanho do disco rígido em GB, e imprimir em MB. Vamos começar simples, basta imprimir o tamanho da unidade em GB.

int drive_gb = 5;

void setup() {

 Serial.begin(9600);

 Serial.print("Your HD is ");
 Serial.print(drive_gb);
 Serial.println(" GB large.");

}

void loop()

empty

{

}

Copie e cole este esboço em software Arduino e nomea esboço DriveCalc Em seguida, compile e recarregue isso.

OK, vamos adicionar uma seção de código que irá imprimir o número de megabytes no disco rígido.

/*

* Drive size calculator!
*/

int drive_gb = 5; int drive_mb;

void setup() {

 Serial.begin(9600);

 Serial.print("Your HD is ");
 Serial.print(drive_gb);
 Serial.println(" GB large.");

 drive_mb = 1024 * drive_gb;

 Serial.print("It can store ");
 Serial.print(drive_mb);
 Serial.println(" Megabytes!");

}

void loop() // precisamos que isso seja aqui embora esteja vazio {

Neste momento, se você compilar e carregá-lo você deve obter o que é correto! Agora tente um pouco diferentes números inteiros para o tamanho do HD, de 1 GB a 100 GB. Você pode notar que se você colocar um tamanho de disco de 100GB, algo bastante estranho acontece: Uma unidade de 100GB deve ter 102400MB nela não no número negativo. O que está acontecendo aqui?

Introdução a como digitar (parte 1)

O que está acontecendo é que temos um problema de excesso. Pense no seu odômetro do seu carro. O odômetro tem apenas 4 dígitos, que pode exibir 0 milhas a 9999 quilômetros percorridos. Se você viajar 10.000 milhas, o odômetro irá voltar para 0 novamente, e dali em diante ele irá mostrar um valor incorreto. Mantendo isso em mente, lembre-se na lição 2, dissemos que quando nós definimos uma variável que também definimos a caixa da variável? A caixa é onde armazenamos os dados, neste caso a digitação é int. Acontece que uma digitação int pode armazenar apenas dois bytes.

Prova rapida!

Quantos bits estão em 2 bytes? Realce o texto abaixo para a resposta Há 8 bits em 1 byte para 2 bytes 16 bits

Para descobrir o quão grande um número que pode ser armazenado em uma caixa do tamanho de 2 bytes utilize uma calculadora e levar 2 à potência do número de bits (uma vez que cada bit pode armazenar dois valores, 0 ou 1). Em seguida, subtraímos 1, pois como no odômetro do carro, você não pode realmente mostrar o valor final, 10000. Então, neste caso o maior número é de 216 - 1 = 65535. Como o número que estamos tentando armazenar (102.400) é maior do que isso, vemos "rollover= volta". OK, vamos corrigi-lo! Tudo o que precisamos fazer é mudar o tipo de variável de forma que ele possa armazenar mais de 2 bytes de dados.

/*

* Drive size calculator!
*/

int drive_gb = 100; long drive_mb; // we changed the type from "int" to "long"

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

 Serial.print("Your HD is ");
 Serial.print(drive_gb);
 Serial.println(" GB large.");

 drive_mb = 1024 * drive_gb;

 Serial.print("It can store ");
 Serial.print(drive_mb);
 Serial.println(" Megabytes!");

}

void loop() // we need this to be here even though its empty {

}

Compile e recarregar este esboço .... em seguida, execute o Monitor de série ....
Uh oh realmente não corrigimos o problema!

Como é frustrante, fizemos a coisa certa e ainda não funcionou. O problema que temos agora é que, embora as caixas sejam do tamanho certo, não estamos os manipulando bem.

drive_mb = 1024 * drive_gb;
Se você olhar para esta linha, o que está acontecendo aqui é que o Arduino procura o valor da variável para obter 100. Depois multiplicamos 100 por 1024 para obter 102.400 e colocar isso na caixa drive_mb. Exceto a maneira que o software do Arduino faz isso é que ele cria uma variável temporária do mesmo tamanho para armazenar o resultado do cálculo antes que ele o liga-lo na caixa drive_mb. Então, basicamente, ainda estamos tendo um transbordamento, só que agora isso está acontecendo como nós fazemos o cálculo.

Aqui está uma maneira de corrigir este erro insidioso:

/*

* Drive size calculator!
*/

int drive_gb = 100; long drive_mb;

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

 Serial.print("Your HD is ");
 Serial.print(drive_gb);
 Serial.println(" GB large.");

 drive_mb = drive_gb;
 drive_mb = drive_mb * 1024;

 Serial.print("It can store ");
 Serial.print(drive_mb);
 Serial.println(" Megabytes!");

}

void loop() // we need this to be here even though its empty {

Agora, quando fazemos o cálculo, o resultado temporário é armazenado em uma caixa do mesmo tamanho para armazenar que drive_mb ( um grande) em vez de um int. Compile e recarregue este esboço para experimentá-lo Vai, agora está funcionando!

Introdução a como digitar (parte 1)

Acontece que eu não estava completamente honesto na seção anterior, quando eu descrevi todas diferentes digitações. Há ainda outro fato importante, a saber, e que tem a ver com o armazenamento de números negativos. Sabemos que uma variável que é de um tamanho de 2 bytes (16 bits) pode armazenar 216 valores diferentes. Assumimos antes que estes valores eram de 0-65535 inclusive. Mas então como é que vamos armazenar números negativos? Acontece que existem dois tipos de variáveis, com e sem sinal. Variáveis com sinal podem ter um valor positivo ou negativo, de modo que você pode armazenar números negativos. Variáveis sem sinal só pode armazenar números positivos. Por predefinição, as variáveis são com sinal.

Prova rapida!

Digamos que você tenha um programa que armazena a idade de um ser humano em anos (que até agora não é mais do que 122), Qual o tipo de dados que é bom para usar? Realce o texto abaixo para a resposta Você provavelmente vai querer usar um tipo byte • Vamos dizer que você quer armazenar a idade de um ser humano em segundos, Qual é o tipo de dados apropriado agora? Realce o texto abaixo para a resposta 110 anos = 3468960000 segundo. Você vai precisar armazenar isso em uma variável longo sem sinal. Por quê ? OK assim que você deve estar se perguntando: "Isso é borrice, por que se preocupar diferentes tamanhos de digitação. Deixa apenas ter todas as variáveis ser tão grande quanto possível e nunca teremos problemas transbordamento". Bem, no seu computador, com gigabytes de memória (RAM), isso é uma coisa razoável a fazer. No entanto, o minúsculo computador no Arduino tem um total de 1 Kilobyte de memória. E alguns são usados para as coisas de segundo plano você não vê. Para pequenos esboços tenha certeza que você pode fazer tudo junto e ser feito com ele, mas se você tem um grande esboço, você vai executar fora da memória muito rápido e então você vai ter grandes problemas. Portanto, neste caso, cada byte conta! O que é estranho sobre números com sinal é que se você chegar ao final do intervalo de valores positivos você vai transbordar em valores negativos. Por exemplo, digamos que você tenha um int com sinal. Se você tem o valor de 32.767 nessa variável, e você adicionar 1 à variável, você realmente transborda para - 32768.

Este esboço vai testar este fato:

int test = 32767;

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

 Serial.print("Test value is: ");
 Serial.println(test);

 test = test + 1;

 Serial.print("Now it is ");
 Serial.println(test);

}

void loop() // we need this to be here even though its empty {

}

 Compile e faça  o upload para executar o teste.
 
Prova rapida!

• Vamos dizer que temos uma variável que é do tipo byte, está com sinal por padrão. Ele começa com o valor 127 e nós adicionamos um para a variável, o que será o novo valor variável ser?

Realce o texto abaixo para a resposta É uma variável com sinal por isso vai transbordar para -128 • Vamos dizer que agora é um tipo byte sem sinal, o que acontece agora? Realce o texto abaixo para a resposta Uma vez que é com sinal, pode armazenar muito mais dado, por isso vai ser capaz de conter o valor 128. • Se tivermos um byte sem sinal e que começa com o valor 250 e somamos 10, o que vai ser o valor? Realce o texto abaixo para a resposta Embora a variável thie possa armazenar uma grande quantidade, não pode armazenar mais do que o número 255, portanto, transbordar e nós vamos acabar com o número 4. Agora é sua vez! Escreva alguns esboços que irão ajudar você a entender tamanhos variáveis, tente criar variáveis de diferentes tipos e com ou sem sinal, e somando e subtraindo. Embora esta parte da lição pareça muito ser muito chata, e extremamente desprovida de luzes piscantes, entendendo este material agora irá salvar você de muitas dores de cabeça mais tarde, quando você tem transborda de dados e seu programa é tudo instável e você está realmente frustrado porque você não pode descobrir o porquê. (Confie em mim um!) Resumindo, o projeto final! Agora o tempo para você expandir a calculadora do tamanho da unidade. Começando com o esboço DriveCalc , modificá-lo para que ele também vá calcular quantos KB são armazenados no disco rígido. Testá-lo com dois HD de tamanho diferentes. Uma vez que você conseguiu este trabalho, modificá-lo novamente para que ele também exiba o espaço que unidade detém realmente e ter um esboço que mostre quanto espaço de armazenamento está faltando' (em KB) também. Aqui está uma possível solução: /*

* Drive size calculator!
*/

int drive_gb = 100; long drive_mb; long drive_kb; long real_drive_mb; long real_drive_kb;

void setup() // run once, when the sketch starts {

 Serial.begin(9600);           // set up Serial library at 9600 bps

 Serial.print("Your HD is ");
 Serial.print(drive_gb);
 Serial.println(" GB large.");

 drive_mb = drive_gb;
 drive_mb = drive_mb * 1024;
 drive_kb = drive_mb * 1024;
 
 Serial.print("In theory, it can store ");
 Serial.print(drive_mb);
 Serial.print(" Megabytes, ");
 Serial.print(drive_kb);  
 Serial.println(" Kilobytes.");

 real_drive_mb = drive_gb;
 real_drive_mb = real_drive_mb * 1000;
 real_drive_kb = real_drive_mb * 1000;
 
 Serial.print("But it really only stores ");
 Serial.print(real_drive_mb);
 Serial.print(" Megabytes, ");
 Serial.print(real_drive_kb);  
 Serial.println(" Kilobytes.");
 
 Serial.print("You are missing ");
 Serial.print(drive_kb - real_drive_kb);  
 Serial.println(" Kilobytes!");

}

void loop() // run over and over again { }

Conclusão: Bom trabalho, você passou por uma das aulas mais chatas. Nesta lição você aprendeu a impressão de texto e dados para o Monitor de série. Isto é essencial para a depuração de projetos futuros! Você também aprendeu sobre os tipos de dados e de armazenamento e como usar o Arduino para calcular as coisas.