Como usar a IDE Arduino na Linkit Smart 7688 Duo

Como usar a IDE Arduino na Linkit Smart 7688 Duo

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.

Linkit Smart 7688 Duo

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

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.

Detalhe 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ê:

Preferências da IDE

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:

Placas Adicionais

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:

Gerenciador de Placas

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á:

Esquemático - Blink Linkit

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 :)

Led Blinking Linkit SmartOBS: Ambos scripts foram retirados do site oficial e somente adaptados para nosso cenário.

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

Gostou do post da Linkit Smart 7688 Duo ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

6
Como usar a IDE Arduino na Linkit Smart 7688 Duo
3 votos, 2.67 classificação média (53% pontuação)

Formado em Técnico em Informática e Graduado em Análise e Desenvolvimento de Sistemas, ambos pelo Instituto Federal Farroupilha - RS. Colaborador do site FILIPEFLOP.

Compartilhe este Post

Deixe uma resposta