Blog

Introdução ao Kit de Desenvolvimento de Argônio de Partículas

Particle-Argon-Development-Kit
Arduino Projetos Tech

Introdução ao Kit de Desenvolvimento de Argônio de Partículas

Ao observar o rápido crescimento da indústria de IoT, alguns líderes de plataforma de IoT de classe mundial, como a nuvem de partículas, introduziram dispositivos IoT de  geração, como Argônio de Partículas, Xenônio, Boro, etc.

Todos eles são kits de desenvolvimento de IoT muito versáteis e poderosos . Todas essas placas são construídas em torno do Nordic nRF52840 SoC e incluem um ARM Cortex-M4F com 1 MB de Flash e 256k de RAM. Este chip é compatível com Bluetooth 5 e NFC. Além disso, o Argon adiciona WiFi com um ESP32 da Espressif. O Boron traz o LTE para a mesa com um módulo ublox SARA-U260, e o Xenon vem com WiFi e celular. Esses kits também oferecem suporte à rede mesh, o que ajuda a expandir os dispositivos IoT.

Neste tutorial de introdução, iremos desembalar um novo Kit de Argônio de Partículas , veremos seus recursos e demonstraremos esse kit com um exemplo de código de LED Blinky .

Particle Argon Kit

Particle Argon IoT Development Board – Explicação do Hardware

Primeiro, vamos ver dentro da caixa, você encontrará uma placa Argon IoT, uma miniplaca de ensaio, um cabo micro-USB, alguns LEDs e resistores para começar com o kit.

Kit de Desenvolvimento de Argônio de Partículas

Agora, entenda o tabuleiro de argônio com a ajuda do diagrama de blocos abaixo.

Diagrama de blocos da placa de desenvolvimento de IoT de partículas de argônio

Como você pode ver no diagrama de blocos, ele possui ESP32 e núcleo nRF nórdico com ARM M4 . Também possui memória flash externa e conector SWD para programação e depuração do código. No lado da alimentação, ele possui circuito de carregamento LiPo.

A partir do diagrama de blocos acima, podemos listar os recursos da placa Argon.

Características

  1. Co-processador Espressif ESP32-D0WD 2,4 GHz Wi-Fi
    1. Flash de 4 MB integrado para ESP32
    2. Suporte 802.11 b / g / n
    3. 802.11 n (2,4 GHz), até 150 Mbps
  2. Nordic Semiconductor nRF52840 SoC
    1. Processador ARM Cortex-M4F de 32 bits a 64 MHz
    2. Flash de 1 MB, 256 KB de RAM
    3. Bluetooth 5: 2 Mbps, 1 Mbps, 500 Kbps, 125 Kbps
    4. Suporta instruções DSP, cálculos de unidade de ponto flutuante acelerado HW (FPU)
    5. ARM TrustZone CryptoCell-310 Módulo criptográfico e de segurança
    6. Até +8 dBm de potência TX (até -20 dBm em etapas de 4 dB)
    7. Etiqueta NFC-A
  3. Flash SPI adicional de 4 MB integrado
  4. 20 sinais mistos GPIO (6 x analógico, 8 x PWM), UART, I2C, SPI
  5. Micro USB 2.0 velocidade total (12 Mbps)
  6. Carregamento Li-Po integrado e conector de bateria
  7. Conector JTAG (SWD)
  8. LED de status RGB
  9. Botões de reset e modo
  10. Antena PCB on-board
  11. Conector U.FL para antena externa

Portanto, está claro com os recursos do painel de partículas de argônio que ele é capaz de realizar tarefas IoT complexas com o processador ARM embutido e os chips RF.

Agora, vamos ver as marcações dos pinos e a descrição dos pinos da placa de argônio.

Marcações de pinos 

Pinagem da placa de argônio

Diagrama de Pin 

Pinagem da placa de argônio

A tensão de entrada de alimentação máxima da placa Argon é de + 6,2v.

Descrição do pino 

  1. Li +  => O pino está conectado internamente ao terminal positivo do conector da bateria LiPo.
  2. EN  => O pino de habilitação do dispositivo é extraído internamente. Para desativar o dispositivo, conecte este pino ao GND.

3.  VUSB  => O pino está conectado internamente à fonte USB (+ ve).

4.  3V3  => Saída do regulador de 3,3V integrado.

5.  GND  => Pino de aterramento do sistema.

 6.  RST  => Entrada de reinicialização do sistema ativo-baixo. Este pino é puxado internamente.

7.  MD  => Este pino é conectado internamente ao botão MODE. A função MODE está ativa-baixa.

8.  RX  => Principalmente usado como UART RX, mas também pode ser usado como GPIO digital.

9.  TX  => Principalmente usado como UART TX, mas também pode ser usado como um GPIO digital.

10.  SDA  => Principalmente usado como pino de dados para I2C, mas também pode ser usado como um GPIO digital.

11.  SCL   => Principalmente usado como pino de clock para I2C, mas também pode ser usado como um GPIO digital.

12.  MO, MI, SCK  => Estes são os pinos da interface SPI, mas também podem ser usados ​​como GPIO digital.

13.  D2-D8  => Estes são pinos GPIO genéricos. D2-D8 são compatíveis com PWM.

14.  A0-A5  => Estes são pinos de entrada analógica que também podem atuar como GPIO digital padrão. A0-A5 são compatíveis com PWM.

Programando as placas de desenvolvimento Argon IoT

Existem muitas maneiras de programar qualquer placa de partículas. Você pode usar o Web IDE para escrever e fazer upload de código de qualquer lugar do mundo, este recurso é chamado de programação Over the Air que usamos anteriormente para programar NodeMCU . Desktop IDE e linha de comando também podem ser usados ​​para programar a placa Aragon. Se os dispositivos IoT estiverem conectados em campo, eles devem ser programados via OTA.

Todos os dispositivos de  geração do Particle possuem bootloader pré-programado e um aplicativo de usuário chamado Tinker. Você pode baixar o aplicativo Particle no dispositivo iOS e Android para alternar os pinos e obter leituras digitais e analógicas. Este bootloader permite ao usuário programar a placa com a ajuda de USB, OTA e também internamente através do processo de reset de fábrica.

Portanto, neste tutorial, usaremos o IDE da web para programar o Particle Argon IoT Development Kit . Também veremos como usar a funcionalidade Tinker no kit Argon.

Setup Particle IO’s Argon Kit

Antes de programar a placa Argon, temos que configurá-la usando o aplicativo Android ou iOS Particle. Portanto, baixe este aplicativo e certifique-se de ter uma conexão de Internet funcionando para que a placa Argon possa fazer uma conexão com ele.

Particle IoT App

1. Agora, conecte a placa Argon com o laptop ou qualquer fonte de alimentação USB com a ajuda do cabo micro-USB fornecido. Você verá que o LED azul está piscando (modo de escuta). Se não estiver piscando em azul, segure o botão MODE por 3 segundos, até que o led RGB fique piscando em azul. Para saber mais sobre o significado dos diferentes status do LED, visite esta documentação do Particle IO.

Particle IoT Board

2. Abra o aplicativo Particle IoT no seu telefone e crie uma conta, se ainda não tiver uma, ou faça login com suas credenciais do Particle.

Login de partícula

3. Agora, para adicionar nosso dispositivo de argônio, pressione o botão “+” para adicionar o dispositivo. Pressione novamente “+” na frente de Configurar argônio, boro ou xenônio .

Configuração do kit de partículas de argônio

4. Para se comunicar com o aplicativo, o Argon usa o Bluetooth, então ele pedirá para habilitar o Bluetooth no smartphone. Agora, escaneie o código QR impresso na placa do Argon para conectar o dispositivo ao smartphone.

Setup Particle Argon Kit

5. Em seguida, ele perguntará se você conectou a antena ou não. Se você conectou a antena, marque a caixa e clique em Avançar. Agora, ele será emparelhado com o telefone.

Configurar Argônio de Partículas

6. Em seguida, ele solicitará a conexão com a rede Mesh. Como não estamos usando Mesh, pressione Não tem rede mesh e clique em Avançar .

Agora, temos que enviar as credenciais da rede Wi-Fi para o Argon. No aplicativo, ele procurará as redes Wi-Fi, escolherá sua rede e digitará a senha. Depois disso, sua placa de argônio será conectada com sucesso à nuvem de partículas e você verá que a cor ciano está piscando lentamente em sua placa.

Configuração da placa de argônio

7. Agora, dê o nome ao seu tabuleiro de Argônio. Digite qualquer nome de sua escolha e clique em Avançar.

Configurar placa de argônio

8. Abra o navegador da web no laptop e digite o link setup.particle.io?start-building. Agora, estamos quase terminando a configuração. Para verificar se nosso Argônio está conectado com sucesso à nuvem, clique no botão Dispositivo de Sinal . As cores do arco-íris piscarão no LED de argônio.

Configurar partícula IO

9. Você pode sinalizar seu dispositivo usando o aplicativo. Clique no nome da sua placa e abra o dispositivo conforme mostrado abaixo. Você verá que a placa Argon está online. Na próxima tela, você encontrará o botão Sinal .

Configuração de partícula IO

10. Agora, estamos prontos para programar a placa Argon usando um IDE da web.

Programando placa Argon usando Web IDE

1. Vá para o Console do Particle e faça login com as credenciais de login no Particle App.

Configuração de partícula IO

2. Como você pode ver, existem muitas opções na parte esquerda da tela que incluem adicionar novos dispositivos, criar redes mesh, integração com IFTTT, Microsoft Azure e Web IDE. Além disso, você pode ver seu dispositivo listado na tela.

Programação Argon Board

3. Primeiro, clique na opção Web IDE. Uma nova guia será aberta com IDE online, conforme mostrado abaixo. Neste IDE, haverá bibliotecas para diferentes sensores e placas com alguns exemplos de código. Se você está familiarizado com o IDE do Arduino, você o achará muito fácil e sua estrutura de programação é a mesma do IDE do Arduino.

Particle Argon usando Web IDE

4. Usaremos um código de exemplo muito básico para piscar um LED . Então, clique no código de exemplo.

Programando Placa de Argônio de Partículas

5. A estrutura básica é a mesma do Arduino IDE, use a configuração void e a função void loop para escrever o código.

Agora, declare duas variáveis ​​para dois LEDs.

int led1 = D6; 
int led2 = D7;

6. Em void setup (), defina o modo pin como saída usando a função pinMode () para ambos os LEDs.

void setup () { 
  pinMode (led1, OUTPUT); 
  pinMode (led2, OUTPUT); 
}

7. Em void loop (), use a função digitalWrite () para fazer os LEDs ligarem e desligarem conforme mostrado abaixo.

void loop () { 
digitalWrite (led1, HIGH); 
digitalWrite (led2, HIGH); 
atraso (1000); 
digitalWrite (led1, LOW); 
digitalWrite (led2, LOW); 
atraso (1000); 
}

O código completo com um vídeo de demonstração é fornecido no final deste tutorial. Agora, compile este código clicando no botão Verificar na seção superior esquerda.

Programando Argon Board usando Web IDE

Se não houver erro no código, você encontrará a mensagem Código verificado na parte inferior da tela.

Agora, o código está pronto para ser exibido no tabuleiro de Argon. Certifique-se de ter conectado a placa ao laptop ou qualquer outra fonte de alimentação e também à internet. O LED RGB deve piscar lentamente na cor ciano, o que significa que sua placa está conectada à nuvem de partículas.

Agora, atualize o código clicando no botão de flash no canto superior esquerdo. Ele deve mostrar uma mensagem Flash bem – sucedido na tela, conforme mostrado abaixo. Para vê-lo em ação, conecte dois LEDs nos pinos D6 e D7 e reinicie a placa.

Particle Argon Programming

Desta forma, você pode escrever seu próprio código e fazer upload usando a funcionalidade OTA e tornar seu projeto mais inteligente.

Usando a funcionalidade do Tinker na placa de desenvolvimento de argônio

Há um exemplo de código especial no IDE da web chamado  Tinker . Depois de fazer o upload deste código na placa Argon, você pode controlar muitos pinos de uma vez sem codificá-lo. Além disso, você pode obter leituras do sensor sem especificar os pinos no código.

1. Assim que piscar o código de exemplo do Tinker, você verá que a opção Tinker está habilitada na opção do dispositivo de argônio, conforme mostrado. Clique na opção Tinker.

Placa de argônio usando a função Tinker

2. Agora, escolha o pino no qual deseja obter saída ou entrada. Ao clicar, você será solicitado a clicar em  digitalWrite ,  digitalRead ,  analogRead  e  analogWrite . Em nosso caso, clique em  digitalWrite  nos pinos D7 e D6.

Configuração de Argônio de Partículas

Após atribuir a função, basta clicar no pino D7 ou D6, o LED acenderá. Ao pressionar D7 novamente o LED apaga-se. Da mesma forma, você pode obter os dados do sensor em diferentes pinos e pode controlar os aparelhos ao mesmo tempo.

Você pode experimentar todos os códigos de exemplo para um melhor entendimento das diferentes funcionalidades da placa.

Além de usar um IDE on-line, você pode baixar o IDE do  Particle Desktop  e o Workbench, onde pode escrever código e fazer flash da mesma forma que um IDE on-line. Mas esses IDEs também são softwares de desenvolvimento online. Para obter mais informações sobre a nuvem de partículas, você pode verificar sua  documentação oficial aqui .

O código completo com um vídeo de demonstração  é fornecido abaixo.

Código

int led1 = D6; // Em vez de escrever D0 repetidamente, escreveremos led1

int led2 = D7; // Em vez de escrever D7 repetidamente, escreveremos led2

void setup () {
  pinMode (led1, OUTPUT);
  pinMode (led2, OUTPUT);
}

void loop () {
  // Para piscar o LED, primeiro vamos ligá-lo …
  digitalWrite (led1, HIGH);
  digitalWrite (led2, HIGH);

  // Deixaremos ligado por 1 segundo …
  delay (1000);

  // Então vamos desligar …
  digitalWrite (led1, LOW);
  digitalWrite (led2, LOW);

  // Aguarde 1 segundo …
  delay (1000);

  // E repita!
}

CÓDIGO TINKER
/ * Protótipos de função ——————————————– ———– * /
int tinkerDigitalRead (pino de string);
int tinkerDigitalWrite (comando String);
int tinkerAnalogRead (pino de string);
int tinkerAnalogWrite (comando String);

/ * Esta função é chamada uma vez na inicialização ———————————- * /
void setup ()
{
// Configure o aplicativo Tinker aqui

// Registra todas as funções do Tinker
Particle.function (“digitalread”, tinkerDigitalRead);
Particle.function (“digitalwrite”, tinkerDigitalWrite);
Particle.function (“analogread”, tinkerAnalogRead);
Particle.function (“analogwrite”, tinkerAnalogWrite);
}

/ * Esta função entra em loop para sempre ——————————————– * /
void loop ()
{
// Isso será executado em um loop
}

/ ************************************************** ********************************
 * Nome da Função: tinkerDigitalRead
 * Descrição: Lê o valor digital de um determinado pino
 * Entrada: Pin
 * Saída: Nenhum.
 * Retorno: Valor do pino (0 ou 1) no tipo INT
                    Retorna um número negativo em caso de falha
 **************************** *************************************************** /
int tinkerDigitalRead (String pin)
{
// converter ascii em inteiro
int pinNumber = pin.charAt (1) – ‘0’;
// Verifique se os números dos pinos estão dentro dos limites
if (pinNumber <0 || pinNumber> 7) return -1;

if (pin.startsWith (“D”))
{
pinMode (pinNumber, INPUT_PULLDOWN);
return digitalRead (pinNumber);
}
else if (pin.startsWith (“A”))
{
pinMode (pinNumber + 10, INPUT_PULLDOWN);
retornar digitalRead (pinNumber + 10);
}
return -2;
}

/ ************************************************** ********************************
 * Nome da Função: tinkerDigitalWrite
 * Descrição: Define o pino especificado como ALTO ou BAIXO
 * Entrada: Pino e valor
 * Saída: Nenhum.
 * Retorno: 1 em caso de sucesso e um número negativo em caso de falha
 *************************************** ******************************************* /
int tinkerDigitalWrite (comando String)
{
bool valor = 0;
// converte ascii em inteiro
int pinNumber = command.charAt (1) – ‘0’;
// Verifique se os números dos pinos estão dentro dos limites
if (pinNumber <0 || pinNumber> 7) return -1;

if (command.substring (3,7) == “HIGH”) valor = 1;
else if (command.substring (3,6) == “LOW”) valor = 0;
senão return -2;

if (command.startsWith (“D”))
{
pinMode (pinNumber, OUTPUT);
digitalWrite (pinNumber, value);
return 1;
}
else if (command.startsWith (“A”))
{
pinMode (pinNumber + 10, OUTPUT);
digitalWrite (pinNumber + 10, valor);
return 1;
}
else return -3;
}

/ ************************************************** *******************************
 * Nome da Função: tinkerAnalogRead
 * Descrição: Lê o valor analógico de um pino
 * Entrada: Pin
 * Saída: Nenhum.
 * Retorno: Retorna o valor analógico no tipo INT (0 a 4095)
                    Retorna um número negativo em caso de falha
 ***************************** *************************************************** /
int tinkerAnalogRead (String pin)
{
// converter ascii em inteiro
int pinNumber = pin.charAt (1) – ‘0’;
// Verifique se os números dos pinos estão dentro dos limites
if (pinNumber <0 || pinNumber> 7) return -1;

if (pin.startsWith (“D”))
{
return -3;
}
else if (pin.startsWith (“A”))
{
return analogRead (pinNumber + 10);
}
return -2;
}

/ ************************************************** *******************************
 * Nome da Função: tinkerAnalogWrite
 * Descrição: Grava um valor analógico (PWM) no pino especificado
 * Entrada: Pino e valor (0 a 255)
 * Saída: Nenhum.
 * Retorno: 1 em caso de sucesso e um número negativo em caso de falha
 *************************************** ****************************************** /
int tinkerAnalogWrite (comando String)
{
/ / converter ascii para inteiro
int pinNumber = command.charAt (1) – ‘0’;
// Verifique se os números dos pinos estão dentro dos limites
if (pinNumber <0 || pinNumber> 7) return -1;

Valor da string = command.substring (3);

if (command.startsWith (“D”))
{
pinMode (pinNumber, OUTPUT);
analogWrite (pinNumber, value.toInt ());
return 1;
}
else if (command.startsWith (“A”))
{
pinMode (pinNumber + 10, OUTPUT);
analogWrite (pinNumber + 10, value.toInt ());
return 1;
}
else return -2;
}

Leave your thought here

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Open chat