ASM51

Boa noite a todos, estou fazendo uma interface entre o PIC16F628 e o CI Registrador de deslocamento 74HC166, o que está acontecendo é o seguinte, a comunicação entre os dois está ok se eu fizer a leitura de um bit por vez, o problema é que se eu quizer ler mais de um bit por vez os dados viram a mior bagunça.

se alguem poder dar uma força.... eu ficarei muito grato.

O programa é todo em ASM ok.

Será que não ocorreu inversão de sentido ?

Coloque aqui o Programa.
.

Olá Josivam

Eu não entendi muito bem sua pergunta, mas eu acho que esteja acontecendo seja o seguinte: No ci citado por vc não existe o lath, vc só tem o data e o clock...quando envia-se o dados serialmente para esse ci os pinos ficam oscilando rapidamente até se estabilizar os dados...

Eu particularmente utilizo o c.i. 4094 que possui o data, clock e strob, eu já postei aquí no forum uma rotina em asm para o pic que funciona muito bem e também a utilizo muito em meus projetos...

Se não encontrar me avise que lhe envio via email...

mcupicc@hotmail.com

Olá amigo, acho que vc está confundindo, pois o CI 74HC166 é para conversão PARALELO / SERIAL recebe os dados paralelo e envia seralmente.
E eu já tenho rotinas funcionando com o 4014 para entradas digitais e o 4094 para saidas digitais, o que eu estou querendo fazer agora é o mesmo só que com os CIs 74HC166 para entradas digitais e 74HC595 para as saidas digitais, sendo que o problema está apenas no CI 74HC166, o restante está tudo Ok.

E o problema é o que eu falei acima ok.

Obrigado pela atenção

Como foi solicitado pelo amigo Djalma, estou colocando aqui a rotina que fiz para a leitura, pode ser implentada em um programinha para teste.

Se alguém encontrar alguma solução para o que eu descrevi no inicio do tópico eu ficarei muito grato.


;********************************************************************
; ROTINA PARA LEITURA DO SN74HC166N
;********************************************************************
LER
CALL LER_74166 ; VAI PARA LER O PRIMEIRO BYTE
MOVFW VALOR ; COPIA O VALOR LIDO PARA
MOVWF INPUT_0 ; O REGISTRADOR TEMPORARIO DO 1° BYTE
;DECFSZ AUX_BYTES,1 ; TERMINOU O NUMERO DE BYTES?
;GOTO $+2 ; NAO, ENTAO LER O PROXIMO
RETURN ; SIM, RETORNA

LER_74166 ; ROTINA PARA LEITURA DOS BITS
MOVFW N_BITS ; COPIA O NUMERO DE BITS A SER CONTADO
MOVWF AUX_BITS ; PARA O REGISTRADOR AUXILIA DA CONTAGEM
BSF CLOCK_74166 ; POE EM 1 O PINO CLOCK(7) DO 74166
BSF ENABLE_74166 ; POE EM 1 O PINO SH/LD(15) DO 74166
; OS PASSOS A CIMA SAO PARA INICIALIZACAO DO CI, O PINO 15 EM 1
;DEIXA LIVRE A ENTRADA DE DADOS 'SEIAIS'ATRAVEZ DO PINO 1

BCF ENABLE_74166 ; DA UM PULSO NEGATIVO NO PINO 15 DO 74166
BCF CLOCK_74166 ; POE A 0 O PINO CLOCK(7)
BSF CLOCK_74166 ; VOLTA A 1 O PINO CLOCK
BSF ENABLE_74166 ; VOLTA A 1 O PINO SH/LD
; OS PASSOS A CIMA SAO FIETOS A FIM DE CARREGAR OS DADOS CONTIDOS
; NA ENTRADA PARALELA PARA OS FLIP FLOPS INTERNOS, COM UM PUSLO A 0 DO PINO
; SH/LD(15), OS DADOS SÃO CARREGADOS, E NA PROXIMA TRASICAO DE 0 PARA 1 NO CLOCK
; OS DADOS SAO SALVOS INTERNAMENTES, SENDO O VALOR DO BIT MSB JÁ ESTANDO PRESENTE
; NA SIDA QH(13) DO CI 74166

CONT_IN ; AQUI COMECA A LEITURA DOS BITS
BCF STATUS,C ; DESLIGA O PINO C DE STATUS
BTFSC DADO_74166 ; TESTA O VALOR DO 1° BITS LIDO SE 1 OU 0
BSF STATUS,C ; SE 1, ROTACIONA O VALOR COM O BIT EM 1
RLF VALOR,1 ; SE 0, ROTACIONA O VALOR COM O BIT EM 0
DECFSZ AUX_BITS,1 ; VERIFICA SE TERMINOU A CONTAGEM DOS BITS
GOTO SERIAL_CLOCK ; SE NÃO, DESVIA PARA DA UM NOVO CLOCK
GOTO SAIR ; SE SIM, DEVIA PARA SAIR DA ROTINA

SERIAL_CLOCK
BCF CLOCK_74166 ; AQUI E UMA ROTINA PARA GERAR UM NOVO
BSF CLOCK_74166 ; CLOCK COM TRANZICAO DE 0 PARA 1
GOTO CONT_IN ; LE UM NOVO BIT
SAIR
RETURN ; RETORNA DA COM O VALOR NAS ENTRADAS PARALELAS
; SALVO NA VARIÁVEL 'VALOR'

;############################################################################

josivan, estou vendo que tu deu apenas um pulso para 1 e ja retorna na próxima instrução.
Se estiver trabalhando com um CK de 4mhz ex,..

A duração de CK = 1, vai ser de 2uS.

Observe o datasheet na folha de tempos, e veja qual é o minimo tempo de CK para que ele possa operar satisfatóriamente..

fabim

Obrigado pela atenção Fabim, veja só, na folha 5 do datasheet (revisão D em setembro de 2003, a ultima revisão) tem uma tabela com todos os dados de temporização para todos os pinos de controle do CI, e nenhum deles tem tempo minimo maior que 250 ns, ou seja, 2us sobra tempo correto, me corrija se eu estiver errado ok.

Mas valeu pela ajuda amigo.

http://www.datasheetcatalog.org/datashe ... _CNV_2.pdf

Olhe a tabela na pagina 3, depois olhe a carta de tempos na pagina 5..

Faça uma comparação com o seu código.

Você confundiu uma coisa, e esqueceu de outra,,

fabim

Olá amigo, quero informar que eu não consegui encontrar o problema ok, o componente que eu estou usando é Texas Instrument (SN74HC166N) e não Philips, poderias ser mas específico amigo.

Té mais, e aguardo.

Josivan escreveu:...AQUI COMECA A LEITURA DOS BITS
BCF STATUS,C ; DESLIGA O PINO C DE STATUS
BTFSC DADO_74166 ; TESTA O VALOR DO 1° BITS LIDO SE 1 OU 0
BSF STATUS,C ; SE 1, ROTACIONA O VALOR COM O BIT EM 1 ...

Na Variável DADO_7416 não estará faltando expecificar qual Bit ?

( BTFSC f,b )

-----------------------------------------------------------------------------------------

Sugestões:
O nome das Variáveis podem, e devem, estar relacionadas com o circuito
ou componente mas, de forma mais abstrata
Em vez de DADO_7416 fica melhor:
D_SR
C_SR
E_SR , etc.

Evite o excesso de comentários
As 3 linhas acima os Mnemônicos são tão claros que dispensam comentários.
E os comentários devem ser breves e não tem sentido expecificar o CI ou o pino correspondente
isso estará no diagrama esquemático.

Ficará mais claro e objetivo ao Soft

Depois volto com sugestão de uma nova abordagem.
.

Olá Djalma, veja só, o menimonico DADO_74166 já está definido no inicio do programa como sendo PORTA,6 ok, a respeito dos comentários, eles foram feitos de forma que todos os que lecem, podessem entender o que está sendo feito opk, se tem muito ou pouco comentário não importa, pois só foi colocado ai mesmo, no programa original nem comentado foi ainda ok.

Valeu pela ajuda.

pra tentar humilhar em C:

Código: Selecionar todos

unsigned int LER(unsigned char AUX_BITS)
{
unsigned int VALOR=0; //ou só char
while(AUX_BITS--)
{
CLOCK_74166=1; asm("nop"); //ou + alguns nop´s...
CLOCK_74166=0;
VALOR<<=1;
VALOR|=DADO_74166;
return VALOR;
}
}

pra tentar ajudar ocê:
-verifique se o 166 não tem um sinal de reset e este deva ser usado ou está sendo ignorado
-coloque um capacitor 0,1 a 1nF em paralelo com os sinais de clk e dado (pro gnd)
-coloque uns nop´s como a dica do fabin. na prática a teoria é outra
abç

Oi Josivan,

Me desculpe a falta de atenção, vc tem razão!

Vou analizar sua rotina e posto aquí, ok...

Olá lellis, quero informa que já coloquei rotina de temporização de até 100 us (deu no mesmo), eu não consegui enchergar o que o fabim falou, talvez vc possa dar uma dica ok.

Olá Vonnilmam eu agradeço a sua ajuda amigo e fico no aguardo ok.

Supondo que sua rotina esteja correta (não verifiquei), supondo também que nenhuma interrupção foi esquecida sem salvar o registro de status, Wreg e outros de interesse em sua rotina, seu problema deve estar no seu hardware.
Cabe lembrar que os tempos observados no manual do chip são nas condições de teste, ou seja, capacitâncias lá do teste deles. Se estiver em um protoboard as capacitâncias são muito altas, seus pulsos não sobem e não descem.

Se o retardo de 100us foi posto entre cada subida e descida de pulso, tudo bem, mas se foi posto entre cada leitura, não ajudará muito ou quase nada.

Há um capacitor entre Vdd e Vss de 100nF no 166 ? Se não tiver coloque-o.

Para teste, use um tempo grande nos pulsos (sem alterar a relação de sincronismo entre eles) e se não der, também para avaliar, use um resistor de 4k7 da porta para referência em cada porta ligada ao chip 166.

Se nada disso resolver, verifique seu sincronismo no software com o datasheet.

NOTA: Após funcionar, você poderá fazer o mesmo pela UART em half duplex sincrona (UART - 74hc166). Seu código desaparecerá(teste de bits, etc). Toda a operação será feita pelos periféricos e o byte da entrada paralela estará lá na UART te esperando.