CENTRO UNIVERSITÁRIO SANTANNA CURSO DE ENGENHARIA DA COMPUTAÇÃO
CARLILIAN OLIVEIRA ERICK CARRIJO DE OLIVEIRA JOICE CRISTINA CANDIDO JOSÉ OLAIRSON VALENTIM LEANDRO ORTEGA OSÉIAS VIEIRA MELO PABLO INÁCIO DUTRA
Projeto Integrador
São Paulo 2012
CARLILIAN OLIVEIRA ERICK CARRIJO DE OLIVEIRA JOICE CRISTINA CANDIDO JOSÉ OLAIRSON VALENTIM LEANDRO ORTEGA OSÉIAS VIEIRA MELO PABLO INÁCIO DUTRA
Projeto Integrador
Projeto apresentado ao Centro Universitário Santanna, como requisito obrigatório para obtenção da nota do Projeto Integrador. Orientador: Prof. Paulo Cezar Souza
São Paulo 2012
Dedicamos este projeto a todo professor que acredita no potencial de seu aluno, tornando-se seu principal incentivador.
Resumo
O projeto consiste em desenvolver um sistema de controle microprocessado baseado em lógica Fuzzy, utilizando microprocessador Arduino. No projeto será demonstrado como é possível controlar a posição de um objeto, utilizando a lógica Fuzzy, microcontroladores, sensores e uma turbina de ar e também demonstrar que ao utilizar a lógica Fuzzy o nível de precisão é maior do que quando utilizamos outras formas de controle, como o PID por exemplo. No projeto utiliza-se a linguagem C# com a biblioteca DotFuzzy para efetuar a fuzzificação e enviar a informação ao microprocessador Arduino, utiliza-se a linguagem C++ para configurar os microcontroladores que tem a função de receber as informações do sensor e controlar a velocidade da turbina. A automação é feita através de controle microprocessado, motor e sensor ultrassônico.
Abstract
The project is to develop a microprocessor control system based on fuzzy logic, using Arduino microprocessor. In the design will be demonstrate how it is possible to control the position of an object using a fuzzy logic, microcontrollers, sensors, and an air turbine, and also demonstrate how better is fuzzy logic than other forms of control, like as PID for example. In this project will be used the C# program language with the library to make DotFuzzy fuzzification and send the information to the Arduino microprocessor, use C++ program language to configure the microcontroller whose function is to receive the sensor information and control the speed of the turbine. The automation is done by microprocessor control, motor and ultrasonic sensor.
Sumário
1.
Diretivas do Projeto Integrador ................................................. 7
2.
Introdução .................................................................................... 8
3.
Desenvolvimento ........................................................................ 9
3.1.
Arduino .................................................................................... 10
3.1.1.
Composição Básica da Placa do Arduino ........................ 11
3.1.2.
Como Programar ................................................................. 12
3.1.3.
Integração com o Computador .......................................... 13
3.2.
Sensor Ultrassônico .............................................................. 14
3.3.
Driver para acionamento da turbina .................................... 17
3.4.
C# e dot.Net............................................................................. 19
3.5.
Sistemas de Controle Fuzzy ................................................. 20
3.6.
DotFuzzy .................................................................................. 22
3.6.1.
Funções da Biblioteca DotFuzzy ....................................... 23
3.6.2.
Exemplo de um código fonte em C# usando DotFuzzy .. 24
4.
Diagramas .................................................................................. 27
5.
Programação ............................................................................. 31
6.
Interface gráfica ........................................................................ 34
7.
Montagem da parte física ......................................................... 36
8.
Conclusão .................................................................................. 38
9.
Bibliografia: ............................................................................... 39
1. Diretivas do Projeto Integrador
O TEMA: Sendo o tema livre, foi escolhido um projeto que de certa forma engloba todas as disciplinas abordadas até o momento. Empenhamo-nos em moldar o projeto aos requisitos de cada disciplina. Neste projeto, foi aplicado o conhecimento dos seguintes módulos:
INTELIGÊNCIA ARTIFICIAL
Foram programados mecanismos de buscas em espaços de soluções para permitir o desempenho em saídas geradas por microcontroladores e computadores inteligentes sobre atuadores.
SISTEMAS ESPECIALISTAS
Foi especificada uma arquitetura de sistema que descreve os componentes de um Sistema Especialista, como interface de aquisição de conhecimento, base de conhecimento, motor de inferência e interface de avaliação do resultado.
INTERFACE HOMEM MÁQUINA
Desenvolveu-se uma avaliação de usabilidade para garantir a facilidade do uso e a tolerância à falha humana. A meta de usabilidade determinada é “não erro”.
CONTROLE INTELIGENTE
Produziu-se um sistema de malha fechada de controle alimentado por comportamento inteligente pela lógica Fuzzy; garantindo a precisão dos resultados, mesmo com entradas vagas ou imprecisas.
7
2.
Introdução
O objetivo do projeto é utilizar a lógica Fuzzy para estabilizar um objeto em um túnel de vento gerado por uma turbina. Utiliza-se o Arduino para receber as informações coletadas do sensor ultrassônico que são processadas pelo programa rodando no computador que envia a outro Arduino responsável por controlar a velocidade da turbina, estabilizando assim o objeto em uma posição enviada pelo computador. Esse controle inteligente é baseado nas regras Fuzzy. Este projeto utiliza controle inteligente que é o sucessor do campo de controle adaptativo, muito usado na década de 70. Modelagens de controle inteligente buscam aprender para reduzir incertezas e melhorar o desempenho de um sistema fechado em loop, baseando-se em aproximações e técnicas de passo a passo a fim de possibilitar a solução de problemas ainda não cobertos por outros métodos de solução, incluindo-se medidas complicadas baseadas em sistemas não lineares. Como os campos de controle não linear estão se tornando bem fundamentados, as ferramentas de controle como redes neurais, logica fuzzy tem se tornando populares e bem utilizadas. Os autores do projeto optaram por utilizar regras fuzzy em consequência desse aumento de popularidade e confiabilidade demonstrada.
8
3. Desenvolvimento
No desenvolvimento do trabalho foram utilizados alguns softwares e ferramentas que facilitaram todo o processo da automatização. Foi desenvolvido um software na linguagem C# juntamente com a biblioteca DotFuzzy que faz a fuzzificação e interface entre os dois microcontroladores, estes programados na própria IDE do Arduino em linguagem C++. Na parte de hardware, temos um motor retirado de um secador de cabelos, um sensor ultrassônico.
9
3.1.
Arduino
Arduino é uma plataforma open-source de protótipos eletrônicos com hardware e software flexíveis e fáceis de usar. Pela sua simplicidade e baixo custo é muito utilizado por artistas, designers, e qualquer pessoa interessada em criar objetos ou ambientes interativos. As placas podem ser construídas à mão ou compradas, o software pode ser baixado gratuitamente. Os projetos de hardware estão disponíveis sob uma licença open-source e você está livre para adaptá-los às suas necessidades.
10
3.1.1.
Composição Básica da Placa do Arduino
A placa é basicamente composta de um micro-controlador (o cérebro da placa), um circuito para gerar o clock (velocidade de processamento, dado em MHz) composto de um cristal e dois capacitores, um chip FTDI de conversão Serial-USB, para que possamos enviar o programa do computador para o Arduino, ou para fazermos alguma leitura da placa. Temos quatorze pinos de entrada/saída digitais sendo que seis destes pinos são PWM (modulação por largura de pulso), ou seja, através do ajuste da frequência, conseguimos ter um valor entre zero e cinco Volts na saída, alternando a variável com um número entre zero e quinhentos e doze, respectivamente. Temos seis pinos de entradas analógicas onde podemos fazer leitura analógica. O Arduino tem um circuito embutido chamado conversor analógico digital que lê a variação na tensão causada pelo potenciômetro e converte-a em números entre 0 e 1023.
11
3.1.2.
Como Programar
No site do Arduino na seção de downloads, temos disponível gratuitamente a IDE (Integrated
Development
Environment ),
um ambiente integrado para
desenvolvimento de software. Através desta IDE , escrevemos um código em linguagem C++, com algumas bibliotecas já pré-dispostas, que nos possibilita o controle total da placa do Arduino. Após o código escrito, verificamos se o código está correto compilando o mesmo na própria IDE . Se estiver tudo correto, basta fazer o upload do programa para o Arduino via cabo USB e pronto! Seu Arduino estará programado para executar seu programa.
12
3.1.3.
Integração com o Computador
O Canal Serial, além de servir para passar os programas da IDE do Arduino para o micro controlador, também serve para que o Arduino se comunique com outros dispositivos, por exemplo, Arduino + GPS, Arduino + Celular, Arduino+ Computador, Arduino + Arduino, Arduino + Display, etc. O Canal Serial utiliza-se de dois cabos, um para transmitir informações (TX), e outro para receber informações (RX). No Arduino, os pinos zero e um fazem estes papéis. Em seu computador, geralmente, temos uma porta padrão DB9 para esta comunicação. No nosso caso, iremos utilizar o cabo USB, já que o Arduino vem equipado com o conversor Serial-USB.
13
3.2.
Sensor Ultrassônico
A principal vantagem do sonar além do seu baixo custo é a necessidade de poucos recursos computacionais. Mas a informação retornada é limitada devido ao seu de raio de atuação muito largo, o que causa leituras imprecisas do ambiente. O sonar é bastante empregado robótica móvel também por ser um dos mais simples de operar. O seu funcionamento se resume a: um transdutor emite uma pequena onda de som em alta frequência; quando esta onda atinge um objeto ela se reflete e é novamente captada pelo transdutor. A distância pode ser calculada usando o tempo entre a emissão e o recebimento de uma onda de som, dividindo-se o tempo decorrido por dois, e multiplicando o resultado pela velocidade do som.
14
Características do Módulo Ultrassônico Tensão
- 5v
Corrente
- 30mA Tip. 50mA Max.
Freqüência
- 40KHz
Distância Max.
-3m
Distância Min.
- 3 cm
Sensibilidade
- Detecta um cabo de vassoura com 3cm de diâmetro, a mais de 2m de distância
Disparo (Trigger)
- 10uS Min. nível TTL
Pulso de eco
- Sinal TTL positivo, proporcional à distância ao obstáculo
Dimensões
- 43mm x 20mm x 17mm
O sensor é controlado por um impulso de nível lógico “1”, com a duração de 20µS. Após receber este impulso de disparo, o sensor envia um sinal acústico ultrassônico e coloca a linha de eco no nível lógico “1”, ficando de seguida à espera pelo sinal acústico do eco. Assim que o eco é recebido, o sensor coloca a linha de eco novamente a “0”. O microcontrolador pode ser facilmente programado para medir o tempo que o eco demorou a ser detectado, isto é, o tempo que a linha de eco esteve a “1”, e dessa forma calcular a distância a que se encontra o obstáculo que provocou o eco. O diagrama temporal da figura abaixo ilustra o que foi dito.
Diagrama Temporal do Sensor Ultrassônico
15
A dispersão do sinal acústico não é uniforme para todo o espaço, e apesar do sensor trabalhar com um ângulo de dispersão de 90º (noventa graus), a sua precisão melhora consideravelmente se for diminuído o ângulo para o qual se pretende que seja efetivada a detecção para um ângulo de 45º de dispersão.
Padrão de dispersão do sinal ultrassônico do sensor Ligação entre o sensor e o Arduino
OBS.: Na ilustração os pinos utilizados foram o 12 e o 10, mas no projeto utilizamos os pinos 8 e 4 respectivamente.
16
3.3.
Driver para acionamento da turbina
Como a turbina de ar utilizada é alimentada por 12 volts e uma corrente muito maior do que a fornecida pela saída PWM do Arduino, foi preciso montar um circuito que atuasse como driver para a turbina utilizando um transistor TIP120. Abaixo, as especificações técnicas retiradas do datasheet do fabricante.
17
A configuração do circuito foi a seguinte:
Resistor de 2,2K ligado à base do transistor e ao pino PWM do Arduino. Diodo 1N4007 ligado entre os terminais da turbina de ar para que evite uma corrente reversa ao ser desligada a turbina, pois ela é construída a partir de enrolamentos de cobre, o que faz com que seja induzida uma corrente ao ser desligada a alimentação da mesma. Alimentação de 12 volts e 1 Ampére. Nunca se esquecendo de tornar o aterramento comum entre todos os circuitos.
18
3.4.
C# e dot.Net
A programação no computador foi feita com a ajuda do Visual Studio, onde iremos iniciar um novo Projeto, selecionando Visual C# como linguagem de programação, Windows Form Application como o tipo do nosso Projeto, e selecionaremos o framework .NET Framework 3.5 . Uma breve explicação para Framework : Nós, humanos, escrevemos uma linguagem de programação em um
nível mais próximo da nossa linguagem, então este código é compilado e o Framework é o responsável em pegar nosso código e transformá-lo em códigos que o computador entenda e possa interagir com os dispositivos. Para adicionar um controle pela porta serial ao programa, basta selecionar SerialPort na caixa de ferramentas e arrastar para dentro da janela programa criado. Depois de adicionada, pode-se configurar as suas propriedades da seguinte forma:
19
3.5.
Sistemas de Controle Fuzzy
A Lógica Fuzzy (Nebulosa) é a lógica que suporta os modos de raciocínio que são aproximados ao invés de exatos. Modelagem e controle Fuzzy de sistemas são técnicas para o tratamento de informações qualitativas de uma forma rigorosa. Derivada do conceito de conjuntos Fuzzy, a lógica Fuzzy constitui a base para o desenvolvimento de métodos e algoritmos de modelagem e controle de processos, permitindo a redução da complexidade de projeto e implementação, tornando-se a solução para problemas de controle até então intratáveis por técnicas clássicas. A ideia básica em controle Fuzzy é modelar as ações a partir de conhecimento especialista, ao invés de, necessariamente, modelar o processo em si. Isso nos leva a uma abordagem diferente dos métodos convencionais de controle de processos, onde os mesmos são desenvolvidos via modelagem matemática dos processos de modo a derivar as ações de controle como função do estado do processo. A motivação para esta nova abordagem veio de casos onde o conhecimento especialista de controle era disponível, seja por meio de operadores ou de projetistas, e os modelos matemáticos envolvidos eram muito custosos, ou muito complicados para serem desenvolvidos. A estrutura de um processo controlado por um controlador Fuzzy é mostrada na figura abaixo enfatizando-se seus componentes básicos: a interface de fuzzyficação, a base de conhecimento, a base de dados, o procedimento de inferência e a interface de defuzzyficação.
20
A interface de fuzzyficação toma os valores das variáveis de entrada, faz um escalonamento para condicionar os valores ao universo de discurso normalizado e fuzzyfica os valores, transformando números em conjuntos Fuzzy, de modo que possam se tornar instâncias de variáveis linguísticas. A base de conhecimento consiste de uma base de regras, caracterizando a estratégia de controle e suas metas. A base de dados armazena as definições necessárias sobre discretizações e normalizações dos universos de discurso, as partições Fuzzy dos espaços de entrada e saída e as definições das funções de pertinência. O procedimento de inferência processa os dados Fuzzy de entrada, junto com as regras, de modo a inferir as ações de controle Fuzzy, aplicando o operador de implicação Fuzzy e as regras de inferência da lógica Fuzzy. A interface de defuzzyficação transforma as ações de controle Fuzzy inferidas em ações de controle não-fuzzy. Em seguida, efetua um escalamento, de modo a compatibilizar os valores normalizados vindos do passo anterior com os valores dos universos de discurso reais das variáveis. Após a inferência da ação de controle fuzzy, é necessária a determinação de uma ação de controle não fuzzy que melhor represente a decisão fuzzy, para ser efetivamente enviada ao controle. Apesar de não haver nenhum procedimento sistemático para a escolha da estratégia de defuzzyficação, as mais comuns incluem: o critério do máximo (MAX), que escolhe o ponto onde a função inferida tem seu máximo, a média dos máximos (MDM), que representa o valor médio dentre todos pontos de máximo quando existe mais de um máximo, e o método do centro de área (CDA), que retorna o centro de área da função inferida.
21
3.6.
DotFuzzy
DotFuzzy é uma classe de biblioteca open source, sob a licença LGPL, desenvolvida para resolver problemas ligados à Lógica Fuzzy. A biblioteca foi construída em C# e pode ser implementada por todas as linguagens que o .NET suporta. Por ser totalmente orientada a objetos tem-se uma facilidade de uso e implementação muito grande. O DotFuzzy foi desenvolvido para ser flexível, robusto e escalável. O DotFuzzy implementa a fuzzyficação, as regras de validação e a defuzzyficação com o método centroide, um dos mais utilizados pela lógica Fuzzy.
22
3.6.1.
Funções da Biblioteca DotFuzzy
A biblioteca DotFuzzy.dll é compilada com os seguintes arquivos, sendo que todos são open source, livres para consulta e alteração se preciso. As funções utilizadas estão todas dentro dos arquivos .CS, que por sua vez estão compiladas dentro do arquivo DotFuzzy.dll.
Referenciaremos a biblioteca ao projeto no Visual Studio, ficando da seguinte forma:
23
3.6.2.
Exemplo de um código fonte em C# usando DotFuzzy
Com o Visual Studio preparado, agora basta começar a programar usando a linguagem C#. Adiante, será mostrado um pequeno exemplo do uso da biblioteca, onde os parâmetros serão fixos e escritos no próprio código fonte, portanto, funcionará apenas para um exemplo específico. Código fonte do arquivo
24
Este programa demonstrado, ao ser executado irá ter a seguinte resposta:
Seria uma espécie de “Hello World” para o DotFuzzy. Ao clicar no botão “Exemplo”,
ele chama a função descrita no código acima como: private void button1_Click(object sender, EventArgs e)
Quando esta função é chamada, temos a linha: LinguisticVariable water = new LinguisticVariable("Water");
Que cria uma variável linguística chamada “water ”, e irá acrescentar os parâmetros
de frio, morno ou quente, nas seguintes linhas: water.MembershipFunctionCollection.Add( new MembershipFunction("Cold", 0, 0, 20, 40)); water.MembershipFunctionCollection.Add( new MembershipFunction("Tepid", 30, 50, 50, 70)); water.MembershipFunctionCollection.Add( new MembershipFunction("Hot", 50, 80, 100, 100));
Ela executa o mesmo procedimento para criar a variável linguística chamada “Power”.
Depois disso, ela cria o objeto fuzzyEngine, que é como se fosse o motor de inferência Fuzzy, com a seguinte função: FuzzyEngine fuzzyEngine = new FuzzyEngine ();
Agora são adicionadas as variáveis linguísticas ao objeto criado: fuzzyEngine.LinguisticVariableCollection.Add(water); fuzzyEngine.LinguisticVariableCollection.Add(power);
É estipulada qual é a variável de saída: fuzzyEngine.Consequent = "Power"; 25
São acrescentadas as regras de inferência: fuzzyEngine.FuzzyRuleCollection.Add( new FuzzyRule("IF (Water IS Cold) OR (Water IS Tepid) THEN Power IS High")); fuzzyEngine.FuzzyRuleCollection.Add( new FuzzyRule("IF (Water IS Hot) THEN Power IS Low" ));
É estipulado um valor de entrada para a variável water: water.InputValue = 60;
Ao final é chamada a função que abre uma caixa de mensagens com a resposta: 39,72. MessageBox.Show(fuzzyEngine.Defuzzify().ToString());
26
4. Diagramas
Para a criação dos programas, foram levantados os fluxos principais e os diagramas são mostrados a seguir. O primeiro fluxograma mostra uma visão superficial do sistema.
27
Nos próximos três fluxogramas foram divididos os códigos de cada componente do sistema: Sensor, Processo e Atuador, que ficaram da seguinte forma:
28
29
30
5. Programação
Baseado nos sistemas e dispositivos acima citados, começaremos a montagem do projeto. A lógica do sistema será descrita a seguir, com informações detalhadas de cada trecho do código: Sensor ultrassônico faz medição da distância do objeto através do código abaixo e envia o valor ao computador
Computador recebe o valor da distância e envia o valor para ser fuzzyficado.
O processo de fuzzyficação funciona da seguinte forma: A distância é comparada com o gráfico a seguir, para a obtenção da pertinência: Entrada: Distância
muitoPerto = (0,0) ; (0,1) ; (12,1) ; (20,0) Perto = (12,0) ; (23,1) ; (26,1) ; (30,0) Meio = (26,0) ; (30,1) ; (33,1) ; (38,0) Longe = (35,0) ; (38,1) ; (42,1) ; (52,0) muitoLonge = (42,0) ; (50,1) ; (60,1) ; (60,0)
31
Na biblioteca DotFuzzy é programado da seguinte maneira:
Depois de obtido o valor, executa-se a função, que pelo método centróide vai retornar o valor de saída fuzzyficado, sendo que a saída é regida pelo seguinte gráfico: Saída: potência do motor
muitoFraco = (60,0) ; (60,1) ; (60,1) ; (65,0) Fraco = (60,0) ; (65,1) ; (66,1) ; (67,0) Medio = (66,0) ; (74,1) ; (76,1) ; (84,0) Forte = (76,0) ; (84,1) ; (85,1) ; (90,0) muitoForte = ( 85,0) ; (90,1) ; (90,1) ; (90,0)
Na biblioteca DotFuzzy programa-se da seguinte maneira:
As regras utilizadas neste processo são as seguintes: Regras de Fuzzificação
32
Na biblioteca, já com o comando de fuzzificação, funciona da seguinte forma:
Na sequencia, o programa envia o valor para o segundo Arduino, que está ligado à turbina de ar:
O segundo Arduino, ligado à turbina recebe o valor que será convertido em um sinal PWM compreendido entre zero e cinco volts.
Na sequencia, o drive PWM recebe o valor entre zero e cinco volts, convertendo-o em um valor entre zero e doze volts, este sim que alimentará a turbina, fazendo com que o objeto permaneça suspenso no ar, praticamente fixo nessa posição. Caso o objeto desloque-se para baixo ou para cima, o sistema detecta o movimento e informa à turbina a rotação necessária para a permanência do objeto na mesma posição.
33
6. Interface gráfica
A interface gráfica criada no Visual Studio C# tem a função de verificar as portas seriais, receber a informação que foi lida pelo microcontrolador no sensor ultrassônico, fazer a fuzzificação da informação recebida e enviar esta informação para o segundo microcontrolador, que tem a função de controlar a turbina, variando sua velocidade através do controle de corrente, assim possibilitando a permanência do objeto a uma determinada distancia.
Interface criada para o controle
Conforme figura, ele contém os seguintes botões e componentes em sua interface:
Botão Ativar/Desativar, utilizado para ativar as portas serias e iniciar a leitura e envio de informações;
Caixa de seleção Porta Sensor e Porta Turbina: contém as opções de portas seriais no exemplo “COM5 e COM3”, que podem ser utilizadas com os
microcontroladores.
Barras de progresso: uma indicação visual dos valores recebidos e enviados para os dois microcontroladores. Esta visualização permite ter informações detalhadas do valor lido pelo sensor ultrassônico e o valor enviado para a turbina através do segundo microcontrolador. 34
Este conjunto faz toda a parte de comunicação e ajuste de potência. O software em si, tem todo o controle que permite ao usuário efetuar a melhor opção de portas e velocidade utilizando a lógica Fuzzy. Buscamos desenvolver o software de uma maneira bem minimalista e intuitiva, tendo como meta de usabilidade o não acesso ao erro, em caso de erro, o usuário consegue facilmente reverter o resultado através da interface.
35
7. Montagem da parte física
Inicialmente houve a tentativa de montar com um cooler de doze (12) volts / doze mili (0,12) amperes em uma garrafa pet adaptada, porém, notou-se que este modelo não tinha potência suficiente para levitar a bolinha, então foi usada uma turbina de secador de cabelos e colocada em um tubo transparente de sessenta cm, com o sensor localizado no topo do tubo, e então conseguimos o resultado esperado.
Protótipo inicial (à esquerda) e Protótipo Final (à direita)
36
Depois começamos a fazer os testes com o sensor ultrassônico para definir qual seria o range do mesmo, e como ele se comportava em ambientes abertos e dentro do tubo.
Sensor ultrassônico sendo testado
Agora é a vez de ajustar qual é a tensão máxima e mínima de alimentação da turbina de ar para setar os valores máximos e mínimos a serem assumidos através do pino PWM que injeta a corrente no driver.
Turbina de ar sendo testada 37
8.
Conclusão
Com a elaboração deste projeto consegue-se avaliar o quanto o sistema de controle baseado em lógica Fuzzy é mais veloz para atingir a estabilidade de resposta sem necessidade de ficar oscilando entre picos. Leva-se um tempo para aferir os valores para a estruturação dos gráficos de entrada e saída no processo de fuzzificação. Neste projeto, como é apenas de caráter educacional, os ajustes foram feitos pelos próprios autores até chegar ao padrão ideal, mas quando for implementado em alguma aplicação que exija precisão, é necessário a consulta com um especialista no auxílio da plotagem de tais gráficos.
38