Sistema de correção de postura sentada em tempo real com base em sensores de pressão têxteis eletrônicos altamente duráveis ​​e laváveis

 

Destaques

•  Foi desenvolvido um sistema de correção de postura assente em tempo real com base em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• A condução de fibras de liga Ni-Ti revestidas com elastômero de poliuretano resultou em sensores de pressão têxtil altamente duráveis ​​e laváveis.
• Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas de sessão foram classificadas com sucesso.
• A exibição em tempo real em um monitor de mudanças na postura sentada, que faz os usuários reconhecer e corrigir o equilíbrio corporal, foi simulada.

 

 

Abstract

Foi demonstrado um sistema de correção de postura sentada em tempo real com base em sensores de pressão têxtil altamente durável e laváveis. Os sensores de pressão têxtil consistiram na condução de fibras de liga de Ni-Ti com uma excelente resistência à fadiga e um elastômero de poliuretano sensível à pressão resultou em mudança de capacitância confiável por uma pressão aplicada em uma faixa de 10 a 180 kPa com uma sensibilidade de 2,39 kPa -1. O desempenho sensitivo foi mantido em 100%, mesmo após a repetida ação de sentar mais de 1000 vezes e a dura lavagem na solução detergente. Ao analisar a pressão detectada nas diferentes posições sob o quadril, coxa e costas, sete tipos de posturas sentadas, incluindo a sessão vertical, sentado com uma perna cruzada, e sentado com as duas pernas levantadas foram classificadas com sucesso. Finalmente, a exibição em tempo real em um monitor das mudanças na postura sentada foi simulada para permitir aos usuários reconhecer e corrigir o equilíbrio corporal.

Palavras-chave

  • Sensor de pressão têxtil lavável ;
  • Fibras de liga Ni-Ti revestidas com poliuretano;
  • Sensor do tipo capacitância ;
  • Correção de postura sentada

 

Fonte: https://www.sciencedirect.com/science/article/pii/S0924424717312815 

Anúncios

Módulo GPS Skylab SKM53

Este módulo opera com 5V e assim que é energizado começa a transmitir coordenadas no pino TXD (mas só serão válidas após o tempo de fix) , repetindo a cada 1s. A baudrate é 9600bps. O pino RXD só tem utilidade se você quiser reconfigurar o módulo, por isso você pode deixá-lo desconectado.

Teste básico

(não requer que o GPS esteja vendo satélites)

No Arduino Mega

Atenção: qualquer exemplo que você pegar na internet que use a biblioteca Newsoftserial poderá não funcionar no Mega. Nesse modelo de arduino, use as portas seriais reais.

Ligue o TXD do GPS no pino RX1 do Mega

Rode o sketch (não é preciso mudar nada) Examples -> Communication -> MultiserialMega

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

$GPRMC,204433.215,V,,,,,0.00,0.00,131013,,,N*48
$GPGGA,204434.215,,,,,0,0,,,M,,M,,*4B
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPGSV,1,1,01,09,,,23*70

 

No Arduino UNO

Instale a biblioteca NewSoftSerial

Ligue o TXD do GPS no pino 2 do Arduino.

Rode o seguinte sketch, ligeiramente adaptado do exemplo TwoPortReceive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <SoftwareSerial.h>
SoftwareSerial portOne(2,3);
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
// Start each software serial port
portOne.begin(9600);
}
void loop()
{
// By default, the last intialized port is listening.
// when you want to listen on a port, explicitly select it:
portOne.listen();
Serial.println("Recebido do GPS:");
// while there is data coming in, read it
// and send to the hardware serial port:
while (portOne.available() &gt; 0) {
char inByte = portOne.read();
Serial.write(inByte);
}
delay(1000);
Serial.println("");
Serial.println("");
}

Algo assim deve aparecer no Serial Monitor (repete-se a cada 1s):

 

Recebido do GPS:
$GPGGA,210946.907,,,,,0,0,,,M,,M,,*4E
$GPGSA,A,1,,,,,,,,,,,,,,

Teste completo

Não faça este teste se sua instalação não tiver passado ainda no teste básico.

Neste teste o GPS precisa ver os satélites. Para isso você precisa estar num local que tenha visão direta para o céu e o lado da antena do GPS precisa estar voltado para cima.

Em um Arduino UNO

Instale a biblioteca TinyGPS (documentação e download da v13). Requer NewsoftSerial.

Conecte o TXD do GPS ao pino 4 do UNO.

Carregue o exemplo Examples -> TinyGPS -> test_with_gps_device

Mude a linha

ss.begin(4800);

para

ss.begin(9600);

Faça o upload do sketch.

Em um Arduino Mega

Instale a biblioteca TinyGPS (documentação e download da v13).

Conecte o TXD do GPS a RX1 do Mega.

Atenção: Os exemplos do TinyGPS usam a biblioteca Newsoftserial, que tem certos problemas para funcionar no Mega. Por isso eu fiz ligeiras modificações no exemplo para usar uma porta serial real do Mega.

Faça o upload do seguinte sketch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <TinyGPS.h>
/* Exemplo test_with_gps_device modificado para usar a porta serial 1
do Arduino Mega.
Jefferson Ryan - Automalabs - 13/10/2013
*/
TinyGPS gps;
static void smartdelay(unsigned long ms);
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);
void setup()
{
Serial.begin(115200);
Serial1.begin(9600);
Serial.print("Testing TinyGPS library v. ");
Serial.println(TinyGPS::library_version());
Serial.println("by Mikal Hart");
Serial.println();
Serial.println("Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt    Course Speed Card  Distance Course Card  Chars Sentences Checksum");
Serial.println("          (deg)     (deg)      Age                      Age  (m)    --- from GPS ----  ---- to London  ----  RX    RX        Fail");
Serial.println("-------------------------------------------------------------------------------------------------------------------------------------");
}
void loop()
{
float flat, flon;
unsigned long age, date, time, chars = 0;
unsigned short sentences = 0, failed = 0;
static const double LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
gps.f_get_position(&flat, &flon, &age);
print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 10, 6);
print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 11, 6);
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
print_date(gps);
print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 7, 2);
print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0xFFFFFFFF : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? TinyGPS::GPS_INVALID_F_ANGLE : TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);
gps.stats(&chars, &sentences, &failed);
print_int(chars, 0xFFFFFFFF, 6);
print_int(sentences, 0xFFFFFFFF, 10);
print_int(failed, 0xFFFFFFFF, 9);
Serial.println();
smartdelay(1000);
}
static void smartdelay(unsigned long ms)
{
unsigned long start = millis();
do
{
while (Serial1.available())
gps.encode(Serial1.read());
} while (millis() - start < ms);
}
static void print_float(float val, float invalid, int len, int prec)
{
if (val == invalid)
{
while (len-- > 1)
Serial.print('*');
Serial.print(' ');
}
else
{
Serial.print(val, prec);
int vi = abs((int)val);
int flen = prec + (val < 0.0 ? 2 : 1); // . and -
flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
for (int i=flen; i<len; ++i)
Serial.print(' ');
}
smartdelay(0);
}
static void print_int(unsigned long val, unsigned long invalid, int len)
{
char sz[32];
if (val == invalid)
strcpy(sz, "*******");
else
sprintf(sz, "%ld", val);
sz[len] = 0;
for (int i=strlen(sz); i<len; ++i)
sz[i] = ' ';
if (len > 0)
sz[len-1] = ' ';
Serial.print(sz);
smartdelay(0);
}
static void print_date(TinyGPS &gps)
{
int year;
byte month, day, hour, minute, second, hundredths;
unsigned long age;
gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
if (age == TinyGPS::GPS_INVALID_AGE)
Serial.print("********** ******** ");
else
{
char sz[32];
sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d ",
month, day, year, hour, minute, second);
Serial.print(sz);
}
print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
smartdelay(0);
}
static void print_str(const char *str, int len)
{
int slen = strlen(str);
for (int i=0; i<len; ++i)
Serial.print(i<slen ? str[i] : ' ');
smartdelay(0);
}

 

 

Se seu GPS estiver enxergando os satélites, a saída será parecida com isto (eu dividi em duas partes porque não cabia na tela e alterei as coordenadas por privacidade):

 

Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
9    91   8.022881 34.324093 83   10/13/2013 22:18:40 95   20.00
9    91   8.022881 34.324093 89   10/13/2013 22:18:41 102  20.00
9    91   8.022881 34.324093 101  10/13/2013 22:18:42 113  20.00
9    91   8.022881 34.324093 122  10/13/2013 22:18:43 135  20.00
9    91   8.022881 34.324093 134  10/13/2013 22:18:44 148  20.00
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   39    0         1
60.25  0.00  ENE   7418     22.79  NNE   502   2         1
60.25  0.00  ENE   7418     22.79  NNE   944   4         1
60.25  0.00  ENE   7418     22.79  NNE   1393  6         1
60.25  0.00  ENE   7418     22.79  NNE   1850  8         1
60.25  0.00  ENE   7418     22.79  NNE   2299  10        1
Se seu GPS não estiver enxergando os satélites, a saída de TinyGPS será parecida com isto (eu dividi em duas partes porque não cabia na tela):
Testing TinyGPS library v. 13
by Mikal Hart
Sats HDOP Latitude  Longitude  Fix  Date       Time     Date Alt
          (deg)     (deg)      Age                      Age  (m)
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
**** **** ********* ********** **** ********** ******** **** ******
Course Speed Card  Distance Course Card  Chars Sentences Checksum
from GPS   to London    RX    RX        Fail
****** ***** ***   *******  ****** ***   0        0         0
****** ***** ***   *******  ****** ***   136    0         0
****** ***** ***   *******  ****** ***   272    0         0
****** ***** ***   *******  ****** ***   408   0         0
****** ***** ***   *******  ****** ***   544   0         0

 

Note que o valor de Chars RX está incrementando em passos fixos (no caso, 136). Isso siginifica que a biblioteca está recebendo dados do GPS, mas não há coordenadas válidas nesses dados. Se Chars RX não estiver incrementando verfique todas as conexões.

Se você realmente precisar reconfigurar esse GPS, o documento MTK NMEA Packet User Manual (link para download no fim do texto) pode ser o que você precisa. Eu não testei, não aconselho seu uso e não dou garantias. Se você mexer nas configurações considere minha garantia finalizada. Estou fornecendo o arquivo apenas para sua conveniência.

 

http://www.automalabs.com.br/download/SkyNav_SKM53_Datasheet.pdf

http://www.automalabs.com.br/download/PMTK_Protocol.pdf

 

Fonte: http://www.automalabs.com.br/modulo-gps-skylab-skm53/#comment-2321

 

Leitor de cédulas para deficientes visuais

Trabalho de conclusão de curso
apresentado à Faculdade de Americana,
como requisito parcial para a obtenção
do título de Bacharel em Engenharia
Elétrica.
Orientador: Professor MSc. Alysson
Fernandes Mazoni

 

 

RESUMO
O objetivo deste trabalho é o desenvolvimento de um leitor de cédulas
de dinheiro para deficientes visuais que fosse prático e utilizasse componentes
de baixo custo. O projeto utiliza o Arduino como microcontrolador e um sensor
de cores para a distinção dos valores das cédulas. No estudo foi possível
identificar que diversos aspectos podem influenciar na identificação das notas,
como por exemplo, a distância que as medições são realizadas e a
luminosidade do ambiente. Assim foi desenvolvida uma padronização para as
medidas e uma calibração para toná-las confiáveis. Através dos resultados
obtidos foi possível comprovar que o leitor de cédulas identifica corretamente
os valores das notas.
Palavras-chave: Deficientes visuais, Leitor de cédulas, Sensor de cores, Arduino.

 

 

Fonte: http://aplicacao.vestibularfam.com.br:881/pergamumweb/vinculos/000002/00000228.pdf

Fonte: http://www.faculdadedeamericana.com.br/revista/index.php/TCC/article/view/167/158

Aquecimento por indução – Induction Heater – Monte um!

Aquecimento por indução – Induction Heater. Apresentação do efeito, funcionamento e circuito para montar um aquecedor por indução! Veja aqui a versão 2.0 desse circuito: https://www.youtube.com/watch?v=wqp0C…

Inscreva-se no canal aqui: https://www.youtube.com/c/electrolab-…

Seja um apoiador do Electrolab na página no apoia-se! https://apoia.se/electrolab

Seja um patrono do Electrolab:

Página do Electrolab no Patreon: https://www.patreon.com/electrolab?ty=h

 

Lista de Material do projeto:

02 MOSFETs canal N IRF540, 640, etc
02 Diodos 1N5819
Choque de RF (12 espiras – entre 40 e 100uH)
Resistor 220R x 1W
01 LM7812
Cap – 470nF a 1uF – 1600V MKP
Indutor 10 espiras com CT – Fio 4mm, com 2cm de diâmetro

 

Treinamentos recomendados pelo Electrolab:

Curso de reparos de Celular: http://bit.ly/2oUM0fa

Guia para reparo de Celular: http://bit.ly/2okqSM3

Curso de reparo de Eletrodomésticos e eletrônica básica: http://bit.ly/2oINxEs

Guia de reparo em placa mãe (PC): http://bit.ly/2okoSDB

Curso de reparo de Notebook: http://bit.ly/2oIDOhE e http://bit.ly/2oJr36m

Curso de instalador de sistema de energia solar: http://bit.ly/2oQWrxB

Curso de Inglês do zero: http://bit.ly/2oZaJgm

Curso técnico de CFTV (Câmeras de segurança): http://bit.ly/2qmBw9B

Arduino Based Home Automation Usando TV Remote

A Arduino Based Home Automation usando TV Remote é um projeto simples, onde um controle remoto de TV antigo é usado para controlar diferentes aparelhos.

Home Automation é um conceito em que um único dispositivo é usado para controlar muitos aspectos de uma casa, como ligar ou desligar aparelhos diferentes, monitoramento de temperatura, alarmes de incêndio, portas de garagem etc. Neste projeto, um controle remoto é usado para controlar (simplesmente ON e OFF) vários aparelhos ou dispositivos, conseguindo assim um sistema de automação residencial simples.

Os controles remotos são um dos dispositivos comumente encontrados em quase todas as casas. Eles nos ajudam a operar um aparelho como TV, Ar-condicionado, VCR, etc. A principal característica de um controle remoto é que ele é específico para um dispositivo. Por exemplo, uma unidade de controle remoto de TV só pode ser usada para essa TV correspondente.

Mas neste projeto, nós criamos uma automação doméstica baseada em Arduino usando TV Remote, onde um único controle remoto é usado para controlar 4 dispositivos diferentes (possível controlar mais dispositivos). O projeto é baseado no Arduino UNO e mais detalhes do projeto são mencionados abaixo.

Diagrama de circuito

Componentes necessários

  • Arduino UNO board
  • TSOP 1738 IR Remote Control Receiver
  • 1 KΩ Resistor X 4
  • 2N2222 NPN Transistor X 4
  • 1N4007 Diodo X 4
  • 12 V Relé X 4
  • Controle remoto
  • Placa de prototipagem (Painel de pão)
  • Fios de conexão
  • 12 V Fonte de alimentação

Descrição do Componente

Arduino UNO

Arduino UNO forma a principal parte controladora do circuito. A UNO tem 13 pinos de E / S digitais e, portanto, é possível controlar 13 dispositivos diferentes ao mesmo tempo. Se o requisito é controlar mais número de dispositivos, placas como Arduino Mega podem ser usadas.

TSOP1738

TSOP1738 é um módulo receptor para controles remotos IR com uma freqüência portadora de 38 KHz. Consiste em um detector de foto e demodulador de sinal em uma única embalagem e a saída pode ser usada diretamente por um microcontrolador.

Placa de relé de 4 canais

Um relé ajuda a controlar um aparelho grande com a ajuda de um microcontrolador. Neste projeto, uma placa de relé de 4 canais é usada para controlar quatro cargas.

Os componentes necessários, como o LED de alimentação, o transistor de comutação, o resistor de limitação de corrente de base, o relé no LED, o diodo flyback e os cabeçalhos macho para conexões de alimentação e entrada já estão incorporados na placa.

 

Cuidado : devemos ter muito cuidado ao usar um relé com alimentação de rede CA.

Controle remoto

Um mini controle remoto padrão é usado neste projeto para fornecer as várias entradas de chave. O controle remoto possui todas as teclas numéricas, volume para cima, baixo, canal para baixo, menu e algumas teclas adicionais.

 

Como projetar a automação residencial baseada em Arduino usando o circuito remoto da TV?

A partir do diagrama de circuito, é claro que o design do circuito é muito simples e requer muita conexão. O design do circuito é explicado abaixo.

O componente principal do projeto é o receptor TSOP1738. É um dispositivo de três pinos, onde os três pinos são GND, VS e OUTPUT. O pino VS está conectado à fonte de 5V. O pino de saída está conectado ao Pino 11 (ou a qualquer outro pino digital) do Arduino UNO.

Estamos usando um módulo de retransmissão de 4 canais neste projeto para controlar 4 cargas diferentes. Uma vez que a placa possui todos os componentes necessários, como transistores, LEDs, etc., tudo o que precisamos fazer é conectar as 4 entradas na placa de relé a 4 pinos de E / S digitais da Arduino. Uma conexão mais detalhada pode ser encontrada no diagrama de circuito.

Trabalho da Arduino baseado em automação residencial usando TV Remote

A automação residencial é um conceito de demanda onde um único dispositivo controlará diferentes aparelhos de uma casa. Além disso, diferentes aspectos como temperatura, umidade, segurança etc. também podem ser monitorados usando esse dispositivo.

Neste projeto, um sistema de automação residencial simples, no qual o sistema controla 4 aparelhos diferentes com a ajuda de um controle remoto de TV. O trabalho do projeto é explicado aqui.

O principal componente do projeto é TSOP1738 IR Receiver Module. Este módulo possui um receptor de foto incorporado, filtro de passagem de banda e desmodulador e a saída do módulo pode ser prontamente lida por um microcontrolador.

TSOP1738 suporta uma freqüência portadora de 38 KHz. Assim, a freqüência portadora da fonte, ou seja, o controle remoto deve estar na faixa de 38 KHz para que ele se desmodule.

Primeiro, descodificaremos os dados do controle remoto usando TSOP1738 e Arduino UNO. Para isso, precisamos usar uma biblioteca especial chamada “IRremote”. Precisamos baixar esta biblioteca em https://github.com/z3t0/Arduino-IRremote e colocá-la na pasta bibliotecas do Arduino.

O próximo passo é decodificar os dados de cada tecla do controle remoto. Para isso, vamos usar algumas funções na biblioteca “IRremote”. O programa a seguir nos ajudará a decodificar os dados de cada chave do controle remoto. NOTA: O seguinte programa é um esboço de exemplo da biblioteca “IRremote”.

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup() {
Serial.begin(9600);
irrecv.enableIRIn();
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume();
}
delay(100);
}

https://gist.githubusercontent.com/elktros/59298a69a71bb16cac9c879d08677e9b/raw/9513ce93ca53c42f0b31d98b260c3d0123f0c3f3/Arduino%20based%20Home%20Automation%20using%20TV%20Remote%20

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

Quando este esboço é executado no Arduino, podemos monitorar os dados no terminal serial para cada tecla pressionada no controle remoto. A seguinte imagem mostra os valores de HEX descodificados das teclas 1 a 9, 0 e a tecla de energia, respectivamente.

 

#include <IRremote.h>
const int RECV_PIN=11;
IRrecv irrecv(RECV_PIN);
decode_results results;
#define IN1 3
#define IN2 4
#define IN3 5
#define IN4 6
bool i=false;
bool j=false;
bool k=false;
bool l=false;
bool m=false;
void setup()
{
Serial.begin(9600);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
irrecv.enableIRIn();
irrecv.blink13(true);

}
void loop()
{
if (irrecv.decode(&results))
{
Serial.println(results.value,HEX);
delay(100);
/////////////////////////
if(results.value==0x40BD00FF)
{
i=!i;
digitalWrite(IN1, i);

}
////////////////////////
if(results.value==0x40BD807F)
{
j=!j;
digitalWrite(IN2, j);

// delay(200);
}
if(results.value==0x40BD40BF)
{
k=!k;
digitalWrite(IN3, k);

// delay(200);
}
//////////////////////////////
if(results.value==0x40BDC03F)
{
l=!l;
digitalWrite(IN4, l);

// delay(200);
}
//////////////////////
if(results.value==0x40BD28D7)
{
m=!m;
digitalWrite(IN1, m);
digitalWrite(IN2, m);
digitalWrite(IN3, m);
digitalWrite(IN4, m);

// delay(200);
}
irrecv.resume(); // Receive the next value
//delay(100);
}
}

 

Aplicação

  • Um projeto simples, onde uma automação residencial baseada em Arduino usando TV Remote é projetada aqui, que usa o Arduino UNO, o Relay e o antigo Remote TV.
  • O projeto é demonstrado com 4 cargas, mas pode ser aumentado para ainda mais cargas.
  • Como o dispositivo de controle é um controle remoto de TV, o projeto do projeto é muito simples e a aplicação também é muito fácil.

Vídeo de construção e saída

 

Link: http://www.electronicshub.org/arduino-based-home-automation-using-tv-remote/

Como usar 5V Relay no Arduino

Arduino é uma placa de prototipagem baseada em microcontroladores que funciona com uma pequena energia DC. Um Relé é um dispositivo que ajuda os microcontroladores (ou placas baseadas em microcontroladores) como o Arduino para ligar ou desligar aparelhos domésticos diferentes, como motores, luzes, aquecedores de água, televisão e ventiladores etc.

Hoje, o Arduino está sendo usado para uma ampla gama de aplicações, como LEDs de controle, temperatura de monitoramento, dados de registro e ativação de motores etc. Outra tarefa importante que pode ser realizada pelo Arduino é controlar um relé de 5V para operar aparelhos e dispositivos de alta tensão AC .

 

A família de microcontroladores Arduino, como UNO, Nano e Mega, etc. pode ser programada para controlar um relé de 5V simples, ou seja, ligue ou desligue no caso de pressionar um botão, lendo o valor da temperatura de um termistor ou apenas configurando um cronômetro predefinido.

 

Neste projeto, veremos um circuito simples onde um Arduino UNO controlará um relé de 5V, que por sua vez será uma lâmpada.

Nota: Utilizamos o Arduino UNO neste projeto, pois é mais popular do que outras placas Arduino e iniciantes em eletrônicos podem usá-lo facilmente. Se você tiver qualquer outro quadro como Arduino Nano ou Arduino Mega, você pode usá-lo sem qualquer incômodo.

Cuidado: Vamos conectar 240V Alimentação de rede (ou 110V dependendo de onde você mora) para o módulo de relé 5V para ligar uma lâmpada. Você deve ser muito cuidadoso e cauteloso ao usar a rede elétrica. Se você tem até a menor dúvida sobre a ligação, não hesite em obter ajuda de um profissional.

Diagrama de circuito

Vejamos o diagrama de circuito para o projeto. Embora tenhamos usado um módulo de retransmissão 5V, as conexões neste diagrama de circuito descreverão a configuração completa.

Usando 5V Relay on Arduino Circuit Diagram

Componentes Necessários 

  • Arduino UNO (ou qualquer outro quadro Arduino)
  • Relé 5V
  • Diodo 1N4007
  • BC547 – Transistor NPN
  • LED vermelho (pode ser usado como LED aceso)
  • LED verde (pode ser usado como um LED de relé ON)
  • 2 x 1K Ohm Resistors (1/4 W – para LEDs vermelhos e verdes)
  • Luminária
  • Fios para conexão de componentes de tensão CC
  • Fios para conexão de rede CA e lâmpada

Descrição do Circuito

Vejamos agora como o circuito foi projetado. A primeira coisa é que usamos um relé de 5V neste projeto. Isso torna mais fácil, pois o Arduino pode ligar o relé diretamente. Se você usou um relé de 12V como usamos neste projeto Arduino Relay Control , você precisa usar uma fonte de alimentação separada para o relé.

Chegando ao design do circuito, é muito simples, pois usamos um módulo de relé de 5V e não os componentes individuais. Embora o diagrama de circuito explique as conexões detalhadas, praticamente não precisamos fazer todas as conexões.

A maioria dos módulos de relé (seja 5V ou 12V) virá com a conexão acima mencionada e, portanto, tudo o que você precisa é fornecer energia ao módulo de relé, ou seja, 5V e GND e conectar o sinal de controle do Arduino ao pino de controle na placa de relé.

Chegando à parte da carga, ou seja, a lâmpada, o fio quente da rede elétrica está conectado a um terminal da lâmpada. Outro terminal da lâmpada está conectado ao contato normalmente aberto (NO) do relé 5V. Finalmente, o fio neutro da rede elétrica está conectado ao contato comum (COMM) do relé.

Um pequeno sensor de luz na forma de LDR (Light Dependent Resistor) é usado para ligar ou desligar a luz automaticamente. A saída do sensor LDR é dada ao pino de entrada analógica A0.

Descrição do Componente

Retransmissão

A vantagem de usar um relé de 5V neste projeto é que a fonte de alimentação para o relé pode ser diretamente fornecida pela própria placa Arduino UNO. Vejamos agora alguns conceitos básicos de um relé. Um relé é um tipo de switch que atua como uma interface entre microcontroladores e AC Loads.

Retransmissão

Um único relé Single Pole – Single Throw (SPST), como o usado neste projeto, consiste em 5 Terminais: 5V, GND, Normalmente Abertos (NO), Normalmente Fechar (NC) e Comum (COMM). Uma vez que precisamos controlar este relé com a ajuda do Arduino, um transistor é usado com um pino adicional chamado Pin de controle no módulo de retransmissão.

Pinos do relé 5VTrabalho do Projeto

Um projeto simples, no qual Arduino UNO controla um relé de 5V, é explicado aqui. O funcionamento do projeto baseia-se no funcionamento do Relé e na capacidade do Arduino para controlar o relé. Vamos discutir o funcionamento do projeto.

Como mencionado anteriormente, ao conectar Arduino com módulo de retransmissão de 5V, pretendemos operar uma carga CA como uma lâmpada. Em vez de usá-lo diretamente, nós criamos uma pequena aplicação onde um LDR é usado para detectar a intensidade da luz e ligar e desligar automaticamente o relé.

Sob condições normais de iluminação, a saída do LDR estará na faixa de 80 – 90 (o intervalo é 0 – 255). Quando as condições de iluminação ficam escuras (pode ser feito cobrindo o LDR com mão), a saída do LDR irá pular para 130 – 140. Essa condição pode ser usada para disparar o Relé 5V e ligar a luz.

Vantagens e desvantagens

Vantagens: a vantagem principal e importante de conectar um relé de 5V com o Arduino é que ele pode ser alimentado pelo próprio Arduino.

Desvantagens : um relé baseado em transistor pode não ser ideal para uso prolongado, pois sempre haverá ruído na bobina do relé. Uma opção adequada será usar isolamento adicional como um opto-isolador ou eliminando completamente o relé eletromecânico e substituindo-o pelo relé de estado sólido.

Aplicações

  • Interfacing a 5V Relay with Arduino abre a porta para uma grande quantidade de aplicações. Embora a principal tarefa do relé seja controlar uma carga, como esse relé está sendo operado pelo Arduino torna um projeto interessante.
  • Algumas das técnicas e métodos com os quais podemos controlar o relé são: Bluetooth, controle de infravermelhos (IR), Transmissor de RF – Par de Receptor ou mesmo usando a Internet.
  • A Arduino Home Automatica requer a combinação de Arduino e muitos módulos de relé (dependendo do número de cargas).

Vídeo de construção e saída

 

 

 

Fonte: http://www.electronicshub.org/use-5v-relay-arduino/

Ligação ao Arduino dispositivos de Delphi através de uma porta serial COM simples.

Arduino com Delphi XE8 ~ LiquidCrystal e Temperatura

 

Ligação ao Arduino dispositivos de Delphi através de uma porta serial COM simples.

> Função

  • LED On / Off controle do interruptor
  • Leia Temperatura do sensor
  • Enviar mensagem para LiquidCrystal

Código Completo para Download: Projeto Delphi e Código Arduino.

 

 

 

Fonte: http://c2design5sh.blogspot.com.br/2015/08/iot-arduino-with-delphi-xe8.html

 

 

 

 

AUTOMAÇÃO NO CULTIVO DE MICROALGAS

Título: AUTOMAÇÃO NO CULTIVO DE MICROALGAS
Autores: SANTOS, Cainã Santana dos
COSTA, Tiago Marcelino Ferreira da
Palavras Chave: Automação
Arduino
Biodiesel
Microalgas
Engenharia de Controle e Automação
Data: 1-Ago-2017
Resumo: Grande poluição causada pelo uso de combustíveis fósseis e o alto custo de extração e tratamento deste tipo de combustível tem levado à busca por encontrar fontes alternativas de combustíveis por causa da grande poluição causada pelo uso de combustíveis fósseis e do alto custo de extração e tratamento deste tipo de combustível. O cultivo de microalgas tem aumentado para pesquisas cujo o objetivo é produzir o biodiesel, por não causar danos ao meio ambiente, por ser economicamente mais viável e ocupar menos espaço para ser produzidos. Diante do exposto, este trabalho teve como objetivo elaborar um processo de automação de medição e supervisão do processo de produção de microalga Chlorella minutissima para a produção de biodiesel. Para tal, foi elaborado um sensor para executar leituras de absorbância do meio de cultivo no laboratório de Qualidade, Meio Ambiente e Bioenergia – USP. Os cultivos são realizados em triplicata, em fotobiorreatores de acrílico com 40 l de capacidade. Um pequeno volume do meio de cultivo é periodicamente drenado, por meio de uma bomba esguicho de água de 12 V, para dentro do sensor. O aparato é constituído dentro de uma caixa metálica e no interior desta caixa passa um tubo de PVC de 1/2” que recebe aberturas nos 2 lados onde são alocados 2 quadrados de vidro de 1 cm2 para o encaixe, de um lado, do Led RGB como emissor de luz que trabalha nos comprimentos de onda das cores vermelha (690 nm) e verde (540 nm) e, do outro lado, o LDR como coletor .As informações geradas pelos dispositivos são processadas pelo microcontrolador Arduino ATmega integrado com shild Ethernet W5100, com sensor de temperatura DS18B20 e um módulo de sensor de pH para solução, e são exibidas em um supervisório. Desta forma, a monitoração da evolução do processo de cultivo das microalgas pode ser visualizada remotamente. Foram realizados três analises, duas contendo uma quantidade de microalgas e uma somente de água, a solução de água se mostrou 0% de absorbância e outras duas demostrou valores mais significativos.
URI: http://hdl.handle.net/123456789/496
Aparece nas Colecções: Engenharia de Controle e Automação

Sistemas Operacionais de Tempo Real – Timers

Introdução

Estava desenvolvendo algumas idéias para um novo artigo técnico, quando encontrei perdida, no fundo de uma gaveta virtual, uma biblioteca de rotinas em C que desenvolvi há algum tempo. É uma preciosidade!!! Eu mesmo já utilizei essas funções em vários projetos. Estou aqui disponibilizando esse material para você.

Vou contar um pouco a história dessa biblioteca. Houve uma época em que o meu trabalho era focado em projetos de desenvolvimento de sistemas dedicados baseados em processadores da família 8051. Desenvolvemos uma célula de carga digital, um sistema de monitoramento ambiental, um mini CLP, um sistema de monitoramento e controle de um processo químico, sistema de controle de elevadores etc. Daí surgiu a ideia de elaborar funções e rotinas padronizadas, pois quase todos esses sistemas tinham alguma coisa em comum, como por exemplo teclas, displays etc. e deveriam operar em tempo real. O objetivo foi diminuir o tempo gasto para o desenvolvimento de um novo projeto. Antes de prosseguir, recomendo a leitura do artigo Sistemas Operacionais de Tempo Real – Introdução, onde são abordados alguns conceitos que serão aplicados neste artigo.

É necessário apresentar aqui alguns esclarecimentos a respeito da filosofia usada na elaboração dessas rotinas. Eu parti do princípio de que os nossos sistemas são de tempo real e que realizam periodicamente algumas funções rotineiras, tais como verificar um teclado, atualizar displays, administrar LEDs de sinalização, realizar medidas, etc. Outras ações são tomadas por demanda, ou seja, apenas quando ocorrem. Essas demandas podem ser periódicas ou assíncronas (aleatórias). Daí já reconhecemos o primeiro elemento a ser implementado no nosso Sistema Operacional: um temporizador (Timer). Para quem não sabe, os processadores tradicionais da família 8051 têm apenas 2 temporizadores, enquanto outras versões oferecem pelo menos mais um. Antes de continuar, acho interessante recordarmos a arquitetura dos microcontroladores da família MCS-51 e os modos de operação dos seus temporizadores. Na parte final desse artigo será desenvolvido um pequeno exemplo prático, cujo código poderá ser compilado e simulado.

TIMERS da família MCS-51

Para ilustrar o que será abordado aqui, vamos nos referenciar aos microcontroladores de fabricação da ATMEL, com a arquitetura baseada no 8051, cujo documento completo você pode consultar aqui: ATMEL 8051 Microcontrollers Hardware Manual. Na Figura 1 podemos observar a arquitetura interna de um microcontrolador AT89S8253, que continua sendo produzido, mostrando em destaque o bloco dos temporizadores.

Timers - Diagrama em blocos da arquitetura interna de um microcontrolador
Figura 1: Diagrama em blocos da arquitetura interna de um microcontrolador AT89S8253

 

Sem entrar nos detalhes referentes aos contadores / temporizadores Timer 0 e Timer 1 dessa família de microcontroladores, basta dizer que eles podem ser programados para funcionarem em 4 modos distintos de operação:

  • Modo 0: O temporizador é configurado como um contador de 13 bits, que pode receber um valor inicial e conta para cima. Na transição do valor limite superior 0x1FFF para  0x0000, é acionado um flag de sinalização;
  • Modo 1: Similar ao modo 0, porém é configurado o contador para 16 bits;
  • Modo 2: O temporizador é configurado como um contador de 8 bits, com um registro de 8 bits associado para recarregar o valor inicial automaticamente. Na transição, é acionado um flag;
  • Modo 3: Nesse modo de operação, o Timer 0 opera como 2 contadores distintos de 8 bits, enquanto o Timer 1 nesse modo de operação permite que se congele a contagem.

Convenções para o uso dos Timers

Para o objetivo de projetar uma biblioteca com rotinas padronizadas, foi definido que o Timer 0 seria o temporizador padrão do sistema e o Timer 1 também poderia ser usado para isso, se acaso não fosse necessário usá-lo para gerar baud-rate da comunicação serial.

O período de interrupção do temporizador deve ser o maior possível e baixo o suficiente para atender às necessidades prioritárias do sistema. Para que se entenda o motivo disso, observe o seguinte exemplo:

Suponhamos que:

  • Um microcontrolador que, por restrições de sua arquitetura e do oscilador (clock) utilizado, possa executar no máximo 10.000 instruções por segundo;
  • Uma rotina de interrupção provocada pelo temporizador execute 20 instruções na média a cada interrupção.

Se numa hipótese absurda o temporizador for dimensionado para gerar 500 interrupções por segundo, a rotina de interrupção vai consumir todo o tempo disponível para executar as instruções do microcontrolador (500 x 20 = 10.000)! Se por exemplo esse número puder cair para 50 interrupções por segundo, sem prejudicar a operação do sistema, a rotina de interrupção vai consumir apenas 10% do total disponível (1.000), deixando os outros 90% para as demais atividades do microprocessador.

A compreensão do que foi ilustrado nesse exemplo é fundamental. As rotinas que são executadas com maior frequência devem ser otimizadas para serem executadas no menor tempo possível e na menor frequência possível também. Voltando ao exemplo das 500 interrupções, se acaso a rotina de interrupção executasse apenas 18 instruções ao invés das 20, já sobrariam 1.000 instruções por segundo que poderiam ser executadas por outras atividades. Em muitos casos isso é suficiente. Note que para esse exemplo em particular, só analisamos uma das soluções possíveis para viabilizar a operação do sistema. Poderia-se também lançar mão de outros recursos, como por exemplo aumentar a frequência do oscilador do microcontrolador.

Assim a frequência da interrupção do nosso timer deve ser dimensionada de modo que:

  • A função que deverá ser executada com maior frequência possa ser atendida pelas interrupções do timer no menor tempo necessário para isso (e maior possível), definindo assim as especificações do timer de referência do sistema;
  • Outras temporizações mais lentas sejam realizadas como múltiplos da interrupção do timer e implementadas por meio de temporizadores virtuais de software.

Um temporizador virtual de software é uma estrutura no programa em que a cada temporizador é associado um valor inicial, que se traduz num número inteiro de interrupções do Timer 0, e um flag de sinalização. A cada interrupção do Timer 0, o temporizador de software é decrementado e testado se zero. Se for zero, é ligado o flag para avisar que a contagem de software foi terminada e o temporizador é reinicializado para o seu valor inicial. O tratamento do final de contagem é realizado no programa principal, testando-se o flag e reinicializando-o depois.

O timer de referência deverá funcionar no modo 2 de operação. Observe que a programação do Timer 0 depende da frequência de clock do microcontrolador, do fator de divisão do clock, que nas CPUs tradicionais do MCS-51 é de 12 vezes, e da frequência requerida de interrupção. Um último limitante é que o valor inicial do Timer nessa configuração é de no máximo 255 (8 bits). Na biblioteca também foi desenvolvido um padrão para a programação do Timer 1, especialmente se não for usado para gerar baud-rate.

Detalhes da Biblioteca em C

O código em C a seguir foi desenvolvido para o compilador KEIL C51 μVision, na versão de avaliação. Se você quiser testar o programa exemplo que desenvolveremos no final deste artigo, recomendo que você baixe e instale esse programa.  O arquivo de biblioteca com os trechos de código em C para a utilização dos timers de forma padronizada está dividido em segmentos. O primeiro segmento define uma série de constantes, que podem ser ajustadas conforme as especificações do projeto. Veja o trecho do código a seguir.

Nesse código há alguns parâmetros que precisam ser alterados, conforme o projeto:

  • #define   FREQUENCIA_DO_CLOCK_DA_CPU 12.0e+6 // Hz —->  12 MHz, por exemplo.

Inicializar essa constante com o valor do clock do seu microcontrolador.

  • #define   FATOR_DE_ESCALA_CLOCK_TIMER    12.0f     // Divide o clock por 12

Valor do pre-scaler.

  • #define   FREQUENCIA_DE_INTERRUPCAO_TIMER_0 5e+3  // Hz —- > 5 kHz, por exemplo.

Define a frequência da interrupção do timer.

São apenas esses três parâmetros que devem ser inicializados. Não é necessário alterar outras partes do código!

O segundo segmento da biblioteca refere-se às inicializações dos timers, conforme o modo de operação, e os comandos para iniciar a operação do temporizador. Observe que nesse segmento é mostrada a rotina principal (void main(void)) e indicado onde devem ser inseridos os trechos do código.

O terceiro segmento mostra como são definidas as rotinas de interrupção.

EXEMPLO

A seguir vamos desenvolver o nosso programa de exemplo. Nesse programa, será programado o Timer 0 no modo 2 de operação, com o microcontrolador operando com um clock de 4 MHz e uma frequência de interrupção de 1,5 kHz. Confira o código no quadro abaixo.

Se você quiser simular o programa exemplo acima e explorá-lo um pouco mais, siga os seguintes passos:

  • Instale o KEIL C51 μVision;
  • Baixe o arquivo Testa_Timer.zip;
  • Instale os arquivos de Testa_Timer.zip num diretório para testes;
  • Navegue até o diretório de testes e acione o arquivo Testa_Timer.uvproj (2 “clickes”)  (Figura 2).

Timers - Arquivos no diretório de teste
Figura 2: Arquivos no diretório de teste

Nesse instante deverá abrir o programa Keil e a tela deverá ser a retratada na Figura 3. Esse painel permite navegar no código em C, editá-lo e compilá-lo. Não é necessário fazer isso para realizar a simulação, mas você poderá posteriormente alterar alguns parâmetros do código e testar o programa com as novas alterações.

Timers - Programa Keil pronto com o programa exemplo carregado
Figura 3: Programa Keil pronto com o programa exemplo carregado

A seguir coloque o programa no modo de Debug (Figura 4, Figura 5 e Figura 6) para que se possa iniciar a simulação.

timers - Selecionando o modo Debug do programa
Figura 4: Selecionando o modo Debug do programa

Antes de entrar no modo de depuração, aparece na tela a mensagem da Figura 4. “Clicke” no  “OK” para continuar.

Timers - Aviso de que no modo de avaliação, o código fica limitado a 2K
Figura 5: Aviso de que no modo de avaliação, o código fica limitado a 2K

timers - Modo Debug de operação
Figura 6: Modo Debug de operação

 

Observe que já estão destacados os painéis de monitoramento do Timer 0 e do Port 3, cujo bit 1 deverá ser alternado a cada término de contagem do temporizador de software. As duas variáveis principais (bFlagTimerDeSoftware e nTimerDeSoftware) poderão ser monitoradas na janela Watch 1 durante a simulação.

É possível utilizar as teclas de função F11 para executar o programa passo a passo ou F5 entrar em execução. Recomendo que você inicie a simulação utilizando o passo  a passo para poder observar detalhadamente como que funciona o mecanismo de operação desse programa.

Resumo

Neste artigo técnico foram apresentados alguns conceitos relativos à utilização de temporizadores de hardware de um microcontrolador associados a temporizadores de software para a implementação de arquiteturas de software típicas de  sistemas operacionais de tempo real. Também foi apresentada e explicada uma biblioteca padronizada para a utilização dos timers de microcontroladores da família MCS-51, codificada em C, para ser compilada no programa da Keil. Depois foi desenvolvido um programa exemplo para que você possa simular o que foi apresentado e observar os detalhes dessa implementação.

Este artigo é o segundo da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos (em breve).

Sistemas Operacionais de Tempo Real

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.

Fonte: https://www.embarcados.com.br/rtos-timers/

Sistemas Operacionais de Tempo Real – Introdução

 

Introdução

Quando se fala em projetos para microcontroladores, especialmente os de 8 ou 16 bits, sempre surgem dúvidas com relação ao sistema operacional. É melhor comprar um sistema operacional ou desenvolver o seu próprio? Como tudo na nossa vida, a resposta a essa pergunta depende sempre da relação custo / benefício da solução. Muitos projetistas se sentem intimidados em projetar o seu próprio sistema, muitas vezes apenas por falta de experiência ou de conhecimento sobre esse assunto. Por outro lado, aprender a usar um sistema operacional de terceiros pode ser um tanto quanto trabalhoso e demorado. Se o sistema não for de uso gratuito, ainda será necessário pagar royalties para cada CPU que executar esse programa.

Neste artigo vou desenvolver alguns raciocínios que mostrarão o fato de que desenvolver um sistema operacional próprio para microcontroladores de 8 ou 16 bits é bem mais simples do que possa parecer. Será apresentada uma estrutura bastante intuitiva e simples de como organizar o seu software de forma que ele opere em tempo real com segurança. Antes disso, precisamos conceituar alguns tópicos. Observe que o assunto sobre Sistemas Operacionais é abordado neste artigo de uma forma muito superficial. Sistemas Operacionais e Sistemas de Tempo Real são temas bastante extensos e complexos e são ensinados em cursos de graduação e pós-graduação. Neste artigo vamos apresentar somente o necessário para compreender a filosofia e preparar o terreno para apresentar em artigos futuros algumas soluções padronizadas para se implementar sistemas de tempo real.

O que é um Sistema Operacional?

Segundo uma definição encontrada na Wikipedia, um Sistema Operacional  é um programa ou um conjunto de programas cuja função é gerenciar os recursos do sistema (definir qual programa recebe atenção do processador, gerenciar memória, criar um sistema de arquivos, etc.), fornecendo uma interface entre o computador e o usuário. Embora possa ser executado imediatamente após a máquina ser ligada, a maioria dos computadores pessoais de hoje o executa através de outro programa armazenado em uma memória não-volátil do tipo ROM (Read Only Memory) chamado BIOS (Basic Input Output System) num processo chamado bootstrapping, conceito em inglês usado para designar processos auto-sustentáveis, ou seja, capazes de prosseguirem sem ajuda externa. Após executar testes e iniciar os componentes da máquina (monitores, discos, etc), o BIOS procura pelo sistema operacional em alguma unidade de armazenamento, geralmente o Disco Rígido, e a partir daí, o sistema operacional toma o controle da máquina. O sistema operacional reveza sua execução com a de outros programas, como se estivesse vigiando, controlando e orquestrando todo o processo computacional.

Segundo alguns autores, existem dois modos distintos de conceituar um sistema operacional:

  • visão top-down pela perspectiva do usuário ou programador: é uma abstração do hardware, fazendo o papel de intermediário entre o software (programas) e os componentes físicos do computador, o (hardware); ou
  • numa visão bottom-up, de baixo para cima: é um gerenciador de recursos, i.e., que controla quais aplicações (processos) podem ser executadas, quando devem ser executadas e quais recursos (memória, disco, periféricos) podem ser utilizados.

 Alguns sistemas operacionais populares são: Windows, Linux, Mac OS, Android, etc.

O que é um Sistema Operacional de Tempo Real?

Sistemas operacionais de tempo real ou RTOS (Real Time Operating Systems) são uma categoria especial de sistemas operacionais. Eles são voltados para aplicações onde é essencial a confiabilidade e a execução de tarefas em prazos compatíveis com a ocorrência de eventos externos.

Por exemplo, se num paciente de UTI ocorrer uma variação importante nos batimentos cardíacos, o monitor cardíaco desse paciente deve ativar um alarme em poucos segundos.

 ID-100279454

Outro exemplo: se um avião em voo com o piloto automático desviar da rota, o controle do avião deve corrigir imediatamente essa rota retornando o avião à rota original.

ID-100177451

Tempo real é um termo que pode ter significados muito diferentes, dependendo da velocidade da ocorrência dos eventos de um sistema e dos tempos de resposta necessários para atender a esses eventos. Há sistemas que podem levar um tempo muito longo para modificar o seu estado. Em geral os processos térmicos de aquecimento são lentos. Pode levar dias ou até semanas para esses processos responderem a determinados estímulos. Nesse caso em particular, um sistema operacional comum serviria perfeitamente para realizar o controle do processo.

Particularidades de um Sistema Operacional de Tempo Real

Há muitos detalhes num Sistema Operacional de Tempo Real que merecem ser apresentados. O principal é que as rotinas de processamento em geral são bastante especializadas e curtas, pois devem executar a sua tarefa no menor tempo possível. Há um forte paralelismo na execução das atividades e um estabelecimento de prioridades, onde as atividades mais prioritárias interrompem as menos prioritárias e assumem o controle do processador. A divisão de tarefas em rotinas especializadas requer que haja alguma forma de sincronismo ou troca de informação entre elas, por exemplo, para que seja informado que tarefa já foi concluída ou não por outra rotina. Algumas estruturas comuns para a troca de informações:

  • Semáforos ou flags: são definidos bits ou palavras para a sinalização do tipo booleano ( binário 0 ou 1) para a troca de mensagens entre duas rotinas;
  • Áreas de troca de mensagens, filas  ou buffers: memórias temporárias que com auxílio dos semáforos permitem a transferência de estruturas de dados maiores entre as rotinas.

Exemplos

Para ilustrar as diversas arquiteturas de tempo real, serão apresentados dois exemplos bastante simplificados.

Exemplo 1

Suponhamos que um programa de computador deseje realizar a transmissão de uma mensagem pela USB. Num sistema comum, ilustrando de uma maneira simplificada, esse programa monta a mensagem e chama a rotina para a transmissão e só são retomadas as próximas atividades após o término da transmissão. Esse tipo de programação é conhecida como programação linear.

No caso de um sistema de tempo real (veja a Figura 1) a sequência de operações pode ser assim:

Transmissão-Serial_a

 Figura 1: Transmissão de caracteres em tempo real simplificada

     Para melhor entendimento ficará convencionado que:

  • flag buffer vazio” = 1,    significa que não há dados no buffer temporário;
  • flag buffer vazio” = 0,    significa que há dados novos no buffer temporário.

    Programa principal:

  • O programa principal inicialmente testa se o buffer temporário está disponível ou vazio (flag buffer vazio” = 1);
  • Se estiver vazio, monta a mensagem numa estrutura temporária (buffer);
  • Dispara a transmissão do conteúdo do buffer temporário alterando o flag “buffer vazio” para “não está vazio” (flag “buffer vazio” = 0);
  • Continua a execução das outras atividades enquanto é realizada a transmissão.

      Rotina de Transmissão:

  • Fica dormente ou então testa periodicamente o flag “buffer vazio”;
  • Se o flagbuffer vazio” indicar que há dados novos (flag “buffer vazio” = 0), transfere os dados do buffer temporário para o buffer de transmissão;
  • Altera o flag de “buffer vazio” sinalizando que o buffer está disponível para novos dados (flag “buffer vazio” = 1);
  • Transmite os caracteres, um de cada vez, até transmitir o último;
  • Sinaliza que “Terminou a transmissão” (flag).

Observe que em geral a rotina de transmissão é programada para ser ativada por interrupção, de forma que ela não gaste ciclos de máquina enquanto espera o término de transmissão de um caracter. Assim é aproveitado o hardware do microcontrolador para realizar tarefas em paralelo com o programa principal.

Exemplo 2

Esse exemplo é baseado num projeto real. Trata-se de uma placa mezanino cuja função é processar simultaneamente os dados referentes a 4 canais telefônicos em tempo real de forma a implementar as seguintes funções:

  • Cancelamento de resíduo de voz na linha de recepção resultante do eco da “fala” gerada pela placa mãe sem distorcer os sinais de origem externa;
  • Pré-processar os sinais de entrada identificando pulsos decádicos telefônicos através de filtragens e outros processamentos;
  • Implementação parcial de call-progress, focando na detecção do tom de “ocupado” e de “linha”.

O sistema operacional de tempo real para esse caso foi projetado em camadas, com prioridades atribuídas decrescentes nas camadas conforme vai crescendo o índice da camada. O fluxo de dados tem taxas decrescentes das camadas inferiores para as superiores. Veja na Figura 2. Observe que a comunicação entre as camadas é realizada através de filas ou buffers circulares, dimensionados de forma que num regime de atendimento simultâneo de quatro linhas telefônicas, o fluxo médio de dados nunca provoque o “estouro” dessas filas. A cada buffer estão associados ponteiros de início e final da fila (“primeira livre”) e uma variável indicando o número de dados que estão na fila. O mecanismo convencionado para a operação das filas circulares é o seguinte:

  • Quem transfere um dado para a fila, incrementa o número de elementos e o ponteiro para o final;
  • Quem retira da fila, decrementa o número de elementos e incrementa o ponteiro de início.

Mezanino_Original

Figura 2: Diagrama da arquitetura do programa em camadas

Uma descrição resumida do que ocorre em cada camada:

CAMADA 0

Trata basicamente dos eventos gerados externamente ao programa. Há eventos assíncronos gerados pela placa-mãe e outros síncronos gerados por temporizadores de hardware. Esses eventos são:

  • Chegada de mensagem enviada pela placa-mãe. Essa mensagem é inserida na fila de entrada de mensagens, que será tratada pela CAMADA 1;
  • Interrupção de hardware com frequência de 10 Hz para a atualização dos estados de cada linha telefônica;
  • Interrupção de hardware com frequência de 8 kHz onde são lidos os dados das 4 linhas telefônicas, e
    • é realizada a decodificação dos dados recebidos;
    • é aplicada uma rotina de cancelamento de eco com filtragem digital adaptativa;
    • o sinal filtrado segue por 3 caminhos:
      • é utilizado como sinal de erro para cálculo do ajuste dos coeficientes do filtro adaptativo;
      • é transferido para a fila que alimenta a CAMADA 1. (Taxa de 8.000 amostras/s);
      • é novamente codificado e retorna à placa-mãe.

CAMADA 1

Realiza o loop principal do programa com funções de pré-processamento dos sinais entregues pela CAMADA 0 na fila de dados e o tratamento das mensagens vindas e que são endereçadas à placa-mãe. A CAMADA 0 é composta pelo encadeamento das seguintes rotinas:

  •  Tratamento dos dados provenientes das linhas telefônicas:
    • Realiza o processamento e a análise de duas linhas por vez gerando uma saída para a CAMADA 2. A taxa máxima desses dados para a CAMADA 2 é de 170 amostras/s;
    • Realiza um pré-processamento de dados analisando simultaneamente as 4 linhas e gera para a CAMADA 2 um fluxo de dados de 400 amostras/s endereçada ao detetor de pulsos decádicos. Também repassa uma mensagem para a placa mãe quando a CAMADA 2 detectar um pulso;
    • Descarta dados das filas e atualiza os ponteiros.
  • Chamada das rotinas que compõem a CAMADA 2.

CAMADA 2

Realiza a análise dos dados gerados na CAMADA 1 e gera as saídas endereçadas à CAMADA 1 ou à placa-mãe. É composta pelas rotinas:

  • Realiza a análise dos dados para detecção de pulsos decádicos. Gera mensagens endereçadas à placa-mãe;
  • Realiza a identificação dos tons de “ocupado” e de linha e sinaliza por meio de mensagens à placa-mãe.

Nesse exemplo o software foi dividido em camadas com prioridades decrescentes para conseguir acomodar todas as funções previstas para o mezanino no curto tempo disponível para a sua execução. Esse projeto funcionou e ficou em operação por pelo menos 10 anos.

 O que é Firmware?

Para completar esse trabalho é interessante conceituar Firmware. Transcrevendo mais uma vez uma definição apresentada pela Wikipedia:

Em eletrônica e computação, firmware é o conjunto de instruções operacionais programadas diretamente no hardware de um equipamento eletrônico. É armazenado permanentemente num circuito integrado (chip) de memória de hardware, como uma ROM, PROM, EPROM ou ainda EEPROM e memória flash, no momento da fabricação do componente. Muitos aparelhos simples possuem firmware, entre eles: controles-remotos, calculadora de mão, algumas partes do computador, como disco rígido, teclado, cartão de memória, unidades USB’s muitos instrumentos científicos e robôs. Outros aparelhos mais complexos como celulares, câmeras digitais, sintetizadores, entre outros, também possuem um firmware para a execução de suas tarefas.

Não há fronteiras rígidas entre firmware e software, pois ambos são termos descritivos bastante livres. Contudo, o termo firmware foi originalmente inventado para contrastar com software de alto nível que poderia ser alterado sem a troca de um componente de hardware, e o firmware está normalmente envolvido com operações muito básicas de baixo nível das quais sem um dispositivo seria completamente não-funcional.

Nos próximos artigos serão apresentadas rotinas padronizadas para utilização em sistemas de tempo real. Nesses artigos serão utilizados diversos conceitos expostos aqui.

Resumo

Sistemas Operacionais de Tempo Real têm uma filosofia muito peculiar na sua arquitetura. Os programas são organizados de forma a poder responder a estímulos externos ou internos num tempo curto o suficiente e compatível com a importância ou urgência do evento que gerou esses estímulos. Frequentemente esses sistemas operacionais estão intimamente ligados ao hardware de um sistema.

Se você quiser se aprofundar um pouco mais sobre esse assunto:

Artigos relacionados

Sistemas Operacionais de Tempo Real

  • Sistemas Operacionais de Tempo Real – Introdução (este artigo) –  Apresentação introdutória do que é um sistema operacional e as características que o tornam um sistema de tempo real. Também são apresentadas algumas estruturas que facilitam o seu projeto.

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers  – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.
Fonte: https://www.embarcados.com.br/sistemas-operacionais-de-tempo-real-rtos/

Proposta de identificação de ataques ao serviço SSH usando padrões no consumo de corrente em plataformas embarcadas

Resumo: Este trabalho apresenta a obtenção de curvas de consumo de corrente elétrica, a partir das respostas geradas por um sistema embarcado de baixo custo Raspberry Pi 2 Model B executando o sistema operacional Linux Raspbian trabalhando como um servidor de acesso remoto SSH, que é avaliado através de diferentes tipos de acessos e ataques de força bruta com dicionários através das ferramentas especializadas Medusa e Hydra, como também a ferramenta não especializada Metasploit. O comportamento energético é interpretado por um sistema de medição de consumo de corrente desenvolvido pela plataforma embarcada de baixo custo Arduino Uno que administra um sensor de corrente baseado no chip ACS721ELC- 5A de efeito Hall, que possui a capacidade de coletar as variações geradas pela plataforma de teste em resposta aos eventos produzidos pelos cenários de provas propostos, os dados são processados pelo Framework Matlab que coleta, analisa e normaliza por meio do método de Welch o sinal de corrente que é interpretado pelo Arduino Uno, posteriormente apresentase uma curva padrão que caracteriza um determinado evento baseado nos cenários de provas. Os resultados apresentam as diferentes curvas padrões normalizadas, e contextualizadas nos tipos de cenários avaliados, seguidamente apresenta-se um modelo matemático teórico do consumo de corrente proposto, como também as regras ou assinaturas propostas para identificar um ataque através do método de detecção por padrões que utilizada o IDS Snort. Essas curvas de corrente facilitam o entendimento e obtenção de um padrão de consumo de corrente para cada acesso e ataque na plataforma embarcada.

https://bdtd.ufs.br/handle/tede/3365

PROPOSTA DE IDENTIFICAÇÃO DE ATAQUES AO SERVIÇO SSH USANDO PADRÕES NO CONSUMO DE CORRENTE EM PLATAFORMAS EMBARCADAS

Este trabalho apresenta a obtenção de curvas de consumo de corrente elétrica, a partir das respostas geradas por um sistema embarcado de baixo custo Raspberry Pi 2 Model B executando o sistema operacional Linux Raspbian trabalhando como um servidor de acesso remoto SSH, que é avaliado através de diferentes tipos de acessos e ataques de força bruta com dicionários através das ferramentas especializadas Medusa e Hydra, como também a ferramenta não especializada Metasploit. O comportamento energético é interpretado por um sistema de medição de consumo de corrente desenvolvido pela plataforma embarcada de baixo custo Arduino Uno que administra um sensor de corrente baseado no chip ACS721ELC- 5A de efeito Hall, que possui a capacidade de coletar as variações geradas pela plataforma de teste em resposta aos eventos produzidos pelos cenários de provas propostos, os dados são processados pelo Framework Matlab que coleta, analisa e normaliza por meio do método de Welch o sinal de corrente que é interpretado pelo Arduino Uno, posteriormente apresentase uma curva padrão que caracteriza um determinado evento baseado nos cenários de provas. Os resultados apresentam as diferentes curvas padrões normalizadas, e contextualizadas nos tipos de cenários avaliados, seguidamente apresenta-se um modelo matemático teórico do consumo de corrente proposto, como também as regras ou assinaturas propostas para identificar um ataque através do método de detecção por padrões que utilizada o IDS Snort. Essas curvas de corrente facilitam o entendimento e obtenção de um padrão de consumo de corrente para cada acesso e ataque na plataforma embarcada.

CAPÍTULO 1 INTRODUÇÃO De acordo com [COELHO et al. 2014], a segurança da informação tem a responsabilidade de proteger a informação sendo determinante para assegurar a competitividade, a lucratividade, e o atendimento aos requisitos legais, preservando a imagem da organização junto ao mercado. A segurança de informação, segundo [GIAVAROTO et al. 2013], não é um produto, é um processo, e por isso, há uma enorme dificuldade em determinar qual é o nível de segurança apropriado. É necessário investigar os riscos, realizar testes, validar as políticas de segurança e tecnologias utilizadas com o objetivo de atender os preceitos de segurança da informação. A segurança nas comunicações [STALLINGS 2007] é uma prática que contém como tarefa principal, prevenir o acesso não autorizado a certos recursos informáticos. Esta conotação é mais estrita no sentido de desenho das soluções entre duas entidades que tentam estabelecer um meio de comunicação comum e seguro. Neste contexto, os protocolos de comunicações são os responsáveis de administrar mecanismos necessários, a fim de estabelecer uma ligação entre uma origem e um destino de forma que os dados enviados sejam transmitidos em forma segura [AMATO 2001]. A confidencialidade, segundo os autores [KUROSE et al. 2010], é um conceito que garante a segurança na transmissão de mensagens e devem ser compreendidas somente pelo remetente e pelo destinatário. A forma de afiançar esta segurança é através de técnicas de cifragem de dados combinada com a autenticação do ponto final. Na atualidade existem soluções em software que cifram os canais de comunicação garantindo a confiabilidade dos dados transmitidos, um exemplo são as redes privadas virtuais VPN [MASON et al. 2002], arquitetura de comunicação que concede um nível aceitável de segurança. Esta arquitetura de segurança exposta a condições de ataques especializados pode chegar a comprometer sua segurança, desta forma um atacante externo está possibilitado a interceptar as mensagens enviadas e recebidas com o agravante de manipular as comunicações à sua vontade [ASHIDANI 2009]. O serviço de comunicação SSH [SILVERMAN et al. 2001] é o serviço de rede mais difundido e utilizado na administração remota de recursos informáticos. Uma das capacidades que possui SSH é estabelecer um canal de comunicação cifra entre uma origem e um destino, este serviço é muito utilizado com o fim de realizar a administração geral de um sistema informático remoto [LAUDON et al. 2013]. Desde o ponto de vista dos administradores de sistemas é a ferramenta por excelência na administração remota, também um ponto de ataque relevante para potenciais intrusões e tudo tipo de ameaças [TABISH et al. 2009]. Hoje em dia se conhecem Malwares [INCE 2008] muito sofisticados que automatizam tudo o processo de conexão a um sistema remoto baseado em ameaças conhecidas [MORTENSEN et al. 2013]. Os sistemas embarcados de acordo com os autores [MORENO et al. 2003] são definidos como uma unidade central de processo integrado a um sistema maior com o objetivo de auxiliar o controle e execução de tarefas, ademais os sistemas embarcados em termos gerais são considerados dispositivos eletrônicos de propósitos gerais. Um claro exemplo é o projeto Raspberry Pi Foundation1 , esta iniciativa nasceu com o objetivo de estimular o ensino da informática baseado na filosofia Open hardware e Open software. Seu desenvolvimento está direcionado em uma economia de escala, frente a um mercado competitivo de sistemas embarcados existentes, tais como: Oluxino2 , Cubieboard23 , Odroid4 , Beagleboard5 , Raspberry Pi possui a maior cota de mercado neste segmento, isso se deve à relação que existe entre o preço e as características disponíveis. Na Tabela 1.1 apresentam-se as características técnicas dos sistemas embarcados mencionados anteriormente…

 Link: https://bdtd.ufs.br/bitstream/tede/3365/2/VICTOR_GABRIEL_GALVAN.pdf

Do Paper Circuit à programação de Arduino com Scratch: uma sequência didática para aprendizagem do conteúdo de energia nos anos iniciais do Ensino Fundamental

Some content on this page was disabled on December 22, 2017 as a result of a DMCA takedown notice from Elaine Silva Rocha Sobreira. You can learn more about the DMCA here:

https://en.support.wordpress.com/copyright-and-the-dmca/

Atualizando Firmware ESP8266

Encontrei estes vídeos muito simples e gostaria de compartilhá-lo com vocês. Não tem voz com sotaque, nem baboseira que nos faz perder tempo.

ESP8266 ESP-01 WiFi IOT Module Flashing or Re-flashing Firmware Update Ai Thinker version Tutorial 1. How to update or re-flashing ESP8266 ESP-01 Ai Thinker version firmware using ESP Flash Download Tool.

Default Version (Jun 5 2015):
SDK 0.9.5 (Ai-Thinker)
AT 0.21.0.0 (Ai-Thinker)

Re-flashing firmware (512KB/4Mbits flash size board version):
– The latest firmware is SDK 1.3.0 but we will flash it the same version as it is the only version that support this ESP-01 with 4Mbit of flash size. You may use the latest version if you have larger flash size.
SDK 0.9.5 (Ai-Thinker)
AT 0.21.0.0 (Ai-Thinker)

Required Firmware file and address (no 4Mbits/512kByte version support version 1.0 and above):
ai-thinker-0.9.5.2.bin (0x00000)

Item Required:
1. ESP8266 ESP-01 4Mbit/512kB version (Hardware) – http://www.aliexpress.com/wholesale?S…
2. FTDI USB to Serial UART Adapter (Hardware) – http://www.aliexpress.com/wholesale?S…
3. Jumpers (Hardware) – http://www.aliexpress.com/wholesale?S…
4. Breadboard (Hardware) – http://www.aliexpress.com/wholesale?S…
5. PuTTY (Software) – http://www.chiark.greenend.org.uk/~sg…
6. ESP Flash Download Tool (Software) – http://bbs.espressif.com/viewtopic.ph…
7. Ai-Thinker Firmware (Firmware) – http://wiki.aprbrother.com/wiki/Firmw…

Extra (For external Power Supply):
1. 3.3V 1A Voltage Regulator (AZ1117T) – http://www.aliexpress.com/wholesale?S…
2. Mini/Micro USB Breakout Board – http://www.aliexpress.com/wholesale?S…
3. Power Bank

NOTE: External power supply is required if the PuTTY or Serial Monitor unable to give response or always show an error.

Steps:
1. Prepare all the hardware required.
2. Build up all connection between ESP8266 ESP-01 and FTDI.
3. Download PuTTY Terminal Program.
4. Download ESP Flash Download Tool.
5. Download the Ai Thinker firmware.
6. Connect and check the current version of firmware using PuTTY.
7. Upload the firmware using ESP Flash Download Tool.
8. Check the uploaded version of firmware using PuTTY.

IMPORTANT NOTE:
1. External power supply is required if the PuTTY or Serial Monitor unable to give response or always show an error.
2. Ai-Thinker firmware version 1.0 and above requires at least 1MB (8Mbit) of Flash. 512kB (4Mbit) of Flash has to use older version (v0.9.5.2 – refer to alternative link below)

Official Download Link for Latest Ai-Thinker firmware:
http://bbs.ai-thinker.com/forum.php?m…

Alternative Download Link for Latest Ai-Thinker firmware:
http://www.electrodragon.com/w/ESP826…

Alternative Download Link for older version Ai-Thinker firmware:
http://wiki.aprbrother.com/wiki/Firmw…

SUBCRIBE Youtube for Channel for more Tutorial Videos:
Youtube Channel: https://www.youtube.com/channel/UCcod…

Soundtrack credits:
Jahzzar – betterwithmusic.com – CC BY-SA
Rainy_Day_Games – YouTube Audio Library

Publicado em 29 de out de 2016

ESP8266 ESP-01 WiFi IOT Module Flashing Firmware Update Espressif Version Tutorial 2. How to update ESP8266 ESP01 Espressif version firmware using ESP Flash Download Tool.

————————————–
I N F O :
————————————–
Default Version (Jun 5 2015):
SDK 0.9.5 (Ai-Thinker)
AT 0.21.0.0 (Ai-Thinker)

Upgrade to latest supported (4Mbit Flash of ESP-01) Espressif version (Sep 18 2015) – Refer Important NOTES for details:
SDK 1.4.0 (Espressif Non-OS no-boot)
AT 0.50.0.0 (Espressif Non-OS no-boot – Sep 18 2015)

ESP-01 Board Flash size: 4Mbit/512KByte version

————————————–
F I R M W A R E :
————————————–
Required Firmware file and address (4Mbit/512KB version):
1. esp_init_data_default.bin (0x7c000)
2. at\noboot\eagle.flash.bin (0x00000)
3. at\noboot\eagle.irom0text.bin (0x10000)
4. blank.bin (0x3e000)
5. blank.bin (0x7e000)

————————————–
P R E P A R A T I O N :
————————————–
Item Required:
1. ESP8266 ESP-01 (Hardware) – http://www.aliexpress.com/wholesale?S…
2. FTDI USB to Serial UART Adapter (Hardware) – http://www.aliexpress.com/wholesale?S…
3. Jumpers (Hardware) – http://www.aliexpress.com/wholesale?S…
4. Breadboard (Hardware) – http://www.aliexpress.com/wholesale?S…
5. PuTTY (Software) – http://www.chiark.greenend.org.uk/~sg…
6. ESP Flash Download Tool (Software) – http://bbs.espressif.com/viewtopic.ph…
7. NON-OS ESP8266 SDK Firmware (Firmware) – http://bbs.espressif.com/viewtopic.ph…

Extra (For external Power Supply):
1. 3.3V 1A Voltage Regulator (AZ1117T) – http://www.aliexpress.com/wholesale?S…
2. Mini/Micro USB Breakout Board – http://www.aliexpress.com/wholesale?S…
3. Power Bank

————————————–
S T E P S :
————————————–
1. Prepare all the hardware required.
2. Build up all connection between ESP8266 ESP-01 and FTDI.
3. Download PuTTY Software.
4. Download ESP Flash Download Tool.
5. Download the latest Espressif Non-OS ESP8266 SDK firmware (use this SDK 1.4.0 version since this is the only version applicable for 4Mb of flash size – refer IMPORTANT NOTES below).
6. Connect and check the current version of firmware using PuTTY.
7. Upload the latest Espressif firmware using ESP Flash Download Tool.
8. Check the latest version of firmware using PuTTY.

————————————–
I M P O R T A N T N O T E S :
————————————–
1. External power supply is required if the PuTTY or Serial Monitor unable to give response or always show an error.
2. 4Mbit of Flash is not supported for SDK v1.5.0 (15_11_27) and above for both boot and non-boot mode due to large size of AT firmware (Starting ESP8266_AT_v0.51). Please use 8Mbit Flash or larger.
3. 4Mbit of Flash is only support non-boot mode for SDK v1.1.0 (15_05_22) until SDK v1.4.0 (15_09_18).
4. Please refer to README file in bin/at/ folder for another flash size.
5. If you have an upgraded version of ESP-01 with 8Mbit of flash size (Black Color), Please refer ESP-201 (8Mbit Flash size) tutorial video on how to download latest SDK firmware. Link here: https://www.youtube.com/watch?v=U8ubG…

————————————–
S U B S C R I B E :
————————————–
SUBCRIBE MakerStream YouTube Channel for more Tutorial Videos:
YouTube Channel: https://www.youtube.com/channel/UCcod…

Soundtrack credits:
Jahzzar – betterwithmusic.com – CC BY-SA – intro sound (cropped)
Rainy_Day_Games – YouTube Audio Library

Programação, Robótica e Música Para Baixinhos

Exemplo de ensino da programação e robótica em sala de aula. Evidentemente que o primeiro protótipo lhe dará um trabalhão para fazer, porém depois de pronto, você possui matéria para meio ano letivo, nesse pequeno e encantador brinquedinho Cover. A didática fica por sua conta. Quem tiver o interesse em desenvolver esse projeto com Raspberry PI + Arduino Mega + Arduino Nano, estamos aí…

Não esqueça, o Youtube é uma rede Social.

Mais de 600GB de material para estudo em TI: Cursos, vídeo aulas, livros, apostilas de todas as variantes da Tecnologia da informação:

 60 GB em vídeos aulas de Java 16 DVDS – Senha = pr0mp7.torrent

Tamanho:153 KB
https://mega.co.nz/#!JRgjRLBT!nNg8JO31WWskPXH96xn1efu9mZqfgM%20jVZo24v6CAiLg

Livro Python para Pentester e Hackers

https://mega.nz/#!atQHACib!jff1wMGqCDMq1s8CjGWcbLDAcgol53DXvWYrwehV6tE

Curso de PHP

https://mega.nz/#F!WJVmQI4K!oosRA55mOWFMGR5qu9ssJg

Curso DreamWeaver

https://mega.nz/#F!AUhkiSpK!HlSxR0lexLecXjCowGG3AQ

Curso de Redes

https://mega.co.nz/#F!hZxDHLIZ!Pw8xfRmJirbL9Jvvip_iKw

Segurança em Redes

https://mega.co.nz/#F!cdQWjA5S!cX1sn4-sDpl1iWTH2b8-8w

Banco de Dados

https://mega.co.nz/#F!4R4ywJYb!-QLSTcDQ7GyhLeauC9HOlA

Curso de Eletrônica

https://mega.co.nz/#F!EYplFZRJ!Hd3g53t4SWuZ_ocF1fGLaw

Curso de JOOMLA completo

https://mega.co.nz/#F!kAohEChQ!C0XDspJDpw7tVxAgZizcaw

Curso de Linux

https://mega.co.nz/#F!YNI3kS5R!VsbYhu0sYIidqlKwwnH14Q

Curso Hardware

https://mega.co.nz/#F!EBAUCBDC!M2L3z07ypj05HtAQSeXkGA

Mega pacote de cursos Alura

https://mega.nz/#!FhxXwK7K!-Kzt-IDBs-rhVWC1_DgaULd7vSkZG7dWULCi_99kiOY

Curso Wireless Hacking

https://mega.co.nz/#F!AFJm2TLK!I6f4pZSX2ltoGBs0b1ztsQ

Curso WordPress

https://mega.co.nz/#F!cBIUBDTZ!Qtx1ahx-YeXUPdzIghwatA

Engenharia de software

https://mega.co.nz/#F!gUAmjbpD!BW7cylJHD_rcO1rryJ1sVQ

Hacking

https://mega.co.nz/#F!ER53kboI!H2RKhe5oMegv0APK2cQoFQ

https://mega.co.nz/#F!9QhWHbTI!oarMp7t3tzyY_yu08KHoEQ

Hardware

https://mega.co.nz/#F!oIZW3AzQ!LqcZV5fNLLmsxKfXAl6EtA

Introdução aos Sistemas Operacionais

https://mega.co.nz/#F!oZpVgbTR!MnX35yBQTexHPm4J8nIP2A

Linux

https://mega.co.nz/#F!YNg3xYhY!KQxsOV5rOF4ZhZm5LaiTwQ

Linux Essentials

https://mega.co.nz/#F!sBZhXDAI!NCWJslFznUXBaymdg_kmuA

Lógica de Programação Usando Python

https://mega.co.nz/#F!QAZ31aYY!JtCs0a5who41VK3jNsBa4Q

OYS pentest – Curso Teste de Invasão em Redes e Sistemas

https://mega.co.nz/#F!dVQkDTIQ!MLNKb5ZELHuIarpqHA0HxQ

Programação WEB

https://mega.co.nz/#F!AQQU3LYI!MIYAsxFZtfFTxpIqfHfIBg

Redes

https://mega.co.nz/#F!NMh1SZQC!5CKtEXGJy2JrIafPhvUuew

Segurança

https://mega.co.nz/#F!MN402QIb!_S4Jg-opFAFQVtl3lR4yJQ

Sistemas Operacionais

https://mega.co.nz/#F!JJAVwQAC!FB-jqhynRl_3CUuNzt7oMw

Software Livre

https://mega.co.nz/#F!EMgUkKxI!Wmv2SRC5bQNiLaZdbNBa9w

Teste de Invasão em Redes Sem Fio

https://mega.co.nz/#F!AUQwgIpa!NFW83TBeph3-7A7-LZqy4Q

Apostila HTML CSS

https://mega.co.nz/#!8FpXjbKB!11EMXK2wdfH3OC5BseR0PMbT9MYSGO%20tMtJrfiv5umEE

Artigo – wireshark

https://mega.co.nz/#!pc43VIpR!qy50wLU0yM7TsaeJtNu7RdaFw88BId%20VmDxCqd_E7ouQ

Curso Android Básico

https://mega.co.nz/#!pRAglZqB!hxJ9kG6dvUVukuT5tKQFMzf7_2jKdx%20V4SjM-IFzl2ns

Curso Banco de dados SQL e Modelagem

https://mega.co.nz/#!QYZSlCLB!FudRrApaiBV1oshkcHo2Rm38KeKSk1%20i_WN_0G84Q41M

Curso completo de Python

https://mega.co.nz/#!pEwA1IBL!REq1z_rnrc-ttqhEI-aGnxHcxc__0x%20gix5F98CwCkKI

Curso Linux

https://mega.co.nz/#!JIxVgYTZ!2aVR4SMtttlGoaEbTl7NGXa8n_VuhE%20K9XzjrlchSqss

Curso ipv6

https://mega.co.nz/#!xd50wAjA!sXt5m6tdZkZ_0ppNw7RKAw9gWgNYsM%20qVR12tr9FoTvM

Hackeando Mentes

https://mega.co.nz/#!kIBzmYAQ!VEYe_yI1Q6xBBsq_m5yvv_eIG3DH3n%20Xbp2AKkqLly88

Hacker inside

https://mega.co.nz/#!9ZgSyCCY!sBTV9Mva-fCYw5QKF0TkJfolcDsuox%20KqadjDqrjQTIM

Kevinmitnick a arte de enganar

https://mega.co.nz/#!INJglDRQ!H1KGBLTP9pEWtfZrp5VAbspu0Uo_Me%20_hkvtNh4B3Dm0

Banco de dados

https://mega.nz/#F!edRGmCIC!RS7TIjy7Krd4blcpLk2_hw

Computação Forense

https://mega.nz/#F!LVZgyKxT!0UEl9uphWKK5XN2iHo2ZTg

Curso inglês

https://mega.nz/#F!rMQW2CiD!nUNJvZ1nIeRHBMx33Vw8oQ

DeepWeb

https://mega.nz/#F!SdACSJSL!ck9c2S2FvjdI-L1ji-8JkQ

Edição de imagens

https://mega.nz/#F!vFIGFBpI!eRnEOpNziIS_mZx4IAIUsg

Engenharia de software

https://mega.nz/#F!ScwiGDhY!mFZz6mdkPMGVs5_6ZPOQeQ

Hacking

https://mega.nz/#F!vVoUhSrY!CCRwM3BC7U31BaAFZHl5SQ

Introdução a sistemas operacionais

https://mega.nz/#F!3doigIaC!pbDI81QC_3K2sD-Y08i1_g

Microsoft office

https://mega.nz/#F!KE4h2KQJ!ARugbDhPAqm9WWet6R606g

Normas para a apresentação de trabalhos acadêmicos

https://mega.nz/#F!2YpWWYrQ!njzFN2wdEjcL-n48ouCwvA

Programação WEB

https://mega.nz/#F!Lc4jwILR!YjIOrB8spSKjbwHmNvP8hQ

Redes

https://mega.nz/#F!vdIXgCRB!LpBx2GGbuthGu7FLHL5CsA

Segurança

https://mega.nz/#F!bFgHiBZB!XHC6bDoVYO3JEMJzf3pPmg

Sistemas operacionais

https://mega.nz/#F!fBxDULYK!g6jOZV3cjXwLYzuWhqCUnA

Software Livre

https://mega.nz/#F!HFABDDgQ!eH-cL2wdBu5y_fbY8yV78A

Teoria da computação

https://mega.nz/#F!rRwjTSiC!QOCkako5vL8sIarKYrZHPA

Vídeo aulas

https://mega.nz/#F!iJgkhDRI!LcvTfLA5rRUe1fwdqa1BUA

São tantos cursos que não dá nem pra mencionar aqui do que eles tratam, mas tem coisa muito boa lá, e grande parte deles são bem atuais, tratando sobre Web, Deepweb, Programação, Pentest, Hacker, Linux. Office, Idiomas, e muitos mais.

+BONUS DE MAIS 380GB em cursos ainda não catalogados:

https://mega.co.nz/#F!98cg2TSR!1q1OctEo3sOq25J11JAbOg

https://mega.nz/#F!V55BFDbD!3cBs3zMuk168LXfhfRmm-g
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA!tZcAXCrK
https://mega.nz/#F!mIcTSRgJ!or6uaG2MJdh4jEKuHPYo_g!SAEDHBbB
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA!ARcBlRhZ
https://mega.nz/#F!WJVmQI4K!oosRA55mOWFMGR5qu9ssJg
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA
https://mega.nz/#F!WcBzgZhK!pJ1WsYkq8Evo1EhJi5oiJA
https://mega.nz/#F!mBB1BSrJ!RPojuKs757rJAIk-hVo4vw

https://mega.nz/#F!khhRAbwa!W5xZdG5Yat_y10Em_rmCng

https://mega.nz/#F!AE9GlDRT!mQQ1laUDxLw52-q1DljDsg

https://mega.nz/#F!CV9WFJYK!cjNuwXYg5wm6rc0YZTqaIg

https://mega.nz/#F!YF12iJ6B!933zM4O_EAxQWR16jC7I3Q

https://mega.nz/#F!ml8xGDYT!8LXsPyDMvQj8jWaM1k4rYQ

https://mega.nz/#F!tsNijbTR!Qj–39YrI4RsIwu6NTrfTQ

http://suporteninja.com/mais-de-300gb-de-cursos-em-ti-para-download-no-mega/

( Na verdade tem mais de 600GB de conteúdo)

Projeto Valkyrie

Você pode usá-lo para automação residencial, bem como controlar dispositivos como braço robo, robôs etc. Valkyrie está ligado à IOT usando Wi-Fi, BLE, Bluetooth clássico, UHF RF Transceiver e XBee, usando o protocolo universal chamado V-API. Este é Valkyrie o caminho futuro do gesto e voz controle.

Características do projeto Valkyrie:

  • processamento de movimento em tempo real inovadora
  • serviço de controle de voz
  • detecção de controle por gestos inteligentes
  • aplicações para smartphones
  • funcionalidade de Bem-Estar
  • API aberta para desenvolvedores
  • Várias interfaces de comunicação

Luva: Projeto Valkyrie é destinado a completar o desafio “SpaceGlove”. Para os 2 dias que trabalharam nesse projeto nós fizemos uma luva de couro e material elástico que é confortável para o uso diário e trabalha cerca de 70 horas em modo de transmissão de energia integral.

Com essa luva, fizemos experiências para controlar muitos dos dispositivos domésticos padrão (lâmpadas, luzes, aquecedor de fã, tiras de luz LED, TV, caixa de configuração) com gestos baseados tais como slide, de cima para baixo, para baixo-up etc Depois que fizemos um serviço que está transmitindo dados a partir da luva a um iPhone, e nós temos modificado a base de dados gesto, e acrescentou gestos personalizados. Com precisão de 10% que têm distinguido com sucesso 16 gestos diferentes e adicionou suporte para mais de 60.

Centro de controle: . Para controlar muitas interfaces precisamos de um centro de controle que está repetindo sinais recebidos a partir de qualquer das interfaces de comunicação e enviá-lo para as outras interfaces
As seguintes interfaces são suportados:

  • Wi-fi
  • Bluetooth Low Energy
  • Classi Bluetooth
  • XBee (ZigBee)
  • 433 MHz transceptor de rádio, e
  • comunicação USB

 Nós integramos muitas bibliotecas e de comunicação único e universal e implementou-lo em um V-API (Valkyrie API). A ideia na V-API é que é pode ser usado com qualquer tipo de dispositivos e usando o protocolo universal você pode facilmente escrever os códigos para a comunicação. O V-API é explicado em detalhes no slide 17 da documentação de hardware e firmware incluídos nos recursos.

Luva das posições dos sensores e descrições:

AccGyro

force-sensor graphic

heart-rate-sensor

As aplicações móveis: Nós desenvolvemos 2 aplicações de interface com o centro de comando (e a luva) – uma para Android e um para iOS. O aplicativo Android usa apenas o serviço de detecção de voz usando o google agora pesquisar e se o comando é reconhecido que envia a solicitação HTTP POST para o nosso serviço on-line (imp elétrica). O serviço Android está trabalhando no telefone, bem como no relógio Android. O aplicativo iOS suporta serviço feito sob encomenda Reconhecimento de voz, controle de automação residencial usando a voz ou entrada directa na aplicação, e informações da estação meteorológica. O nosso serviço de bem-estar está verificando a sua frequência cardíaca automaticamente a cada 30 minutos ou continuamente enquanto você está treinando. Ele também pode contar seus passos e detectar sua qualidade de sono. O aplicativo também pode ser usado para upload de novo firmware para a luva e para criar mais gestos de ser reconhecidos pela luva e ligá-los para executar uma variedade de ações.

iPhoneScreens

No momento, temos uma luva totalmente funcional, a aplicação iOS com todas as propriedades que precisamos, controles remotos para computadores (luva agindo como dispositivo HID), controle de telefone embora o serviço HID BLE, controle de casa inteligente com os hábitos e gestos já implementadas, controle robo braço, controle de jogo de computador, controle rover / carro gesto, controle remoto da TV inteligente e muitos mais por causa do protocolo V-API universal que pode ser usado em muitos lugares.

Q & A:

  • Não há gravidade no espaço aberto – podemos usar um transmissor magnético para determinar o ponto “zero” no espaço e usá-lo para calibrar e sentir a gravidade pseudo e velocidade angular.

  • É difícil usar a maioria dos dispositivos de comunicação GHz no espaço – É por isso que nós temos transceptores de 433 MHz  no Centro de Controle. As bandas de VHF e UHF são capazes de penetrar na atmosfera terrestre e transmitir a comunicação de baixo ruído da terra para o espaço. Isto é usado pelos radioamadores para fazer QSOs utilizando as estações espaciais internacionais como repetidor.

  • velocidade de dados de baixo se o dispositivo controlado é muito longe da terra – não há muito que possamos fazer sobre isso, então decidimos fazer macros personalizadas (por exemplo, se você está controlando braço robótico), você faz o movimento uma vez com a mão então este é enviado para o braço robótico, que memoriza o movimento e fazê-lo pelo comando. Por exemplo no vídeo temos usado este sistema para agarrar a caixa e movê-lo algumas polegadas atrás.
  • Conexão cai enquanto controla algo – Se não há nenhuma conexão para 300 ms, a operação pára até que a ligação não for retomada.
  • Carregar – estamos considerando o carregamento sem fio, porque com as novas tecnologias no carregamento sem fio é possível cobrar 800 mAh por menos de 40 min.
  • Consumo de energia – é 13 – 15 mA no modo de transmissão.
  • você pode usar dispositivos externos (como celulares com Android, Bluetooth Joystic) para controlar dispositivos periféricos Control Center – Sim, pode-V API é um protocolo universal para comunicação, todos os relatórios recebidos são repetidos para as outras interfaces de comunicação.

Imagens da luva feita durante os 2 dias do desafio Apps Space: sistema de sensor de pressão real.

IMG_2025_photoshop

 

Desenvolvimento futuro

  • Para tornar totalmente funcional Aplicativo para Android
  • Para adicionar mais sensores para a estação de controle
  • Para melhorar e tornar as bibliotecas V-API claramente legíveis para C, C ++, C #, Java, Java Script, Objective C
  • A cooperar com muitas universidades e outras instituições de ciência em todo o worlд
  • Para tornar a placa de circuito impresso flexível para a luva
  • Para desenvolver personalizados Bluetooth Serviços de Energia baixa para ser fácil de usar por desenvolvedores Android / iOS
  • Para adicionar mais documentação e estabelecer centro de suporte para suportar os desenvolvedores usando o nosso V-API
  • Para fazer algumas variações a luva por exemplo, negócios, esporte, casual e fazer o hardware para ser fácil mutável
  • Testes oficiais
  • Lançamento do projeto (Se começarmos em 2015/06/01 até o final de setembro ’15 teremos um produto)

 

https://open.nasa.gov/innovation-space/valkyrie/

O ESP8266+Arduino Mega como WebServer

Depois de testar o modulo com vários comandos AT (vale a pena dar uma sapeada no arquivo anexo, bem legal!), parti para fazer o modulo funcionar como Web Server. Partido que tinha aprendido, principalmante com um tutorial do blog FILIPEFLOP:

http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

O Circuito:

 

Webservercircuit

 

O código:

/*************************************************************************

* Web Server with ESP8266

* Based on: FILIPEFLOP http://blog.filipeflop.com/wireless/esp8266-arduino-tutorial.html

* Adapted by Marcelo Jose Rovai

**************************************************************************/

#define esp8266 Serial2

#define CH_PD 4

#define speed8266 115200 // This is the speed that worked with my ESP8266

#define DEBUG true

void setup()

{

  esp8266.begin (speed8266);

  Serial.begin(9600);

  reset8266(); // Pin CH_PD needs a reset before start communication

  sendData(“AT+RST\r\n”, 2000, DEBUG); // reset

  sendData(“AT+CWJAP=\”ROVAI TIMECAP\”,\”mjr747@1\”\r\n”, 2000, DEBUG); //Connect network

  delay(3000);

  sendData(“AT+CWMODE=1\r\n”, 1000, DEBUG);

  sendData(“AT+CIFSR\r\n”, 1000, DEBUG); // Show IP Adress

  sendData(“AT+CIPMUX=1\r\n”, 1000, DEBUG); // Multiple conexions

  sendData(“AT+CIPSERVER=1,80\r\n”, 1000, DEBUG); // start comm port 80

}

void loop()

{

  if (esp8266.available()) // check if 8266 is sending data

  {

    if (esp8266.find(“+IPD,”))

    {

      delay(300);

      int connectionId = esp8266.read() – 48;

      String webpage = “<head><meta http-equiv=””refresh”” content=””3″”>”;

      webpage += “</head><h1><u>MJRoBot ==> WebServer (ESP8266) </u></h1><h2>Arduino Pin: “;

      webpage += “D8 status ==> “;

      int a = digitalRead(8);

      webpage += a;

      webpage += “<h2>Arduino Pin: D9 status ==> “;

      int b = digitalRead(9);

      webpage += b;

      webpage += “<h2>Arduino Pin: A0 data ===> “;

      int c = analogRead(0);

      webpage += c;

      webpage += “</h2>”;

      String cipSend = “AT+CIPSEND=”;

      cipSend += connectionId;

      cipSend += “,”;

      cipSend += webpage.length();

      cipSend += “\r\n”;

      sendData(cipSend, 1000, DEBUG);

      sendData(webpage, 1000, DEBUG);

      String closeCommand = “AT+CIPCLOSE=”;

      closeCommand += connectionId; // append connection id

      closeCommand += “\r\n”;

      sendData(closeCommand, 3000, DEBUG);

    }

  }

}

/*************************************************/

 // Send AT commands to module

String sendData(String command, const int timeout, boolean debug)

{

  String response = “”;

  esp8266.print(command);

  long int time = millis();

  while ( (time + timeout) > millis())

  {

    while (esp8266.available())

    {

      // The esp has data so display its output to the serial window

      char c = esp8266.read(); // read the next character.

      response += c;

    }

  }

  if (debug)

  {

    Serial.print(response);

  }

  return response;

}

/*************************************************/

// Reset funtion to accept communication

void reset8266 ()

{

  pinMode(CH_PD, OUTPUT);

  digitalWrite(CH_PD, LOW);

  delay(300);

  digitalWrite(CH_PD, HIGH);

}

A web Page:

Note que o endereço da pagina é o segundo IP que aparece no Serial monitor com o comando AT+CIFSR na fase de Set-up (veja a copia do Serial monitor abaixo): 

+CIFSR:STAIP,”10.0.1.2″

Webserverpage

A saída no Serial Monitor:

1. A conexão com o modulo esp8266

 

SerialConxion

2. A comunicação:

SerialOngoingcomm

Eu fiz um pequeno vídeo para dar uma visão do WebServer funcionando:

ESP8266 como webserver

Documento legal com dicas de comandos AT para configurar o esp8266:

ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Fonte:  http://labdegaragem.com/profiles/blogs/o-esp8266-como-webserver-usando-o-mega?xg_source=msg_mes_network

Arduino e comunicação sem fio: módulo NRF24L01+

Como configurar e programar a conexão sem fio direta entre Arduinos usando o módulo NRF24L01+ para transmitir comandos e receber respostas.

O módulo NRF24L01+ é bastante popular e bem documentado, e algumas das bibliotecas que o suportam vem acompanhadas de bons programas de exemplo.


nfr001

Neste artigo, veremos os elementos básicos de uma aplicação prática: um programa que pode ser instalado tanto no Arduino que estiver atuando como mestre (que comanda as transmissões e recebe os dados), quanto no que estiver configurado como subalterno (que aguarda os comandos e transmite os dados).

Ambos transmitirão e receberão dados: o mestre envia comandos e recebe as respostas do subalterno, e o subalterno aguarda a recepção dos comandos e envia a resposta de acordo com cada comando recebido.

CONHECENDO O NRF24L01+

O chip nRF24L01+, da Nordic, é uma dessas maravilhas da tecnologia moderna: reúne transmissão e recepção em um mesmo componente, consome pouca energia (pode funcionar meses ou até anos com uma pilha AA), transmite/recebe a até 2Mbps e encapsula boa parte da complexidade da comunicação digital via rádio, deixando os microcontroladores livres para se preocupar com as demandas da aplicação.

Ele é usado em periféricos sem fio para computadores, em acessórios esportivos e de jogos eletrônicos, em brinquedos, controles remotos avançados, headsets, joysticks, e em eletrônicos de consumo em geral.

A comunicação do NRF24L01+ é direta, sem roteadores ou outra infra-estrutura. – não é um chip WiFi.

A comunicação usando esse tipo de chip é diretamente entre dispositivos, sem intermediação por roteadores ou similares – não é um adaptador WiFi, nem usa protocolos da Internet, como o TCP e o IP. Normalmente eles atuam em pares (como em um teclado sem fio conectado a um adaptador USB), ou um mestre controla vários subalternos (como em uma rede de sensoreamento na qual um Arduino com esse chip obtém dados de vários outros Arduinos com esse chip, e os registra ou envia para um PC via serial). Outras topologias também são possíveis, inclusive redes estrela com até 6 nós.

nrf002

No mundo Arduino, é frequente ele ser visto na forma de um módulo que inclui não apenas o chip, mas também todos os (poucos) elementos adicionais necessários ao seu funcionamento: um cristal para sincronização precisa, os capacitores e resistores associados a este cristal, e uma antena, frequentemente impressa na própria placa.

Esses módulos são fáceis de encontrar em lojas de eletrônica nacionais, e saem bastante baratos para comprar em quantidade nos grandes sites de comércio eletrônico chineses.

Este artigo foi escrito com um par de módulos iguais a este. Ao escolher um modelo para prototipação, sugiro optar por um que já tenha pinos DIP soldados ou com espaço disponível para soldá-los. Fora isso, vale a pena verificar itens como a antena (ou mesmo a presença de um conector para antena externa), que podem influenciar bastante no alcance.

De modo geral, os demais parâmetros de operação variam pouco entre os modelos, pois dependem basicamente do chip. Os principais são:

  • Opera nas frequências da faixa de 2,4GHz (que é livre para uso sem necessidade de registro na Anatel ou similares)
  • 125 canais
  • Baixíssimo consumo de energia
  • Velocidades selecionáveis entre 250Kbps e 2Mbps
  • Modulação FSK/GSK
  • Suporte a comunicação multipontos
  • Capacidade de evitar interferência e de saltar entre frequências

A comunicação entre o módulo nRF24L01+ e o Arduino ocorre usando o protocolo SPI e, embora o módulo opere a 3,3V (e assim precise ser alimentado por meio do pino 3V3 do Arduino), ele aceita e envia sinais compatíveis com o nível lógico de 5V do Arduino Uno e seus similares, sem precisar de conversão.

ARDUINO E NRF24L01+: COMO CONECTAR

A pinagem dos meus módulos nRF24L01+ é de 8 pinos, e foi conectada ao Arduino Uno como segue:

Os números de pinos do Arduino mencionados acima referem-se ao uso da popular bibliotecaRF24 em um Arduino Uno, na forma como configurei para este artigo – outras configurações podem assumir outros valores.

Os pinos CE e CSN podem ser conectados a outros pinos do Arduino que não o 9 e o 10, se necessário – mas isso exigirá alteração no nosso programa de exemplo, no trecho em que faz referência a esses pinos.

Ainda, existem módulos com pinagens diferentes da exibida: verifique a documentação do seu, e adeque. E se o seu Arduino tiver os pinos da comunicação SPI em outras posições (como ocorre com o Leonardo e o Mega), adeque também.

Não plugue os pinos diretamente a uma breadboard: cada par ficará em curto entre si. Uma alternativa simples é usar jumpers macho-fêmea para ligar.

ARDUINO E NRF24L01+: COMO PROGRAMAR

O exemplo a seguir considera 2 Arduinos Uno, cada um conectado a um módulo NRF24L01+, e ambos próximos entre si1. Lembre-se de instalar previamente a biblioteca RF24.

Nosso programa implementa os 2 modos de operação: mestre e subalterno. A instalação é a mesma em ambos os Arduinos.

O mesmo código deve ser instalado em ambos os Arduinos, sem alteração. Durante a execução, um deles será o mestre, e o outro será o subalterno. Para configurar um deles como o mestre, passe um resistor entre seu pino 2 e o pino GND – o programa irá procurar por essa conexão para saber qual papel deve assumir. Não há problema em trocar, durante a execução, qual deles será o mestre – mas se/enquanto ambos estiverem simultaneamente como mestre ou como subalterno, a comunicação não será bem-sucedida.

O programa a seguir se baseia na transmissão de pacotes de dados, com tamanho fixo (sempre uma matriz de 0 a 5 inteiros), entre os Arduinos. O primeiro inteiro da matriz será sempre o identificador do tipo de pacote (um questionamento, uma resposta, etc.), e nos demais o programa pode colocar livremente os dados que deseja comunicar: o estado de uma porta, um sensor, o tempo decorrido desde algum evento, etc.

O quadro a seguir indica uma saída possível do programa rodando no mestre:

Enviei comando 11
Recebi resposta de interrogacao: 8325
 
Enviei comando 21
Recebi resposta de um ping enviado ha 985ms.

Enviei comando 11
Não houve resposta
 
Enviei comando 11
Recebi resposta de interrogacao: 8436

O programa define 2 tipos de questionamento e suas respectivas respostas, e controla o envio e recebimento de todos eles:

#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>

RF24 radio(9,10);

const uint64_t PIPE_COMANDO = 0xE8E8F0F0E1LL;
const uint64_t PIPE_RESPOSTA = 0xE8E8F0F0E2LL;


const int CMD_INTERROGA=11;
const int CMD_RESPONDEINTERROG=12;
const int CMD_PING=21;
const int CMD_RESPONDEPING=22;

int msg[5];

const byte pinoChave=2;
boolean temMensagem;

void setup() {
  Serial.begin(9600);
  pinMode(pinoChave,INPUT_PULLUP);
  radio.begin();
  radio.openWritingPipe(PIPE_COMANDO);
  radio.openReadingPipe(1,PIPE_RESPOSTA);
  radio.startListening();
}

void enviaMsg() {
  radio.stopListening();
  radio.write(msg, sizeof(msg));
  radio.startListening();
}
 
void interroga(int comando) {
  msg[0]=comando; 
  msg[1]=millis() % 32768;
  enviaMsg();
  Serial.print("Enviei comando ");
  Serial.println(msg[0]);
  for (int i=0; i<500; i++) {
    temMensagem=radio.available();
    if (temMensagem) {
      break;
    }  
    delay(4);
  }  
  if (temMensagem) {
    boolean concluido=false;
    while (!concluido) {
      concluido=radio.read(msg, sizeof(msg));
    }  
    switch (msg[0]) {
      case CMD_RESPONDEINTERROG:
        Serial.print("Recebi resposta de interrogacao: ");
        Serial.println(msg[1]);
        break;
      case CMD_RESPONDEPING:
        Serial.print("Recebi resposta de um ping enviado ha ");
        Serial.print((millis() % 32768)-msg[1]);
        Serial.println("ms.");
        break;
      default:
        Serial.print("Recebi resposta desconhecida ou impropria:");
        Serial.print(msg[0]);
        Serial.print(" ");
        Serial.println(msg[1]);
    }  
  } else {
    Serial.println("Nao houve resposta");
  }    
  Serial.println(" ");
} 

void responde() {
  int resposta=0;
  if (radio.available()) {
    boolean concluido=false;
    while (!concluido) {
      concluido=radio.read(msg, sizeof(msg));
    }  
    switch (msg[0]) {
      case CMD_INTERROGA:
          resposta=random(8000,9000);
          Serial.print("Recebi comando de interrogacao e vou responder: ");
          Serial.println(resposta);
          msg[0]=CMD_RESPONDEINTERROG;
          msg[1]=resposta;
          enviaMsg();
          break;
      case CMD_PING:
          msg[0]=CMD_RESPONDEPING;
          enviaMsg();
          Serial.print("Recebi comando ping e ja respondi: ");
          Serial.println(msg[1]);
          break;
        default:
          Serial.print("Recebi comando desconhecido ou improprio:");
          Serial.println(msg[0]);
      }  
  } else {
    Serial.println("Nao ha mensagens disponiveis");
  }  
} 
 
 
void loop() {
  if (digitalRead(pinoChave)==LOW) {
    if (random(0,5)==3) interroga(CMD_PING);
    else interroga(CMD_INTERROGA);
  } else {
    responde();
  }  
  delay(1000);
}

As linhas iniciais, em vermelho, executam uma sequência já bem conhecida de referenciar bibliotecas e instanciar um objeto para acesso aos métodos dela.

As 2 últimas linhas do bloco em vermelho oferecem algo diferente, entretanto: são elas quedefinem as pipes (“dutos”) por onde serão transmitidos os dados nas duas direções: o envio de comandos e a recepção de respostas2

A seguir, em laranja, temos definições essenciais para o funcionamento do programa: os tipos de mensagens que serão enviadas e/ou recebidas. Veremos mais detalhes a seguir, mas note que são 2 pares de constantes: CMD_INTERROGA com CMD_RESPONDEINTERROG e CMD_PING com CMD_RESPONDEPING. Também em laranja temos a definição da matrizmsg, composta de 6 (0 a 5) números inteiros. Essa mesma matriz será usada para enviar e receber as mensagens.

A inicialização do programa está em verde, e começa ativando a Serial e definindo o modo dopino 2 (definido em pinoChave), que será usado mais adiante para verificar se um Arduino deve agir como mestre (se houver um resistor entre o pino 2 e o GND) ou como subalterno (se não houver).

A seguir, ainda em verde, vem a inicialização e configuração inicial do rádio. Note que definimos as 2 pipes (radio.openWritingPipe e radio.openReadingPipe) e colocamos o rádio em modo de recepção de pacotes (radio.startListening), que será nosso modo básico de operação (exceto quando for a hora de transmitir algo, como veremos a seguir).

Assim na vida como no NRF24L01: para falar bem, acaba sendo necessário parar de ouvir, nem que seja por um instante.

Em cor salmão temos a enviaMsg(), uma rotina de uso geral usada pelas funções que vêm a seguir. O que ela faz é muito simples: desativa o modo de recepção de pacotes (radio.stopListening), aí transmite o conteúdo que estiver armazenado na matriz msg, e volta a ativar o modo de recepção de pacotes.

Agora, antes de ver as linhas imediatamente a seguir, vamos dar um grande salto, diretamente para o final do programa, no trecho marcado em marrom. É o loop, a função que o Arduino executa continuamente. Veja como ele é simples – a cada execução:

  1. Se o estado do pino 2 for LOW (ou seja, se ele estiver conectado ao Terra, indicando que este Arduino deve agir como o mestre):
    • Se um número sorteado entre 0 e 4 for 3, chama a função interroga() passando como parâmetro CMD_PING – e, nos demais casos do sorteio, chama a função interroga passando como parâmetro CMD_INTERROGA.
  2. Se o estado do pino 2 não for LOW, conclui-se que este Arduino é o subordinado, e assim é chamada a função responde().

Note que a complexidade do programa foi toda removida do loop e transportada para as 2 funções mencionadas: interroga() e responde(). O loop se limita a chamá-las, dependendo de se identificar como mestre ou subalterno. No caso do mestre, o loop ainda escolhe entre interrogar passando como parâmetro o comando PING ou o comando INTERROGA.

A função interroga() só é executada no mestre, e se encarrega de enviar um comando, aguardar a resposta do subordinado e processá-la.

Retorne agora para o trecho em roxo, que é o início da função interroga(), executada apenas no Arduino que estiver como mestre. Note que a sua primeira linha move para o primeiro elemento da matriz cmd o valor recebido como parâmetro pela função, que – já sabemos – será CMD_PING ou CMD_INTERROGA.

A segunda linha move para o segundo elemento da matriz os 2 últimos bytes da funçãomillis(), que conta o número de milissegundos desde a inicialização. Isso é relevante apenas para o comando CMD_PING, e veremos a razão a seguir. A seguir a nossa já conhecida função enviaMsg() é chamada, e uma descrição do que acaba de acontecer é enviada para o monitor serial.

Neste momento a transmissão já está completa, mas nós queremos receber uma resposta do Arduino subordinado – e aguardar por essa resposta é o que fazem os 2 trechos em cor dourada da mesma função interroga(). Note que é um loop simples, que repetirá 500 vezes o delay de 4 milissegundos (o tempo total será algo pouco acima de 2 segundos), a não ser que a funçãoradio.available() (que informa que um pacote foi recebido pelo rádio) retorne um valor positivo antes disso. Se tiver mensagem, o trecho em cinza será executado, senão a mensagem em dourado no final da função, informando que não foi recebida nenhuma resposta, será exibida.

O trecho em cinza na função interroga() só tem um aspecto realmente diferente: ele usaradio.read para mover para a matriz msg o conteúdo do pacote recebido do rádio (se vários tiverem sido recebidos, ele continua lendo até chegar ao último). A seguir, dependendo do que estiver no primeiro elemento da matriz (CMD_RESPONDEINTERROG ou CMD_RESPONDEPING), ele exibe a resposta da interrogação, ou calcula quanto tempo faz desde que o ping foi enviado (lembra que havíamos colocado o valor de millis() no pacote antes de enviá-lo? Ele terá sido transmitido de volta para nós, como veremos a seguir) e exibe o resultado.

A função responde() só é executada no subalterno, e aguarda por comandos, respondendo-os conforme chegam.

Finalizando, em cor fúcsia, temos a função responde() que, como sabemos, só executada no Arduino que não estiver como mestre. Note que ela inicia com um loop similar ao do trecho em cinza da função anterior, para receber na matriz msg o pacote que tiver sido recebido do rádio – mas, ao contrário da função anterior, ela não tem limite de tempo de espera para isso, porque o subalterno não terá nada para fazer enquanto o mestre não lhe enviar um comando. Após receber um pacote, ele seleciona (via switch) o que fazer, dependendo do comando que tiver sido expresso no primeiro elemento da matriz cmd:

  • se tiver sido um CMD_INTERROGA, envia um CMD_RESPONDEINTERROG, colocando no segundo elemento da matriz um número aleatório entre 8000 e 9000 (aqui você colocaria o valor de um sensor, ou o que estivesse monitorando, em uma aplicação prática).
  • se tiver sido um CMD_PING, envia um CMD_RESPONDEPING, sem alterar o conteúdo do segundo elemento da matriz recebida, que conterá o valor de millis() que foi enviado pelo mestre.

Agora releia o programa para observar que em nenhum momento fizemos referência à seleção de canal, velocidade de transmissão, número e intervalo de tentativas de retransmissão, e outros elementos que o NRF24L01+ oferece. A configuração default é adequada para boa parte dos usos mas, quando você precisar modificar, os métodos da biblioteca RF24 estarão à sua disposição

Note ainda que as funções essenciais de tratamento de erro na camada de aplicação – comando impróprio, resposta imprópria, resposta não recebida a tempo – estão presentes e, como o restante do código, podem ser adaptados à sua aplicação e topologia. Boas transmissões!

  1.  A distância, a presença de ruído eletromagnético (seu telefone sem fio, o roteador, o forno de microondas e vários aparelhos com controle remoto podem interferir) e outros elementos do ambiente podem interferir no resultado.
  2.  Os identificadores de pipes constam no programa como números de 5 bytes expressos em hexadecimal e com o identificador LL (que indica o tipo “long long“) ao final. Eles podem ser escolhidos arbitrariamente mas, caso seu programa vá ter mais de um canal de recepção simultâneos, os 4 primeiros bytes deles devem ser idênticos entre si.

 

Este artigo foi publicado em 10/06/2015 por Augusto Campos em: http://br-arduino.org/2015/06/arduino-sem-fio-nrf24l01.html