burn/omegafire

Olá amigos, estou desenvolvendo um projeto de datalogger para temperatura no compilador MikroC. A ideia é utilizar um PIC 16F877A para controlar um modulo DS1307 como este que possui além do relógio RTC, um modulo de eeprom 24C32A, e usar essa memória eeprom para guardar dados de data e temperatura fornecido por um LM35. O problema é que simulando no proteus, eu consigo escrever na memória e depois executar a leitura, mas apenas uma vez. Quando tento ler de novo, a string que deveria conter a leitura está "zerada". Alguém pode me dar uma ajuda? Acho que estou com algum problema no endereçamento de dados na memória eeprom. Segue o código e o arquivo em formato rar com projeto no mikro c e proteus. #define Lo(param) ((char *)&param)[0]#define Hi(param) ((char *)&param)[1]char temp[16] = "00:00:00;000,0\r"; //15 caractereschar nome[16];unsigned int endereco=0;char segundos, minutos, horas, dia, date, mes, ano;unsigned long adc;////////////////////////////////////////////////////////////////////////////////void Eeprom_24C32A_WriteByte(char DEVICE, unsigned address, char wData){ I2C1_Start(); I2C1_Wr(0xA0 | (DEVICE << 1)); I2C1_Wr(Hi(address)); I2C1_Wr(Lo(address)); I2C1_Wr(wData); I2C1_Stop(); Delay_ms(5);}char Eeprom_24C32A_ReadByte(char DEVICE, unsigned address){char rData; I2C1_Stop(); I2C1_Start(); I2C1_Wr(0xA0 | (DEVICE << 1)); I2C1_Wr(Hi(address)); I2C1_Wr(Lo(Address)); I2C1_Repeated_Start(); I2C1_Wr(0xA1 | (DEVICE << 1)); rData = I2C1_Rd(0); I2C1_Stop(); return rData;}int Eeprom_24C32A_WriteString(char DEVICE, unsigned address, char *wData){ while(*wData != 0) { Eeprom_24C32A_WriteByte(DEVICE, address++, *(wData++)); }return address++;}void Eeprom_24C32A_ReadString(char DEVICE, unsigned address, char *rData, char Size){char i; while(i < Size) { rData[i++] = Eeprom_24C32A_ReadByte(DEVICE, address++); }}char Eeprom_24C32A_Connected(char DEVICE){char ack; I2C1_Start(); ack = I2C1_Wr(0xA0 | (DEVICE << 1)); I2C1_Stop(); return !ack;}////////////////////////////////////////////////////////////////////////////////void ds1307_write(unsigned short registro, unsigned short valor){I2C1_Stop();I2C1_Start();I2C1_Wr(0xD0);I2C1_Wr(registro);I2C1_Wr(Dec2Bcd(valor));I2C1_Stop();}void ds1307_read(){I2C1_Start();I2C1_Wr(0xD0);I2C1_Wr(0x00);I2C1_Repeated_Start();I2C1_Wr(0xD1);segundos = Bcd2Dec(I2C1_Rd(1));minutos = Bcd2Dec(I2C1_Rd(1));horas = Bcd2Dec(I2C1_Rd(1));dia = Bcd2Dec(I2C1_Rd(1));date = Bcd2Dec(I2C1_Rd(1));mes = Bcd2Dec(I2C1_Rd(1));ano = Bcd2Dec(I2C1_Rd(0));I2C1_Stop();}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////void Write1_Line_string(char *msg){ //Escreve string e linha UART1_Write_text(msg); UART1_Write(13); UART1_Write(10); }void Write1_Line_Int(int *intMsg){ //escreve numero e linha char cMsg[7]; IntToStr(intMsg,cMsg); UART1_Write_text(cMsg); UART1_Write(10); UART1_Write(13); } void Write1_Line_char(int *intMsg){ //escreve numero e linha char cMsg; UART1_Write(cMsg); UART1_Write(10); UART1_Write(13); }void Write1_string(char *msg){ //escreve string UART1_Write_text(msg); }void Write1_char(char *msg){ //escreve caractere UART1_Write(msg); }void Write1_int(int *intMsg){ //escreve numero char cMsg[7]; IntToStr(intMsg,cMsg); UART1_Write_text(cMsg); }////////////////////////////////////////////////////////////////////////////////void main(){ short z; ADC_Init(); ADCON1 = 0B00001110; I2C1_Init(100000); UART1_Init(9600); for(z=0;z<14;z++){nome[z]=(49+z);}//"Zera" a string de leitura da memoria eeprom while(1){ adc = ADC_Read(0); //Leitura do termometro adc = adc * 1000/204; temp[9] = (adc/1000) + 48; temp[10] = ((adc/100)%100) + 48; temp[11] = ((adc/10)%10) + 48; temp[13] = (adc%10) + 48; ds1307_read(); //Leitura do relogio temp[0] = horas/10 + 48; temp[1] = horas%10 + 48; temp[3] = minutos/10 + 48; temp[4] = minutos%10 + 48; temp[6] = segundos/10 + 48; temp[7] = segundos%10 + 48; delay_ms(10); endereco=Eeprom_24C32A_WriteString(0, 0, temp); //escrita na memoria Write1_line_string(temp); //imprime na porta serial o que foi escrito na memoria delay_ms(10); Eeprom_24C32A_ReadString(0, 0, nome, 15); //le na memoria o que foi escrito Write1_line_string(nome); Write1_line_int(endereco); //"Zera" a string de leitura da memoria. for(z=0;z<14;z++){nome[z]=(49+z);} delay_ms(2000); }} eeprom_i2c.rar

Olá amigos, em minhas andanças pelo mundo do pic, me deparei com a seguinte linha de comando: Sensor->Accel.X = ( MPU6050_I2C_Rd(1) << 8 ) | MPU6050_I2C_Rd(1); Sensor->Accel.Y = ( MPU6050_I2C_Rd(1) << 8 ) | MPU6050_I2C_Rd(1);Sensor->Accel.Z = ( MPU6050_I2C_Rd(1) << 8 ) | MPU6050_I2C_Rd(1);//Sendo que a struct é:typedef struct{ struct { signed int X; signed int Y; signed int Z; }Accel; signed int Temperatura; struct { signed int X; signed int Y; signed int Z; }Gyro;}MPU6050; Na primeira linha :Sensor->Accel.X = ( MPU6050_I2C_Rd(1) << 8 ) | MPU6050_I2C_Rd(1); eu consigo entender que o ponteiro sensor está apontando para o endereço do inteiro Accel.X, e este por sua vez vai receber o valor da leitura do MPU6050_I2C_Rd(1), e depois os bits serão deslocados oito casas a esquerda, mas essa parte do comando que vem depois "| MPU6050_I2C_Rd(1)" e não consigo entender. Alguem pode ajudar a me esclarecer? Obrigado.

Resolvido. Além do mal contato que estava me atrapalhando, depois que comecei a gravar o PIC direto com o programador, sem o uso do bootloader, ele funcionou a 80MHz com um cristal de 8MHz sem problema nenhum. E vamos ao desenvolvimento. Abs.

Caros colegas, comprei outro dia no ebay uma plaquinha de desenvolvimento muito jeitosa chamada SnadPic. Ela vem com um PIC32MX795F512L que é um dos Pics mais modernos e suportado pelo MikroC para PIC32 bits, além de alimentação regulada própria, leds, cristal oscilador de 8MHz e 32K e uns quebrado, disposição dos pinos do PIC no formato DIP, um plug mini-USB por onde pode se alimentar e se comunicar com a placa, e ainda um slot para cartão SD. Como nunca programei em PIC 32 bits antes, dei uma boa estudada no datasheet dele e parti para usar a plaquinha. Para facilitar a vida do usuário, a placa já vem com o bootloader da Microchip instalado, então podemos usar o próprio cabo USB de alimentação para enviar o programa para a placa. O meu problema é que, até agora, não consegui fazer nenhum programa meu começar a rodar na plaquinha. Sei que ela não está com defeito pois quando coloco o programa que vei com ela para funcionar, funciona perfeitamente, mas os que eu faço no mikroC não funcionam nem com reza braba. Alguém pode me dar uma mão ou me fornecer um arquivo de projeto de mikroC para PIC32 para que eu possa copiar os parâmetros principais? Será que não posso usar um programa compilado pelo mikroC em um controlador que está com o bootloader da Microchip? Obrigado.

Amigo, acho que você pode fazer um programa de PWM normal usando as funções do mikroc. Para controlar cada servo de forma independente como uma só saida, jogue esse sinal PWM no coletor de 5 transistores do tipo BC547 e use a portD do controlador para saturar ou cortar os transistores, dependendo de pra qual servo você querer mandar o sinal. Acho que deve funcionar... Programa de PWM que usei para testar meu osciloscópio porquera: void main() {short siPWMduty=0;ADCON0= 0b00000101;ADCON1= 0b00001101;TRISD.RD0=0;LATD.RD0=0;TRISA.RA0=1;TRISA.RA1=1;TRISC.RC1=0;TRISC.RC2=0;PWM1_Init(4000000);PWM1_Start();ADC_Init(); while(1){ siPWMduty=ADC_Read(0); PWM1_Set_Duty(siPWMduty); LATD.RD0=~PORTD.RD0; Delay_us(1); LATD.RD0=~PORTD.RD0; delay_ms(20000); }}

Olá amigo, faz tempo que não passo por aqui mas como estou retomando meus trabalhos com PIC, resolvi dar uma passada e li o seu tópico. A um tempinho atrás eu estava com o mesmo problema, o de estabelecer uma rede de comunicação entre diversos pics. O meu objetivo nesse projeto era "multiplexar" uma porta serial em 6 ou mais. Para isso, eu tinha como intuito usar um PIC18F4620 ou 4550 como master e PIC18F2550 como slaves, e estabelecer a comunicação entre eles usando o protocolo I2C. Eu cheguei a fazer um programa para o master, e outro para o slave que funcionaram no Proteus, mas minhas prioridades mudaram e eu acabei desistindo de evoluir o projeto, até porque, o programa acabou ficando confuso pra caramba e eu fiquei com preguiça de arruma-lo. Como base para começar o programa, eu usei o tutorial do site microcontrolandos que ensina fazer comunicação entre 2 Pics via I2C e usar um deles como memória RAM. Com esse sistema, eu posso criar uma rede de até 16 Pics slaves cada um com um endereço que vão de 254 a 222 se não me engano. Vou postar os programas: Slave: #define SSPCON SSPCON1 //PIC18F//#define SSPCON SSPCON //PIC16F//ENDEREÇO DO SALVEconst ADDRESS_SLAVE = 224;char ADDRESS_SLAVE_STR[4]="224";//VARIAVEIS//rx char i = 0;//int j;char sspd; //leo conteudo de SSPBUF só para apaga-lo.//rx unsigned EnderecoDaRAM = 0;int aux=0; // ...Slave é requisitado para enviar um byte ao Mastershort xEndereco=0;//char repet=43;//bit flag_buff;char xbuffer[500];//auxiliar buffer de stringchar buffer2[500]="teste teste teste 3x";//buffer secundaria. Armazena penultima string recebida.char buffer3[500];//char xstring[10];//string auxiliarchar Comando[100]=""; //string que recebe o Comando a ser enviado//char valor[10]="";int xComando=0; //contador da string comandoint xBuff; //auxiliar marca de imediato quantos bytes foram recebidos em buffint xfor; //auxiliar contador geral loop forint xSSPBUF2; //auxiliar contador buffer 2 transmissão I2Cint xSSPBUF3; //auxiliar contador buffer 3 transmissão I2Cint ContBuff3;Contbuff2; //auxiliar contador do bufferint timer1; //contador de timer 1//int ComaShift;int xTres;//contador que impede a gravacao dos 3 primeiros dados na string Comandobit flagComando; //flag sinaliza recebeu novo Comando. Ativa o Tx do UART.bit flagTimer1; //flag de estouro de timer 1bit flag232; //flag de nova transmissao 232/UART recebida;bit flag_buffer3; // flag de conteudo no buffer 3;bit dadoRecebido;//bit flagFirstPass;//PONTEIROchar *Ptr = 0x0000;void Buffer_Read(char *buff){ SSPBUF = *buff; Uart_write(*buff); SSPCON.CKP = 1; buff++;}void I2C_Slave_Init(){ ADCON1 = 0x0f; //Desliga a porta analogica TRISB = 255; //Define os pinos do modulo I2C como entrada SSPADD = ADDRESS_SLAVE; //Define o endereço do slave SSPCON = 0x36; //configura I2c como slave, 7bits PIE1.SSPIE = 1; //habilita interrupção do modulo I2c INTCON = 0xC0; //habilita interrupçao global e dos perifericos TRISC.RC2=0; LATC.RC2 =1;}void interrupt(){ // interrupção para Timers if (TMR1IF_bit) { TMR1IF_bit = 0; TMR1H = 0x0B; //1s 8MHz TMR1L = 0xDC; //1s 8MHz //TMR1H = 0xB1;//10ms 8Mhz //TMR1L = 0xE0;//10ms 8Mhz xbuffer[xbuff]=0; //encerra a string. timer1++; if(flag232==1){flagtimer1=1;} }/*if (TMR2IF_bit) { TMR2IF_bit = 0; //LATB.B6=~LATB.B6; }*////////////////////////////////////////////////////////////////////// //interrupção para armazenamento em buffer (sensor -> Buffer) if(RCIF_bit) { RCIF_bit=0; RCIE_bit=0; //desabilita interrupção no Rx if(xbuff>498){xbuff=0;} //impede overflow do buffer xbuffer[xbuff]=UART1_Read(); // grava na posição xbuff o dado recebido xbuff++; //passa uma posição adiante flag232=1; //... se houver escrita no xbuffer, buffer3 = buffer2 e // buffer2 = xbuffer feito no while do void main. RCIE_bit = 1; //habilita interrupção no Rx TMR1IE_bit = 1; //será habilitado quando houver escrita no 232 TMR1ON_bit = 1; dadoRecebido = 1; }///////////////////////////////////////////////////////////////////// if (PIR1.SSPIF == 1) { LATC.RC2=~LATC.RC2; PIR1.SSPIF = 0;///////////////////////////////////////////////////////////////////// //Slave é requisitado para enviar um byte ao Master if (SSPSTAT.R_W == 1) { //envia os 3 bytes que contem o endereco primeiro. if(xEndereco<3) { SSPBUF = ADDRESS_SLAVE_STR[xEndereco]; SSPCON.CKP = 1; xEndereco++;} else{ //Transmite o que tem no buffer 2 SSPBUF = buffer2[aux]; SSPCON.CKP = 1;//libera o clock - envia o dado no SSPBUF aux++; if(aux>1)//não deixa executar na primeira e segunda passada. =D { //se executar na prim./segun. passada, aux == (-2) apontará //endereço inexistente de memória e enviará valor incorreto. if(buffer2[aux-2]==0){aux=0;xEndereco=0;} //verifica qual valor no buffer ==0 //o buffer2 precisa enviar dois bytes a mais para o master //para que ele receba o byte de valor 0 e o próximo, //onde ele irá encerrar a comunicação, porque é o master //quem pede a comunicacao. } } //fecha else } //Fecha o if (SSPSTAT.R_W == 1)///////////////////////////////////////////////////////////////////// //Slave é requisitado para receber um byte do Master if(SSPSTAT.R_W == 0) { if (SSPSTAT.D_A == 0) //Recebeu um endereço? { sspd = SSPBUF; //ler o buffer para esvazia-lo } else //Recebeu um dado qualquer? { Comando[xComando]=SSPBUF; if(xTres<3){xTres++;} //impede a gravacao dos 3 primeiros bytes enviados else{xComando++;} flagComando = 1; //Ativa no main o envio da string }// fecha o else } //Buffer if (SSPSTAT.BF == 0) { //j = SSPBUF; return; } } // fecha o PIR1.SSPIF == 1} // fecha o interruptvoid main(){ //Configuração do interrupção USART RX - RS-232. RCIF_bit=0; //EUSART Receive Interrupt Flag bit RCIE_bit=1; //EUSART Receive Interrupt Enable bit RCIP_bit=1; //EUSART Receive Interrupt Priority bit (High) TXIE_bit=0; //EUSART Transmit Interrupt Enable bit //Configuração do I2C_Slave I2C_Slave_Init(); //Configuração dos timers. // InitTimer1() T1CON = 0x31; TMR1IF_bit = 0; TMR1H = 0x0B; //1 segundo 8MHz TMR1L = 0xDC; //1 segundo 8MHz TMR1IE_bit = 0; //será habilitado quando houver escrita no 232 TMR1ON_bit = 0; //TMR1H = 0xB1;//10ms 8Mhz //TMR1L = 0xE0;//10ms 8Mhz // InitTimer2()/*T2CON = 0x26; PR2 = 250; TMR2IE_bit = 0; INTCON = 0xC0; TMR2ON_bit=1;*/ //INTCON = 0xE0; UART1_Init(9600); delay_ms(100); //Configurações adicionais. TRISB.B7=0; TRISB.B6=0; TRISB.B5=1; TRISB = 0b00011111; //define pinos como entrada para I2C (RB0 + RB1). //Habilitando interrupções INTCON = 0xC0; //Zerando variaveis.xbuff=0; //auxiliar marca de imediato quantos bytes foram recebidos em buffxfor=0; //auxiliar contadorContBuff3=0;Contbuff2=0;timer1=0;flagTimer1=0;flag232=0;flag_buffer3=0; //xSSPBUF2 = 0;xSSPBUF3 = 0;flagComando=0;xComando=0;aux =0;//flagFirstPass=0;//ComaShift=0;xTres=0; while(1){ //////////////////////////////////////////// if(flagComando) // indica o recebimento de comando e ativa o envio { delay_ms(100);//essencial para dar tempo da int. do I2C escrever todo vetor. UART1_Write_text(Comando); //transmite o comando Uart1_Write(10); Uart1_Write(13); xComando=0; // depois de enviar a mensagem, reseta o contador xComando flagComando=0; //reseta o flag de comando xTres=0; //reseta o contador que impede a gravacao dos 3 primeiros bytes transm. } ///////////////////////////////////////// if(flagtimer1==1)//Se houve o esturo de timer 1... {//Uart_write_text("flagtimer1"); TMR1IE_bit = 0; //Desativa o timer 1 TMR1ON_bit = 0; flagtimer1 = 0; //Apaga o flag do timer1 if(flag232==1)//... E se houve escrita no 232 { flag232=0; ContBuff3=ContBuff2;//passa o que tiver no buffer2 para o buffer3 for(xfor=0;xfor<contbuff3;xfor++) { buffer3[xfor]=buffer2[xfor]; } contbuff2=xbuff;//passa o que tiver no xbuffer para o buffer2 for(xfor=0;xfor<contbuff2;xfor++) { buffer2[xfor]=xbuffer[xfor]; } xbuff=0; //depois de copiado o conteudo de xbuffer para buffer2, prepara para receber nova string flag_buffer3=1; if(dadoRecebido) { Uart1_Write_Text("Dado Recebido \r\n"); Uart1_Write_Text(buffer2); Uart1_Write(1); dadorecebido=0; } }//if(flag232==1) }//fecha if(TMR1IF_bit == 1) /////////////////////////////////////////// }//fecha while 1} Master: // VARIAVEIS GLOBAISint xComando=0;int xfor=0;int ADDRESS_SLAVE = 224;int iTemp=0;char Comando[100]=" abcdefghijklmnopq";char mensagem[500]="";char Endereco[10]="065";short dispositivos=1;bit flagComando; // flag para enviar comando a um determinado slavebit flagTimer1; // indica estouro de timer 1bit flagOneTime;unsigned char HidReadBuff[64] absolute 0x500;unsigned char HidWriteBuff[64] ="teste USB" absolute 0x540;int teste=0;// Habilitar Software I2Csbit Soft_I2C_Scl at RC0_bit;sbit Soft_I2C_Sda at RC1_bit;sbit Soft_I2C_Scl_Direction at TRISC0_bit;sbit Soft_I2C_Sda_Direction at TRISC1_bit;// Lê um texto via Soft I2Cvoid SI2C_Slave_Read_Text(char *out){ bit flag_out; char txt [10]; Soft_I2C_Start(); Soft_I2C_Write(ADDRESS_SLAVE); Soft_I2C_Start(); Soft_I2C_Write(ADDRESS_SLAVE + 1); flag_out=0; do{*out=Soft_I2C_Read(1); if(*out==0){Soft_I2C_Read(0);flag_out=1;} out++; }while(flag_out==0); Soft_I2C_Stop();}// Escrever um texto no Soft I2Cvoid SI2C_Slave_Write_Text(char *texto){ Soft_I2C_Start(); Soft_I2C_Write(ADDRESS_SLAVE); do { Soft_I2C_Write(*texto); texto++; delay_us(100); } while(*texto != 0); Soft_I2C_Write(0); Soft_I2C_Stop();}// Escrever um byte no Soft I2Cvoid SI2C_Slave_Write(){ Soft_I2C_Start(); Soft_I2C_Write(ADDRESS_SLAVE); //escreve endereco Soft_I2C_Stop();}void interrupt() { // Habilita a comunicação USB if(USBIF){Usb_Interrupt_Proc();} // Configuracao do Timer 1 if (TMR1IF_bit) { TMR1IF_bit = 0; TMR1H = 0x0B; //1 segundo 8MHz TMR1L = 0xDC; //1 segundo 8MHz flagTimer1=1; Comando[xComando]=0; //Encerra a string. xComando=0; //ocorrendo o estouro de timer, string comando estará fechada. } // Configuracao do UART if(RCIF_bit) { RCIF_bit=0; RCIE_bit=0; //desabilita interrupção no Rx if(xComando>100){xComando=0;} //impede overflow do buffer Comando[xComando]=UART1_Read(); // grava na posição xbuff o dado recebido xcomando++; //passa uma posição adiante flagComando=1; RCIE_bit = 1; //habilita interrupção no Rx TMR1IE_bit = 1; // habilita a interrupção no Timer 1 TMR1ON_bit = 1; // habilita o Timer 1 TMR1H = 0x0B; //reseta a contagem no timer 1 TMR1L = 0xDC; }} // fecha o interruptvoid main(){ Soft_I2C_Init(); //I2C1_Init(100000); Uart1_Init(9600); delay_ms(10); TRISD = 0; TRISB = 0xFF; ADCON1 = 0xFF; //Configuração dos timers. // InitTimer1() T1CON = 0x31; TMR1IF_bit = 0; TMR1H = 0x0B; //1 segundo 8MHz TMR1L = 0xDC; //1 segundo 8MHz TMR1IE_bit = 0; //será habilitado quando houver escrita no 232 TMR1ON_bit = 0; //TMR1H = 0xB1;//10ms 8Mhz //TMR1L = 0xE0;//10ms 8Mhz //Configuração do interrupção USART RX - RS-232. RCIF_bit=0; //EUSART Receive Interrupt Flag bit RCIE_bit=1; //EUSART Receive Interrupt Enable bit RCIP_bit=1; //EUSART Receive Interrupt Priority bit (High) TXIE_bit=0; //EUSART Transmit Interrupt Enable bit //Habilitando interrupções INTCON = 0xC0; // Zerando variaveis de controleComando[0]=0;xComando=0;flagComando=0;flagTimer1=0;flagOneTime=0;Comando[0]=97;// Envio para descarte//SI2C_Slave_Write_Text(Comando); while(1) { SI2C_Slave_Read_Text(Mensagem); if(flagComando) { endereco[0]=comando[0]; endereco[1]=comando[1]; endereco[2]=comando[2]; ADDRESS_SLAVE = atoi(endereco); SI2C_Slave_Write_Text(Comando); flagcomando=0; } Uart1_Write_Text("mensagem recebida"); Uart1_Write(13); Uart1_Write_text(Mensagem); Uart1_Write(13); delay_ms(4000); }} Espero que ajude em alguma coisa. Abs!

Caros colegas, Estou a longo tempo longe dos testes de performace, mas outro dia me ocorreu uma situação real na qual pouco adiantou a superioridade da intel nos benchmaks diante da AMD. Explico a situação: Minha namorada trabalha no laboratório de modelagem computacional da COPPE/UFRJ e embora todo mundo lá seja nerd, ninguem entende muito de computadores e hardware em si. Ela estava extremamente atrasada e precisava gerar dados para um trabalho. O programa que ela estava usando era o mathlab e ela precisava gerar diversos resultados e cada resultado era independente do outro. Enquanto ela estava desesperada rodando o programa e esperando o resultado, eu fiquei de olho no desempenho do computador equipado com um corei7 de primeira geração. Apenas 25% do poder de processamento total estava sendo utilizado, o que me sugeriu que o mathlab não sabe usar multicore ou então que simplesmente ela não programou o mathlab corretamente para usar o multicore. Foi então que eu fui abrindo outras janelas do mathlab e fui rodando outras instancias simultaneamente para agilizar o resultado. No final das contas, ao abrir a 4 instancias o computador perdeu muito desempenho embora haja "8 cores" como diz a intel. Rodei no final com 3 instancias apenas, o que agilizou muito o trabalho e fez o resultado ser gerado a tempo. Mas fico imaginando como essa situação real teria se resolvido com um CPU da AMD de 8 cores reais. Provavelmente, pelo menos 7 janelas de mathlab rodando ao mesmo tempo a toda acho que eu poderia abrir. Vai a dica então ao Gabriel para criar situações reais do dia a dia, como aconteceu comigo, e incorporar nos testes que são executados e não apenas executar testes padrões de um unico aplicativo rodando de cada vez, porque pelo menos pra mim, não é mais a realidade. Em um mundo multicore, executar um jogo, uma codificação de video, e zipar um arquivo tudo ao mesmo me parece um bom teste. Testar apenas com um software de cada vez, mesmo que esse seja especifico para multicore me parece muito pouco para realmente arregaçarmos um CPU multifoderoso e testarmos toda a sua capacidade e tudo o que ele pode realmente nos oferecer. Fica ai as minhas espectativas e meus parabens por todo o trabalho realizado. Abração.

Velho, se eu fosse fazer um circuito desses, faria da seguinte forma: Faria um pequeno controle remoto com um led infra vermelho que seria o emissor. Esse controle remoto teria um PIC 16F628A e ele seria programado para quando eu apertar o botão "ligar" soltar uns 10 pulsos pelo led de luz infra vermelho, e quando eu apertar o botão "desligar" soltar 20 pulsos pelo led de luz infra-vermelho. No PC, eu colocaria outro PIC 16F628A, com um foto diodo para luz infra vermelho que seria o receptor. Programaria o PIC para quando receber os 10 pulsos em uma entrada ligada ao foto diodo, ativar um CI 4n35 (que nada mais é do que um fotoacoplador (que poderia ser até ser substituido por um relé ou um transistor) para dar um pulso no circuito que liga o PC. Quando o pic que está no PC receber 20 pulsos, ele liberaria outro pulso no 4n35 para desligar o PC. Acho que o programa tem que ter duas constantes, uma para contar o numero de pulsos, e outra para determinar um tempo máximo para o pic receber os pulsos, caso não seja alcançado, o numero certo, a constante de contagem de pulsos seria resetada. Acho que no controle remoto, que provavelmente será movido a baterias, ativar o PIC pela interrupção externa pra poupar a bateria. E sim... sou viciado em PIC. =D . Embora saia um pouco mais caro, acho que se você fizer com PIC as possibilidades de você expandir o seu sistema no futuro são enormes, dando a ele muito mais funções. Mas sou novata pacas no negócio, talvez não seja tão boa ideia assim.

Acho que quase tudo já está explicado nos posts, portanto só vou acrescentar algumas coisas que eu fiz no meu projeto final do curso de eletrônica aonde usei justamente um lm35 e um peltier de 92W para fazer o controle de temperatura de um aquário. Ai vai o esquema de como fiz a ligação para controlar o peltier atraves do PWM do PIC 887a: O MOSFET que utilizei foi o IRF 3710 que achei vendendo barato aqui perto de casa, uns 4 reais. Tive que usar um amplificar operacional com saida nao invertida no projeto porque o MOSFET trabalhando junto com o peltier só começava a entrar na zona ativa quando chegava nos 7,5 Volts e o PWM do PIC só chega no maximo 5 Volts. Mesmo assim, com a ajuda do amplificador operacional, eu nao consegui saturar esse MOSFET porque minha fonte era de 12 Volts, e com 11 Volts em cima do gate do MOSFET esse nao saturou por completo, deixando passar só uns 8 Volts para a pastilha no lugar de 12 Volts. No esquema, vocês podem ver que no amplificador operacional eu coloquei um trimpot, ele me ajudou a calibrar a tensão resultante do PWM para ficar exatamente entre a região de corte e ativa do MOSFET. O PWM também foi filtrado por uma resistencia baixa e um capacitor antes de ser jogada amplificar operacional. Eu já tinha visto alguns outros esquemas, inclusive aqui no forum, mas preferi esse porque achei mais simples no meu entendimento. Para resfriar o peltier, eu usei um velho cooler VCOM 21B que tinha aqui em casa do meu antigo AthlonXP 2400M @ 2.4GHz 1.9Volts (É obvil que não usei esse cooler para chegar nesse clock) . O cooler é parrudo e aguentou de boa, mesmo quando joguei 12 Volts direto na pastilha. Lembrando que se voce for usar um mosfet, esse necessita de tanta refrigeração quanto o próprio peltier. Quando voltar pra casa do mais uma olhada no tópico.

MatheusLPS, Muito obrigado pelo exemplo, resolvi o meu problema baseado na sua postagem. Achei esse driver consideravelmente mais chatinho do que o driver original para LCD16x2, mas já peguei o jeitão dele. Abração!

Matheus, eu ainda continuo com dificuldade mesmo depois de tentar de diversas formas. Devo estar errando em alguma coisa no meio do caminho. Eu fiz o seguinte, copiei o code para um arquivo chamado flex_lcd420.c e coloquei esse arquivo dentro da pasta de drivers do PICC. Fiz a mudança no código do programa principal de #include <lcd.c> para #include <flexlcd420.c> mas o LCD no proteus não responde de jeito nenhum. Eu sou um usuario novato do PICC e ainda começo a minha programação usando o Pic Wizard , por isso eu não tenho muito ideia dessas configurações mais avançadas. Se voce puder me fazer um exemplo de um programa que funcione aqui pra eu copiar e testar modificações ou um passo a passo de como utilizar esse driver novo ficarei muito agradecido. Abs!

Amigos, já usei sem problemas o LCD 16x2 em conjunto com um PIC 877 através do compilador CCS. Estou tentando agora fazer o LCD 20x4 funcionar, mas creio eu que estou fazendo algum erro por ele simplesmente não funciona. Eu até posso usa-lo com a biblioteca do LCD normal, mas ele não acessa as linhas seguintes, só as linhas 1 e 2, a 3 e 4 ficam em branco. O programa que estou fazendo é esse ai que se segue. Será que alguem pode me dizer aonde ou o que devo modificar para que ele passe a aceitar o novo LCD? #include <Leitor de Salinidade e Temp com int.h> #define LCD_ENABLE_PIN PIN_B3 #define LCD_RS_PIN PIN_B1 #define LCD_RW_PIN PIN_B2 #define LCD_DATA4 PIN_B4 #define LCD_DATA5 PIN_B5 #define LCD_DATA6 PIN_B6 #define LCD_DATA7 PIN_B7 #include <lcd.c> int salcal; int tempcal; int salatual; int tempatual; int sallcdatual; int templcdatual; int sallcdcal; int templcdcal; #int_EXT void EXT_isr(void) { lcd_init(); setup_adc_ports(AN0_AN1_AN3); setup_adc(ADC_CLOCK_DIV_4); set_pwm1_duty(0); if (input(pin_c4)) { set_adc_channel(0); salcal= read_adc(); sallcdcal=salcal; set_adc_channel(1); tempcal= read_adc(); templcdcal =(tempcal)/2; lcd_putc("\f Calibrando..."); delay_ms(2000); printf(lcd_putc,"\f Sal. Cal %u", sallcdcal); printf(lcd_putc,"\n Temp. Cal %u", templcdcal); delay_ms(3000); if (tempcal <= 20 || salcal <= 40){lcd_putc("\fCalibragem \nIncorreta."); delay_ms(3000);} else {lcd_putc ("\f Calibragem \n Concluida!");delay_ms(3000);} } while(input(pin_c3)) { tempcal=tempcal-1; templcdcal=(tempcal)/2; lcd_gotoxy(1,1); printf(lcd_putc,"Temperatura \n %u graus",templcdcal); if (tempcal==21) {set_adc_channel(1);tempcal= read_adc();} delay_ms(100); output_high(pin_c6); delay_ms(100); output_low(pin_c6); } while(input(pin_c5)){ printf(lcd_putc,"\fSal. Cal. %u ", sallcdcal); printf(lcd_putc,"\nTemp. Cal. %u", templcdcal); delay_ms(2000);} } void main() { lcd_init(); setup_adc_ports(AN0_AN1_AN3); setup_adc(ADC_CLOCK_DIV_4); set_pwm1_duty(0); enable_interrupts(INT_EXT); enable_interrupts(GLOBAL); lcd_putc ("\fSistema controle \n Temp. e Sal.");// ... Obrigado!

A fonte ficou um sonho de consumo! Parabéns!