Tag: pic

Palavra-chave
Destaque/Sem destaque
Resolvida/Não Resolvida
Aberta/Encerrada
0 votos
2k visualizações

Olá pessoal, procuramos free lancer com domínio sistemas de leitura/interpretação e programação em SMD sistemas microcontroladores CI PIC das linhas 16C711/12 e 16F716 conhecimentos em Eprom/Assembly.

Objetivo: interpretar comandos da placa para novo projeto.

aguardamos seu contato.

  • Walter Pinto perguntada 4 anos atrás
  • última atividade 4 anos atrás
0 votos
1k visualizações

Saudações,
Estou fazendo um projeto com o sensor de temperatura e umidade DHT22 junto com o PIC 16F628A, porém percebi que o problema está na função que lê os bits do sensor. Alguém poderia me indicar onde está o problema? O meu LCD não aparece nada, somente aparece se eu comentar as linhas que recebem readData(). Esse é o código do PIC:

/*********************** FUNÇOES DO SENSOR DHT22 ****************************************************/
//Envia sinal de start para o sensor
void startSignal() {
set_tris_a(0b00000000); //Configura RA1 como output
output_low(DATA); //Pino DATA envia 0 para o sensor
delay_ms(25);
output_high(DATA); //Pino DATA envia 1 para o sensor
delay_us(30);
set_tris_a(0b00000010); //Configura RA1 como input
}

//Checa resposta do sensor
unsigned short checkResponse() {
delay_us(40);
if(!input(DATA)) delay_us(80);
if(input(DATA)) {
delay_us(50);
return 1;
}
return 0;
}

//Função para ler os dados do sensor DHT22
unsigned short readData() {
unsigned short j=0, contaTempo=0, dataByte=0;

if(timeOut) break;

for(j = 0; j <= 7; j++) {
    contaTempo = 0;
    while(!input(DATA)){ // Espera até que a porta DATA vá para High
        delay_us(1);
        contaTempo++;
        if(contaTempo > 100) {
            timeOut = 1; 
            break;
        }
    }

    delay_us(40);

    if(!input(DATA)) { //Se continuar em Low apos 40us, bit = 0

        dataByte &= ~(1 << (7 - j)); //Zera bit (7-j)
    }
    else { //Se estiver em High apos 40us, bit = 1
        dataByte |= (1 << (7 - j)); //Seta bit (7-j)

        while(input(DATA)){ //Espera até que a porta DATA vá para Low
            delay_us(1);
            contaTempo++;
            if(contaTempo > 100) {
                timeOut = 1; 
                break;
            }
        }
    }
}
return dataByte;

}
/***************************************************************************/

//PROGRAMA PRINCIPAL
void main(void) {
set_tris_a(0b00000000);
set_tris_b(0b00000000);
output_a(0);
output_b(0);
setup_ccp1(CCP_OFF);
lcd_init(); //Inicializa LCD
printf(lcd_putc, “\f”); //Limpa LCD

while(TRUE) {

    delay_ms(2000);
    timeOut = 0;
    //inicia leitura do sensor
    startSignal();
    if(checkResponse()) {

        umidade_byte1 = readData();     //primeiro byte da umidade: bit 15 ~ bit 8
        umidade_byte2 = readData();     //segundo byte da umidade bit: 7 ~ bit 0
        temperatura_byte1 = readData(); //primeiro byte da temperatura: bit 15 ~ bit 8
        temperatura_byte2 = readData(); //segundo byte da temperatura: bit 7 ~ bit 0
        paridade_byte = readData();     //byte da paridade bit: 7 ~ bit 0

        if(timeOut){                           // If reading takes long time
            printf(lcd_putc,"\f");                       // LCD clear
            lcd_gotoxy(2, 6);                     // Go to column 5 row 1
            printf(lcd_putc, "Time out!");
        }
        else {
            if(paridade_byte == ((umidade_byte1 + umidade_byte2 + temperatura_byte1 + temperatura_byte2) & 0xFF)) {
                umidade_2byte = umidade_byte1;
                umidade_2byte = (umidade_2byte << 8) | umidade_byte2;
                temperatura_2byte = temperatura_byte1;
                temperatura_2byte = (temperatura_2byte << 8) | temperatura_byte2;

                if(temperatura_2byte > 0x8000) { //Se temperatura for maior que 1000 0000 (binario)
                    temperatura_2byte &= 0x7FFF; //Temperatura recebe 14bits, pois o bit 15 representa sinal
                    temperatura =  temperatura_2byte;
                    temperatura = ( temperatura / 10) * -1; //Corrige temperatura
                    sinal = '-';
                }
                else {
                    sinal = ' ';
                    temperatura =  temperatura_2byte;
                    temperatura = ( temperatura / 10) * -1; //Corrige temperatura
                }
                umidade = umidade_2byte;
                umidade = umidade / 10; //Corrige umidade

                lcd_gotoxy(1,5);                                                   // Define o ponto de inicio da frase L1C5                                             
                printf(lcd_putc,"Temp: %02.1f \xDFC", temperatura);                // Escreve no LCD Temperatura em Celsius     [printf(lcd_putc, "%f " "\xdf" "C", temperatura)];
                lcd_gotoxy(2,5);                                                   // Define o ponto de inicio da frase L2C5
                printf(lcd_putc,"Temp: %02.1f \xDFF", ((temperatura * 1.8) + 32)); // Escreve no LCD Temperatura em Fahrenheit
                /*lcd_gotoxy(3,5);                                                   // Define o ponto de inicio da frase L3C5
                printf(lcd_putc,"Temp: %02.1f \xDFK", temperatura + 273.15);       // Escreve no LCD Temperatura em Kelvin*/
                lcd_gotoxy(4,5);                                                   // Define o ponto de inicio da frase L4C5
                printf(lcd_putc,"Umid: %02.1f %c", umidade, 0x25);                 // Escreve no LCD Umidade em %
            }
            else {
                printf(lcd_putc, "\f");              // Limpa LCD
                lcd_gotoxy(2, 3);                    // Define o ponto de inicio da frase L2C3
                printf(lcd_putc, "Checksum Error!"); // Escreve no LCD (Erro de paridade dos dados)
            }
        }
    }
    else {
        lcd_gotoxy(2, 3);                     // Define o ponto de inicio da frase L2C3
        printf(lcd_putc, "  No response   "); // Escreve no LCD
        lcd_gotoxy(3, 3);                     // Define o ponto de inicio da frase L2C3
        printf(lcd_putc, "from the sensor");  // Escreve no LCD
    }
}

}

0 votos
0 respostas
1k visualizações

Saudações,
Não estou conseguindo enviar informações para a plataforma ThingSpeak, as funções do DHT22 estão funcionando perfeitamente pois já testei com LCD, e a configuração do Timer1 também pois já testei separado.
Mas nesse meu projeto algo está errado porque não consigo enviar dados de umidade e temperatura para meu canal no ThingSpeak.
Liguei a porta Rx do ESP8266 na porta Tx do PIC já com divisor de tensão de 3.3V. A porta Tx do ESP8266 liguei na porta RX do PIC. E as portas GPIO0, RST, CH_PD e VCC estão conectados no 3.3v. Porta GND está no terra.
O LED (BREATHING_LIGHT) está piscando aleatoriamente, porém a configuração do Timer1 está correta.
Espero que alguém possa me dar uma luz sobre o que pode estar errado, notem que alterei as informações de “SSID”, “SENHA_WIFI” e “CHAVE” por motivos de segurança:

//Programa : PIC na IoT com ThingSpeak e DHT22 usando PIC16F628A
//Autor : Marcos Roberto Baungartner RA: 9902012531
//Data 29/04/2017

//Diretivas para o pré-processador

include <16F628A.h> //Inclui Header do PIC16F628A

FUSES HS //Oscilador Interno e portas como IO

FUSES NOMCLR //Master Clear (Reset)

FUSES NOWDT //Watch Dog Timer

FUSES PUT //Power-Up Timer

FUSES BROWNOUT //Resetar quando detectar brownout

FUSES NOLVP //Gravação em baixa-tensão

FUSES NOCPD //Proteção do memória EEPROM

FUSES NOPROTECT //Proteção para leitura do código

use delay(clock = 20000000) //Clock de 4MHz (clock útil de 1MHz)

use rs232(baud=115200,parity=N,xmit=PIN_B2,rcv=PIN_B1,bits=8,ERRORS)

priority INT_TIMER1, INT_RDA //INT_EXT,//ordem de prioridade das interrupções (ordem decrescente de prioridade)

//defines gerais:

define DATA PIN_A0

define BREATHING_LIGHT PIN_A1

define TAMANHO_COMANDO_MODO_ESTACAO sizeof(ComandoModoEstacao);

define TAMANHO_COMANDO_CONECTA_ROTEADOR sizeof(ComandoConectaRoteador);

define TAMANHO_COMANDO_MULTI_CONEXOES sizeof(ComandoMultiplasConexoes);

define TAMANHO_COMANDO_HTTP_THINGSPEAK sizeof(ComandoConectaHTTPThingspeak);

define TAMANHO_COMANDO_SEND_THINGSPEAK sizeof(ComandoSendDadoThingspeak);

define VALOR_INICIAL_TIMER1 3036

define ESTADO_MODO_ESTACAO 0

define ESTADO_CONECTA_ROTEADOR 1

define ESTADO_MULTI_CONEXOES 2

define ESTADO_HTTP_THINGSPEAK 3

define ESTADO_SEND_THINGSPEAK 4

define TEMPO_SEND_THINGSPEAK 30 //envio para o thingspeak é feito em um período de 30s

define VALOR_MAX_CONTADOR_TEMPO_THINGSPEAK TEMPO_SEND_THINGSPEAK*20

define SIM 1

define NAO 0

char ContadorIntTimer;
long ContadorEnvioDadosThingspeak;
volatile char EstadoMaquinaESP8266;
char DeveEnviarDadoThingspeak;
unsigned char ContadorIntTimerSensor, umidade_byte1, umidade_byte2, temperatura_byte1, temperatura_byte2, paridade_byte, timeOut;
unsigned long temperatura_2byte, umidade_2byte;
float temperatura = 0, umidade = 0;

//prototypes
//void ConfigInterrupcaoEXT(void);
void ConfigInterrupcaoUART(void);
void ConfigTimer1(void);
void ESP8266SetaModoEstacao(void);
void ESP8266ConectaRoteador(void);
void ESP8266MultiplasConexoes(void);
void ESP8266HTTPThingspeak(void);
void ESP8266PreparaEnvioHTTP(void);
void ESP8266SendThingspeak(char valor);
void SetupESP8266(void);

/*********************** FUNÇOES DO SENSOR DHT22 ****************************************************/
//Envia sinal de start para o sensor
void startSignal() {
set_tris_a(0b00000000); //Configura RA0 como output
output_low(DATA); //Pino DATA envia 0 para o sensor
delay_ms(20);
output_high(DATA); //Pino DATA envia 1 para o sensor
delay_us(30);
set_tris_a(0b00000001); //Configura RA0 como input
}

//Checa resposta do sensor
unsigned char checkResponse() {
delay_us(40);

if(!input(DATA)) {
    delay_us(80);

    if(input(DATA)) {
        delay_us(40);
        return 1;
    }
    else
        return 0;
}

}

//Função para ler os dados do sensor DHT22
unsigned char readData() {
unsigned char j=0, dataByte=0;

if(timeOut) break;

for(j = 0; j <= 7; j++) {
    while(!input(DATA)){              // Espera até que a porta DATA vá para High
        delay_us(1);
    }

    delay_us(30);

    if(!input(DATA)) {               //Se continuar em Low apos 30us, bit = 0

        dataByte &= ~(1 << (7 - j)); //Zera bit (7-j)
    }
    else {                           //Se estiver em High apos 30us, bit = 1
        dataByte |= (1 << (7 - j));  //Seta bit (7-j)
        while(input(DATA)){          //Espera até que a porta DATA vá para Low
            delay_us(1);
        }
    }
}
return dataByte;

}
/***************************************************************************/

/*
//tratamento da interrupção externa

int_EXT

void EXT_isr(void) {
//debouncing
delay_ms(10);
// código caso necessite de uma interrupção externa
}
*/

//tratamento da interrupção serial

INT_RDA

void serial_isr() {
char ByteLido;
ByteLido = getc();
}

//tratamento da interrupção de timer

INT_TIMER1

void TrataTimer1() {
ContadorIntTimer++;
ContadorEnvioDadosThingspeak++;
ContadorIntTimerSensor++;
//contabiliza tempo de envio do dado ao thingspeak
if (ContadorEnvioDadosThingspeak >= VALOR_MAX_CONTADOR_TEMPO_THINGSPEAK)
DeveEnviarDadoThingspeak = SIM;

//controla tempo para piscada do breathing light
if (ContadorIntTimer >= 20) {   //cada "tick" do timer1 tem 0,05s. Logo, 20 "tiks" equivalem a 1 segundo
    //troca o estado da saída do breathing light
    output_toggle(BREATHING_LIGHT);
    ContadorIntTimer = 0;
}

//controla tempo para leitura do sensor

while(ContadorIntTimerSensor >= 40) {
    //inicia leitura do sensor
    startSignal();
    if(checkResponse()) {
        umidade_byte1 = readData();     //primeiro byte da umidade: bit 15 ~ bit 8
        umidade_byte2 = readData();     //segundo byte da umidade bit: 7 ~ bit 0
        temperatura_byte1 = readData(); //primeiro byte da temperatura: bit 15 ~ bit 8
        temperatura_byte2 = readData(); //segundo byte da temperatura: bit 7 ~ bit 0
        paridade_byte = readData();     //byte da paridade bit: 7 ~ bit 0
        if(paridade_byte == (umidade_byte1 + umidade_byte2 + temperatura_byte1 + temperatura_byte2) & 0xFF) {
            umidade_2byte = umidade_byte1;
            umidade_2byte = (umidade_2byte << 8) | umidade_byte2;
            temperatura_2byte = temperatura_byte1;
            temperatura_2byte = (temperatura_2byte << 8) | temperatura_byte2;
            if(temperatura_2byte > 0x8000) { //Se temperatura for maior que 1000 0000 (binario)
                temperatura_2byte &= 0x7FFF; //Temperatura recebe 14bits, pois o bit 15 representa sinal
                temperatura = temperatura_2byte;
                temperatura *= -1;
            }
            else {
                temperatura = temperatura_2byte;
            }
            umidade = umidade_2byte;

            ContadorIntTimerSensor = 0;
        }
    }
}

//configura timer e religa interrupções
set_timer1(VALOR_INICIAL_TIMER1);

}

//função de configuração da interrupção UART
//parametros: nenhum
//saida: nenhum
void ConfigInterrupcaoUART(void) {
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
}

//função de configuração da interrupção externa
//parametros: nenhum
//saida: nenhum
/*
void ConfigInterrupcaoEXT(void) {
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
ext_int_edge(L_TO_H);
}
*/

//função de configuração do Timer1
//parametros: nenhum
//saida: nenhum
void ConfigTimer1(void) {
// – Frequencia do oscilador interno (20000000/4) = 5Mhz (por default, o PIC funciona a 1/4 da frequencia de clock estabelecida)
// – Se o Timer1 tem 16 bits, seu valor máximo de contagem é 0xFFFF (65535)
// – Com 5MHz de frequencia util, cada ciclo de máquina terá, em segundos: 1 / 5MHz = 0,0000002 (0,2us)
// – Utilizando o prescaler do microcontrolador em 4 (ou seja, a frequencia util do timer1 é 1/4 da frequencia util do pic), temos:
// Periodo minimo “contável” pelo Timer1 = (1 / (5MHz/4)) = 0,0000008 (0,8us)
// – Logo, a cada 16 bits contados, teremos: 65536 * 0,8us = 0,0524288s
// – visando maior precisão, sera feito um timer de 0,05s. Logo:
// 0,0524288s — 65536
// 0,05s — x x = 62500
// Logo, o valor a ser setado no timer1 é: 65536 – 62500 = 3036 (Aplicar esse numero na linha 6 do pic_esp8266.h)
ContadorIntTimer = 0;
setup_timer_1(T1_INTERNAL| T1_DIV_BY_4);
set_timer1(VALOR_INICIAL_TIMER1);
enable_interrupts(INT_TIMER1);
enable_interrupts(GLOBAL);
}

//função que configura o ESP8266 para operar em modo estação (se conecta em um roteador)
//parametros: nenhum
//saida: nenhum
void ESP8266SetaModoEstacao(void) {
puts(“AT+CWMODE=1\r\n\0”);
delay_ms(500);
}

//função que conecta o ESP8266 em um roteador
//parametros: nenhum
//saida: nenhum
void ESP8266ConectaRoteador(void) {
puts(“AT+CWJAP=\”SSID\”,\”SENHA_WIFI\”\r\n\0″);
delay_ms(7000);
}

//função que configura o ESP8266 para operar com multiplas conexoes
//parametros: nenhum
//saida: nenhum
void ESP8266MultiplasConexoes(void) {
puts(“AT+CIPMUX=1\r\n\0”);
delay_ms(500);
}

//função que conecta o ESP8266 via HTTP ao Thingspeak
//parametros: nenhum
//saida: nenhum
void ESP8266HTTPThingspeak(void) {
puts(“AT+CIPSTART=4,\”TCP\”,\”184.106.153.149\”,80\r\n\0″);
delay_ms(5000);
}

//função que prepara o ESP8266 para enviar dados via HTTP ao Thingspeak
//parametros: nenhum
//saida: nenhum
void ESP8266PreparaEnvioHTTP(void) {
puts(“AT+CIPSEND=4,46\r\n\0”);
delay_ms(500);
}

//função que envia um dado ao Thingspeak
//parametros: dado (número de 1 byte)
//saida: nenhum
void ESP8266SendThingspeak(float valor1, float valor2) {
char ComandoEnvioDadoHTTP[71];

memset(ComandoEnvioDadoHTTP,0,sizeof(ComandoEnvioDadoHTTP));
sprintf(ComandoEnvioDadoHTTP,"GET /update?key=CHAVE&field1=%.1f&field2=%.1f\r\n\0", valor1, valor2);
puts(ComandoEnvioDadoHTTP);
delay_ms(5000);

}

//função que inicializa, configura e conecta ESP8266 ao roteador
//parametros: nenhum
//saida: nenhum
void SetupESP8266(void) {
ESP8266SetaModoEstacao();
ESP8266ConectaRoteador();
ESP8266MultiplasConexoes();
}

//programa principal
void main(void) {

//inicializa maquina de controle da ESP8266
EstadoMaquinaESP8266 = ESTADO_MODO_ESTACAO;

//configura Timer1
ConfigTimer1();

//inicializa contador de tempo de envio de dados para o Thingspeak
ContadorEnvioDadosThingspeak = 0;
DeveEnviarDadoThingspeak = NAO;

//configuração das interrupções (UART e interrupção externa)
ConfigInterrupcaoUART();
//ConfigInterrupcaoEXT();

//inicializa, configura e conecta ESP8266 ao roteador
SetupESP8266();

while(TRUE) {

    output_high(PIN_B3);
    if (DeveEnviarDadoThingspeak == SIM) {

        ESP8266HTTPThingspeak();
        ESP8266PreparaEnvioHTTP();
        ESP8266SendThingspeak(umidade, temperatura);
        ContadorEnvioDadosThingspeak = 0;
        DeveEnviarDadoThingspeak = NAO;
    }
}

}

0 votos
0 respostas
378 visualizações

Bom dia amigos, gostaria de saber se alguem aqui possui experiencia em ISOBUS, estou querendo implementar em meu equipamento o ISOBUS para nao precisar mais ter uma tela, e sim usar o VT do proprio trator, li alguns documentos, artigos porem nao evolui, nao sei se alguem tem algum exemplo de como fazer uma tela simples…

Mostrando 4 resultados