|
|
| Friday, 6-Nov-2009 02:50 |
Email | Share |  | Bookmark |
|
Projetinho de fim de semana: Reloginho VFD
|
|
Comprei no ebay uns displays VFD IV-8, resolvi fazer um reloginho com eles, eles foram escolhidos porque trabalhar.
Daí foi começar a desenhar a placa e esquema enquanto a encomenda não chegava da Rússia..
O resultado do esquema e placas está nas fotos 1 e 2.
A idéia era usar um AT89s52 e depois de umas horinhas de trabalho o negócio funcionou muito bem!
O programa ocupa só 1kB da Flash e foi compilado no SDCC, deixo o código para quem quiser fazer o seu próprio reloginho!
Poutz e não é que essa nhaca de fotopage detonou a minha identação!
/*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <at89x52.h>
#define Desabilita_INT IE=0x0
#define Habilita_INT IE=0x1
// Prototipos
void inicializa_timer2(void) ;
void enviacharvfd (unsigned char disp1,unsigned char disp2, unsigned char disp3, unsigned char disp4);
void delay_ms(unsigned char ms);
// Variaveis globais
unsigned char ms100=0;
//ISR's
void Timer2_ISR(void) interrupt 5
{
ms100++;
TF2 = 0; // Apago o flag de interrupcao
}
void main(void)
{
unsigned char segundos, min1, min2, hor1, hor2;
segundos=0;
ms100=0;
min1=0;
min2=0;
hor1=0;
hor2=0;
enviacharvfd(hor2, hor1, min2, min1);
inicializa_timer2();
while (1)
{
P2_7=1;
if (P2_7==0)
{
min1++;
enviacharvfd(hor2, hor1, min2, min1);
delay_ms(30);
}
//ms100++;
if (ms100>9)
{
ms100=0;
segundos++;
enviacharvfd(hor2, hor1, min2, min1);
}
if (segundos>59)
{
segundos=0;
min1++;
}
if (min1>9)
{
min1=0;
min2++;
}
if (min2>5)
{
hor1++;
min2=0;
}
if (hor1>9)
{
hor2++;
hor1=0;
}
if (hor2==2 && hor1>3)
{
hor1=0;
hor2=0;
}
}
}
// Modo 0 com auto reload
void inicializa_timer2(void)
{
T2MOD &= 0xFC; // T2OE=0;DCEN=1;
T2MOD |= 0x01;
EXF2=0; //apago o flag
TCLK=0;RCLK=0; // desabilita o BRG
EXEN2=0; //ignora T2ex
TH2=0x7D; //Valores de inicializacao: 100ms (4MHz) - descontos das intrucoes executadas no ISR
TL2=0xC8;
RCAP2H=0x7D; // Valores do reload
RCAP2L=0xC8;
C_T2=0; // Modo timer
CP_RL2=0; // Reload
EA=1;
ET2=1; // Habilita int do timer 2
TR2=1; // Habilito contagem do timer 2
}
// Disp1,2=horas Disp2,3=minutos
void enviacharvfd (unsigned char disp1,unsigned char disp2, unsigned char disp3, unsigned char disp4)
{
// Horas 2
//if (disp1==0x00) P0=0xA0;
if (disp1==0x00) P0=0xFF; // Não mostra nada no primeiro dígito se 0, ex 02:59 -> 2:59
if (disp1==0x01) P0=0xF3;
if (disp1==0x02) P0=0xC4;
if (disp1==0x03) P0=0xC0;
if (disp1==0x04) P0=0x93;
if (disp1==0x05) P0=0x81;
if (disp1==0x06) P0=0x88;
if (disp1==0x07) P0=0xE3;
if (disp1==0x08) P0=0x80;
if (disp1==0x09) P0=0x83;
// Horas 1
if (disp2==0x00) P1=0x82;
if (disp2==0x01) P1=0xE7;
if (disp2==0x02) P1=0x91;
if (disp2==0x03) P1=0xC1;
if (disp2==0x04) P1=0xE4;
if (disp2==0x05) P1=0xC8;
if (disp2==0x06) P1=0x88;
if (disp2==0x07) P1=0xE3;
if (disp2==0x08) P1=0x80;
if (disp2==0x09) P1=0xE0;
// Minutos 2
if (disp3==0x00) P3=0x82;
if (disp3==0x01) P3=0xE7;
if (disp3==0x02) P3=0x91;
if (disp3==0x03) P3=0xC1;
if (disp3==0x04) P3=0xE4;
if (disp3==0x05) P3=0xC8;
if (disp3==0x06) P3=0x88;
if (disp3==0x07) P3=0xE3;
if (disp3==0x08) P3=0x80;
if (disp3==0x09) P3=0xE0;
// Minutos 1
if (disp4==0x00) P2=0x82;
if (disp4==0x01) P2=0xE7;
if (disp4==0x02) P2=0x91;
if (disp4==0x03) P2=0xC1;
if (disp4==0x04) P2=0xE4;
if (disp4==0x05) P2=0xC8;
if (disp4==0x06) P2=0x88;
if (disp4==0x07) P2=0xE3;
if (disp4==0x08) P2=0x80;
if (disp4==0x09) P2=0xE0;
}
void delay_ms(unsigned char ms) // delay pra lá de aproximado!
{
unsigned char i;
while (ms> 1)
{
ms--;
for (i=0; i < 200; i++)//era 200
{
_asm
nop // o DJNZ é 2 Machine Cycles (12x4 clocks) ,NOP é 1 Machine Cycle
nop // conferir as contas e adicionar/reduzir a enrolacao da rotina ao se fazer a mudanca de cristal!
nop
_endasm; // cada machine cycle é 12 clocks!!! (que lerdeza) .. 12 MHz
}
}
}
|
|
|
|
|
|
| Sunday, 12-Jul-2009 04:35 |
Email | Share | | Bookmark |
|
STM32
|
 |
|
Nem bêbado tira foto pior!!!
|
|
|
Terminando mais uma semana com outro post, agora tratando sobre um microcontrolador no core ARM cortex-M3, vindo de uma recente aquisição de uma placa de desenvolvimento adquirida na fururelec.
O fabricante da placa mandou junto com a mesma um cabo serial de 3 fios e um cd lotado de exemplos, que podem ser baixados do site da st, a primeira idéia era ter um contato inicial com o microcontrolador compilando os exemplos.
O primeiro exemplo foi o de fazer os leds piscar...muito idiota, pra deixar o negócio mais emocionante a idéia era fazer algumas funções pra lidar com o famoso lcd feito a partir do KS0070B, mas agora em 4 bits, o sistema em 8 bits já tinha feito com sucesso anteriormente.
Após errar ligação do LCD uma vez e quebrar um pouco a cabeça como de costume cheguei nas seguintes funções com testes indicando o total funcionamento:
void Inicializa_LCD(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 |
GPIO_Pin_1 |
GPIO_Pin_2 |
GPIO_Pin_3 |
GPIO_Pin_4 |
GPIO_Pin_5 |
GPIO_Pin_6 |
GPIO_Pin_7;
GPIO_Init(GPIOC, &GPIO_InitStructure);
DelaymS(400);
Envia_comando_LCD(0x02); // 4 bits mode
Envia_comando_LCD(0x02); // 4 bits mode
Envia_comando_LCD(0x08); // 5x7 2 lines
DelaymS(5);
Envia_comando_LCD(0x00);
Envia_comando_LCD(0x0F); // Display on/cursor on part 1
DelaymS(5);
Envia_comando_LCD(0x00); // Display on/cursor on part 2
Envia_comando_LCD(0x01); // Moving direction part 1
DelaymS(5);
Envia_comando_LCD(0x08); // Moving direction part 2
Envia_comando_LCD(0x00); // Moving direction part 1
clrLCD();
}
void Envia_comando_LCD(u8 comando)
{
u16 GPIOC_saida_atual,GPIOC_saida_proxima;
comando=comando &0x0F;
GPIO_WriteBit(GPIOC,GPIO_Pin_6,Bit_RESET); // RS=0, command mode
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_RESET); // E=0
GPIOC_saida_atual=GPIO_ReadOutputData(GPIOC) & 0xFF00;
GPIOC_saida_proxima=GPIOC_saida_atual | (u16)comando;
GPIO_Write(GPIOC,GPIOC_saida_proxima);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_SET); // E=1
DelayuS(500);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_RESET); // E=0
}
void Envia_dado_LCD(u8 dado)
{
u16 GPIOC_saida_atual,GPIOC_saida_proxima;
u8 dadol, dadoh;
dadol=dado;
dado=dado&0xF0;
dadoh=dado/16;
dadoh=dadoh & 0x0F;
dadol=dadol & 0x0F;
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_RESET); // E=0
GPIO_WriteBit(GPIOC,GPIO_Pin_6,Bit_SET); // RS=1
DelayuS(500);
GPIOC_saida_atual=GPIO_ReadOutputData(GPIOC) & 0xFFF0;
GPIOC_saida_proxima=GPIOC_saida_atual | (u16)dadoh;
GPIO_Write(GPIOC,GPIOC_saida_proxima);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_SET); // E=1
DelayuS(500);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_RESET); // E=0
GPIOC_saida_atual=GPIO_ReadOutputData(GPIOC) & 0xFFF0;
GPIOC_saida_proxima=GPIOC_saida_atual | (u16)dadol;
GPIO_Write(GPIOC,GPIOC_saida_proxima);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_SET); // E=1
DelayuS(500);
GPIO_WriteBit(GPIOC,GPIO_Pin_7,Bit_RESET); // E=0
DelayuS(500);
}
u8 addressLCD;
void putcharLCD(u8 entrada)
{
u8 terminated;
terminated=0x0;
if (addressLCD<15)
{
addressLCD++;
terminated=0xFF;
}
if ((addressLCD==15) && (terminated==0x0))
{
Envia_comando_LCD(0x0C); // DDRAM 0x40 address part 1
Envia_comando_LCD(0x00); // DDRAM 0x40 address part 2
addressLCD=64;
terminated=0xFF;
}
if ((addressLCD>63) && (terminated==0x0)) // 64
{
addressLCD++;
}
if (addressLCD>79)
{
Envia_comando_LCD(0x08); // DDRAM 0x0 address part 1
Envia_comando_LCD(0x00); // DDRAM 0x0 address part 2
addressLCD=0;
}
Envia_dado_LCD(entrada);
}
Vale ressaltar que estas funções foram feitas em cima do exeplo do led, e por exemplo os tipos u8, u16 são definidos de lá.
Depois acabei o dia testando e modificando um exemplo utilizando a USB do micro com o exemplo da virtual com port, que cria uma porta serial virtual, a idéia nesse caso foi utilizar o terminal e o display pra exibir os caracteres....
Enfim, mais um pouco de obstáculos e considerações erradas antes de se concluir essa modificação.
A idéia é conseguir amanhã trabalhar com a comunicação no sentido de transferir dados pro pc usando a usb e aquele mesmo exemplo...mais trabalho e um pouco de aprendizado pela frente!
|
|
|
|
|
|
| Sunday, 5-Jul-2009 02:36 |
Email | Share | | Bookmark |
|
Mau contato no conector do k550i
|
|
Outro dia estava ouvindo música no celular aqui e o som estava ficando estranho certas horas, como se o pino comum do fone estivesse com mau contato.
Como sobrou um tempinho aqui vi melhor ,o fone estava ok, o adaptador também, olhando no celular o conector estava se movendo mais do que deveria, achei muito estranho isso e resolvi abrir aqui.
Depois de baixar o manual de serviço vi que era tranqulo abrir, coloquei alguns passos importantíssimos pra abrir o celular e poder ajudar quem não trabalha com esse modelo.
Depois de abrir vi um negócio muito estranho, os pinos responsáveis por prender o conector a placa, nao os de sinal, estavam soltos..
Como o problema era nos pinos de sinal comecei ressoldando eles, como fazia um bom tempo que eu não soldava ci smd e o fluxo meu acabou demorei um pouco, mas o que deu trabalho foram os pinos que suportam mecanicamente o conector, sem fluxo foi muito chato, várias tentativas antes de conseguir um bom resultado.
O mais estranho foi que não vi solda nenhuma nesses furos...a não ser que na fabricação escorreu pra dentro da via...
Depois foi só fechar ele, o único detalhe foi que eu pra variar esqueci de colocar um parafuso lá de dentro (pra variar é sempre aquele do pior lugar possível), mas enfim, posso conferir 1000 vezes que sempre sobra alguma coisa pra fora.
Fora isso o celular é muito bom, já tive 4 antes desse e na minha opinião esse é o melhor celular que já tive a respeito de qualidade do material, outros dois eram v220, c975 e me deram muita canseira, fiquei com um f3 por uns tempos e achei muito bom, o outro era da época do tdma ainda e nem conta hehehe
A idéia desse conector é muito boa, já que ele nunca vai dar mal contato como aqueles que se utilizam de força de mola nos contatos do celular, como os p2, que acabam ficando ruins com o uso.
|
|
|
|
|
|
| Friday, 3-Jul-2009 23:22 |
Email | Share | | Bookmark |
|
Teste com o picoblaze
|
|
Outro dia achei esse interessante "soft-processor" no site da xilinx, o melhor ainda é que é disponibilizado de graça os fontes tanto em VHDL como em Verilog.
Vendo os manuais que achei, e o core dele vi que tinha até uma versão mais compacta feita para cpld, olhando os fontes não foi difícil entender o funcionamento, é realmente bem compacto.
Baixei o assembler dele disponibilizado pela xilinx e uma ide bem simples, daí estava tranquilo aqui outro dia e resolvi testar ele, imprimi o set de instruções e pensei num programa bem idiota pra fazer alguns testes.
Como já tinha feito e testado a interface do display resolvi fazer um somador em loop infinito que enviasse periodicamente o resultado da soma para o display, abaixo o fonte:
CONSTANT portaled,01
CONSTANT portabotao,02
CONSTANT contagem,FF
NAMEREG S0,contador1
NAMEREG S1,contador2
NAMEREG S2,contador3
NAMEREG S3,estado_s
ADDRESS 000
DISABLE INTERRUPT
LOAD estado_s, 00
ini:
LOAD contador1, 00
LOAD contador2, 00
LOAD contador3, 00
ini_cont:
ADD contador1, 01
COMPARE contador1, contagem
JUMP Z, fim_cont
contad2:
ADD contador2, 01
contad3: ADD contador3, 01
COMPARE contador3, FF
JUMP NZ, contad3
COMPARE contador2, FF
JUMP NZ, contad2
JUMP ini_cont
fim_cont:
ADD estado_s, 05
OUTPUT estado_s, portaled
JUMP ini
fim:
JUMP fim
Chutei 24 bits de contagem aqui, porque o picoblaze está rodando num clock
de 40MHz, foi o que eu usei pra piscar uns leds outro dia aqui quando eu testava o kit
novo do spartan 3A que me chegou aqui.
Esse código meu ficou meio ruim, até porque faz muito tempo que eu só estou trabalhando com C, mas enfim, funcionou.
A única surpresa que eu tive aqui foi quanto ao fato de que a minha ide utilizada ,o pblazeide utiliza mnemonicos diferentes dos utilizados pelo assembler da xilinx, no pblazeide a instrução COMPARE vira COMP, no conjunto de instruções tem COMP entre parenteses, só depois em outro documento vi que existe essa diferença de nomenclatura.
Isso causou uma perda de tempo para compilar o programinha, mas depois
consegui ver que era esse o problema.
É tudo muito tranquilo, o próprio assembler gera um arquivo VHDL com a ROM do processador, sem erros...
O processador é muito util, apesar de ter no máximo 1kB endereçável, o que já é mais que suficiente pra muitas aplicações, ainda mais com toda a lógica disponível de um FPGA para poder fazer determinadas funções que seriam feitas por software em um microcontrolador normal.
Outra coisa mais legal ainda foi o fato de que a área ocupada, considerando o core para interface do display, rom e processador foi menos de 2% do FPGA instalado aqui, o que dá um pouco menos que o meu projeto de interface serial publicado no opencores.
Vendo uma matéria que saiu na revista da xilinx há uns tempos, sobre o projeto de um painel publicitário, lá diz que foram usados mais de 1000 desses picoblaze.
http://www.xilinx.com/publications/xcellonline/xcell_51/xc_pdf/xc_es-tsquare51.pdf
E realmente parece uma boa escolha quando não precisamos de muita velocidade e quando simplesmente não dá tempo de se trabalhar em VHDL, já que fazer um programa é muitas vezes mais simples que projetar um hardware específico para se fazer tal função.
Bom fim de semana!
|
|
|
|
|
|
| Wednesday, 17-Jun-2009 23:43 |
Email | Share | | Bookmark |
|
Placa nova para display
|
|
Na hora de testar o que faço em VHDL e é bom ter alguma coisa pra ver o que está acontecendo com determinados sinais, às vezes alguns leds é pouco...daí a idéia de usar displays.
Tinha um monte de tipos de displays aqui nas sucatas, até uns de 14 segmentos, fiquei perdido aqui de tanta opção...o escolhido foi o com maior número de dígitos, já que é interessante ter mais informações pra ver...
Achei aqui um motorola PT550 e uns dpc650 na sucata, abri o maior e o display estava soqueteado...como pode, um display soqueteado num celular..ocupa o dobro de espaço...
Pra variar datasheet desse display nem em sonho, tive que pegar o multímetro analógico aqui e ver como estava ordenado os pinos, estavam os 7 dígitos multiplexados e os segmentos em anodo comum.
Depois de pensar aqui resolvi colocar um ULN2003 nos comuns dos digitos, como eram 7,cabia perfeito, também foram colocados alguns optoacopladores pra ajudar a controlar cargas que precisam de isolação.
A placa que desenhei fiz com trilhas bem largas pra prevenir problemas na transferencia de toner, o desenho foi feito no eagle, um programa fácil de mexer e que tem muitas bibliotecas.
O percloreto estava muito fraco, demorou mais de 4 horas o processo de corrosão, que na falta de tempo foi feito a noite num frio de doer...
Depois de umas horas de trabalho saiu o componente VHDL que faz o controle do display, pegando o dado de 28 bits e escrevendo nele por varredura...ou seja, vc acha que a imagem está parada mas...
Interessante que como a varredura desses celulares era muito rápida eu nunca percebi que o acionamento dos dígitos não era estático...
Enfim...um bom uso pras sucatas aqui de casa!
Um abraço pros que acompanham o blog aqui!
|
|
|
|
|
|
| Saturday, 7-Mar-2009 22:05 |
Email | Share | | Bookmark |
|
Projeto publicado no Opencores.org
|
|
Estou trabalhando em alguns projetos aqui e resolvi publicar um pequeno projeto no opencores, que distribui hardware livre, principalmente em linguagens VHDL e Verilog.
Há muito material sobre isso na internet, são fundamentalmente linguagens de descrição de hardware, onde utilizando alguns softwares é possível entre outras coisas implementar esse hardware em circuitos integrados como FPGA's e CPLD's.
Esses circuitos integrados são diferentes dos demais pelo fato de que não vem com algum circuito específico implementado neles de fábrica, esse trabalho fica pra quem irá desenvolver esses circuitos, que não é necessáriamente o fabricante dos próprios ci's.
Utilizando ferramentas de síntese é possível fazer o seu FPGA funcionar como você projetou, isto é, é possível fazer o seu próprio circuito integrado por um custo baixo comparado a se produzir o mesmo sob a forma de ASIC.
É difícil ver esse tipo de tecnologia nos equipamentos comerciais, os principais fabricantes são Altera, Lattice, Xilinx, Actel e Lattice, Atmel produz alguns e Cypress e AMD já produziram esse tipo de ci.
O unico equipamento relativamente comum que usa isto são alguns modchips de ps2 e wii, onde há uma necessidade de atualização e de hardware e essa solução coube bem nesse caso.
Também é comum encontrar em placas de servidores, centrais telefônicas e equipamentos industriais, já que nesse caso o volume de vendas não é suficientemente grande para se produzir um ASIC.
Para o core que eu implementei foi usado um Xilinx Spartan 3, que pode acomodar até 100000 portas lógicas, e que nesse projeto não foram utilizados nem 8% da capacidade lógica da FPGA.
A idéia foi fazer uma UART (Universal Assyncronous Receiver Transmitter), que pega dados da porta serial rs-232 e os converte em dados digitais de 8 bits e também converte outros dados digitais de 8 bits em serial.
Mas há muitos cores livres por aí e o diferencial desse é que foi feito de forma a economizar o máximo do dispositivo programável, fazendo com que se pudesse implementar o core numa variedade grande de CPLD's, mesmo os que tem pouca capacidade.
A foto foi tirada de alguns testes com um display de 2x16 caracteres, e o protocolo de recepção dos dados seriais é praticamente idêntico ao desse display.
Link para o projeto:
http://www.opencores.org/projects.cgi/web/muart/overview
Bom fim de semana!
|
|
|
|
|
|
| Thursday, 23-Oct-2008 02:35 |
Email | Share | | Bookmark |
|
8051 e SDCC
|
|
Ao receber uma pergunta, isso me fez lembrar o como foi difícil trabalhar no iníncio com 8051, onde ainda não tinha a série AT89xx da atmel, um tempo em que era necessário ou comprar um gravador para 8751 (difícil de achar até hoje) eprom, janelado ou então abrir mão da prom interna aos 8051 e utlizar um gravador de eprom, mais fácil de fazer ou conseguir.
Hoje em dia com esse comércio que sobe o preço ao invés de o diminuir com o aumento da demanda uma alternativa ao pic e com excelente custo comparado ao pic de 40 pinos, que não se compra por menos de 18 reais, é o AT89s52 chega na faixa dos 7~10.
Com todos esses problemas de complexidade de gravação, que pra quem tem um gravador de eprom é fácil de contornar, como eu fiz há uns anos atrás (grande gambi e ainda repeti o feito em 2003 se não me engano), o 8051 não seria o mais adequado, mas com esses micros da Atmel tudo isso fica pra trás porque agora o 8051 tem programação serial ISP!
Enfim, com isso você consegue ter em mãos o micro que feito no final da década de 70 ainda consegue adeptos e com certeza está em todos os lugares do ambiente industrial, e até dentro de algumas tv's com micros philips, que com certeza tem núcleo 8051.
Informações sobre o clássico no site da intel, que o colocou no mercado:
http://www.intel.com/design/mcs51/cf_51.htm
Outro dia quando recebi a pergunta peguei um 89s52 que estava mofando aqui na geveta e o coloquei na protoboard, comecei pelo programa clássico da atmel pra gravação serial, como tinha diversos cabos aqui pra diversos ci's, exceto o isp do 89s52 que já não mexia há muuitos anos e com certeza está (estará) perdido, passei a pesquisar aqui no google secreto.
Após muito andar por aí achei o site de um cara que fez um gravador da série AT89s incrível, ele simplesmente aceita qualquer cabo, com um sistema de configuração custom de interface.
Achei pré configurado o STK200 paralelo aqui que estava por perto, espetei no micro e gravou tranquilo, é incrível, pena que não tinha isso há alguns poucos anos atrás.
http://dybkowski.net/elka/ispprog.html
Esse é o tipo de programa que você que já mexeu com 8051 vai guardar com carinho em algum cd pq vc que já mexeu com isso procurando na internet sabe que muita coisa que estava naquela época simplesmente não existe mais (98...2001).
Agora vai a dica sobre o SDCC e o 8051, outros micros suportados pelo SDCC em breve...
http://sdcc.sourceforge.net/
O SDCC é um compilador em C pra quem não foi afortunado com o GCC, GPL etc e tal...
Suporta muitas arquiteturas clássicas como 0 Z80, 8051 além de PIC's, o que pode fazer a diferença pra você que como eu já programou em asm pq era obrigado e agora com C, basic e outras linguagens se libertou (infelizmente de vez em quando é necessário fazer asm inline...), a não ser que você tenha nas mãos um pic10f ou 12f5.. que não tem quase nada em flash e daí vc tem que fazer milagre com isso.
Enfim, já programei muito em asm de pic, depois com os compiladores basic e C deixei de ser detalhista e parei de mexer com isso em troca da minha saúde mental  hehehehe
Na hora de compilar é sdcc com cpu default, daí você faz o /? e olha lá, sem erro, vai gerar um dos tipos de arquivo q o programador suporta e pronto (SDCC...), só gravar!
Olhe o software super idiota que eu fiz pra testar, ele pisca leds sem usar nenhum timer, idiota, não?
#include <at89x52.h>
#define Desativa_INT IE=0x0;
void delay_ms(unsigned char ms);
void main(void)
{
Desativa_INT
while(1)
{
P0=0;
delay_ms(200);
P0=0xFF;
delay_ms(200);
}
}
void delay_ms(unsigned char ms)
{
unsigned char i;
while (ms> 1)
{
ms--;
for (i=0; i < 111; i++)
{
_asm
nop // o DJNZ é 2 Machine Cycles (12x2 clocks) ,NOP é 1 Machine Cycle
_endasm; // cada machine cycle é 12 clocks!!! (que lerdeza)
}
}
}
Aí você vai ver esse DJNZ com um monte de coisa na frente e dizer: "De onde esse imbecil tirou isso?" não se desespere!!! fui no list em asm, dei uma olhada no que o compilador aprontou, peguei o datasheet lá e tirei q DJNZ é 2 machine cycles.
Espero que o meu 111 esteja certo (não conferi as contas mas piscou)...não esqueça que o meu cristal lá era de 4MHz, e você deve configurar isso no programador também!
Se vc é begginer não esqueça de colocar o EA em nível alto e fazer o reset funcionar na hora certa (ao ligar o sistema, use o velho sistema de capacitor, resistor diodo e chave).
Que lixo de blog agora que eu vi que ele tira minha identação!!! 
Boa semana a todos!
|
|
|
|
|
|
| Friday, 17-Oct-2008 21:25 |
Email | Share | | Bookmark |
|
Linha AVR
|
|
Ultimamente tenho postado pouco aqui pois tenho trabalhado mais com desenvolvimento.
Um microcontrolador que tem um ótimo custo benefício é a linha ATtiny e ATMega (core AVR) da Atmel.
Com 32 acumuladores, todos eles ligados á ALU, ele consegue fazer muito mais que um PIC de 14 bits usando menos memória RAM.
Outro ponto importante é a execução de uma instrução por ciclo de clock, o que só é conseguido com pic's mais caros, linha PIC18...
Além disso também tem instrução de multiplicação, o que pra quem ainda programa em assembly pode resultar em programas mais fáceis de fazer.
Mais uma coisa interessante é o fato de existir um compilador em C gratuito e ainda opensource, o AVR-GCC, com ampla documentação na internet.
Quanto aos programadores essa linha também tem isp, assim como o AT89s... ou pic's, utilizei dois tipos de interfaces:
1-STK200 paralelo: http://www.lancos.com/e2p/betterSTK200.gif
Fácil de fazer e o meu coube dentro da capa do cabo DB25.
2-USBASP usb: é muito interessante também, tenho uma placa feita para ele em face simples, quem quiser me mande algum comentário pedindo, é a modificação de uma delas do site mas está feita para um conector USB vertical que eu tinha no estoque.
http://www.fischl.de/usbasp/
Quanto aos softwares uso o WINAVR e a IDE padrão da Atmel, disponível no site deles.
Enfim, pra quem já trabalhou com 8051e outros vai se impressionar com a quantidade de softwares para este micro, inclusive a implementação da USB do usbasp é feita em software, sendo o código aberto
Nos próximos posts continuo, assim que lembrar de mais algo interessante.
Bom fim de semana, por favor comente!
|
|
|
|
|
|
| Tuesday, 9-Oct-2007 03:58 |
Email | Share | | Bookmark |
|
Nobreak APC Back-UPS ES
|
|
 |
|
Forma de onda sem rede, com carga
|
|
|
Esse post aqui é sobre um nobreak que eu paguei baratinho, 10% do preço de mercado, com uns defeitos...
O que diferenciou dos outros com defeito foi o fato de que ele é leve comparado aos nobreaks normais.
Ao abrir o nobreak uma boa constatação, a bateria estava em boas condições, já que a fabricação data de 2004 e esse modelo também está em linha de produção, com bateria de 12V 3A.
Analisando o circuito uma surpresa, ele usa somente um microcontrolador PIC e um ci quad amp-op. lm324, já bem conhecido, muito diferente dos outros nobreaks nacionais de 1kVA ou mais, com cerca de 12 ci's, sendo muitos deles lógicas cmos, comparadores de tensão e amplificadores operacionais.
Analisando o circuito dele também outra coisa interessante, só havia um transformador, diferente dos outros nobreaks offline que eu tinha visto, em que havia um transformador para o inversor e outro para recarregar a bateria, sendo esse transformador tendo uma retificação e recarga controlada pelo pic por um mosfet.
Agora os defeitos, logo vi uma mancha de queimado numa das tomadas, queimado que veio até a placa, sinalizando um curto.
Partindo disso fui direto aos mosfets chaveadores, estava um aberto, troquei os dois, STP55NF da ST, peguei o datasheet e logo substituí por um mais robusto, o famoso irfz48, que é figura conhecida nos nobreaks.
Trocado os 2 mosfets de chaveamento e também o de carga que achei interessante trocar pq não havia dissipador nele, e como o rdson do irfz48 era menor, provocanco menos aquecimento seria interessante para uma maior durabilidade...
Não funcionava nada após a troca dos mosfets, após quebrar um pouco a cabeça com o circuito do 127V e medir e testar os relés pensando que eles estariam ruins pelo uso, estava tudo ok, mas olhando para o lado da baixa tensão, não havia alimentação no PIC (um velho conhecido meu dos desenvolvimentos de firmware), daí comecei a seguir a alimentação, o fusível de 30A estava ok, olhando melhor tinha um símbolo de fusível na pcb, estranhamente não havia fusível lá, fui para o lado cobreado da placa e a surpresa, a APC colocou uma trilha para servir de fusível....plausível se bem calculado, mas uma solução um tanto descartável...
Resolvido o problema desse fusível e do mosfet o nobreak funcionou normalmente...
Outra coisa que chamou a atenção é a quantidade grande de varistores comparada aos outros nobreaks que eu já trabalhei, eram uns 6, sendo que o normal seriam 2, além de um filtro de linha muito bem feito.
Enfim, é um conserto bem fácil e simples, só pra poder trazer novos posts...
Abraços a todos...
|
|
|
|
|
|
| Wednesday, 3-Oct-2007 13:36 |
Email | Share | | Bookmark |
|
Gravando componentes
|
 |
|
Willem montado
|
|
 |
|
Trilhas da placa e soldas
|
|
 |
|
Byteblaster e adaptador para o altera smd
|
|
|
Conto aqui uma breve história sobre os gravadores de eprom que eu fiz.
O primeiro foi um bem simples, para conseguir desenvolver com 8051, isso há mais de 7 anos atrás, pra quem sabe esse componente exigia uma eprom, ou alguma memória exterma, já que era muito difícil encontrar algum programador para o 8051 no mercado, hoje o Willem faz isso com o 8751 que pode ser apagado por uv...
Na época o escolhido foi: http://www.larwe.com/zws/products/epromr2/index.html
Fiz esse circuito em uma protoboard, funcionou muito bem, até montei ele 3 anos depois numa placa de prototipagem que guardo até hoje.
Acabei desenvolvendo pouco com esse sistema pq não dispunha de lâmpada uv para o apagamento e tinha que usar lâmpada fluorescente comum, o que demorava mais de uma semana cada apagamento, mas a lâmpada uv que acabei comprando uns 3 anos depois fazia isso em 30~40 minutos...
No final acabei indo para a linha 89s51 que é flash gravável serialmente por um cabo simples de programação.
O circuito é simples, contadores cmos e um sistema inteligente de dip-switches, com o barramento de dados ligados na porta bidirecional paralela (EPP)...
Depois de alguns anos, resolvi comprar uma placa para fazer o gravadow Willem:
http://www.willem.org/
Era uma PCB3b, mas veio com os furos de diâmetro muito pequeno, além de ser face simples, o que demandou uma quantidade enorme de jumpers, veja as fotos.
O gravador Willem além de gravar as eproms série 27 também grava flash das séries 28F, 29F, 39 e 49, além de muitos outros dispositivos como e²prom séries 24, 25, 93, além do 8751 com módulo adaptador, o que seria uma grande ajuda na época do 8051, além de gravar PIC por icsp...
O funcionamento é simples, shift register para os endereços e buffer para os dados, com um sistema multiplexado de entrada de dados, saida de dados e enderecos...
Ele também tem um DC-DC próprio com o mc34063, que além de ter 12,5V para eprom comum também tem as tensões maiores para as eproms antigas.
Recomendo o circuito, é muito bom, porém com a placa face dupla, que dá muito menos trabalho e erros, como foi no caso da minha que também veio faltando muitas trilhas, além de trilhas em curto, placa comprada e da má qualidade.
Outro circuito montado foi o cabo byte blaster da Altera, que é um JTAG na paralela, simples construção, usa apenas um ls244:
http://opencollector.org/history/freecore/Build%20your%20own%20ByteBlaster!.htm
Com esse circuito programo meus epm3032 e 3064, mas também funciona com outros dispositivos de outras linhas...
Além disso um outro sistema que eu fiz foi baseado no propic para gravação de pic, todos os sistemas funcionam bem comigo e são recomendados.
Um abraço a quem leu!
|
|
|
|
|
