Como usar port_b_pullups

chacalgbi · 24 de outubro de 2012

Pode parecer uma pergunta besta, mas para que serve mesmo o port_b_pullups?

Vejo sempre dizendo que é para acionar os resistores internos do PIC, mas se for resistores:

1 - Usa-los em que tipo de aplicação?

2 - E poderia omitir o resistor externo?

3 - Como aciona-los? Seria port_b_pullups (true)?

4 - Será acionado todo portB?

5 - E seu eu quiser só o B1 ou B7?

6 - De que valor são os resistores?

7 - Quantos Watts? 1/8W?

Acho que respondendo isso ai já dá pra sanar minhas dúvidas... rsrs

vtrx · 24 de outubro de 2012

1 - Usa-los em que tipo de aplicação?

Quando se precisa de níveis lógicos como referencia.

Exemplo,pinos de PORTs que são 'OPen Drain',precisam de um sinal de referencia ou ficarão em 'Tristate'.

Pinos como 'Entrada',ficam sem referencia.

2 - E poderia omitir o resistor externo?

Sim,se o circuito precisar voce pode usar os 'internos'.

4 - Será acionado todo portB?

Sim.

5 - E seu eu quiser só o B1 ou B7?

Que eu saiba não.

6 - De que valor são os resistores?

Devem estar enter 4K7 e 10K(tem que olhar no Datasheet).

7 - Quantos Watts? 1/8W?

Ídem,datasheet.

chacalgbi · 24 de outubro de 2012

Então eu acionando o port_b_pullups todo portB ficará em um nível lógico até que outra entrada mude isso correto?

Mas esse nível lógico quando acionado o port_b_pullups é por padrão 0 (zero)?

vtrx · 24 de outubro de 2012

Não,port_b_pullups,siginifica nível alto.

Quando voce os ativa,os pinos estarão em nível alto.

Assim,quando voce 'aterrar' o pino do PORT,ele ficarã em 'zero' e a lógica do micro 'entenderá' que houve uma mudança de nível,que sendo o pino como Entrada Digital,siginifica qye foi 'acionado'.

se não existir um resistor entre o pino e o +5(no caso PullUp),o pino ficaria 'instavel/Flutuante' gerando erros de leitura.

chacalgbi · 24 de outubro de 2012

Pode-se configurar o inverso tb? Para ficar nível lógico ZERO?

vtrx · 24 de outubro de 2012

voce tem que procurar no datasheet do PIC que vai usar,mas acho que não.

Se puder ser feito INTERNAMENTE,então o compilador aceitará a instrução port_b_pulldown.

chacalgbi · 25 de outubro de 2012

Muito esclarecedor! Obrigado!

Para não precisar criar outro tópico, você saberia dizer como faço para gravar uma variável na memória Eprom do PIC (essa é a memória não volátil né?)

E como recuperá-la depois?

vtrx · 25 de outubro de 2012

Saber eu sei,mas os procedimentos vai depender da linguagem e compilador que voce usa.

Se for CCS,aguarde o Matheus responder pois só uso o CCS quando alguem não responde.

chacalgbi · 25 de outubro de 2012

Eu uso C e o compilador é o CCS PCWHD 4.078

Olhei no livro "Microcontroladores PIC, Programação em CCS" do Fábio Pereira, na página 219 fala sobre manipulação da EEPROM interna, os comandos eu achei, agora surgiram outras dúvidas que o livro não tem a solução:

READ_EEPROM() - Lê um byte de um endereço especificado da EEPROM interna.

ex:

x = READ_EEPROM(1)

WRITE_EEPROM() - Escreve um valor em um determinado endereço da memória EEPROM interna.

ex:

WRITE_EEPROM(1,5)

READ_PROGRAM_EEPROM() - Lê um byte de um endereço especificado da memória de programa.

ex:

x = READ_PROGRAM_EEPROM(1)

WRITE_PROGRAM_EEPROM() - Escreve um valor na memória de programa do dispositivo.

ex:

WRITE_PROGRAM_EEPROM(10, 0X0050)

AGORA AS DÚVIDAS:

Se eu quiser escrever o valor de uma variável, na EEPROM para depois, se o PIC for desligado eu quiser pegar de novo, como eu vou procede? Para escrever eu uso WRITE_EEPROM() ou WRITE_PROGRAM_EEPROM() ?

E para ler tb?

E esse endereço de memória, como é o valor? é em assim (0X0050) ?

Se eu quiser quardar 4 variáveis, como seria o procedimento?

Vou colocar um pequeno código, que incrementa uma variável, como seria o mesmo pra gravar na eeprom e depois ler em um outro momento? caso a alimentação do PIC falhasse?



int8 x=0;

void main()
{
while(true)
{
if (input(BOTAO_INCREMENTO))
            {
               delay_ms (75);
               x++;
            }

            if (input(BOTAO_DECREMENTO))
            {
               delay_ms (75);
               x--;
            }
}
}

MatheusLPS · 25 de outubro de 2012

Como te falei, mais tarde eu posto um exemplo pois estou no celular e por ele é complicado fazer algo decente. Quanto estiver no PC eu volto aqui.

Falou

chacalgbi · 25 de outubro de 2012

beleza, brigadão! Tô no aguardo!

MatheusLPS · 26 de outubro de 2012

Bom, sobre o PORT_B_PULLUPS, o colega vtrx já respondeu tudo. Mas gostaria de complementat apenas alguns pontos:

4 - Será acionado todo portB?
5 - E seu eu quiser só o B1 ou B7?

Isso depende de cada PIC. Alguns só permitem que todo o PORt seja habilitado. Já outros permite que você configure os bits individualmente.

Se você ver o manual do CCS, ele diz assim:

port_b_pullups (value)

value is TRUE or FALSE on most parts, some parts that allow pullups to be specified on individual pins permit an 8 bit int here, one bit for each port pin.

Ou seja, no caso do 16F690, você pode configurar assim:

port_b_pullups(0b11110000); // O 1 deixa ligado.

Pesquise sobre :"Individually programmable weak pull-ups" no google que o mesmo irá te retornar alguns PICs que suportam a escolha dos pull-ups individuais.

Sobre a eeprom, o manual do CCS diz o seguinte:

write_eeprom (address, value)

O adress seria o local da eeprom onde você deseja gravar o dado e o value seria o dado a ser guardado.

O adress pode ser 8 ou 16 bits. vai depender do PIC. Já o value seria um valor de 8 bits. Para essa função!

Nesse caso, value pode assumir de 0 a 255. Se quiser escrever um n'umero maior, tem que usar uma biblioteca para isso.

Exemplo para gravar na eeprom:

#define LAST_VOLUME 10 // Local da EEPROM

volume++;

write_eeprom(LAST_VOLUME,volume);

Veja que a eeprom tem limite de escrita e leitura. Se não me engano são 10000 vezes (alguem corrija).

Por isso não acho legal você escrever nela dentro de um loop de while. Acho que deve ser escrita somente quando se quer guardar um valor importante e nao toda hora que ele muda.

Se o valor a ser guardado é maior que 255. Faça assim:

Apenas inclua essa biblioteca:

#include <internal_eeprom.c>

E utilize esses comandos:

write_int16_eeprom(0,x);
n = read_int16_eeprom (0);

Suas variáveis x e n devem ser int16.

Simples e funcional.

Teste:

#include <16F628A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                          //Clock <=4Mhz
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection

#use delay(clock=4000000)

#include <lcd_flex.c>
#include <internal_eeprom.c>

int16 n;
int16 x=365;

void main()
{ 
   lcd_init(); //Inicializa LCD

   printf(lcd_putc,"\fteste");

   write_int16_eeprom(0,x);


   n = read_int16_eeprom (0);

   printf(lcd_putc,"\n%lu", n);    

   while(true);
}

Resultado:

Falou

chacalgbi · 26 de outubro de 2012

Eu entendi, fiz uns testes aqui e deu certo, mas se eu quiser salvar 2 ou mais variáveis? Como vou escrever o address ?

No 1° teste que fiz aqui coloquei assim:

write_int16_eeprom(0,x);

write_int16_eeprom(1,y);

Ficou louca as variáveis quando eu apertava um botão pra incrementar,

Ai mudei pra essa

write_int16_eeprom(0,x);

write_int16_eeprom(10,y);

Testei na prática e deu certo, agora não sei como devo proceder na hora de colocar o endereço da EEPROM pra salvar. É em decimal como fiz? Se for, qual o limite e o espeço entre um número e outro?

No seu exemplo você salvou no endereço 0 (zero) da memória EEPROM?

Em cada locação de memória cabe uma variável de quantos bits?

MatheusLPS · 26 de outubro de 2012

Eu entendi, fiz uns testes aqui e deu certo, mas se eu quiser salvar 2 ou mais variáveis? Como vou escrever o address ?
No 1° teste que fiz aqui coloquei assim:

write_int16_eeprom(0,x);

write_int16_eeprom(1,y);

Ficou louca as variáveis quando eu apertava um botão pra incrementar

Com o codigfo acima, era pra funcionar normalmente. O que pode acontecer e que quando se grava na eeprom, leva-se varios mili segundos para isso. Talvez esse seja o problema. Tente colocar um delay_ms (20) logo depois de cada escrita. Nao sei o tempo certo. Tem que olhar no datasheet.

É em decimal como fiz?

Sim, e em decimal mesmo.

No seu exemplo você salvou no endereço 0 (zero) da memória EEPROM?

Sim.

Em cada locação de memória cabe uma variável de quantos bits?

Isso eu ja disse la em cima. Temnos duas funçoes diferentes.:

1 - write_eeprom(adress,value); // Nessa, adress vai depender do PIC, pode ser 8 ou 16 bits. Isso fala no datasheet. Value e no maximo 8 bits. Ou seja, você so ira guardar valores entre 0 e 255. Resumindo: Com essa funçao, você tem 256 locais de armazenamentos e pode guardar valores de ate 255.

2 - write_int16_eeprom(adress,value); //Nessa, adress vai depender do PIC, pode ser 8 ou 16 bits. Isso fala no datasheet. Value e 16 bits. Ou seja você pode escrever valores ate 65535.

Falou

chacalgbi · 26 de outubro de 2012

Levando em consideração o que você disse sobre o limite de gravações da EEPROM, eu fiz o código que você define o valor das duas variáveis primeiro, e só depois salva, depois ainda vou colocar mais um botão pra sair do menu de ajuste sem salvar.

Foto do Teste e Código

Código:


#include <16F877A.h>
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                          //Clock <=4Mhz
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#use delay(clock=4000000)
#include <lcd.c>
#define botao_incremento PIN_C6
#define botao_decremento PIN_C7
#define vm1 PIN_B1
#include <internal_eeprom.c>


int16 x, y;
int8 modo;
#int_EXT
void  EXT_isr(void) 
{
modo++;
}


void main()
{     
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_EXT);
   enable_interrupts(GLOBAL);
delay_ms(100);
modo = 0;
lcd_init();
delay_ms(100);
output_high(vm1);
delay_ms (1000);
output_low(vm1);

x = read_int16_eeprom (0);
y = read_int16_eeprom (10);

while(true)
{
if (modo>4)modo = 0;


switch (modo)
{
         case 1:
         {            
            if (input(BOTAO_INCREMENTO))
            {
               delay_ms (75);
               x++;
            }

            if (input(BOTAO_DECREMENTO))
            {
               delay_ms (75);
               x--;
            }

            if (x > 23 )
            {
               x = 0;
            }
            printf(lcd_putc,"\fAjustar Hora1:\n%lu",x);            
            delay_ms (100);
            break;
         }

         case 2:
         {            
            if (input(BOTAO_INCREMENTO))
            {
               delay_ms (75);
               y++;
            }

            if (input(BOTAO_DECREMENTO))
            {
               delay_ms (75);
               y--;
            }

            if (y > 59 )
            {
               y = 0;
            }
            printf(lcd_putc,"\fAjustar Minuto1:\n%lu",y);            
            delay_ms (100);
            break;
         }

         case 3:
         {
         write_int16_eeprom(0,x);
         write_int16_eeprom(10,y);
         lcd_gotoxy (2,1);
         lcd_putc ("\f");
         lcd_putc("Hora 1 Gravada");
         lcd_gotoxy (3,2);
         lcd_putc("Com Sucesso!");
         delay_ms(1500);
         lcd_putc ("\f");
         modo++;
         break;
         }

         default:
{
lcd_gotoxy (3,1);
lcd_putc("Teste EEPROM");
printf(lcd_putc,"\n Hr:%lu Min:%lu",x,y);
delay_ms(300);
}
}
}
}

Li sua resposta aqui, vou fazer o teste com o delay de 20 ms entre as escritas....

Valeu!

Deu certo, coloquei os Delays entre as escritas e as leituras.

Tem limite de quantidade de variáveis? Ou o limite será a capacidade de EEPROM?

MatheusLPS · 26 de outubro de 2012

Muito bom o seu exemplo com um menu so para gravaçao. Eu tinha imaginado algo daquele tipo mesmo.

No caso nao tem limite de variaveis. O tanto que o PIC suportar. Mas você so consegue gravar 256 variaveis. Mas mesmo assim, depende do PIC. Tem que ver o datashhet para ver quanto de eeprom cada um suporta.

Falou