Calculadoras de valor do transformador de corrente (CT) OpenEnergyMonitor

Essas calculadoras são projetadas para ajudá-lo a determinar os valores dos componentes necessários para o (s) transformador (es) de corrente usado (s) no projeto Open Energy Monitor . Vá dar uma olhada!

Por favor, note que estas calculadoras não levam em consideração a permeabilidade do núcleo e o valor do core AL. Use por sua conta e risco.

Atualização de novembro de 2017: Fórmulas fixas exibidas abaixo de cada calculadora para reduzir pela metade a voltagem do sistema como foi originalmente planejado.


Tensão do sistema: Volts
Para monitores de energia baseados em arduinos de 5V (principalmente os mais antigos), digite 5 acima


Resistor de carga

Calcula o valor do resistor de sobrecarga a ser usado em uma corrente Max RMS do transformador de 
corrente:Amps
Relação atual da volta do sensor:: 1
valor do resistor calculado:Ohms
Fórmula:
burden_resistor = (system_voltage / 2.0) / ((I_RMS * 1.414) / ct_turns)


Corrente máxima

Calcula a corrente máxima que você pode razoavelmente esperar medir usando um transformador de corrente 
Valor do resistor de carga:Ohms
Relação atual da volta do sensor:: 1
corrente máxima calculada de RMS:Amps
Fórmula:
I_RMS = (((system_voltage / 2.0) / burden_resistor) * Turns) * 0.707


O sensor atual gira

Calcula uma estimativa do número de voltas que um transformador de corrente precisaria. 
Valor do resistor de carga:Ohms
Max RMS atual:Amps
O sensor atual gira:
Fórmula:
turns = (I_RMS * 1.414) / ((system_voltage / 2.0) / burden_resistor)

Cálculo Online de Cores de Resistores

Calculadora de código Da Cor Do Resistor

Entre com as cores das faixas do resistor e obtenha seu valor em Ohm�s ( Ω )

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco

Preto
Marron
Vermelho
Laranja
Amarelo
Verde
Azul
Violeta
Cinza
Branco
Dourado
Prateado

Dourado
Prateado
Nenhum


Valor Da Resist�ncia:

 

Valores padrão de resistores (comercial):

Tabela de resistores comerciais usado na eletrônica:

1 marrom preto dourado
1,2 marrom vermelho dourado
1,5 marrom verde dourado
1,8 marrom cinza dourado
2,2 vermelho vermelho Dourado
2,7 Vermelho Violeta dourado
3,3 laranja laranja dourado
3,9 laranja branco dourado
4,7 amarelo violeta dourado
5,6 verde azul dourado
6,8 azul cinza dourado
8,2 cinza vermelho dourado
9,1 branco marrom dourado
10 marrom preto preto
12 marrom vermelho preto
15 marrom verde preto
18 marrom cinza preto
22 vermelho vermelho preto
27 vermelho violeta preto
33 laranja laranja preto
39 laranja branco preto
47 amarelo violeta preto
56 verde azul preto
68 azul cinza preto
82 cinza vermelho preto
91 branco marrom preto
100 marrom preto marrom
120 Marrom Vermelho Marrom
150 Marrom Verde Marrom
180 Marrom Cinza Marrom
220 Vermelho Vermelho Marrom
270 Vermelho Violeta Marrom
330 Laranja Laranja Marrom
390 Laranja Branco marrom
470 Amarelo Violeta Marrom
560 Verde Azul Marrom
680 Azul Cinza Marrom
820 Cinza Vermelho Marrom
910 Branco Marrom Marrom
1000 ou 1K Marrom Preto Vermelho
1200 ou 1K2 Marrom Vermelho Vermelho
1500 ou 1K5 Marrom Verde Vermelho
1800 ou 1K8 Marrom Cinza Vermelho
2200 ou 2K2 Vermelho Vermelho Vermelho
2700 ou 2K7 Vermelho Violeta Vermelho
3300 ou 3K3 Laranja Laranja Vermelho
3900 ou 3K9 Laranja Branco Vermelho
4700 ou 4K7 Amarelo Violeta Vermelho
5600 ou 5K6 Verde Azul Vermelho
6800 ou 6K8 Azul Cinza Vermelho
8200 ou 8K2 Cinza Vermelho Vermelho
9100 ou 9K1 Branco Marrom Vermelho
10000 ou 10K Marrom Preto laranja
12000 ou 12K Marrom Vermelho Laranja
15000 ou 15K Marrom Verde Laranja
18000 ou 18K Marrom Cinza Laranja
22000 ou 22K Vermelho Vermelho Laranja
27000 ou 27K Vermelho Violeta Laranja
33000 ou 33K Laranja Laranja Laranja
39000 ou 39K Laranja branco Laranja
47000 ou 47K Amarelo Violeta Laranja
56000 ou 56K Verde Azul Laranja
68000 ou 68K Azul Cinza Laranja
82000 ou 82K Cinza Vermelho Laranja
91000 ou 91K Branco Marrom Laranja
100000 ou 100K Marrom Preto Amarelo
120000 ou 120K Marrom Vermelho Amarelo
150000 ou 150K Marrom Verde Amarelo
180000 ou 180K Marrom Cinza Amarelo
220000 ou 220K Vermelho Vermelho Amarelo
270000 ou 270K Vermelho Violeta Amarelo
330000 ou 330K Laranja Laranja Amarelo
390000 ou 390K Laranja Branco Amarelo
470000 ou 470K Amarelo Violeta Amarelo
560000 ou 560K Verde Azul Amarelo
680000 ou 680k Azul Cinza Amarelo
820000 ou 820K Cinza Vermelho Amarelo
910000 ou 910K Branco Marrom Amarelo
1000000 ou 1M Marrom Preto Verde
1200000 ou 1M2 Marrom Vermelho Verde
1500000 ou 1M5 Marrom Verde Verde
1800000 ou 1M8 Marrom Cinza Verde
2200000 ou 2M2 Vermelho Vermelho Verde
2700000 ou 2M7 Vermelho Violeta Verde
3300000 ou 3M3 Laranja Laranja Verde
3900000 ou 3M9 Laranja Branco Verde
4700000 ou 4M7 Amarelo Violeta Verde
5600000 ou 5M6 Verde Azul Verde
6800000 ou 6M8 Azul Cinza Verde
8200000 ou 8M2 Cinza Vermelho Verde
9100000 ou 9M1 Branco Marrom Verde
10000000 ou 10M Marrom Preto Azul
12000000 ou 12M Marrom Vermelho Azul
15000000 ou 15M Marrom Verde Azul
18000000 ou 18M Marrom Cinza Azul
22000000 ou 22M Vermelho Vermelho Azul
Calculadora online de c�digo de Cores de Resistor

Resistores em série


Um circuito de associação em série de resistores, é um circuito em que os resistores (resistências) estão dispostos em uma cadeia, de modo que a corrente tem apenas um caminho a seguir. A corrente é a mesma através de cada resistência. A resistência total do circuito é encontrado simplesmente somando os valores de resistência dos resistores:
Resistores em série: R = R 1 + R 2 + R 3 + …
Resistores em s�rie

Um circuito em s�rie � mostrado acima. A corrente passa atrav�s de cada resistor, por sua vez. Se os valores das tr�s resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte:
I = V / I = 10/20 = 0,5 A. A corrente atrav�s de cada resist�ncia seria 0,5 A.

 

Resistores em paralelo

 

Em uma associa��o em paralelo de resistores � um circuito em que as resistências s�o dispostos lado a lado. Nesse caso a tens�o em todos os resistores � igual, mas a soma das correntes que atravessam os resistores � igual � resist�ncia do resistor. Ent�o a resistência equivalente de uma associação em paralelo � sempre menor que o resistor de menor resistência da associa��o.

A resistência total de um conjunto de resistores em paralelo � encontrado somando-se os rec�procos dos valores das resistências e, em seguida, tomar o recíproco do total:

resistência equivalente de resistores em paralelo: 1 / R = 1 / R 1 + 1 / R 2 + 1 / R 3 + …

Resistores em paralelo
Um circuito paralelo � mostrado acima. Neste caso, a corrente fornecida pela bateria divide-se, e a quantidade que passa por cada resistor depende da resist�ncia. Se os valores das três resistências s�o os seguintes:
Com uma bateria de 10 V, por V = IR a corrente total no circuito � a seguinte: I = V / I = 10/2 = 5 A.

As correntes individuais tamb�m pode ser encontrado usando I = V / R. A tens�o em cada resist�ncia � de 10 V, de modo que:
I 1 = 10/8 = 1,25 A
I 2 = 10/8 = 1,25 A
I 3 = 10/4 = 2,5 A

API de sensor genérico – W3C

Cada vez mais, os dados dos sensores são usados ​​no desenvolvimento de aplicativos para permitir novos casos de uso, como geolocalização, contagem de etapas ou rastreamento de cabeças. Isso é especialmente verdadeiro em dispositivos móveis nos quais novos sensores são adicionados regularmente.

A exposição de dados de sensores à Web até agora tem sido lenta e ad-hoc. Poucos sensores já estão expostos à web. Quando eles são, muitas vezes é de maneiras que limitam seus possíveis casos de uso (por exemplo, expondo abstrações que são muito alto nível e que não funcionam bem o suficiente). As APIs também variam muito de um sensor para o outro, o que aumenta a carga cognitiva dos desenvolvedores de aplicativos da Web e diminui o desenvolvimento.

O objetivo da Generic Sensor API é promover consistência entre APIs de sensores, habilitar casos de uso avançados graças a APIs de baixo nível e aumentar o ritmo no qual novos sensores podem ser expostos à Web, simplificando a especificação e os processos de implementação.

Uma lista abrangente de sensores sólidos que são baseados na API do Sensor genérico, casos de uso aplicáveis ​​e exemplos de código pode ser encontrada nos documentos do [GENERIC-SENSOR-USECASES] e [MOTION-SENSORS] .

https://w3c.github.io/sensors/#high-level

SENSOR ULTRASÔNICO JSN-SR04T

O JSN-SR04T é um sensor de distância ultra-sônico à prova d’água, fácil de usar, com uma faixa de 25 a 450 cm. Se você está planejando construir um sistema de medição do nível de água ou se você precisa fazer outras medições de distância fora, então este é o sensor que você precisa!

Eu incluí um diagrama de fiação e códigos de exemplo para que você possa começar a experimentar seu sensor.

 

O que este artigo cobre

Informações sobre o sensor

O sensor vem com um cabo de 2,5 m de comprimento que se conecta a uma placa de fuga que controla o sensor e faz todo o processamento do sinal. Note que apenas o sensor e o cabo em si são à prova d’água, se você colocar água na placa de fuga, coisas ruins acontecerão.

Um sensor de distância ultra-sônico funciona enviando ondas de ultra-som. Essas ondas de ultra-som são refletidas de volta por um objeto e o sensor ultrassônico as detecta. Ao cronometrar quanto tempo passou entre enviar e receber as ondas sonoras, você pode calcular a distância entre o sensor e um objeto.

Distância (cm) = Velocidade do som (cm / µs) × Tempo (µs) / 2

Onde Tempo  é o tempo entre enviar e receber as ondas sonoras em microssegundos.

Então, quais são as diferenças entre este sensor e o HC-SR04? A principal diferença, além de ser à prova d’água, é que este sensor usa apenas um transdutor ultrassônico. Este transdutor serve tanto como transmissor quanto receptor das ondas de ultra-som.

Para mais informações sobre como os sensores ultrassônicos funcionam, você pode conferir o artigo no HC-SR04 abaixo. Neste artigo, o princípio de funcionamento é explicado com muito mais detalhes.

JSN-SR04T Especificações

Tensão operacional 5V
Corrente de operação 30mA
Corrente quiescente 5mA
Freqüência 40 kHz
Faixa de medição 25 a 450 cm
Resolução 2 mm
Ângulo de medição 45 a 75 graus
Dimensões do sensor Cabo de 23,5 x 20 mm, 2,5 m de comprimento
Dimensões do PCB 41 x 28,5 mm
Orifício de montagem 18 mm

Para mais informações, você pode conferir a folha de dados aqui.

Componentes

* Nota: os links acima são afiliados, o que significa – sem nenhum custo adicional para você – se você comprar algo usando eles, você está ajudando a apoiar o meu trabalho neste site. Meus humildes agradecimentos (eu realmente agradeço)! 

Ao comprar o sensor, você pode encontrar a versão atualizada,  JSN-SR04T-2.0 . Essa versão mais recente funciona exatamente da mesma forma, mas alguns usuários encontraram problemas ao usar os sensores em uma voltagem mais baixa. Esta versão mais recente está classificada para 3 a 5 V.

Usar um pulso de gatilho mais longo de pelo menos 20 µs em vez de 10 µs parece ajudar se você estiver tendo leituras defeituosas.

Fiação – Conectando o JSN-SR04T ao Arduino UNO

O diagrama de fiação / esquema abaixo mostra como conectar o sensor JSN-SR04T ao Arduino. A placa de desagregação da JSN-SR04T possui a mesma pinagem que a HC-SR04, portanto, pode ser usada como substituta imediata. O cabo do sensor em si pode ser conectado ao conector na parte de trás da placa de fuga.

JSN-SR04T com diagrama de fiação do Arduino

Os exemplos de código abaixo usam os pinos digitais 2 e 3 para o gatilho e o pino de eco, mas é claro que você pode mudar isso para qualquer pino digital desejado.

Conexões JSN-SR04T

JSN-SR04T Arduino
5V 5V
Trig Pino 2
Eco Pino 3
GND GND

Exemplo de código para o JSN-SR04T com Arduino

Agora que você conectou o sensor, é hora de conectar o Arduino ao computador e fazer o upload de algum código. O sensor pode ser usado sem uma biblioteca do Arduino. Mais tarde, mostrarei um exemplo com a biblioteca NewPing, que torna o código muito mais curto.

Você pode fazer o upload do seguinte código de exemplo para o seu Arduino usando o  Arduino IDE . Em seguida, vou explicar como o código funciona. (Este código também funciona para o JSN-SR04T-2.0).

/* JSN-SR04T Ultrasonic Distance Sensor with Arduino Example Code. More info: https://www.makerguides.com */

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 3

//Define variables
long duration;
int distance;

void setup()
{
//Define inputs and outputs
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);

//Begin Serial communication
Serial.begin(9600); // Starts the serial communication at a baudrate of 9600
}

void loop()
{
//Clear the trigPin by setting it LOW
digitalWrite(trigPin, LOW);
delayMicroseconds(5);

//Trigger the sensor by setting the trigPin high for 10 microseconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

//Read the echoPin. pulseIn() returns the duration (length of the pulse) in microseconds.
duration = pulseIn(echoPin, HIGH);
// Calculate the distance
distance= duration*0.034/2;

//Print the distance on the Serial Monitor (Ctrl+Shift+M)
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");
delay(100);
}

Se houver a necessidade de leitura de mais sensores, isso pode ser feito facilmente com a biblioteca NewPing. Basta criar duas ou mais instâncias da classe NewPing e adicionar um gatilho e um eco adicionais:

#define trigPin 2 
#define echoPin 3 
#define trigPin2 4 
#define echoPin2 5

Sonar NewPing (trigPin, echoPin, MAX_DISTANCE); 
Sonar 2 de NewPing (trigPin2, echoPin2, MAX_DISTANCE);

Agora, se você quiser ler o primeiro sensor, você pode usar o sonar.ping_cm () e o segundo sensor sonar2.ping_cm ().

 

DOWNLOAD DA BIBLIOTECA NEW PING

 

FONTE: https://www.makerguides.com/jsn-sr04t-arduino-tutorial/

 

Sensor Transdutor de Pressão

TESTADO EM ARDUINO UNO R3

//Eu sou capaz de obter leituras precisas (+- 1-2 PSI) deste sensor com o seguinte código Arduino.

//Placa: Arduino UNO R3  IDE: Arduino IDE Version 1.8.5 ;  S O: Windows 10

//Conectando o sensor PSI no Arduino: Vermelho: +5V  Preto: GND (Ground)  Amarelo: Conecta-se ao pino analogico 0 (A0)

void setup()

{

 Serial.begin(9600);

}

void loop()

{

float sensorVoltage = analogRead(0);

//Lê os dados que chegam do sensor PSI em

//Arduino pin# A0.

int psi = ((sensorVoltage – 102 ) * 175 / ( 921 – 102 ));

//Matematica para converter dados analogicos em PSI.

Serial.print(“PSI “); //Imprime “PSI” no monitor serial.

Serial.println(psi); //Imprime “PSI” no monitor serial.

the serial monitor. delay (5000);//Pausas de 5 segundos entre as leituras.

}

 

Fonte: https://www.ebay.com/itm/G1-4-inch-5V-0-1-2-MPa-Pressure-Transducer-Sensor-Oil-Fuel-Diesel-Gas-Water-GL/112592366514?epid=16008939195&hash=item1a37072bb2:g:9vUAAOSwe2FZ2FZI&shqty=1&isGTR=1#shId

Gort – Interface de linha de comando para RobotOps

Gort ( http://gort.io ) é um kit de ferramentas de linha de comando para RobotOps. O Gort fornece ferramentas para procurar dispositivos conectados, carregar firmware e muito mais.

Gort é escrito na linguagem de programação Go ( http://golang.org ) para máxima velocidade e portabilidade.

Quer usar o Golang para programar seus robôs? Confira nossa estrutura de robótica de código aberto Gobot ( http://gobot.io ).

Quer usar JavaScript em robôs? Confira Cylon.js ( http://cylonjs.com )

Quer usar o Ruby em robôs? Confira Artoo ( http://artoo.io )

 

https://github.com/hybridgroup/gort

wiringpi.com

Sobre

WiringPi é uma biblioteca de acesso GPIO baseada em PIN escrita em C para os dispositivos SoC BCM2835, BCM2836 e BCM2837 usados ​​em todos os Raspberry Pi. versões. É lançado sob alicença LGPLv3 da  GNU e é utilizável em C, C ++ e RTB (BASIC), assim como em muitos outros idiomas com invólucros adequados (Veja abaixo). Ele foi projetado para ser familiar a pessoas que usaram osistema de “ fiação ” Arduino 1 e é destinado ao uso por programadores C / C ++ experientes. Não é uma ferramenta de aprendizado de novatos.

O WiringPi é desenvolvido diretamente em um Raspberry Pi executando Raspbian de 32 bits. Eu não suporto nenhuma outra plataforma, compilação cruzada ou sistemas operacionais. Ele foi portado para outras plataformas, outros sistemas operacionais e alguns são cross compiling, no entanto, este autor não mantém esses sistemas. Se você está tentando usar wiringPi em uma plataforma diferente do Raspberry Pi com Raspbian então você deve contatar a pessoa que fez o porto e não eu.

O original Raspberry Pi Modelo A e B versão B1 era um computador de placa única de US $ 35 com um conector GPIO (General Purpose Input / Output) de 26 pinos e isso transporta um conjunto de sinais e barramentos. Existem 8 pinos digitais de E / S para fins gerais – estes podem ser programados como saídas digitais ou entradas. Dois desses pinos (em Pi de 40 pinos, apenas um em Pi de 26 pinos) também podem ser designados para saída PWM de hardware. Além disso, há uma interface I2C de 2 fios e uma interface SPI de 4 fios (com uma segunda linha de seleção, totalizando 5 pinos) e a serial UART com mais 2 pinos.

Ao longo dos anos, houve algumas atualizações:

  • O modelo original B com o conector GPIO de 26 pinos.
  • O modelo B, Revision 1.1 Raspberry Pi tem um adicional de 4 linhas GPIO em um conector separado que você tem que soldar na placa.
  • O modelo A é essencialmente o mesmo que o modelo B v1.1, mas sem o hub USB e o conector ethernet.
  • O modelo A + e B + Raspberry Pi representa 2 anos de pesquisa, desenvolvimento e testes e agora possui um único conector GPIO de 40 pinos com 28 pinos GPIO utilizáveis ​​e 4 soquetes USB. (Sem USB ou Ethernet no A +)
  • O modelo B v2 possui um processador quad-core Arm A7 com 1GB de RAM. O mesmo GPIO.
  • O modelo Zero é um Pi A + reduzido (1GHz). Conector GPIO de 40 pinos e muito pouco mais. $ 5 de preço.
  • O modelo B v3 possui um processador quad-core Arm A8 (64 bits) com a mesma RAM e GPIO do modelo 2, mas também possui Wi-Fi e Bluetooth integrados. Ainda o mesmo preço de US $ 35.
  • O modelo Zero-W adiciona o Wi-Fi on-board, o Bluetooth e o conector da câmera Pi ao modelo existente da placa Zero.

As interfaces I2C, SPI e UART também podem ser usadas como pinos de E / S de finalidade geral quando não estão sendo usados ​​em seus modos de barramento, fornecendo um total de 8 + 2 + 5 + 2 = 17 pinos de E / S no conector P1 ( mais mais 4 no conector P5 em uma Revisão 2 Pi) e 28 pinos de E / S nas placas B + e versões 2 e 3 (embora 2 sejam reservados para a interface HAT I2C, mas podem ser usados ​​como GPIOs normais se não forem usados Placa HAT)

O WiringPi inclui um utilitário de linha de comando gpio que pode ser usado para programar e configurar os pinos do GPIO. Você pode usar isso para ler e escrever os pinos e até usá-lo para controlá-los a partir de scripts de shell.

WiringPi é extensível e módulos são fornecidos para ampliar o cabeamentoPi para usar dispositivos de interface analógica no Gertboard, e usar os populareschips de expansão GPIO MCP23x17 / MCP23x08 (I2C 7 SPI), bem como módulos que permitirão blocos de até 4 × 74 × 595 registros de deslocamento para serem encadeados juntos para um valor adicional de 32 bits de saída como uma única unidade. (Você pode ter vários blocos de 4 74x595s, se necessário) Um dos módulos de extensão permite que você use um ATmega (por exemplo, Arduino ou Gertboard) como mais expansão GPIO também – através da porta serial do Pi.

Além disso, você pode escrever facilmente seus próprios módulos de extensão para integrar seus próprios dispositivos periféricos à fiaçãoPi, conforme necessário.

O WiringPi suporta leitura e escrita analógicas, e embora não exista nenhum hardware analógico nativo em um Pi por padrão, os módulos são fornecidos para suportar os chips analógicos Gertboards e outros dispositivos A / D e D / A podem ser implementados com relativa facilidade.

NOTA:

Faça o download da fiação aqui

Existe uma versão do wiringPi hospedada no Github. Não use esta versão do wiringPi . Ele existe apenas para facilitar a construção dos wrappers Ruby e Python que foram escritos por Gadgetoid. Você também pode encontrar outras versões do wiringPi no github – todas elas foram bifurcadas e alteradas para suportar diferentes plataformas de hardware.

A fiação dev devLib

devLib é um conjunto de rotinas de bibliotecas implementadas usando o wiringPi para facilitar o acesso a alguns periféricos populares. Os dispositivos suportados incluem exibições de LCD de caracteres (com base nos chips Hitachi HD44780U) e gráficos – por exemplo, as exibições comuns de 128 × 64 pixels com o chip de driver genérico 12864H. O chip de clock do DS1302 RTC, sensores baseados nos chips Maxdetect (por exemplo, RHT003), as placas de interface Gertboard e PiFace e assim por diante.

Recursos de WiringPi

PiFace

O WiringPi também suporta totalmente a placa PiFace . Veja esta página para mais detalhes.

Gertboard

O WiringPi suporta totalmente o Gertboard. Veja esta página para mais detalhes.

Outros recursos de fiaçãoPi:

Informações adicionais podem ser encontradas nas páginas do Raspberry Pi Wiki .


1 Arduino é realmente duas coisas; uma é uma plataforma de hardware, o outro software e parte do software é um pacote chamado Fiação . A fiação é o núcleo da entrada e saída para o Arduino, então eu pensei que seria bom replicar essa funcionalidade (ou um bom subconjunto utilizável com as extensões do Raspberry Pi) no Raspberry Pi.

Guia Interativo de Pinos GPIO para Raspberry Pi

O guia abrangente de Pinos do GPIO para o Raspberry Pi.

Esta GPIO Pinout foi projetada para ser uma referência rápida e interativa aos pinos GPIO do Raspberry Pi, além de um guia abrangente para as interfaces GPIO do seu Raspberry Pi. Ele também inclui dezenas de pinouts para placas de expansão, HATs e pHATs do Raspberry Pi.

 

https://pinout.xyz/

GERADOR DE TONS

gerador-de-tom

gerador-de-tom

 

Para que posso usar este gerador de tons?

Instrumentos de sintonia, experimentos científicos ( qual é a freqüência de ressonância deste copo de vinho? ), Teste de equipamento de áudio ( quão baixo o meu subwoofer vai? ), Testando sua audição ( qual a freqüência mais alta que você pode ouvir? Há freqüências que você pode ouvir em apenas uma ouvido? ).

Correspondência de frequência do zumbido. Se você tem zumbido de tom puro , esse gerador de frequência on-line pode ajudá-lo a determinar sua frequência. Conhecer a frequência do zumbido pode permitir que você direcione melhor os sons de mascaramento e o treinamento de discriminação de frequência . Quando você encontrar uma frequência que pareça corresponder ao seu zumbido, certifique-se de verificar as frequências uma oitava acima (frequência × 2) e uma oitava abaixo (frequência × ½), pois é fácil confundir tons separados por uma oitava.

Doença de Alzheimer. Há alguma evidência científica inicial de que ouvir um tom de 40 Hz pode reverter algumas das mudanças moleculares nos cérebros dos pacientes de Alzheimer. Essa é uma dessas coisas que parece boa demais para ser verdade, mas os primeiros resultados são muito promissores. Aqui está um resumo da pesquisa até agora e um relatório de um usuário que tentou terapia de 40 Hz em sua esposa. ( Observe que este gerador de tom não é um dispositivo médico – não garanto nada! )

https://www.szynalski.com/tone-generator/

Módulo Ultrassônico JSN-SR04T WAVGAT À Prova D’ Água

Características:

O tamanho pequeno, fácil de usar
Baixa tensão, baixo consumo de energia
Alta precisão
Forte anti-jamming
Integrado com sonda de fio fechado à prova d’ água, adequado para molhado, duras ocasiões de medição

Especificação:

Tensão de funcionamento: DC 5 V
Estática atual de trabalho: 5mA
Corrente de trabalho: 30mA
Freqüência de emissão acústica: 40 KHz
Fiação: + 5 V (positiva); Trig (controle); Echo (receber); GND (cátodo)

Conexão com arduino:
5 V: 5 V Suply
Trig: D12
Echo: D13
GND: GND

Aplicação:

Distância Horizontal messurement
Desvio de obstáculos, controle automático
Controle de tráfego
Segurança, controle industrial

 

 

/* O PROJETO TEM COMO OBJETIVO CONTROLAR UM SISTEMA DE OSMOSE REVERSA CONSTITUÍDA POR 3 BOMBAS, ONDE OS CONTATOS AUXILIARES
DOS SEUS DISJUNTORES DEVEM MANDAR UM SINAL PARA O ARDUINO, O QUAL IRÁ VERIFICAR SE A BOMBA ESTÁ EM FUNCIONAMENTO, CASO
O ARDUINO NÃO RECEBA O SINAL, O DISPLAY INDICARÁ QUE DETERMINADA BOMBA PAROU DE FUNCIONAR. HÁ TAMBÉM DOIS SENSORES BÓIA
QUE INDICARÁ O NÍVEL DO TANQUE. */

 

#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 4, 5, 6, 7, 13);

// DEFINIÇÃO DE ENTRADAS E SAÍDAS DIGITAIS
#define SinalBombaOR 9 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA OR
#define SinalBombaPressOR 10 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA DE PRESSURIZAÇÃO OR
#define SinalBombaPressCME 11 // ENTRADA DE SINAL DO CONTATO AUXILIAR DO DISJUNTOR DA BOMBA DE PRESSURIZAÇÃO CME
#define SinalBoiaInferior 12 // ENTRADA DE SINAL DA BOIA INFERIOR
#define SinalBoiaSuperior 8 // ENTRADA DE SINAL DA BOIA SUPERIOR
#define Sirene A0 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DE SOM
#define LuzVermelha A1 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR VERMELHA
#define LuzAmarela A2 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR AMARELA
#define LuzVerde A3 // SAÍDA DE SINAL PARA ACIONAR O RELÉ SINALIZADOR DA COR VERDE

// VARIAVÉIS GLOBAIS
float vazao = 0; // VARIÁVEL PARA ARMAZENAR O VALOR EM L/MIN
int contaPulso; // VARIÁVEL PARA A QUANTIDADE DE PULSOS
int leituraBombaOR = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraPressOR = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraPressCME = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraBoiaInferior = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
int leituraBoiaSuperior = 0; // VARIAVEL PARA ARMAZENAMENTO DE ESTADO
bool mostra = false; // Libera tela de vazao
bool flag = false; // Controle para evitar repetição de dispaly
unsigned long tempo = 0; // Tempo de milis()
unsigned long ciclo = 500; // Tempo de liberação de display
//————————————————————————-
void setup()
{
// PORTAS DE ENTRADA DE SINAL
Serial.begin(9600);
pinMode(SinalBombaOR, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBombaPressOR, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBombaPressCME, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBoiaInferior, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(SinalBoiaSuperior, INPUT_PULLUP); // PULLUP INVERTE A LOGICA DA PORTA
pinMode(2, INPUT); // ENTRADA DO PULSO DO SENSOR DE VAZAO
attachInterrupt(0, incpulso, RISING); // CONFIGURA O PINO 2(INTERRUPÇÃO 0)

// PORTAS DE SAÍDA DE SINAL PARA ACIONAMENTO DO RELÉ (SE ATIVA NO ESTADO LOW)
pinMode(Sirene, OUTPUT);
pinMode(LuzVermelha, OUTPUT);
pinMode(LuzAmarela, OUTPUT);
pinMode(LuzVerde, OUTPUT);

// CONFIGURA OS RELÉS PARA FICAREM INICIALMENTE DESLIGADOS
digitalWrite(Sirene, HIGH);
digitalWrite(LuzVermelha, HIGH);
digitalWrite(LuzAmarela, HIGH);
digitalWrite(LuzVerde, HIGH);

// INICIALIZAÇÃO DO LCD
lcd.begin(16, 2);
lcd.setCursor(0, 0);
lcd.print(“Monitoramento da”);
lcd.setCursor(1, 1);
lcd.print(“Osmose Reversa”);
delay(1000);
tempo = millis(); // Inicializa tempo
}
//————————————————————————-
void tela_vazao ()
{
mostra = true; // Trava mostra seguida
vazao = (contaPulso / 5.5) / 2; // CONVERTE PARA L/MIN /2 pois usei 500ms
lcd.setCursor (6, 1); // Posiciona cursor
lcd.print(vazao); // ESCREVE NO DISPLAY O VALOR DA VAZAO
contaPulso = 0; // ZERA A VARIÁVEL
}
//————————————————————————-
void loop ()
{
// LEITURA DOS SINAIS NAS PORTAS DIGITAIS(D9 À D13)
leituraBombaOR = digitalRead(SinalBombaOR);
leituraPressOR = digitalRead(SinalBombaPressOR);
leituraPressCME = digitalRead(SinalBombaPressCME);
leituraBoiaInferior = digitalRead(SinalBoiaInferior);
leituraBoiaSuperior = digitalRead(SinalBoiaSuperior);
/*
bombaOR pressOR pressCME inferior superior
HIGH LOW LOW LOW LOW Defeito Bomba OR
LOW HIGH LOW LOW LOW Defeito Bomba Press OR
LOW LOW HIGH LOW LOW Defeito Bomba Press CME
LOW LOW LOW HIGH LOW TANQUE VAZIO
LOW LOW LOW LOW LOW TANQUE ENCHENDO
LOW LOW LOW LOW HIGH TANQUE CHEIO
*/
if ((millis() – tempo) >= ciclo) // Tempo de display
{
tempo = millis(); // Recupera millis()
flag = false; // Libera display
mostra = false; // Libera tela vazao
}

if (leituraBombaOR == HIGH) // SE O SINAL DA BOMBA OR ESTIVER 0VCC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (4, 1);
lcd.print (“Bomba OR”);
flag = true; // Trava display
}
}

if (leituraPressOR == HIGH ) // SE O SINAL DA BOMBA DE PRESSURIZAÇÃO OR ESTIVER 0VVC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (1, 1);
lcd.print (“Bomba Press OR”);
flag = true; // Trava display
}
}

if (leituraPressCME == HIGH) // SE O SINAL DA BOMBA DE PRESSURIZAÇÃO CME ESTIVER 0VCC
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (3, 0);
lcd.print (“Defeito na”);
lcd.setCursor (0, 1);
lcd.print (“Bomba Press CME”);
flag = true; // Trava display
}
}

if (leituraBoiaInferior == HIGH ) // SE O SINAL DA BOIA INFERIOR E SUPERIOR ESTIVEREM BAIXO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, LOW); // SIRENE ALARMA INDICANDO FALHA NO SISTEMA DA OSMOSE
digitalWrite(LuzVermelha, LOW); // LUZ VERMELHA INDICANDO FALHA NO SISTEMA DA OSMOSE
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A FALHA DO SISTEMA
lcd.setCursor (4, 0);
lcd.print (“Atencao”);
lcd.setCursor (2, 1);
lcd.print (“Tanque Vazio”);
flag = true; // Trava display
}
}

if (leituraBombaOR == LOW && leituraPressOR == LOW && leituraPressCME == LOW && leituraBoiaInferior == LOW && leituraBoiaSuperior == LOW) // SE O SINAL DA BOIA SUPERIOR ESTIVER BAIXO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, HIGH); // SIRENE DESATIVADA INDICANDO QUE NÃO HÁ FALHAS NO SISTEMA DA OSMOSE
digitalWrite(LuzAmarela, LOW); // LUZ AMARELA INDICA QUE O TANQUE DE ÁGUA ESTÁ ENCHENDO
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A INFORMAÇÃO DO SISTEMA
lcd.setCursor (0, 0);
lcd.print (“Tanque Enchendo”);
flag = 1;
lcd.setCursor(0, 1);
lcd.print(“Vazao “);
lcd.setCursor(12, 1);
lcd.print(“L/mn”); // ESCREVE L/MIN
flag = true; // Trava display
}
if ( mostra == false)
tela_vazao(); // ESCREVE O VALOR DA VAZAO
}

if ( leituraBoiaSuperior == HIGH) // SE O SINAL DA BOIA INFERIOR E SUPERIOR ESTIVEREM ALTO
{
if (flag == false) // Se display liberado
{
digitalWrite(Sirene, HIGH); // SIRENE DESATIVADA INDICANDO QUE NÃO HÁ FALHAS NO SISTEMA DA OSMOSE
digitalWrite(LuzVerde, LOW); // LUZ VERDE INDICA QUE O TANQUE DE ÁGUA ESTÁ CHEIO
lcd.clear(); // LIMPA O DISPLAY E, EM SEGUIDA, MOSTRA A INFORMAÇÃO DO SISTEMA
lcd.setCursor (4, 0);
lcd.print (“Atencao”);
lcd.setCursor (2, 1);
lcd.print (“Tanque Cheio”);
flag = true; // Trava display
}
}
} // FIM DO VOID LOOP
//————————————————————————-
void incpulso ()
{
contaPulso++; // INCREMENTA A VARIÁVEL DE PULSOS
}

Conhecendo o MQTT

Por que o MQTT é um dos melhores protocolos de rede para a Internet das Coisas?

Para os dispositivos de Internet das Coisas (IoT), a conexão com a Internet é um requisito. A conexão com a Internet permite que os dispositivos trabalhem entre si e com serviços de backend. O protocolo de rede subjacente da Internet é o TCP/IP. Desenvolvido com base na pilha TCP/IP, o MQTT (Message Queue Telemetry Transport) tornou-se o padrão para comunicações de IoT.

O MQTT foi inventado e desenvolvido inicialmente pela IBM no final dos anos 90. Sua aplicação original era vincular sensores em pipelines de petróleo a satélites. Como seu nome sugere, ele é um protocolo de mensagem com suporte para a comunicação assíncrona entre as partes. Um protocolo de sistema de mensagens assíncrono desacopla o emissor e o receptor da mensagem tanto no espaço quanto no tempo e, portanto, é escalável em ambientes de rede que não são confiáveis. Apesar de seu nome, ele não tem nada a ver com filas de mensagens, na verdade, ele usa um modelo de publicação e assinatura. No final de 2014, ele se tornou oficialmente um padrão aberto OASIS, com suporte nas linguagens de programação populares, usando diversas implementações de software livre.

Por que o MQTT

O MQTT é um protocolo de rede leve e flexível que oferece o equilíbrio ideal para os desenvolvedores de IoT:

  • O protocolo leve permite a implementação em hardware de dispositivo altamente restringido e em redes de largura da banda limitada e de alta latência.
  • Sua flexibilidade possibilita o suporte a diversos cenários de aplicativo para dispositivos e serviços de IoT.

Para entender por que o MQTT é tão adequado para desenvolvedores de IoT, vamos analisar por que outros protocolos de rede populares falharam em IoT.

Por que não usar algum dos outros inúmeros protocolos de rede

A maioria dos desenvolvedores já se acostumou aos serviços da Web HTTP. Então, por que não conectar os dispositivos de IoT aos serviços da web? O dispositivo poderia enviar seus dados como uma solicitação de HTTP e receber atualizações do sistema como uma resposta de HTTP. Esse padrão de solicitação e resposta tem algumas limitações graves:

  • O HTTP é um protocolo síncrono. O cliente espera que o servidor responda. Os navegadores da web têm esse requisito, mas o custo é a baixa escalabilidade. No mundo da IoT, a comunicação síncrona tem sido um problema devido ao grande número de dispositivos e à rede, muitas vezes não confiável e de alta latência. Um protocolo de mensagem assíncrono é muito mais adequado para aplicativos de IoT. Os sensores podem enviar leituras e permitir que a rede descubra o caminho e a sincronização ideais para entregar aos dispositivos e serviços de destino.
  • HTTP é unidirecional. O cliente precisa iniciar a conexão. Em um aplicativo de IoT, os dispositivos e sensores geralmente são clientes, o que significa que eles não podem receber comandos da rede passivamente.
  • HTTP é um protocolo de um para um. O cliente faz uma solicitação e o servidor responde. É difícil e caro transmitir uma mensagem a todos os dispositivos na rede, o que é um caso de uso comum em aplicativos de IoT.
  • HTTP é um protocolo pesado com muitos cabeçalhos e regras. Ele não é adequado para redes restringidas.

Pelos motivos citados acima, a maioria dos sistemas escaláveis de alto desempenho usam um barramento do sistema de mensagens assíncrono, em vez de serviços da web, para trocas de dados internas. Na verdade, o protocolo de sistema de mensagens mais popular que é usado em sistemas de middleware corporativos é chamado AMQP (Advanced Message Queuing Protocol). No entanto, no ambiente de alto desempenho, a capacidade de computação e a latência da rede geralmente não são uma preocupação. O AMQP foi criado para assegurar a confiabilidade e a interoperabilidade em aplicativos corporativos. Ele possui um rico conjunto de recursos, mas não é adequado para aplicativos de IoT com restrição de recursos.

Além do AMQP, existem outros protocolos populares de sistema de mensagens. Por exemplo, o XMPP (Extensible Messaging and Presence Protocol) é um protocolo de mensagem instantânea (IM) ponto a ponto. Ele é pesado em recursos com suporte para casos de uso de IM, como presença e anexos de mídia. Em comparação com o MQTT, ele requer muito mais recursos no dispositivo e na rede.

Então, como o MQTT consegue ser tão leve e flexível? Um importante recurso do protocolo MQTT é o modelo de publicação e assinatura. Como em todos os protocolos de sistema de mensagens, ele desacopla o publicador e o consumidor de dados.

O modelo de publicação e assinatura

O protocolo MQTT define dois tipos de entidades na rede: um message broker e inúmeros clientes. O broker é um servidor que recebe todas as mensagens dos clientes e, em seguida, roteia essas mensagens para os clientes de destino relevantes. Um cliente é qualquer coisa que possa interagir com o broker e receber mensagens. Um cliente pode ser um sensor de IoT em campo ou um aplicativo em um data center que processa dados de IoT.

  1. O cliente conecta-se ao broker. Ele pode assinar qualquer “tópico” de mensagem no broker. Essa conexão pode ser uma conexão TCP/IP simples ou uma conexão TLS criptografada para mensagens sensíveis.
  2. O cliente publica as mensagens em um tópico, enviando a mensagem e o tópico ao broker.
  3. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Como as mensagens do MQTT são organizadas por tópicos, o desenvolvedor de aplicativos tem a flexibilidade de especificar que determinados clientes somente podem interagir com determinadas mensagens. Por exemplo, os sensores publicarão suas leituras no tópico “sensor_data” e assinarão o tópico “config_change”. Os aplicativos de processamento de dados que salvam os dados do sensor em um banco de dados de backend assinarão o tópico “sensor_data”. Um aplicativo de console administrativo poderia receber comandos do administrador do sistema para ajustar as configurações dos sensores, como a sensibilidade e a frequência de amostragem, e publicar essas mudanças no tópico “config_change”. (Consulte Figura 1.)

Figura 1. O modelo de publicação e assinatura do MQTT para sensores de IoT

Ao mesmo tempo, o MQTT é leve. Ele tem um cabeçalho simples para especificar o tipo de mensagem, um tópico baseado em texto e, em seguida, uma carga útil binária arbitrária. O aplicativo pode usar qualquer formato de dados para a carga útil como JSON, XML, binário criptografado ou Base64, desde que os clientes de destino possam analisar a carga útil.

Introdução ao desenvolvimento com MQTT

A ferramenta mais fácil para começar o desenvolvimento com MQTT é o módulo Python mosquitto, que faz parte do projeto Eclipse Paho e fornece SDKs e bibliotecas do MQTT em várias linguagens de programação. Ele contém um broker do MQTT que pode ser executado no computador local e ferramentas de linha de comandos que podem interagir com o broker usando mensagens. É possível fazer download e instalar o módulo mosquitto no website do mosquitto.

O comando mosquitto executa o broker do MQTT no computador local. Opcionalmente, é possível usar a opção -d para executá-lo em segundo plano.

$ mosquitto -d

Em seguida, em outra janela do terminal, é possível usar o comando mosquitto_sub para conectar-se ao broker local e assinar um tópico. Após a execução do comando, ele vai esperar e imprimir todas as mensagens que receber da assinatura, à medida que elas forem chegando.

$ mosquitto_sub -t "dw/demo"

Em uma outra janela do terminal, é possível usar o comando mosquitto_pub para conectar-se ao broker local e, em seguida, publicar uma mensagem em um tópico.

$ mosquitto_pub -t "dw/demo" -m "hello world!"

Agora, o terminal que executa o mosquitto_sub deverá exibir “hello world!” na tela. Você acabou de enviar e receber uma mensagem usando um broker do MQTT!

É claro que em um sistema de produção, não é possível usar um computador local como o broker. Nesse caso, é possível usar o Serviço da plataforma Internet das Coisas do IBM Bluemix, que é um serviço sob demanda e confiável que funciona como um broker do MQTT. (Leia mais sobre como esse serviço do Bluemix se integra e usa o MQTT como seu protocolo para comunicar-se com dispositivos e aplicativos na documentação do serviço.)

O nó Serviço da plataforma Internet das Coisas do IBM Bluemix funciona da seguinte forma.

  • No console do Bluemix, é possível criar uma instância do serviço da plataforma Internet das Coisas sob demanda.
  • Em seguida, é possível incluir dispositivos que possam conectar a instância de serviço usando o MQTT. Cada dispositivo terá um ID e um nome. Somente os dispositivos listados podem acessar o serviço, e o painel da plataforma Watson IoT relatará informações sobre tráfego e uso desses serviços, nos respectivos dispositivos.
  • Para cada cliente do dispositivo, o Bluemix designará um nome do host, um nome de usuário e uma senha para a conexão com a instância de serviço (o broker do MQTT). (No Bluemix, o nome de usuário sempre é use-token-auth e a senha é o token que é mostrado na Figura 2 para cada dispositivo conectado.)
Figura 2. Criando uma instância de serviço da plataforma Internet das Coisas no IBM Bluemix

Ao usar um broker remoto do MQTT, será necessário passar pela aprovação das credenciais de autenticação e de nome do host do broker para os comandos mosquitto_sub e mosquitto_pub. Por exemplo, o comando a seguir assina o tópico de demonstração no nosso serviço da plataforma Internet das Coisas com o nome de usuário e senha fornecidos pelo Bluemix:

$ mosquitto_sub -t "demo" -h host.iotp.mqtt.bluemix.com -u username -P password

Para conhecer mais opções de como usar as ferramentas do mosquitto e também de como usar a API do mosquitto para criar seus próprios aplicativos clientes do MQTT, consulte a documentação no website do mosquitto.

Agora que você já tem as ferramentas necessárias, vamos nos aprofundar no protocolo MQTT.

Entendendo o protocolo MQTT

O MQTT é um protocolo de ligação que especifica como os bytes de dados são organizados e transmitidos pela rede TCP/IP. Mas por motivos práticos, os desenvolvedores não precisam entender o protocolo de ligação. Basta saber que cada mensagem tem uma carga útil de comando e dados. O comando define o tipo de mensagem (por exemplo, uma mensagem CONNECT ou uma mensagem SUBSCRIBE). Todas as bibliotecas e ferramentas do MQTT oferecem maneiras simples de manipular essas mensagens diretamente e podem preencher automaticamente alguns campos necessários, como os IDs da mensagem e do cliente.

Primeiro, o cliente conecta-se ao broker enviando uma mensagem CONNECT. A mensagem CONNECT pede para estabelecer uma conexão do cliente com o broker. A mensagem CONNECT tem os parâmetros de conteúdo a seguir.

Tablela 1. Parâmetros da mensagem CONNECT
Parâmetro Descrição
cleanSession Esta sinalização especifica se a conexão é persistente ou não. Uma sessão persistente armazena todas as assinaturas e as mensagens possivelmente perdidas (dependendo do QoS) no broker. (Consulte Tablela 3 para obter uma descrição do QoS).
username As credenciais de autenticação e autorização do broker.
password As credenciais de autenticação e autorização do broker.
lastWillTopic Quando a conexão for encerrada inesperadamente, o broker publicará automaticamente uma mensagem de “último desejo” em um tópico.
lastWillQos O QoS da mensagem de “último desejo”. (Consulte Tablela 3 para obter uma descrição do QoS).
lastWillMessage A própria mensagem de “último desejo”.
keepAlive Este é o intervalo de tempo em que o cliente precisa efetuar ping no broker para manter a conexão ativa.

O cliente receberá uma mensagem CONNACK do broker. A mensagem CONNACK tem os parâmetros de conteúdo a seguir.

Tablela 2. Parâmetros da mensagem CONNACK
Parâmetro Descrição
sessionPresent Indica se a conexão já tem uma sessão persistente. Ou seja, a conexão já tem tópicos assinados e receberá a entrega de mensagens ausentes.
returnCode 0 indica sucesso. Outros valores identificam a causa da falha.

Depois que uma conexão for estabelecida, o cliente poderá enviar uma ou mais mensagens SUBSCRIBE ao broker para indicar que ele receberá mensagens do broker de determinados tópicos. A mensagem pode ter uma ou várias repetições dos parâmetros a seguir.

Tablela 3. Parâmetros da mensagem SUBSCRIBE
Parâmetro Descrição
qos A sinalização qos (qualidade de serviço ou QoS) indica com que consistência as mensagens neste tópico precisam ser entregues aos clientes.

  • Valor 0: não confiável, a mensagem é entregue no máximo uma única vez, se o cliente estiver indisponível no momento, ele perderá a mensagem.
  • Valor 1: a mensagem deve ser entregue pelo menos uma vez.
  • Valor 2: a mensagem deve ser entregue exatamente uma vez.
tópico Um tópico para assinar. Um tópico pode ter vários níveis separados pelo caractere barra. Por exemplo, “dw/demo” e “ibm/bluemix/mqtt” são tópicos válidos.

Depois que o cliente tiver assinado um tópico com sucesso, o broker retornará uma mensagem SUBACK com um ou mais parâmetros returnCode.

Tablela 4. Parâmetros da mensagem SUBACK
Parâmetro Descrição
returnCode Existe um código de retorno para cada um dos tópicos no comando SUBSCRIBE. Os valores de retorno são os seguintes.

  • Valores 0 a 2: sucesso como nível de QoS correspondente. (Consulte Tablela 3 para saber mais sobre QoS.)
  • Valor 128: falha.

Correspondendo à mensagem SUBSCRIBE, o cliente também poderá UNSUBSCRIBE (cancelar a assinatura) de um tópico ou de vários tópicos.

Tablela 5. Parâmetros da mensagem UNSUBSCRIBE
Parâmetro Descrição
tópico Este parâmetro pode se repetir para vários tópicos.

O cliente pode enviar mensagens PUBLISH ao broker. A mensagem contém um tópico e uma carga útil de dados. Em seguida, o broker encaminha a mensagem a todos os clientes que assinam esse tópico.

Tablela 6. Parâmetros da mensagem PUBLISH
Parâmetro Descrição
topicName O tópico no qual a mensagem é publicada.
qos O nível de qualidade de serviço da entrega da mensagem. (Consulte Tablela 3 para obter uma descrição do QoS).
retainFlag Esta sinalização indica se o broker reterá a mensagem como a última mensagem conhecida deste tópica.
carga útil Os dados reais na mensagem. Pode ser uma sequência de texto ou um blob binário de dados.

Dicas e soluções alternativas

O poder do MQTT é a simplicidade. Não há restrições quanto ao tipo de tópico ou de carga útil de mensagem que se pode usar. Isso permite alguns casos de uso interessantes. Por exemplo, considere estas questões:

Como executar mensagens de um para um com o MQTT? Ambas as partes podem concordar em usar um tópico que seja exclusivo para elas. Por exemplo, o nome do tópico pode conter os IDs dos dois clientes para garantir sua exclusividade.

Como um cliente transmite seu status de presença? O sistema pode concordar com uma convenção de nomenclatura para tópicos de “presença”. Por exemplo, o tópico “presence/client-id” pode conter as informações de presença do cliente. O cliente define a mensagem como true quando se conecta e false quando se desconecta. O cliente também pode configurar uma mensagem de last will como false para ser definida quando a conexão for encerrada. A mensagem pode ser retida pelo broker para que novos clientes possam ler o tópico e descobrir o status de presença.

Como proteger as comunicações? A conexão do cliente com o broker pode ser uma conexão TLS criptografada para proteger os dados em trânsito. Além disso, como o protocolo MQTT não impõe restrições quanto ao formato de dados da carga útil, o sistema pode concordar com um método de criptografia e um mecanismo de atualização de chave. Depois disso, todo o conteúdo na carga útil pode ser dados binários criptografados das mensagens JSON ou XML reais.

Conclusão

Neste artigo eu ofereci uma introdução técnica ao protocolo MQTT. Você aprendeu o que é o MQTT, por que ele é adequado para aplicativos de IoT e como começar a desenvolver aplicativos que usam o MQTT.

Em um de meus próximos artigos, vou mostrar como desenvolver uma solução de sensor de IoT completa com serviços de MQTT de backend e usando uma placa NodeMCU.

Recursos

Recursos para download

Temas relacionados

Fonte:  https://www.ibm.com/developerworks/br/library/iot-mqtt-why-good-for-iot/index.html

Mosquitto Eclipse – Um Broker MQTT de Software Livre

O Eclipse Mosquitto é um intermediário de mensagens de código-fonte aberto (licenciado por EPL / EDL) que implementa as versões 3.1 e 3.1.1 do protocolo MQTT. O Mosquitto é leve e adequado para uso em todos os dispositivos, desde computadores de mesa única de baixa potência até servidores completos.

O protocolo MQTT fornece um método leve de executar mensagens usando um modelo de publicação / assinatura. Isso o torna adequado para mensagens da Internet das Coisas, como sensores de baixa potência ou dispositivos móveis, como telefones, computadores embutidos ou microcontroladores.

O projeto Mosquitto também fornece uma biblioteca C para implementar clientes MQTT, e os populares clientes MQTT da linha de comando mosquitto_pub e mosquitto_sub.

O Mosquitto faz parte da Eclipse Foundation e é um projeto do iot.eclipse.org

Baixar

O Mosquitto é altamente portátil e está disponível para uma ampla gama de plataformas. Vá para a página de download dedicada para encontrar a origem ou os binários para sua plataforma.

Leia o log de alterações para saber mais sobre os lançamentos recentes.

Teste

Você pode ter sua própria instância do Mosquitto em execução em minutos, mas para tornar o teste ainda mais fácil, o Projeto Mosquitto executa um servidor de teste em test.mosquitto.org onde você pode testar seus clientes de várias maneiras: MQTT simples, MQTT sobre TLS , MQTT sobre TLS (com certificado de cliente , MQTT sobre WebSockets e MQTT sobre WebSockets com TLS.

plataformas.

Comunidade

Segurança

Use a página de segurança para descobrir como denunciar vulnerabilidades ou respostas a problemas de segurança anteriores.

Fonte

Downloads mais antigos estão disponíveis em http://mosquitto.org/files/

Instalação Binária

janelas

Veja o arquivo readme-windows.txt depois de instalar os detalhes e dependências específicos do Windows.

Mac

Mosquitto pode ser instalado a partir do projeto homebrew. Veja brew.sh e depois usebrew install mosquitto

Arch Linux

  • Mosquitto pode ser encontrado no repositório da comunidade.

CentOS

Baixe o arquivo de configuração do repositório para sua versão do CentOS a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. CentOS 7CentOS 6

Debian

  • O Mosquitto agora está no Debian. Haverá um pequeno atraso entre uma nova versão e ela aparecerá no Debian como parte dos procedimentos normais da Debian.
  • Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository>

Fedora

O Mosquitto está agora disponível diretamente no Fedora. Use yum install mosquittoou pesquise “mosquito” para encontrar os pacotes relacionados.

FreeBSD

Mosquitto está disponível para o FreeBSD: http://www.freshports.org/net/mosquitto/

Gentoo

Usar emerge mosquitto

openSUSE

Faça o download do arquivo de configuração do repositório para a sua versão do openSUSE abaixo e copie-o para /etc/zypp/repos.d/ Agora você poderá instalar e manter o mosquito atualizado usando as ferramentas normais de gerenciamento de pacotes.

As embalagens disponíveis são: mosquitto, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto.

OpenWrt

Se você estiver usando um instantâneo de tronco, use opkg update; opkg install mosquitto

Karl Palsson mantém um conjunto de feeds que podem ser mais atualizados do que a versão atual do OpenWrt:

Raspberry Pi

Mosquitto está disponível através do repositório principal.

Existem também repositórios Debian fornecidos pelo projeto do mosquito, como descrito em http://mosquitto.org/2013/01/mosquitto-debian-repository/

Redhat Enterprise Linux

Faça o download do arquivo de configuração do repositório para sua versão do RHEL a partir de baixo e copie-o para /etc/yum.repos.d/ Agora você poderá instalar e manter o mosquitto atualizado usando as ferramentas normais de gerenciamento de pacotes.

Os pacotes disponíveis são: mosquito, mosquito-cliente, libmosquitto1, libmosquitto-devel, libmosquittopp1, libmosquittopp-devel, python-mosquitto. RHEL 7RHEL 6

SUSE Linux Enterprise Server

Adicione o repositório apropriado à sua configuração de pacote na lista abaixo e instale o mosquitto a partir de suas ferramentas normais de gerenciamento de pacotes.

Ubuntu

O Mosquitto está disponível nos repositórios do Ubuntu para que você possa instalar como em qualquer outro pacote. Se você estiver em uma versão anterior do Ubuntu ou quiser uma versão mais recente do mosquitto, adicione o PPA mosquitto-dev à sua lista de repositórios – veja o link para detalhes. O mosquito pode então ser instalado a partir do gerenciador de pacotes.

  • sudo apt-add-repository ppa:mosquitto-dev/mosquitto-ppa
  • sudo apt-get update

Se o comando apt-add-repositorynão for reconhecido, ele poderá ser instalado com:

  • sudo apt-get install python-software-properties

Iphone

Você pode usar o libmosquitto (incluído no download da fonte) no iPhone para criar aplicativos MQTT. Ele compila como objective-c, ou você pode usar o projeto marquette que é um wrapper object-c e aplicativo de exemplo.

Fonte: https://mosquitto.org/download/

 .

Mosquitto e paho-mqtt-python

Mosquitto e paho-mqtt-python

Melhore a segurança do mosquito no Ubuntu 16.04 LTS

Instalar mosquito
> sudo apt-adicionar-repositório ppa: mosquitto-dev / mosquitto-ppa
> sudo apt-get atualizar
> sudo apt-get instalar mosquitto mosquitto-clients

Instalar o paho-mqtt-python
> pip install paho-mqtt

Configurar mosquito
> sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistência true 
persistence_location / var / lib / mosquitto / 
allow_anonymous falso 
arquivo log_dest /var/log/mosquitto/mosquitto.log 
include_dir /etc/mosquitto/conf.d

Adicione a confoguração do mosquito
> sudo vi /etc/mosquitto/conf.d/default.conf

password_file / etc / mosquitto / passwd
ouvinte 1883 localhost
listener 8883 
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem 
cafile /etc/letsencrypt/live/[hostname]/chain.pem 
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem

Adicionar nome de usuário e senha do
mosquitto> mosquitto_passwd -c / etc / mosquitto / passwd [nome de usuário]
Senha: [senha]
Redigite a senha: [senha]

Teste com o assinante do mosquitto
> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -q [qos] -c -i [clientid] -u [username] -P [senha]

Teste com o editor de mosquitos
> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs-t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [senha]

assinante paho-mqtt

 

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

 

Configurar mosquito

>sudo vi /etc/mosquitto/mosquitto.conf
> wget https://github.com/eclipse/mosquitto/blob/master/mosquitto.conf

persistence true
persistence_location /var/lib/mosquitto/
allow_anonymous false
log_dest file /var/log/mosquitto/mosquitto.log
include_dir /etc/mosquitto/conf.d

Adicione a configuração do mosquito

password_file /etc/mosquitto/passwd
listener 1883 localhost
listener 8883
certfile /etc/letsencrypt/live/[hostname]/fullchain.pem
cafile /etc/letsencrypt/live/[hostname]/chain.pem
keyfile /etc/letsencrypt/live/[hostname]/privkey.pem
include_dir /etc/mosquitto/conf.d

Adicionar nome de usuário e senha do

> mosquitto_passwd -c /etc/mosquitto/passwd [username]
Password: [password]
Reenter password: [password]

 

Teste com o assinante do mosquitto

> mosquitto_sub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -q [qos] -c -i [clientid] -u [username] -P [password]

 

Teste com o editor de mosquitos

> mosquitto_pub -h [hostname] -p 8883 –capath /etc/ssl/certs -t [topic] -m [message] -q [qos] -i [clientid] -u [username] -P [password]

Assinante paho-mqtt

import ssl
import sys

import paho.mqtt.client

def on_connect(client, userdata, flags, rc):
	print('connected (%s)' % client._client_id)
	client.subscribe(topic='[topic]', qos=2)

def on_message(client, userdata, message):
	print('------------------------------')
	print('topic: %s' % message.topic)
	print('payload: %s' % message.payload)
	print('qos: %d' % message.qos)

def main():
	client = paho.mqtt.client.Client(client_id='[clientid]', clean_session=False)
	client.username_pw_set('[username]', '[password]')
	client.on_connect = on_connect
	client.on_message = on_message
	client.tls_set('/etc/ssl/certs/DST_Root_CA_X3.pem', tls_version=ssl.PROTOCOL_TLSv1_2)
	client.connect(host='[hostname]', port=8883)
	client.loop_forever()

if __name__ == '__main__':
	main()
	sys.exit(0)

Editor paho-mqtt

import ssl
import sys

import paho.mqtt.client
import paho.mqtt.publish

def on_connect(client, userdata, flags, rc):
	print('connected')

def main():
	paho.mqtt.publish.single(
		topic='[topic]',
		payload='[message]',
		qos=2,
		hostname='[hostname]',
		port=8883,
		client_id='[clientid]',
		auth={
			'username': '[username]',
			'password': '[password]'
		},
		tls={
			'ca_certs': '/etc/ssl/certs/DST_Root_CA_X3.pem',
			'tls_version': ssl.PROTOCOL_TLSv1_2
		}
	)

if __name__ == '__main__':
	main()
	sys.exit(0)

 

erinus diz:

Se o seu assinante quiser receber todas as mensagens não lidas em um tópico após o início, você deverá concluir estas etapas:

Use o mesmo ID de cliente quando você inicia o assinante.
Use clean_session = False quando você inicia o assinante.
Use qos> 0 quando você assina um tópico.
Use qos> 0 quando você publicar uma mensagem.

Para tornar suas comunicações mais seguras, você deve concluir estas etapas:

Usar TLS 1.2
Set allow_anonymous = False
Habilitar autenticação com nome de usuário e senha

Se você quer mais métodos de autenticação, tente este plugin mosquitto:

https://github.com/jpmens/mosquitto-auth-plug

 

Fonte:  https://medium.com/@erinus/mosquitto-paho-mqtt-python-29cadb6f8f5c

 

 

 

 

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 

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/