Universidade de São Paulo
Escola Politécnica
PSI2222
Relatório Projeto 58
Relógio Volta
Componentes: Júlio Mota Pinheiro
Leonardo Doin
Pedro Cicolin Leme
Vitor Andrade
Orientadores: Prof. Dr. Edson Toshimi Midorikawa
Prof. Dr. Jairo Galindo
Novembro 2010
São Paulo
Resumo do Projeto
O Projeto 58 consiste no estudo e desenvolvimento de uma variação do Relógio Volta, relógio esse
desenvolvido pelo Prof. Dr. Jairo Galindo, que busca uma representação de tempo com um maior apelo ao
passar natural do dia, buscando a integração entre o tempo que o homem vê e o tempo de seu ciclo
biológico.
O relógio constitui-se de uma parte em programação atuando em conjunto com um hardware
desenhado para facilitar a visualização do passar do tempo.
Introdução Teórica
A construção do Relógio Volta, um relógio que terá de dar apenas uma volta completa para marcar o
período relativo a um dia todo, tem por objetivo testar sua viabilidade e o possível impacto causado por seu
uso na percepção do tempo por seus usuários.
O formato e a ideia do relógio vêm da indicação real do passar do tempo durante o dia. Na
sociedade atual, o dia é baseado no período necessário para que a Terra complete uma volta em torno de
seu próprio eixo, sua rotação, e pode ser visualizado como o tempo que compreende o Sol “circundar
totalmente a Terra”, tendo como resultado disso as 24 horas que guiam os passos diários da sociedade,
além, principalmente, de todos os ciclos biológicos, humanos ou não, que acompanham o passar do dia.
Apesar do dia ser pautado na rotação da Terra, os relógios de ponteiro mais difundidos atualmente
fazem a divisão do dia em duas fatias de 12 horas, sendo que essa divisão não tem relação com as ações
do homem ao longo do dia, nem mesmo com qualquer ciclo biológico ou funcionamento da sociedade.
De modo a buscar uma representação temporal que realmente estivesse ligada com seu usuário, o
ser humano, o Prof. Dr. Jairo Galindo, em conjunto com o Prof. Dr. Edson Toshimi Midorikawa,
desenvolveram um relógio do tipo de ponteiros com uma visualização total do dia, com apenas uma rotação
do ponteiro por dia. Tal relógio pode ser interpretado como aquilo que mais se aproxima de uma indicação
natural do passar do dia, podendo inclusive acompanhar o caminho do sol no céu ao longo do dia se
deixado em uma posição favorável a isso.
Como consequência disso temos que o relógio não fornece uma divisão artificial do dia, desse modo
evitando induzir o usuário a dividir suas ações com base em uma divisão arbitrária. O Relógio Volta também
dá ao usuário uma visão mais natural do passar do dia, indicando apenas a mudança do dia, permitindo que
a própria pessoa passe a realizar suas ações de uma maneira que mais condiz com sua própria natureza,
ou seja, de maneira fluida, e não compartimentalizada como vemos atualmente em nossa sociedade veloz e
que tem o tempo como seu senhor.
A nós foi dada a chance de pensar junto na implementação do Relógio Volta no projeto, e
destacamos alguns pontos que poderiam fazer sentido aos usuários do relógio, desenvolvendo dessa
maneira algumas adaptações que poderiam melhorar a rápida visualização do tempo no relógio, além de
permitir tanto uma interpretação fluida do dia quanto uma baseada em secções definidas do tempo, em
conjunto com outras funções de melhora na assimilação do período do dia.
Entre as ideias surgiram a inclusão de dois indicadores dos minutos. Enquanto um deles dá uma
passagem mais suave do passar do tempo o outro, posto um pouco deslocado do disco do relógio, indicaria
os minutos com precisão, podendo as duas funções serem usadas conforme a necessidade de quem o
visualiza.
Outra característica incluída em nossa implementação do relógio foi o uso de um indicador que faz
uso da passagem do dia para simular os tons do céu ao longo do tempo, de modo que caso a pessoa só
deseje saber se é de manhã ou de tarde, nem mesmo precise interpretar o ponteiro, bastando olhar para o
relógio.
Por fim, houve ainda a inclusão de um alarme, item esse ainda muito requisitado em nossa
sociedade, servindo para alertar o usuário sobre uma hora pré-determinada, com uma fácil manipulação do
horário escolhido para tocar.
Com todas essas implementações, busca-se a criação de um relógio que realmente consiga indicar
com mais acurácia a passagem do tempo do dia, entrando em consonância com a natureza do homem e
seu ciclo biológico para que possa melhorar sua relação com o tempo, que hoje o escraviza. Além disso,
que seja de fácil e rápida visualização, contando ainda com itens que busquem diminuir muito o tempo de
assimilação do usuário quanto ao horário mostrado, se mostrando uma boa aquisição para o cotidiano da
pessoa em todos os sentidos.
Desenvolvimento
A parte técnica do projeto foi moldada com base em uma simplificação do desenvolvimento do
relógio, enfatizando assim a construção de um protótipo em que se pudesse visualizar a viabilidade da
abordagem escolhida e suas possibilidades de modificação e melhora, de modo a ter um produto que
realmente atinja o objetivo a que foi proposto e que ao mesmo tempo seja algo desejado pelo consumidor e
que introduza em seu cotidiano a ideia porque fora idealizado.
Com base em um rápido jogo de ideias sobre o relógio, levantamos que ele seria composto de uma
parte em software, responsável por fazer o controle do sistema como um todo, uma parte em hardware, com
circuitos eletrônicos, a mecânica seria representada pelo motor de passo e qualquer sistema de redução
que se apresentasse necessário, além do design do produto.
Hardware
O projeto de hardware do relógio sofreu muitas modificações desde a ideia original, sendo
estabelecido finalmente como:
• um Freeduino, ramificação totalmente compatível com o Arduino Duemilanove, uma plataforma de
desenvolvimento de hardware aberta, com toda uma comunidade de suporte, contando ainda com
esquemáticos bem produzidos, especificações bem dimensionadas e uma plataforma de
programação de fácil utilização, através de um ambiente de desenvolvimento que usa uma
linguagem muito parecida com o C para a criação de programas que são rapidamente transferidos
para a placa, de modo a possibilitar prototipagem sem complicações;
• três leds, responsáveis por indicar o período da hora em um intervalo de quinze minutos, sendo
controlados diretamente pelo Arduino;
• três leds rgb que deverão ser controlados diretamente por saídas PWM do Arduino, indicando o
período do dia através dos tons de cores correspondentes;
• um buzzer, também controlado por uma saída PWM do Arduino, e servira como o som do alarme;
• dois displays de sete segmentos que terão suas portas alimentadas por registradores de entrada
serial e saída paralela (shift-registers), modelo MM74HC595. Dessa maneira o display não é
alimentado diretamente por um decodificador bcd/sete segmentos, mas sim diretamente por sinais
do Arduino, possibilitando que outros caracteres alem dos dígitos numéricos sejam exibidos nos
displays, o que facilita na indicação de estados do relógio ao usuário;
• um motor de passo, modelo PL15S-020, retirado de um drive de cd-rom que seria enviado `a
reciclagem, que é o responsável por movimentar o ponteiro que indicara as horas no relógio. Tal
motor de passo eh ligado ao Arduino através de uma h-bridge modelo SN754410, responsável por
fornecer a potencia ao motor a partir dos sinais de controle do microcontrolador;
• dois botões, que darão ao usuário a possibilidade de alterar o horário do relógio e do alarme;
Basicamente é uma montagem muito simples e de fácil confecção, mas que mesmo assim fornece
uma flexibilidade interessante para que partes do projeto possam ser alteradas sem que se necessite de
grandes modificações nos esquemas elétricos. Tal montagem requer muito pouco de circuitos montados
sobre placas, com exceção do microcontrolador, que já esta presente na plataforma do Arduino e é o
responsável por controlar todo o restante do sistema. Com isso temos a possibilidade de alterar o projeto
até que ele se encaixe exatamente ao que desejamos, fazendo dele um exemplo de protótipo poderoso.
Software
Nosso sistema de controle foi escrito em uma linguagem semelhante ao C, usada para a
programação de microcontroladores, e com funções que possibilitam extrair as funcionalidades especificas
do controlador sem grandes esforços de código.
Durante o desenvolvimento, dividimos os blocos de código em funções, de modo que cada ação
especifica seja executada por uma determinada função, eliminando assim a confusão dos códigos e
possibilitando uma verificação de erros mais precisa e uma manutenção muito mais rápida, limpa e segura.
Com isso ganhamos agilidade e, mesmo tendo de modificar todo o software após uma mudança mais
brusca no hardware, tudo foi feito de maneira muito rápida, sem danos ao cronograma do projeto.
Abaixo seguem algumas funções presentes no sistema:
Decodificador decimal / 7 segmentos – responsável por realizar a conversão dos minutos em
caracteres indicativos;
Carregador de displays – carrega nos shift-registers a seqüência de segmentos que devem ser
acesos;
Buzzer – sonoriza em uma determinada freqüência, por um período estipulado;
Motor – tal função controla a rotação do motor e seu posicionamento no ângulo desejado;
Leds dos minutos – acende os indicadores de led conforme os períodos de quinze minutos;
Botões – detecta e interage com o usuário a fim de atualizar o horário e o alarme;
Leds RGB – se alteram ao longo do dia variando sua cor para acompanhar a “cor natural” do dia;
Após a montagem do hardware produzimos ainda uma rotina de conferência dos componentes para
nos certificarmos de que tudo funcionava como esperado.
Mecânica
A única mecânica utilizada em nosso projeto é a do motor de passo, que tem sua volta dividida em
vinte. A partir de um jogo de engrenagens, de vinte para vinte e quatro, foi possível a obtenção da volta
completa do relógio ao longo do dia. O motor é alimentado através de uma ponte-H (circuito integrado), que
fornece a potencia necessária ao motor a partir do sinal de controle do microcontrolador.
Após algumas pesquisas sobre o motor, constatamos que seria de difícil obtenção um motor com as
especificações necessárias no varejo nacional. Com isso em mente, partiu-se para outras possibilidades, e
eis que foi possível conciliar nosso projeto ao desenvolvimento sustentável, obtendo o motor a partir de
drives de cd-rom e disquete que seriam descartados. Para isso contamos com a ajuda do Centro de
Descarte e Reuso de Resíduos de Informática (CEDIR-USP), que nos forneceu drives obsoletos e avariados
para que deles pudéssemos obter os motores. Após extraídos os motores, identificamos aqueles que
poderíamos utilizar em nosso trabalho, com 5V, baixo torque e um numero de passos compatível, modelo
PL15S-020.
Design e Base
A base do relógio foi confeccionada em madeira e acrílico, com duas chapas com ângulo de
abertura de aproximadamente 45 graus. Enquanto a placa suspensa terá o visor do relógio e os displays e
os botões, a placa de sustentação abarcara os circuitos.
Baseada num design simplista e elegante, a base será aberta para que toda a montagem possa ser
observada e analisada a partir de uma motivação de tecnologia a mostra, aberta.
A escolha de material foi detalhista e sofisticada, de modo que pudesse incluir em suas
características pontos importantes para toda a confecção do projeto. A madeira utilizada, é leve e resistente,
de relativa facilidade em sua manipulação e fácil acesso. O acrílico atende a necessidade de ser translúcido
e opaco, na região dos ponteiros e da madeira, respectivamente, para sua visualização em cores, que no
caso mudarão, devido aos leds.
Testes e Simulações
Após as características especificadas, assim como os circuitos, e os componentes adquiridos, todo
o circuito foi montado sobre uma protoboard (matriz de contatos - placa usada para prototipagem rápida de
pequenos circuitos), de modo que foi possível realizar testes de funcionamento dos componentes e da
lógica presente no circuito.
Apesar de alguns mal-contatos e fios soltos, foi obtido êxito com o funcionamento do sistema,
usando para isso o sistema de testes programado especificamente para realizar rotinas preestabelecidas.
Com isso foi possível comprovar alguns pequenos erros de montagem e arruma-los antes de transferir o
circuito para uma placa impressa.
Após os testes de hardware e a confecção dos circuitos partiu-se para a averiguação do
funcionamento do software do relógio, onde foi possível detectar alguns erros de lógica que não foram
observados através do código. Os testes porém não puderam se concluir com qualidade, uma vez que itens
como o ajuste dos displays, a intensidade dos leds RGB ao longo do dia ou ainda a criação de uma rotina
para o contorno do bouncing dos botões não foi possível sem o funcionamento final das placas montadas.
União das Partes
Todo o trabalho de conferência e análise dos circuitos, programação, funcionamento de peças,
atendimento de peças às necessidades; foi feito por partes e enfim foi necessário que observássemos o
funcionamento de todas as partes em conjunto, e assim o fizemos novamente na protoboard. Os problemas
mais usuais encontrados em todo o circuito conjunto foi a dificuldade na montagem, devido à quantidade de
fios e ligações minuciosas, além de mau contato.
Após a observação destes detalhes, o circuito foi completamente montado, e enfim a montagem da
protoboard estava pronta para ser implementada nas placas impressas.
Impressão das Placas
A impressão das placas foi feita manualmente, seguindo todo o esquemático em anexo.
Simplificamos o circuito o mais que pudemos para utilizarmos o mínimo de fios nas ligações, mas fios o
suficiente para que pudéssemos mudar as ligações, verificar maus contatos e falhas nas transmissões das
correntes, ou caso precisássemos trocar leds ou peças que por ventura queimassem. Utilizamos soquetes
para os CIs e pinheads para ligarmos os fios ao Arduino.
Resultados obtidos e discussões
Ao final da montagem do relógio todo, pudemos testá-lo e conferir seu funcionamento total,
ajustando alguns parâmetros e reforçando alguns pontos. Mesmo atestando todo o funcionamento do
circuito quando na protoboard e em separado, ao unir-se todo o sistema ele não apresentou funcionamento
satisfatório, deixando muito a desejar daquilo que planejamos inicialmente.
Naturalmente nosso protótipo se mostrou com uma certa instabilidade, o que talvez seja causado
pela falta de habilidades manuais para sua confecção, ou ainda o fato de alguns componentes não terem
sido testados exaustivamente para esse fim, o que se espera sanar com um tempo maior de
amadurecimento do projeto ao longo do tempo, dispondo ainda de maiores recursos de pesquisa, tanto
humanos (possibilidade de maior carga de trabalho) quanto de ferramentaria.
Atesta-se assim que não se deve supor que a montagem final seja simples, nem subestimar seu
tempo de execução e desenvolvimento, visto que mesmo com todo o sistema projetado e testado pela
razão, há variáveis que fogem ao controle do processo, culminando
Observou-se que o custo de desenvolvimento desse protótipo ficou por aproximadamente R$150,
contabilizando custos com ferramentas, componentes extras e erros advindos do projeto, mas estima-se
que esse preço possa baixar para R$20, a partir de um maior desenvolvimento, otimizações e produção em
larga escala.
Conclusões
O Relógio Volta, apesar de alguns problemas referentes a prototipagem, se mostrou uma ideia de
grande potencial, e quando aliada a um baixo custo, através da produção em escala poderia se constituir
num produto de relativo sucesso, empregando também uma nova ideia, mesmo sem influenciar diretamente
seus usuários.
Também foi um projeto que empreendeu muitos conhecimentos, passando desde a lógica da
programação ate a especificação de circuitos integrados e desmonte de produtos para reciclagem.
Acreditamos que o sistema ainda tem falhas, mas que deverão ser sanadas com a continuidade do
projeto. Para isso, elencamos alguns pontos a serem alcançados como próximos marcos:
• Finalização da ideia e pavimentação;
• Otimização dos circuitos a fim de reduzir os custos;
• Produção de uma documentação de todas as etapas em detalhes;
• Apresentação de nosso desenvolvimento no Congresso Municipal de Linguagens Diversificadas
2010/2011;
Do ponto de vista da linguagem e a respeito do ideal apresentado no projeto pelo Prof. Doutor Jairo
Galindo, e pelas observações feitas no funcionamento das partes e posteriormente do relógio, a conclusão é
que o relógio Volta atende de fato a algumas abordagens alternativas do relógio para com o seu usuário,
permitindo assim algumas assimilações linguísticas diferenciadas daquelas convencionais em relógios
comuns.
O relógio se utiliza de muitos recursos de comunicação com o usuário, permitindo inúmeras
interpretações do tempo e abrindo margem para reflexão e melhor entendimento deste. Assim como uma
obra de arte só pode ser entendida e apreciada por completo quando se conhece a história, os intuitos e os
sentimentos daquele autor, o relógio Volta traz tantas reflexões quanto utilidade, pois carrega junto a si um
significado maior do que a pura marcação do tempo, significado este que não pode ser entendido por
completo a não ser que se entenda o tempo por si, ou seja, o projeto final do relógio ainda sim é abstrato.
Código-fonte da programação do microcontrolador
#define dsp_data1 6#define dsp_data2 5#define dsp_clock 4
#define rgb_r 11#define rgb_g 10#define rgb_b 9
#define minutes_led1 0#define minutes_led2 1#define minutes_led3 2
#define buzzer_out 3
#define motor_out1 7#define motor_out2 8#define motor_out3 12#define motor_out4 13
#define button_1 'A0' //analog#define button_2 'A1' //analog
void setup(){
pinMode(dsp_data1, OUTPUT);pinMode(dsp_data2, OUTPUT);pinMode(dsp_clock, OUTPUT);
pinMode(rgb_r, OUTPUT);pinMode(rgb_g, OUTPUT);pinMode(rgb_b, OUTPUT);
pinMode(minutes_led1, OUTPUT);pinMode(minutes_led2, OUTPUT);pinMode(minutes_led3, OUTPUT);
pinMode(buzzer_out, OUTPUT);
pinMode(motor_out1, OUTPUT);pinMode(motor_out2, OUTPUT);pinMode(motor_out3, OUTPUT);pinMode(motor_out4, OUTPUT);
pinMode(button_1, INPUT);pinMode(button_2, INPUT);
}
int minute = 0 ;int hour = 0 ;int al_hour = 0 ;int al_minute = 0 ;
int time_adjust = 0 ;int alarm_adjust = 0 ;
int dsp_array_dec[8] = {0,0,0,0,0,0,0,0};int dsp_array_unit[8] = {0,0,0,0,0,0,0,0} ;
int n = 0 ;
unsigned long time_count = 0 ;
void loop(){ if( ( millis() - time_count ) > 60000 ) { time_count = millis() - time_count ; } minute = minute + ( time_count % 600000 ) ; if( minute >= 60 ) { minute = minute - 60 ; hour = hour + 1 ; stepper_motor( hour - 1, hour ) ; } if( hour >= 24 ) { hour = hour - 24 ; } if( minute == al_minute && hour == al_hour ) { buzzer() ; } rgb_leds( ( 60 * minute ) + ( 3600 * hour ) ) ; minutes_leds( minute ) ; minutes_display( minute ) ; for( n = 0 ; n < 100 ; n ++ ) { if( digitalRead( button_1 ) == HIGH ) { time_adjust = fbutton_1() ; stepper_motor( hour, time_adjust % 60 ) ; hour = time_adjust % 60 ; minute = time_adjust - ( hour * 60 ) ; rgb_leds( ( 60 * minute ) + ( 3600 * hour ) ) ; minutes_leds( minute ) ; minutes_display( minute ) ; } if( digitalRead( button_2 ) == HIGH ) { alarm_adjust = fbutton_2() ; al_hour = alarm_adjust % 60 ; al_minute = alarm_adjust - ( al_hour * 60 ) ; } }}
void rgb_leds( int day_seconds ){ int red = 221 ; int blue = 168 ; int green = 047 ;
//faz calculos para cada led e coloca a intensidade necess riaá
analogWrite( rgb_r, red ) ; analogWrite( rgb_b, blue ) ; analogWrite( rgb_g, green ) ; delay(10);
}
void minutes_leds( int minutes ){
if( minutes >= 15 && minutes < 30 ){
digitalWrite( minutes_led1, HIGH );digitalWrite( minutes_led2, LOW );digitalWrite( minutes_led3, LOW );
}else if( minutes >= 30 && minutes < 45 ){
digitalWrite( minutes_led1, HIGH );digitalWrite( minutes_led2, HIGH );digitalWrite( minutes_led3, LOW );
}else if( minutes >= 45 && minutes < 60 ){
digitalWrite( minutes_led1, HIGH );digitalWrite( minutes_led2, HIGH );digitalWrite( minutes_led3, HIGH );
}else{
digitalWrite( minutes_led1, LOW );digitalWrite( minutes_led2, LOW );digitalWrite( minutes_led3, LOW );
}}
void buzzer(){
/*int n = 0;
for( n = 0; n < 500; n ++ ){
digitalWrite( buzzer_out, HIGH );//timelapsedigitalWrite( buzzer_out, LOW );//timelapse
}*/
tone( buzzer_out, 440, 15000 );}
void stepper_motor( int current_position, int desired_position ){
if(current_position > desired_position){
desired_position = 24 - current_position + desired_position;}else{
desired_position = desired_position - current_position;}
int n = 0;
for( n = 0; n < desired_position; n ++ ){
digitalWrite( motor_out1, LOW ); digitalWrite( motor_out2, HIGH ); digitalWrite( motor_out3, HIGH );digitalWrite( motor_out4, LOW );
delay(40);
digitalWrite( motor_out1, LOW ); digitalWrite( motor_out2, HIGH ); digitalWrite( motor_out3, LOW );digitalWrite( motor_out4, HIGH );
delay(40);
digitalWrite( motor_out1, HIGH ); digitalWrite( motor_out2, LOW ); digitalWrite( motor_out3, LOW );digitalWrite( motor_out4, HIGH );
delay(40);
digitalWrite( motor_out1, HIGH ); digitalWrite( motor_out2, LOW ); digitalWrite( motor_out3, HIGH );digitalWrite( motor_out4, LOW );
delay(40);}
}
int fbutton_1(){ int hour = 0 ; int minute = 0; int time_choice = 0; minutes_display( 70 ); delay( 1000 ); minutes_display( 74 );
delay(200); do { if( digitalRead( button_2 ) == HIGH ) { if( time_choice == 0 ) { hour = hour + 1 ; minutes_display( hour ) ; } else { minute = minute + 1; minutes_display( minute ) ; } delay(200); } if( digitalRead( button_1 ) == HIGH ) { if( time_choice == 0 ) { time_choice = 1 ;
minutes_display( 75 ) ; } else { time_choice == 2 ; } delay(200); } } while( time_choice < 2 ); return ( ( hour * 60 ) + minute ) ;}
int fbutton_2(){ int hour = 0 ; int minute = 0; int time_choice = 0; minutes_display( 80 ); delay( 1000 ); minutes_display( 74 );
delay(200); do { if( digitalRead( button_1 ) == HIGH ) { if( time_choice == 0 ) { hour = hour + 1 ; minutes_display( hour ) ; } else { minute = minute + 1; minutes_display( minute ) ; } delay(200); } if( digitalRead( button_2 ) == HIGH ) { if( time_choice == 0 ) { time_choice = 1 ; minutes_display( 75 ) ; } else { time_choice == 2 ; } delay(200); } } while( time_choice < 2 ); return ( ( hour * 60 ) + minute ) ;}
void minutes_display(int minutes){
int n = 0;
if( minutes == 70 ) /*prints AJ - for Adjust*/{
display_fill( dsp_array_dec, 11 );display_fill( dsp_array_unit, 12 );
}else if( minutes == 74 ) /*prints Hr - for Hours*/{
display_fill( dsp_array_dec, 14 );display_fill( dsp_array_unit, 15 );
}else if( minutes == 75 ) /*prints Mn - for Minutes*/{
display_fill( dsp_array_dec, 16 );display_fill( dsp_array_unit, 17 );
}else if( minutes == 80 ) /*prints AL - for Alarm*/{
display_fill( dsp_array_dec, 11 );display_fill( dsp_array_unit, 13 );
} else if( minutes == 85 ) /*prints dn - for Done*/ { display_fill( dsp_array_dec, 18 ); display_fill( dsp_array_unit, 19 ); }
else /*prints minutes*/{
int decimal = minutes % 10;int unit = minutes - decimal;
display_fill( dsp_array_dec, decimal );display_fill( dsp_array_unit, unit );
}
for( n = 0; n < 8; n ++ ){
if( dsp_array_dec[n] == 0 ){ digitalWrite( dsp_data1, HIGH ); }else{ digitalWrite( dsp_data1, LOW ); }
if( dsp_array_unit[n] == 0 ){ digitalWrite( dsp_data2, HIGH ); }else{ digitalWrite( dsp_data2, LOW ); }
digitalWrite( dsp_clock, HIGH );digitalWrite( dsp_clock, LOW );
}
}
void display_fill( int dsp_array[], int value ){ //requer que o circuito seja montado para se garantir que cada sequ nciaê de bits gere o n mero desejado - requer testes ap s montado o circuitoú ó //s o necess rios testes para que se possa preencher todos os n merosã á ú
if( value == 0 ){
dsp_array[0] = 0 ; dsp_array[1] = 1 ; dsp_array[2] = 1 ; dsp_array[3] = 1 ; dsp_array[4] = 0 ; dsp_array[5] = 1 ; dsp_array[6] = 1 ; dsp_array[7] = 1 ;
}else if( value == 1 ){
}
else if( value == 2 ){
}else if( value == 3 ){
}else if( value == 4 ){
}else if( value == 5 ){
}else if( value == 6 ){
}else if( value == 7 ){
}else if( value == 8 ){
}else if( value == 9 ){
}else if( value == 11 ){
}else if( value == 12 ){
}else if( value == 13 ){
}else if( value == 14 ){
}else if( value == 15 ){
}else if( value == 16 ){
}else if( value == 17 ){
}else if( value == 18 ){
}else if( value == 19 ){
}}
Top Related