Sistema de sensoriamento genérico baseado na internet das coisas (IOT) usando uma OrangePi, uma ESP8266 e comunicação através do protocolo MQTT
Adicionar:
#define LED_BUILTIN 2
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
// ---> WIFI <---
const char* ssid = "INTELBRAS"; //Rede WIFI
const char* password = "Pbl-Sistemas-Digitais"; //Senha
WiFiClient nodemcuClient;
// ---> MQTT <---
const char* mqtt_broker = "10.0.0.101";
const char* mqtt_ClientID = "aluno";
const char* mqtt_pass = "@luno*123";
//PubSubClient client(nodemcuClient);
const char*topicoTemp = "dispositivos/temperatura";
const char*topicoUmid = "dispositivos/umidade";
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived in topic: ");
Serial.println(topic);
Serial.print("Message:");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
Serial.println("-----------------------");
}
PubSubClient client(mqtt_broker, 1883, callback, nodemcuClient);
// ---> SETUP <---
void setup() {
conectaWifi();
if (client.connect("arduinoClient", "aluno", "@luno*123")) {
client.publish("Temp","Mensagem", true);
client.subscribe("Temp");
}else{
Serial.println("Erro");
}
}
void loop() {
if (!client.connected()) {
reconMQTT();
}
publicaTempUmidMQTT();
}
// ---> FUNÇÕES REDE <---
void conectaWifi(){
delay(10);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
}
void reconMQTT(){
while (!client.connected()) {
client.connect(mqtt_ClientID);
}
}
// ---> FUNÇÕES PUBLISH <---
void publicaTempUmidMQTT() {
client.publish(topicoTemp, String("teste").c_str(), true); //true retém o dado publicado até que seja enviado o próximo
client.publish(topicoUmid, String("teste").c_str(), true);
delay(300000);
}
svg is inheriting overflow: hidden; style property from parent div, witch leads to content being cut.
Issue been tracked here: software-mansion/react-native-svg#1928
#include <stdio.h> // printf,
#include <stdlib.h> // atoi
#include <string.h> // strncpy, strtok, strlen, strcmp,
#include "display.h" // write_char, init_display, clear_display
#include "sensor.h" // Sensor, print_sensor_to_console,
#include "serial.h" // uart_configure, uart_send_string, serialReadBytes
#include "comunication.h" // command_to_int
#include "utils.h" // await
#include "menu.h" // menu
#include "help.h"
#include <lcd.h>
#include <MQTTClient.h>
#include <wiringPi.h>
//#define TRUE 1
#define MQTT_ADDRESS "tcp://10.0.0.101"
#define BROKER_ADDRESS "tcp://10.0.0.101:1883"
#define CLIENTID "98631145"
#define USERNAME "aluno"
#define PASSWORD "@luno*123"
#define MQTT_PUBLISH_TOPIC "Temp"
#define MQTT_SUBSCRIBE_TOPIC "Temp"
//USE WIRINGPI PIN NUMBERS
#define LCD_RS 13 //Register select pin
#define LCD_E 18 //Enable Pin
#define LCD_D4 21 //Data pin D4
#define LCD_D5 24 //Data pin D5
#define LCD_D6 26 //Data pin D6
#define LCD_D7 27 //Data pin D7
// Botões
#define BUTTON_1 19
#define BUTTON_2 23
#define BUTTON_3 25
MQTTClient client;
int lcd;
void escreverEmDuasLinhas(char linha1[], char linha2[]) {
lcdHome(lcd);
lcdPuts(lcd, linha1);
lcdPosition(lcd,0,1);
lcdPuts(lcd, linha2);
}
void publish(MQTTClient client, char *topic, char *payload);
int on_message(void *context, char *topicName, int topicLen, MQTTClient_message *message);
int isPressed(int btt);
void publish(MQTTClient client, char *topic, char *payload)
{
MQTTClient_message pubmsg = MQTTClient_message_initializer;
pubmsg.payload = payload;
pubmsg.payloadlen = strlen(pubmsg.payload);
pubmsg.qos = 2;
pubmsg.retained = 0;
MQTTClient_deliveryToken token;
MQTTClient_publishMessage(client, topic, &pubmsg, &token);
MQTTClient_waitForCompletion(client, token, 1000L);
}
int on_message(void *context, char *topicName, int topicLen, MQTTClient_message *message)
{
char *payload = message->payload;
/* Mostra a mensagem recebida */
printf("Mensagem recebida! \n\rTopico: %s Mensagem: %s\n", topicName, payload);
/* Faz echo da mensagem recebida */
//publish(client, MQTT_PUBLISH_TOPIC, payload);
MQTTClient_freeMessage(&message);
//MQTTClient_free(topicName);
return 1;
}
int get_number_of_digital_ios();
char *getSubstring(char *dst, const char *src, size_t start, size_t end);
void separate_string_in_3(char *str, char a[10], char b[10], char c[10]);
void print_io_name_and_id(int max_digital);
int add_digital_sensor(char *sensor_info, Sensor *digital);
/**
* @brief Realiza a leitura de sensores de forma automatizada atraves de comunicação serial
* da raspberry pi
*
* @param argc Numero de argumentos da linha de comando recebidos
* @param argv Lista de argumentos recebidos
* @return int Retorna 0 se executado com sucesso. Qualquer outro valor em caso de execução incorreta
*/
int main(int argc, char *argv[]) {
// Configuração inicial
wiringPiSetup();
lcd = lcdInit (2, 16, 4, LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7,0,0,0,0);
pinMode(BUTTON_1,INPUT);
pinMode(BUTTON_2,INPUT);
pinMode(BUTTON_3,INPUT);
escreverEmDuasLinhas(" MI - SD ", "");
while (1) {
//printf("no loop\n\n");
isPressed(BUTTON_1);
isPressed(BUTTON_2);
//await(1000);
}
int rc;
/*Configuração do Cliente*/
MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;
conn_opts.keepAliveInterval = 20;
conn_opts.cleansession = 1;
conn_opts.username = USERNAME;
conn_opts.password = PASSWORD;
/* Inicializacao do MQTT (conexao & subscribe) */
MQTTClient_create(&client, MQTT_ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
MQTTClient_setCallbacks(client, NULL, NULL, on_message, NULL);
rc = MQTTClient_connect(client, &conn_opts);
if (rc != MQTTCLIENT_SUCCESS)
{
printf("\n\rFalha na conexao ao broker MQTT. Erro: %d\n", rc);
exit(-1);
}
MQTTClient_subscribe(client, MQTT_SUBSCRIBE_TOPIC, 0);
//escreverEmDuasLinhas(" MI - SD ", "Protocolo MQTT");
unsigned char ler[100]; // Leitura de respostas
Sensor analogico;
Sensor digital[31];
int digitalQtd = 0; // Quantidade de sensores digitais selecionados
if (argc < 2) { // Se não tiver argumentos, encerra o programa
printf("Uso inválido. Não há argumentos\n");
return 0;
}
/**
* Percorre a lista de argumentos para definir os sensores
*/
for (int index = 1; index < argc; index++) {
char str[6] = "\0\0\0";
/**
* @brief Se adicionado um sensor analogico
*/
if (strcmp(argv[index], "-analogic") == 0) {
printf("Há um sensor na porta analogica\n");
char *j = "Analogico";
analogico.name[9] = '\0';
for (int i = 0; i < strlen(j) && i < 10; i++) {
//printf("%c", ptr[i]);
analogico.name[i] = j[i];
}
analogico.name[10] = '\0';
analogico.value = 0;
analogico.id = 'A';
analogico.type = Analogic;
}
/**
* Se inserido uma porta digital
*/
else if (strcmp(getSubstring(str, argv[index], 0, 2), "-d") == 0) {
//char name[10];
if (digitalQtd >= 31) {
printf("Atingido maximo de sensores digitais!\n");
continue;
}
int res = add_digital_sensor(argv[index], &digital[digitalQtd]);
if (res == -1) { // se hoube erro
exit(0); // termina o programa
} // do contrario
digitalQtd++; // contabilize o sensor adicionado
}
/**
* @brief Se listando os sensores disponíveis
*/
else if (strcmp(argv[index], "-l") == 0) {
unsigned char read[100]; // Leitura de respostas
//printf("\nPegando o numero de portas digitais disponíveis: \n");
int max_digital = get_number_of_digital_ios();
if (max_digital < 0) {
printf("Erro na leitura do numero de portas disponíveis\n");
return 0; // encerra programa
}
/** Numero de portas digitais disponíveis */
print_io_name_and_id(max_digital);
}
/** Se opção manual */
else if (strcmp(argv[index], "-m") == 0) {
// exibe menu
char notice[80] = " ";
while (1)
{
menu_item entries[] = {
{
.item_name = "Status da NodeMCU", .id = 0
},
{
.item_name = "Ligar o led", .id = 1
},
{
.item_name = "Desligar o led", .id = 2
},
{
.item_name = "Ler sensor analogico", .id = 3
},
{
.item_name = "Ler sensor digital", .id = 4
},
{
.item_name = "Sair", .id = 5
},
};
int selected_entrie_id = menu(
entries,
Lenght(entries),
"Use as setas para navegar entre as opções do menu. Pressione enter para selecionar a opção",
"",
notice
);
switch (selected_entrie_id)
{
case 0:
send_command(GET_NODE_MCU_STATUS, 'O');
printf("Obtendo status da NodeMCU...\n");
await(3000);
//serialReadBytes(ler); // lê resposta
if (ler[0] == NODE_MCU_STATUS_OK && ler[1] == NODE_MCU_STATUS_ERROR) {
sprintf(notice, "Status: OK"); // Limpa mensagem
} else {
sprintf(notice, "Status: ERRO!");
}
clear_display();
write_string(notice);
break;
case 1:
send_command(NODE_MCU_ON_LED_BUILTIN, 'L');
sprintf(notice, "LED ligado");
clear_display();
write_string(notice); // Limpa mensagem
break;
case 2:
send_command(NODE_MCU_OFF_LED_BUILTIN, 'L');
sprintf(notice, "LED desligado");
clear_display();
write_string(notice); // Limpa mensagem
break;
case 3:
send_command(GET_ANALOG_INPUT_VALUE, GET_ANALOG_INPUT_VALUE);
printf("Lendo sensor analogico...\n");
await(3000);
//serialReadBytes(ler); // lê resposta
print_sensor_to_console("Analogico", command_to_int(ler[1], ler[2]));
sprintf(notice, "%9s: %4i", "Analogico", command_to_int(ler[1], ler[2]));
break;
case 4:
printf("Digite o endereço do sensor: ");
scanf("%s", ler);
int sensor_address = atoi(ler);
printf("Lendo sensor digital...\n");
send_command(GET_DIGITAL_INPUT_VALUE, (char) sensor_address); // Solicita leitura do sensor
await(3000); // Aguarda comando ser processado
//serialReadBytes(ler); // lê resposta
if (ler[0] == NODE_MCU_STATUS_ERROR) { // Se houve erro na leitura
printf("NodeMCU com problema. Endereço do sensor é inválido!\n");
clear_display();
write_string("NodeMCU com erro");
} else { // Se lido com sucesso
print_sensor_to_console("Sensor", ler[1] - '0'); // Exibe informações lidas
sprintf(notice, "Sensor: %i: %4i", sensor_address, ler[1] - '0');
}
break;
case 5:
exit(0);
break;
default:
sprintf(notice, " "); // Limpa mensagem
break;
}
}
}
// menu de ajuda
else if (strcmp(argv[index], "-h") == 0) {
help("general");
exit(0);
}
// Comando inválido
else {
printf("\n\nComando inválido!!\nEncerrando...\n");
exit(0);
}
}
printf("Iniciando leitura\n\n");
while(1) {
/**
* Lê o sensor analogico
*/
if (analogico.type == Analogic) { // Se existe um sensor analogico
send_command(GET_ANALOG_INPUT_VALUE, GET_ANALOG_INPUT_VALUE);
await(3000);
//serialReadBytes(ler); // lê resposta
//analogico.value = command_to_int(ler[1], ler[2]);
print_sensor_to_console(analogico.name, analogico.value);
}
/**
*/
for (int i = 0; i < digitalQtd; i++) {
send_command(GET_DIGITAL_INPUT_VALUE, (char) digital[i].id); // Solicita leitura do sensor
await(3000); // Aguarda comando ser processado
//serialReadBytes(ler); // lê resposta
if (0) { // Se houve erro na leitura
printf("NodeMCU com problema. Endereço do sensor é inválido!\n");
clear_display();
write_string("NodeMCU com erro");
} else { // Se lido com sucesso
//digital[i].value = ler[1] - '0'; // salva o valor lido
print_sensor_to_console(digital[i].name, digital[i].value); // Exibe informações lidas
}
}
if (analogico.type != Analogic && digitalQtd < 1) { // Se não houver nenhum sensor
printf("\nNão foram adicionados sensores. Ecerrando...\n");
return 0; // Encerra o programa
}
}
}
/**
* @brief Obtem o numero de entradas digitais disponíveis para
* leitura
*
* @return int o numero de entradas digitais ou -1 em caso de erro
*/
int get_number_of_digital_ios() {
unsigned char read[100];
send_command(GET_NUMBER_OF_SENSORS, GET_NUMBER_OF_SENSORS);
await(3000);
//serialReadBytes(read);
if (read[0] != NUMBER_OF_DIGITAL_PORTS || strlen(read) < 2) {
return -1;
}
/** Numero de portas digitais disponíveis */
return read[1] - '0';
}
/**
* @brief Exibe no terminal o nome e o endereço de cada uma das
* entradas digitais disponíveis.
*
* @param max_digital Numero maximo de entradas digitais. (valor
* retornado pela função get_number_of_digital_ios)
* @see get_number_of_digital_ios
*/
void print_io_name_and_id(int max_digital) {
unsigned char read[100];
char command[100];
printf("Portas digitais disponíveis: %i\n\n", max_digital);
printf("%10s: %8s\n", "Nome", "Endereço\n");
for (int p = 1; p <= max_digital; p++) {
send_command(GET_SENSOR_ADDRESS, p); // Solicita o endereço do sensor
await(3000); // Aguarda processamento da solicitação
//serialReadBytes(read); // faz a leitura
/** Se problema com a node, encerra a leitura*/
if (read[0] == NODE_MCU_STATUS_ERROR) { // se houver erro
printf("NodeMCU com problema!!!\n\n");
clear_display();
write_string("NodeMCU com erro");
exit(0); // termina o programa
}
unsigned char sensor_address = read[1]; // endereço do sensor
/** Obtendo o nome */
send_command(GET_SENSOR_NAME, sensor_address); // Solicita o nome do sensor
await(3000); // Aguarda processamento da solicitação
//serialReadBytes(read); // Lê a resposta
command[0] = read[1];
command[1] = read[2];
// exibe a informação
printf("%10s: %2i\n", command, sensor_address); // Exibe os dados lidos
}
}
/**
* @brief Get the Substring object
*
* @param dst Destination variable
* @param src String to get a substring
* @param start Initial position of the substring
* @param end Ending position of the substring
* @return char* Substring
*/
char *getSubstring(char *dst, const char *src, size_t start, size_t end) {
return strncpy(dst, src + start, end);
}
/**
* @brief Separa um argumento lido em 3 substrings
*
* @param str string lida
* @param a priemira substring de tamanho 10
* @param b segunda substring de tamanho 10
* @param c terceira substring de tamanho 10
*/
void separate_string_in_3(char *str, char a[10], char b[10], char c[10]) {
char *ptr = strtok(str, ".");
int index = 0;
while(ptr != NULL && index < 3)
{
//printf("%s\n", ptr);
//res[i] = ptr;
//strcpy(res[index], ptr);
if (index == 0) {
for (int i = 0; i < strlen(ptr) && i < 10; i++) {
//printf("%c", ptr[i]);
a[i] = ptr[i];
}
a[10] = '\0';
}
if (index == 1) {
for (int i = 0; i < strlen(ptr) && i < 10; i++) {
//printf("%c", ptr[i]);
b[i] = ptr[i];
}
b[10] = '\0';
}
if (index == 2) {
for (int i = 0; i < strlen(ptr) && i < 10; i++) {
//printf("%c", ptr[i]);
c[i] = ptr[i];
}
c[10] = '\0';
}
//printf("\n");
ptr = strtok(NULL, ".");
index++;
}
}
/**
* @brief Adiciona um sensor digital a lista de sensores salvos
*
* @param sensor_info String (argumento recebido pelo programa) contendo
* as informações do sensor digital
* @param digital Ponteiro para uma estrutura onde as informações serão salvas
* @return int Retorna 1 se sucesso, ou -1 se houver algum erro.
*/
int add_digital_sensor(char *sensor_info, Sensor *digital) {
printf("Há um sensor na porta digital\n");
char arr[3][11] = {"", "", ""};
separate_string_in_3(sensor_info, arr[0], arr[1], arr[2]);
/**
* @brief Os parametros para adiconar um sensor digital não
* podem ser vazios. O nome e o endereço são obrigatórios
*/
if (strlen(arr[0]) == 0 || strlen(arr[1]) == 0 || strlen(arr[2]) == 0) {
printf("\nComando ilegal!!!\n\n");
//exit(0);
return -1;
}
/**
* O endereço do sensor nunca é zero
*/
int address = atoi(arr[2]);
if (address == 0) {
printf("Endereço invalido para o sensor!!!\n");
//exit(0);
return -1;
}
/**
* @brief Salvando o nome do sensor
*/
for (int i = 0; i < strlen(arr[1]) && i < 10; i++) {
//printf("%c", ptr[i]);
digital->name[i] = arr[1][i];
}
int end = 10;
if (strlen(arr[1]) < 10) {
end = strlen(arr[1]);
}
digital->name[end] = '\0';
//digital[0].name = arr[1];
/**
* @brief Definido as outras propriedades do sensor
*
*/
digital->value = 0;
digital->id = atoi(arr[2]);
digital->type = Digital;
//printf("cmd: %s\n", digital[0].name);
printf("Nome: %s\n", digital->name);
printf("Endereço: %i\n", digital->id);
/**
* Limpando substrings
*/
for (int i = 0; i < 11; i++) {
arr[0][i] = '\0';
arr[1][i] = '\0';
arr[2][i] = '\0';
}
//printf("nome %s", arr[1]);
return 1;
}
// Debounce
int isPressed(int btt){
if(digitalRead(btt) == 0){
await(100);
if(digitalRead(btt) == 0){
printf("Pressed %d! \n", btt);
return 1;
}
}
return 0;
}
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.