telefone de casa … com o Arduino

Até agora chegou na presente série Eletrônica Fundamentos e circuitos com sensores e atuadores para a linguagem. A placa de microcontrolador usado experimentado apenas uma insularidade e foi possivelmente conectado via USB para o anfitrião. Este papel irá cair esta restrição. Neste e nos próximos episódios, a série tratada com uma variedade de opções de comunicação para placas Arduino.

Internet das coisas significa comunicação: a comunicação entre dispositivos, a comunicação entre dispositivos e serviços em nuvem e interação entre dispositivos e pessoas. Mas como pode o homem, dispositivo móvel ou PC pode falar com o microcontrolador? Em outras palavras: Como pode uma placa Arduino para chamar de lar, ou conversar com outras máquinas?

Neste artigo, Ethernet Shields estão na vanguarda. Em outros episódios também WiFi e Bluetooth são discutidos. Além disso, lidamos com diferentes protocolos de comunicação específicos de aplicativos, tais MQTT. de forma que nós estabelecer as bases para conectar nossos dispositivos da Internet das coisas à Internet.

Antes de começarmos com exemplos práticos, é necessária uma pequena excursão ao mundo dos sistemas de ônibus. Shields Ethernet comunicar com o Arduino via o barramento SPI.

SPI - Peripheral Interface Serial

Em episódios anteriores temos autocarros, tais como I2C e 1-Wire I2C met mais feito, por exemplo, a ligação de um visor LCD, sobre um fio-DS18B20 sensor de temperatura e o sistema de microcontrolador comunicadas uma com a outra. Mas há mais sistemas de ônibus orientados para a prática.

Um sistema de ônibus muito comum chamado SPI (Serial Peripheral Interface), é originária da Motorola e é usado para síncrono de comunicação full-duplex entre um Master (!) E seus escravos. Para os escravos como um leitor de cartão SD, monitores e componentes de comunicação podem incluir. Você pode se perguntar por que não também usam para I2C. A resposta é curta. comunicação SPI é simplesmente mais rápido do que através de um barramento I2C.

SPI configuração típica com um mestre e três escravosSPI configuração típica com um mestre e três escravos(Foto: wikipedia.org)
quatro linhas

Mas como SPI funciona em detalhes? Uma característica do SPI é que o protocolo especifica quatro linhas:

wikipedia.orgComunicação de mestre e escravo usando registradores de deslocamento(Foto: wikipedia.org)

encurtada

No início de cada comunicação SPI, o mestre configura o relógio para que o escravo pode operar nesta freqüência. Em seguida, o mestre selecciona o dispositivo desejado através de um sinal baixo. Se um período de espera é necessária, as master aguarda o tempo especificado antes de iniciar a comunicação.

SPI transmite bits de dados por bit em full duplex. unidades principais são bytes ou palavras máquina. O mestre envia um bit através da sua saída MOSI, onde o escravo recebe os dados. Em paralelo, os bits de escravos enviada na sua saída MISO, que por sua vez recebe o mestre.

Esta comunicação bidirecional ocorre mesmo quando os dados do usuário é transportado em uma única direção. Cada parceiro de comunicação contém dois registos de deslocamento de 8 bits, um para enviar e outro para receber dados.

polaridades e as fases SPI

Assim, o mestre e escravo pode se comunicar com sucesso, requer um ajuste não só a frequência do relógio, mas também a polaridade utilizada (CPOL) e fase (CPHA) do relógio.

depende da polaridade, que o valor do sinal activo, e que representa o estado inactivo. na fase depende se é lido na borda de subida e escreveu na borda de descida, ou vice-versa.

wikipedia.orgDiagrama de Temporização polaridades e as fases(Foto: wikipedia.org)

Atribuição dos pinos do Arduino

arduino.cc assignement Pin para SPI com Arduino(Foto: arduino.cc)

A questão preço é onde os pinos SPI acima mencionados são realmente localizado nas placas Arduino individuais. Uma página SPI em Arduino.cc são prova disso. Você vai encontrar, pelo menos, as atribuições para o Conselho de arduino.cc. Em réplicas e outros conselhos você deve consultar a documentação do fabricante.

O que é um UART

Obviamente, há tanto a comunicação serial e paralela dentro placas de microcontrolador.

Precisamos de uma interface que combina ambas as variantes.

O Universal Asynchronous Receiver / transmissor tem a tarefa de conversão de dados em comunicação em série e em paralelo. Por exemplo entrar através de uma interface paralela de bytes decomposto o UART transmissor, e enviada através de uma linha série pouco a pouco para o receptor, em que um receptor UART reagrupa os bits em bytes novamente. O ingrediente mais importante da UART contém Shift Register - na verdade, existem dois. Nós tinha aprendido na revisão dos LEDs, como o 74HC595 registo de deslocamento recebe um byte e fornece em seu saídas de bits disponível. A comunicação em série entre o UART é sincronizado por bits de arranque e de paragem. Ela pode ser realizada em full duplex ou no modo simplex.

A UART não é responsável pelo nível lógica dos componentes ligados. Para o cuidado de sinalização dependentes de voltagem em vez de normas tais como RS-232, RS-422 e RS-485.

Arduino Ethernet Shield

O Arduino Ethernet Shield em sua versão atual é baseada no chip W5100 de Wiznet. Os dados de desempenho mais importantes são rapidamente enumerou. O dispositivo proporciona a transmissão até 100 Mbytes / s de dados, suporta o IEEE 802.3 / 10BASE-T, IEEE 802.3 u / 100BASE-TX tem um tampão interno de 16 Kbytes e permite que até quatro ligações de encaixe paralelas.

Para conduzir o escudo Ethernet, precisamos de uma biblioteca apropriada. O Arduino IDE já implica uma biblioteca correspondente chamado Ethernet.

Começamos com um pequeno esquete, que só abre uma conexão Ethernet. Se você encontrar o seu Ethernet Proteja uma etiqueta com um endereço MAC único, localizado, situado no Esboço menor este URL. No entanto, não existe tal informação, você inventar um endereço MAC. A maneira mais fácil é, naturalmente, se você tem o endereço MAC no esboço inalterado. O risco de que um dispositivo com o mesmo endereço MAC está na sua rede é insignificante, de qualquer maneira.

O programa está a tentar obter através de DHCP endereço IP dinâmico, e dá informações adequadas em caso de falha. Se você estiver usando endereços estáticos, proceda conforme indicado na listagem.

////////////////////////////////////////////////// /////////////
//
esboço // Arduino: Entrar Sobre escudo para Ethernet
// a) com um endereço estático, ou
// b) com o endereço dinâmico através do DHCP
//
////////////////////////////////////////////////// /////////////

#include
#include

////////////////////////////////////////////////// /////////////
// Precisamos de um endereço MAC.
// Se o escudo Ethernet sem endereço
// (geralmente adesivos de colagem)
// tem, temos de inventar o nosso próprio:
////////////////////////////////////////////////// /////////////

byte mac [] = {
0x00, 0xCC, 0xBB, 0xAA, 0xDE, 0x02
};


// Ethernet cliente: API para acessar o escudo Ethernet
Cliente cliente Ethernet;

////////////////////////////////////////////////// /////////////
// O esboço é baseada em endereços IP dinâmicos via DHCP.
// Como alternativa, especificando um endereço estático seria possível.
// substituir a seguinte informação da sua
// ambiente do Sistema:
//
// IPAddress ip (192, 168, 178, 72);
// Endereço_ip DNS (192168178, 1);
// gateway de endereço IP (192, 168, 178, 1);
// Endereço_ip sub-rede (255, 255, 0, 0);
// Ethernet.begin (mac, IP, DNS, gateway, sub-rede);
//
// Substituir ggf.in a configuração do método ()
// if declaração
//
// if (Ethernet.begin (mac) == 0) {
// Ethernet.begin (mac, IP, DNS, gateway, sub-rede);
//}
//
////////////////////////////////////////////////// /////////////

void setup () {
Serial.begin (9600); // conexão serial Abrir

// conexão e Ethernet Abrir pedir para o endereço IP DHCP:
if (Ethernet.begin (mac) == 0) {
Serial.println ("endereço IP via DHCP solicitação falhou");

while (true) {} // indefinidamente em espera
}

// endereço através da saída de porta serial:
Serial.print ("O seu endereço IP é: ");
Serial.println (Ethernet.localIP ());
}

void loop () {
////////////////////////////////////////////////// ////////////
// Os endereços IP são DHCP só até certo
// "prazo de validade" premiado. Portanto, de acordo com a
// um certo tempo um Neuabonnement necessário:
////////////////////////////////////////////////// ////////////

interruptor (Ethernet.maintain ())
{
Caso 1:
Serial.println ("Erro: rejeitado envelhecimento endereço");
break;
Caso 2:
Serial.println ("Endereço envelhecimento com sucesso");
break;
case 3:
Serial.println ("Erro: falha religação");
break;
Caso 4:
Serial.println ("religação com sucesso");
break;
default: // Nada aconteceu
break;
}
}

Arduino desempenha servidor Web

A versão mais simples de comunicação para comunicar com o Arduino via Internet, HTTP é. O usuário seleciona uma página web em particular e as pessoas respondem a placa Arduino com o feedback dos dados atuais do sensor. No entanto, isso apareceria como um servidor Web do Arduino. Felizmente, ele cai para a biblioteca Ethernet não é difícil, só que em ação
implementar.

////////////////////////////////////////////////// /////////////
//
esboço // Arduino: Entrar Sobre escudo para Ethernet
// e trabalhar como um servidor web.
// uso do cliente: página do browser http: // go 80
//
////////////////////////////////////////////////// //////////////

#include // Interface Serial Peripheral
#include // Escudo Ethernet

// Digite o endereço MAC do seu Shields Ethernet
byte mac [] = {
0xDE, 0xAA, 0xBB, 0xCC, 0xDD, 0xED
};

////////////////////////////////////////////////// ////////////
// use o endereço IP estático. Digite aqui
// seu próprio endereço IP estático.
// alternativa seria endereço IP dinâmico via DHCP////////////////////////////////////////////////// ////////////
Endereço_ip serverIP (192, 168, 178, 72);

////////////////////////////////////////////////// ////////////
// O esboço implementado um servidor
// com o serverIP e a porta 80:////////////////////////////////////////////////// ////////////
servidor Ethernet Server (80);

void setup () {
// Iniciar Monitor de série
Serial.begin (9600);

// inicializar o servidor com MAC e IP:
Ethernet.begin (mac, serverIP);
server.begin ();
Serial.print ("Servidor lançado. Endereço IP: ");
Serial.println (Ethernet.localIP ());
}

////////////////////////////////////////////////// ////////////
// ciclo de eventos de servidor Web baseado em Arduino////////////////////////////////////////////////// ////////////void loop () {
// espera de um cliente:
Ethernet client = server.available ();
if (cliente) {
Serial.println ("nova conexão");
// Uma linha em branco marca o fim da solicitação HTTP:
booleano endOfRequestReached = true;
// Enquanto a conexão é estabelecida, os dados são lidos a partir do cliente:
enquanto (client.connected ()) {
if (client.available ()) {
char c = client.read ();
Serial.write (c);
// Ao chegar ao final da solicitação HTTP
// podemos montar a resposta. if (c == '\ n' && endOfRequestReached) {
// enviar a resposta:
client.println ("HTTP / 1.1 200 OK");
client.println ("Content-Type: text / html"); // É necessário quebrar o link:
client.println ("Connection: close"); // A cada 10 segundos, a ser realizada uma atualização:
client.println ("Atualizar: 10");
client.println ();
client.println ("");
client.println (""); // Nós damos um valor aleatório de A0 volta:
int val = leitura analógico (A0);
client.print ("Analógico Porto A0 ");
client.print ("tem o valor: ");
client.print (Val);
client.println ("
");
client.println ("");
}
endOfRequestReached = (c == '\ n') || (C == '\ r');
}
}

Carregar o esboço para o Arduino, abra seu navegador e digite inferior como o URL (serverIP é a saída do esboço sobre o endereço IP monitor serial):

http: // serverIP: 80

Você deve então começar a ver problemas semelhantes como o seguinte:

Analógico Porto A0 tem o valor: 434
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 390
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 322
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 314
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 286
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 395
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 296
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 276
HTTP / 1.1 200 OK Content-Type: text / html Connection: close refresh: 10 Analog Porto A0 tem o valor: 432

conclusão

Neste episódio, nós começamos a olhar para o detalhe escudo Ethernet. Para a comunicação linguagem de baixo nível através de TCP / IP e HTTP veio. Além disso, os exemplos foram limitados a 1: 1 de comunicações. Assim, já pode, efectivamente, alguns nas pernas, mas para aplicações da Internet das coisas seria protocolos orientados a aplicação benéfica. Para dar um exemplo chamado MQTT ele vai no próximo episódio.