Tutoriais

Como utilizar as placas, sensores e componentes comprados com a L3K? É só buscar seu produto abaixo (caso não o encontre, nos envie um e-mail que postaremos em 1 dia útil)!

Sensores

Displays

Módulos

Drivers

 


 

Sensores

Sensor de Batimento Cardíaco KY-039

Ao executar o programa, os valores medidos são enviados para o Monitor Serial. Este projeto utiliza o Sensor de Batimento Cardíaco KY-039, baseado em um LED IR (infravermelho) e um fototransistor para detectar o batimento no dedo, sendo que um LED vermelho pisca com cada batimento. O monitor de pulso funciona da seguinte forma: o LED IR é posicionado de um lado do dedo e o fototransistor no outro lado. Quando o coração bate, o fluxo se altera e o infravermelho recebido pelo fototransistor é ligeiramente alterado.

Alterar o sensorPino para o pino que deseja conectar o sensor, neste caso estamos utilizando o pino 2.

Os valores obtidos são enviados para o Monitor Serial.

 


 

Sensor de Taxa de Batimento Cardíaco e Oxímetro MAX30100

O Sensor de Taxa de Batimento Cardíaco e Oxímetro MAX30100 é a nossa nova adição à nossa open-source para monitoramento de variáveis do corpo humano. O chip da Maxim, o MAX30100, é um ótimo e novíssimo produto que combina tudo o que é necessário para um oxímetro e monitor de taxa de batimento cardíaco, com o sensor fazendo parte do próprio chip! Medindo 18 mm de largura e 14 mm de comprimento, esta placa é facilmente presa ao dedo para medir o pulso de sangue.

Nota Importante: Este sensor destina-se apenas a ser usado para fins de pesquisa e NÃO deve ser usado como um dispositivo médico.

Características:

  • O próprio chip integra o sensor óptico
  • Fácil de usar, com interface I2C basta conectá-lo ao Arduino ou outro microcontrolador
  • Biblioteca Arduino disponível
  • Software de Testes para Processing IDE disponível
  • Calcula o SpO2 – nível de saturação de oxigênio no sangue
  • Monitor de PPG – taxa de freqüência cardíaca em tempo real

ANTES DE ACHAR QUE NÃO FUNCIONA: esta placa não acende nenhum LED quando alimentada. O LED do sensor é infravermelho e nós não conseguimos enxergar infravermelho, portando não se desespere!

Biblioteca e Software

Você vai precisar da Biblioteca Batimento Cardiaco Oximetro MAX30100,  disponível na aba “Downloads”.

Dentro deste arquivo você vai encontrar:

  • /Software – biblioteca Arduino, software para Processing IDE e exemplos
  • /extras – o datasheet

Conectando ao Arduino

Faça esta simples conexão entre o módulo e o Arduino:

Arduino Módulo
5V VIN
A5 SCL
A4 SDA
GND GND

 

ATENÇÃO: este sensor não possui resistores pull-ups nas linhas SCL e SDA, necessários para a comunicação I2C. Caso haja outros dispositivos no barramento I2C, não há necessidade de se preocupar, pois o pull-up deles farão o papel de colocar as duas linhas em nível alto. Mas caso o MAX30100 seja o único dispositivo I2C, acrescentar resistores de 4K7 ou 10K como pull-ups nas linhas SCL e SDA. Recomendamos fortemente o uso do I2CScanner (disponível na aba DOWNLOADS) para verificar se o sensor está sendo encontrado no barramento I2C.

Usando o Processing: Software de Visualização de Dados

O Processing é um software de visualização de dados, que existe desde 2001, utilizado tanto por artistas como por cientistas. É uma estrutura de codificação open-source baseada em Java. Se você está familiarizado com o ambiente Arduino IDE, o Processing IDE é semelhante, e você não terá muita dificuldade de aprender a utilizar!

Seguem-se as etapas para executar o código:

1. Faça o download do Processing para seu sistema operacional

Faça o download do Processing IDE em sua última versão diretamente dos links:

Uma vez baixado, descompacte e instale.

2. Baixe o código do Processing para a visualização do oxímetro

a. Faça o download dos arquivos e diretórios necessários encontrados na Biblioteca Batimento Cardiaco Oximetro MAX30100,  disponível na aba “Downloads”.

b. Descompacte o arquivo, e dentro da pasta “Pulse-master > Software > Processing” contém o código de visualização.

c. Localize o diretório de sketch do Processing no seu computador. Ele é automaticamente criado quando você instalou o Processing. Dependendo do seu sistema operacional, o caminho será o seguinte:

No Windows: “C:/Meus documentos/Processing/”
No MAC: “/Users/seu_user_name/Documents/Processing/”
No Linux: “/Home/seu_user_name/sketchbook/”

Nota: Este diretório aparece como “Processing” no Windows / Mac, e aparece como “Sketchbook” no Linux. Crie um subdiretório com o nome “libraries” se não existir.

d. Do diretório “Pulse-master > Software > Processing/openview_oximeter” copie ou mova seu conteúdo para diretório de sketch do Processing.

e. Instale a biblioteca MAX30100.zip em seu Arduino IDE, encontrada em “Pulse-master\Software\Arduino”. Abra e carregue o sketch exemplo PPG_plot.

f. Você está pronto para obter a sua primeira forma de onda PPG e a leitura SpO2 visualizada a partir do Processing!

3. Abrir o Processing e iniciar o openview_oximeter

a. Com as bibliotecas e sketches instaladas, abra o Processing IDE.

b. Clique duas vezes em qualquer um dos arquivos .pde no diretório openview_oximeter para abrir o código do oxímetro no Processing IDE.

c. Se tudo feito corretamente até agora, clicando no botão “run” no canto superior esquerdo do IDE, o software deve executar o código!

d. Uma vez que a GUI está em execução, selecione a porta serial conectada ao Arduino em “SELECT PORT”, conforme mostrado na figura abaixo:

e. Uma vez que a porta serial esteja apropriadamente selecionada, o botão “START” esterá habilitado, e clicando nele a visualização iniciará.

f. Você será capaz de ver as ondas PPG bem como o valor de SpO2, conforme abaixo:

 

Se se interessou por este artigo mas ainda não tem o sensor, ele está a venda AQUI

 


 

Displays

Display LCD com Módulo I2C

 

Alimente o display com 5V e faça as conexões I2C normalmente. No arduino UNO, o SDA é no pino A4 e o SCL é no pino A5. Para outros Arduinos, basta uma consulta no Google.

Para que o display funcione corretamente, você precisa saber o endereço I2C dele. Se não sabe ou não tem certeza, utilize o sketch I2CScanner.ino que está disponível na aba “Downloads”. Você vai precisar também da biblioteca NewliquidCrystal_1.3.4, também disponível na aba “Downloads”.

Neste exemplo, o nosso display possui o endereço 0x3F. Caso o seu módulo I2C possua um valor de endereço diferente, basta substituir o 0x3F do código.

Nota: para testar utilize o código acima. Não rode os exemplos da biblioteca (exemplo: HelloWorld_i2c) pois muitos possuem erros e fará com que o backlight fique piscando com caracteres estranhos, dando a impressão que há algo de errado no hardware.

Um detalhe importante: caso não apareça nada no display ou apareça somente retângulos brancos, ajuste o contraste pelo trimpot no módulo I2C.

 


 

Display 8 Dígitos 7 Segmentos MAX7219
O display com 8 dígitos de 7 segmentos controlados pelo MAX7219 necessita de apenas 3 pinos de dados para seu controle. Com ele você pode não apenas mostrar números, mas alguns caracteres em 7 segmentos. Uma outra característica deste display é que pode ser interligado em cascata com outros displays iguais.Abaixo vemos a pinagem do display:

 

 

A biblioteca que utilizaremos é a LedControl, que você encontra na aba “DOWNLOADS” no respectivo produto.

Esta é a inicialização da biblioteca LedControl usados no sketch exemplo:

LedControl display = LedControl  (din, clk, load, quantidade_de_módulos) Configura os pinos conectados no arduino. Você pode alterar estes pinos à vontade. O parâmetro quantidade_de_módulos representa o número de displays quando ligados em cascata.

Estes são os principais comandos da biblioteca LedControl usados no sketch exemplo:

Nos comandos abaixo, o parâmetro módulo é o número do módulo que se quer escrever. Caso haja apenas um módulo este parâmetro deve ser (zero); e o parâmetro dígito corresponde ao número do dígito no display, como temos 8 dígitos, este parâmetro deve estar entre 0 e 7.

display.clear(módulo) Este comando serve para limpar o display.

display.shutdown(módulo, FALSE) Este serve para desliga-lo sem perder os dados da memória. Para ligar o display novamente é só enviar o comando display.shutdown (módulo, TRUE) que os dados aparecem.

display.setIntensity(módulo, valor) Regula o brilho do display. O parâmetro valor é o nível de brilho sendo 0 o mínimo e 15 o máximo.

display.setDigit(módulo, dígito, valor, ponto_decimal) Usado diretamente para enviar um número ao display. O parâmetro ponto_decimal pode ser ligado ou desligado, utilizando TRUE ou FALSE.

 

Podemos escrever em 7 segmentos também, ligando apenas determinados segmentos do display, usamos o comando display.setRow(), que tem a seguinte sintaxe :

display.setRow(módulo, dígito,  valor)  Podemos definir valor em decimal, hexa ou binário, mas o comando fica mais fácil de entender se utilizarmos binário.

Por exemplo, para escrevermos a letra “r”, usamos este comando:

display.setRow(módulo, dígito, B00000101)

Que significa que estamos acionando apenas os segmentos E e G do display. A figura abaixo mostra exatamente como isso funciona:

Escolha os segmentos que você deseja ligar ou desligar, alterando o valor do bit correspondente para 1 ou 0.

 


 

Módulos

Módulo de Reconhecimento de Voz Elechouse V3.1

 

O módulo de reconhecimento de voz da ELECHOUSE é uma placa compacta e fácil de controlar. Este produto é um módulo de reconhecimento de voz dependente do locutor (reconhece apenas a voz de quem gravou os comandos).

Ele suporta até 80 comandos de voz no total. No máximo 7 comandos de voz podem trabalhar ao mesmo tempo se forem utilizados os pinos de saída, no entanto se for utilizada a porta serial, os 80 comandos podem ser transmitidos.

Qualquer som pode ser treinado como comando. Os usuários precisam treinar o módulo antes de deixá-lo reconhecer qualquer comando de voz.

Para iniciar sua programação você vai precisar de sua biblioteca, portanto baixe-a na aba “DOWNLOADS”. O seu manual é bem útil e explicativo e pode ser baixado na aba “DOWNLOADS”.

Conectando ao Arduino

Faça esta simples conexão entre o módulo e o Arduino:

Arduino Módulo
5V VCC
2 TX
3 RX
GND GND

 

Ficará assim:

 

 

Ensinando

Conecte o microfone ao módulo e o Arduino ao cabo USB. Abra o exemplo:

“Arquivo > Exemplos > VoiceRecognitionV3 > vr_sample_train”

Carregue no Arduino e abra o Monitor Serial com as seguintes configurações: “115200″ e “Ambos, NL e CR”.

A página de treinamento abrirá. Caso seja a primeira vez que está usando o módulo ou quer apagar toda a memória de comandos digite clear e pressione Enter.

Você pode ensinar até 80 comandos (0 a 79). Para ensinar o comando 0, por exemplo digite no Monitor Serial:  sigtrain 0 ligar, onde sigtrain significa ensinar com assinatura, é o número do comando que quer ensinar, no caso o 0, e ligar é apenas a assinatura, um nome, que está dando a este comando, no caso “ligar” (pode ser qualquer nome).

Ao digitar sigtrain 0 ligar e pressionar Enter. A seguinte frase aparecerá:

Record: 0     Speak now

 

Toda vez que a frase Speak now aparecer você fala o comando. Fale “ligar”. A seguinte frase aparecerá:

Record: 0     Speak again

 

Quando a frase Speak again aparecer você repete o mesmo comando. Fale “ligar”.

O módulo comparará os dois comandos que falou e se são idênticos. Caso não sejam, a seguinte frase aparecerá e o processo se repetirá.

Record: 0     Cann’t matched

 

Você tem de falar as duas vezes de modo idêntico, portanto o volume, a entonação da voz, e a distância do microfone, afetam o resultado.

Quando os dois comandos que falou forem idênticos aparecerá:

Record: 0     Success
Success 1  
Record: 0     Trained
SIG:     On

 

O resultado de tudo descrito acima é a seguinte tela:

Record: 0     Speak now
Record: 0     Speak again
Record: 0     Cann’t matched
Record: 0     Speak now
Record: 0     Speak again
Record: 0     Success
Success 1  
Record: 0     Trained
SIG:     On

 

Agora que já sabe como treinar os comandos, vamos preparar dois comandos para o exemplo. Treine o comando 0 falando “ligar” e o comando 1 falando “desligar”. Lembre-se, você utilizará o sigtrain da seguinte maneira: sigtrain 0 ligar até obter sucesso, e sigtrain 1 desligar até obter sucesso.

Agora você precisa carregar os dois comandos gravados utilizando load, no caso carregaremos os comandos 0 e 1 já gravados, portanto digite load 0 1 e pressionar Enter. A seguinte tela aparecerá:

Load success: 2
Record 0     Loaded
Record 1     Loaded

 

Para testarmos, abra o exemplo:

“Arquivo > Exemplos > VoiceRecognitionV3 > vr_sample_control_led”

Carregue no Arduino e abra o Monitor Serial com as seguintes configurações: “115200″ e “Ambos, NL e CR”.

Fale ao microfone a palavra “ligar”. Caso o módulo reconheça seu comando o LED da placa do Arduino acenderá. Fale ao microfone a palavra “desligar”. Caso o módulo reconheça seu comando o LED da placa do Arduino apagará. No Monitor Serial é possível ver o resultado bem como o número dos comando e suas assinaturas.

Veja abaixo o resultado:

 

Para compreender como o código por inteiro funciona, abra o exemplo “Arquivo > Exemplos > VoiceRecognitionV3 > vr_sample_train” e no Monitor Serial dê um clear para apagar tudo. Grave o comando “liga” da seguinte maneira: sigtrain 15 ligar , e o comando “desliga” da seguinte maneira: sigtrain 79 desligar. Carregue da seguinte maneira: load 15 79.

Abra o exemplo “Arquivo > Exemplos > VoiceRecognitionV3 > vr_sample_control_led” e altere as linhas:

Carregue no Arduino e abra o Monitor Serial. Você verá que o resultado será o mesmo, o LED acende ao falar “liga” e apaga ao falar “desliga”, mas agora utilizando os comandos número 15 e 79!

Mais detalhes, leia o manual por completo pois é muito interessante.

 


 

Módulo SSD EEPROM 256Kb I2C

O módulo SSD L3K possui memória EEPROM de 256Kb, o que representa 32.768 posições de memória de 8bits (0 a 32.767), ideal para data loggers e grandes tabelas. A biblioteca que utilizaremos é a SSDL3K, que você encontra na aba “DOWNLOADS” no respectivo produto, trabalhando com gravação e leitura de byte, int e long. Ela possui um exemplo fácil de entender.

O módulo SSD L3K possui endereçamento programável, o que garante que não haverá conflitos em seu barramento I2C, permitindo ainda a utilização de até 8 módulos, cada um com um endereço diferente. O endereçamento é muito simples, bastando jumpear com solda as ilhas A0, A1 e A2.

Para alterar o endereço do módulo é muito simples, basta uma pequena solda nas ilhas de jumper. Estas ilhas foram projetadas para, quando a solda for aplicada, “puxar” o estanho e manter os dois lados do jumper conectados. Caso queira remover um jumper feito, basta passar a ponta do ferro de solda rapidamente sobre a solda do jumper retirando o estanho ou utilizar um sugador de solda.

O endereço padrão (sem nenhum jumper fechado) é 0x50. Abaixo segue a tabela de endereços vs. jumpers.

Endereço A0 A1 A2
0x50 aberto aberto aberto
0x51 fechado aberto aberto
0x52 aberto fechado aberto
0x53 fechado fechado aberto
0x54 aberto aberto fechado
0x55 fechado aberto fechado
0x56 aberto fechado fechado
0x57  fechado  fechado  fechado

 

As funções disponíveis na biblioteca são:

Utilize, para byte:
writeSSD(endereço_I2C, endereço_na_memória, valor_até_255);
readSSD(endereço_I2C, endereço_na_memória);

Utilize, para int:
writeIntSSD(endereço_I2C, endereço_inicial_na_memória, valor_até_65535);
readIntSSD(endereço_I2C, endereço_inicial_na_memória);

Utilize, para long:
writeLongSSD(endereço_I2C, endereço_inicial_na_memória, valor_até_4294967295);
readLongSSD(endereço_I2C, endereço_inicial_na_memória);

O endereço_I2C deve estar entre 0x50 e 0x57 de acordo com os jumpers.

O endereço_na_memória deve estar entre 0x0000 e 0x7FFF (0 e 32767).

Estas funções de leitura e escrita são válidas para a maioria dos Arduinos (Pro Mini, Nano, UNO, Mega) . Já no caso do Arduino Due, por exemplo, a int é formada por 4 bytes, portanto o programador deve levar isso em consideração.

Ao trabalhar com int ou long, cuidado para não sobrescrever bytes como por exemplo:

Neste caso a primeira chamada gravou 2598 nas posições de memória 10 e 11, mas quando fez a segunda chamada ela gravou 1234 nas posições de memória 11 e 12, sendo que a 11 já estava em uso. Portanto o correto seria:

Neste caso a primeira chamada gravou 2598 nas posições de memória 10 e 11, e a segunda chamada gravou 1234 nas posições de memória 12 e 13.


 

Drivers

Driver L298n Motor De Passo Ou Ponte H
Aprenda como usar o driver L298N  para motor de passo ou motores em ponte H.
O driver L298N permite controlar a velocidade e direção de dois motores DC ou um motor de passo bipolar com extrema facilidade. O L298N pode ser utilizado com motores de tensão entre 5 e 35VDC, portanto a alimentação do driver deve estar de acordo com o motor utilizado. Caso a alimentação seja menor ou igual a 12V, o driver L298N vendido pela L3K possui um regulador de 5V onboard, muito conveniente para alimentar por exemplo, o próprio
Arduino. Para tensões acima de 12V, o regulador de 5V fica desabilitado.

 

Primeiramente vamos ver as conexões, e explicar como controlar motores DC e posteriormente motor de passo.

 

Veja as conexões do driver L298N abaixo:
  1.  Motor DC 1 “+” ou Motor de Passo A+
  2.  Motor DC 1 “-” ou Motor de Passo A-
  3.  Jumper – remova se for utilizar uma tensão maior que 12V. Este jumper habilita o regulador de 5V onboard
  4.  Tensão de alimentação do motor (máx. 35VDC). Remova o Jumper “3” se a tensão for maior que 12VDC
  5.  GND
  6.  Saída 5VDC se o jumper “3” estiver conectado. Pode ser usado para alimentar o Arduino
  7.  Jumper ENA do Motor DC 1. Deixe conectado se for utilizar um motor de passo. Retire se for utilizar uma saída PWM para controle de velocidade do motor DC.
  8.  IN1
  9.  IN2
  10.  IN3
  11.  IN4
  12.  Jumper ENB do Motor DC 2. Deixe conectado se for utilizar um motor de passo. Retire se for utilizar uma saída PWM para controle de velocidade do motor DC.
  13. Motor DC 2 “+” ou Motor de Passo A+
  14. Motor DC 2 “-” ou Motor de Passo A-

Controlando Motor DC

Controlar um ou dois motores DC com este driver é fácil. Primeiro conecte cada motor às conexões A e B. Caso esteja utilizando os motores em um veículo ou robô por exemplo, garanta que a polaridade seja a mesma nas duas conexões.

Conecte sua fonte de alimentação ao pino 4 e 5. Se a tensão de alimentação for igual ou menor que 12V deixe o jumper 3 conectado e você terá 5V no pino 6. Lembre que o Arduino não possui corrente suficiente para alimentar motores.

Agora você precisa de seis pinos digitais do Arduino, sendo que dois deles devem ser PWM, com o símbolo “~”.

Finalmente conecte os pinos do Arduino ao L298N. Neste exemplo estaremos controlando dois motores DC com controle de velocidade. Para o nosso exemplo, conectamos:

  • IN1: D9
  • IN2: D8
  • IN3: D7
  • IN4: D6
  • Remova o jumper 7 e conecte o D10
  • Remova o jumper 12 e conecte o D5
  • 4 ao +5V
  • 5 ao GND

Os motores giram enquanto os pinos ENA ou ENB recebem nível alto, e param quando ENA ou ENB recebem nível baixo. Como teremos controle de velocidade, pinos PWM estarão conectados ao ENA e ENB e o PWM cuidará disso..

Abaixo um sketch de demonstração com um Arduino UNO e dois motores DC conectados como acima descrito:

Controlando Motor de Passo

Motores de passo parecem complexos, mas não é verdade. Neste exemplo vamos controlar um motor de passo comum tipo NEMA-17 que possui quatro fios com 200 passos por volta, e vamos girá-lo a 60RPM.

A chave do sucesso para controlar motores de passo é a identificação de seus fios. Você deve determinar os fios A+, A-, B+ e B-.

Como identificar os fios do motor de passo bipolar

Segue um procedimento simples para identificação dos pares e fios:

O motor de passo bipolar possui quatro fios provenientes de duas bobinas:

A bobina dos fios A+ e A- é completamente isolada da bobina dos fios B+ e B-. Para identificá-los faça o seguinte procedimento com ajuda de um multímetro ajustado em continuidade:

  1. Com uma fita ou papel, marque qualquer um dos quatro fios como sendo “A+”.
  2. Coloque uma ponta do multímetro no fio “A+” e teste em qual dos três fios restantes apresenta continuidade.
  3. No fio que apresentar continuidade marque “A-“.
  4. Foi identificado uma bobina que chamamos de “A” e seus respectivos fios. Os dois fios restantes são da bobina “B”. Infelizmente não há como identificar com multímetro qual a polaridade dos fios da bobina “B”, mas pelo menos o motor irá girar com as instruções abaixo, e aí será possível identificar as polaridades. Continue o tutorial e volte ao ponto 5 abaixo.
  5. Caso você configure o motor para girar em sentido horário e isso acontecer, o fio ligado ao pino 13 é o “B+” e o ligado no pino 14 é o “B-“. Agora, caso você configure o motor para girar em sentido horário e ele girar em sentido anti-horário a polaridade dos fios está invertida. Inverta os fios ligados nos pinos 13 e 14, o motor passará a girar corretamente e você pode identificar o fio ligado ao pino 13 como “B+” e o ligado no pino 14 como “B-“.

Continuando…

Conecte os fios A+, A-, B+ e B-  do motor de passo às conexões 1, 2, 13 e 14 da foto respectivamente (caso não saiba a polaridade dos fios da bobina “B”, apenas conecte seus fios aos pinos 13 e 14 e volte ao ponto 5 do passo-a-passo acima após este tutorial). Conecte os jumpers nas posições 7 e 12. Conecte sua fonte de alimentação ao pino 4 e 5. Se a tensão de alimentação for igual ou menor que 12V deixe o jumper 3 conectado e você terá 5V no pino 6. Lembre que o Arduino não possui corrente suficiente para alimentar motores.

Finalmente conecte os pinos do Arduino ao L298N. Neste exemplo estaremos controlando um motor de passo bipolar. Para o nosso exemplo, conectamos:

  • IN1: D9
  • IN2: D8
  • IN3: D7
  • IN4: D6
  • 4 ao +5V
  • 5 ao GND

Controlar motor de passo com o nosso sketch exemplo é muito simples, graças à Biblioteca Stepper, abaixo da lista “Arquivo > Exemplos > Stepper”, inclusa como padrão na IDE do Arduino.

Como demonstração, simplesmente carregue o sketch exemplo “stepper_oneRevolution”.

No sketch exemplo, altere o número de passos por volta de acordo com o seu motor, no nosso caso “200”:

E também a velocidade para 60RPM na seguinte linha:

Agora carregue o sketch no Arduino, o que fará seu motor dar um giro em um sentido e retornar no sentido oposto. Isso é feito pela função abaixo:

Aí está, maneira simples e barata de se controlar motores com o módulo L298N com Arduino!