ASM51

gostaria de saber se alguem tem os comentarios desta biblioteca 74595.c

cpp code

void write_expanded_outputs(BYTE* eo) {
  BYTE i;
  output_low(EXP_OUT_CLOCK);
  output_low(EXP_OUT_ENABLE);

  for(i=1;i<=NUMBER_OF_74595*8;++i) {  // Clock out bits from the eo array
    if((*(eo+(NUMBER_OF_74595-1))&0x80)==0)
      output_low(EXP_OUT_DO);
    else
      output_high(EXP_OUT_DO);
  shift_left(eo,NUMBER_OF_74595,0);
  output_high(EXP_OUT_CLOCK);
  output_low(EXP_OUT_CLOCK);
  }
  output_high(EXP_OUT_ENABLE);
  output_low(EXP_OUT_ENABLE);

Pessoal sei que , com otimismo , bom senso respeito pelo proximo , e com uma vida realizada com muito esforço , trabalho e dedicação , o conhecimento é merecido , pessoas esforçadas que estudam em faculdades as vezes perdem até o sono para ter uma vida melhor e dar o melhor para a suas familias ,
estou nesta luta e me esforçando tambem , peço encarecidamente se alguem se compadecer neste apelo , nesta petição para passar para mim uma PM
caso algum membro do forum não se sinta a vontade em postar sobre o esplicamento da biblioteca 74hc595 , sou esforçado , dedicado busco um objetivo, pois o estudo da engenharia é uma das areas para mim , mais fascinantes de cursos universitarios, em bora estou ainda cursando o ensino medio espero um dia chegar lá... gostaria de saber o que faz cada comando bem explicado , se alguem tiver esse material ou arquivo seja ele em formato PDF ou Word ficarei muito agradecido!

Como você esta iniciando,o correto é você analisar o datasheet e entender como o CI se comporta e depois usar esta biblioteca,se bem que com compreensão de como o CI se comporta,você mesmo poderia fazer uma rotina,assim iria aprender mais.
Explicar esta biblioteca é o mesmo que explicar o funcionamento do CI.
Voce entendeu como o CI é ativado pelo Clock/data etc?

Bom, vamos tentar ajudar:

Código: Selecionar todos

// Esta biblioteca escreve uma serie de bits num array de shift registers em serie.
// A rotina recebe um ponteiro para um array onde estarao os bytes a serem escritos nos CIs
// Eh importante observar que o tamanho do array deve ser igual aa quantidade de CIs presentes na placa
// Por exemplo, se no circuito houverem 3 CIs ligados em serie, pode-se criar um array do tipo
// BYTE valores[3];
// valores[0] = 0x35;
// valores[1] = 0x48;
// valores[2] = 0xAC;
// write_expanded_outputs(valores);
// Desta forma, o valor 0x35 sera escrito no primeiro CI, o valor 0x48 no segundo CI, e 0xAC no terceiro CI
// Eh importante notar que, como a rotina eh meio mequetrefe, ela altera estes valores, entao depois de chamar
// a rotina os valores no array estarao zerados.
void write_expanded_outputs(BYTE* eo)
{
  BYTE i;

  // Coloco a linha de clock do CI em nivel baixo, porque o clock eh ativado em rampa de subida
  output_low(EXP_OUT_CLOCK);

  // Coloco a linha de Enable em nivel baixo, para habilitar o shift register dos CIs
  output_low(EXP_OUT_ENABLE);

  // Esta laco eh executado por 8 vezes para cada CI que estiver nesta placa
  // (suponho) o #define NUMBER_OF_74595 especifica quantos CIs estao presentes no circuito
  // Como cada CI precisa de 8 clocks para fazer shift de seus 8 bits, entao se por exemplo
  // houverem 3 CIs 74595 em serie no circuito, ele precisa fazer shift de 24 bits (8 * 3)
  for(i=1; i<=NUMBER_OF_74595*8; ++i)
  { 
      // Essa parte eh F***, entao vamos por partes.
      // Primeiro, a rotina pega o valor que foi passado no array. Ela comeca pelo ultimo valor.
      // Seguindo o exemplo acima, temos 3 CIs n0 circuito, entao NUMBER_OF_74595 foi definido com valor 3.
      // Assim, eo aponta para o primeiro valor do array, ou seja, valores[0]. Fazendo a conta abaixo,
      // NUMBER_OF_74595 - 1 resulta em 2. Somar eo com 2 faz ele apontar para valores[2], que eh o ultimo membro
      // do array. Beleza, jah tem o valor que quer trabalhar. So que ele precisa ler os bits do BYTE, porque precisa escrever bit
      // por bit. Entao ele faz a seguinte jogada: ele faz uma operacao AND com o valor 0x80, que em binario eh 1000 0000. Isto
      // quer dizer que, se o bit mais significativo de valores[2] for 1 (como por exemplo, se o valor passado for 0xAC, que
      // em binario representa 1010 1100, se fizer esta operacao chamada de "mascara" o resultado serah 0x80; por outro lado, se fosse passado
      // se o valor fosse 0x3B, que em binario representa 0011 1011, o resultado da operacao sera 0x00.
      // Veja que o if compara o resultado com 0 (ali ó, ==0), entao deste jeito ele verifica se o bit eh 0 ou nao eh zero
      if( ( *(eo + (NUMBER_OF_74595-1)) & 0x80) == 0 )
         output_low(EXP_OUT_DO);   // Se ele verificou que o bit eh zero, entao coloca a linha de Data Out em nivel baixo
      else                                        // Caso contrario, ele verificou que o bit entao eh 1
         output_high(EXP_OUT_DO);  // Entao coloca a linhas de Data Out em nivel alto
     
     //Pra entender o comando abaixo, eh preciso dar uma lida no manual do CCS. Basicamente, voce passa pro comando
     // o ponteiro de um array, diz quantos bytes o array tem, e ele enfia pela esquera um bit e faz todos os bits pularem uma
     // casa para a esquerda. No caso abaixo, ele enfia um zero (mas isso nao faz nenhuma diferenca), e depois deste comando
     // o bit mais significativo do byte mais significativo (ou seja, o bit MSB de valores[2]) vai pro espaco, e o bit que estava do lado dele
     // assume seu lugar
     shift_left(eo,NUMBER_OF_74595,0);

     // Os dois comandos abaixo geram um pulso de clock, ou seja, vao para nivel alto, depois para nivel baixo
     output_high(EXP_OUT_CLOCK);
     output_low(EXP_OUT_CLOCK);
  }
 
  // Aqui gera mais um pulso, que suponho que esteja ligado no pino RCLK do 74595, que pega os bits que foram rotacionados
  // e escreve ele nos pinos de saida
  output_high(EXP_OUT_ENABLE);
  output_low(EXP_OUT_ENABLE);
}


Se ficou alguma dúvida, é só perguntar!

é isso aí. vá! enfrente! bom, não é o 'esplicamento' que vc merece mas vou tentar mostrar uma altenativa mais infantilizada para escrever em um 595 com o hitech-c
cpp code

#define EXP_OUT_CLOCK RB0
#define EXP_OUT_ENABLE RB1
#define EXP_OUT_DO RB2
void write_expanded_outputs(unsigned char dado)
{
unsigned char i;
for(i=0;i<8;i++) //8 bits
	{
	EXP_OUT_DO=dado; // não se preocupe: apenas o bit0 de dado vai para RB2. (no MEU hw não importa a ordem)
	EXP_OUT_CLOCK=1;EXP_OUT_CLOCK=0;//um pulso em RB1 para deslocar INTERNAMENTE um bit no hw do 595
	dado>>=1;//na próxima passada pela iteração, vou querer o próximo bit
	}
EXP_OUT_ENABLE=1;EXP_OUT_ENABLE=0;//bom, agora que INTERNAMENTE o 595 está pronto, posso expor em sua saída
}

se necessário N 595, chame a função write_expanded_outputs() N vezes...
cpp code

#define N 3
unsigned char d[N];
d[0]=0xaa;//p.ex.
d[1]=0x55;
...
//d[N-1]=xxx;
void writen_595(void)
{
unsigned char i;
for (i=0;i<N;i++) write_expanded_outputs(d[i]);
}

siga a dica do amigo vtr e dê uma olhada no datashit do 595. portas e mente se abrirão.

VTRX grato pela a tensão !!,
xultz grato pela atensão !!,
ze grato pela atensão em fim Obrigado a todos !!!




Agora as dicas postadas irei avalialas com calma , caso algo que eu não tenha entendido , ierei corresponder!!
até mais ...

Xults acabeide enviar uma PM com imagem do meu projeto uma matriz de led 8x8 que forma um quadro e junto o seu respctivo codigo compilado
para avaliação se fiz a coisa serta , Agradecimentos!!

Ola amigo METABEE.

Sou um veterano na eletronica e estou cursando engenharia tal como vc, suponho que nao tenham experiencia ou estudo anterior no ramo, tal como muito colegas que tenho nessa empreitada.

A eletronica, envolve diversas areas do conhecimento humano e ela mesma acaba se desdobrando em varios outros campos, no caso estamos lidando com dois campos em seu pedido, um que eh a programacao e outro que eh a eletronica digital.

Como o colega VTRX colocou, uma boa abordagem do problema eh entender o 595 antes de programar qualquer coisa, entender a recepcao de um bit, em que borda ele sera aceito pelo o CI, o que o sinal de ENABLE vai fazer nos demais pinos e assim por diante.
Uma vez que fique claro, procure observar o codigo, ele nada mais eh do que comando para operar esse CI, feito uma sequencia logica e estabelecida.
Na minha opiniao, re escreve o codigo em portugues ou desenhe, pode parecer idiota fazer isso, mas nao eh.
Saiba que esse codigo eh muito simples e esse eh momento para aprender, quando entender possivelmente vai sentir um enorme prazer, como ja falado, o pote conhecimento tem as bordas azedas, mas seu conteudo eh puro mel.

Um abraco e seja bem vido ao ASM51.

METABEE escreveu:Xults acabeide enviar uma PM com imagem do meu projeto uma matriz de led 8x8 que forma um quadro e junto o seu respctivo codigo compilado

Posta essas informações aqui também.
Pode ser que alguem mais dê alguma dica importante.


+++

ai pessoal tentei mais não ouve exito não consigo , devo dizer que realmente quando não se entende o que esta se fazendo
é desanimador mais naõ é impossivel , ai pessoal alguem se desapega e poderia postar algo apenas com a imagem que estou tentando fazer
um quadrardo com 2 shift register !! Desapega pessoal!!apenas um exemplo!! Rsrs!
consigo fazer isso sem os 74595 apenas utilizando matrizes mais da muito trabalho e toma muito tempo !! OK!

Cara fan de MEDABOTS, por favor coloque o datasheet, esquema ou as informacoes que possui da matrix de leds, que poderemos lhe ajudar mais.

Como ja foi citado a tempos no outro fórum,esquece esse PIC e use o 16F628,e use uma varredura simples e não varredura com latch,que no seu caso se for para uma matriz a programação fica muito longa.
Voce ja deve ter dado uma olhada a muito tempo atrás no link do vídeo que postei;


Para o seu aprendizado,esquece o programa do vídeo,a programação ASM,mas olhe para o esquema no Proteus,é usado um 74HC164 para cada matriz e um 16F628 que é um PIC de 'esquina',que você encontra em qualquer farmácia.
Você quer apenas usar uma matriz?
Ja tem o hardware montado?

MetaBee, colocou uns resistores para polarizar os leds da matrix ne, se não fizer isso pode queimar ela.

Naõ , preciso espandir por isso estou tentando usar dois shift um para linha e outro para coluna
entendendo o funcionamento linha e coluna utilizando a biblioteca 74595 ...

alguem pode me esplicar um pouco sobre
ou dar um exemplo de codigo desse comando!?
shift_left(eo,NUMBER_OF_74595,0);

Cara, esse comando é o seguinte:
Primeiro vamos entender o que é um shift: ele desloca os bits prá um lado ou pro outro, e coloca um bit na primeira posição. A maioria dos comandos shift (como o comando >> da linguagem C) coloca um bit zero, mas este comando do CCS permite que você escolha se quer colocar 0 ou 1.

Vamos supor, primeiramente, que tenho somente 1 byte, cujo valor é 0xA9, que em binario é 10101001, certo?
Aí eu decido fazer um shift left, colocando 0 na primeira posicao. O que o PIC faz é girar todos os bits prá esquera, e coloca um zero lá na última posição. Fica assim:
01010010
Aí eu devido fazer de novo:
10100100
De novo:
01001000
De novo:
10010000
Agora eu decido fazer três vezes na sequência, só que colocando 1
00100001
01000011
10000111

Agora vou fazer três prá direita, colocando 0
01000011
00100001
00010000

Beleza até aqui?

O comando shift_left faz exatamente isto, porém você passa um array inteiro, e ele gira a galera toda.
Vamos supor que eu tenha o seguinte array:
unsigned char val[4];
val[0] = 0xA9;
val[1] = 0x32;
val[2] = 0xB4;
val[3] = 0x3C;

na memória, este valores em binário são:
00111100 10110100 00110010 10101001
Sendo que representei as posições de trás prá frente, prá ficar mais fácil de entender, ou seja, o valor mais da esquerda acima é 0x3C, que é val[3], o seguinte é 0xB4, que é val[2], e assim por diante.
Aí eu decido fazer uma shift_left. O comando será
shift_left(val, 4, 0);
Isso quer dizer "Rotacione para a esquerda o array cujo ponteiro é val, que possui 4 bytes, e coloque um 0.
O resultado será:
01111001 01101000 01100101 01010010
e os valores de val serão: val[0] = 0x62, val[1] = 0x65, val[2] = 0x68, val[3] = 0x79

Me fiz entender?

XultZ, Parceiro Valeu mesmo!

minha mente ficou esclarecida agora ,então entendi um pouco quer dizer então se fosse rotacionar para a
direita seria shift right !!

Ai obtive EXITO MAIS PESSOAL !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!HEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE MAIS ...MAIS... compilou mais não funcionou no proteus Xults não conssegui

poderia me enviar uma PMcaso não queira postar aqui!! POR favor PELOS DEUSES EU IMPLORO!!!!!! kkkkkkkkkk! quem não chora não mamã kkkkkkkkkkkkkkkkkkkkkkkk! quase Xults!!! pra mim é motivo pra comemorar chegou a compilar montei no proteus mais não vi nada!!
BELEZA AMIGO qualquer coisa Ai!! uma ideia a mais sera sempre bem vinda!!

cpp code

#include <16f84a.h>
#use delay(clock=4M)
#fuses hs,protect
#use fast_io(b)

#IFNDEF EXP_OUT_ENABLE
#define EXP_OUT_ENABLE  PIN_B0
#define EXP_OUT_CLOCK   PIN_B1
#define EXP_OUT_DO      PIN_B2
#define NUMBER_OF_74595 1
#ENDIF

 int set[12]=
{
   0x00,0x08,   //   X=8
   0x00,0x08,   //   Y=8
   0xFF,   //   ########
   0x81,   //   #......#
   0x81,   //   #......#
   0x81,   //   #......#
   0x81,   //   #......#
   0x81,   //   #......#
   0x81,   //   #......#
   0xFF    //   ########
}; 

void write_expanded_outputs(BYTE* eo) 
{
  BYTE i;

  output_low(EXP_OUT_CLOCK);
  output_low(EXP_OUT_ENABLE);

  for(i=1;i<=NUMBER_OF_74595*8;++i) {  // Clock out bits from the eo array
    if((*(eo+(NUMBER_OF_74595-1))&0x80)==0)
      output_low(EXP_OUT_DO);
    else
      output_high(EXP_OUT_DO);
   shift_left(eo,NUMBER_OF_74595,0);
   output_high(EXP_OUT_CLOCK);
   output_low(EXP_OUT_CLOCK);
  }
  output_high(EXP_OUT_ENABLE);
  output_low(EXP_OUT_ENABLE);

}

    
void main() {
 
while(true) {
 // set=0xf00ff; 
 
write_expanded_outputs(set); 
}
}