Neste artigo iremos tratar de como preparar o ambiente de desenvolvimento para criar projetos utilizando a Linkit Smart 7688 Duo com IDE Arduino. Se você se interessou por este artigo, assumo que você já conheça a Linkit Smart Duo! Caso ainda não a conheça não se preocupe, abaixo deixarei duas referências abordando sobre uma introdução e outro relatando sobre os primeiros passos com a Linkit.
Antes de começar, caso seja o seu primeiro contato com a Linkit Smart 7688 Duo, recomendo os dois conteúdos abaixo:
Material necessário
- Linkit Smart 7688 Duo
- Cabo micro usb
- 1 Led
- 1 resistor 100ohm
- Jumpers macho-macho
Preparando a IDE do Arduino
Para programar o ATMega, utilizaremos a própria IDE do Arduino, pois como mencionado no artigo citado, o modelo do microcontrolador é o mesmo daquele utilizado no Arduino Leonardo, o ATMega32u4.
A integração da IDE vai soar bem familiar para vocês, visto que segue praticamente os mesmos passos para integrar a ide pro esp8266 / nodemcu, mudará somente a url informada.
Portanto para de fato realizar a integração, você deverá abrir sua IDE Arduino (estou utilizando a última versão que consta no site até o momento de lançamento deste artigo: 1.8.1) e posteriormente ir até as preferências da IDE. Observe a imagem abaixo a qual ilustra a tela que deverá abrir para você:
Observe as últimas linhas da imagem, procure pelo seguinte texto: Additional Boards Manager URL’s. Observe que na minha IDE já consta alguma url, que no caso se refere a da Linkit Smart.
Para realizar a adição de uma URL clique ao botão ao lado, uma pequena janela se abrirá para você colocar a url referente à Linkit. Veja na tela abaixo como deverá ficar:
Veja que possui duas URLS na lista, uma referente ao esp8266 e outra referente à Linkit. Para realizar a adição basta adicionar a seguinte url: http://download.labs.mediatek.com/package_mtk_linkit_smart_7688_index.json.
Com isso você terá meio caminho andado, faltará apenas instalar as ferramentas para que de fato a integração esteja pronta.
O próximo passo será abrir o gerenciador de placas da IDE, o item referido fica localizado a parir do menu: Tools -> Board -> Bords Manager. Seguindo este caminho, uma tela se abrirá para você com uma lista de placas disponíveis. Terá um campo de pesquisa, digite “linkit” para realizar um filtro na lista. Você deverá ver algo parecido com o da imagem abaixo:
No meu caso ela já estará instalada, mas para você aparecerá o botão para instalar, apenas clique nele e aguarde alguns instantes (nesta fase dependerá da velocidade de sua conexão com a internet, pois neste momento será efetuado o download de todas as ferramentas necessárias para programar o ATMega).
Terminada a instalação, agora na sua lista de placas você poderá observar que possui uma nova plaquinha: Nossa Linkit Smart :). Então neste momento temos a IDE pronta para podermos fazer algo com o ATMega.
Circuito Linkit Smart 7688 Duo
Como será feito um simples blink, o circuito não terá nenhum mistério. Confira na imagem abaixo como o mesmo ficará:
Realizando o primeiro Blink
Para fazer o blink, apenas abra o Exemplo localizado em sua IDE, ele se encontra no seguinte caminho: File -> Examples -> 01. Basics -> Blink. Apenas será mudado o pino em que o led estará conectado. Portanto veja como deverá ficar seu Sketch:
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
the correct LED pin independent of which board is used.
If you want to know what pin the on-board LED is connected to on your Arduino model, check
the Technical Specs of your board at https://www.arduino.cc/en/Main/Products
This example code is in the public domain.
modified 8 May 2014
by Scott Fitzgerald
modified 2 Sep 2016
by Arturo Guadalupi
modified 8 Sep 2016
by Colby Newman
*/
#define LED_PIN 13
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_PIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(LED_PIN, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(LED_PIN, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
Realizando Upload para a Linkit Smart
Resolvi tratar este passo num tópico pois nós podemos utilizar duas formas para realizar upload para o atmega da Linkit Smart com IDE Arduino:
- Via cabo usb(modo tradicional);
- Via OTA;
Para realizar o upload da forma tradicional não terá mistério, simplesmente escolha a porta a qual a sua Linkit está conectada e mande ver clicando no botão de Upload. Espere alguns instantes e seu led já estará piscando – Nossa essa foi fácil heim Douglas!
Bem, o primeiro método foi barbada! Agora utilizaremos o segundo método que nos é disponibilizado: OTA (Over-The-Air). OTA nos permite realizar a atualização do firmware sem que haja necessidade do cabo usb estar conectado. É isso mesmo! Neste momento você utilizará a conexão de rede para efetuar este processo.
Para que isso ocorra bem, recomendo que sua Linkit esteja conectada na sua rede wifi. Caso não saiba fazer isso, dê uma conferida no segundo artigo que foi mencionado na introdução.
Portanto caso tudo esteja configurado, no mesmo local onde você selecionou a porta da sua Linkit, você deverá ver uma outra opção: Network ports, e logo abaixo irá aparecer o nome da sua placa seguida do IP de sua Linkit, no meu caso o nome completo é o seguinte: “Linkit Smart 7688 Duo on 192.168.0.130”. Apenas selecione a porta :).
O próximo passo será realizar o upload, a única coisa que será pedido nesta etapa será a senha que você definiu para sua Linkit(relatado no segundo artigo mencionado) – uma caixa de diálogo se abrirá para você digitá-lá. Se sua senha estiver ok, você verá o processo de upload ‘correndo’ no console da sua IDE. No meu caso teve a seguinte saída.
set pinmux spi_s -> gpio
avrdude: Version 6.1, compiled on Sep 27 2016 at 08:17:47
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
System wide configuration file is "/etc/avrdude.conf"
User configuration file is "/root/.avrduderc"
User configuration file does not exist or is not a regular file, skipping
Using Port : unknown
Using Programmer : linuxgpio
AVR Part : ATmega32U4
Chip Erase delay : 9000 us
PAGEL : PD7
BS2 : PA0
RESET disposition : dedicated
RETRY pulse : SCK
serial program mode : yes
parallel program mode : yes
Timeout : 200
StabDelay : 100
CmdexeDelay : 25
SyncLoops : 32
ByteDelay : 0
PollIndex : 3
PollValue : 0x53
Memory Detail :
Block Poll Page Polled
Memory Type Mode Delay Size Indx Paged Size Size #Pages MinW MaxW ReadBack
----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
eeprom 65 20 4 0 no 1024 4 0 9000 9000 0x00 0x00
flash 65 6 128 0 yes 32768 128 256 4500 4500 0x00 0x00
lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
hfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
efuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
lock 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00
calibration 0 0 0 0 no 1 0 0 0 0 0x00 0x00
signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00
Programmer Type : linuxgpio
Description : Use sysfs interface to bitbang GPIO lines
Pin assignment : /sys/class/gpio/gpio{n}
RESET = 3
SCK = 15
MOSI = 16
MISO = 17
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.01s
avrdude: Device signature = 0x1e9587
avrdude: erasing chip
avrdude: reading input file "/tmp/sketch.hex"
avrdude: input file /tmp/sketch.hex auto detected as Intel Hex
avrdude: writing flash (32758 bytes):
Writing | ################################################## | 100% 4.61s
avrdude: 32758 bytes of flash written
avrdude: verifying flash memory against /tmp/sketch.hex:
avrdude: load data flash data from input file /tmp/sketch.hex:
avrdude: input file /tmp/sketch.hex auto detected as Intel Hex
avrdude: input file /tmp/sketch.hex contains 32758 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 4.26s
avrdude: verifying ...
avrdude: 32758 bytes of flash verified
avrdude done. Thank you.
Percebeu a ‘dificuldade’ né? Você poderá sempre utilizar este método, eu mesmo venho utilizando na maioria dos casos, pois é comodo. Tudo isso ocorrerá de forma transparente pois o firmware da linkit já estará preparado para isso. Você simplesmente terá o ‘trabalho’ de selecionar a placa na lista e mandar ver. Simples, prático e eficaz!
Modos de Desenvolvimento
Num ecossistema onde possuímos um 1 Microcontrolador + 1 Microprocessador embarcados na mesma placa nos podemos usufruir de alguns modos de desenvolvimento. Para quem já brincou com Arduino + PC se comunicando via porta serial, Arduino + Firmata + NodeJS, cenários comuns os quais foram citados que você provavelmente algum dia já brincou com eles.
Portanto diante dessas características da linkit, podemos fazer tudo isso na mesma placa – é isso mesmo! Diante do famoso exemplo tratado acima – Blink, iremos utilizar o mesmo conceito, porém será aplicado em outro cenário.
Modos de desenvolvimento:
- Utilizando somente o ATMEGA
- Comunicação serial
- Firmata
- Bridge
O primeiro cenário já foi tratado, que é programar somente o atmega para que o mesmo trabalhe de forma independente. Neste próximo exemplo será programado o ATMega e também será desenvolvido um Script Python para rodar no lado da Linkit, e ambos se comunicarão via porta serial.
O exemplo será: o script python mandar um comando a cada segundo para o ATMega através da porta serial, e o atmega estará esperando por isso, logo, de acordo com o comando recebido, ligará ou desligará o led.
Sketch Arduino
#define LED_PIN 13
void setup()
{
Serial.begin(115200); // open serial connection to USB Serial port (connected to your computer)
Serial1.begin(57600); // open internal serial connection to MT7688AN // in MT7688AN, this maps to device
pinMode(LED_PIN, OUTPUT);
}
void loop()
{
int c = Serial1.read(); // read from MT7688AN
if (c != -1) {
switch (c)
{ case '0': // turn off D13 when receiving "0"
digitalWrite(LED_PIN, 0);
Serial.println("[INFO] LED DESLIGADO");
break;
case '1': // turn off D13 when receiving "1"
digitalWrite(LED_PIN, 1);
Serial.println("[INFO] LED LIGADO"); break;
}
}
}
Para realizar o upload para o atmega basta escolher um dos métodos de upload abordados acima.
Script Python
import serial
import time
s = None
def setup():
global s
# open serial COM port to /dev/ttyS0, which maps to UART0(D0/D1)
# the baudrate is set to 57600 and should be the same as the one
# specified in the Arduino sketch uploaded to ATmega32U4.
s = serial.Serial("/dev/ttyS0", 57600)
def loop():
# send "1" to the Arduino sketch on ATmega32U4.
# the sketch will turn on the LED attached to D13 on the board
s.write("1")
time.sleep(1)
# send "0" to the sketch to turn off the LED
s.write("0")
time.sleep(1)
if __name__ == '__main__':
setup()
while True:
loop()
O script python acima deverá ser colocado ‘dentro’ de sua linkit smart, ou seja, você deverá acessar a sua linkit via ssh e depois criar um arquivo, colocar o código acima, salvar e depois executar o script normalmente.
Se tudo der certo, o script inicializará e você deverá observar seu led piscando 🙂
Consideração finais Linkit Smart 7688 Duo
Vimos acima 2 exemplos de acordo com o modo de desenvolvimento: Programando o ATMega e programando ambos chips e comunicando-os via porta serial.
Os modos de desenvolvimento 3 e 4 serão abordados em artigos futuros. O modo 4 é deveras interessante, pois ativando o modo bridge da linkit(MT7688), através do atmega podemos nos conectar diretamente na internet através da rede wifi, bacana concorda? Já efetuei alguns testes com conexão MQTT e funciona muito bem. Mas deixamos este tema para um próximo artigo 😉
Referências
- Arduino IDE;
- Fritzing, EMF and SVG diagrams;
- MPU-MCU UART Connection;
Gostou do post da Linkit Smart 7688 Duo? Deixe seu comentário logo abaixo.
