Projeto propeller clock.

[jorgeletronico]

ta ae galera o resultado final agora.

[biroxxx]

Caramba bem loco!!!

estou começando agora com eletronica, e ja vi que tem muita coisa bacana pra fazer hehe

[alexandrefdem]

Jorge, eu uso o compilador MikroC que não lê algumas instruções do seu código como o set_timer1. Acho que ele tem alguma forma específica de escrever essa função(que eu também não sei direito o que faz).

E outra coisa. Dezena, unidade e dígito correspondem a horas minutos segundos? Não entendi como o código escreve números compostos(por exemplo 12 horas) porque 1 dígito eu até entendo mas não saquei como você fez pra fazer 12 virar 1 e 2...

Se der pra me dar uma ajuda, agradeço muito.

[jorgeletronico]

Ola amigo, vou explicar como é feito:

void caracter(digito) { 

dezena = (digito/10); 
unidade = (digito-(dezena*10));

for (n=0;n<5;n++) { 
     output_b(table[dezena][n]);
    delay_ms(1); 
}
delay_ms(1); 
output_b(0xff);
delay_ms(1); 

for (n=0;n<5;n++) {
     output_b(table[unidade][n]); 
     delay_ms(1);
}
delay_ms(1); 
output_b(0xff);
delay_ms(1); 
}

observe q apos a conta para se extrair a unidade e a dezena ,a funçao se repete duas vezes amigo,dezena e unidade,temos os dois digitos então....beleza,Qto ao microc nao mexo com ele.

[alexandrefdem]

Valeu jorge! Muito bom o seu projeto por sinal. Tentei escrever meu código tentando entender o teu. ainda vou tentar, mas se nada der certo uso teu código(todos os teus direitos reservados, relaxa ^^)

Mas, me explica...

#int_TIMER1 //Interrupção do Timer1

essa instruçãa serve, na prática, pra quê? por quê ela é necessária?

set_timer1 (3036); //Preload do Timer1

3036 o quê? ms?

void main() {

setup_timer_1 (T1_INTERNAL | T1_DIV_BY_8); //Configuração do Timer1 para clock interno = 1E6 dividido por 8

set_timer1 (3036);

enable_interrupts(INT_TIMER1); //Habilita interrupção timer1

enable_interrupts(global); //habilita interrupcão global

E essas instruções do Main que não entendi...

Se você desmistificar isso, tenho chance de escrever meu código \o/

[hudmal69]

fico feliz em ver apaixonados por eletronica como eu, e feliz por sua dedicação e determinação, amigo continue porque os que tem sede de sabedoria nunca tera limites.

[caroline cabral]

que asim seja amen

[Phenom_X4]

Bom pessoal, primeiramente um Feliz 2012!!

..é que eu gostaria de ver as fotos do propeller clock e de seu circuito... não pude ver antes de serem retiradas...

mas desde já parabéns Jorge pelo seu projeto...

[jorgeletronico]

Eu tive q excluir alguns anexo pra poder postar outras imagens,mais ficou desse jeito ai,qualquer coisa so falar.Abraços.

[Fervolt]

Bom dia,

Bem legal seu propeller, parabéns!!

Eu tenho um também, nem lembrava mais, só que o meu é mais simples, usa 2 baterias CR2016 onboard e é tipo "AXIAL", programado em C (ccs) e consegue escrever até 16 caracteres rotacionando. Se você permitir posso postar uma foto.

Abraço

[jorgeletronico]

o veio porque nao postou ,me interessei pelo projeto.Posta ai o material.O meu escreve bom dia,boa tarde e boa noite ,dependendo do horario.

[mister nintendo]

cara to fazenu o meu só falta o codigo quando terminado posto tudo aqui

[Fervolt]

Bom dia,

Segue um vídeo que fiz ontem do meu propeller.

Arquivo propeller.h (somente cabeçalho)

#include <16F628A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOBROWNOUT               //No brownout reset
#FUSES MCLR                     //Master Clear pin enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
//#FUSES RESERVED                 //Used to set the reserved FUSE bits

#use delay(clock=4000000)

Arquivo graphics.c (adaptado do próprio ccs)

/////////////////////////////////////////////////////////////////////////
//// Defines a 5x7 font
/////////////////////////////////////////////////////////////////////////
const int8 FONT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
                         0x00, 0x00, 0x5F, 0x00, 0x00, // !
                         0x00, 0x03, 0x00, 0x03, 0x00, // "
                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #
                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
                         0x43, 0x33, 0x08, 0x66, 0x61, // %
                         0x36, 0x49, 0x55, 0x22, 0x50, // &
                         0x00, 0x05, 0x03, 0x00, 0x00, // '
                         0x00, 0x1C, 0x22, 0x41, 0x00, // (
                         0x00, 0x41, 0x22, 0x1C, 0x00, // )
                         0x14, 0x08, 0x3E, 0x08, 0x14, // *
                         0x08, 0x08, 0x3E, 0x08, 0x08, // +
                         0x00, 0x50, 0x30, 0x00, 0x00, // ,
                         0x08, 0x08, 0x08, 0x08, 0x08, // -
                         0x00, 0x60, 0x60, 0x00, 0x00, // .
                         0x20, 0x10, 0x08, 0x04, 0x02, // /
                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
                         0x00, 0x04, 0x02, 0x7F, 0x00, // 1
                         0x42, 0x61, 0x51, 0x49, 0x46, // 2
                         0x22, 0x41, 0x49, 0x49, 0x36, // 3
                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4
                         0x27, 0x45, 0x45, 0x45, 0x39, // 5
                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6
                         0x01, 0x01, 0x71, 0x09, 0x07, // 7
                         0x36, 0x49, 0x49, 0x49, 0x36, // 8
                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9
                         0x00, 0x36, 0x36, 0x00, 0x00, // :
                         0x00, 0x56, 0x36, 0x00, 0x00, // ;
                         0x08, 0x14, 0x22, 0x41, 0x00, // <
                         0x14, 0x14, 0x14, 0x14, 0x14, // =
                         0x00, 0x41, 0x22, 0x14, 0x08, // >
                         0x02, 0x01, 0x51, 0x09, 0x06, // ?
                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @
                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A
                         0x7F, 0x49, 0x49, 0x49, 0x36, // B
                         0x3E, 0x41, 0x41, 0x41, 0x22, // C
                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D
                         0x7F, 0x49, 0x49, 0x49, 0x41, // E
                         0x7F, 0x09, 0x09, 0x09, 0x01, // F
                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G
                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H
                         0x00, 0x41, 0x7F, 0x41, 0x00, // I
                         0x30, 0x40, 0x40, 0x40, 0x3F, // J
                         0x7F, 0x08, 0x14, 0x22, 0x41, // K
                         0x7F, 0x40, 0x40, 0x40, 0x40, // L
                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N
                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O
                         0x7F, 0x09, 0x09, 0x09, 0x06, // P
                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
                         0x7F, 0x09, 0x09, 0x09, 0x76};// R

const int8 FONT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S
                         0x01, 0x01, 0x7F, 0x01, 0x01, // T
                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U
                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V
                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W
                         0x41, 0x22, 0x1C, 0x22, 0x41, // X
                         0x07, 0x08, 0x70, 0x08, 0x07, // Y
                         0x61, 0x51, 0x49, 0x45, 0x43, // Z
                         0x00, 0x7F, 0x41, 0x00, 0x00, // [
                         0x02, 0x04, 0x08, 0x10, 0x20, // \
                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]
                         0x04, 0x02, 0x01, 0x02, 0x04, // ^
                         0x40, 0x40, 0x40, 0x40, 0x40, // _
                         0x00, 0x01, 0x02, 0x04, 0x00, // `
                         0x20, 0x54, 0x54, 0x54, 0x78, // a
                         0x7F, 0x44, 0x44, 0x44, 0x38, // b
                         0x38, 0x44, 0x44, 0x44, 0x44, // c
                         0x38, 0x44, 0x44, 0x44, 0x7F, // d
                         0x38, 0x54, 0x54, 0x54, 0x18, // e
                         0x04, 0x04, 0x7E, 0x05, 0x05, // f
                         0x08, 0x54, 0x54, 0x54, 0x3C, // g
                         0x7F, 0x08, 0x04, 0x04, 0x78, // h
                         0x00, 0x44, 0x7D, 0x40, 0x00, // i
                         0x20, 0x40, 0x44, 0x3D, 0x00, // j
                         0x7F, 0x10, 0x28, 0x44, 0x00, // k
                         0x00, 0x41, 0x7F, 0x40, 0x00, // l
                         0x7C, 0x04, 0x78, 0x04, 0x78, // m
                         0x7C, 0x08, 0x04, 0x04, 0x78, // n
                         0x38, 0x44, 0x44, 0x44, 0x38, // o
                         0x7C, 0x14, 0x14, 0x14, 0x08, // p
                         0x08, 0x14, 0x14, 0x14, 0x7C, // q
                         0x00, 0x7C, 0x08, 0x04, 0x04, // r
                         0x48, 0x54, 0x54, 0x54, 0x20, // s
                         0x04, 0x04, 0x3F, 0x44, 0x44, // t
                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u
                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v
                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w
                         0x44, 0x28, 0x10, 0x28, 0x44, // x
                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y
                         0x44, 0x64, 0x54, 0x4C, 0x44, // z
                         0x00, 0x08, 0x36, 0x41, 0x41, // {
                         0x00, 0x00, 0x7F, 0x00, 0x00, // |
                         0x41, 0x41, 0x36, 0x08, 0x00, // }
                         0x02, 0x01, 0x02, 0x04, 0x02};// ~
/////////////////////////////////////////////////////////////////////////

Arquivo propeller.c (programa principal)

#include "propeller.h"
#include "graphics.c"

int8 letra[5];

void texto57(char* textptr, int posicao){
   int8 h;   
   h = 0; 

   textptr += posicao;

         if(*textptr < 'S') 
            memcpy(letra, FONT[*textptr - ' '], 5);
         else if(*textptr <= '~')
            memcpy(letra, FONT2[*textptr - 'S'], 5);
         else
            memcpy(letra, FONT[0], 5);

}

//****************** Rotina principal ******************//
void main(){
   int8 n, m, inicio, fim, atual, tamanho, comeco;

   char texto[] = "                 Feliz 2012 a todos do Forum Clube do Hardware!!               ";

   *cmcon = 0x07;
   atual = 0;
   m=0;
   tamanho = sizeof(texto)-2;

   output_b(255);
   output_bit(pin_a6, 1);
   output_bit(pin_a7, 1);

   delay_ms(3000); //Acende todos os leds por 3 segundos, para teste 

   while(1){
      if(!input(PIN_A0)){                     
               delay_ms(5);

               for(inicio = 0; inicio < 17; inicio++){

                  if(fim+inicio < tamanho){
                     texto57(texto, fim+inicio);
                  }else{
                     fim = 0;
                  }  

                  for(n = 0; n < 5; n++){

                     output_bit(pin_a6, bit_test(letra[n], 4));
                     output_bit(pin_a7, bit_test(letra[n], 6));

                     output_b(letra[n]);
                     delay_us(180);

                     output_low(pin_a6);
                     output_low(pin_a7);

                     output_b(0);
                     delay_us(230);
                  }
                  delay_us(320);
               }
               m++;
               if(m == 2){
                  atual++;
                  fim++;
                  m = 0;
               }
      }
   }   

//*********** FIM LOOP PRINCIPAL *************
}

O programa foi desenvolvido por mim, peguei a tabela de caracteres pronta do ccs (um dos motivos que prefiro o ccs ao mikroc ). Acredito que da pra melhorar esse código, minha intenção era implementar um controle IR para editar a frase mas não tive mais tempo.

Se alguém tiver alguma dúvida é só perguntar.

Att,

Fervolt

[gilsonpa]

vocês tem o esquema completo? e o hex compilado para o pic?esse serve pra relogio tambem? tem k ter outro hex?

[AGNETHOFRID]

desculpe minha ignorância mas eu tenho um monte de sucata eletrônica aqui e estou doido pra fazer um desses só que estou boiando no assunto alguém poderia me dar uma aula básica pra eu poder entender.

[Aldemir Marques]

olá jorge,gostei do projeto do relógio,resolvi montar um,estou tendo dificuldade com a mensagem,

é preciso fazer outra tabela para as letras?,se poder me ajudar agradeço,

[Daniela Eudes]

OLÁ JORGE você TERIA AI O ESQUEMA DO CIRCUITO FEITO NO PROTEUS SE TIVER ME MANDA AI. VALEU AGRADEÇO SE PUDER