tag:blogger.com,1999:blog-6319271099144886202024-02-19T02:17:19.221-03:00ArduinoBRDavid Fariashttp://www.blogger.com/profile/15145555607647989148noreply@blogger.comBlogger17125tag:blogger.com,1999:blog-631927109914488620.post-39376756378247654182016-06-19T12:47:00.000-03:002016-06-19T12:47:11.532-03:00Integrando Raspberry PI com Arduíno via I²COlá, neste post iremos explicar como fazer a comunicação entre um Raspberry PI e 2 Arduínos, utilizando o protocolo I²C. Já havíamos explicado como fazer uma integração entre eles, utilizando o barramento serial (para ver o artigo, clique <a href="http://arduinoccbr.blogspot.com.br/2016/05/integrando-o-arduino-com-raspberry-pi.html" target="_blank">aqui</a>). A vantagem de utilizarmos o I²C, como já explicado nesse artigo <a href="http://arduinoccbr.blogspot.com.br/2016/05/barramento-ic.html" style="color: #6c85ce; font-family: Arial, Tahoma, Helvetica, FreeSans, sans-serif; font-size: 18px; text-decoration: none;">Barramento I²C</a>, é que podemos ter no mesmo barramento até 128 dispositivos e via Serial, só podemos ter um dispositivo conectado e como o Raspberry tem poucas portas GPIO's, podemos expandir esse número utilizando um ou mais Arduínos integrados via I²C.<br />
<br />
No post <a href="http://arduinoccbr.blogspot.com.br/2016/05/barramento-ic.html" style="color: #6c85ce; font-family: Arial, Tahoma, Helvetica, FreeSans, sans-serif; font-size: 18px; text-decoration: none;">Barramento I²C</a>, utilizamos um Arduíno UNO como Master, um Duemilanove e um Nano como Slavers. Neste post, vamos substituir o Arduíno UNO Master por um Raspberry PI.<br />
<br />
Segue lista de materiais utilizados:<br />
<br />
<ul>
<li>1 Raspberry PI Rev B</li>
<li>1 Arduíno Duemilanove</li>
<li>1 Arduíno Nano</li>
</ul>
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgLr78z2rqrqY_mrNkX7GHc3-RlFcsNLYGUP2tbBEW1r82Bppuh0Q8aZBe2vhuHGRZweXNOBLUZ_FjX_Q4QBVrri1G-_0OwWIQ1Kjm1-6dP9uN2kUsW8n5ajGNHpW_UVAliPCDzpiit6Cqd/s1600/IMG_20160604_085626046.jpg" imageanchor="1"><img border="0" height="225" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgLr78z2rqrqY_mrNkX7GHc3-RlFcsNLYGUP2tbBEW1r82Bppuh0Q8aZBe2vhuHGRZweXNOBLUZ_FjX_Q4QBVrri1G-_0OwWIQ1Kjm1-6dP9uN2kUsW8n5ajGNHpW_UVAliPCDzpiit6Cqd/s400/IMG_20160604_085626046.jpg" width="400" /></a></div>
<br />
Na nossa montagem, o Raspberry irá imprimir uma mensagem enviada por cada Arduíno, similar ao post <a href="http://arduinoccbr.blogspot.com.br/2016/05/barramento-ic.html" style="color: #6c85ce; font-family: arial, tahoma, helvetica, freesans, sans-serif; font-size: 18px; text-decoration: none;">Barramento I²C</a>:<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9wksAsL9LLH6Rk5WKqdQVie3kpFTEFIoM4W7I1sjwnZgKZ-E7tOdRoRoztLEM9xo2AoJV36kT_gUfjJ2WlaqWYYis6X1lUyWjNIeFHieweouWP9OO0I16YOtqo6MbHDOfnyPVGuzlzauA/s1600/Captura+de+tela+de+2016-06-04+11-52-57.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9wksAsL9LLH6Rk5WKqdQVie3kpFTEFIoM4W7I1sjwnZgKZ-E7tOdRoRoztLEM9xo2AoJV36kT_gUfjJ2WlaqWYYis6X1lUyWjNIeFHieweouWP9OO0I16YOtqo6MbHDOfnyPVGuzlzauA/s400/Captura+de+tela+de+2016-06-04+11-52-57.png" width="400" /></a></div>
<br />
<b>Raspberry PI</b><br />
<br />
Por default, os pinos I²C do Raspberry estão desabilitados. Segue abaixo os passos habilitá-los.<br />
<br />
1 - Via console, acesse a ferramenta de configuração<br />
<div>
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"><code style="color: black; word-wrap: normal;">$ sudo raspi-config</code>
</pre>
</div>
<div>
<br />
<br />
2 - Selecione <i>Advanced Options</i><br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgf7QANX0hTS3EE3lAmiJCnu8zmHrzN_q47rVd7A2nMRIJd6qYE-JPvlU9LUP1Mx2RBcTGb89IDbKrMRPNkH4mDsslJjud7ck0GOFjdM9lmlKPJN7ZdeVyaK7mgpJJWQJVeqFCLETf79KeN/s1600/Captura+de+tela+de+2016-06-04+09-15-17.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgf7QANX0hTS3EE3lAmiJCnu8zmHrzN_q47rVd7A2nMRIJd6qYE-JPvlU9LUP1Mx2RBcTGb89IDbKrMRPNkH4mDsslJjud7ck0GOFjdM9lmlKPJN7ZdeVyaK7mgpJJWQJVeqFCLETf79KeN/s400/Captura+de+tela+de+2016-06-04+09-15-17.png" width="400" /></a></div>
<br />
<br />
3 - Selecione <i>A7 I2C</i><br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgHqs2DUDwku0Zf7oNISrGJksnyP5IJCbooU9jNvIm8heCYX8EIdGt8t98fpxa04PgAJdDykKGlAMwL4V4VAWqOqMHXlx5SeKEBwmp3FTOhvOkknFGbDaF4pjOm3BU2ydfBBbVPPxtjHUhyphenhyphen/s1600/Captura+de+tela+de+2016-06-04+09-15-26.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgHqs2DUDwku0Zf7oNISrGJksnyP5IJCbooU9jNvIm8heCYX8EIdGt8t98fpxa04PgAJdDykKGlAMwL4V4VAWqOqMHXlx5SeKEBwmp3FTOhvOkknFGbDaF4pjOm3BU2ydfBBbVPPxtjHUhyphenhyphen/s400/Captura+de+tela+de+2016-06-04+09-15-26.png" width="400" /></a></div>
<br />
<br />
4 - Selecione <i>Yes</i> e depois <i>OK</i><br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjyjKnQgcOHtmy4Dl2oR5GkUnO_du3pGbL7r1Tywqw33sS2mwB0bduNUcepBt6rzF34JSFeYJpBtXY04DFoHySPwAH9yi9SpZaZdKYf54XZCBGImjL_bqz12WMqK-xAHi3_8vrJOq3HvcHc/s1600/Captura+de+tela+de+2016-06-04+09-15-34.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjyjKnQgcOHtmy4Dl2oR5GkUnO_du3pGbL7r1Tywqw33sS2mwB0bduNUcepBt6rzF34JSFeYJpBtXY04DFoHySPwAH9yi9SpZaZdKYf54XZCBGImjL_bqz12WMqK-xAHi3_8vrJOq3HvcHc/s400/Captura+de+tela+de+2016-06-04+09-15-34.png" width="400" /></a></div>
<div style="text-align: center;">
<br /></div>
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgpY0Igy8ZBzZw7jfI-vTa_t23m_nikBX2ACW8J10jgEMpFBJkjh7a2noMyWY2BDXiHYkW8aZNh_GlP9pUE4LxRsR_EXC7a5kUj9gM1p861yTWxB0kPL8550acnjmHl96cygGJM4gU2B-z6/s1600/Captura+de+tela+de+2016-06-04+09-15-37.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgpY0Igy8ZBzZw7jfI-vTa_t23m_nikBX2ACW8J10jgEMpFBJkjh7a2noMyWY2BDXiHYkW8aZNh_GlP9pUE4LxRsR_EXC7a5kUj9gM1p861yTWxB0kPL8550acnjmHl96cygGJM4gU2B-z6/s400/Captura+de+tela+de+2016-06-04+09-15-37.png" width="400" /></a></div>
<br />
<br />
5 - Selecione <i>Yes</i> e depois <i>OK</i><br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj2Xn85ylPoiSlZcL50vtF-qUAjS_1AtVfTC4lKfuTKBBCmCG1O2zJrPdGhiVsmAChMcOmpz82QnxBkh-mCpqQW1Kz_EuQT1QvCSqx7vKfZnAGxBW1689-5J1ImYu-UmNeaiTjo00D8jiAK/s1600/Captura+de+tela+de+2016-06-04+09-15-45.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj2Xn85ylPoiSlZcL50vtF-qUAjS_1AtVfTC4lKfuTKBBCmCG1O2zJrPdGhiVsmAChMcOmpz82QnxBkh-mCpqQW1Kz_EuQT1QvCSqx7vKfZnAGxBW1689-5J1ImYu-UmNeaiTjo00D8jiAK/s400/Captura+de+tela+de+2016-06-04+09-15-45.png" width="400" /></a></div>
<div style="text-align: center;">
<br /></div>
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiK4oItnGrfew2yopTCZcn8ytzuI5j80aDvSm8pdfr8PSUbwvOO2Jtknwx7TS5X2E4DyCDEYXoEBP6bJQv1Y0XeGym0kURdN1LzeapMETkytTAsnw5xw4YjdBr4z-Pqxr_VZTKFJYFzTgZm/s1600/Captura+de+tela+de+2016-06-04+09-15-48.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiK4oItnGrfew2yopTCZcn8ytzuI5j80aDvSm8pdfr8PSUbwvOO2Jtknwx7TS5X2E4DyCDEYXoEBP6bJQv1Y0XeGym0kURdN1LzeapMETkytTAsnw5xw4YjdBr4z-Pqxr_VZTKFJYFzTgZm/s400/Captura+de+tela+de+2016-06-04+09-15-48.png" width="400" /></a></div>
<br />
<br />
6 - Selecione Finish<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhmDSLZG4f083xk8A38RHbXGMYKu9PhT88U-ZSsQKgYCU4IWuRTGACzBkT-_x625gxsI-wGPCm7X2aX3wnpOiX2Hw7_tn8y2_ejQXQkixS4O1BqbVl1kqUAyMUiZ__Y-qsrDEDePMISkyl8/s1600/Captura+de+tela+de+2016-06-04+09-15-17.png" imageanchor="1"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhmDSLZG4f083xk8A38RHbXGMYKu9PhT88U-ZSsQKgYCU4IWuRTGACzBkT-_x625gxsI-wGPCm7X2aX3wnpOiX2Hw7_tn8y2_ejQXQkixS4O1BqbVl1kqUAyMUiZ__Y-qsrDEDePMISkyl8/s400/Captura+de+tela+de+2016-06-04+09-15-17.png" width="400" /></a></div>
<br />
7 - Desligue o Raspberry como o comando abaixo, desligue a força e faça conexões dos Arduínos.<br />
<div>
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ sudo halt</code>
</pre>
</div>
<div>
<br />
<b>Esquema de ligação</b><br />
<br />
Segue abaixo a lista de pinos do Raspberry PI Rev B<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_wbYMh67Nast8OdvbD8VB_7hRNG3w8a1Z6fCnERT1O4PqbWakOPfmaMAOBl9SgZMDSGs39Y0lWcQl9fpycQIBFNhTX0VtOnsdHZ44ZaOjt2Aoe7mHHIv4rtnbKN34ZjdTtX3TluTvh3SA/s1600/Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900.png" imageanchor="1"><img border="0" height="211" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_wbYMh67Nast8OdvbD8VB_7hRNG3w8a1Z6fCnERT1O4PqbWakOPfmaMAOBl9SgZMDSGs39Y0lWcQl9fpycQIBFNhTX0VtOnsdHZ44ZaOjt2Aoe7mHHIv4rtnbKN34ZjdTtX3TluTvh3SA/s640/Raspberry-Pi-GPIO-Layout-Model-B-Plus-rotated-2700x900.png" width="640" /></a></div>
<br />
Os pinos I²C são: 3 - SDA(Dados) e 5 - SCL (Clock). O esquema de ligação é exatamente o mesmo do post <a href="http://arduinoccbr.blogspot.com.br/2016/05/barramento-ic.html" style="color: #6c85ce; font-family: arial, tahoma, helvetica, freesans, sans-serif; font-size: 18px; text-decoration: none;">Barramento I²C</a>.<br />
<br />
Segue esquemático:<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhwGWbThuYh6SnUEQbAjSbDOdV0yhOyYdzNHC-hOMzEcY03JNaglS5VO230xdDju1MHSPcWSbo4nVbJmYdHE0Biio1wXieeE9g3XcySmLVePlHsKKCRX1nlqSdfA0kPOgcvvX_y6PjXMarK/s1600/Captura+de+tela+de+2016-06-04+09-45-00.png" imageanchor="1"><img border="0" height="336" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhwGWbThuYh6SnUEQbAjSbDOdV0yhOyYdzNHC-hOMzEcY03JNaglS5VO230xdDju1MHSPcWSbo4nVbJmYdHE0Biio1wXieeE9g3XcySmLVePlHsKKCRX1nlqSdfA0kPOgcvvX_y6PjXMarK/s640/Captura+de+tela+de+2016-06-04+09-45-00.png" width="640" /></a></div>
<br />
Apesar de o Raspberry Pi trabalhar a 3,3V e o Arduíno a 5V, como o Raspberry PI será o Master a tensão do barramento será definida por ele e por isso, não se faz necessário montar um circuito para limitar a tensão (se o arduíno for Master, ele pode queimar a porta do Raspberry). Além disso, o Raspberry PI já tem um resistor pull-up nos pinos utilizado no barramento I²C que dispensa o seu uso em outros dispositivos.<br />
<br />
<b>Programação dos Arduínos.</b><br />
<br />
A biblioteca que utilizaremos no Raspberry só permite a leitura de um inteiro por vez (não é possível ler um buffer) e por isso, enviaremos a mensagem caractere a caractere, com o primeiro caractere de controle. Explicarei com mais detalhes mais a frente.<br />
<br />
Código do Nano:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">#include <Wire.h>
void setup()
{
Wire.begin(0x50);//endereço de I2C
Wire.onRequest(requestEvent);
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
char * buff="*hello I'm Nano";
byte count = 0;
void requestEvent()
{
Wire.write(buff[count]);
if(count == 14)
count = -1;
count ++;
}</span></span></pre>
<br />
Código do Duemilanove:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">#include <Wire.h>
void setup()
{
Wire.begin(0x40);//endereço de I2C
Wire.onRequest(requestEvent);
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
char * buff="*hello I'm Due";
byte count = 0;
void requestEvent()
{
Wire.write(buff[count]);
if(count == 13)
count = -1;
count ++;
}</span></span></pre>
<br />
<b>Programação do Raspberry PI.</b><br />
<br />
Para confirmar se o módulo I²C está ativo, basta digitar a linha de comando abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ lsmod | grep i2c</code></pre>
<br />
Devemos ter uma saída similar a essa:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-size: 12px; line-height: 14px;">pi@raspberrypi:~ $ lsmod | grep i2c
i2c_bcm2708 5988 0
i2c_dev 6386 0 </span></pre>
<br />
A saída acima indica que o módulo i2c_bmc2708 está ativo.<br />
<br />
Agora, vamos instalar a biblioteca para o I²C. Para mais detalhes sobre ela, clique <a href="http://wiringpi.com/reference/i2c-library/" target="_blank">aqui</a>.<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ sudo apt-get install libi2c-dev</code></pre>
<br />
O Raspberry vem com um programa para detectar o endereço dos dispositivos conectados no barramento.<br />
<br />
Basta digitar o comando abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ i2cdetect -y 1</code></pre>
<br />
Se seu Raspberry PI for Rev 1, digite:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ i2cdetect -y 0</code></pre>
<br />
Essa diferença acontece, pois houve uma alteração nos pinos utilizados pelo I²C entre Rev 1 e 2.<br />
<br />
A saída deve ser de acordo com texto abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-size: 12px; line-height: 14px;">pi@raspberrypi:~ $ i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: 50 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- -- </span><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px;">
</span></pre>
<div>
<br /></div>
<div>
0x40 e 0x50 são os Arduínos conetados no barramento.</div>
<br />
Agora vamos a codificação.<br />
<br />
<i>Makefile</i> - Crie o arquivo de acordo com o texto abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">#
# Makefile:
#################################################################################
#DEBUG = -g -O0
DEBUG = -O3
CC = gcc
INCLUDE = -I/usr/local/include
CFLAGS = $(DEBUG) -Wall $(INCLUDE) -Winline -pipe
LDFLAGS = -L/usr/local/lib
LDLIBS = -lwiringPi -lwiringPiDev -lpthread -lm
# Should not alter anything below this line
###############################################################################
SRC = i2cTest.cpp \</code></pre>
<br />
Crie um arquivo chamado i2cTest.cpp, de acordo com o texto abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">#include <stdio.h>
#include <wiringPi.h>
#include <wiringPiI2C.h>
void readI2CString(int fd, char*buffer,int length,char charController)
{
for(;;)//aguardando caractere de controle para guardar a mensagem
if(wiringPiI2CRead(fd)==charController)
break;
for(int i = 0; i < length; i++)//lendo mensagem
{
buffer[i]=wiringPiI2CRead(fd);
}
}
int main (int argc, char *argv[])
{
int fd1,fd2;//identificadores de cada dispositivo
char buffer[20];//buffer para armazenar a mensagem
wiringPiSetup ();//inicializando biblioteca
fd1=wiringPiI2CSetup (0x40);//conectando com dispositivo 40
fd2=wiringPiI2CSetup (0x50);//conectando com dispositivo 50
if(fd1==-1||fd2==-1)
{
printf("Can't setup the I2C devices\n");
return -1;
}
else
{
for (;;)
{
readI2CString(fd1,buffer,13,'*');//Lendo mensagem do dispositivo 40
buffer[13] = '\0';
printf("%s\n",buffer);
readI2CString(fd2,buffer,14,'*');//Lendo mensagem do dispositivo 50
buffer[14] = '\0';
printf("%s\n",buffer);
}
}
return 0;
}</span></span><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px;">
</span></pre>
<div>
<br /></div>
Para compilar, basta executar a linha de comando abaixo:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><code style="font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; word-wrap: normal;">$ </code><span style="background-color: transparent; font-size: 12px; line-height: 14px;">make i2cTest</span></pre>
</div>
<div>
<br />
Para executar o programa, basta digitar o comando:<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">$ sudo ./i2cTest</code></pre>
<br />
A saída deverá ser essa:<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjcAdl6Cksqe7eRVpr9ZqM2UhjWJCkRUgWOQK744eJvFHJzokAXiVe0YhJci5OonSzoVu2l7ejxdeUFb__MrevshTS58ebFzwptGntPqpk1-UuCXxCY8e-hPZPJ9Ag2zb9jkIE54qHq00jQ/s1600/Captura+de+tela+de+2016-06-04+11-52-57.png" imageanchor="1"><img border="0" height="425" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjcAdl6Cksqe7eRVpr9ZqM2UhjWJCkRUgWOQK744eJvFHJzokAXiVe0YhJci5OonSzoVu2l7ejxdeUFb__MrevshTS58ebFzwptGntPqpk1-UuCXxCY8e-hPZPJ9Ag2zb9jkIE54qHq00jQ/s640/Captura+de+tela+de+2016-06-04+11-52-57.png" width="640" /></a></div>
<br />
<b><br /></b>
<b>Entendimento do código</b><br />
<br />
Esse método abaixo, irá chamar o método <span style="background-color: #eeeeee; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px;">wiringPiI2CRead</span> da biblioteca <span style="background-color: #eeeeee; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px;">wiringPiI2C</span> que retorna um inteiro (valor lido). Como queremos imprimir uma String, se simplesmente imprimíssemos os caracteres no console, poderíamos imprimir <i>llo I'm Duehe</i> ou o <i>I'm Duehello</i>, ou outra combinação, pois o arduíno irá enviar sequencialmente e infinitamente a sequencia de caracteres. Assim, adicionei um caractere de controle para indicar que a mensagem iniciará no próximo caractere e o código irá esperar que venha esse caractere para começar a gravar a mensagem.<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">void readI2CString(int fd, char*buffer,int length,char charController)
{
for(;;)//aguardando caractere de controle para guardar a mensagem
if(wiringPiI2CRead(fd)==charController)
break;
for(int i = 0; i < length; i++)//lendo mensagem
{
buffer[i]=wiringPiI2CRead(fd);
}
}</span></span></pre>
<br />
Aqui, a aplicação ficará em loop, lendo as mensagens de cada um dos Arduínos.<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">for (;;)
{
readI2CString(fd1,buffer,13,'*');//Lendo mensagem do dispositivo 40
buffer[13] = '\0';
printf("%s\n",buffer);
readI2CString(fd2,buffer,14,'*');//Lendo mensagem do dispositivo 50
buffer[14] = '\0';
printf("%s\n",buffer);
}</span></span></pre>
<br />
O Arduíno Duemilanove, que está com o endereço 0x40, irá enviar o caractere de controle '*' e a mensagem <i>hello I'm Due</i>, caractere a caractere (13 caracteres excluindo o de controle)<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">char * buff="*hello I'm Due";
byte count = 0;
void requestEvent()
{
Wire.write(buff[count]);
if(count == 13)
count = -1;
count ++;
}</span></span></pre>
<br />
O Arduíno Nano, que está com o endereço 0x50, irá enviar o caractere de controle '*' e a mensagem <i>hello I'm Nano</i>, caractere a caractere (14 caracteres excluindo o de controle)<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); overflow: auto; padding: 5px; width: 653px;"><span style="font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace;"><span style="font-size: 12px; line-height: 14px;">char * buff="*hello I'm Nano";
byte count = 0;
void requestEvent()
{
Wire.write(buff[count]);
if(count == 14)
count = -1;
count ++;
}</span></span></pre>
<br />
E por isso, no loop do Raspberry, ele esperará 13 caracteres do Duemianove e 14 do Nano.<br />
<br />
<br /></div>
</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-31920036309006216762016-06-12T13:59:00.000-03:002016-06-12T13:59:00.830-03:00Utilizando EEPROM I²C Com ArduínoOlá, neste post iremos explicar como utilizar uma memória externa EEPROM com o barramento I²C e com um Arduíno. Para mais informações sobre o I²C, consulte o post anterior (clique <a href="http://arduinoccbr.blogspot.com.br/2016/05/barramento-ic.html" target="_blank">aqui</a>).<br />
<br />
A EEPROM(Electrically-Erasable Programmable Read-Only) é uma memória que permite escrita e gravação e seus dados não são apagados quando não há energia. As memórias flash(pen driver, SD e outros), são uma evolução desse tipo de memória. A EEPROM pode ser utilizada para armazenar algumas informações do seu programa que precisam ser salvas quando não houver energia. Para mais informações sobre esse tipo de memória, consulte <a href="https://pt.wikipedia.org/wiki/EEPROM" target="_blank">aqui</a>.<br />
<br />
Os micro-controladores que estão presentes nas mais diversas versões do Arduíno, têm diferentes quantidades de memória EEPROM disponíveis.<br />
<br />
<ul>
<li>ATmega328 - 1KB (1024 bytes)</li>
<li>ATmega168 e ATmega8 - 512 bytes</li>
<li>ATmega1280 e ATmega2560 - 4 KB (4096 bytes)</li>
</ul>
<div>
É possível acessar a EEPROM dos micro-controladores e há uma biblioteca disponível para isso na própria IDE do Arduíno. A documentação pode ser encontrada <a href="https://www.arduino.cc/en/Reference/EEPROM" target="_blank">aqui</a>.</div>
<div>
<br /></div>
<div>
Mas, neste post, iremos focar no uso de EEPROMs externas que utilizam o barramento I²C para leitura e escrita.</div>
<div>
<br /></div>
<div>
Existem no mercado diversas marcas e modelos de memória, com os mais diversos tamanhos e para cada uma delas, há um protocolo definido para se comunicar e por isso, é difícil ter um código genérico de acesso. Esse exemplo funcionará para as EEPROMs do tipo 24C16,que são bem comuns. </div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh4JuGx1Fc5k5ixdn4QH0WdxoAcjjU3VDAmgZ8kPxp1geXjdldmLIL4SxBky1ep8CC43ik5GodM1E0OYDtr6VHpmtVen2iSKg4JUB4vG9KIxlbEiQXr9baNo1pTyq62RgN_8GeRKMRgyHZw/s1600/24C16WP-DIP8-.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="217" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh4JuGx1Fc5k5ixdn4QH0WdxoAcjjU3VDAmgZ8kPxp1geXjdldmLIL4SxBky1ep8CC43ik5GodM1E0OYDtr6VHpmtVen2iSKg4JUB4vG9KIxlbEiQXr9baNo1pTyq62RgN_8GeRKMRgyHZw/s320/24C16WP-DIP8-.jpg" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
EEPROM 24C16WP</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Essa memória tem 16 Kbits (2 Kbytes) de armazenamento, permitindo a leitura e escrita byte-a-byte ou em blocos (páginas). Aqui, iremos abordar a leitura e escrita byte-a-byte.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Montagem</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue a lista de materiais utilizados:</div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<ul>
<li>1 Memória EEPROM 24C16WP</li>
<li>1 Arduíno Uno</li>
<li>1 Protoboard</li>
<li>Alguns fios</li>
</ul>
<br />
<div>
Segue abaixo os pinos da memória:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi6V6I7OdOAV3YupFiLfJ9utMWy2PXB-VrkWO8KA62AkiYNeye2RKb6ga8gyZqHeNJ5ObUeeTAfsXEE1lEAuIDfJJxVCf2f5W243Kmh7Mxsm8e9yKjl6O5zl5HEs5apBjSkJF2q2Mt261lQ/s1600/24C16WP-Datasheet.gif" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="258" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi6V6I7OdOAV3YupFiLfJ9utMWy2PXB-VrkWO8KA62AkiYNeye2RKb6ga8gyZqHeNJ5ObUeeTAfsXEE1lEAuIDfJJxVCf2f5W243Kmh7Mxsm8e9yKjl6O5zl5HEs5apBjSkJF2q2Mt261lQ/s400/24C16WP-Datasheet.gif" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Pinagem 24C16WP</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Os pinos 6 (SCL) e 5 (SDA), são utilizados para o barramento I²C e devem ser conectados aos pinos analógicos do Arduíno A4 (SDA - Data ) e A5 (SCL - Clock)</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O endereçamento I²C da memória inicia em 0x50 e vai até 0x57. Os pinos NC são utilizados para o ajustar esse endereçamento se aterrados(GND) ou ligados ao VCC.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Exemplo:</div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<ul>
<li>NC - 0, NC - 0, NC - 0 -> Endereço da memória 0x50</li>
<li>NC - 0, NC - 0, NC - 1 -> Endereço da memória 0x51</li>
<li>NC - 0, NC - 1, NC - 0 -> Endereço da memória 0x52</li>
</ul>
<br />
<div class="separator" style="clear: both; text-align: left;">
Essa configuração é interessante, pois podemos colocar até 8 memórias no mesmo barramento.</div>
<div>
</div>
<br />
<div class="separator" style="clear: both;">
O pino 7(WC), é utilizado para indicar se a memória está protegida contra gravação ou não. Se "0" - ligado ao GND, a memória pode ser escrita. Se "1" - ligada ao VCC, protegida contra gravação.</div>
<div class="separator" style="clear: both;">
<br /></div>
<div class="separator" style="clear: both;">
Para o nosso exemplo, utlizaremos os pinos abaixo:</div>
<div class="separator" style="clear: both;">
<br /></div>
<div class="separator" style="clear: both;">
</div>
<table>
<tbody>
<tr>
<td><b>EEPROM
</b></td>
<td><b>Arduíno
</b></td>
</tr>
<tr>
<td>6(SCL)
</td>
<td>A5(SCL)
</td>
</tr>
<tr>
<td>5(SDA)
</td>
<td>A4(SDA)
</td>
</tr>
<tr>
<td>8(VCC)
</td>
<td>VCC
</td>
</tr>
<tr>
<td>4(VSS)
</td>
<td>GND
</td>
</tr>
<tr>
<td>7(WC)
</td>
<td>GND
</td>
</tr>
</tbody></table>
<div>
<br />
Segue abaixo do esquemático:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjzoU6PIqPIl6c-AI0SUF3b2the6BZpJsBlS0HOplwt80KnvvQZ4q4zMPC_yAxv4tKTjbPfc4Mxba_9qTIpJEgil1v1OGY3_KgJDXMwK8_JEFeg_4O8YYn9xbjW1s5AqHTaQaReW9dcBieZ/s1600/Esquema.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjzoU6PIqPIl6c-AI0SUF3b2the6BZpJsBlS0HOplwt80KnvvQZ4q4zMPC_yAxv4tKTjbPfc4Mxba_9qTIpJEgil1v1OGY3_KgJDXMwK8_JEFeg_4O8YYn9xbjW1s5AqHTaQaReW9dcBieZ/s400/Esquema.png" width="325" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Esquema feito no programa Fritzing</div>
<div class="separator" style="clear: both; text-align: left;">
Vamos ao programa:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"><code style="color: black; word-wrap: normal;">
#include ‹Wire.h›
#define i2cAddress 0x50 //Endereço da memoria
void setup(void)
{
Serial.begin(115200);
Wire.begin(); //inicializando I2C
int sizeBuf = 21;
char buf[sizeBuf] = "teste gravando eeprom";
Serial.print("Gravando... \n");
for(int i = 0; i < sizeBuf; i++)
{
writeI2CEEPROM(i2cAddress,i,buf[i]);
}
Serial.print("Lendo... \n");
for(int i = 0; i < sizeBuf; i++)
{
Serial.print((char)readI2CEEPROM(i2cAddress,i));
}
Serial.print("\nFim... \n");
}
void loop(){}
void writeI2CEEPROM(int i2cAddr, byte memoryAddress, byte data)
{
Wire.beginTransmission(i2cAddr);//iniciando barramento para o endereco I2C da memoria
Wire.write(memoryAddress);//informando endereco da memoria
Wire.write(data);//dados
Wire.endTransmission();//finalizando transmissao do emissor
delay(5);
}
byte readI2CEEPROM(int i2cAddr, byte memoryAddress)
{
byte data = 0xFF;
Wire.beginTransmission(i2cAddr);//iniciando barramento para o endereco I2C da memoria
Wire.write(memoryAddress);//informando endereco da memoria
Wire.endTransmission();//finalizando transmissao do emissor
Wire.requestFrom(i2cAddr,1);//avisando a memoria que espera-se dado (1 byte)
if (Wire.available()){
data = Wire.read();
}
return data;
}
</code>
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
No código acima, iremos escrever na memória a frase "teste gravando eeprom" e na sequência, os valores serão recuperados.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Vamos explicar alguns pontos do código.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">void writeI2CEEPROM(int i2cAddr, byte memoryAddress, byte data)
{
Wire.beginTransmission(i2cAddr);//iniciando barramento para o endereco I2C da memoria
Wire.write(memoryAddress);//informando endereco da memoria
Wire.write(data);//dados
Wire.endTransmission();//finalizando transmissao do emissor
delay(5);
}</code></pre>
<br />
O método writeI2CEEPROM tem três parâmetros:<br />
<br />
<ul>
<li>i2cAddr - Endereço I²C da memória</li>
<li>memoryAddress - endereço da memória (0 até 255)</li>
<li>data - byte que será gravado</li>
</ul>
<br />
Como já citado anteriormente, essa memória suporta até 2 Kbytes e por isso, ela terá 256 endereços para escrita e leitura (de 0 atá 255). Para escrever na memória, é necessário iniciar a transmissão, indicar o endereço da memória, enviar o byte e finalizar a transmissão. Esse protocolo, está definido no datasheet da memória, que pode ser consultado <a href="http://www.st.com/content/ccc/resource/technical/document/datasheet/a2/2d/80/cb/91/59/43/9a/DM00061111.pdf/files/DM00061111.pdf/jcr:content/translations/en.DM00061111.pdf" target="_blank">aqui</a>.<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"><code style="word-wrap: normal;">byte readI2CEEPROM(int i2cAddr, byte memoryAddress)
{
byte data = 0xFF;
Wire.beginTransmission(i2cAddr);//iniciando barramento para o endereco I2C da memoria
Wire.write(memoryAddress);//informando endereco da memoria
Wire.endTransmission();//finalizando transmissao do emissor
Wire.requestFrom(i2cAddr,1);//avisando a memoria que espera-se dado (1 byte)
if (Wire.available()){
data = Wire.read();
}
return data;
}
</code></pre>
<div>
<code style="word-wrap: normal;"><br /></code></div>
O método readI2CEEPROM tem dois parâmetros e retorna o byte gravado.<br />
<ul>
<li>i2cAddr - Endereço I²C da memória</li>
<li>memoryAddress - endereço da memória (0 até 255)</li>
</ul>
<div>
Assim como na escrita, o protocolo de leitura está definido no datasheet da memória mas, de maneira resumida temos: inicio da transmissão, envia-se o endereço, finalização a transmissão, requisita-se a resposta e faz-se a leitura do valor se estiver disponível.</div>
</div>
<div>
<br /></div>
<div>
Segue a saída desse programa:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgQXqNCB3HQ4hcxOOyrTJpuOKveGuHVhmYTtjpwnZTbf__OtflPYJxIo5EM4uUq5kXlMNulPjoMaGAff28ZAlKzwiQvcs-MBH2yuobQCWnX3ziINkkhgPAxTHjV_DbnuLXWBOKx9PPMTphM/s1600/GravandoLendo.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="243" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgQXqNCB3HQ4hcxOOyrTJpuOKveGuHVhmYTtjpwnZTbf__OtflPYJxIo5EM4uUq5kXlMNulPjoMaGAff28ZAlKzwiQvcs-MBH2yuobQCWnX3ziINkkhgPAxTHjV_DbnuLXWBOKx9PPMTphM/s400/GravandoLendo.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Para comprovar a a gravação, você pode comentar o trecho que faz a gravação. Ficando assim:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhZtJRLgETWpRxwKSVBjmPgaEjBXG5BW2Bf0913OuMSjI7kpr_JxXeI2L5ebPZ63TgO02GGmlYl4gyljoVwa1iUKCb_hLHwPoKLCMu5B5kfjGkStxBo5SvF72fDVTHaMKU7N8zssgXt6_uh/s1600/Lendo.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="243" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhZtJRLgETWpRxwKSVBjmPgaEjBXG5BW2Bf0913OuMSjI7kpr_JxXeI2L5ebPZ63TgO02GGmlYl4gyljoVwa1iUKCb_hLHwPoKLCMu5B5kfjGkStxBo5SvF72fDVTHaMKU7N8zssgXt6_uh/s400/Lendo.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div>
<br /></div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-38016035895212390792016-05-29T13:36:00.002-03:002016-06-04T09:02:01.708-03:00Barramento I²CNeste post falaremos um pouco sobre o barramento I²C, mostraremos um exemplo de como utilizá-lo e como fazer um scan no barramento, para descobrir o endereço de outros dispositivos I²C.<br />
<br />
<b>I²C</b><br />
<br />
Esse barramento foi desenvolvido para fazer a comunicação entre um dispositivo principal e seus periféricos. E por isso, que ele utiliza o conceito de Master/Slave onde, poderemos ter em um mesmo barramento um Master e "N" Slavers.<br />
<br />
O barramento define duas linhas de comunicação. Uma bidirecional para dados (SDA) e outra para o clock (SCL). O clock, irá controlará a velocidade e sincronismo de todos os dispositivos do barramento e será controlado pelo dispositivo Master.<br />
<br />
Como poderemos ter até 128 dispositivos Slavers no mesmo barramento, cada um deles precisa ter um endereço único para que possam se comunicar com o Master.<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9_Cm8h-K15cRbDvC58ejqE7io_18hB2M_ZQoRT8GlDmHA0Homv4LJhwBgQ9NC0C1wU6bLyj5C28hClYt7KZUkHCMnkchlwHQwjbNrSghmg3h9fIY90Vt9Er14PU8OBAu-FxASu2S9hvin/s1600/i2c-diagram.png" imageanchor="1"><img border="0" height="110" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9_Cm8h-K15cRbDvC58ejqE7io_18hB2M_ZQoRT8GlDmHA0Homv4LJhwBgQ9NC0C1wU6bLyj5C28hClYt7KZUkHCMnkchlwHQwjbNrSghmg3h9fIY90Vt9Er14PU8OBAu-FxASu2S9hvin/s320/i2c-diagram.png" width="320" /></a></div>
<br />
Para mais informações sobre o barramento, clique <a href="https://pt.wikipedia.org/wiki/I%C2%B2C" target="_blank">aqui</a>. De acordo com a especificação física do barramento, também deveremos ter resistores "pull-up" ligados aos pinos SDA e SCL. Mas, os pinos do Arduíno já têm esses resistores e para o nosso exemplo, não serão necessários. Para mais detalhes sobre resistores pull-up no barramento I²C, clique <a href="http://www.robot-electronics.co.uk/i2c-tutorial" target="_blank">aqui</a>.<br />
<br />
<b>Exemplo</b><br />
<b><br /></b>
Neste exemplo, iremos fazer uma comunicação entre 3 Arduínos onde, um deles será o Master e os outros dois os Slavers. Utilizaremos a biblioteca Wire (clique <a href="https://www.arduino.cc/en/Reference/Wire" target="_blank">aqui</a> para mais informações). Essa biblioteca implementa o protocolo I²C e está disponível na IDE do Arduíno. Já havia comentado sobre a biblioteca Wire no post sobre o uso do <a href="http://arduinoccbr.blogspot.com.br/2013/06/tiny-rtc-i2c-real-time-clock.html" target="_blank">Tiny RTC I2C Real Time Clock</a>.<br />
<br />
Segue a lista de materiais:<br />
<ul>
<li>1 Arduíno Uno</li>
<li>1 Arduíno Duemilanove</li>
<li>1 Arduíno Nano</li>
<li>1 Protoboard</li>
</ul>
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhkRb0pHNlsyIZr_qMOPOWKgnMPL_p0nggtwBfs3u3f27-yAxxXFtsX4IKgysZapcQ415Np1FK22FIHRHYt6KUyLhdxxT89rdV17I0DU0vpDV8MCWNo6ut7QJTcXiI48iRaJuGYxGI_XD6r/s1600/IMG_20160529_095205329.jpg" imageanchor="1"><img border="0" height="225" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhkRb0pHNlsyIZr_qMOPOWKgnMPL_p0nggtwBfs3u3f27-yAxxXFtsX4IKgysZapcQ415Np1FK22FIHRHYt6KUyLhdxxT89rdV17I0DU0vpDV8MCWNo6ut7QJTcXiI48iRaJuGYxGI_XD6r/s400/IMG_20160529_095205329.jpg" width="400" /></a></div>
<div style="text-align: center;">
Montagem</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
Como já falamos, o barramento utiliza 2 linhas de comunicação. Uma de dados e uma para o clock. No Arduíno, esses pinos são definidos respectivamente pelo pinos:</div>
<div style="text-align: left;">
<ul>
<li>A4 - SDA - Pino de dados</li>
<li>A5 - SCL - Pino para o clock</li>
</ul>
<div>
A ligação é muito simples. Basta ligar todos os pinos A4 juntos e todos os pinos A5 juntos. Segue abaixo o esquemático.</div>
<div>
<br /></div>
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjtbcdvplu9vcf6blVPbrxTAuNigFnt6c1H6BMuHwKLTT2ibJOermtkA8xU9LXR3WztP67OznbywRiDyZWGPE1dCE9oqKCS7bgdyp6ZsqQa9o3HiP2OQM5lZlQx2qWm7TDPyrrEvaE_yukJ/s1600/Captura+de+tela+de+2016-05-29+09-50-51.png" imageanchor="1"><img border="0" height="432" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjtbcdvplu9vcf6blVPbrxTAuNigFnt6c1H6BMuHwKLTT2ibJOermtkA8xU9LXR3WztP67OznbywRiDyZWGPE1dCE9oqKCS7bgdyp6ZsqQa9o3HiP2OQM5lZlQx2qWm7TDPyrrEvaE_yukJ/s640/Captura+de+tela+de+2016-05-29+09-50-51.png" width="640" /></a></div>
<div style="text-align: center;">
Esquemático feito no Fritzing</div>
<div style="text-align: center;">
<br /></div>
<div style="text-align: left;">
Nesse exemplo o UNO será o Master e Duemilanove e Nano serão os Slavers. Pode-se utilizar qualquer outro dispositivo, ou Arduíno.</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
<b>Código do Master</b></div>
<div style="text-align: left;">
<b><br /></b>
Esse código foi feito com base no exemplo "<i>master_reader</i>" da biblioteca Wire. Ele foi adaptado para se comunicar com 2 dispositivos Slaver.</div>
<div style="text-align: left;">
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹Wire.h›
void setup()
{
Wire.begin(); // join i2c bus (address optional for master)
Serial.begin(9600); // start serial for output
}
int device = 3;
void loop()
{
Wire.requestFrom(device, 14); // request 14 bytes from slave device
while (Wire.available()) // slave may send less than requested
{
char c = Wire.read(); // receive a byte as character
Serial.print(c); // print the character
}
Serial.print("\n");
delay(1000);
device++;
if(device >3)
device = 2;
}
</code></pre>
</div>
</div>
<div style="text-align: left;">
<b><br /></b></div>
<div style="text-align: left;">
Este programa irá requisitar 14 bytes dos dispositivos 2 e 3 e irá imprimir na serial string recebida.<br />
<b><br /></b>
<b>Código do Slaver 01 (Duemilanove)</b><br />
<br />
Esse código foi feito com base no exemplo "<i>slaver_sender</i>" da biblioteca Wire. Ele foi adaptado para enviar uma mensagem para o master e piscar o Led do pino 13.<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹Wire.h›
void setup()
{
Wire.begin(2); // join i2c bus with address #2
Wire.onRequest(requestEvent); // register event
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(1000);
}
// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent()
{
Wire.write("hello I'm Duem"); // respond with message of 14 bytes
// as expected by master
}
</code>
</pre>
<br />
Este programa irá enviar uma string para o master, quando requisitado.<br />
<b><br /></b>
<b>Código do Slaver 02 (Nano)</b><br />
<br />
A diferença entre o código abaixo e o anterior é somente o endereço (de 2 para 3) e a mensagem (de Duem para Nano).<br />
<pre style="background-color: #eeeeee; border: 1px dashed rgb(153, 153, 153); font-family: 'andale mono', 'lucida console', monaco, fixed, monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 653px;"> <code style="word-wrap: normal;">
#include ‹Wire.h›
void setup()
{
Wire.begin(3); // join i2c bus with address #3
Wire.onRequest(requestEvent); // register event
pinMode(13, OUTPUT);
}
void loop()
{
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(1000);
}
// function that executes whenever data is requested by master
// this function is registered as an event, see setup()
void requestEvent()
{
Wire.write("hello I'm Nano"); // respond with message of 14 bytes
// as expected by master
}
</code></pre>
<br />
Quando o console serial for aberto, conectado ao master, teremos a saída abaixo:<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi7C-ntOfxrPaCt_ehkMB78Mq7_MuTNagK7T4Qt_gCJRCdISU3nRhA1VVgYzNvg6ldla5C5Mj8VKCdMSOYixj-Ubq6R8y-7v3sThy9xVWOEMuTEVMD7ec0MRYGZWNSF0ACwLtKv6YiuffgH/s1600/Captura+de+tela+de+2016-05-29+09-33-05.png" imageanchor="1"><img border="0" height="242" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi7C-ntOfxrPaCt_ehkMB78Mq7_MuTNagK7T4Qt_gCJRCdISU3nRhA1VVgYzNvg6ldla5C5Mj8VKCdMSOYixj-Ubq6R8y-7v3sThy9xVWOEMuTEVMD7ec0MRYGZWNSF0ACwLtKv6YiuffgH/s400/Captura+de+tela+de+2016-05-29+09-33-05.png" width="400" /></a></div>
<div style="text-align: center;">
Saída Serial - Master</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
<b>Fazendo um Scan no Barramento</b></div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
No exemplo acima nós definimos os endereços dos dispositivos escravos. Mas, muitas vezes, quando utilizarmos dispositivos de terceiros (que já vem programados), precisaremos descobrir o endereço do dispositivo. Por exemplo, existe o sensor de temperatura da Dallas (Ds18b20), que utiliza o barramento I²C, ou uma memória EEPROM, ou para o <a href="http://arduinoccbr.blogspot.com.br/2013/06/tiny-rtc-i2c-real-time-clock.html" target="_blank">Tiny RTC I2C Real Time Clock</a>, já citado em outro post. Se não tivermos o datasheet do componente poderemos utilizar o código abaixo para descobrir o endereço.</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹Wire.h›
void setup()
{
Wire.begin();
Serial.begin(115200);
Serial.println("\nI2C Scanner");
}
void loop()
{
byte error, address;
int nDevices;
Serial.println("Scanning...");
nDevices = 0;
for(address = 1; address < 127; address++ )
{
// The i2c_scanner uses the return value of
// the Write.endTransmisstion to see if
// a device did acknowledge to the address.
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
Serial.print("I2C device found at address 0x");
if (address < 16)
Serial.print("0");
Serial.print(address,HEX);
Serial.println(" !");
nDevices++;
}
else if (error==4)
{
Serial.print("Unknow error at address 0x");
if (address < 16)
Serial.print("0");
Serial.println(address,HEX);
}
}
if (nDevices == 0)
Serial.println("No I2C devices found\n");
else
Serial.println("done\n");
delay(5000); // wait 5 seconds for next scan
}
</code></pre>
</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
O programa acima irá testar os endereços de 1 até 127 a cada 5 segundo e se houver uma resposta, irá imprimir na serial os endereços encontrados.<br />
<br />
Se carregarmos esse programa no UNO do exemplo anterior (Master), teremos a seguinte saída na serial:<br />
<br />
<div style="text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhCQBs5CfDphzHR-Rb7OeUoLkb724fOXJN9mhFgyabfOq1mN1zNvazdppQJOpiFSIBIL9uk_UD3v-_a5YrF5zxMGzz2VMnK17EfKLqG4ElVCYLPoXzx25iQIg6Tj4eJnDdr8tZmBoItozp0/s1600/Captura+de+tela+de+2016-05-29+10-50-49.png" imageanchor="1"><img border="0" height="243" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhCQBs5CfDphzHR-Rb7OeUoLkb724fOXJN9mhFgyabfOq1mN1zNvazdppQJOpiFSIBIL9uk_UD3v-_a5YrF5zxMGzz2VMnK17EfKLqG4ElVCYLPoXzx25iQIg6Tj4eJnDdr8tZmBoItozp0/s400/Captura+de+tela+de+2016-05-29+10-50-49.png" width="400" /></a> </div>
<div style="text-align: center;">
Saída serial do Scan.</div>
<div style="text-align: left;">
<br /></div>
<div style="text-align: left;">
Como pode-se ver, poderemos ligar vários dispositivos no barramento e só utilizaremos apenas dois pinos do Arduíno. Existe uma série de dispositivos e periféricos que utilizam esse barramento. </div>
</div>
</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com2tag:blogger.com,1999:blog-631927109914488620.post-88766989194985362822016-05-22T09:00:00.000-03:002016-05-22T09:00:20.444-03:00Usando Infravermelho para controlar um aparelho de TVOlá, neste post iremos mostrar como enviar e receber informações através de emissores e receptores de IR, para controlar um aparelho de TV.<br />
<br />
Segue lista de materiais utilizados:<br />
<ul>
<li>1 Arduíno nano</li>
<li>1 Arduíno UNO</li>
<li>1 Receptor de IR LNF</li>
<li>1 LED Emissor de IR</li>
<li>1 Resistor de 200 ohms</li>
<li>1 Protoboard</li>
<li>Alguns fios</li>
</ul>
<div>
Seguem as fotos dos sensores de IR:</div>
<div>
<br /></div>
<div>
Iremos montar a aplicação que faz a leitura e escreve na serial os códigos de IR do controle remoto de um aparelho de TV e depois, iremos montar uma aplicação que envia esses códigos para o aparelho de TV. Assim, você poderá controlar a sua TV ou outro equipamento através de um Arduíno.</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhjHlKsc1rx-UYgkscucYVCLXtn_x3d3_nhEoii0HfolYwLmd2rH3FAATOH6QhDGCOyPB8Oz06aMRRv9AMksRowzobh-dghyphenhyphenfPfzaqDQ11NXBCq7DO0_LJoHNpP7_4WYTGjys2Q8RJtfj4q/s1600/IR_Receiver_model.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhjHlKsc1rx-UYgkscucYVCLXtn_x3d3_nhEoii0HfolYwLmd2rH3FAATOH6QhDGCOyPB8Oz06aMRRv9AMksRowzobh-dghyphenhyphenfPfzaqDQ11NXBCq7DO0_LJoHNpP7_4WYTGjys2Q8RJtfj4q/s320/IR_Receiver_model.jpg" width="270" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Receptor LNF de IR</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEidflTXlHmKz_L1kQhWuQidFQdxSr_jXv51t4_yi0NZaKz_DC0aaSXtMrAVg4RlaA3YoggtmwR2kcnYj10gQe2QOEVCLg_qqMzHX2oFSsyCPMgaMtu6U2Wr34Ld0CBmSLD4PYFAgJPJhGjf/s1600/IR_Emitter.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEidflTXlHmKz_L1kQhWuQidFQdxSr_jXv51t4_yi0NZaKz_DC0aaSXtMrAVg4RlaA3YoggtmwR2kcnYj10gQe2QOEVCLg_qqMzHX2oFSsyCPMgaMtu6U2Wr34Ld0CBmSLD4PYFAgJPJhGjf/s320/IR_Emitter.jpg" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
LED Emissor de IR</div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<br class="Apple-interchange-newline" />Utilizaremos a biblioteca IRremote para enviar e receber os códigos em infravermelho. Para mais informações sobre ela, clique <a href="https://github.com/z3t0/Arduino-IRremote" target="_blank">aqui</a>.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo a documentação dos método da biblioteca, que utilizaremos. Para mais detalhes acesse <a href="https://www.pjrc.com/teensy/td_libs_IRremote.html" target="_blank">aqui</a>.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Receiving</b> </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both;">
<span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">IRrecv</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;"> irrecv(receivePin)</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Create the receiver object, using a name of your choice.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irrecv.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">enableIRIn</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">()</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Begin the receiving process. This will enable the timer interrupt which consumes a small amount of CPU every 50 µs.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irrecv.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">decode</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(&results)</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Attempt to receive a IR code. Returns true if a code was received, or false if nothing received yet. When a code is received, information is stored into "results".</div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 6em; padding-top: 0px;">
<b>results.decode_type</b>: Will be one of the following: <span style="color: #006699;">NEC</span>, <span style="color: #006699;">SONY</span>, <span style="color: #006699;">RC5</span>, <span style="color: #006699;">RC6</span>, or <span style="color: #006699;">UNKNOWN</span>.<br /><b>results.value</b>: The actual IR code (0 if type is UNKNOWN)<br /><b>results.bits</b>: The number of bits used by this code<br /><b>results.rawbuf</b>: An array of IR pulse times<br /><b>results.rawlen</b>: The number of items stored in the array</div>
<div style="background-color: white; font-family: Arial, Helvetica, sans-serif;">
</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irrecv.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">resume</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">()</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
After receiving, this must be called to reset the receiver and prepare it to receive another code.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irrecv.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">blink13</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">true</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">)</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Enable blinking the LED when during reception. Because you can't see infrared light, blinking the LED can be useful while troubleshooting, or just to give visual feedback.</div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white;"><br /></span></div>
<div class="separator" style="clear: both; text-align: left;">
<span style="background-color: white;"><b>Transmitting</b></span></div>
<div class="separator" style="clear: both;">
<span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">IRsend</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;"> irsend;</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Create the transmit object. A fixed pin number is always used, depending on which timer the library is utilizing.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irsend.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">sendNEC</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(IRcode, numBits);</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Send a code in NEC format.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irsend.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">sendSony</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(IRcode, numBits);</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Send a code in Sony format.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irsend.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">sendRC5</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(IRcode, numBits);</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Send a code in RC5 format.</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irsend.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">sendRC6</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(IRcode, numBits);</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Send a code in RC6</div>
<div class="separator" style="clear: both;">
<span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">irsend.</span><span style="background-color: white; color: #cc6600; font-family: Arial, Helvetica, sans-serif;">sendRaw</span><span style="background-color: white; font-family: Arial, Helvetica, sans-serif;">(rawbuf, rawlen, frequency);</span></div>
<div class="desc" style="background-color: white; font-family: Arial, Helvetica, sans-serif; font-size: 0.75em; padding-bottom: 0.8em; padding-left: 3em; padding-top: 0.2em;">
Send a raw code. Normally you would obtain the contents of rawbuf and rawlen by using the receiver many times and averaging the results. Some adjustments may be necessary for best performance. The frequency is the expected bandpass filter frequency at the receiver, where 38 is the most commonly used.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Cada fabricante utiliza um protocolo para codificar seus códigos de IR e temos basicamente os protocolos a seguir que são reconhecidos por essa biblioteca: NEC, SONY, RC5, RC6 e desconhecido(UNKNOWN) - para mais informações sobre os protocolos de IR, clique <a href="https://en.wikipedia.org/wiki/Consumer_IR" target="_blank">aqui</a>.</div>
<div class="separator" style="clear: both; text-align: left;">
<b><br /></b></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Leitor de IR</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o esquema de ligação do receptor de IR ao Arduíno Nano</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgl_dJBcXNPIYoIdoLyALEiaCBzx0bxeCtE6ICreUHb4MC1YFFUL29FEerorE6n5qEnLFmOoiWz9TeRPbm_PGNbYC5gRFn_Xno74PNNk7rZz66GwwgnyKLhLBNdF5WoA-aYgfAw3xxi5qdr/s1600/IR_Receiver.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgl_dJBcXNPIYoIdoLyALEiaCBzx0bxeCtE6ICreUHb4MC1YFFUL29FEerorE6n5qEnLFmOoiWz9TeRPbm_PGNbYC5gRFn_Xno74PNNk7rZz66GwwgnyKLhLBNdF5WoA-aYgfAw3xxi5qdr/s320/IR_Receiver.png" width="175" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: center;">
Esquema feito no aplicativo Fritzing</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O esquema é muito simples, dispensando uma protoboard. Segue abaixo a pinagem do sensor:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiCej3K9GBJKBMc0UM_gs36MJHuAl3CNgNq6ukIqgDXulPaS8KEMO4bMdOXTxpnb73n5P41zyPOa2l1ERW_qTLQdlf8EbM_wZDLzFb2ZBzmTKCX3IvAwsCENjwGzyG5piT4QTTbkyHkQIrc/s1600/IR+Receiver_Pin.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiCej3K9GBJKBMc0UM_gs36MJHuAl3CNgNq6ukIqgDXulPaS8KEMO4bMdOXTxpnb73n5P41zyPOa2l1ERW_qTLQdlf8EbM_wZDLzFb2ZBzmTKCX3IvAwsCENjwGzyG5piT4QTTbkyHkQIrc/s320/IR+Receiver_Pin.jpg" width="270" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Pinos do sensor LFN IR Receiver </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O pino 01(Out) do sensor será ligado ao pino D11 do Nano.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Vamos ao código para o Arduíno:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹irremote .h›
const int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup(void)
{
Serial.begin(115200);
irrecv.enableIRIn();
}
char buf[20];
void loop()
{
if (irrecv.decode(&results)) {
if (results.decode_type == NEC) {
Serial.print("NEC: ");
} else if (results.decode_type == SONY) {
Serial.print("SONY: ");
} else if (results.decode_type == RC5) {
Serial.print("RC5: ");
} else if (results.decode_type == RC6) {
Serial.print("RC6: ");
} else if (results.decode_type == UNKNOWN) {
Serial.print("UNKNOWN: ");
}
Serial.print(results.value, HEX);
Serial.print(" ");
Serial.print(" size: ");
Serial.println(results.bits);
irrecv.resume(); // Receive the next value
}
}
</code></pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
No programa acima, definimos o pino 11 como pino de leitura de dados. No setup é feita a inicialização do IR e serial e no loop, se houver dados, as informações serão impressas na serial (código e tamanho).</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Após a carga do programa, utilizei o controle da minha TV como emissor e anotei a saída dos principais botões dele. Segue abaixo um trecho da saída da Serial:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhS9jid2AOsg8zKr2YDisEmgcSzg1sWbMaQEzxDw7mORCn0dyTdYAX5MzwAAxeETeEpXQGJ347u2iGRIuPkrtmAwM3brOSbujKrA1X3Uo0tur22RT7fyFgTdOanHiT5qT1ZC0rZBXC-JaX4/s1600/Console_IR_Receiver.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="256" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhS9jid2AOsg8zKr2YDisEmgcSzg1sWbMaQEzxDw7mORCn0dyTdYAX5MzwAAxeETeEpXQGJ347u2iGRIuPkrtmAwM3brOSbujKrA1X3Uo0tur22RT7fyFgTdOanHiT5qT1ZC0rZBXC-JaX4/s640/Console_IR_Receiver.png" width="640" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div>
A minha TV é da marca Philips e ela utiliza o protocolo RC-5 para a transmissão de IR. Os códigos acima 0x80C e 0xC (em hexadecimal) são referentes a pressionar o botão power do controle. Ele envia alternadamente cada um desses comandos quando o botão é pressionado. Um deles liga e o outro desliga a TV.<br />
<br />
<b>Emissor de IR</b><br />
<br />
Agora vamos montar o emissor de IR. Segue abaixo o esquema de ligação.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjh8sh33qxjfK_v6gVU9Kq4Yus_6zYxnAthXl7vCPor-PFlPs5KxfN_OP-gVGB64SQ0PG_KxC8jQfT0y3pUPh48LhyvR-KaVNfAdev6VTGEMk7IUtFUOopmZJquxI2OHqVfYq1X5ndX_L8H/s1600/IR_Send.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjh8sh33qxjfK_v6gVU9Kq4Yus_6zYxnAthXl7vCPor-PFlPs5KxfN_OP-gVGB64SQ0PG_KxC8jQfT0y3pUPh48LhyvR-KaVNfAdev6VTGEMk7IUtFUOopmZJquxI2OHqVfYq1X5ndX_L8H/s400/IR_Send.png" width="378" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Esquema feito no aplicativo Fritzing</div>
<div>
<br /></div>
<div>
O resistor de 200 ohms é para evitar que o LED queime, pois ele não suporta 5V. Por padrão, a biblioteca de envio utiliza o pino D3 do Arduíno como pino de saída.<br />
<br />
Vamos ao programa:</div>
<div>
<br /></div>
<div>
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹IRremote.h›
//definicoes para TV PHILIPS
#define PHILIPS_LENGHT 12
#define BTN_PHILIPS_PWD_ON 0xC
#define BTN_PHILIPS_PWD_OFF 0x80C
#define BTN_PHILIPS_SOURCE_ON 0x838
#define BTN_PHILIPS_SOURCE_OFF 0x38
#define BTN_PHILIPS_SLEEP1 0x826
#define BTN_PHILIPS_SLEEP2 0x26
#define BTN_PHILIPS_VOLUP1 0x810
#define BTN_PHILIPS_VOLUP2 0x10
#define BTN_PHILIPS_VOLDOWN1 0x811
#define BTN_PHILIPS_VOLDOWN2 0x11
#define BTN_PHILIPS_MUTE1 0x80D
#define BTN_PHILIPS_MUTE2 0xD
int buff;
char cBuff[4];
int command[100];
int inicializado;
IRsend irsend;
void setup() {
//PHILIPS COMMANDS 0 - 19
command[0] = BTN_PHILIPS_PWD_ON;
command[1] = BTN_PHILIPS_PWD_OFF;
command[2] = BTN_PHILIPS_SOURCE_ON;
command[3] = BTN_PHILIPS_SOURCE_OFF;
command[4] = BTN_PHILIPS_SLEEP1;
command[5] = BTN_PHILIPS_SLEEP2;
command[6] = BTN_PHILIPS_VOLUP1;
command[7] = BTN_PHILIPS_VOLUP2;
command[8] = BTN_PHILIPS_VOLDOWN1;
command[9] = BTN_PHILIPS_VOLDOWN2;
command[10] = BTN_PHILIPS_MUTE1;
command[11] = BTN_PHILIPS_MUTE2;
Serial.begin(115200);
inicializado = 0;
}
void loop() {
while (Serial.available() >= 3)//loop de leitura/escrita da serial
{
cBuff[0] = Serial.read();
cBuff[1] = Serial.read();
cBuff[2] = Serial.read();
cBuff[3] = '\0';
Serial.read();
buff = atoi(cBuff);//convertendo char[] em int
Serial.write(cBuff);
if(inicializado==1)
{
//PHILIPS -> 0 - 19
if(buff <=19){
Serial.write("PHILIPS....\n");
irsend.sendRC5(command[buff],PHILIPS_LENGHT);
}
Serial.write("comando executado....\n");
}
if(buff == 999){
Serial.write("Aguardando comando....\n");
inicializado = 1;
}
if(buff== 998){
Serial.write("Nao aguardando comando....\n");
inicializado = 0;
}
}
}
</code></pre>
</div>
<div>
<br /></div>
<div>
Originalmente, esse programa estava preparado para os equipamentos da minha casa (TVs, Console da NET e Home Theater) e recebendo comandos via serial através de um Raspberry PI. Mas, para efeitos didáticos, eu deixei somente os códigos referentes a TV Philips, que estão definidos nos primeiros #define, onde temos o mapeamento de alguns comandos do controle da TV como: ligar/desligar, volume, mudo e outros. Além dos comandos da TV temos o 999 e 998 que habilitam ou não a interpretação de comandos.</div>
<br />
Os comandos são colocados em um array (command[100] na função setup). A aplicação fica em loop esperando dados na serial. A cada 3 bytes disponíveis na serial, ele os converte em número e utiliza esse número como índice do array (exceto 999 e 998) comandos e envia através do IR para a TV.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiJYVnTTy-KUlf1qSyAnoob04Uprm8HvkrURmrROuxIv04ECuS5t45O5B9LqT9A4F_ORIeJXQehVFP-Y0G8o0v6njvj08ZGiw4uway8PrYI7qoWPSy4pxVMvkNIb39v4zp2b09lRz5a-HRW/s1600/Console_IR_Send.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="256" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiJYVnTTy-KUlf1qSyAnoob04Uprm8HvkrURmrROuxIv04ECuS5t45O5B9LqT9A4F_ORIeJXQehVFP-Y0G8o0v6njvj08ZGiw4uway8PrYI7qoWPSy4pxVMvkNIb39v4zp2b09lRz5a-HRW/s640/Console_IR_Send.png" width="640" /></a></div>
<br />
Foram digitados os seguintes comandos na sequência: 999, 001, 000.<br />
<br />
<b>Observações</b><br />
<br />
Você pode utilizar o mesmo Arduíno para fazer ambos os projetos. Utilizei dois, por tê-los disponíveis.<br />
A princípio, é possível controlar qualquer dispositivo IR, bastando ler e reenviar o comando lido.<br />
Assim como temos um sensor receptor pronto, é possível achar um emissor "pronto", dispensando a protoboard e resistor.<br />
<br />
<br /></div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com2tag:blogger.com,1999:blog-631927109914488620.post-42815960114369316942016-05-15T06:00:00.000-03:002016-05-15T13:51:34.515-03:00Montando um ArduínoOlá, neste post iremos mostrar como montar um Arduíno bem simples. Você não precisa comprar um Arduíno para cada projeto seu. Basta que você tenha somente uma plaquinha original, ou uma Interface Serial-USB para poder gravar os programas e montar de acordo com as especificações abaixo.<br />
<br />
<br />
A versão mais comum do Arduíno, que é o Arduíno Uno, trabalha com um processador da Atmel, chamado de ATMEGA328-P PU. É um processador de 8bits com arquitetura RISC. Para maiores informações, clique <a href="https://en.wikipedia.org/wiki/ATmega328" target="_blank">aqui</a>. No processador, há a identificação do modelo e número de série e gravados na parte superior<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiDHK_lDbQYCUp6w23PhkXB7PN7Z33whbWGMcf_9tJx4dAL9QeDkiY4AnWteEPsV9n89_zVdem21X7PuWmTSmDJ3WlwanSRl_zURv5HyYE9IRsFswnmDaQGS-0uJjIe2GyL0frm9xA7T6oy/s1600/atmega328p.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em; text-align: center;"><img border="0" height="157" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiDHK_lDbQYCUp6w23PhkXB7PN7Z33whbWGMcf_9tJx4dAL9QeDkiY4AnWteEPsV9n89_zVdem21X7PuWmTSmDJ3WlwanSRl_zURv5HyYE9IRsFswnmDaQGS-0uJjIe2GyL0frm9xA7T6oy/s320/atmega328p.jpg" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<br />
<b>Versão Protoboard</b><br />
<br />
Segue lista de materiais utilizados:<br />
<ul>
<li>1 Capacitor eletrolítico de 100nF</li>
<li>2 Capacitores cerâmicos de 22 pF</li>
<li>1 Resistor de 10k</li>
<li>1 Cristal de 16MHz</li>
<li>1 Botão (Switch Momentary)</li>
<li>Uma Protoboard</li>
<li>1 Processador ATMEGA 328P-PU</li>
</ul>
<br />
<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgIrISCxk2GkSWwB1n3tsj4wh7CTmjIfOAdevZp_O079RyhD7KkDWotzmaCk_ViVXd6AhapufY0ist1bFxNupFtzwJk0Akf5mt3PM9SHs3u99s0X7xTEEslK79aOmRv9rVyOLiFLeX9Ioj9/s1600/IMG_20160514_074501434.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="223" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgIrISCxk2GkSWwB1n3tsj4wh7CTmjIfOAdevZp_O079RyhD7KkDWotzmaCk_ViVXd6AhapufY0ist1bFxNupFtzwJk0Akf5mt3PM9SHs3u99s0X7xTEEslK79aOmRv9rVyOLiFLeX9Ioj9/s400/IMG_20160514_074501434.jpg" width="400" /></a></div>
<div style="text-align: center;">
Placa montada e programa "Blink Led" gravado</div>
<div style="text-align: center;">
<span style="text-align: left;"><br /></span>
<span style="text-align: left;"><br /></span>
</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgzOLx-mn9vBBrM69J9i0xGkt7f9ErZBOvxmFqzmUivTGLkoVseqeG2KeqhEDexukGOKZsCi45qfgCvQQDONap3myDauHD_zu-vu-cjNEZQ1_cISDsU3npj6Rx3cIP3cBskuf0VFKgbQuO8/s1600/Arduino-To-Atmega8-Pins.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="260" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgzOLx-mn9vBBrM69J9i0xGkt7f9ErZBOvxmFqzmUivTGLkoVseqeG2KeqhEDexukGOKZsCi45qfgCvQQDONap3myDauHD_zu-vu-cjNEZQ1_cISDsU3npj6Rx3cIP3cBskuf0VFKgbQuO8/s400/Arduino-To-Atmega8-Pins.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Mapeamento dos pinos do processador</div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Se observarmos, os pinos do processador são mesmos pinos que estão disponíveis na placa do Arduíno. As analógicas A0-A5, as digitais D0(RX),D1(TX) a D13, VCC, GND e outros.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o esquema de montagem feito no programa Fritzing (mais informações, clique <a href="http://fritzing.org/" target="_blank">aqui</a>)</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi90DVbyY-j9KEzXc78YpNF5dhmAzcoMHizLD9cwQByK0B_l4IpDq8TxRlbj46vXmHzSj9eJz0AFDHCjktdfXnEbr0hfuCZCqaivl6I-I6q97gnqhagwxZ8tXuMyDDkYEJtOpw7tEDtACDe/s1600/Fritzing.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="253" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi90DVbyY-j9KEzXc78YpNF5dhmAzcoMHizLD9cwQByK0B_l4IpDq8TxRlbj46vXmHzSj9eJz0AFDHCjktdfXnEbr0hfuCZCqaivl6I-I6q97gnqhagwxZ8tXuMyDDkYEJtOpw7tEDtACDe/s400/Fritzing.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Diagrama da montagem do processador e seus componentes na placa</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Versão Montada na Placa</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div style="text-align: left;">
Segue lista de materiais utilizados:</div>
<div style="text-align: left;">
</div>
<ul>
<li>Além dos componentes utilizados no item anterior (exceto a protoboard);</li>
<li>Placa para circuito eletrônico</li>
<li>Soquete para ATMEGA328-P</li>
<li>Barras de pinos</li>
<li>Material de solda</li>
<li>Fios </li>
</ul>
<br />
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
A disposição dos componentes seguir esquema feito no software Fritzing, já citado.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhO9h1qakX6dgC9YNwTDx1yeYIBHIn6vNzVQiDj9z8Sm3ELEUKbl2CkUPB0c_oVpSUs0_yxr1cfepBjDeXgTBOrXUF8TSt_sncL503wFy3Zpc3llN_cs_BJNwpIZf-_0WMNGgRhCACTEjbO/s1600/IMG_20160514_082444454.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="358" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhO9h1qakX6dgC9YNwTDx1yeYIBHIn6vNzVQiDj9z8Sm3ELEUKbl2CkUPB0c_oVpSUs0_yxr1cfepBjDeXgTBOrXUF8TSt_sncL503wFy3Zpc3llN_cs_BJNwpIZf-_0WMNGgRhCACTEjbO/s640/IMG_20160514_082444454.jpg" width="640" /></a></div>
<br />
<div style="text-align: center;">
Lado da frente da placa .</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjPaG32p-RcZLBbHIoMjoOqSXF7-RTRP3TDmzu8nfNYJXKUCWLUp-iZLjFat4GbOYIxfVhwYXm4ySj6mbYzFbcmuBlevlxxGp84laexmgcLLDL7kFJPegTN8KOG9UES0F1I6r0UWY0xKHcZ/s1600/IMG_20160514_082457858.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="358" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjPaG32p-RcZLBbHIoMjoOqSXF7-RTRP3TDmzu8nfNYJXKUCWLUp-iZLjFat4GbOYIxfVhwYXm4ySj6mbYzFbcmuBlevlxxGp84laexmgcLLDL7kFJPegTN8KOG9UES0F1I6r0UWY0xKHcZ/s640/IMG_20160514_082457858.jpg" width="640" /></a></div>
<br />
<div style="text-align: center;">
Verso da Placa.</div>
<br />
<b>Gravando o Software</b><br />
<br />
A gravação do software pode ser feita de duas maneiras:<br />
<ol>
<li>Utilizando um Arduíno</li>
<li>Utilizando uma interface Serial-USB</li>
</ol>
1. Utilizando um Arduíno<br />
<br />
A maneira mais simples, que é usar uma placa de um Arduíno, removendo o processador atual e trocando pelo que se deseja gravar. Pode-se ter somente uma placa Arduíno e gravar em "n" processadores. Utilizando a placa do Arduíno como um "gravador".<br />
<br />
2.Utilizando uma interface Serial-USB<br />
<br />
Pode-se utilizar um adaptador Serial USB para fazer a comunicação entre seu Arduíno montado e o PC ( a placa do Arduíno já tem um embutido).<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi3TeSfh5fCAwG0WrmCVJ6pfvz0dyeIQGzbiKGY03hhXs7_7BXpeOTfwX3r4qjw309pDTNXLDjBrmG0J6o8-uBdZpa-W9AItWWOVPDJrafx04HH3a7VsMJ_W1XRl6MerWv4xZpvJhMsFUQr/s1600/SerialUSB-controller.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="105" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi3TeSfh5fCAwG0WrmCVJ6pfvz0dyeIQGzbiKGY03hhXs7_7BXpeOTfwX3r4qjw309pDTNXLDjBrmG0J6o8-uBdZpa-W9AItWWOVPDJrafx04HH3a7VsMJ_W1XRl6MerWv4xZpvJhMsFUQr/s320/SerialUSB-controller.jpg" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Basta ligar os pinos de acordo com a tabela abaixo:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<table>
<tbody>
<tr>
<td><div style="text-align: center;">
Serial USB
</div>
</td>
<td><div style="text-align: center;">
Arduino Montado
</div>
</td>
</tr>
<tr>
<td><div style="text-align: center;">
GND
</div>
</td>
<td><div style="text-align: center;">
GND
</div>
</td>
</tr>
<tr>
<td><div style="text-align: center;">
5V
</div>
</td>
<td><div style="text-align: center;">
VCC
</div>
</td>
</tr>
<tr>
<td><div style="text-align: center;">
TX
</div>
</td>
<td><div style="text-align: center;">
RX
</div>
</td>
</tr>
<tr>
<td><div style="text-align: center;">
RX
</div>
</td>
<td><div style="text-align: center;">
TX
</div>
</td>
</tr>
<tr>
<td><div style="text-align: center;">
RST
</div>
</td>
<td><div style="text-align: center;">
RST
</div>
</td>
</tr>
</tbody></table>
<br />
<b><br /></b>
<b>Boot Loader</b><br />
<b><br /></b>
Quando compramos somente o processador, ele vem de fábrica sem nenhum conteúdo. Vem "zerado" e por isso, que precisamos a primeira vez gravar um bootloader. Esse software que gravamos no Arduíno, de maneira bem resumida, irá fazer a comunicação com a IDE o Arduíno e irá gravar os nossos programas na flash do processador.(Mais detalhes <a href="https://www.arduino.cc/en/Hacking/Bootloader?from=Tutorial.Bootloader" target="_blank">aqui</a>)<br />
<br />
As últimas versões da IDE do Arduíno tem uma opção no menu de "Ferramentas", chamada "Gravar Bootloader", que pode ser usada para gravar o bootloader.<br />
<br />
<br />Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-13935281388836723112016-05-08T09:41:00.000-03:002016-05-08T22:51:51.155-03:00Integrando o Arduíno com Raspberry PI via Interface SerialNesse artigo, iremos mostrar como integrar um Arduíno com o Raspberry PI 2 através da interface serial, fazendo o LED do pino 13 do Arduíno piscar baseado em um comando enviado pelo Raspberry PI.<br />
<br />
Segue abaixo a lista de materiais utilizados:<br />
<br />
<ul>
<li>Raspberry PI 2 - clique <a href="https://www.raspberrypi.org/products/raspberry-pi-2-model-b/" target="_blank">aqui</a> ver a especificação oficial;</li>
<li>Arduíno UNO;</li>
<li>2 Resistores de 10K;</li>
<li>Protoboard;</li>
<li>Alguns fios.</li>
</ul>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2Y0RZzUoAr1vMQLjubSDIMSmjJPzUsNFhAJRI7FmQUPAq4xhJ6RFFXnssWLVkCQfIiObE2qQ5RN_lOg996ARskJKNUq18f8T3iTa_u7x6Qs0zFAqf_lMu1YSZMEMXmnOZEPP_uwr5cApB/s1600/Montagem.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="224" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2Y0RZzUoAr1vMQLjubSDIMSmjJPzUsNFhAJRI7FmQUPAq4xhJ6RFFXnssWLVkCQfIiObE2qQ5RN_lOg996ARskJKNUq18f8T3iTa_u7x6Qs0zFAqf_lMu1YSZMEMXmnOZEPP_uwr5cApB/s400/Montagem.jpg" width="400" /></a></div>
<div style="text-align: center;">
Foto do projeto montado</div>
<div style="text-align: center;">
<br /></div>
<div>
<br /></div>
<div>
No Raspberry utilizado, foi instalada a última versão do sistema operacional disponibilizado pelo <a href="https://www.raspberrypi.org/downloads/noobs/" target="_blank">NOOBS(clique aqui)</a> - Raspibian, que até a escrita desse artigo estava na Versão 1.9.0 de 18/03/2016. Não iremos abordar a instalação e configuração do Raspberry.</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgi451eaLwl_x_rTxitpV_h3l6AtXZ-pArnfs6kEzt8BC8qwr_FDqSmU09W4QRngRhFcy04ELGCCEc9R3caVNpGBq71Nzcbw8o2atEDfkHhXb05Xg82hH3npOUKtzAIriEUt1rjUM-1Fo7M/s1600/Raspberry_pi_2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="211" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgi451eaLwl_x_rTxitpV_h3l6AtXZ-pArnfs6kEzt8BC8qwr_FDqSmU09W4QRngRhFcy04ELGCCEc9R3caVNpGBq71Nzcbw8o2atEDfkHhXb05Xg82hH3npOUKtzAIriEUt1rjUM-1Fo7M/s320/Raspberry_pi_2.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
Raspberry PI 2</div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Esquema elétrico</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
A Serial do Raspberry está definida nos pinos 14 - TX e 15 - RX, figura abaixo, e iremos utilizar além desses o Ground (qualquer um deles). </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi1QVYFaTBk9sEI7mYUCz-FjqcMBz8MLi5nhYonvXOgrJXkiGjBKQ2WdMK3R8ZIDOx_qIAyv1WMoATDPRtxQXSSaK7VM992-cVkU06e1u5M1iZnAGn2c-5DgL8XRK2myEVEVtLwg3gEBhv5/s1600/gpio-numbers-pi2.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="95" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi1QVYFaTBk9sEI7mYUCz-FjqcMBz8MLi5nhYonvXOgrJXkiGjBKQ2WdMK3R8ZIDOx_qIAyv1WMoATDPRtxQXSSaK7VM992-cVkU06e1u5M1iZnAGn2c-5DgL8XRK2myEVEVtLwg3gEBhv5/s320/gpio-numbers-pi2.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
A documentação completa dos pinos pode ser encontrada <a href="https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/" target="_blank">aqui</a>.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
No Arduíno, iremos utilizar também os pinos TX, RX e Ground, que estão definidos na própria placa.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgt96F1iM7cfdJfMATgG3tN6LR5jMyGdC0YhTxOvPsIwJgfTN011P4O8D6Scpd3NyaSNIyzJbhsVCJesUpk9Vo-_5uCTZGuu-hsRVSZxO3FKJIHeWrLjROt9ejLknaOAyukAL-k0Rkoc2JS/s1600/ArduinoUNO.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="231" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgt96F1iM7cfdJfMATgG3tN6LR5jMyGdC0YhTxOvPsIwJgfTN011P4O8D6Scpd3NyaSNIyzJbhsVCJesUpk9Vo-_5uCTZGuu-hsRVSZxO3FKJIHeWrLjROt9ejLknaOAyukAL-k0Rkoc2JS/s320/ArduinoUNO.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
De maneira resumida, no padrão RS-232 (para mais informações sobre a interface serial e protocolo RS-232, clique <a href="https://pt.wikipedia.org/wiki/RS-232" target="_blank">aqui</a>), os dispositivos que irão conversar devem ter um pino TX e um RX. Onde o TX é o pino emissor e o RX é o pino receptor. Partindo desse princípio, bastaria ligar o TX do Raspberry no RX do Arduíno e ligar o TX do Arduíno no RX do Raspberry. </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Mas, há um porém.O Arduíno trabalha a 5V e o Raspberry a 3,3V. Se ligarmos o TX do Arduíno no RX do Raspberry, poderemos <b>queimar o pino</b>, pois o Arduíno irá enviar 5V e o Raspberry espera até 3,3V. O contrário, não é problema (TX do Raspberry com RX do Arduíno). Pois o Arduíno espera até até 5V e o Raspberry irá enviar até 3,3V.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Para resolver esse problema utilizaremos um circuito divisor de tensão bem simples com dois resistores de 10K entre a ligação do TX do Arduíno com o RX do Raspberry.</div>
<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjYD7nk8BH1N78JO0otwaQGJq8f-1L2Qj5yT36j4ucmgw2Bh-IZ1q0yVuImeJqmPL1SFZ1WISocx2Apn0flZPdMNZiTwmC4DsQ3ZwDyKj1P-DTF5yRYN_y3iVl19QUYAH2n_mJ8-L9_NHA0/s1600/DivisorTensao.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="266" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjYD7nk8BH1N78JO0otwaQGJq8f-1L2Qj5yT36j4ucmgw2Bh-IZ1q0yVuImeJqmPL1SFZ1WISocx2Apn0flZPdMNZiTwmC4DsQ3ZwDyKj1P-DTF5yRYN_y3iVl19QUYAH2n_mJ8-L9_NHA0/s320/DivisorTensao.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
Dessa forma, a tensão que vier do Arduíno, será divida entre o Raspberry e o GND(Ground).</div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o diagrama completo:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhiN9ng_6oWcL1KWacG-qxzayS-dXgs9-5GSXnYtjCYayltTUYRL4Sw6cof1IHH4EGrdfyC3pRgBmMYHPY4ZnrX-eBDBzKHWRQFv9oseXbFcpQeFnP36hnsiocLFUhKeBhwxON2mv9l9Y0D/s1600/EsquemaCompleto.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="296" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhiN9ng_6oWcL1KWacG-qxzayS-dXgs9-5GSXnYtjCYayltTUYRL4Sw6cof1IHH4EGrdfyC3pRgBmMYHPY4ZnrX-eBDBzKHWRQFv9oseXbFcpQeFnP36hnsiocLFUhKeBhwxON2mv9l9Y0D/s640/EsquemaCompleto.png" width="640" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Programação</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O programa do Arduíno é bem simples. Temos um loop que enquanto a serial estiver disponível, esperará o caractere "L" pela serial. A cada "L", ele altera o estado do LED de acordo com a variável "state" e responde pela serial o estado do LED (LED Ligado ou Desligado). O programa foi compilado e embarcado usando a IDE oficial do Arduíno.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Fonte para o Arduíno</div>
<div class="separator" style="clear: both;">
<br /></div>
<div class="separator" style="clear: both;">
</div>
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#define PIN_LED 13
char buff;
char state = 1;
void setup()
{
pinMode(PIN_LED, OUTPUT);//Inicializa o Pino 13 como saida
Serial.begin(115200);//Inicializando a serial em 115200
}
void loop()
{
while (Serial.available() > 0)//loop de leitura/escrita da serial
{
buff = Serial.read();
if (buff == 'L')// se caractere 'L' (LED) vindo na serial
{
// Liga/Desliga o LED com base no state ( 0 - LOW, 1 - HIGH)
digitalWrite(PIN_LED, state);
// Avisa o receptor do status de LED
Serial.print("Led: ");
if (state)
{
Serial.println("Ligado");
}
else
Serial.println("Desligado");
}
state = !state;
}
}
</code>
</pre>
<br />
No Raspberry, criaremos um programa em C que inicializa a serial, envia infinitamente o caractere "L" a cada segundo, logando basicamente o estado do LED pelo console (informado pelo Arduíno).<br />
<br />
Fonte em C para o Raspberry<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
#include ‹unistd.h› //Usado na serial
#include ‹fcntl.h› //Usado na serial
#include ‹termios.h› //Usado na serial
int uart = -1;
int main(){
//Abrindo a Serial do raspberry para leitura e escrita
uart = open("/dev/ttyAMA0",O_RDWR|O_NOCTTY|O_NDELAY);
if(uart == -1)
printf("Erro ao abrir UART\n");
//setup da serial
struct termios options;
options.c_cflag= B115200|CS8|CLOCAL|CREAD;
options.c_iflag= IGNPAR;
options.c_oflag= 0;
options.c_lflag= 0;
tcflush(uart,TCIFLUSH);
tcsetattr(uart,TCSANOW,&options);
unsigned char tx_buff[1];//buffer de envio
tx_buff[0] = 'L';
unsigned char rx_buff[256];//buffer de leitura
int rx_len = 0;
while(1)//loop infinito
{
printf("preparando para escrever\n");
if(uart != -1 )//send bytes
{
int count = write(uart,&tx_buff[0],1);//escrevendo na serial
if(count < 0)
printf("Erro de escrita\n");
else
printf("mensagem enviada\n");
rx_len = read(uart,(void*)rx_buff,255);//lendo da serial, até 255 bytes
if(rx_len > 0 )
{
rx_buff[rx_len] = '\0';
printf("Recebido - %s\n",rx_buff);
}
}
else{
printf("Erro ao escrever na serial");
}
sleep(1);//pausa a cada 1 segundo
}
close(uart);
printf("fim\n");
return 0;
}
</code>
</pre>
<br />
Para mai detalhes sobre a inicialização da Serial(UART) em C no Raspberry, clique <a href="http://www.raspberry-projects.com/pi/programming-in-c/uart-serial-port/using-the-uart" target="_blank">aqui</a>.<span id="goog_683464911"></span><span id="goog_683464912"></span><a href="https://www.blogger.com/"></a><br />
<br />
O programa foi compilado usando o compilador <i><b>G++</b></i> nativo da instalação do Raspberry, com a linha de comando abaixo:<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
g++ Serial.cpp -o ardSerial
</code>
</pre>
<br />
e executado com a linha:<br />
<br />
<pre style="background-color: #eeeeee; border: 1px dashed #999999; color: black; font-family: "andale mono" , "lucida console" , "monaco" , "fixed" , monospace; font-size: 12px; line-height: 14px; overflow: auto; padding: 5px; width: 100%;"> <code style="color: black; word-wrap: normal;">
./ardSerial
</code>
</pre>
<br />
Segue abaixo um print do console:<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj8XABP26xj3I4-83G9uLK6eTYzyRpkViQm8oSxBVaEuDBm7iY-iQzjax_v7SfHl7XYIe39kYjhFOxobUcseTofW2Emd5bNrjyudNPvRc1SCQnkZpfnRg6ncTfBE_qIzrXBIN5u7QcJ2YnV/s1600/Saida_Serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj8XABP26xj3I4-83G9uLK6eTYzyRpkViQm8oSxBVaEuDBm7iY-iQzjax_v7SfHl7XYIe39kYjhFOxobUcseTofW2Emd5bNrjyudNPvRc1SCQnkZpfnRg6ncTfBE_qIzrXBIN5u7QcJ2YnV/s400/Saida_Serial.png" width="270" /></a></div>
<br />
Um detalhe importante. Por default, a Serial do Raspberry vem configurada para ficar logando informações para um console. O programa acima irá falhar na abertura da Serial se essa funcionalidade não for desabilitada.<br />
<br />
O passo-a-passo de como desabilitar a o console Serial no Raspberry pode ser encontrado <a href="https://www.cube-controls.com/2015/11/02/disable-serial-port-terminal-output-on-raspbian/" target="_blank">aqui</a>.<br />
<br />
O programa para o Raspberry pode ser escrito em qualquer outra linguagem, como python, por exemplo.<br />
<br />
<br />
<br />Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-27806500834587610212013-06-11T22:31:00.000-03:002013-06-11T22:31:33.577-03:00Motor ServoOlá, neste artigo iremos mostrar como utilizar um motor servo com o arduino. Esse motor tem uma série de engrenagens e uma placa controladora onde é possível controlar o ângulo do seu eixo. Por exemplo, pode-se indicar que o mesmo gire 45, 90, 180 graus, etc... Esse tipo de motor é muito utilizado em robótica, para fazer articulações em robores. Segue abaixo uma foto do mesmo. Você pode utilizá-lo para girar uma câmera ou um sensor ultrasônico, explicado no artigo <a href="http://arduinoccbr.blogspot.com.br/2013/06/ola-neste-artigo-iremos-explicar-como.html" target="_blank">anterior</a>.<br />
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<br />
<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh-vUeGNXbjWezH3mZLItwyYR_JUVigzrnhyphenhyphen7dA2oDBs0CR7BEPbfZZeXSp0mNUrlzJhU8p9Y_8SN5TKNl5p4JgJZ8Ubs1-I4KZKfH4HvYFt5tmW4nqPMhGFLfygnSMBh_7zZQ30AYvCl5R/s1600/servo-motor-9g-tower-pro-sg90-arduino_MLB-F-4269153751_052013.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh-vUeGNXbjWezH3mZLItwyYR_JUVigzrnhyphenhyphen7dA2oDBs0CR7BEPbfZZeXSp0mNUrlzJhU8p9Y_8SN5TKNl5p4JgJZ8Ubs1-I4KZKfH4HvYFt5tmW4nqPMhGFLfygnSMBh_7zZQ30AYvCl5R/s1600/servo-motor-9g-tower-pro-sg90-arduino_MLB-F-4269153751_052013.jpg" height="240" width="320" /></a></div>
<br />
Para esse projeto, utilizaremos a biblioteca <b>Servo </b>disponibilizada na IDE do arduino. Para maiores detalhes sobre ela, clique <a href="http://arduino.cc/en/reference/servo" target="_blank">aqui</a>.<br />
<br />
Esse motores vêm com 3 fios onde normalmente temos um vermelho(VCC) que deve ser ligado na alimentação do arduino em 5V, um preto ou marrom que deve ser ligado ao terra(GND) e um amarelo ou laranja (DADOS), que deve ser ligado para esse exemplo ao pino digital 9 do arduino.<br />
<br />
A seguir um código-exemplo. Este código irá mover o eixo do motor a cada 2 segundos, alternando entre 45 e 135 graus.<br />
<br />
<pre class="brush: cpp">#include <Servo.h>
#define SERVO 9
Servo servoMotor;
void setup()
{
servoMotor.attach(SERVO);//pino de dados do motor
servoMotor.write(90);//iniciando em 90 graus
}
void loop()
{
delay(2000);
servoMotor.write(45);//indo ate 45 graus
delay(2000);
servoMotor.write(135);//indo ate 135 graus
}
</pre>
<br />
<br />
Segue uma imagem do motor ligado ao arduino.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2Z7dFndUGDe_OCib3ObRUAa9SFO4la1AiVyyaKY2SkNyj2nbnfyBErlDLC1AsvQV8_9sjuleue_TA3EqEVcQjZ_hhIWD_KAHCL0EBt9mpA22WkoV_XnOH6EdrPKYzA41WYKL-1cMVKebT/s1600/photo.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg2Z7dFndUGDe_OCib3ObRUAa9SFO4la1AiVyyaKY2SkNyj2nbnfyBErlDLC1AsvQV8_9sjuleue_TA3EqEVcQjZ_hhIWD_KAHCL0EBt9mpA22WkoV_XnOH6EdrPKYzA41WYKL-1cMVKebT/s1600/photo.JPG" height="240" width="320" /></a></div>
<br />
<br />
Até a próxima. <br />
<br />
<br />Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-55810332192978618882013-06-11T21:55:00.001-03:002013-06-11T22:09:02.349-03:00Sensor UltrasônicoOlá, neste artigo iremos explicar como utilizar um sensor ultrasônico HY-SRF05 com o arduino.<br />
<br />
Este sensor (figura abaixo) funciona como um sonar, onde o mesmo calcula a distancia a partir do tempo que uma onda sonora emitida por ele leva para sair do sensor e voltar, refletida por algum objeto. Com isso, teremos a distância entre o sensor e o objeto que refletiu o som emitido.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhV_v8ean3NVZ9pmwYGOjo6OxF7vlaekx5AY3bG3__z6IICPOeEBeeAhlvES_qrYHtGl3yUoJnzPaGGLR59SKhMNOH3qo0ukoZiys-hpWUZ0mT8ls2Aohfz6ZWusgxowkXcwF5E_Xlgr_aB/s1600/HY_SRF05.jpeg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhV_v8ean3NVZ9pmwYGOjo6OxF7vlaekx5AY3bG3__z6IICPOeEBeeAhlvES_qrYHtGl3yUoJnzPaGGLR59SKhMNOH3qo0ukoZiys-hpWUZ0mT8ls2Aohfz6ZWusgxowkXcwF5E_Xlgr_aB/s1600/HY_SRF05.jpeg" height="218" width="320" /></a></div>
<br />
Faremos uma aplicação que ficará medindo a distância a cada segundo. Para isso, utilizaremos a biblioteca <b>NewPing</b>. Para mais informações sobre ela clique <a href="http://playground.arduino.cc/Code/NewPing" target="_blank">aqui</a>.<br />
<br />
Ligue os pinos VCC(5V) e GND aos pinos do arduino. O pino TRIG ao pino digital 6 e o pino ECHO ao pino 5. <br />
<br />
Segue abaixo um código-exemplo para esse projeto.<br />
<br />
<pre class="brush: cpp">#include <NewPing.h>
#define TRIG_PIN 6
#define ECHO_PIN 5
#define DISTANCIA_MAX 100
//API utilizada para acionar o sonar
NewPing sonar(TRIG_PIN, ECHO_PIN, DISTANCIA_MAX);//Distancia em cm
float distancia = 0.0;
void setup(void)
{
Serial.begin(9600);
}
void loop()
{
distancia = sonar.ping()/US_ROUNDTRIP_CM;//Calculando em cm
Serial.print("Distancia em cm:");
Serial.println(distancia);
delay(1000);//A distancia sera calculada a cada segundo
}
</pre>
<br />
A seguir, a saída serial. Aproxime e afaste a mão na frente do sensor e observe a saída do console serial.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEitx_F3XA8bhqN5R06hXzhkXAbQ-WnDk_3_RD_vrqXw3xzyDRY3461G-yBCRVDO1dLfNeIvXvCoxGUIS-MfcovjpFrPgLNZDm90OT-SHSNY60uRgFVfg3lBU3rSGNOdVOUjybfmjpCnWo6x/s1600/Serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEitx_F3XA8bhqN5R06hXzhkXAbQ-WnDk_3_RD_vrqXw3xzyDRY3461G-yBCRVDO1dLfNeIvXvCoxGUIS-MfcovjpFrPgLNZDm90OT-SHSNY60uRgFVfg3lBU3rSGNOdVOUjybfmjpCnWo6x/s1600/Serial.png" height="185" width="320" /></a></div>
<br />
Abaixo uma foto do sensor ligado ao arduino. Você pode utilizar mais de um sensor, bastando ligar os pinos TRIG e ECHO a outros pinos do arduino.<br />
<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjM6k44eh23bu-iZAWYJe3WnuH7XbcmzAy3TA48z_u0IFOE8mcWeo2vArAkuWUwv2w8HKXdbA70UbdLbNS8DK5X0QloUEoXT7uNk8rdKTup4JihfmM8wv11NIPv6GKDdvFZdH351eEEZsIG/s1600/ultraArduino.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjM6k44eh23bu-iZAWYJe3WnuH7XbcmzAy3TA48z_u0IFOE8mcWeo2vArAkuWUwv2w8HKXdbA70UbdLbNS8DK5X0QloUEoXT7uNk8rdKTup4JihfmM8wv11NIPv6GKDdvFZdH351eEEZsIG/s1600/ultraArduino.JPG" height="240" width="320" /></a></div>
<br />
Até a próxima.Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-30799277112322826942013-06-09T16:50:00.000-03:002013-06-09T16:50:02.093-03:00Transmissão RFOlá, neste artigo iremos explicar como realizar uma transmissão com Rádio Frequência (RF), utilizando os módulos abaixo com dois arduinos.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgtDWIhNi0pslSQbuKmHBOvscaNo9ieszdq4x6HGLCYFrcVa2l0fG7TcgXmix02_Qyx95G-G28XVdtC7gPmA2iw6Z6Ze_6cu-EG2YZG1tiEuuiVy98EWjNMAYzpH7YORVQ0hDcMFGjUPM-O/s1600/Modulos_RF.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgtDWIhNi0pslSQbuKmHBOvscaNo9ieszdq4x6HGLCYFrcVa2l0fG7TcgXmix02_Qyx95G-G28XVdtC7gPmA2iw6Z6Ze_6cu-EG2YZG1tiEuuiVy98EWjNMAYzpH7YORVQ0hDcMFGjUPM-O/s1600/Modulos_RF.jpg" height="317" width="320" /></a></div>
<br />
<div class="separator" style="clear: both; text-align: left;">
O módulo menor é o transmissor (TX). O maior é o receptor (RX). Utilizaremos também a biblioteca <a href="http://www.pjrc.com/teensy/td_libs_VirtualWire.html" target="_blank">VirtualWire</a> para fazer a comunicação com os módulos. Esses módulos só permitem a comunicação em um sentido ou unidirecional, ou seja, sempre teremos o envio de dados do TX para o RX. Para que possamos fazer uma comunicação completa com envio e recebimento por ambos teríamos que utilizar dois pares de módulos com frequências diferentes. O download da biblioteca e maiores detalhes sobre ela, podem ser obtidos no link já informado.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Em ambos os módulos temos um local para colocar uma antena (ANT). Com a antena, a distância entre eles poderá ficar bem maior. </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Transmissão (TX)</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Iniciaremos pela aplicação que envia os dados. Essa aplicação enviará a mensagem "TransRF" a cada segundo. Ligue os pinos de alimentação e terra do módulo ao arduino e o pino ATAD ao pino 9 também do arduino. </div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o código-exemplo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<pre class="brush: cpp">#include <VirtualWire.h> // lib para RF
//Pinos para o transmissor RF
#define TX_PIN 9
#define RX_PIN 10
#define PTT_PIN 11
#define DOIS_MIL 2000
char mensagem[8];
void setup()
{
//Pino de envio
vw_set_tx_pin(TX_PIN);
//Pino de recepcao. Embora nao seja utilizado no TX, faz-se necessario definir
vw_set_rx_pin(RX_PIN);
vw_set_ptt_pin(PTT_PIN);
vw_set_ptt_inverted(true);
vw_setup(DOIS_MIL);
mensagem[0]= 'T';
mensagem[1]= 'r';
mensagem[2]= 'a';
mensagem[3]= 'n';
mensagem[4]= 's';
mensagem[5]= 'R';
mensagem[6]= 'F';
mensagem[7]= '\0';
}
void loop()
{
vw_send((uint8_t *)mensagem, 8);
delay(1000);
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b>Recepção</b></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Essa aplicação receberá a mensagem enviada pelo TX e imprimirá a mesma no console serial.</div>
<div class="separator" style="clear: both; text-align: left;">
Ligue os pinos de alimentação e terra do módulo no arduino e ligue o pino DATA ao pino 9 também do arduino. Note de nesse módulo temos 2 pinos de dados. Ambos são iguais. Utilize qualquer um deles.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o código-exemplo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<pre class="brush: cpp">#include <VirtualWire.h>
void setup() {
Serial.begin(9600);
vw_set_tx_pin(10);//Embora nao usado, mas precisa ser definido
vw_set_ptt_pin(11);
vw_set_rx_pin(9);//Pino de envio
vw_set_ptt_inverted(true);
vw_setup(2000);
vw_rx_start();
}
void loop() {
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
Serial.println("Aguardando");
if (vw_get_message(buf, &buflen))
{
Serial.print("Texto recebido:");
Serial.write((char*)buf);
Serial.println();
}
delay(1000);
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Saída do console serial:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEihyphenhyphenr7ym4NIQ0gd-liEfI4rZA2gQbTtKLmrwyiiKRQO-WBWnMl5eUS7Q7L3WyVXy34A0CByXDYYMrNHHDXfYYFl4HkRNSLa_utyvl28De4Y7jA3ywNrPN4fUaFyC8PYGmxo4s56vRENYaw0/s1600/Serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEihyphenhyphenr7ym4NIQ0gd-liEfI4rZA2gQbTtKLmrwyiiKRQO-WBWnMl5eUS7Q7L3WyVXy34A0CByXDYYMrNHHDXfYYFl4HkRNSLa_utyvl28De4Y7jA3ywNrPN4fUaFyC8PYGmxo4s56vRENYaw0/s1600/Serial.png" height="183" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo uma foto dos módulos montados:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhwRWpMUKyax2Cm7eRIYvWNMvN6CEv9Cl8URiuc2nVv8Pw31X8ZoAMHPK80GSUkc3AOod9XGieMXbr1w7aS7DnmpkxFHwwqbJwMVLpVDQjrDv-LKWytqGISci5EovU94xno-xQHtecsrz6y/s1600/Modulos+Montados.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhwRWpMUKyax2Cm7eRIYvWNMvN6CEv9Cl8URiuc2nVv8Pw31X8ZoAMHPK80GSUkc3AOod9XGieMXbr1w7aS7DnmpkxFHwwqbJwMVLpVDQjrDv-LKWytqGISci5EovU94xno-xQHtecsrz6y/s1600/Modulos+Montados.JPG" height="240" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Até a próxima.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-88709796778518626092013-06-04T23:03:00.001-03:002013-06-06T15:02:24.327-03:00Arduino EthernetOlá, neste artigo iremos mostrar como montar um mini servidor, que retorne uma página para um navegador utilizando um arduino e uma placa ethernet.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjq0dGeJ7cKegb9BT4qd4TwK4yTn0nPSH_3pK9UrHV-N5vePSVetVAnvURm2JDRfvDcVnTmXyHOPFU9ayIJX9ZpjVVX-Dxpnp4k13Mkd7P2Kve4-z9_1dKNpDg8qXizYJbjFzHVp4JOHq_o/s1600/ArduinoEthernetShieldV3.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="248" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjq0dGeJ7cKegb9BT4qd4TwK4yTn0nPSH_3pK9UrHV-N5vePSVetVAnvURm2JDRfvDcVnTmXyHOPFU9ayIJX9ZpjVVX-Dxpnp4k13Mkd7P2Kve4-z9_1dKNpDg8qXizYJbjFzHVp4JOHq_o/s1600/ArduinoEthernetShieldV3.jpg" width="320" /></a></div>
<br />
<br />
A placa ethernet que usaremos é compatível pino a pino com o arduino UNO. Sendo assim, ela encaixará perfeitamente na mesma. A figura abaixo mostra a placa e o arduino.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjgEB392KBMX7tjLBL0ERmkBIsfkPwoaUmvYPxXEtu3cE3jikWmn4pbSHMhI085d7PQ_3hEYth0CfuVEj13RYYywcRafdfEQUJEJptXXpTTkyU015V9wzPq29IL6fpNfDDJYQ9g9itAspUU/s1600/Separados.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="240" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjgEB392KBMX7tjLBL0ERmkBIsfkPwoaUmvYPxXEtu3cE3jikWmn4pbSHMhI085d7PQ_3hEYth0CfuVEj13RYYywcRafdfEQUJEJptXXpTTkyU015V9wzPq29IL6fpNfDDJYQ9g9itAspUU/s1600/Separados.JPG" width="320" /></a></div>
<br />
<br />
Utilizaremos as biblioteca Ethernet.h e SPI.h que já fazem parte da IDE 1.0.1, utilizada para fazer esse artigo.<br />
<br />
Abaixo, segue montado.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgGasfH1oc8tTgvQudVSIlNcVTBhk1GABL9zoEpApHkHplPoYUnMEpdzpyIMtznywmviTtgx6_n-Y9EXLJX-VYezr9qsG_4aoCjRoVphR1IIdrq5NXqGMrpsPfKP8kTybhfyKWhyxC1RATd/s1600/Juntos.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="240" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgGasfH1oc8tTgvQudVSIlNcVTBhk1GABL9zoEpApHkHplPoYUnMEpdzpyIMtznywmviTtgx6_n-Y9EXLJX-VYezr9qsG_4aoCjRoVphR1IIdrq5NXqGMrpsPfKP8kTybhfyKWhyxC1RATd/s1600/Juntos.JPG" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
A seguir, segue um código-exemplo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<pre class="brush: cpp">
#include <SPI.h>
#include <Ethernet.h>
// Defina o IP de acordo com a sua rede:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };//Informe um mac-address
IPAddress ip(169,254,109, 208);//Informe um IP
EthernetServer server(80);//Informando a porta para receber requisicoes
void setup()
{
// Inicializando modulo com mac e ip
Ethernet.begin(mac, ip);
server.begin();//Inicializando o servidor
}
void loop() {
// Aguardando conexoes
EthernetClient client = server.available();
if (client)
{
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available())
{
char c = client.read();//Lendo carcteres recebidos
Serial.write(c);
//Se receber \n e a linha for em branco (dois \n) - fim http request
if (c == '\n' && currentLineIsBlank)
{
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connnection: close");
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
client.println("<title>Ola</title>");
client.println("<html>");
client.println("</head>");
client.println("<center>");
client.println("<h1>");
client.println("<p>ArduinoCC</p>");
client.println("</h1>");
client.println("<h1>");
client.println("<p>Arduino Ethernet</p>");
client.println("</h1>");
client.println("TESTE HTTP");
client.println("</center>");
client.println("</html>");
break;
}
if (c == '\n') {
// Nova linha
currentLineIsBlank = true;
}
else if (c != '\r') {
// recebendo caractere apos nova linha
currentLineIsBlank = false;
}
}
}
//Aguardando o navegador receber a pagina
delay(1);
client.stop();//Fechando conexao
}
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue a saída no navegador</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgLuSKYjAcTUXBn0RnTa76gQ0svPsyuDG2c4kXY-4lYit5Dpfw7wxAO8vZJo-0acD3xbp5z5SigcsnE8wuSwdbz-VGlsiDYtSNLiJj1SsuIf7qTEnq2EqNYJm1mAgSGWXUfiVmnJWVXqC7q/s1600/Navegador.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="131" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgLuSKYjAcTUXBn0RnTa76gQ0svPsyuDG2c4kXY-4lYit5Dpfw7wxAO8vZJo-0acD3xbp5z5SigcsnE8wuSwdbz-VGlsiDYtSNLiJj1SsuIf7qTEnq2EqNYJm1mAgSGWXUfiVmnJWVXqC7q/s1600/Navegador.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Até a próxima.</div>
<br />Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-64562673160010046442013-06-03T22:48:00.000-03:002013-06-06T15:02:59.462-03:00Utilização de cartões SDOlá, Neste artigo iremos ver como ler e escrever em um cartão SD com o arduino. A IDE do arduino já possui uma API para trabalhar com SDs. Mostraremos como utilizá-la.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjZp41UDeb2awb0I14_keA8t9YJLbJj8kRgrmXSOQjQJ5ZnfTtKv7SPEOi0fsSpnOtNyl0WD3aA0qOSk2kscfpv21px1SZ7iyZbQTxCr3G6Pjw8mUp1r_EpFTa_Z9JDGlG6AxvJPL41kIo5/s1600/CartaoSD.jpeg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjZp41UDeb2awb0I14_keA8t9YJLbJj8kRgrmXSOQjQJ5ZnfTtKv7SPEOi0fsSpnOtNyl0WD3aA0qOSk2kscfpv21px1SZ7iyZbQTxCr3G6Pjw8mUp1r_EpFTa_Z9JDGlG6AxvJPL41kIo5/s1600/CartaoSD.jpeg" /></a></div>
Material necessário:<br />
<br />
<ul>
<li>Arduino</li>
<li>Módulo de leitura e escrita de cartão SD - <a href="http://dx.com/p/sd-card-reading-writing-module-for-arduino-deep-blue-142121" target="_blank">aqui</a></li>
<li>Alguns fios</li>
</ul>
<div>
A implementação da biblioteca do arduino (SD.h) utiliza um padrão chamado de SPI - Serial Peripheral Interface Bus. Para maiores detalhes, clique <a href="http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus" target="_blank">aqui</a> e <a href="http://arduino.cc/en/Reference/SPI" target="_blank">aqui</a>.</div>
<div>
Essa biblioteca utiliza alguns pinos pré-definidos. A ligação dos mesmos deve seguir a tabela abaixo.</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhIj9lLtPO2TgB8TzZUR64tYYCmBITzQxUFpuXkTMgWI0w4PuwslrJcyrh8htiL89fZxnrOCAxEKdZ9pjDbGSrNr10eK25G-r47-flUe89JdfHY11LkYXLLyqEObfkWnb3rwKfoyQ7JOu4f/s1600/Tabela.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhIj9lLtPO2TgB8TzZUR64tYYCmBITzQxUFpuXkTMgWI0w4PuwslrJcyrh8htiL89fZxnrOCAxEKdZ9pjDbGSrNr10eK25G-r47-flUe89JdfHY11LkYXLLyqEObfkWnb3rwKfoyQ7JOu4f/s1600/Tabela.png" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
No módulo há indicações de cada um dos pino. Ver figura abaixo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjGyOmYZz_27BiRoAbYrdu7EZkinsvBMDS6sk3g0OKg8mzFLHsfqQ23adT0HtyKbkXEShr7qB8mlCaE69iCaGDWSVHCFSVw9jZBxSo3y_SBKb3e75RDM2oogyuZEUTvXY6gMAVEf13TuM-X/s1600/CartaoSD1.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjGyOmYZz_27BiRoAbYrdu7EZkinsvBMDS6sk3g0OKg8mzFLHsfqQ23adT0HtyKbkXEShr7qB8mlCaE69iCaGDWSVHCFSVw9jZBxSo3y_SBKb3e75RDM2oogyuZEUTvXY6gMAVEf13TuM-X/s1600/CartaoSD1.jpg" height="195" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Lembre-se de ligar os pinos de 5V e 3.3V. O Módulo precisa de ambos para funcionar. O Cartão SD deverá está formatado com o sistema de arquivos FAT.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo um exemplo de ligação do módulo ao arduino.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEicJgjTfjJ8ry4Wfjpuv8DSXSagCVjkp94XmybaVHdnzeRpY3zycyNj2MMgjySKV7IOYp2DvPfW6KjAM23mb4G1SvpWoOh_ZdWVrDtGczm5hqMKJWi6I2li2aeuzK4vJ2_LEzbjl8W7ZLzA/s1600/CartaoMontado.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEicJgjTfjJ8ry4Wfjpuv8DSXSagCVjkp94XmybaVHdnzeRpY3zycyNj2MMgjySKV7IOYp2DvPfW6KjAM23mb4G1SvpWoOh_ZdWVrDtGczm5hqMKJWi6I2li2aeuzK4vJ2_LEzbjl8W7ZLzA/s1600/CartaoMontado.JPG" height="240" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue o fonte para o arduino UNO</div>
<div>
<br /></div>
<div>
<pre class="brush: cpp">
#include <SD.h>
//Pino CS do arduino UNO
#define CS 10
File myFile;
#define FILENAME "teste.txt"
void setup()
{
Serial.begin(9600);
Serial.print("Inicializando SD...");
pinMode(CS, OUTPUT);//Inicializando pino CS como output
if (!SD.begin(CS)) {//Inicializando SD card
Serial.println("Falha!");
return;
}
Serial.println("Ok!");
if(!SD.exists(FILENAME))//Se nao existe o arquivo
{
myFile = SD.open(FILENAME, FILE_WRITE);//Abrindo arquivo para gravacao
if (myFile)
{
Serial.print("Escrevendo no arquivo...");
myFile.println("teste 1, 2, 3.");
myFile.println("teste 4, 5, 6.");
myFile.close();
Serial.println("fim de escrita.");
}
else
{
Serial.println("erro na abertura");
}
}
myFile = SD.open(FILENAME, FILE_READ);//Abrindo o arquivo para leitura
char tmp;
while(myFile.available())//Enquanto nao chega no fim do arquivo
{
tmp = myFile.read();//Leitura de cada caractere
Serial.print(tmp);
}
myFile.close();//Fechando arquivo
}
void loop()
{
//Nao se faz necessario usar
}
</pre>
</div>
<div>
<br /></div>
<div>
A saída serial deve apresentar algo parecido com:<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjj7wvcVVR0UqgfgUtD2ii6zwYBYDsDl2c-oAWkEeo4xyHBzk4iwe0z4hbjPRqdXHx9oQA5B4Ybqn919jAQAGnPjrgRrT7ZHHK8Ew30a4QMWngcO7PxZ4LaPlHRWYJC_Wi0ZG3OHWPKEr3I/s1600/Serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjj7wvcVVR0UqgfgUtD2ii6zwYBYDsDl2c-oAWkEeo4xyHBzk4iwe0z4hbjPRqdXHx9oQA5B4Ybqn919jAQAGnPjrgRrT7ZHHK8Ew30a4QMWngcO7PxZ4LaPlHRWYJC_Wi0ZG3OHWPKEr3I/s1600/Serial.png" height="184" width="320" /></a></div>
<br />
Até a próxima</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com5tag:blogger.com,1999:blog-631927109914488620.post-16534798386403492102013-06-02T23:12:00.001-03:002013-06-06T15:48:04.825-03:00ATTiny - Arduino TinyOlá, neste artigo iremos falar sobre uma opção barata de processador compatível com a plataforma arduino, o attiny85. Explicaremos como gravar uma aplicação que acende um LED pelo tiny.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEinK-NQjIePaupfxYQpuPbO89JkueAqIzO2nbolrYq7By5BWU0nzlBy4sK0Wq35z1IPxuPUcumRnZywdb37odMvmeFTK4Y9IlEhmbODDPsMzuKs3-3_kwMUua6XpWMUMioN2sxUcpyNTF6P/s1600/ATtiny45-85.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEinK-NQjIePaupfxYQpuPbO89JkueAqIzO2nbolrYq7By5BWU0nzlBy4sK0Wq35z1IPxuPUcumRnZywdb37odMvmeFTK4Y9IlEhmbODDPsMzuKs3-3_kwMUua6XpWMUMioN2sxUcpyNTF6P/s1600/ATtiny45-85.png" height="114" width="320" /></a></div>
<br />
<br />
O Tiny85 apresenta as seguintes vantagens:<br />
<br />
<ul>
<li>É pequeno, tem apenas 8 pinos divididos em 2 blocos de 4;</li>
<li>Bem mais barato que um ATMega;</li>
<li>Relativamente fácil de programar;</li>
<li>Compatível com a IDE do arduino.</li>
</ul>
<div>
Para esse projeto precisaremos dos seguintes componentes:</div>
<div>
<ul>
<li>1 x ATTiny85 PU20</li>
<li>1 x Arduino UNO</li>
<li>1 x Capacitor eletrolítico de 10 uf</li>
<li>1 x Resistor de 220 ohms</li>
<li>1 x LED</li>
</ul>
Primeiramente devemos preparar a IDE do arduino para compilar código para o tiny.</div>
<div>
<br /></div>
<div>
Passos:</div>
<div>
<ol>
<li>Fazer o download da biblioteca do Tiny <a href="https://github.com/damellis/attiny/archive/master.zip" target="_blank">aqui</a>.</li>
<li>Descompacte o zip</li>
<li>Abra a pasta <b>Hardware</b> dentro da instalação do arduino e crie uma pasta chamada de <b>attiny</b></li>
<li>Copie o conteúdo para lá. Deve ficar de acordo com a figura abaixo.<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiRM5JYHu_lzcWjVd0Jsuc0VDE34ItZfI7QyhjVMFQTxrCmCY_3ub9J9tUghcsncGKBAmJVEunjOqz6ZkXRdDyG9BLBa1UIIwwswQ3Fmih3wFF0wUN3Z5ak06vYa-iT0VJgiL6fcgcM6rs6/s1600/diretorio.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em; text-align: center;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiRM5JYHu_lzcWjVd0Jsuc0VDE34ItZfI7QyhjVMFQTxrCmCY_3ub9J9tUghcsncGKBAmJVEunjOqz6ZkXRdDyG9BLBa1UIIwwswQ3Fmih3wFF0wUN3Z5ak06vYa-iT0VJgiL6fcgcM6rs6/s1600/diretorio.png" height="126" width="320" /></a></li>
<li><div class="separator" style="clear: both; text-align: left;">
Abra a IDE do arduino e vá em Tools->Board. Deverá aparecer algo como:</div>
<div class="separator" style="clear: both; text-align: left;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgmgbgOsPjORA3RW_Fhhy2E5_xby4C_NEtAAquHPWNW9-Y5KYyoveDp7LM9n8hapeEQ141K7HFOnarAp4fobl4cG2XzlsnOKG8grt6V8zuv-UQK5oLagspu5935PJR1JzlOa0vBK2uxwNef/s1600/instalacaoTiny.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgmgbgOsPjORA3RW_Fhhy2E5_xby4C_NEtAAquHPWNW9-Y5KYyoveDp7LM9n8hapeEQ141K7HFOnarAp4fobl4cG2XzlsnOKG8grt6V8zuv-UQK5oLagspu5935PJR1JzlOa0vBK2uxwNef/s1600/instalacaoTiny.png" height="237" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Usaremos o arduino UNO para gravar o programa no tiny e para isso, precisamos carregar o software <b>ArduinoISP</b>. Vá em File->Examples->ArduinoISP. Procure pela função abaixo e troque de 40 para 20 o tempo de delay.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<pre class="brush: cpp">
uint8_t hbval=128;
int8_t hbdelta=8;
void heartbeat(){
if (hbval > 192) hbdelta = -hbdelta;
if (hbval < 32) hbdelta = -hbdelta;
hbval += hbdelta;
analogWrite(LED_HB, hbval);
delay(20); // <-- alterar essa linha de 40 para 20
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Grave o programa ArduinoISP no UNO. Após a gravação, abra o exemplo Blink altere o pino 13 do LED para pino 0. Segue figura.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<pre class="brush: cpp">
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
This example code is in the public domain.
*/
//Pin 13 has an LED connected on most Arduino boards.
//give it a name:
in led = 0;
//this setup routine runs once when you press reset:
void setup(){
//initialize the digital pin as an putput.
pinMode(led, OUTPUT);
}
//this loop routine runs over and over again forever:
void loop(){
//turn the LED on
digitalWrite(led, HIGH);
//wait fora second
delay(1000);
//turn the LED off
digitalWrite(led, LOW);
//wait for a second
delay(1000);
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Em Tools->Board, selecione ATtiny85(internal 1 MHz clock) e em seguida, em Tools->Programmer, selecione <b>Arduino as ISP.</b></div>
<div class="separator" style="clear: both; text-align: left;">
<b><br /></b></div>
<div class="separator" style="clear: both; text-align: left;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_ceZhzZb4vX2qdXRWv4yRA6_E2SFQZQ1KZBDwEHQcj9x5KA-W0WKz6ulI4rxbdvqCsIU54r_VOWKB0kuH-jrW5T9CiOSqPZJ97U1WKmNfviqq5bDkXtYEMQdT972Qa3V_7kFSyYNfbDkQ/s1600/SelecaoISP.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_ceZhzZb4vX2qdXRWv4yRA6_E2SFQZQ1KZBDwEHQcj9x5KA-W0WKz6ulI4rxbdvqCsIU54r_VOWKB0kuH-jrW5T9CiOSqPZJ97U1WKmNfviqq5bDkXtYEMQdT972Qa3V_7kFSyYNfbDkQ/s1600/SelecaoISP.png" height="238" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<b><br /></b></div>
<div class="separator" style="clear: both; text-align: left;">
Seu programa está pronto para ser carregado. Monte o circuito de acordo com a figura abaixo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiVBaPlEB_6_O6waHSUnakTpgqk8dzrLkDEAqET1643xfcwrHvefJl1QUgQ9biRHNs9OqlM0N2pat5gNUpntzTmMoMGWSm911lyjET2zAx_RTxJl06qPaRjCLBksq1gQBP_v7AvNZGvOj8x/s1600/GravadorTiny.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiVBaPlEB_6_O6waHSUnakTpgqk8dzrLkDEAqET1643xfcwrHvefJl1QUgQ9biRHNs9OqlM0N2pat5gNUpntzTmMoMGWSm911lyjET2zAx_RTxJl06qPaRjCLBksq1gQBP_v7AvNZGvOj8x/s1600/GravadorTiny.png" height="320" width="236" /></a></div>
<br />
<div class="separator" style="clear: both; text-align: left;">
O Capacitor deve ser usado para evitar que a IDE faça o reset do UNO - Ligando o GND ao pino de Reset. Abaixo a tabela com a ligação dos pinos.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhJQKIun7ls7jVKds2NGwJS93Qcy2m0rceXvAcnqS_rZ8OxJhonCVXyPmga2tHD-LmADF65cauzmoKHfH3TkV2AtbZ4rEJLeljEuwPhFTRe0xyYZaMk1E2i6c8XJrDFunJDLkUpz178g5St/s1600/Tabela.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhJQKIun7ls7jVKds2NGwJS93Qcy2m0rceXvAcnqS_rZ8OxJhonCVXyPmga2tHD-LmADF65cauzmoKHfH3TkV2AtbZ4rEJLeljEuwPhFTRe0xyYZaMk1E2i6c8XJrDFunJDLkUpz178g5St/s1600/Tabela.png" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O programa (Blink alterado) já pode ser gravado. Grave normamente. Nesse momento o arduino UNO irá gravar o código no Tiny. Após a gravação, retire o Tiny e monte o circuito abaixo, Utilize preferencialmente uma alimentação de 5V.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjYpAvrsGSIswPAoEcHiCMCh8ZxCuuYMoHBge8s2sAmz7tzJELyxkG4evp5movE3Mn2JJkH5xF43CQrAgpa3Cvu33AJC3b_Rs-gxaEQXR_5cthgudagEfXcaVsjwkUrsgnANqGh3bz3G98P/s1600/Tiny_LED.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjYpAvrsGSIswPAoEcHiCMCh8ZxCuuYMoHBge8s2sAmz7tzJELyxkG4evp5movE3Mn2JJkH5xF43CQrAgpa3Cvu33AJC3b_Rs-gxaEQXR_5cthgudagEfXcaVsjwkUrsgnANqGh3bz3G98P/s1600/Tiny_LED.png" height="244" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Eu montei na mesma protoboard os dois circuitos, trocando apenas o tiny de lugar e aproveitei a alimentação do arduino para alimentar o circuito acima.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Tiny na posição do gravador.</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEglA3lR2V0YtqthjoxKcET1k2wNylsuf0nNpDGk7Pa58F-TC64tnm0Ylf6MTKH0CHtFeW2ghh8QQWoeyd4nxULXdNUgYkKwChrD8LIHnnN-WxIbEIiwTntLMvNd9hBLrEYcnVmvqGTLR5cA/s1600/GravadorTiny_montado.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEglA3lR2V0YtqthjoxKcET1k2wNylsuf0nNpDGk7Pa58F-TC64tnm0Ylf6MTKH0CHtFeW2ghh8QQWoeyd4nxULXdNUgYkKwChrD8LIHnnN-WxIbEIiwTntLMvNd9hBLrEYcnVmvqGTLR5cA/s1600/GravadorTiny_montado.JPG" height="240" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Tiny em execução, aproveitando a mesma protoboard e alimentacão</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjw7Y_3X5xhkdm3KD3XiZHiBT57PzMFOrTc_JXoMSG-Ks72W-_cyJgU1SdFLkoXf1EiOB06pPzQLGAra0398oAqSut8tA8RpPOHbZCU6LfD-AhfZylD39RmiO5kUiHGrzxeuW0T0VSw0dyJ/s1600/Tiny_LED_montado.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjw7Y_3X5xhkdm3KD3XiZHiBT57PzMFOrTc_JXoMSG-Ks72W-_cyJgU1SdFLkoXf1EiOB06pPzQLGAra0398oAqSut8tA8RpPOHbZCU6LfD-AhfZylD39RmiO5kUiHGrzxeuW0T0VSw0dyJ/s1600/Tiny_LED_montado.JPG" height="240" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Somente alterei o tiny de posição.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Até a próxima.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
</li>
</ol>
</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-82768979763988774722013-06-02T20:04:00.000-03:002016-05-08T09:41:06.591-03:00LCD Nokia 5110 e Sensor de Temperatura LM35Olá, neste artigo falaremos sobre a utilização do LCD Nokia 5110 e o sensor de temperatura LM35 com o arduino.<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhdaC1BzjDJ9pwqV6KpbOBT3sb08P18nhtKj0zUuWD-QsAoHsoHn6fYxHY5bvQWJDq6zaPq5U1u2gKI2Ym9WIK8x8G51PPb_RZe06OP-T_UfyJxvlWoBEbpwtqcKfcqVlw337M9h_N4r9Ya/s1600/Nokia5110.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="200" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhdaC1BzjDJ9pwqV6KpbOBT3sb08P18nhtKj0zUuWD-QsAoHsoHn6fYxHY5bvQWJDq6zaPq5U1u2gKI2Ym9WIK8x8G51PPb_RZe06OP-T_UfyJxvlWoBEbpwtqcKfcqVlw337M9h_N4r9Ya/s1600/Nokia5110.jpg" width="200" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
Também utilizaremos duas bibliotecas externas para acessar o LCD do nokia e uma outra feita por mim para criar menus.</div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<ul>
<li><a href="https://code.google.com/p/pcd8544/" target="_blank">PCD8544</a> - API de acesso ao LCD</li>
<li><a href="https://code.google.com/p/apigrafica-nokia-5110/" target="_blank">APIGrafica (clique aqui)</a> - API para desenho e controle de menus</li>
</ul>
<div>
O datasheet do sensor de temperatura LM35 pode ser obtido <a href="http://www.ti.com/lit/ds/symlink/lm35.pdf" target="_blank">aqui</a>.</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjEb_FHY-Pe8gSMTMc6DBvLvL0a4ZY4Gl8e2AjteJ1H2d8BDBa-7cOTiZNo7blTWmInS6AMpX-qtlwY6Xg0XmY67_f1cZm2UXR4xRojnJ-uM_L-nxbTXrz9GLHMtnWpvUYUIq1Y28D1tLCk/s1600/LM35.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="320" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjEb_FHY-Pe8gSMTMc6DBvLvL0a4ZY4Gl8e2AjteJ1H2d8BDBa-7cOTiZNo7blTWmInS6AMpX-qtlwY6Xg0XmY67_f1cZm2UXR4xRojnJ-uM_L-nxbTXrz9GLHMtnWpvUYUIq1Y28D1tLCk/s1600/LM35.jpg" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
O LCD do nokia, possui os seguintes pinos:</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
</div>
<ul style="background-color: white; margin: 0px; padding: 0px 0px 0px 35px;">
<li>RST - Reset</li>
<li>CE - Chip Enable</li>
<li>DC - Data/Command</li>
<li>DIN - Data Input</li>
<li>CLK - Clock</li>
<li>VCC - Alimentação</li>
<li>BL - Backlight</li>
<li>GND - Ground</li>
</ul>
<div>
<br /></div>
<div>
Devem ser ligados no Arduino de acordo com a tabela abaixo:</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiyj8N92eYWmd7yTsSi486v7Q2l5ZAbguigb1DNQgt7a54MiReZfBSOClP5Ch_F7NkG1pq8uzI0kqj5Dc0sOMNRvalaFNvnfdmd8tjSl9xulJtnb-eYMQ7n-MtordJnu7A8FYcVUxBEUsNi/s1600/Tabela.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="171" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiyj8N92eYWmd7yTsSi486v7Q2l5ZAbguigb1DNQgt7a54MiReZfBSOClP5Ch_F7NkG1pq8uzI0kqj5Dc0sOMNRvalaFNvnfdmd8tjSl9xulJtnb-eYMQ7n-MtordJnu7A8FYcVUxBEUsNi/s1600/Tabela.png" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue abaixo o esquema completo do projeto.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgodwq3E2sHYwgDUgpTXR7mnnL75Tj_3Nf9Aei2p6JTxhcCjlTM8vCpa3Ovbj1jkftRjPNQmeC3ZvNFVIXz18aR0XTnPA1ZIvJCAitHIx1ismqTpJqWbD-x7InvWjezXc_cE7Vwb44HZPCX/s1600/LCD_Nokia_schetch.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="286" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgodwq3E2sHYwgDUgpTXR7mnnL75Tj_3Nf9Aei2p6JTxhcCjlTM8vCpa3Ovbj1jkftRjPNQmeC3ZvNFVIXz18aR0XTnPA1ZIvJCAitHIx1ismqTpJqWbD-x7InvWjezXc_cE7Vwb44HZPCX/s1600/LCD_Nokia_schetch.png" width="320" /></a></div>
<div>
<br /></div>
<div>
<br /></div>
<div>
A aplicação aqui exemplificada desenhará um menu inicial, um menu de demonstração e um exibindo a temperatura do ambiente.</div>
<div>
<br /></div>
<div>
Menu Inicial:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjWHiGWtJxyGzHZTYb7MOOiLjL_IltvTAldYFjXI8rmQTqDyY7NCUUzHt-zCtCtpWXdOnC_P9Ef96yMxpZc4tFQ4NOzZJF-vdD6DqxoI-gFg8cwqB0nJmLqkFV8SARAb7w1k4p4FedSTgb8/s1600/MenuInicial.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="240" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjWHiGWtJxyGzHZTYb7MOOiLjL_IltvTAldYFjXI8rmQTqDyY7NCUUzHt-zCtCtpWXdOnC_P9Ef96yMxpZc4tFQ4NOzZJF-vdD6DqxoI-gFg8cwqB0nJmLqkFV8SARAb7w1k4p4FedSTgb8/s1600/MenuInicial.JPG" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
Menu Temperatura:</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhNgLjS6EEF0R9IAV1IQjzcxbUcd8zNBJ4XuBEGqKOtE3EcklCke-yUQKQ0aRaNtIIHGE_p_RubG_b1bad_FP2ItUxPF7emfynYV6SJFjvzfHDwOBRooGWQQE4vCnpAYszHwucBvI98fxUy/s1600/MenuTemperatura.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="240" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhNgLjS6EEF0R9IAV1IQjzcxbUcd8zNBJ4XuBEGqKOtE3EcklCke-yUQKQ0aRaNtIIHGE_p_RubG_b1bad_FP2ItUxPF7emfynYV6SJFjvzfHDwOBRooGWQQE4vCnpAYszHwucBvI98fxUy/s1600/MenuTemperatura.JPG" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
A troca entre as telas é feita através do Console Serial informando 1 - para o menu de exemplos, 2 - para o menu de temperatura e 3 ou outro caractere para voltar ao menu inicial. Pode-se colocar botões para substituir a interface serial.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Abaixo um exemplo de saída serial. </div>
<div>
</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjN0EAEWBdoF0bpXvmInOHIYKrqbXcnzRhyphenhypheniB8LkeQf4sEadh06AQ6r6WhYWD9d4QC5_ErKtqOfapXjtWKBMBN485cwbsOVk28y9NZNh4qMCTLjyg-NWjVs8n5G6HX-XKfBnb5oU079Gl_S/s1600/Serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="182" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjN0EAEWBdoF0bpXvmInOHIYKrqbXcnzRhyphenhypheniB8LkeQf4sEadh06AQ6r6WhYWD9d4QC5_ErKtqOfapXjtWKBMBN485cwbsOVk28y9NZNh4qMCTLjyg-NWjVs8n5G6HX-XKfBnb5oU079Gl_S/s1600/Serial.png" width="320" /></a></div>
<div>
<br /></div>
<br />
<div>
A seguir o fonte desse projeto.</div>
<div>
</div>
<div>
<br /></div>
<div>
<pre class="brush: cpp"> #include <APIGrafica.h>
//Definindo o contraste do LCD
#define LCD_CONTRAST 49
//Pino analogico do A0 do arduino para o LM35
#define sensor 0
PCD8544 nokia = PCD8544(3, 4, 5,6,7); // 3 - clk, 4 - din, 5 - dc, 6 - ce, 7 - rst
APIGrafica apiGraf = APIGrafica(nokia); //Inicializacao da API Grafica
float temperaturaAmb; //Variavel que armazena a temperatura
int leituraSensor; //Valor lido pelo sensor
char buffer[20]; //Buffer temporario
void setup()
{
nokia.init(LCD_CONTRAST); //Inicializacao do LCD
Serial.begin(9600); //Inicializacao da serial
menuInicio(); //Carregando o menu inicial
Serial.println("Aguardando comando....");
}
//Menu de exemplo
void menu()
{
apiGraf.clearDisplay(); //Limpando a tela
apiGraf.createMenu("Titulo",3); //Setando o titulo do menu
apiGraf.setItem(0,"Item 01"); //Setando item 1
apiGraf.setItem(1,"Item 02"); //Setando item 2
apiGraf.setItem(2,"Item 03"); //Setando item 3
apiGraf.selItem(1); //Selecionando o item 1 da tela
apiGraf.setTextLeftBTN("Btn1"); //Setando o texto do botao esquerdo
apiGraf.setTextRightBTN("Btn2"); //Setando o texto do botao Direito
apiGraf.drawMenu(); //Desenhando o menu
apiGraf.updateDisplay(); //Atualizando o display
}
//Utilizando o menu e conjunto com a API do LCD nokia
void tempAmb()
{
apiGraf.clearDisplay();
apiGraf.createMenu("Temperatura",3);
apiGraf.setItem(0,"");
apiGraf.setItem(1,"");
apiGraf.setItem(2,"");
apiGraf.selItem(-1);
apiGraf.setTextLeftBTN("Voltar");
apiGraf.drawMenu();
//convertendo de float para string
dtostrf(temperaturaAmb, 4, 2, buffer);
//Desenhando a string na tela
nokia.setTextColor(BLACK);
nokia.drawstring(0,20,buffer);
apiGraf.updateDisplay();
}
//Menu inicial
void menuInicio()
{
apiGraf.clearDisplay();
apiGraf.createMenu("Aguard Serial",3);
apiGraf.setItem(0,"1 - Menu");
apiGraf.setItem(1,"2 - Temp");
apiGraf.setItem(2,"3 - Inicio");
apiGraf.setTextLeftBTN("btn1");
apiGraf.setTextRightBTN("btn2");
apiGraf.drawMenu();
apiGraf.updateDisplay();
}
void lerTemperatura()
{
leituraSensor = analogRead(sensor); //Lendo o valor do sensor
temperaturaAmb = (5.0*leituraSensor*100.0)/1024.0; //Convertendo para float
}
char comando = 0;//Variavel que armazenara o comando digitado na serial
void loop()
{
if(Serial.available()) //Aguardando dados na serial
{
comando = Serial.read(); //Lendo serial
Serial.print("comando recebido");
Serial.println(comando);
Serial.println("Aguardando comando....");
}
switch(comando)
{
case '1': //Se numero 1
menu(); //Desenha menu de exemplo
break;
case '2': //Se numero 2
lerTemperatura(); //Leitura da temperatura
tempAmb(); //Desenha menu de temperatura
break;
default: //Quanquer outro valor
menuInicio(); //Desenha menu inicial
}
}
</pre>
<br />
<div>
<br /></div>
<div>
Até a próxima.</div>
</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com4tag:blogger.com,1999:blog-631927109914488620.post-55163137849619923962013-06-02T12:00:00.000-03:002013-06-06T15:53:00.528-03:00Tiny RTC I2C Real Time ClockOlá, neste artigo iremos falar um pouco sobre a utilização de um RTC - Real Time Clock com o arduino. Utilizaremos o módulo <b>Tiny RTC I2C Real Time Clock</b>, figura abaixo:<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjzgeFxj3ZUtyrvCsBZojpHABk7mqkWeALDMvPRuGFVvhtCPBWtIM7d9KYrWKwj77mb_zuttsuFjn3PjO2MjvOA8ntl9pTdMy4uZdd4PI7EQn_7Qr07UGXJYmyOZdXc9DoKkthPOxBsONLz/s1600/RTC_back.jpeg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjzgeFxj3ZUtyrvCsBZojpHABk7mqkWeALDMvPRuGFVvhtCPBWtIM7d9KYrWKwj77mb_zuttsuFjn3PjO2MjvOA8ntl9pTdMy4uZdd4PI7EQn_7Qr07UGXJYmyOZdXc9DoKkthPOxBsONLz/s1600/RTC_back.jpeg" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
Esse módulo contém os componentes abaixo:<br />
<br />
<ul>
<li>DS1307 - clock</li>
<li>EEPROM 24C32AN - memória</li>
<li>Bateria de lithium CR2032</li>
</ul>
<br />
<br />
Como ele tem uma bateria, as configurações de data e hora serão mantidas mesmo que o módulo seja desligado. Para maiores informações sobre o módulo clique <a href="http://dx.com/p/i2c-rtc-ds1307-real-time-clock-module-1-x-lir2032-147824?utm_rid=89095133&utm_source=affiliate" target="_blank">aqui</a>.<br />
<br />
Para a este artigo, utilizaremos a biblioteca <b>RTCLib</b> para trabalhar com o módulo que pode ser baixada <a href="https://github.com/adafruit/RTClib/archive/master.zip" target="_blank">aqui</a>.<br />
<br />
Abaixo uma tabela com a pinagem que deve ser seguida para ligar o módulo ao arduino.<br />
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiqMfMX_Fw8w4JkeRaWmjkQuijXXkozHwVc7HCOwq4Vc1nyMkmiH-Lb5fBw48SPibD6to1zau6_cLAkZGAgAeff7uhBcv-58QZo9GCtgtCEcBFL886D_3coOJkugfN0fg0EJStlXD_bm0_L/s1600/tabela.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiqMfMX_Fw8w4JkeRaWmjkQuijXXkozHwVc7HCOwq4Vc1nyMkmiH-Lb5fBw48SPibD6to1zau6_cLAkZGAgAeff7uhBcv-58QZo9GCtgtCEcBFL886D_3coOJkugfN0fg0EJStlXD_bm0_L/s1600/tabela.png" height="149" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue uma foto, ilustrando a ligação.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi8vnmRTrZrvI-cqhx9kTyAHxq2kEOr_FcHMvSEoKL1kcwVLkS4ko23KR2-R4T4AFhy-OgENLKQCxJv1tWovCaBPU0efOywiuYvfipUbdlT2WWk72LNVPxuw-deQ2NlDZN_6tEiJKNrdBbA/s1600/RTC_arduino.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi8vnmRTrZrvI-cqhx9kTyAHxq2kEOr_FcHMvSEoKL1kcwVLkS4ko23KR2-R4T4AFhy-OgENLKQCxJv1tWovCaBPU0efOywiuYvfipUbdlT2WWk72LNVPxuw-deQ2NlDZN_6tEiJKNrdBbA/s1600/RTC_arduino.JPG" height="240" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Segue um código exemplo para testar o módulo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<pre class="brush: cpp">
#include <Wire.h>
#include <RTClib.h>
//RTC - Real Time Clock
RTC_DS1307 RTC;
//Inicializacao dos modulos
void setup () {
//Inicialozacao da serial
Serial.begin(9600);//Inicializacao da serial
Wire.begin();//Inicializacao do protocolo wire
RTC.begin();//Inicializacao do modulo RTC
//Verifica se o modulo esta funcionando ou nao
if (! RTC.isrunning()) {
Serial.println("RTC is NOT running!");
//Ajusta a data/hora do Clock com a data/hora em que o codigo foi compilado, basta descomentar a linha
//RTC.adjust(DateTime(__DATE__, __TIME__));
}
}
void loop () {
DateTime now = RTC.now();//Recuperando a data e hora atual
Serial.print(now.day(), DEC);//Imprimindo o dia
Serial.print('/');
Serial.print(now.month(), DEC);//Recuperando o mes
Serial.print('/');
Serial.print(now.year(), DEC);//Recuperando o ano
Serial.print(' ');
Serial.print(now.hour(), DEC);//Recuperando a hora
Serial.print(':');
Serial.print(now.minute(), DEC);//Reci[erando os minutos
Serial.print(':');
Serial.print(now.second(), DEC);//Recuperando os segundos
Serial.println();
delay(3000);//A leitura sera repetida a cada 3 segundos
}
</pre>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
O código acima deve gerar uma saída similar no console serial conforme abaixo.</div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj1HWpPnUBxFKTbgSoiZ5hIRr6-rHtFXeNJ9QvopqfmPQ8MbvBfg-X0W6N1-Oeu2gGWRF6rfS3vJvFDJSdcxa4455vEiglqQ0Ag4aJSI7h6yUUaVGMQvKjf1HLMSokNqQV46vVSLom4cLAI/s1600/serial.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj1HWpPnUBxFKTbgSoiZ5hIRr6-rHtFXeNJ9QvopqfmPQ8MbvBfg-X0W6N1-Oeu2gGWRF6rfS3vJvFDJSdcxa4455vEiglqQ0Ag4aJSI7h6yUUaVGMQvKjf1HLMSokNqQV46vVSLom4cLAI/s1600/serial.png" height="181" width="320" /></a></div>
<div class="separator" style="clear: both; text-align: left;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Até a próxima.</div>
<br />Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com7tag:blogger.com,1999:blog-631927109914488620.post-68167429831533666962013-06-01T14:52:00.000-03:002013-06-06T15:12:55.912-03:00Ponte H com transistoresNeste artigo exemplificaremos o uso da <a href="http://arduinoccbr.blogspot.com.br/2013/05/ponte-h.html" target="_blank">Ponte H</a> (artigo anterior) com transistores em conjunto com o arduino.<br />
<br />
Lista de componentes:<br />
<ul>
<li>1 x Arduino</li>
<li>4 x Resistores de 470 ohms</li>
<li>4 x Transistores TIP120</li>
<li>2 x Diodos </li>
<li>1 x Protoboard</li>
<li>1 x Bateria 9V</li>
<li>1 x Chicote para ligar a bateria </li>
<li>1 x Motor CC</li>
<li>Alguns fios</li>
</ul>
<div>
Os mesmos devem ser ligados de acordo com o diagrama abaixo:</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjQfaDJDNuhpNKfKs9khrble9k3yUOEE-tWmG9tVtfrj-JRzJk0UKoCiGUP9uzqZSxB2iGl2AfjejDG4mm_OjXcI-6Q63rBTSqEkqZMRfEP7Rw-WonSJliPek8WzF2uokd74pdyIdOTlZaW/s1600/PonteH_Transistor_breadboard.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="218" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjQfaDJDNuhpNKfKs9khrble9k3yUOEE-tWmG9tVtfrj-JRzJk0UKoCiGUP9uzqZSxB2iGl2AfjejDG4mm_OjXcI-6Q63rBTSqEkqZMRfEP7Rw-WonSJliPek8WzF2uokd74pdyIdOTlZaW/s1600/PonteH_Transistor_breadboard.png" width="400" /></a></div>
<div>
<br /></div>
<div>
Os diodos devem ser colocados entre o arduino e a ponte, para evitar que algum tipo de corrente gerada pelos motores volte para o arduino e queime o mesmo. Segue abaixo o diagrama esquemático do circuito.<br />
<br /></div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjmwx8z8eoLJh0HVAbsjHn2UANOYu6praxMyGpaSEPzuE08Lb0-8dYM0EF-xarziXFmFSsnltDvPdsOBk6PlL4TtkkI1tacLxKouvVx30acQQ6ogaKNBQX9P0CqnNP905T9JAgkC6tQQboj/s1600/PonteH_Transistor_schematic.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="230" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjmwx8z8eoLJh0HVAbsjHn2UANOYu6praxMyGpaSEPzuE08Lb0-8dYM0EF-xarziXFmFSsnltDvPdsOBk6PlL4TtkkI1tacLxKouvVx30acQQ6ogaKNBQX9P0CqnNP905T9JAgkC6tQQboj/s1600/PonteH_Transistor_schematic.png" width="400" /></a></div>
<div class="separator" style="clear: both; text-align: center;">
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
Abaixo uma imagem do circuito montado.</div>
<br />
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjoyLkiQRAdbTAqBlcRcQJhSRWT6UdqP7DLAebX7jUr4VZRFtpLSmU18tesSRUBmgmcdUtAQOcuTEm2-DW66g3K4uSTwGtPasntiTbDUobwLn6G3gGD0wYhtiuK-89U9Gl-Abr6S4L6Uxfa/s1600/PonteH_Transistor_montagem.JPG" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="300" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjoyLkiQRAdbTAqBlcRcQJhSRWT6UdqP7DLAebX7jUr4VZRFtpLSmU18tesSRUBmgmcdUtAQOcuTEm2-DW66g3K4uSTwGtPasntiTbDUobwLn6G3gGD0wYhtiuK-89U9Gl-Abr6S4L6Uxfa/s1600/PonteH_Transistor_montagem.JPG" width="400" /></a></div>
<div>
<br /></div>
<div>
Com esse circuito é possível controlar a direção e velocidade do motor, através dos pinos 5 e 6 do arduino. É importante frisar que a tabela abaixo deve ser respeitada pois poderá haver <b>curto-circuito</b>.</div>
<div>
<br /></div>
<div class="separator" style="clear: both; text-align: left;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhBLtNcCpphMor3L3rz_4IZ-RFoFOLfskb0L0PnFcDpk2tb-p8cxC91Bd9s_33IvM3YcdiUda3Zp7CPW0I-MsRyMP31urInns2JMjIfMzrVHEJr2Q13b7naxzNuwEQEqIU9C3a7KcbwRZIs/s1600/Tabela.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="47" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhBLtNcCpphMor3L3rz_4IZ-RFoFOLfskb0L0PnFcDpk2tb-p8cxC91Bd9s_33IvM3YcdiUda3Zp7CPW0I-MsRyMP31urInns2JMjIfMzrVHEJr2Q13b7naxzNuwEQEqIU9C3a7KcbwRZIs/s1600/Tabela.png" width="400" /></a></div>
<div>
<br /></div>
<div>
Segue abaixo um código exemplo para o arduino. Ele inverterá o sentido do motor a cada 5 segundos.</div>
<div>
<br /></div>
<pre class="brush: cpp">
//Pinos 5 e 6 do arduino utilizados como saida para controla o sentido do motor
int sentido1 = 5;
int sentido2 = 6;
//Funcao de inicializacao:
void setup(){
//Pinos inicializados como saida.
pinMode(sentido1, OUTPUT);
pinMode(sentido2, OUTPUT);
}
//Contador de segundos do motor ligado
int segundos = 1;
//loop principal chamado eternamente
void loop(){
if(segundos <= 5){
//Ligando o motor em um sentido
digitalWrite(sentido1, HIGH);
digitalWrite(sentido2, LOW);
} else {
//Ligando o motor em outro sentido
digitalWrite(sentido1, LOW);
digitalWrite(sentido2, HIGH);
}
segundos++;
//Se passou de 10 segundos, reinicia o contador
if(segundos > 10)
segundos = 1;
//Aguarda 1 segundo
delay(1000);
}
</pre>
<div>
Softwares utilizados:<br />
<ul>
<li>IDE arduino versão 1.0.1 - compilação e carga do programa</li>
<li>Fritzing - diagramas do circuito</li>
</ul>
<div>
Datasheets:<br />
<ul>
<li><a href="http://www.adafruit.com/datasheets/TIP120.pdf" target="_blank">TIP120</a> </li>
</ul>
<br />
Até a próxima!</div>
</div>
Testehttp://www.blogger.com/profile/10426910851463913560noreply@blogger.com4tag:blogger.com,1999:blog-631927109914488620.post-17643954159743642842013-05-27T09:52:00.000-03:002013-05-27T09:52:01.587-03:00Ponte H<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;"><b>O que é?</b></span></div>
<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;"><br /></span></div>
<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;">A ponte H é um circuito com quatro chaves que são acionadas de forma alternada, fundamental para o desenvolvimento de dispositivos, capaz de controlar motores de corrente contínua, através de sinais elétricos permitindo assim o controle do sentido, potência e velocidade.</span></div>
<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;"><br /></span></div>
<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;"><b>Como Funciona?</b></span></div>
<div style="text-align: justify;">
<span style="background-color: white; color: #555555; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 14px; line-height: 20px;"><br /></span></div>
<div style="text-align: justify;">
<span style="color: #555555; font-family: Helvetica Neue, Helvetica, Arial, sans-serif;"><span style="font-size: 14px; line-height: 20px;">A ponte H é um circuito com quatro chaves que são acionadas de forma alternada (chave 1 e chave 4 ou chave 2 e chave 3). Na primeira configuração das chaves, o motor girará em um sentido e, utilizando a segunda configuração o motor girará no sentido contrário. Segue abaixo circuito que exemplifica o seu funcionamento:</span></span></div>
<div style="text-align: justify;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEimWSv-7o0e9E8UtropDVmfBBMyXd0zkDsfzlGkyDtl0YtZzCbtCUnnG3O1egviWJd6Z0cXkpMqj03NVPHiBOEwwldjk0ZU5fFYk8Bgs_GFi9fgVgTq734JmLdrtDoNMZBjdlXo2sfD9h8/s1600/ponteH.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEimWSv-7o0e9E8UtropDVmfBBMyXd0zkDsfzlGkyDtl0YtZzCbtCUnnG3O1egviWJd6Z0cXkpMqj03NVPHiBOEwwldjk0ZU5fFYk8Bgs_GFi9fgVgTq734JmLdrtDoNMZBjdlXo2sfD9h8/s1600/ponteH.png" height="111" width="200" /></a><span style="color: #555555; font-family: Helvetica Neue, Helvetica, Arial, sans-serif;"><span style="font-size: 14px; line-height: 20px;">Na figura mais da esquerda você verifica que a seta do motor está apontando para cima. Isso devido as chaves S1 e S4 estarem fechadas, fechando assim o circuito num sentido.</span></span><br />
<span style="color: #555555; font-family: Helvetica Neue, Helvetica, Arial, sans-serif;"><span style="font-size: 14px; line-height: 20px;">Na outra figura verifica-se que a seta do motor está apontando para baixo devido as chaves S2 e S3 estarem fechadas, fechando assim o circuito no outro sentido.</span></span><br />
<br />
<span style="color: #555555; font-family: Helvetica Neue, Helvetica, Arial, sans-serif;"><span style="font-size: 14px; line-height: 20px;">Inicialmente, o propósito é consolidarmos algumas teorias para quando chegarmos na implementação os conceitos já tenham sido entendidos evitando assim que se implemente algo sem ao menos entender como funciona.</span></span></div>
<div style="text-align: justify;">
<br />
<div class="separator" style="clear: both; text-align: center;">
</div>
<br />
<br />
<br /></div>
David Fariashttp://www.blogger.com/profile/15145555607647989148noreply@blogger.com0tag:blogger.com,1999:blog-631927109914488620.post-23779176968896940952013-05-24T14:25:00.001-03:002013-05-24T14:34:24.257-03:00Apresentação<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: center;">
</div>
<div class="separator" style="clear: both; text-align: center;">
<a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDNZwyZiSNKoYEiRZ2pss-MlLYpSW5GIMO-AdRN4UPE55bMrA-Tddf2iciAUsqXzoLws1SeawZl6dCiIp5h9xwgxF5C6DZD7pS1ZSd0LmEs3Ea2K7CIxD1URzVOxieCULkBuGkPiawdYw/s1600/arduinoUNO.jpg" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDNZwyZiSNKoYEiRZ2pss-MlLYpSW5GIMO-AdRN4UPE55bMrA-Tddf2iciAUsqXzoLws1SeawZl6dCiIp5h9xwgxF5C6DZD7pS1ZSd0LmEs3Ea2K7CIxD1URzVOxieCULkBuGkPiawdYw/s1600/arduinoUNO.jpg" height="200" width="200" /></a></div>
<div style="text-align: justify;">
Olá Arduinistas de plantão...</div>
<div style="text-align: justify;">
<br /></div>
<div style="text-align: justify;">
Eu, juntamente com meu amigo Fernando Rebouças, vamos aqui postar informações sobre nossas experiências com o Arduino.</div>
<div style="text-align: justify;">
<br /></div>
<div style="text-align: justify;">
Pretendemos postar dicas para os mais variados níveis, seja você um entusiasta e/ou um profissional da área.</div>
<div style="text-align: justify;">
<br /></div>
<div style="text-align: justify;">
Nossa idéia é estar trocando experiências com vocês para assim fazermos, desse espaço, um local de troca de experiências.</div>
David Fariashttp://www.blogger.com/profile/15145555607647989148noreply@blogger.com1