Thiago Felipe Soares Gonçalves

Boa Noite, estou trabalhando em um projeto com o objetivo de fazer um relógio usando NodeMCU com sincronização da hora usando NTP. porém estou com algum erro no código que usei para fazer a sincronização estão dando horário totalmente diferentes e como não entendo muito de NTP queria ajuda para encontrar o problema. Segue o código utilizado. #include <NTPClient.h>//Biblioteca do NTP. #include <WiFiUdp.h>//Biblioteca do UDP. #include <ESP8266WiFi.h>//Biblioteca do WiFi. WiFiUDP udp;//Cria um objeto "UDP". NTPClient ntp(udp, "pool.ntp.br", -3 * 3600, 60000);//Cria um objeto "NTP" com as configurações. #define led D4//Define o LED ao pino D4. String hora;//Váriavel que armazenara o horario do NTP. void setup() { Serial.begin(9600);//Inicia a comunicação serial. pinMode(led, OUTPUT);//Define o pino como saida. digitalWrite(led, 1);//Apaga o LED. WiFi.mode(WIFI_STA); WiFi.begin("Copel71", "36927100");//Conecta ao WiFi. delay(2000);//Espera a conexão. ntp.begin();//Inicia o NTP. ntp.forceUpdate();//Força o Update. } void loop() { hora = ntp.getFormattedTime();//Armazena na váriavel HORA, o horario atual. Serial.println(hora);//Printa a hora já formatada no monitor. if (hora == "19:23:30")//Se a hora atual for igual à que definimos, irá acender o led. { digitalWrite(led, 0);//Acende } delay(1000);//Espera 1 segundo. } O horário que fiz o teste era 20:01 porém o print do NodeMCU mostra 03:52.

Vi só agora @Isadora Ferraz, vou testar do seu jeito, estou tendo outros problemas no projeto tipo estou de variável kkkkkk umas incompatibilidades loucas nem sei explicar direito.

Consegui resolver o problema ontem de madrugada, aumentei o clock de 4Mhz para 16Mhz, alem disso fiz uma instrução parecida com o que a @Isadora Ferraz mostrou. Alias o microcontrolador que estou usando é um ATMEGA328P e o que estou fazendo é um pov com velocidade variável, fazendo a projeção manter sua forma mesmo alterando a velocidade de rotação. data = 0b01001001; if(data & 0b00000001) setb(PB4); else clrb(PB4); if(data & 0b00000010) setb(PB3); else clrb(PB3); if(data & 0b00000100) setb(PB2); else clrb(PB2); if(data & 0b00001000) setb(PB1); else clrb(PB1); if(data & 0b00010000) setb(PB0); else clrb(PB0); if(data & 0b00100000) setd(PD7); else clrd(PD7); if(data & 0b01000000) setd(PD6); else clrd(PD6); Basicamente comparo o byte com uma mascara se o resultado for verdadeiro ele acendera o led que quero. Funcionou bem mas tive que fazer mudanças no hardware e no código para funcionar. Lembre aos que quiserem fazer projetos assim, faça a sua tabela alfanumérica coincidir com a disposição dos led em seu hardware facilita muito a vida.

Infelizmente o minimalismo se faz necessário, pois a velocidade com que ele vai processar isso influencia na projeção da minha imagem. Vou continuar procurando uma solução que inverta o byte como já mencionado. Se encontrar posto aqui para futuras consultas.

Infelizmente assim não vai dar, pois eu já tenho uma lista de vetores aonde cada célula do meu vetor é um byte, assim: const char A_seq[5] = {0x7e,0x09,0x09,0x09,0x7e}; Eu leio no meu código um byte por vez, assim PORTB = 0x7e; Assim consigo acender leds numa sequencia especifica, porém preciso inverter esse byte para acender a sequencia corretamente. A ideia é inverter ele em seguida deslocá-lo assim consigo por parte dele em um PORT e parte em OUTRO. Exemplo: Original - 0b01001110 Inverto - 0b01110010 data = 0b01110010; PORTB = data>>3; //0b00001110 PORTD = data<<5; //0b01000000 A ideia é essa.

Boa noite, estou com a seguinte questão tenho um conjunto de bits e preciso inverte-los da seguinte maneira. Original - 0b01001111 Invertido - 0b11110010 A segunda questão é preciso deslocar esses bits depois de invertidos da seguinte maneira. Invertido - 0b11110010 Deslocado - 0b11001000 No deslocamento eu posso perder os bits deslocados não a problema. Se alguém saber aonde posso achar algo que me ajude a fazer isso eu ficaria muito agradecido.

@Isadora Ferraz Então eu testei não deu muito certo, vou reescrever os bits pra ficar certo.

Pessoal o que vocês sugeriram deu certo, porém surgiu um probleminha, eu preciso inverter os bytes que contem a informação dos leds que serão acessos da seguinte forma. 76543210 76543210 data = 0x00001001 ====>> data = 0x10010000 E ai alguma sugestão?

Vou fazer o que vocês estão sugerindo mesmo. Parece que vau ficar melhor assim.

Não estou confundindo, a pessoa que desenvolveu o código é um americano e ele fez para o PIC16F628. Nessa parte do código: rom char* A_seq = {0x7e,0x09,0x09,0x09,0x7e}; rom char* B_seq = {0x7f,0x49,0x49,0x49,0x3e}; rom char* C_seq = {0x3e,0x41,0x41,0x41,0x22}; rom char* D_seq = {0x7f,0x41,0x41,0x41,0x3e}; rom char* E_seq = {0x7f,0x49,0x49,0x49,0x41}; rom char* F_seq = {0x7f,0x09,0x09,0x09,0x01}; ... Ele grava uma tabela de caracteres na memoria EEPROM do microcontrolador durante a gravação do microcontrolador. Depois de gravado ele só recupera esses valores da EEPROM, gostaria de fazer o mesmo mas com o ATMEGA328P.

Então @Isadora Ferraz ele utiliza o PORTA e PORTB, pois não tem pinos suficientes, no caso do ATMEGA328P daria pra usar o PORTB ou PORTC inteiro como você fez ali, pois ele possui pinos suficientes. O programa funciona perfeitamente para o PIC, mas é necessário mudar algumas coisas nele para funcionar no AVR, primeiro queria colocar aquela tabela com os caracteres na memoria EEPROM na gravação do microcontrolador da mesma maneira que ele fez e omo o ATMEGA tem mais memoria EEPROM eu vou colocar mais caracteres depois. Eu ainda não fiz o esquemático kkkk mas faço hj e posto mais tarde. kkk

Bom dia a todos, estou querendo portar um código em C escrito para o microcontrolador PIC16F628 para um microcontrolador AVR ATMEGA328P. O código que quero portar é de um POV (display rotativo), como não tenho todo o conhecimento necessário pensei que alguém poderia me ajudar. Segue o código: #include <system.h> #include <eeprom.h> //Target PIC16F628 configuration word #pragma DATA _CONFIG, 0x3F18 //Set clock frequency #pragma CLOCK_FREQ 4000000 unsigned char message[60]; unsigned char data; unsigned char address; rom char* A_seq = {0x7e,0x09,0x09,0x09,0x7e}; rom char* B_seq = {0x7f,0x49,0x49,0x49,0x3e}; rom char* C_seq = {0x3e,0x41,0x41,0x41,0x22}; rom char* D_seq = {0x7f,0x41,0x41,0x41,0x3e}; rom char* E_seq = {0x7f,0x49,0x49,0x49,0x41}; rom char* F_seq = {0x7f,0x09,0x09,0x09,0x01}; rom char* G_seq = {0x3e,0x41,0x41,0x49,0x7a}; rom char* H_seq = {0x7f,0x08,0x08,0x08,0x7f}; rom char* I_seq = {0x00,0x41,0x7f,0x41,0x00}; rom char* J_seq = {0x20,0x40,0x41,0x3f,0x01}; rom char* K_seq = {0x7f,0x08,0x14,0x22,0x41}; rom char* L_seq = {0x7f,0x40,0x40,0x40,0x40}; rom char* M_seq = {0x7f,0x02,0x04,0x02,0x7f}; rom char* N_seq = {0x7f,0x02,0x04,0x08,0x7f}; rom char* O_seq = {0x3e,0x41,0x41,0x41,0x3e}; rom char* P_seq = {0x7f,0x09,0x09,0x09,0x06}; rom char* Q_seq = {0x3e,0x41,0x51,0x21,0x5e}; rom char* R_seq = {0x7f,0x09,0x19,0x29,0x46}; rom char* S_seq = {0x46,0x49,0x49,0x49,0x31}; rom char* T_seq = {0x01,0x01,0x7f,0x01,0x01}; rom char* U_seq = {0x3f,0x40,0x40,0x40,0x3f}; rom char* V_seq = {0x1f,0x20,0x40,0x20,0x1f}; rom char* W_seq = {0x3f,0x40,0x38,0x40,0x3f}; rom char* X_seq = {0x63,0x14,0x08,0x14,0x63}; rom char* Y_seq = {0x03,0x04,0x78,0x04,0x03}; rom char* Z_seq = {0x61,0x51,0x49,0x45,0x43}; rom char* a_seq = {0x30,0x4a,0x4a,0x4a,0x7c}; //a rom char* b_seq = {0x7f,0x50,0x48,0x48,0x30}; //b rom char* c_seq = {0x38,0x44,0x44,0x44,0x20}; //c rom char* d_seq = {0x38,0x44,0x44,0x48,0x7f}; //d rom char* e_seq = {0x38,0x54,0x54,0x54,0x18}; //e rom char* f_seq = {0x08,0x7e,0x09,0x01,0x02}; //f rom char* g_seq = {0x06,0x49,0x49,0x49,0x3f}; //g rom char* h_seq = {0x7f,0x08,0x04,0x04,0x78}; //h rom char* i_seq = {0x00,0x44,0x7d,0x40,0x00}; //i rom char* j_seq = {0x20,0x40,0x44,0x3d,0x00}; //j rom char* k_seq = {0x7f,0x10,0x28,0x44,0x00}; //k rom char* l_seq = {0x00,0x41,0x7f,0x40,0x00}; //l rom char* m_seq = {0x7c,0x04,0x08,0x04,0x78}; //m rom char* n_seq = {0x7c,0x08,0x04,0x04,0x78}; //n rom char* o_seq = {0x38,0x44,0x44,0x44,0x38}; //o rom char* p_seq = {0x7c,0x14,0x14,0x14,0x08}; //p rom char* q_seq = {0x08,0x14,0x14,0x18,0x7c}; //q rom char* r_seq = {0x7c,0x08,0x04,0x04,0x08}; //r rom char* s_seq = {0x48,0x54,0x54,0x54,0x20}; //s rom char* t_seq = {0x04,0x3f,0x44,0x40,0x20}; //t rom char* u_seq = {0x3c,0x40,0x40,0x20,0x7c}; //u rom char* v_seq = {0x1c,0x20,0x40,0x20,0x1c}; //v rom char* w_seq = {0x3c,0x40,0x30,0x40,0x3c}; //w rom char* x_seq = {0x44,0x28,0x10,0x28,0x44}; //x rom char* y_seq = {0x0c,0x50,0x50,0x50,0x3c}; //y rom char* z_seq = {0x44,0x64,0x54,0x4c,0x44}; //z rom char* n0_seq = {0x3e,0x51,0x49,0x45,0x3e}; rom char* n1_seq = {0x00,0x42,0x7f,0x40,0x00}; rom char* n2_seq = {0x42,0x61,0x51,0x49,0x46}; rom char* n3_seq = {0x22,0x41,0x49,0x49,0x36}; rom char* n4_seq = {0x18,0x14,0x12,0x7f,0x10}; rom char* n5_seq = {0x27,0x45,0x45,0x45,0x39}; rom char* n6_seq = {0x3e,0x49,0x49,0x49,0x30}; rom char* n7_seq = {0x01,0x71,0x09,0x05,0x03}; rom char* n8_seq = {0x36,0x49,0x49,0x49,0x36}; rom char* n9_seq = {0x06,0x49,0x49,0x29,0x1e}; rom char* exp_seq = { 0x00,0x0,0x5f,0x0,0x0}; rom char* colon_seq= { 0x00,0x36,0x36,0x0,0x0}; rom char* space_seq ={ 0,0,0,0,0 }; rom char* heart_seq = {0x0c,0x1e,0x3c,0x1e,0x0c}; rom char* asterisk_seq = {0x2a,0x1c,0x7f,0x1c,0x2a}; bit oldVal; int idx; rom char *GetByteList(char c) { switch(c) { case 1: return A_seq; case 2: return B_seq; case 3: return C_seq; case 4: return D_seq; case 5: return E_seq; case 6: return F_seq; case 7: return G_seq; case 8: return H_seq; case 9: return I_seq; case 10: return J_seq; case 11: return K_seq; case 12: return L_seq; case 13: return M_seq; case 14: return N_seq; case 15: return O_seq; case 16: return P_seq; case 17: return Q_seq; case 18: return R_seq; case 19: return S_seq; case 20: return T_seq; case 21: return U_seq; case 22: return V_seq; case 23: return W_seq; case 24: return X_seq; case 25: return Y_seq; case 26: return Z_seq; case 33: return a_seq; case 34: return b_seq; case 35: return c_seq; case 36: return d_seq; case 37: return e_seq; case 38: return f_seq; case 39: return g_seq; case 40: return h_seq; case 41: return i_seq; case 42: return j_seq; case 43: return k_seq; case 44: return l_seq; case 45: return m_seq; case 46: return n_seq; case 47: return o_seq; case 48: return p_seq; case 49: return q_seq; case 50: return r_seq; case 51: return s_seq; case 52: return t_seq; case 53: return u_seq; case 54: return v_seq; case 55: return w_seq; case 56: return x_seq; case 57: return y_seq; case 58: return z_seq; case 59: return n0_seq; case 60: return n1_seq; case 61: return n2_seq; case 62: return n3_seq; case 63: return n4_seq; case 64: return n5_seq; case 65: return n6_seq; case 66: return n7_seq; case 67: return n8_seq; case 68: return n9_seq; case 69: return exp_seq; case 70: return colon_seq; case 71: return heart_seq; case 72: return asterisk_seq; } // Everything else is a space return space_seq; }; void showData(const char data) { if(data & 0b0000001) clear_bit(portb,3); else set_bit(portb,3); if(data & 0b0000010) clear_bit(porta,7); else set_bit(porta,7); if(data & 0b0000100) clear_bit(porta,6); else set_bit(porta,6); if(data & 0b0001000) clear_bit(portb,7); else set_bit(portb,7); if(data & 0b0010000) clear_bit(portb,6); else set_bit(portb,6); if(data & 0b0100000) clear_bit(portb,5); else set_bit(portb,5); if(data & 0b1000000) clear_bit(portb,4); else set_bit(portb,4); } void showMessage(const char *message, char count) { char i; char j; char data; rom char *sequence; for(j=0; j<count; j++) { sequence = GetByteList(message[j]); for(i=0; i<5; i++) { // Display column data = sequence[i]; showData(data); delay_us(200); delay_us(200); // All Off portb = 0xff; porta = 0xff; delay_us(200); delay_us(200); } // Space between letters. delay_ms(1); } }; void programming() { unsigned char data = 1; unsigned char i,j; unsigned char count; for(i=0; i<3;i++) { for(j=0;j<7;j++) { showData(data); data <<= 1; data |= 1; delay_ms(45); } for(j=0;j<7;j++) { data >>= 1; showData(data); delay_ms(45); } } while(!portb.1 || !portb.2); // Wait for both buttons to be released data = eeprom_read(address); showData(data); while(1) { count = 10; while(!portb.1 && count) { delay_ms(2); count--; } if(count == 0) // Held down for 20ms? { data++; if(data>0x7f) data = 0; showData(data); count = 80; while(!portb.1) { delay_ms(15); if(count) count--; if(count==0) { data++; if(data>73) data=0; showData(data); if(data==0 || data==16 || data ==32 || data==48 || data==64) { while(!portb.1); } } } } if(!portb.2) // Button 2 is pressed { delay_ms(10); if(!portb.2) // Is it still pressed? { eeprom_write(address++,data); data = eeprom_read(address); showData(data); while(!portb.2); // Wait for release } } } } void main( void ) { cmcon = 7; //disable comparators clear_bit( option_reg, 7 ); //Configure port A trisa = 0x00; //Configure port B trisb = 0x07; // RB0, 1, 2 are inputs. //Initialize port A porta = 0x00; //Initialize port B portb = 0x00; delay_ms(100); address = 0; while((data = eeprom_read(address)) != 0) { message[address++] = data; } if(!portb.1 || !portb.2) { address = 0; programming(); } else { //Endless loop while( 1 ) { showMessage(message,address); //while(portb.0); //while(!portb.0); delay_ms(7); }; } } Acho que a primeira dificuldade é encontrar o equivalente que salva na memoria a sequencia de bytes para cada letra do alfabeto. Já que esta não funciona para o AVR. rom char* A_seq = {0x7e,0x09,0x09,0x09,0x7e};

A função if a seguir: if(data & 0b0000001) clear_bit(portb,3); else set_bit(portb,3); Na condição (data & 0b0000001) ela verdadeira quando data é igual ao byte 0b0000001?

O código abaixo é uma mutretagem que não esta funcionando muito bem, nele uso a função "sprintf", mas pra converter int em string. void status(float temp, int dog, float pot) // Atualiza com o status de temperatura e potência { /*int temp2 = temp*100; int pot2 = pot*100; USART_Transmit(0x23); USART_Transmit(0x43); sprintf(atualiza_status,"%d",temp2); USART_putstring(atualiza_status);*/ int temp2 = (int)temp; int temp3 = (temp-temp2)*100; int pot2 = (int)pot; int pot3 = (pot-pot2)*100; USART_Transmit(0x23); USART_Transmit(0x43); if(temp2<10) { if (temp2 == 0) { USART_putstring("00"); } else { USART_Transmit(0x30); sprintf(atualiza_status,"%d",temp2); USART_putstring(atualiza_status); } } else { sprintf(atualiza_status,"%d",temp2); USART_putstring(atualiza_status); } if(temp3<10) { if (temp3 == 0) { USART_putstring("00"); } else { USART_Transmit(0x30); sprintf(atualiza_status,"%d",temp3); USART_putstring(atualiza_status); } } else { sprintf(atualiza_status,"%d",temp3); USART_putstring(atualiza_status); } USART_Transmit(0x44); sprintf(dog_pres,"%d",dog); USART_putstring(dog_pres); /*USART_Transmit(0x57); sprintf(atualiza_status,"%d",pot2); USART_putstring(atualiza_status);*/ USART_Transmit(0x57); if(pot2<10) { if (pot2 == 0) { USART_putstring("00"); } else { USART_Transmit(0x30); sprintf(atualiza_status,"%d",pot2); USART_putstring(atualiza_status); } } else { sprintf(atualiza_status,"%d",pot2); USART_putstring(atualiza_status); } if(pot3<10) { if (pot3 == 0) { USART_putstring("00"); } else { USART_Transmit(0x30); sprintf(atualiza_status,"%d",pot3); USART_putstring(atualiza_status); } } else { sprintf(atualiza_status,"%d",pot3); USART_putstring(atualiza_status); } USART_Transmit(0x2A); } Basicamente como não consegui converter de float para string eu converti para um numero inteiro com 4 algarismos sendo os dois ultimo os decimais do meu float.

Na verdade quero converter de float para string, no site http://www.cplusplus.com a função indicada é a sprintf, mas ela não imprime nada só converte.