Placa Mult Função PDF

Machine Translated by Google
Hackatronics
Usando um
Escudo multifuncional do Arduino
Por Kashif Baig

© 2015 cohesivecomputing.co.uk
Hackatronics – Usando um escudo multifuncional Arduino cohesivecomputing.co.uk
Apresentando Hackatronics – Codificação para se divertir.......................................... .........................................3

Instalando a biblioteca de blindagem multifuncional. ................................................ ................................3
Mais sobre esta série............. ................................................ ................................................ ..3
Parte 1 Entrada/Saída Básica............................... ................................................ ......................5
Usando o bipe do escudo............................ ................................................ ................................5
Detecção de botões pressionados no escudo ........................ ................................................ .............................5
Escrevendo no display de dígitos do shield.............. ................................................ .............................6
Controlando as luzes de LED do escudo.............. ................................................ .............................7
Lendo o valor do potenciômetro da blindagem......... ................................................ ............7 Parte
2 Sensores de Leitura........................... ................................................ ................................9 Contando
pulsos............... ................................................ ................................................ ...........9 Lendo a
temperatura usando um sensor LM35........................... .........................................10 Usando um
módulo de sonar HC SR04.. ................................................ .........................................10 Obtendo
dados de um movimento MPU6050 sensor................................................. ......................11 Parte 3
Aplicações do mundo real............... ................................................ ................................14 Temporizador
de contagem regressiva.............. ................................................ ................................................ ......14
Relógio Despertador 24 Horas........................... ................................................ ......................15
Monitor cardíaco........................... ................................................ ................................................ ..19
Indicador de inclinação da superfície............................... ................................................ ..................21
Sonar ranger .............................. ................................................ .........................................23
Velocímetro... ................................................ ................................................ ......................24
Apêndices............................ ................................................ ................................................ .........27
Ajuda da Biblioteca de Escudo Multifuncional........................... ................................................ .....27
Ajuda do MPU6050............................... ................................................ ................................30
Apresentando Hackatronics - Codificação para se divertir
Quando eu tinha uns 10 anos, meus pais compraram para mim um computador C64, e logo eu estava aprendendo
a conectar alguns componentes básicos e sensores ao seu joystick e portas paralelas para tentar fazer algumas
coisas interessantes. Isso foi em 1983. Em uma ocasião, consegui fritar este computador de £ 350 enquanto soldava
um fio que estava conectado a uma porta quando foi ligado.
Felizmente, consertei o C64 a um custo mínimo, mas não tente fazer algo assim sozinho.
Hoje, a linha de microcontroladores Raspberry Pi e Arduino é uma ótima maneira de começar a aprender a escrever código que se conecta
com o mundo exterior. Além disso, existem inúmeros add-ons eletrônicos com componentes já embutidos neles, prontos para serem
utilizados com um pouco de código. Um desses complementos é um escudo Arduino multifuncional disponível a baixo custo em
fornecedores da Internet, sendo um deles o Hobby Components:
E/S simples que geralmente são consideradas normais em PCs, como ler teclas pressionadas, enviar para
uma tela e soar um alarme, muitas vezes atrapalham o foco da tarefa principal ao desenvolver para microcontroladores.
É por esta razão que desenvolvi uma biblioteca para este escudo multifuncional que simplifica as operações de E/
S básicas e mundanas. Também forneço um conjunto de aplicativos do mundo real que fazem uso dessa biblioteca
como parte de uma série de codificação, para que os novatos em codificação no Arduino possam experimentá-
los e aprimorá-los. Bem, foi assim que aprendi a programar há tantos anos.
Presume-se alguma familiaridade com a plataforma Arduino, assim como a instalação do ambiente de
desenvolvimento Arduino . um vídeo de demonstração de alguns dos aplicativos do Arduino está disponível no meu
site.
Instalando a biblioteca de blindagem multifuncional Se

ainda não o fez, você precisará primeiro instalar o TimerOne e Software I2C bibliotecas usando instruções
para instalar bibliotecas do Arduino.
Você pode baixar a biblioteca de escudos multifuncionais no link abaixo e instalá-la como uma biblioteca .zip,
consultando as instruções no link acima:
• Biblioteca de escudos multifuncional •

Todo o código-fonte usado em série
Se, por algum motivo, você não tiver conseguido instalar nenhuma das bibliotecas, faça o download deste pacote
de bibliotecas em vez disso, descompacte e copie para a pasta Documents\Arduino\libraries (se estiver
usando o Windows) ou sistema operacional equivalente. Embora façamos tudo para garantir que nossos
downloads estejam livres de vírus e malware, verifique se o software de verificação de vírus e malware está
atualizado com antecedência.
Devo salientar que, ao seguir a série Hackatronics, você concorda em fazê-lo por sua conta e risco e concorda em
assumir total responsabilidade por qualquer perda ou dano que possa incorrer em si mesmo ou em outros. Se você
é uma criança começando, certifique-se de ter a supervisão de um adulto responsável.
Mais sobre esta série

Esta série está dividida em três partes principais:
1. Entrada / Saída Básica
Página 3 de 30
2. Sensores de leitura 3.
Aplicações no mundo real
A Parte 1 demonstra a facilidade com que os botões multifuncionais, o bipe e o visor do escudo podem ser utilizados usando
a biblioteca de escudos, facilitando assim a concentração na lógica do aplicativo.
A Parte 2 demonstra como a biblioteca shield pode ser usada para ler valores de sensores externos, como temperatura, sonar e
sensores de movimento, e como processar pulsos eletrônicos de um sensor externo
fonte.
A Parte 3 explora os aplicativos de trabalho usando a biblioteca e o escudo multifuncional:
• Despertador de 24 horas •
Monitor cardíaco • – (requer sensor de pulso cardíaco)
Contador regressivo •
Indicador de nível de inclinação da superfície – (requer sensor de movimento MPU6050) •

Sonar ranger – (requer módulo de sonar HC SR04) • Velocímetro – (requer ímã e
interruptor reed)
Cada um deles tem um escopo a ser construído e expandido, mas deixo isso para você.
Obtenha codificação e divirta-se!
Página 4 de 30
Parte 1 Entrada/ Saída Básica
Esta é a primeira parte da série Applied Hackatronics para o escudo multifuncional do Arduino, que mostra como usar a
biblioteca de escudos para acessar os botões, campainha e visor do escudo multifuncional.
Se ainda não o fez, você precisará baixar o código-fonte e instalar as bibliotecas usando os links na introdução.
Ao seguir a série Hackatronics, você concorda em fazê-lo por sua conta e risco e concorda em assumir total
responsabilidade por qualquer perda ou dano que possa incorrer em si mesmo ou em outros.
Usando o bipe do escudo A biblioteca

multifuncional do escudo fornece uma maneira flexível de soar diferentes tipos de alarmes usando o bipe. O tempo real e
o som do bipe são controlados em segundo plano usando interrupções, o que significa que seu aplicativo pode
continuar se concentrando na execução de sua tarefa principal.
#include <TimerOne.h> #include

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
// coloque seu código de configuração aqui, para executar uma vez:
Timer1.initialize();
MFS.initialize(&Timer1); // inicializa a biblioteca de escudo multifuncional
// OBSERVAÇÃO o controle de bipe é executado em segundo plano, ou seja, beep() não bloqueia.
// bipe curto por 200 milissegundos MFS.beep();
atraso(1000);
// 4 bips curtos, repetidos 3 vezes.

MFS.beep(5, // bipe por 50 milissegundos // silêncio por 50 milissegundos
3, 5, // repita o ciclo acima 4 vezes 4, // loop 3 vezes
50 // espera 500 milissegundos entre os loops );
void loop() { // coloque

seu código principal aqui, para executar repetidamente:
Detecção de pressionamento de botão no escudo Com a

biblioteca de escudo multifuncional, diferentes tipos de pressionamento de botão podem ser detectados: pressionamento
curto, pressionamento longo, liberação do botão após pressionamento curto, liberação do botão após pressionamento
longo. O esboço abaixo exibe o tipo de pressionamento de botão na janela do monitor serial. Verifique o que acontece
quando você pressiona e/ou mantém vários botões juntos e por diferentes durações.

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
Página 5 de 30

Serial.begin(9600);
}

byte btn = MFS.getButton(); // Normalmente basta comparar o retorno

// valor para macros predefinidas, por exemplo
BUTTON_1_PRESSED,
// BUTTON_1_LONG_PRESSED etc.
if (btn) {
byte buttonNumber = btn & B00111111; byte buttonAction

= btn & B11000000;
Serial.print("BUTTON_");
Serial.write(buttonNumber + '0'); Serial.print("_");
if (buttonAction == BUTTON_PRESSED_IND) {
Serial.println("PRESSED");
} else if (buttonAction == BUTTON_SHORT_RELEASE_IND) {
Serial.println("SHORT_RELEASE");
} else if (buttonAction == BUTTON_LONG_PRESSED_IND) {
Serial.println("LONG_PRESSED");
} else if (buttonAction == BUTTON_LONG_RELEASE_IND) {
Serial.println("LONG_RELEASE");
}
}
}
Escrevendo no visor de dígitos do escudo O

gerenciamento do visor de dígitos do escudo multifuncional é executado em segundo plano usando
interrupções, o que significa que seu aplicativo pode continuar a se concentrar na execução de sua tarefa
principal. Os valores string, integer e float são gravados no display conforme demonstrado no esboço abaixo:

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
MFS.write("Olá");
atraso(2000);
MFS.write(-273);
atraso(2000);
MFS.write(3.141, 2); // exibe com 2 casas decimais. atraso(2000);
int contador=0; byte

finalizado = falso;
Página 6 de 30

if (contador < 200) {
MFS.write((int)counter); contador++;
} else if (!terminado) {
terminou = verdadeiro;
MFS.write("Fim");
MFS.blinkDisplay(DIGIT_ALL, ON);
} atraso(50);
}
Controlando as luzes de LED do escudo

Embora não seja estritamente necessário usar a biblioteca de escudo multifuncional para controlar as luzes
de LED do escudo, o suporte é fornecido nos casos em que seu aplicativo precisa dos LEDs para realizar
operações básicas de piscar. O piscar é gerenciado em segundo plano usando interrupções.

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
MFS.writeLeds(LED_ALL, ON); atraso(2000);

MFS.blinkLeds(LED_1
| LED_2, ON); atraso(2000); MFS.blinkLeds(LED_1 |
LED_2,
DESLIGADO);
MFS.blinkLeds(LED_3 | LED_4, ON); atraso(2000);
MFS.blinkLeds(LED_ALL, ON); atraso(2000);
MFS.blinkLeds(LED_ALL, OFF);
MFS.writeLeds(LED_ALL, OFF);
}

Lendo o valor do potenciômetro do escudo Este esboço

demonstra como o valor do potenciômetro predefinido é lido e exibido no escudo multifuncional. Depois de
carregar este esboço, gire o parafuso do potenciômetro para ver a mudança de leitura no visor de dígitos.

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
Página 7 de 30

}

MFS.write(analogRead(POT_PIN));
atraso(100);
}
Todos os exemplos de código e aplicativos foram testados e funcionam. Se você tiver alguma dificuldade,
deixe um comentário e entrarei em contato com você o mais rápido possível.
Página 8 de 30
Parte 2 Sensores de Leitura
Esta é a segunda parte da série Applied Hackatronics para o escudo multifuncional do Arduino e mostra como
a biblioteca de escudo multifuncional pode ser usada para ler valores de sensores externos, como temperatura,
sonar e sensores de movimento, e como processar componentes eletrônicos pulsos de uma fonte externa. Se
ainda não o fez, você precisará baixar o código-fonte e instalar as bibliotecas usando os links na introdução.
Contagem de pulsos
A biblioteca shield multifuncional tem suporte para contagem de pulsos (até 500 Hz) aplicados a um pino de
entrada do Arduino. A contagem de pulsos é gerenciada em segundo plano por meio de interrupções, o que
permite que seu aplicativo se concentre na execução de sua tarefa principal. Depois de carregar este esboço,
pressione repetidamente o botão 1 para gerar os pulsos e veja uma leitura da taxa de pressão no visor de dígitos.

<Wire.h> #include
<MultiFuncShield.h>
void setup() {
MFS.initPulseInCounter( BUTTON_1_PIN, //
use o botão 1 como meio de gerar pulsos. 1500, // o número de milissegundos para aguardar um pulso, antes
de redefinir o pulso no período para 0.
BAIXO // dispara pulso na entrada LOW.

);
}

// Obtém o período do pulso mais recente (em milissegundos).

// NOTA: as medições de pulso são realmente realizadas usando interrupções. unsigned int pulsePeriodMs =
MFS.getPulseInPeriod();
if (pulsePeriodMs == 0) {
MFS.write(0.0, 1);
} outro
{
MFS.write(1000.0 / pulsePeriodMs, 1); // calcula pulsos por segundo. Exibir até 1 casa decimal.
}
}
Página 9 de 30
Lendo a temperatura usando um sensor LM35 O shield

multifuncional possui um soquete para aceitar um sensor de
temperatura LM35, que deve ser inserido corretamente, caso contrário
você pode danificar irreparavelmente seu Arduino, ou computador conectado a ele.
Você saberá quando o sensor estiver conectado incorretamente,
pois ficará muito quente. A biblioteca de proteção multifuncional
fornece três níveis de filtragem para suavizar as leituras deste sensor:

<Wire.h> #include
<MultiFuncShield.h>
// NOTA: certifique-se de que o jumper J1 foi removido da blindagem e que o LM35 foi inserido corretamente.
void setup() {
// coloque seu código de configuração aqui, para executar uma
vez: Timer1.initialize();
// Inicializa usando um filtro passa-baixo.

// Escolha entre: SMOOTHING_NONE, SMOOTHING_MODERATE ou SMOOTHING_STRONG
MFS.initLM35(SMOOTHING_MODERATE);
}
void loop() { //
coloque seu código principal aqui, para executar repetidamente:
int tempCentigrade = MFS.getLM35Data(); // obter centígrados em 1/10 de grau.
MFS.write((float)tempCentigrade / 10, 1); // exibe a temperatura com 1 casa decimal.
atraso(100);
}
Usando um módulo de sonar HC SR04 Ao

usar um módulo de sonar HC SR04, é aconselhável usar a biblioteca
de proteção multifuncional para ler e calcular valores de distância se as
interrupções estiverem ativadas. A razão para isso é que a rotina
de serviço de interrupção da biblioteca afeta os requisitos de tempo deste
módulo de sonar e, como tal, a biblioteca compensa isso. A biblioteca
também oferece três níveis de filtragem para suavizar as leituras do
módulo de sonar. Os pinos de disparo e eco do módulo de sonar são
conectados aos pinos 5 e 6 do Arduino, respectivamente.

<Wire.h> #include
<MultiFuncShield.h>
const int TrigPin = 5;
Página 10 de 30
const int EchoPin = 6;
void setup() {
pinMode(TrigPin, OUTPUT);
pinMode(EchoPin, INPUT);
// inicializa com filtro passa-baixo: SMOOTHING_NONE, SMOOTHING_MODERATE ou

SMOOTHING_STRONG
MFS.initSonar(SMOOTHING_MODERATE);
}
void loop() { //
coloque seu código principal aqui, para executar repetidamente:
MFS.write((int)MFS.getSonarDataCm(TrigPin, EchoPin));
atraso(100);
}
Obtendo dados de um sensor de movimento MPU6050

O escudo multifuncional não expõe os pinos I2C de hardware de algumas
placas Arduino, como o Leonardo. O esboço a seguir usa a biblioteca Shield
para ler valores brutos do sensor MPU6050, usando a biblioteca Wire ou uma
implementação de software de I2C.
Faça o download do código-fonte completo para carregar o esboço em um
Arduino, após o que pressione o botão 1 no escudo para alternar o relatório
de dados do sensor e pressione o botão 2 para percorrer os valores de
aceleração, giroscópio e temperatura.
#define _SOFTI2C_H
#include <SoftI2CMaster.h> #include
<Wire.h> #include
<TimerOne.h> #include
<MultiFuncShield.h>
#include "SoftwareI2C.h" #include

"I2C.h" #include
"MPU6050.h"
#define SOFTWARE_I2C
MPU6050 MPU;
void displayHeading(modo byte);
void setup()
{ Serial.begin(9600);
// coloque seu código de configuração aqui, para executar uma

vez: Timer1.initialize();
#se definido (SOFTWARE_I2C)

// Usa o software I2C
Página 11 de 30
// Uno e Leonardo, use o pino 5 para SCL e 6 para SDA. Mega2560, use o pino A5 para
SDA.
SoftI2C1.initialize();
MPU.initialize(&SoftI2C1, MPU_DEFAULT_ADDRESS << 1); #else // Usa hardware I2C
Wire.begin(); I2C1.initialize(&Wire);
MPU.initialize(&I2C1,
MPU_DEFAULT_ADDRESS); #fim se
MFS.initialize(&Timer1); MFS.write("Acc");
byte exibirValores = verdadeiro; byte

displayMode = 0;

byte btn = MFS.getButton();
// Use o botão 1 para alternar o relatório dos valores do sensor. if (btn ==

BUTTON_1_PRESSED) {
exibirValues = !displayValues;
if (valores de exibição) {
displayHeading(displayMode);
} outro
{
MFS.write("Desligado");
}
}
if (valores de exibição) {
// Use o botão 2 para alternar entre os modos de exibição. if (btn ==

BUTTON_2_PRESSED) {
displayMode++;
if (displayMode == 3) {
displayMode = 0;
}
displayHeading(displayMode);
}
if (displayMode == 0) {
// exibe valores brutos de aceleração.

MPU.getAccelRaw();
Serial.print((float)MPU.accel_X_Raw / MPU.accelScaleValue); Serial.print("\t");
Serial.print((float)MPU.accel_Y_Raw /
MPU.accelScaleValue); Serial.print("\t"); Serial.print((float)MPU.accel_Z_Raw / MPU.accelScaleValue);
Serial.print("\t\n");
} else if (displayMode == 1) {
// exibe valores de giroscópios brutos

MPU.getGyroRaw();
Serial.print((float)MPU.gyro_X_Raw / MPU.gyroScaleValue);
Página 12 de 30
Serial.print("\t");
Serial.print((float)MPU.gyro_Y_Raw / MPU.gyroScaleValue); Serial.print("\t");
Serial.print((float)MPU.gyro_Z_Raw /
MPU.gyroScaleValue); Serial.print("\t\n");
} else if (displayMode == 2) {
// exibe o valor da temperatura.

Serial.println((float)MPU.getTemp10th() / 10);
}
}
atraso(50);
}
void displayHeading(modo byte) {
if (modo == 0) {
Serial.println("Aceleração em g (1g = 9,8 m/s/s)"); Serial.println("X\tY\tZ");

MFS.write("Acc");
} else if (modo == 1) {
Serial.println("Velocidade angular do giroscópio em graus / segundo"); Serial.println("X\tY\tZ");

MFS.write("Giroscópio");
} else if (modo == 2) {
Serial.println("Temperatura em graus Celsius."); MFS.write("Te");
}
}
Todos os exemplos de código e aplicativos foram testados e funcionam. Se você tiver alguma dificuldade,
deixe um comentário e entrarei em contato com você o mais rápido possível.
Página 13 de 30
Parte 3 Aplicações do mundo real
Esta é a terceira parte da série Applied Hackatronics para o escudo multifuncional do Arduino e explora os aplicativos
de trabalho usando a biblioteca e o escudo multifuncional. Se ainda não o fez, você precisará baixar o código-fonte e instalar
as bibliotecas usando os links na introdução.
Para cada um dos aplicativos abaixo, há um vídeo on-line que acompanha, bem como um vídeo resumo.
Temporizador de contagem regressiva
Este cronômetro de contagem regressiva é semelhante a um cronômetro de contagem regressiva que você pode encontrar
em um forno de micro-ondas. Você define o tempo, inicia a contagem regressiva e, quando chega a zero, o
alarme soa. Você pode pausar/continuar o cronômetro e redefinir para zero. Use os botões 2 e 3 do escudo multifuncional
para definir os minutos e os segundos. Um toque curto no botão 1 inicia ou para o cronômetro e um toque longo o redefine.
Possíveis melhorias para este aplicativo são ter um dispositivo ligado apenas enquanto o cronômetro está em contagem
regressiva.

<Wire.h> #include
<MultiFuncShield.h>
enum CountDownModeValues
{
COUNTING_STOPPED,
CONTAGEM
};
byte countDownMode = COUNTING_STOPPED;
décimos de byte = 0; char

segundos = 0; char minutos
= 0;
void setup() {
MFS.initialize(&Timer1); MFS.write(0); // inicializa a biblioteca de escudo multifuncional
Serial.begin(9600);
}

alternar (modo de contagem regressiva)

{
caso COUNTING_STOPPED:
if (btn == BUTTON_1_SHORT_RELEASE && (minutos + segundos) > 0) {
// inicia o cronômetro
countDownMode = COUNTING;
Página 14 de 30
} else if (btn == BUTTON_1_LONG_PRESSED) {
// redefine o cronômetro
décimos = 0;
segundos = 0;
minutos = 0;
MFS.write(minutos*100 + segundos);
} else if (btn == BUTTON_2_PRESSED || btn == BUTTON_2_LONG_PRESSED) {
minutos++; if
(minutos > 60) {
minutos = 0;
}
segundos += 10; if
(segundos >= 60) {
segundos = 0;
}
} quebrar;
CONTAGEM de casos:
if (btn == BUTTON_1_SHORT_RELEASE || btn == BUTTON_1_LONG_RELEASE) {
// para o cronômetro
countDownMode = COUNTING_STOPPED;
} outro
{
// continua contando décimos++;
if (décimos == 10) {
décimos = 0;
segundos--;
if (segundos < 0 && minutos > 0) {
segundos = 59;
minutos--;
}
if (minutos == 0 && segundos == 0) {
// timer chegou a 0, soe o alarme MFS.beep(50, 50, 3); // bipe 3 vezes,

500 milissegundos ligado / 500 desligado countDownMode = COUNTING_STOPPED;
} atraso(100);
} quebrar;
}
}
Despertador 24 horas
Página 15 de 30
Este aplicativo demonstra um relógio digital com capacidade de alarme. Quando o Arduino é ligado, o
display do escudo multifuncional pisca até que o usuário defina a hora. Segure o botão 1 para definir a hora
ou o alarme. Ao definir a hora, use o botão 3 para definir a hora ou os minutos. Pressione o botão 2 para
visualizar a hora do alarme ou cancelar o alarme se estiver em andamento. Segurar o botão 3 ativa ou desativa
o alarme (LED1 indica que o alarme está ativado). Possíveis aprimoramentos para este aplicativo são ter um
recurso de soneca ou vários períodos de ligar/desligar durante o dia para um dispositivo.

<Wire.h> #include
<MultiFuncShield.h>
/*
botão 1 : segure para definir a hora ou o alarme
botão 2 : pressione para ver a hora do alarme ou cancelar o alarme se estiver em andamento :
botão 3 incrementa hora / minuto ao definir a hora (de alarme). Segure para alternar
configuração de alarme.
LED1 : aceso = alarme ativado

*/
volátil unsigned int clockMilliSeconds = 0; byte volátil clockSeconds =

0; byte volátil clockMinutes = 0; byte volátil
clockHours = 12; byte volátil clockEnabled = 1;
byte alarmeMinutos = 30; byte

AlarmHours = 6; byte volátil
alarmEnabled = false;
byte alarmTogglePressed = false;
enum displayModeValues {
MODE_CLOCK_TIME,
MODE_CLOCK_TIME_SET_HOUR,
MODE_CLOCK_TIME_SET_MINUTE,
MODE_ALARM_TIME,
MODE_ALARM_TIME_SET_HOUR,
MODE_ALARM_TIME_SET_MINUTE };
byte displayMode = MODE_CLOCK_TIME;
//------------------------------------------------ ------------------------------- void setup() {
MFS.userInterrupt = clockISR;
MFS.initialize(&Timer1);
MFS.blinkDisplay(DIGIT_ALL); //
MFS.beep(500);
}
loop void() {
// coloque seu código principal aqui, para rodar repetidamente:
switch (displayMode) {
caso MODE_CLOCK_TIME:
displayTime(relógioHoras, relógioMinutos);
Página 16 de 30
if (btn == BUTTON_2_PRESSED) {
MFS.beep(0); // cancela o alarme. displayMode =

MODE_ALARM_TIME;
MFS.blinkDisplay(DIGIT_ALL, OFF);
MFS.blinkDisplay(DIGIT_1 | DIGIT_2); displayMode =
MODE_CLOCK_TIME_SET_HOUR; clockAtivado = false;
clockMilliSeconds = 0;
clockSegundos = 0;
} else if (btn == BUTTON_3_LONG_PRESSED && !alarmTogglePressed) {
alarmeTogglePressed = verdadeiro;
alarmEnabled = !alarmEnabled;
MFS.writeLeds(LED_1, alarmEnabled);
} else if (btn == BUTTON_3_LONG_RELEASE) {
alarmeTogglePressed = false;
} quebrar;
caso MODE_CLOCK_TIME_SET_HOUR:
MFS.blinkDisplay(DIGIT_1 | DIGIT_2, OFF); MFS.blinkDisplay(DIGIT_3

| DIGIT_4); displayMode = MODE_CLOCK_TIME_SET_MINUTE;
clockHoras++; if
(relógioHoras >= 24) {
clockHoras = 0;
} displayTime(relógioHoras, relógioMinutos);
} quebrar;
caso MODE_CLOCK_TIME_SET_MINUTE: if (btn ==

BUTTON_1_PRESSED) {
MFS.blinkDisplay(DIGIT_3 | DIGIT_4, OFF); displayMode =

MODE_CLOCK_TIME; clockEnabled = verdadeiro;
clockMinutos++; if
(relógioMinutos >= 60) {
clockMinutos = 0;
} displayTime(relógioHoras, relógioMinutos);
} quebrar;
caso MODE_ALARM_TIME:
displayTime(alarmHours,alarmMinutes);
if (btn == BUTTON_2_SHORT_RELEASE || btn == BUTTON_2_LONG_RELEASE) {
displayMode = MODE_CLOCK_TIME;
Página 17 de 30
MFS.blinkDisplay(DIGIT_1 | DIGIT_2); displayMode =
MODE_ALARM_TIME_SET_HOUR; alarmeAtivado = false;
} quebrar;
caso MODE_ALARM_TIME_SET_HOUR:
MFS.blinkDisplay(DIGIT_1 | DIGIT_2, OFF); MFS.blinkDisplay(DIGIT_3

| DIGIT_4); displayMode = MODE_ALARM_TIME_SET_MINUTE;
AlarmHours++; if
(alarmHours >= 24) {
horaalarme = 0;
} displayTime(alarmHours, alarmMinutes);
} quebrar;
caso MODE_ALARM_TIME_SET_MINUTE: if (btn ==

BUTTON_1_PRESSED) {
MFS.blinkDisplay(DIGIT_3 | DIGIT_4, OFF); displayMode =

MODE_CLOCK_TIME; alarmeAtivado = verdadeiro;
MFS.writeLeds(LED_1, ON);
alarmeMinutos++; if
(minutos de alarme >= 60) {
alarmeMinutos = 0;
} displayTime(alarmHours, alarmMinutes);
} quebrar;
}
}
void displayTime (byte horas, byte minutos) {
tempo de char[5];
sprintf(tempo, "%03d", (horas * 100) + minutos); MFS.write(tempo, 1);
//------------------------------------------------ -------------------------------- void clockISR () {
// Executa contagem de ondulação para todos os componentes de tempo. if (relógio

ativado) {
clockMilliSeconds++; if
(clockMilliSeconds >= 1000) {
clockMilliSeconds = 0;
clockSeconds++; if
(clockSeconds >= 60) {
clockSegundos = 0;
Página 18 de 30
clockMinutos++; if
(relógioMinutos >= 60) {
clockMinutos = 0;
clockHoras++; if
(relógioHoras >= 24) {
clockHoras = 0;
}
}
// Se a hora atual coincidir com a hora do alarme e o alarme estiver ativado, acione
o alarme.
if (alarmEnabled && (clockMinutes == alarmMinutes) && (clockHours == alarmHours)) {
MFS.beep(
10, // no período 5, // no
período off 4, // número de
ciclos 100, // número de ciclos de loop
50 // atraso entre os ciclos de loop );
}
}
}
}
}
Monitor cardíaco
Esta aplicação requer um sensor de batimento cardíaco semelhante

ao mostrado na imagem (que pode ser adquirido em vários
fornecedores da Internet), que usa luz infravermelha para detectar
pulsos em um dedo ou no lóbulo da orelha. Quando normalizado, o sensor
emite um sinal analógico de 2,5 volts, que sobe e desce sempre que o
fluxo sanguíneo muda devido a um batimento cardíaco. O aplicativo
funciona contando cada vez que o sinal sobe acima de 3 volts,
depois cai abaixo de 2,5 volts e mede o tempo entre os pulsos para
calcular as batidas por minuto. O bipe soa toda vez que um batimento
cardíaco é detectado. A saída do sensor precisará ser conectada ao pino
A5 do Arduino exposto na blindagem multifuncional.
AVISO: Este aplicativo não se destina a fins médicos.
Depois de ligar o Arduino, gentilmente, mas com firmeza, coloque o dedo indicador no sensor e aguarde o
visor começar a piscar. Isso indica que o sensor foi normalizado, após o que o visor do escudo mostrará as
batidas por minuto e o bipe soará. Se o display permanecer em 0 e não piscar após alguns segundos,
retire o dedo, espere um pouco e tente novamente. Certifique-se de que o dedo seja colocado com
pressão consistente.
A possível modificação para esta aplicação é ter uma luz de LED sincronizada com cada batimento cardíaco.

<Wire.h> #include
<MultiFuncShield.h>
void initializeSensorReading(); dados int[4]; byte

dataIdx=0;
Página 19 de 30
byte pulsoDetetado = falso; int últimoPulseTime

= -1;
void setup() {
initializeSensorReading(); //Serial.begin(9600);
loop void() {
if (MFS.getTimer() == 0) {
MFS.setTimer(10000); if // redefine o cronômetro de contagem regressiva em milissegundos.

(lastPulseTime != -1) {
lastPulseTime = 10000 + lastPulseTime;

}
}
int valor do sensor = analogRead(A5); // lê o sensor.
if (sensorValue < 20 || sensorValue > 970) {
// O sensor não normalizou, verifique quanto tempo em milissegundos. if (lastPulseTime != -1 &&

lastPulseTime - MFS.getTimer() > 700) {
initializeSensorReading();
}
} else if (sensorValue > (3 * 1024) / 5) // o valor está aumentando, então deve ser o início de um pulso. {
if (!pulseDetectado) {
pulsoDetetado = verdadeiro;
if (lastPulseTime == -1) {
lastPulseTime = MFS.getTimer();
} outro
{
int pulsePeriod = lastPulseTime - MFS.getTimer(); // calcula o tempo entre os pulsos em milissegundos.
lastPulseTime = MFS.getTimer();
int bpm = 60000 / pulsePeriod; // calcula batimentos por minuto.
se (bpm < 45 || bpm > 230) o buffer de // bpm está fora do intervalo aceitável, então claro
dados. {
initializeSensorReading();
} outro
{
// bpm está dentro do intervalo, mas ainda precisa calcular a média.
dados[dataIdx++] = bpm;
if (dataIdx >= 4) {
dataIdx = 0;
}
Página 20 de 30
if (data[0] && data[1] && data[2] && data[3]) // verifica se o buffer de dados
está cheio antes de calcular avg bpm.
{
int avgBpm = (dados[0] + dados[1] + dados[2] + dados[3]) / 4;
MFS.blinkDisplay(DIGIT_ALL, OFF); MFS.write(avgBpm);

MFS.beep();
} outro
{
// buffer não está cheio, então pisque o display.
}
}
}
}
} else if (sensorValue < (1024 / 2)) // o valor está caindo, então deve ser o fim do pulso. {
pulso detectado = falso;

}
//Serial.println(sensorValue); //atraso(10);
// Inicializa o buffer de leitura e exibe. void initializeSensorReading() {
últimoPulseTime = 0;
dataIdx = 0; for (int

i=0; i<4; i++) {
dados[i] = 0;
}
MFS.write(0);
}
Indicador de inclinação da superfície
O aplicativo indicador de inclinação de superfície usa o sensor de movimento MPU6050 para determinar o
ângulo de inclinação de uma superfície plana. Você precisará baixar o código-fonte completo antes de fazer o
upload para o Arduino. Como a aplicação utiliza software I2C, ao utilizar placas R3 Uno e Leonardo, utilize o
pino 5 para SCL e 6 para SDA. Para Mega2560, use o pino 5 para SCL e o pino A5 para SDA.
Depois de ligar o Arduino, coloque o sensor de movimento em uma superfície o mais nivelada possível e
pressione e segure o botão 1 no escudo multifuncional. O LED 1 pisca enquanto o sensor é calibrado.
Depois disso, colocando o sensor de movimento em superfícies inclinadas, o escudo exibirá o ângulo de
inclinação.
Atualmente, a inclinação é exibida apenas para um único eixo, mas o aplicativo pode ser modificado para
mostrar a inclinação para um eixo adicional.
#define _SOFTI2C_H #include

<SoftI2CMaster.h> #include <Wire.h>
#include <TimerOne.h>
#include <MultiFuncShield.h>
Página 21 de 30
#include "SoftwareI2C.h" #include

"I2C.h" #include
"MPU6050.h"
#define SOFTWARE_I2C
void calibrar();
MPU6050 MPU;
const float radToDeg = 180,0 / 3,1415926535897932384626433832795; int xOffset=0, yOffset=0; float

zScaleOffset = 1; // multiplica o eixo Z
por este valor para chegar o mais próximo possível de 1g.
void setup() {
#se definido (SOFTWARE_I2C)

// Use o software I2C // Uno e
Leonardo, use o pino 5 para SCL e 6 para SDA. Mega2560, use o pino 5 para
SCL e pino A5 para SDA.
SoftI2C1.initialize();
MPU.initialize(&SoftI2C1, MPU_DEFAULT_ADDRESS << 1, ACCEL_FS_2, GYRO_FS_250, DLPF_BW_5); #else // Usa
hardware I2C
Wire.begin(); I2C1.initialize(&Wire);
MPU.initialize(&I2C1,
MPU_DEFAULT_ADDRESS,
ACCEL_FS_2, GYRO_FS_250, DLPF_BW_5); #fim se
}

if (btn == BUTTON_1_LONG_PRESSED) {
calibrar();
}
MPU.getAccelRaw();
MPU.accel_X_Raw -= xOffset;
MPU.accel_Y_Raw -= yOffset;
ângulo de flutuação;
if (MPU.accel_Z_Raw == 0) {
ângulo = 90;
} outro
{
ângulo = atan((float)MPU.accel_Y_Raw / (MPU.accel_Z_Raw * zScaleOffset)) *
radToDeg; // calcula para o eixo y
//ângulo = atan((float)MPU.accel_X_Raw / (MPU.accel_Z_Raw * zScaleOffset)) * radToDeg; }
// calcula para o eixo X
MFS.write(ângulo, 1); atraso(200);
Página 22 de 30
void calibrar() {
MFS.write(" ");
MFS.writeLeds(LED_1, ON);
MFS.blinkLeds(LED_1, ON);
// descarta as primeiras leituras do sensor. for (int i=0; i<10; i+

+) {
MPU.getAccelRaw(); atraso(10);
int xValues[5], yValues[5], zValues[5];
for (int i=0; i<5; i++) {
MPU.getAccelRaw(); xValues[i]
= MPU.accel_X_Raw; yValues[i] =
MPU.accel_Y_Raw; zValues[i] =
MPU.accel_Z_Raw; atraso(300);
} xOffset = MedianOf5(xValues[0], xValues[1], xValues[2], xValues[3], xValues[4]); yOffset = MedianOf5(yValues[0], yValues[1],

yValues[2], yValues[3], yValues[4]);
zScaleOffset = (float)MPU.accelScaleValue / MedianOf5(zValues[0], zValues[1],

zValores[2], zValores[3], zValores[4]);
MFS.blinkLeds(LED_1, OFF);
// limpa o buffer do botão de entrada lendo-o e descartando o valor. for (int i=0; i<10; i++) {
MFS.getButton();
}
}
sonar ranger
O aplicativo sonar ranger usa o módulo de sonar HC SR04 para medir a distância entre o módulo e um
objeto sólido de até 5 metros de distância. Esta aplicação funciona de forma semelhante ao sensor de
obstáculos de alguns veículos para auxiliar o condutor nas manobras de estacionamento. Conforme um
obstáculo se aproxima do módulo do sonar, o bipe soa em intervalos cada vez mais curtos. O botão 1 do
escudo é usado para ativar ou desativar o módulo de sonar.
Os pinos de disparo e eco do módulo de sonar são conectados aos pinos 5 e 6 do Arduino, respectivamente,
que são expostos na blindagem multifuncional. Depois de ligar o Arduino, coloque um objeto sólido a
diferentes distâncias do módulo sonar.

<Wire.h> #include
<MultiFuncShield.h>
const int TrigPin = 5; const int

EchoPin = 6;
enum sonarModeValues
{
MODE_SONAR_OFF,
MODE_SONAR_ON };
byte sonarMode = MODE_SONAR_OFF;
void setup()
Página 23 de 30
{
//Serial.begin(9600);
pinMode(TrigPin, OUTPUT);
pinMode(EchoPin, INPUT);
MFS.initialize(&Timer1); MFS.write("off");
loop void() {
switch (sonarMode) {
caso MODE_SONAR_OFF: if
(btn == BUTTON_1_PRESSED) {
sonarMode = MODE_SONAR_ON;
MFS.beep(5, 95, 1,0,0); MFS.write("em");
} quebrar;
case MODE_SONAR_ON: if
sonarMode = MODE_SONAR_OFF;
MFS.beep(0);
MFS.write("off");
MFS.blinkDisplay(DIGIT_ALL, OFF); MFS.initSonar();
} outro
{
int distância = MFS.getSonarDataCm(TrigPin, EchoPin);
if (distância != 0 && distância < 2000) {
int offPeriod = distância - 6;
if (offPeriod < 0) {
offPeríodo = 0;
}
MFS.write(distância);
MFS.setBeepOffPeriod(offPeriod);
MFS.blinkDisplay(DIGIT_ALL, distância < 11);
} atraso(100);
} quebrar;
}
}
Velocímetro
O aplicativo velocímetro calcula a velocidade de uma roda (em quilômetros/hora) usando um imã e um reed
switch, que é conectado ao pino 5 do Arduino. Também deve ser possível fabricar seu próprio codificador
de roda usando um sensor de linha ou marca.
Depois de ligar o Arduino, pressione e segure o botão 1 do escudo multifuncional até que o display
pisque, então use os botões 2 e 3 para definir o diâmetro da roda em centímetros. Pressione o botão
1 novamente quando terminar. Gire a roda para ver a velocidade indicada na tela do escudo.
Página 24 de 30
Uma possível melhoria para este aplicativo é manter um registro da distância percorrida em quilômetros.

<Wire.h> #include
<MultiFuncShield.h>
enum SpeedoModeValues {
SETUP_WHEEL,
CALCULATE_SPEED };
byte speedoMode = CALCULATE_SPEED; byte

wheelDiameterCm = 60; unsigned int
wheelCirmcumferenceCm = (wheelDiameterCm * 314) / 100;
float SpeedKmh (unsigned int wheelCircumferenceCm, unsigned int periodMs);
void setup() {
pinMode(5, INPUT_PULLUP);
MFS.initPulseInCounter( // usa o pino

digital 5 para entrada de pulso. 5, 2000, // o número de
milissegundos para esperar por um pulso, antes de redefinir o pulso no período para 0.
BAIXO // dispara pulso na entrada LOW.

);
}

switch (speedoMode) {
caso SETUP_WHEEL: if
speedoMode = CALCULATE_SPEED;
wheelCirmcumferenceCm = (wheelDiameterCm * 314) / 100;
rodaDiâmetroCm--;
if (rodaDiâmetroCm < 30) {
rodaDiâmetroCm = 30;
}
MFS.write(rodaDiameterCm);
rodaDiâmetroCm++;
if (rodaDiâmetroCm > 100) {
rodaDiâmetroCm = 100;
}
Página 25 de 30
} quebrar;
caso CALCULATE_SPEED: if (btn

== BUTTON_1_LONG_PRESSED) {
speedoMode = SETUP_WHEEL;
} outro
{
unsigned int pulsePeriodMs = MFS.getPulseInPeriod();
if (pulsePeriodMs == 0) {
MFS.write(0.0, 1);
} outro
{
MFS.write(SpeedKmh(wheelCirmcumferenceCm, pulsePeriodMs), 1);
}
} quebrar;
} atraso(100);
}
float SpeedKmh (unsigned int wheelCircumferenceCm, unsigned int periodMs) {
return (float)(rodaCircumferenceCm * 36) / periodMs;

}
Todos os exemplos de código e aplicativos foram testados e funcionam. Se você tiver alguma dificuldade, por favor
poste um comentário, e eu entrarei em contato com você o mais rápido possível.
Página 26 de 30
Apêndices
Ajuda da biblioteca de escudos multifuncional
#define ON 1 #define
OFF 0
#define LED_1_PIN #define 13

LED_2_PIN #define 12
LED_3_PIN #define 11
LED_4_PIN #define POT_PIN 10
#define BEEPER_PIN 0
#define BUTTON_1_PIN A1 3
#define BUTTON_2_PIN A2 #define
BUTTON_3_PIN A3 #define LATCH_PIN
#define CLK_PIN #define DATA_PIN
#define LM 35_PIN 4
7
8
A4
#define DIGIT_1 1 #define

DIGIT_2 2 #define DIGIT_3 4
#define DIGIT_4 8 #define
DIGIT_ALL 15
#define LED_1 1 #define

LED_2 2 #define LED_3 4
#define LED_4 8 #define
LED_ALL 15
// indicadores de estado do botão #define

BUTTON_PRESSED_IND (0 << 6) #define
BUTTON_SHORT_RELEASE_IND (1 << 6) #define
BUTTON_LONG_PRESSED_IND (2 << 6) #define
BUTTON_LONG_RELEASE_IND (3 << 6)
#define BUTTON_1_PRESSED #define (1 | BUTTON_PRESSED_IND)

BUTTON_1_SHORT_RELEASE (1 | BUTTON_SHORT_RELEASE_IND) #define
BUTTON_1_LONG_PRESSED (1 | BUTTON_LONG_PRESSED_IND) #define BUTTON_1_LONG_RELEASE
(1 | BUTTON_LONG_RELEASE_IND)


#define SMOOTHING_NONE #define 0
1
SMOOTHING_MODERATE #define
2
SMOOTHING_STRONG
classe MultiFuncShield {
public: //
Ponteiro para interrupção do usuário com frequência de 1khz. void (*interrupção do
usuário)() = NULL;
// Inicializa esta instância usando uma instância TimerOne. Uma interrupção de 1 khz está anexada. void inicializar(TimerOne *timer1);
Página 27 de 30
// Inicializa esta instância, mas os recursos baseados em interrupção não estão disponíveis. void inicializar();
// Apenas para uso interno. void

isrCallBack();
// Inicia um cronômetro de contagem regressiva em milissegundos. void

setTimer (milésimos longos sem sinal);
// Obtém o valor atual do cronômetro de contagem regressiva. getTimer() longo não

assinado;
// Inicia e espera até que o cronômetro de contagem regressiva de milissegundos chegue a 0. void wait(unsigned
long mileths);
// Grava no visor de dígitos do LED. void write(const char

*textstring, byte rightJustify =0); void escrever(int inteiro); void write(número float, byte
decimalPlaces = 1);
// Atualiza manualmente o display de dígitos do Led.

// Não deve ser usado enquanto recursos baseados em interrupção estiverem disponíveis. void
manualDisplayRefresh();
// Pisca os dígitos no display LED de dígitos. void blinkDisplay(byte digits, byte

ativado = ON ); // use OR bit a bit, por exemplo, DIGIT_1 | DIGIT_2 // liga/desliga a
piscada
// Liga ou desliga os LEDs. void

writeLeds(byte leds, byte aceso ); // use OR bit a bit, por exemplo, LED_1 | LED_2 //
LIGADO ou DESLIGADO
// Pisca os LEDs. void

blinkLeds(byte leds, byte habilitado = ON ); // use OR bit a bit, por exemplo, LED_1 | LED_2 //
LIGADO ou DESLIGADO
// Ativa o bipe, que é gerenciado em segundo plano. O tempo do período está em 100º de segundo
void beep(unsigned int onPeriod = 20, unsigned int offPeriod = 0, byte cycles = 1,
unsigned int loopCycles = 1 /* 0=indefinidamente */, unsigned int loopDelayPeriod =0);
// Use isso para definir o período de desligamento enquanto o bipe estiver ativado, void
setBeepOffPeriod(unsigned int offPeriod);
// Enfileira uma ação de botão na fila de botões, por exemplo, BUTTON_1_PRESSED void queueButton (botão
byte);
// Extrai uma ação de botão da fila de botões. byte getButton();
// Ações curtas de pressionamento e liberação do botão Filas. Pressões longas de botão não são
suportados, e lançamentos longos são relatados como lançamentos curtos.
// Não deve ser usado enquanto recursos baseados em interrupção estiverem disponíveis. void manualButtonHandler();
// Inicializa o contador de pulsos. Usado para contar pulsos aplicados a um pino de entrada.
Frequência máxima de pulso 500Hz.
void initPulseInCounter(byte pin = BUTTON_1_PIN, unsigned int timeOut = 3000, // pino de entrada //
o número de milissegundos
para esperar por um pulso, antes de redefinir o pulso no período para 0.
disparador de byte = BAIXO // aciona o contador em qualquer um
borda ascendente ou descendente
);
// Obtém o período do pulso mais recente (em milissegundos). unsigned int getPulseInPeriod();
Página 28 de 30
// Obtém o número total de pulsos contados. longo não assinado

getPulseInTotalCount();
// Redefine o contador de pulso para 0. void

resetPulseInTotalCount();
// Define o pulso no tempo limite, que é o número de milissegundos para esperar por um pulso, antes de redefinir o pulso no período
para 0.
void setPulseInTimeOut(unsigned int timeOut);
// Inicializa o recurso de leitura do sonar. Precisa do módulo de sonar HC-SR04. void initSonar(nível de byte =
SMOOTHING_MODERATE); // nível 0=nenhum, 1=moderado, 2=forte.
// Obtém a distância medida em centímetros, usando o módulo de sonar HC-SR04. unsigned int getSonarDataCm(byte
triggerPin, byte echoPin);
// Inicializa o recurso de leitura de temperatura. Precisa do sensor LM35. Deve remover o jumper J1
de escudo.
void initLM35(nível de byte = SMOOTHING_MODERATE); // nível 0=nenhum, 1=moderado, 2=forte
// Obtém a leitura da temperatura em 1 décimo de centígrado. int getLM35Data();
};
MFS MultiFuncShield externo;
Página 29 de 30
Ajuda MPU6050
classe MPU6050 {
público:
int accel_X_Raw; int

accel_Y_Raw; int
accel_Z_Raw;
int giroscópio_X_Raw;
int giroscópio_Y_Raw;
int giroscópio_Z_Raw;
int accelScaleValue; // divide a aceleração bruta por este valor para obter a leitura em g. float gyroScaleValue; // divide o giroscópio bruto
por este valor para obter graus/segundo de velocidade de rotação.
// Inicializa o sensor MPU6050. void initialize(II2C *i2c,

byte addr, byte accelScale = 0, byte gyroScale = 0, byte dlpf = 0);
void getAccelRaw(); // obtém valores brutos de aceleração void getGyroRaw(); //

obtém os valores de aceleração do giroscópio int getTemp10th(); // obtém a temperatura
em 10 graus celsius };
#define ADDRESS_AD0_LOW 0x68 #define

ADDRESS_AD0_HIGH 0x69 #define
MPU_DEFAULT_ADDRESS ADDRESS_AD0_LOW
// escala de aceleração
#define ACCEL_FS_2 0x00 #define
ACCEL_FS_4 0x01 #define
ACCEL_FS_8 0x02 #define
ACCEL_FS_16 0x03
// escala do giroscópio
#define GYRO_FS_250 0x00 #define
GYRO_FS_500 0x01 #define
GYRO_FS_1000 0x02 #define
GYRO_FS_2000 0x03
// dlpf
#define DLPF_BW_256 0x00 #define
DLPF_BW_188 0x01 #define
DLPF_BW_5 0 x06
Página 30 de 30

Placa Mult Função PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Placa Mult Função PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Por Kashif Baig

Apresentando Hackatronics – Codificação para se divertir.......................................... .........................................3

Apresentando Hackatronics - Codificação para se divertir

Instalando a biblioteca de blindagem multifuncional Se

• Biblioteca de escudos multifuncional •

Mais sobre esta série

1. Entrada / Saída Básica

A Parte 3 explora os aplicativos de trabalho usando a biblioteca e o escudo multifuncional:

Indicador de nível de inclinação da superfície – (requer sensor de movimento MPU6050) •

Obtenha codificação e divirta-se!

Parte 1 Entrada/ Saída Básica

Usando o bipe do escudo A biblioteca

#include <TimerOne.h> #include

// bipe curto por 200 milissegundos MFS.beep();

// 4 bips curtos, repetidos 3 vezes.

void loop() { // coloque

Detecção de pressionamento de botão no escudo Com a

#include <TimerOne.h> #include

// coloque seu código de configuração aqui, para executar uma vez:

void loop() { // coloque

byte btn = MFS.getButton(); // Normalmente basta comparar o retorno

byte buttonNumber = btn & B00111111; byte buttonAction

} else if (buttonAction == BUTTON_SHORT_RELEASE_IND) {

} else if (buttonAction == BUTTON_LONG_PRESSED_IND) {

} else if (buttonAction == BUTTON_LONG_RELEASE_IND) {

Escrevendo no visor de dígitos do escudo O

#include <TimerOne.h> #include

int contador=0; byte

void loop() { // coloque

if (contador < 200) {

Controlando as luzes de LED do escudo

#include <TimerOne.h> #include

MFS.writeLeds(LED_ALL, ON); atraso(2000);

MFS.blinkLeds(LED_3 | LED_4, ON); atraso(2000);

MFS.blinkLeds(LED_ALL, ON); atraso(2000);

void loop() { // coloque

Lendo o valor do potenciômetro do escudo Este esboço

#include <TimerOne.h> #include

MFS.initialize(&Timer1); // inicializa a biblioteca de escudo multifuncional

void loop() { // coloque

Parte 2 Sensores de Leitura

#include <TimerOne.h> #include

BAIXO // dispara pulso na entrada LOW.

void loop() { // coloque

// Obtém o período do pulso mais recente (em milissegundos).

Lendo a temperatura usando um sensor LM35 O shield

#include <TimerOne.h> #include

// Inicializa usando um filtro passa-baixo.

int tempCentigrade = MFS.getLM35Data(); // obter centígrados em 1/10 de grau.

MFS.write((float)tempCentigrade / 10, 1); // exibe a temperatura com 1 casa decimal.

Usando um módulo de sonar HC SR04 Ao

#include <TimerOne.h> #include

const int TrigPin = 5;

const int EchoPin = 6;

// inicializa com filtro passa-baixo: SMOOTHING_NONE, SMOOTHING_MODERATE ou

Obtendo dados de um sensor de movimento MPU6050

#include "SoftwareI2C.h" #include

// coloque seu código de configuração aqui, para executar uma

#se definido (SOFTWARE_I2C)

byte exibirValores = verdadeiro; byte

void loop() { // coloque

byte btn = MFS.getButton();