Contador/cronometro com TPIC6B595N e display de 7 segmentos 12V anodo comum

Gabriel_ggp · 6 de outubro de 2018

Olá estou fazendo projetando um placar eletrônico com o microcontrolador ATMEGA328p, que irá utilizar displays de 7 segmentos anodo comum (12Volts) controlados pelo CI TPIC6B595N, o qual é um shift register (registrador de deslocamento).

datasheet TPIC6B595N : http://www.ti.com/lit/ds/symlink/tpic6b595.pdf

Inicialmente quero conseguir controlar apenas um display, para finalmente entender o funcionamento do TPIC6B595N ;

Porém estou encontrando alguns problemas, que creio eu ser da programação (porém pode ser da montagem);

Obs: para realizar os testes estou utilizando um arduino duemilinove.

É dessa maneira que o CI está conectado ao placar (olhe o conector na foto)

Por fim gostaria de pedir ajuda de vocês para descobrir onde estou errando....

Att: Gabriel Gimenes Pedroza

Segue em anexo a foto do display

Programação:

// variávis globais
int LATCH = 2; // pino 12 do TPIC6B595
int CLK = 3; // pino 13 do TPIC6B595
int DATA = 4; // pino 3 do TPIC6B595

//declarando os numeros que aparecerão no display
byte digito1[10] =
{
11000000, //0
11111001, //1
10100100, //2
10110000, //3
10011001, //4
10010010, //5
10000010, //6
11111000, //7
10000000, //8
10010000 //9
};

byte digito2[10] =
{
11000000, //0
11111001, //1
10100100, //2
10110000, //3
10011001, //4
10010010, //5
10000010, //6
11111000, //7
10000000, //8
10010000 //9
};

int i;
int j;

void setup() {

pinMode(LATCH, OUTPUT); // define pino 12 do TPIC6B595 como saida
pinMode(CLK, OUTPUT); // define pino 13 do TPIC6B595 como saida
pinMode(DATA, OUTPUT); // define pino 3 do TPIC6B595 como saida

}

void loop() {

for (int i = 0; i <= 10; i++) { // contador da primeira casa decimal
if (int i = 9) { // inicia contador da segunda casa decimal
j++; // contador da segunda casa decimal

digitalWrite(CLK, LOW);
digitalWrite(LATCH, LOW); // permite a transferencia de dados para o TPIC6B595
shiftOut(DATA, CLK, MSBFIRST, digito1); // envia dados para o digito 1
shiftOut(DATA, CLK, MSBFIRST, digito2[j]); // envia dados para o digito 2
digitalWrite(LATCH, HIGH); // finaliza a transferencia de dados para o TPIC6B595
delay(1000);
}
}
}

.if · 6 de outubro de 2018

1 hora atrás, Gabriel_ggp disse:

finalmente entender o funcionamento do TPIC6B595N

isso é totalmente bom.

1 hora atrás, Gabriel_ggp disse:

encontrando alguns problemas

isso é pouco. Fale mais... beeeeem mais

Gabriel_ggp · 6 de outubro de 2018

6 horas atrás, Isadora Ferraz disse:

isso é totalmente bom.

isso é pouco. Fale mais... beeeeem mais

Acabei me esquecendo de falar o meu problema....

Eu utilizei uma fonte de bandacada variável para alimentar os 12v do placar e a alimentação do CI foi com a tensão fornecida pelo Arduino.....

Assim que eu ligava tudo o display acendia todos os segmentos e o ponto decimal, porém quando eu passava a programação para o arduíno não surtia nenhum efeito no display, além de que algumas vezes eu energizava o circuito e o display não acendia.

Revi todas as ligações do circuito, bem como a programação, mas não acho erro algum.... Por isso estou aqui pedindo um help!!!

.if · 7 de outubro de 2018

Em 06/10/2018 às 11:24, Gabriel_ggp disse:

shiftOut(DATA, CLK, MSBFIRST, digito1); // envia dados para o digito 1
shiftOut(DATA, CLK, MSBFIRST, digito2[j]); // envia dados para o digito 2

por acaso não está faltando o index do digito1?

Bem de fato este ci é relativamente simples de programar bastando dar uma ohadela no d.s. dele. Pra você refletir...

-ele é bem parecido com um 74hc595 anabolizado. É bem simples:desloca 8 bits e chuta pra fora

-você pode ligar os ci's em cascata - em série - ligando ser-out de um no ser-in do próximo

-não precisa de uma tabela pra cada display: basta uma

-ele é dreno aberto ou seja pra display anodo comum ou seja aciona com 0. Sua tabela parece aciona com um

-Simule pra ver. Coloque oscliloscópio nos sinais.

Continuo achando que seu complemento ainda não foi suficiente e não pule a etapa do pisca led.

Gabriel_ggp · 7 de outubro de 2018

8 horas atrás, Isadora Ferraz disse:

8 horas atrás, Isadora Ferraz disse:

por acaso não está faltando o index do digito1?

Isso está na minha programação, porém quando colei aqui sumiu....

8 horas atrás, Isadora Ferraz disse:

Simule pra ver. Coloque oscliloscópio nos sinais.

Pretendo fazer isso essa semana, quando eu fizer falo os resultados.....

8 horas atrás, Isadora Ferraz disse:

Continuo achando que seu complemento ainda não foi suficiente e não pule a etapa do pisca led.

não entendi o que você quis dizer

.if · 8 de outubro de 2018

Não consegui entender onde você acha que tá o problema e se você sabe o que cada função faz e como faz. Daí a importância da etapa 'pisca led'.

Vou complementar a mim...

-use interrupção e faça a varredura dos displays dentro dela. E não dentro do loop principal

-em c (e mínimo conhecimento do hw do mc) é fácil. Sorry não vou com a cara desta linguagem do arduino

Gabriel_ggp · 13 de outubro de 2018

Achei uma programação que funcionou perfeitamente, para fazer a contagem de 0 a 9 e por último acendendo o ponto decimal......

Porém como sou novo em programação não entendi muito bem como realiza esses comandos....

Gostaria que você me ajudasse a entender essa programação comentando as linhas ou me explicando de algum jeito, pois realmente quero saber como funciona e não estou conseguindo

#define pino12_RCK 8
#define pino13_SRCK 9
#define pino3_SER_IN 10
#define pino9_G 11 
#define  _8Bit 0b10000000
uint8_t F82ReleCmd;
//   0 .ABCDEFG  1 .GFEDCBA  2 .GFEDCBA  3 .GFEDCBA  4 .GFEDCBA  5 .GFEDCBA  6 .GFEDCBA  7 .GFEDCBA  8 .GFEDCBA  9 .GFEDCBA  . .GFEDCBA 
const uint8_t Num_Let_7Se[11] = {0b00111111, 0b00000110, 0b01011011, 0b01001111, 0b01100110, 0b01101101, 0b01111101, 0b000000111, 0b01111111, 0b1101111, 0b10000000};
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\////\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
void F01_IMPRIME_TPIC(uint8_t F01ee)
{
    uint8_t F01aa;	
    for (F01aa = 0; F01aa != 8; F01aa++) 
	{
        if (0 == (F01ee & _8Bit))
			digitalWrite(pino3_SER_IN, LOW);
        else
			digitalWrite(pino3_SER_IN, HIGH);
        F01ee = F01ee << 1;
		digitalWrite(pino13_SRCK, HIGH);
		digitalWrite(pino13_SRCK, LOW);
    }
}
void setup() 
{
	pinMode(pino12_RCK, OUTPUT);
	pinMode(pino13_SRCK, OUTPUT);
	pinMode(pino3_SER_IN, OUTPUT);
	pinMode(pino9_G, OUTPUT);
	digitalWrite(pino9_G, LOW);
	F82ReleCmd = 0;
}
void loop() 
{
	delay(300);                       
	F01_IMPRIME_TPIC(Num_Let_7Se[F82ReleCmd]);
	digitalWrite(pino12_RCK, LOW);
	digitalWrite(pino12_RCK, HIGH);
	F82ReleCmd ++;
	if (F82ReleCmd == 11)
	{
		F82ReleCmd = 0;
	}
}

Ricardov · 13 de outubro de 2018

Para postar o código use o botão <> (code) do editor. Fica melhor.

Gabriel_ggp · 13 de outubro de 2018

3 horas atrás, Ricardov disse:

Para postar o código use o botão <> (code) do editor. Fica melhor.

Muito obrigado !!!

.if · 14 de outubro de 2018

Bacana. mas antes é preciso que você entenda com funciona o 595. Me explique pelo seu princípio básico.

Depois disso, por partes..

const uint8_t Num_Let_7Se[11] = {0b00111111, 0b00000110,

é uma tabela de dados constantes indexáveis que ficam gravados na flasheprom ou rom e não na ram. Espero que saiba a diferença entre rom e ram.

to be continued...

Gabriel_ggp · 18 de outubro de 2018

Em 13/10/2018 às 21:41, Isadora Ferraz disse:

Bacana. mas antes é preciso que você entenda com funciona o 595. Me explique pelo seu princípio básico.

De acordo com as minhas pesquisar o 595 em geral é um deslocador de bits.

Especificamente o que estou usando é utilizado para controlar cargas com uma corrente e tensão um pouco mais elevada.

Basicamente ele transforma a informação (bits) de serial para paralelo, deslocando os mesmos para suas respectivas saídas, isso de acordo com um clock.

Seus pinos e suas funções:
SER IN: entrada de dados (serial), ou seja, entra um byte que é jogado em cada DRAIN (saída);

DRAIN: São as saídas paralelas;

SRCLR: limpa os dados do registrador;

G: Ativa as saídas quando em HIGH;

RCK: Permite a passagem de dados para as saídas paralelas (sensível a borda de subida);

SRCK: pulso de clock que faz com que um bit seja deslocado (sensivel a borda de subida);

SER OUT: saída de dados que permite o cascateamento.

Em 13/10/2018 às 21:41, Isadora Ferraz disse:

Depois disso, por partes..

const uint8_t Num_Let_7Se[11] = {0b00111111, 0b00000110,

é uma tabela de dados constantes indexáveis que ficam gravados na flasheprom ou rom e não na ram. Espero que saiba a diferença entre rom e ram.

to be continued...

Até aqui eu consegui entender....

Uma das minhas dúvidas é saber se quando eu declaro uma variável como "uint8_t" o valor inicial dela é 00000000, como por exemplo quando quando diz que " (uint8_t F01ee) " , o valor de F01ee inicial é igual a 00000000 ?

Outro questionamento que surgiu é saber o que acontece / pra quer serve a informação que é colocada entre parênteses após declarar uma variável "void", como por exemplo:

" void F01_IMPRIME_TPIC(uint8_t F01ee) {"

Agradeço desde já sua ajuda !!!

aphawk · 19 de outubro de 2018

Olha, tenho de concordar com a @Isadora Ferraz .... quanto mais eu leio esses comandos dessa linguagem, menos entendo ....

Paulo

.if · 19 de outubro de 2018

Sim a maioria dos compiladores definem como zero na inicialização. De fato quem faz isso é o hw do mc. Consulte o ds do seu. Mas em ambientes críticos e em sistemas mais robustos penso que custa pouco você fazer

//#define uint8_t F01ee unsigned char //uint8_t não á ansi c. Depende do seu compilador.

uint8_t F01ee=0b00000000;

11 horas atrás, Gabriel_ggp disse:

pra quer serve a informação que é colocada entre parênteses após declarar uma variável "void"

void é vazio. De fato nem precisa mencionar. É só questão de padronização ansi antiga (=eu). Uso colocar só por questão de gosto mesmo. É meio que pra garantir que a função não vai retornar nada e evitar o uso de memória.

O que está entre parêntesis é o argumento da função. Ou seja o dado a ser manipulado que ela leva consigo. Algo como uma semente que te entrego, você planta, cuida e me devolve flores.

O detalhe interessante é que a função não pode ser tipo void

11 horas atrás, Gabriel_ggp disse:

void F01_IMPRIME_TPIC(uint8_t F01ee) {

pois void é o tipo de retorno e me retornaria ... vazio.

Olha isso bem elementar meeeesmo:

char mult(char a, char b)
{
return a*b;
}

quando fizer

c=mult(5,2);// vai retornar ... 10 em c. Em c é 10 ... menos pro Paulão kk

Agora tenta fazer:

void mult(char a, char b)
{
return a*b;
}

o compilador vai chiar.

e se fizer:

mult(char a, char b)
{
return a*b;
}

ele deve chiar menos só te dando um warning tipo implicit return ou algo do gênero...

Mas colocando a carroça na frente do cavalo, se algum dia você for programar pra ambientes críticos, médico, aeroespacial e afins, não se acostume com os warnings pois não deve te deixar muito a vontade né? Mas por hora.. sem paranóia...

aphawk · 19 de outubro de 2018

Em ‎13‎/‎10‎/‎2018 às 21:41, Isadora Ferraz disse:

const uint8_t Num_Let_7Se[11] = {0b00111111, 0b00000110,

é uma tabela de dados constantes indexáveis

?

2 horas atrás, Isadora Ferraz disse:

//#define uint8_t F01ee unsigned char //uint8_t não á ansi c. Depende do seu compilador.

uint8_t F01ee=0b00000000;

??

2 horas atrás, Isadora Ferraz disse:

O detalhe interessante é que a função não pode ser tipo void

14 horas atrás, Gabriel_ggp disse:

void F01_IMPRIME_TPIC(uint8_t F01ee) {

pois void é o tipo de retorno e me retornaria ... vazio.

??????

2 horas atrás, Isadora Ferraz disse:

Em c é 10 ... menos pro Paulão kk

Meu Deus ..... acho que já passei de minha hora por aqui .....

Paulo

.if · 19 de outubro de 2018

16 minutos atrás, aphawk disse:

Meu Deus ..... acho que já passei de minha hora por aqui .....

Vamos inverter isso daí!! Meu Deus, dê muitas e muitas e muitas horas, dias e anos a mais pro amigo Paulão! Ele tem muito que aprender ainda mas o principal.. a ensinar! kk

Um extra só porque é pra você...

const uint8_t Num_Let_7Se[11] = {0b00111111, 0b00000110,

O amigo não escolheu muito bem os nomes (ou a fonte do seu ctrl-c ctrl-v) mas é relativamente simples:

char const tabela[11]={0b00111111, 0b00000110, ... //onze entidades . o 0b instrui o compilador pra considerar como binário

é um banquinho de dados que o mc pega diretamente da flash (const). Se fizer

PORTD=tabela[0]; //(o zero conta)

os bits 001111111 vão ficar nos pinos. Viu que o 0b00111111 é o 1º da lista?

O legal é que o índice da tabela[i] pode ser uma variável a qual localizo o que quero no banquinho de dados.

P.ex. outra utilidade: gerar uma tabela de seno no excel e colocar no mc pra gerar onda senoidal por pwm. Fiz isso prum inversorzinho de frequencia com pic onde obtive sucesso total com 16 senos precalculados. Obviamente muito mais rápido do que obrigar o mc a fazer o cálculo.

E aí... está gostando da introdução no ... ops! na linguagem c? kk

abç e tmj...

aphawk · 19 de outubro de 2018

@Isadora Ferraz ,

Sim, entendí o que significa, mas acho uma baita complicação de "protocolo" , muita complicação e conhecimento do compilador .....

Eu estou acostumado a fazer isso de uma maneira que me parece bem mais "legível" :

Dim Num_Let_7Se(11) as Byte ; Num_Let_7Se(1) = &b00111111 ; Num_Let_7Se(2) = ..............

Para usar um index X :

Dim X as Byte ; x=1

Num_Let_7se(x) = &h031 e pronto o primeiro elemento mudou para esse valor.

Agradeço o seu esforço por tentar me introduzir no C ( conforme leitura rápida e literal ) , mas realmente como diz o caipira, ocê não faz meu tipo kkkk

Embora me sinta meio inútil nos dias de hoje, em que é tudo tipo IDE do Arduíno ou C, tento ajudar da minha velha maneira !

adicionado 2 minutos depois

3 horas atrás, Isadora Ferraz disse:

gerar uma tabela de seno no excel e colocar no mc pra gerar onda senoidal por pwm. Fiz isso prum inversorzinho de frequencia com pic onde obtive sucesso total com 16 senos precalculados. Obviamente muito mais rápido do que obrigar o mc a fazer o cálculo.

Sim, eu usei o mesmo conceito num post meu sobre um Gerador de Forma de Onda usando DDS, que gerava qualquer tipo de forma de onda de maneira perfeita e sem jitter ...

Paulo