Fórum

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

Ola pessoal.
Eu estou precisando de um circuito que gere 0,65V para aplicar entre dois sensores. Eu sei que não deve ter baterias tão pequenas assim, e também essa tensão sera aplicada varias vezes ao longo do dia então é necessário que tenha uma fonte constante. Meu professor me deu a ideia de usar um regulador de tensão, mas pesquisando por ai, só achei o CI 78xx que tem como menor tensão de saída 5V. Então como eu faço pra consegui uma tensão fixa tão pequena?
Obrigada pela atenção!

  • vera63 perguntada 23 horas atrás
0 votos
0 respostas
85 visualizações

Bom dia pessoal, estou utilizando um triac em um circuito indutivo, e com isso ele não chaveia como deveria, pois como a corrente está defasada da tensão em 90º, o triac acaba conduzindo muito mais do que deveria, e alguns pulsos de disparo nem são percebidos.
Vocês conhecem alguma técnica para forçar o desligamento dos triacs nessa situação?

Obrigado.

0 votos
139 visualizações

Gostaria de saber como comprar o mikroc e qual o valor. Estou perguntando isso porque vi num site por R$ 850,00 e em outro por R$ 70,00. É uma diferença muito grande.

  • MauroMarinho21 perguntada 3 semanas atrás
  • última atividade 5 dias atrás
0 votos
0 respostas
137 visualizações

Preciso da placa de desenvolvimento ARM :Fs9200v4.0 EURONAVY, alguem sabe como conseguir aqui no Brasil?Consegui na china neste site http://www.ucdragon.cn/ProductsSt/237.html

0 votos
200 visualizações

Olá,estou com dificuldades em programar minha placa SK-S7G2,preciso de ajuda pois não conheço essa placa,procurei pelo programa que é usado para acessar a placa e não encontrei,preciso de alguns exemplos para eu testar.

  • fabsec3561 perguntada 4 semanas atrás
  • última atividade 4 semanas atrás
0 votos
0 respostas
133 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
156 visualizações

Olá a todos,

Tenho experiência em programar em C e em outras linguagens. Recentemente comecei a programa no pic16f690. E uma coisa que me está a deixar bastante confuso e até chateado é o facto de existir aquele ciclo while! Basicamente está sempre a ser executado. Por isso, se quiser atribuir sequencia de comandos no ciclo while terei que criar variáveis de validação, certo?
Alguma dica para ajudar a estruturar o código no ciclo while? Principalmente para quem está habituado a programar em outros tipos de ambientes?

  • ederesistor57 perguntada 1 mês atrás
  • última atividade 5 dias atrás
0 votos
0 respostas
150 visualizações

Olá amigos, estou fazendo um projeto e gostaria muito da ajuda de vocês se possível. Estou ainda estou aprendendo sobre o assunto mas acredito que saiba dos conceitos básicos para começar.
Estou realizando o controle da velocidade de uma bomba de água com um sensor ultrasom (HC-SR04): possuo um tanque de água que quero elevar essa água para um tanque superior e a variação da velocidade da bomba seria de acordo com o nível do tanque inferior. A bomba de água é de 12v então estou usando um driver Ponte H L298N para controlar. A variação simples dessa velocidade já realizei como teste, simples conversões dos valores do sensor para a bomba, mas agora gostaria de fazer isso com a biblioteca PID do Arduino, e encontrei alguns problemas. Segue a lógica que criei até agora, não está finalizada por só falta a parte do direcionamento do valor do sensor para o Input do PID:

  • PID Basic Example for 12V Pump – By Edes
  • Reading analog input 0 to control analog PWM output 3
  • Esse exemplo foi adaptado para funcionar com uma bomba 12V,
  • um driver L298N e um ultrassonico

include <PID_v1.h> //Carrega a biblioteca PID

include <Ultrasonic.h> //Carrega a biblioteca do sensor ultrassonico

define PIN_INPUT 0 //Define os pinos para Input e Output do PID

define PIN_OUTPUT 3

define pino_trigger 4 //Define os pinos para o trigger e echo do ultrasom

define pino_echo 5

int IN1 = 7; //Saídas digitais 3 e 4 ligadas à entrada da Ponte H
int IN2 = 8;
//int variacV_PonteH = 6; //Saída PWM ligada à  entrada da Ponte H p/ variação de tensão do motor

int cmMsec, inMsec; //variáveis de conversão e visualização no monitor serial

//Define Variables we’ll be connecting to
double Setpoint, Input, Output;

//Specify the links and initial tuning parameters
double Kp=2, Ki=5, Kd=1;
PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);

//Inicializa o sensor nos pinos definidos
Ultrasonic ultrasonic(pino_trigger, pino_echo);

void setup()
{
//initialize the variables we’re linked to
Input = analogRead(PIN_INPUT);
Setpoint = 100;

//turn the PID on
myPID.SetMode(AUTOMATIC);

//Inicializa Pinos da bomba/motor e Ponte H
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
//pinMode(variacV_PonteH, OUTPUT);

//Inicia a serial com um baud rate de 9600
Serial.begin(9600);
}

void loop()
{
Input = analogRead(PIN_INPUT);
myPID.Compute();
analogWrite(PIN_OUTPUT, Output);

//Motor
//Sentido Horario:
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);

//Sensor Ultrassonico
//Le as informaçoes do sensor, em cm e pol
int cmMsec, inMsec;
long microsec = ultrasonic.timing();
cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);

//imprimi os valores no monitor serial:
Serial.print(“Distancia em cm: “);
Serial.print(cmMsec);
Serial.print(” – Distancia em polegadas: “);
Serial.print(inMsec);
Serial.print(” – “);
Serial.print(Input);
Serial.print(” – “);
Serial.println(Output);
delay(500);
}

Meu problema: Já tentei de diversas maneiras realizar alguma conversão/adaptação/leitura do valor do sensor para injetar na porta analógica que o PID utiliza (PIN_INPUT – A0) , porém sem sucesso. Cogitei a possibilidade de ter feito leituras erradas porque não se trata de um valor PWM vindo do sensor e sim um pulso, realizei conversões com o comando “map” para ver se ajudava mas sem sucesso também. Acredito que posso ter feito algum erro bobo e não enxerguei o que realmente devo fazer. Pensei em utilizar o conversor D/A MCP4725, mas ainda da não tenho conhecimento para usá-lo. Se alguém puder me dar uma luz, agradecerei muito.
Desculpe ter prolongado demais o post mas queria tentar explicar o melhor possível, e desculpe se postei na categoria errada. Agradeço desde já!

0 votos
0 respostas
169 visualizações

Olá pessoal,

Necessito ajuda! O problema é:

O usuário necessita acessar uma página web do webserver instalado no esp8266 e conectado como client.

Para isso é necessário conhecer o IP atribuido pelo DHCP do router da rede.

Estou tentando usar a biblioteca mDNS para acessar o device como “mydevice.local”.

Isso não está funcionando. (Mesmo utilizando Bonjour na Win 10, e tambem não funciona no Android 6.0)

Alguém sugere uma outra técnica ou método atingir para o mesmo propósito?

Obrigado

Mostrando 1 - 10 de 297 resultados