Universidade de São Paulo - projeto58.files.wordpress.com · O Projeto 58 consiste no estudo e...

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.

Datasheets e Programação

Diagrama de controle dos displays

Diagrama de controle do motor

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


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


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


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

















}}

Datasheets

Universidade de São Paulo - projeto58.files.wordpress.com · O Projeto 58 consiste no estudo e...

Documents

Transcript of Universidade de São Paulo - projeto58.files.wordpress.com · O Projeto 58 consiste no estudo e...