Universidade de São Paulo

(1)

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

(2)

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.

(3)

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.

(4)

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.

(5)

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;

(6)

•

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;

(7)

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.

(8)

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.

(9)

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.

(10)

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.

(11)

(12)

(13)

(14)

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 ;

(15)

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 ) ; }

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 ;

(16)

//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 ); //timelapse

digitalWrite( 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; }

(17)

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( time_choice == 0 ) {

(18)

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) {

(19)

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*/ {

else if( minutes == 75 ) /*prints Mn - for Minutes*/ {

else if( minutes == 80 ) /*prints AL - for Alarm*/ {

else if( minutes == 85 ) /*prints dn - for Done*/ {

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 ) {

(20)

}

} }

(21)