Tutorial de Computação PWM v2010.08

Tutorial de Computação PWM v2010.08 Linha de Equipamentos MEC Desenvolvidos por: Maxwell Bohr Instrumentação Eletrônica Ltda. Rua Porto Alegre, 212 Londrina PR Brasil http://www.maxwellbohr.com.br

1 Introdução Esse tutorial irá abordar a programação para controle dos PWM do MEC1100. Esse tipo de dispositivo permite um controle muito variado de seu sinal, sendo possível desde escolher a intensidade de luminosidade de uma fonte de luz até definir com precisão o posicionamento do eixo de um motor. Vamos criar um projeto que permite ligar e desligar os PWMs e ajustar os parâmetros de seu sinal. Também veremos como um PWM pode ser conectado ao MEC1100, e assim desfrutar de todas as suas funcionalidades. PWM (Pulse Width Modulation) ou Modulação por Largura de Pulso O PWM é um sinal periódico em que se pode ajustar o período e tempo ativo. Figura 1: Exemplo de sinal PWM Pode ser usado para conversão digital/analógico, usando apenas um bit, onde é gerada uma forma de onda quadrada onde o tempo em que esta forma fica em "1" define o valor da saída. Por exemplo, se o bit 1 permanecer durante 45% do tempo da onda, o sinal será de 45% do valor total. O servomotor é um exemplo típico de dispositivo que usa PWM para ser controlado. Seu período é de 20ms. Isso significa que a onda se repetirá a cada 20 ms. O Tempo Ativo, mais conhecido como ciclo ativo, terá sua duração em uma faixa que varia de 1 a 2ms. Conforme a duração do ciclo ativo pode-se definir a nova posição do eixo, 1ms para -90, 1,5ms para posição central e 2ms para +90. É possível controlar dispositivos PWM através desta porta, ajustando o sinal de acordo com a frequência (tamanho da onda) e duração do pulso. Os pinos de 1 a 3 possuem comportamento diferente dos pinos 4 a 8. Os 3 primeiros permitem uma precisão maior com relação a duração do sinal (faixa válida de 0-750ms - precisão de 90ns a 12us) enquanto que os demais permitem um controle de duração menos preciso (faixa válida de 0-524s - precisão de 62,5us a 8ms). PWM 1 a 3 => faixa válida de 0-750ms - precisão de 90ns a 12us. PWM 4 a 8 => faixa válida de 0-524s - precisão de 62,5us a 8ms. 1

2 Material Para esse tutorial é necessário um MEC1100 com um ou mais PWMs conectados à ele. A porta para conexão dos PWMs está conjugada com a porta de Servomotores. Para maiores informações de como ligar os PWMs ao módulo veja os tópicos deste tutorial. Para a criação do programa será necessário o Borland Delphi 6. A seguir a imagem do MEC1100, necessário para esse tutorial. Figura 2: MEC1100 com destaque para a porta dos PWMs. 3 Ligação e Adaptação de PWMs As saídas para conexão com PWMs foram desenvolvidas tendo como objetivo possibilitar seu uso nas mais variadas aplicações. A utilização de PWMs, em conjunto com as funcionalidades do MEC1100, possibilita a elaboração de sistemas mecânicos automatizados, como robôs, além de controle e interação de uma infinidade de dispositivos eletroeletrônicos. Para criar e controlar esses esquemas, é necessário conectar adequadamente os PWMs. Torna-se indispensável conhecer a pinagem das saídas de PWMs, baseando-se na imagem a seguir. 2

Figura 3: Pinagem de ligação: +V, Sinal e GND Analisando a imagem acima, podemos perceber algumas características desses conectores. Cada um deles possui três pinos, sendo um de 5V, um ajustando o sinal e um de 0V. Fazendo uso do programa criado com esse tutorial, das funcionalidades do MEC1100 e conhecendo o esquema dos conectores, o usuário é então capaz de criar um sistema de automação, estabelecendo relações entre os componentes do MEC1100, de modo que eles interajam de acordo com a aplicação a qual sejam destinados. A utilização dos PWMs encontra uma limitação na fonte de alimentação do MEC1100. É necessário o uso de alimentação externa quando houver o desejo de ligar mais de um PWM simultaneamente, pois o seu consumo não é suportado pela fonte de alimentação, que é capaz de fornecer apenas algumas centenas de miliamperes. Como consequência, a fonte poderá superaquecer e danos podem ser causados ao equipamento. 4 Projeto Nesse tutorial vamos desenvolver três programas para controlar os PWMs do MEC1100. No primeiro, iremos ligar e desligar os PWMs além de ajustar os parâmetros de seu sinal a partir da definição do período do sinal, definição do tempo do Ciclo Ativo e do divisor do Clock interno do Hardware. A aparência desse programa depois de pronto será a seguinte. Figura 4: Interface gráfica do primeiro programa desenvolvido nesse tutorial: PWMs. 3

No segundo programa, iremos controlar um servomotor, ajustando o tempo do período e o tempo de sinal ativo. A aparência desse programa será a seguinte: Figura 5: Interface do segundo programa: PWM: Ajuste pelo Tempo. No terceiro programa, faremos um controle de intensidade de luz emitida por um LED, através do controle de frequência do sinal enviado ao LED. A aparência desse programa será a seguinte: Figura 6: Terceiro exemplo deste tutorial. 4

Ainda iremos criar um gerador de clock, muito útil em eletrônica para criar uma sincronização entre dispositivos. O gerador de clock será feito a partir de uma simples alteração no exemplo 3. Exemplo 1: Método PwmOn O método PwmOn ativa um dispositivo PWM passando como parâmetros valores para o período e ciclo ativo. Esses valores variam de 0 a 65535. Conforme o número do pino utilizado, esses valores representam diferentes quantidades de tempo. Nos pinos de 1 a 3, o tempo de controle varia de 0 a 750 ms. Nos demais, varia entre 0 e 524 s. Os pinos de 1 a 3 também permitem uma maior precisão com relação ao posicionamento desses valores, indo de 90 ns a 12 us. Os demais pinos permitem uma precisão de 62,5us a 8ms. Nosso primeiro passo do primeiro programa é criar a interface gráfica. Vamos utilizar o projeto criado no tutorial Base que já nos fornece algumas funcionalidades interessantes. Para isso copiamos o projeto daquele tutorial e em cima dele vamos adicionar alguns componentes gráficos extras. Este programa irá controlar um PWM através do envio de valores para período, ciclo ativo e o divisor de clock, além de definir a polaridade do sinal de PWM. Essa interface possui quatro componentes do tipo TLabel que são utilizados para identificação das configurações. Outro componente é um TComboBox que é utilizado para selecionar o PWM que queremos controlar. Existe também três TScrollBar para ajustar os parâmetros, um TCheckBox para inverter a polaridade do sinal e por fim dois botões utilizados para ligar e desligar o PWM selecionado. Todos esses componentes encontram-se na aba Standard da barra de componentes. Figura 7: Aba "Standard" da Barra de componente. Vamos adicionar os TLabel e o TComboBox para a seleção do PWM que queremos controlar. O componente TLabel possui o seguinte ícone. Figura 8: Ícone do componente TLabel. E o componente TComboBox possui o seguinte ícone. Figura 9: Ícone do componente TComboBox. 5

Adicionamos os quatro TLabel e modificamos as seguintes propriedades. Caso tenha dúvidas sobre o posicionamento, consulte a imagem com a janela do programa já com os componentes posicionados. Name = LabelPeriodo Caption = Período: Font/Style/fsBold = true Name = LabelCicloAtivo Caption = Ciclo Ativo: Font/Style/fsBold = true Name = LabelDivisorClock Caption = Divisor de Clock: Font/Style/fsBold = true Name = LabelPwm Caption = PWM: Font/Style/fsBold = true Em seguida adicionamos um componente TComboBox e modificamos as propriedades a seguir. Name = ComboBoxPwm Style = csdropdownlist Items.Strings = 1, 2, 3, 4, 5, 6, 7, 8 (um abaixo do outro, sem as virgulas) ItemIndex = 0 Com isso nosso Form irá se parecer com o seguinte. 6

Figura 10: Form parcialmente montado. Agora vamos inserir os componentes para ajuste do sinal do PWM. Aqui vamos utilizar três componente TScrollBar. O componente TScrollBar encontra-se na aba Standard da barra de componentes e possui o seguinte ícone. Figura 11: Ícone do componente TScrollBar. Adicionamos os componentes e modificamos as seguintes propriedades do TScrollBar. Name = ScrollBarPeriodo Max = 65535 Position = 0 Name = ScrollBarCicloAtivo Max = 65535 Position = 0 Name = ScrollBarDivisorClock Max = 7 Position = 0 7

Criamos agora uma caixa de verificação, utilizando o componente TCheckBox. Este componente se encontra na aba Standard, e tem o seguinte ícone: Figura 12: Ícone do componente TCheckBox. Após adicionar o componente ao formulário, altere as propriedades: Name = CheckBoxPolaridade Caption = Inverter Polaridade Nesse ponto só nos falta adicionar os dois botões para ligar e desligar o PWM. Para isso adicionamos dois componentes TButton que podem ser encontrados na aba Standard da barra de componentes. Esse componente possui o seguinte ícone. Figura 13: Ícone do componente TButton. motor. Temos que modificar as seguintes propriedades dos botões. Primeiro do botão para ligar o Name = ButtonLigar Caption = Ligar Em seguida as propriedades do botão para desligar o motor. Name = ButtonDesligar Caption = Desligar Um último detalhe que vamos modificar é a propriedade Caption do Form principal. Como copiamos o projeto do tutorial Base, essa propriedade possui o valor Projeto Base. Vamos modificar essa propriedade para PWMs. Com isso finalizamos a construção de nossa interface gráfica. A seguir a imagem dessa interface finalizada. 8

Figura 14: Interface finalizada. O próximo passo é implementar o código para controle dos PWMs. Para isso precisamos criar um manipulador para o evento OnClick do botão Ligar e um para o botão Desligar. Vamos criar primeiro o manipulador do botão que liga os PWMs. Para fazer isso podemos selecionar o componente TButton que possui o texto Ligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. Procedure TFormMain.ButtonLigarClick(Sender:TObject); Dentro desse manipulador vamos implementar o código que liga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOn. Esse método possui a seguinte declaração. Procedure PWMOn(pwm : Byte; period : Integer; active : Integer; clk_div : Byte; pol : Byte); Esse método possui cinco parâmetros, o primeiro indicando o PWM que será ligado, o segundo informando um valor para o período de cada sinal, o terceiro um valor para a duração de sinal de Ciclo Ativo, o quarto para a divisão do Clock e o quinto para definir a polaridade do sinal do PWM. O MEC1100 suporta até 8 servo motores, logo o primeiro parâmetro pode variar de 1 a 8. O parâmetro de período e ciclo ativo podem variar de 0 a 65535, o divisor de clock pode ser de 0 a 9

7 e a polaridade aceita 0 para negativo e 1 para positivo. Agora vamos implementar o código para acionar os PWMs. A seguir o código do manipulador do botão Ligar. Procedure TFormMain.ButtonLigarClick(Sender: TObject); // Liga e ajusta os parâmetros do PWM mec.pwmon(strtoint(comboboxpwm.text), ScrollBarPeriodo.Position, ScrollBarCicloAtivo.Position, ScrollBarDivisorClock.Position, strtoint(booltostr(not(checkboxpolaridade.checked)))); Como podemos observar, é muito simples ligar um PWM. Foi necessário apenas chamar o método PWMOn com os parâmetros que obtemos dos componentes TComboBox e TScrollBar. O item do TComboBox foi adicionado de modo que o valor dentro desse componente equivale ao parâmetro que deve ser passado ao método PwmOn para indicar o PWM que ele corresponde. Dessa forma é necessário apenas saber o número do PWM selecionado no TComboBox e passar esse como parâmetro. O parâmetro do período será o valor da propriedade Position do TScrollBar. Ele sempre estará na faixa de 0 a 65535 porque definimos que a propriedade Max, que define o valor máximo de retorno da posição desse componente, fosse 65535 e por padrão o valor mínimo já é 0. O mesmo ocorre para a duração do Ciclo Ativo. O parâmetro do divisor de clock foi definido na posição do seu TScrollBar. Internamente, a biblioteca usa este valor para definir um divisor de frequência, que pode ser 1, 2, 4, 8, 16, 32, 64 e 128. Estes são valores que resultam da operação 2^ a posição do TScrollBar (0 a 7). Vamos criar agora o manipulador do botão que desliga os PWMs. Para fazer isso podemos selecionar o componente TButton que possui o texto Desligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. Procedure TFormMain.ButtonDesligarClick(Sender:TObject); Dentro desse manipulador vamos implementar o código que desliga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOff. Esse método possui a seguinte declaração. Procedure PwmOff(pwm : Integer); 10

Esse método possui um parâmetro indicando o PWM que será desligado. Agora vamos implementar o código para desligar os PWMs. A seguir o código do manipulador do botão Desligar. Procedure TFormMain.ButtonDesligarClick(Sender: TObject); // Desliga o PWM mec.pwmoff(strtoint(comboboxpwm.text)); Também é possível e muito útil definir que, conforme se escolhe os valores na barra de rolagem, eles apareçam em uma Label, facilitando a escolha do valor. Para isso, clique duas vezes sobre o ScrollBarPeriodo e implemente o seguinte código: procedure TFormMain.ScrollBarPeriodoChange(Sender: TObject); // Exibir o valor na Label LabelPeriodo.Caption:= 'Período : ' + inttostr(scrollbarperiodo.position); Logo após, clique duas vezes sobre o componente ScrollBarCicloAtivo e implemente o código: procedure TformMain.ScrollBarCicloAtivoChange(Sender: // Exibir o valor na Label LabelCicloAtivo.Caption:= 'Ciclo Ativo : ' + inttostr(scrollbarcicloativo.position); TObject); E finalmente, clique duas vezes no componente ScrollBarDivisorClock e adicione o código: procedure TFormMain.ScrollBarDivisorClockChange(Sender: TObject); 11

// Exibir o valor na Label LabelDivisorClock.Caption:= 'Divisor de Clock : ' + inttostr(scrollbardivisorclock.position); Além disso, podemos fazer com que o botão Ligar e Desligar seja ativado de acordo com o estado da conexão com o MEC1100. Para essa finalidade, podemos utilizar o componente TTimer, o qual já foi adicionado anteriormente no Projeto Base. Esse componente pode ser configurado para executar um método em intervalos pré-determinados. No nosso Projeto Base, ele foi configurado para verificar continuamente a presença de um MEC1100 conectado à porta USB. Dê um duplo clique sobre ele, para exibir o código que foi criado anteriormente. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; end... // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; Devemos então configurar o TTimer de modo que ele faça a verificação constantemente. A seguir, o código com a função adicionada. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; 12

// Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; ButtonLerClick(Sender); // Ativa os botoes Ligar e Desligar ButtonLigar.Enabled := true; ButtonDesligar.Enabled := true; end else // Apaga LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := clgreen; // Muda texto para indicar erro de conexão LabelConnected.Caption := 'Desconectado'; // Muda cor do texto para vermelho LabelConnected.Font.Color := clred; // Desativa os botoes Ligar e Desligar ButtonLigar.Enabled := false; ButtonDesligar.Enabled := false; Com isso, se os PWMs já estiverem conectados, podemos fazer um teste de controle dos PWMs do MEC1100. Se os PWMs ainda não foram conectados é interessante ler a seção sobre PWMs no inicio desse tutorial ou deixar para fazer o teste posteriormente. Para testar o programa vamos no menu Run Run ou pressionamos F9. Se não houver nenhum erro o programa será compilado e executado. Com um MEC1100 conectado em alguma porta USB podemos testar se o programa está funcionando. Selecione a porta USB correta, selecione um PWM que está conectado e pressione o botão ligar. O PWM agirá de acordo com os parâmetros selecionados no TScrollBar de ajustes. Teste algumas vezes com valores diferentes. Pronto, temos um programa que controla os PWMs e ajusta os seus parâmetros. Sua aparência final ficou assim. 13

Figura 15: Programa finalizado. Podemos selecionar nessa interface o pino de PWM que vamos controlar e definir os parâmetros para seu funcionamento. Em seguida é preciso apenas pressionar o botão Ligar e o PWM se ajustará aos parâmetros passados. Para desligar o PWM, basta pressionar o botão Desligar. Na figura anterior, o PWM do pino 1 está configurado para posicionar um servomotor na posição -90 graus. Neste caso, será necessário ligar o cabo de conexão do servomotor no pino 1 da porta Servomotores/PWM. Variando o ciclo ativo é possível mudar a posição eixo do servo. A figura abaixo mostra uma configuração que deixa um LED conectado ao pino 4 piscando: Figura 16: Configuração que faz um LED piscar. 14

Mudando o período altera a frequência com que o LED pisca e mudando o ciclo ativo podemos determinar quanto tempo o LED fica aceso a cada piscada. Exemplo 2: PwmOnTime O método PwmOnTime permite ajustar o PWM utilizando como parâmetros o tempo de duração do período e o tempo de permanência do ciclo ativo. Nesta etapa, iremos criar um programa onde esses parâmetros serão passados em função do tempo em milissegundos. Utilizaremos este programa para controlar um Servomotor. Para o funcionamento de um Servomotor, os parâmetros necessários serão: Período: 20 ms Ciclo Ativo: 1 ms = -90 graus no eixo 1,5 ms = posição central 2 ms = + 90 graus no eixo Outros valores intermediários entre 1 e 2 ms podem ser passados para a definição da posição do eixo do servomotor. Estes valores são de uso do servomotor. Para outros componentes diferentes, atente as suas especificações para uma correta manipulação de suas propriedades. A próxima figura exibe a aparência final do programa criado para controlar o servomotor através do método PwmOnTime: Figura 17: Aparência final do programa que controla PWMs ajustando o tempo de Período e Ciclo Ativo. O primeiro passo do programa será criar a interface gráfica. Vamos utilizar o projeto criado no tutorial Base que já nos fornece algumas funcionalidades interessantes. Para isso copiamos o projeto daquele tutorial e em cima dele vamos adicionar alguns componentes gráficos extras. 15

Nossa interface possui cinco componentes do tipo TLabel que são utilizados para identificação das configurações e exibição dos valores escolhidos. Outro componente é um TComboBox que é utilizado para selecionar o PWM que queremos controlar. Existe também dois TScrollBar para ajustar os parâmetros, um TCheckBox para inverter a polaridade do sinal e por fim dois botões utilizados para ligar e desligar o PWM selecionado. Todos esses componentes encontram-se na aba Standard da barra de componentes. Figura 18: Aba "Standard" da Barra de componente. Vamos adicionar os cinco TLabel e um TComboBox para a seleção do PWM que queremos controlar. O componente TLabel possui o seguinte ícone. Figura 19: Ícone do componente TLabel. E o componente TComboBox possui o seguinte ícone. Figura 20: Ícone do componente TComboBox. Após adicionar os cinco TLabel, modifique as seguintes propriedades. Caso tenha dúvidas sobre os posicionamentos, consulte a imagem com a janela do programa já com os componentes posicionados, na figura 20. Name = LabelPeriodo Caption = Período: Font/Style/fsBold = true Name = LabelCicloAtivo Caption = Ciclo Ativo: Font/Style/fsBold = true Name = LabelPeriodoms Caption = 0 ms 16

Name = LabelCicloAtivoms Caption = 0 ms Name = LabelPWM Caption = PWM: Font/Style/fsBold = true Em seguida, selecione o componente TComboBox e modifique as propriedades a seguir. Name = ComboBoxPwm Style = csdropdownlist Items.Strings = 1, 2, 3, 4, 5, 6, 7, 8 (um abaixo do outro, sem as virgulas) ItemIndex = 0 Com isso nosso Form irá se parecer com o seguinte. Figura 21: Form com parte dos componentes. Agora vamos inserir os componentes para ajuste do sinal do PWM. Aqui vamos utilizar dois componente TScrollBar. O componente TScrollBar encontra-se na aba Standard da barra de componentes e possui o seguinte ícone. 17

Figura 22: Ícone do componente TScrollBar. Adicionamos os componentes e modificamos as seguintes propriedades do TScrollBar. Name = ScrollBarPeriodo Max = 75000 Position = 0 Name = ScrollBarCicloAtivo Max = 75000 Position = 0 Criamos agora uma caixa de verificação, utilizando o componente TCheckBox. Este componente se encontra na aba Standard, e tem o seguinte ícone: Figura 23: Ícone do componente TCheckBox. Após adicionar o componente ao formulário, altere as propriedades: Name = CheckBoxPolaridade Caption = Inverter Polaridade Nesse ponto só nos falta adicionar os dois botões para ligar e desligar o PWM. Para isso adicionamos dois componentes TButton que podem ser encontrados na aba Standard da barra de componentes. Esse componente possui o seguinte ícone. Figura 24: Ícone do componente TButton. motor. Temos que modificar as seguintes propriedades dos botões. Primeiro do botão para ligar o Name = ButtonLigar 18

Caption = Ligar Em seguida as propriedades do botão para desligar o motor. Name = ButtonDesligar Caption = Desligar Um último detalhe que vamos modificar é a propriedade Caption do Form principal. Como copiamos o projeto do tutorial Base, essa propriedade possui o valor Projeto Base. Vamos modificar essa propriedade para PWMs: Ajuste pelo Tempo. Com isso finalizamos a construção de nossa interface gráfica. A seguir a imagem dessa interface finalizada. Figura 25: Interface finalizada. O próximo passo é implementar o código para controle dos PWMs. Para isso precisamos criar um manipulador para o evento OnClick do botão Ligar e um para o botão Desligar. Vamos criar primeiro o manipulador do botão que liga os motores. Para fazer isso podemos selecionar o componente TButton que possui o texto Ligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. Procedure TFormMain.ButtonLigarClick(Sender:TObject); 19

Dentro desse manipulador vamos implementar o código que liga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOnTime. Esse método possui a seguinte declaração. Procedure PwmOnTime(pwm : Byte; period_ms : Real; active_cycle_ms : Real; polarity : Byte); Esse método possui quatro parâmetros, o primeiro indicando o PWM que será ligado, o segundo informando um valor para o período de cada sinal em milissegundos, o terceiro um valor para a duração de sinal de Ciclo Ativo também em milissegundos e o quarto para definir a polaridade do sinal do PWM. O MEC1100 suporta até 8 PWMs, logo o primeiro parâmetro pode variar de 1 a 8. O parâmetro de período e ciclo ativo podem variar de 0 a 720 para os pinos 1 a 3 e 0 a 524000 para os pinos de 4 a 8 e a polaridade aceita 0 para negativo e 1 para positivo. Agora vamos implementar o código para acionar os PWMs. A seguir o código do manipulador do botão Ligar. Procedure TFormMain.ButtonLigarClick(Sender: TObject); // Liga e ajusta os parâmetros do PWM mec.pwmontime(strtoint(comboboxpwm.text), ScrollBarPeriodo.Position/100, ScrollBarCicloAtivo.Position/100, strtoint(booltostr(not(checkboxpolaridade.checked)))); Como podemos observar, é muito simples ligar um PWM. Foi necessário apenas chamar o método PwmOnTime com os parâmetros que obtivemos dos componentes TComboBox e TScrollBar. O item do TComboBox foi adicionado na ordem de modo que o valor dentro desse componente equivale ao parâmetro que deve ser passado ao método PwmOnTime para indicar o PWM que ele corresponde. Dessa forma é necessário apenas saber o número do PWM selecionado no TComboBox e passar esse como parâmetro. O parâmetro do período será o valor da propriedade Position do TScrollBar dividido por 100, para uma maior precisão. Ele estará na faixa de 0 a 750 porque definimos a propriedade Max, que define o valor máximo de retorno da posição desse componente. Só que existe um porém: esse valor só é válido caso o pino de PWM escolhido seja 1, 2 ou 3. Nos demais pinos (4, 5, 6, 7 e 8), esse valor deve ser entre 0 e 524000. Portanto, será necessário implementar um código que altere automaticamente o valor máximo dos componentes conforme a porta escolhida. Este código será implementado ainda neste tutorial. Por padrão o valor mínimo já é 0. O mesmo ocorre para a duração do Ciclo Ativo. Vamos fazer a definição do valor máximo dos TScrollBars. Para fazer isso, podemos selecionar o componente TComboBox que possui os valores dos PWMs, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnChange. Uma forma 20

mais fácil de fazer isso é apenas dar um duplo clique sobre o componente no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnChange. O seguinte código será criado. procedure TFormMain.ComboBoxPWMChange(Sender: TObject); Dentro desse manipulador vamos implementar o código que ajusta o valor máximo dos TScrollBar. A seguir o código do manipulador: procedure TFormMain.ComboBoxPWMChange(Sender: TObject); // Verifica o PWM selecionado através do indice do // ComboBoxPWM (vai de 0 a 2) if (ComboBoxPWM.ItemIndex <= 2) then end else // Define os valores maximos dos scrollbars para os // indices do combobox menores ou iguais a 2 (0, 1 e 2) ScrollBarPeriodo.Max:=75000; ScrollBarCicloAtivo.Max:=75000; // Define os valores maximos dos scrollbars // para os indices para os demais ScrollBarPeriodo.Max:=52400000; ScrollBarCicloAtivo.Max:=52400000; A partir deste momento, ao selecionar o número do PWM no TComboBox, o valor máximo dos componentes TScrollBar serão alterados automaticamente de acordo com o PWM escolhido. Se o PWM 1, 2 ou 3 for selecionado (Itens de índices 0, 1 e 2 no TcomboBox), então o valor máximo dos TScrollBar é definido como 75000. Para os outros PWMs o valor máximo é definido como 52400000. Vamos criar agora o manipulador do botão que desliga o PWM. Para fazer isso podemos selecionar o componente TButton que possui o texto Desligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. 21

Procedure TFormMain.ButtonDesligarClick(Sender:TObject); Dentro desse manipulador vamos implementar o código que desliga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOff. Esse método possui a seguinte declaração. Procedure PwmOff(pwm : Integer); Esse método possui um parâmetro indicando o PWM que será desligado. Agora vamos implementar o código para desligar os PWMs. A seguir o código do manipulador do botão Desligar. Procedure TFormMain.ButtonDesligarClick(Sender: TObject); // Desliga o PWM mec.pwmoff(strtoint(comboboxpwm.text)); Também é possível e muito útil definir que, conforme se escolhe os valores na barra de rolagem, eles apareçam em uma Label, facilitando a escolha do valor. Para isso, clique duas vezes sobre o ScrollBarPeriodo e implemente o seguinte código: procedure TFormMain.ScrollBarPeriodoChange(Sender: TObject); // Exibir o valor na Label LabelPeriodoms.Caption:= floattostr((scrollbarperiodo.position)/100) + ' ms'; Logo após, clique duas vezes sobre o componente ScrollBarCicloAtivo e implemente o código: procedure TformMain.ScrollBarCicloAtivoChange(Sender: TObject); // Exibir o valor na Label 22

LabelCicloAtivoms.Caption:= floattostr((scrollbarcicloativo.position)/100) + ' ms'; Os valores máximos dos TScrollBar foram multiplicados por 100 e posteriormente divididos por 100 no momento da passagem para os TLabels e como parâmetros nos códigos. Isto foi preciso para se obter uma maior precisão nos parâmetros enviados, pois os PWMs podem aceitar valores fracionados dos milissegundos. Assim, conseguimos obter uma precisão de dois dígitos nos valores de tempo. Além disso, podemos fazer com que o botão Ligar e Desligar seja ativado de acordo com o estado da conexão com o MEC1100. Para essa finalidade, podemos utilizar o componente TTimer, o qual já foi adicionado anteriormente no Projeto Base. Esse componente pode ser configurado para executar um método em intervalos pré-determinados. No nosso Projeto Base, ele foi configurado para verificar continuamente a presença de um MEC1100 conectado à porta USB. Dê um duplo clique sobre ele, para exibir o código que foi criado anteriormente. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; end... // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; Devemos então configurar o TTimer de modo que ele faça a verificação constantemente. A seguir, o código com a função adicionada. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape 23

ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; ButtonLerClick(Sender); // Ativa os botoes Ligar e Desligar ButtonLigar.Enabled := true; ButtonDesligar.Enabled := true; end else // Apaga LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := clgreen; // Muda texto para indicar erro de conexão LabelConnected.Caption := 'Desconectado'; // Muda cor do texto para vermelho LabelConnected.Font.Color := clred; // Desativa os botoes Ligar e Desligar ButtonLigar.Enabled := false; ButtonDesligar.Enabled := false; Com isso, se os PWMs já estiverem conectados, podemos fazer um teste de controle dos PWMs do MEC1100. Neste exemplo, recomendamos a utilização de um servomotor, pois os valores necessários como parâmetros já foram apresentados no início deste exemplo. Caso deseje, pode-se utilizar qualquer outro componente que interaja com um sinal PWM, desde que seja conhecido seus valores de período e ciclo ativo em milissegundos. Para testar o programa vamos no menu Run Run ou pressionamos F9. Se não houver nenhum erro o programa será compilado e executado. Com um MEC1100 conectado em alguma porta serial podemos testar se o programa está funcionando. Selecione a porta USB correta, selecione um PWM que está conectado e pressione o botão Ligar. O motor deverá se posicionar de acordo com os valores selecionados nos TScrollBars de ajuste de período e ciclo ativo. Teste 24

algumas vezes com valores diferentes. Pronto, temos um programa que controla os PWMs e ajusta os seus parâmetros em milissegundos. Sua aparência final ficou assim. Figura 26: Programa finalizado. Podemos selecionar nessa interface o pino de PWM que vamos controlar e definir os parâmetros para seu funcionamento. Em seguida é preciso apenas pressionar o botão Ligar e o PWM se ajustará aos parâmetros passados. Para desligar o PWM, basta pressionar o botão Desligar. Na figura anterior, o PWM do pino 1 está configurado para posicionar o eixo de um servomotor na posição central. Neste caso, será necessário ligar o cabo de conexão do servomotor no pino 1 da porta Servomotores/PWM. Variando o ciclo ativo é possível mudar a posição eixo do servo. Exemplo 3: PwmOnFreq A porta PWM também permite controle de componentes através do envio de uma frequência, que nada mais é que a quantidade de ciclos repetidos por segundo. Com isso, é possível ajustar o ciclo ativo através da taxa de porcentagem da duração do sinal. Por exemplo, uma frequência de 5 Hz, quer dizer que o período se repetirá 5 vezes por segundo, durando 200 ms cada. Além disso, se definirmos a taxa de ciclo ativo em 30, por exemplo, dizemos que a duração será de 30% do tempo do período, ou seja, 30% de 200 ms, o que dá uma duração de 60 ms. Caso seja variado para 80%, terá uma duração de 160 ms. Nossa próxima etapa será criar um programa que envie um sinal PWM ajustando apenas a frequência de períodos e a taxa de duração do ciclo ativo. Este programa irá controlar um LED, fazendo-o acender e apagar em uma determinada frequência e podendo ajustar o tempo que ficara aceso a cada piscada. Ao final, nosso programa terá a seguinte interface: 25

Figura 27: Aparência final do programa que controla PWMs ajustando a frequência e a taxa de ciclo ativo O primeiro passo do programa será criar a interface gráfica. Vamos utilizar o projeto criado no tutorial Base que já nos fornece algumas funcionalidades interessantes. Para isso copiamos o projeto daquele tutorial e em cima dele vamos adicionar alguns componentes gráficos extras. Nossa interface possui cinco componentes do tipo TLabel que são utilizados para identificação das configurações e exibição dos valores escolhidos. Outro componente é um TComboBox que é utilizado para selecionar o PWM que queremos controlar. Existe também dois TScrollBar para ajustar os parâmetros, um TCheckBox para inverter a polaridade do sinal e por fim dois botões utilizados para ligar e desligar o PWM selecionado. Todos esses componentes encontram-se na aba Standard da barra de componentes. Figura 28: Aba "Standard" da Barra de componente. Vamos adicionar os cinco TLabel e um TComboBox para a seleção do PWM que queremos controlar. O componente TLabel possui o seguinte ícone. Figura 29: Ícone do componente TLabel. E o componente TComboBox possui o seguinte ícone. 26

Figura 30: Ícone do componente TComboBox. Após adicionar os cinco TLabel, modifique as seguintes propriedades. Caso tenha dúvidas sobre os posicionamentos, consulte a imagem com a janela do programa já com os componentes posicionados, na figura 30. Name = LabelFrequencia Caption = Frequência: Font/Style/fsBold = true Name = LabelCicloAtivo Caption = Taxa de Ciclo Ativo: Font/Style/fsBold = true Name = LabelFrequenciaHz Caption = 0 Hz Name = LabelCicloAtivoPorc Caption = 0 % Name = LabelPWM Caption = PWM: Font/Style/fsBold = true Em seguida, selecione o componente TComboBox e modifique as propriedades a seguir. Name = ComboBoxPwm Style = csdropdownlist Items.Strings = 1, 2, 3, 4, 5, 6, 7, 8 (um abaixo do outro, sem as virgulas) ItemIndex = 0 Com isso nosso Form irá se parecer com o seguinte. 27

Figura 31: Programa parcialmente feito. Agora vamos inserir os componentes para ajuste do sinal do PWM. Aqui vamos utilizar dois componente TScrollBar. O componente TScrollBar encontra-se na aba Standard da barra de componentes e possui o seguinte ícone. Figura 32: Ícone do componente TScrollBar. Adicionamos os componentes e modificamos as seguintes propriedades do TScrollBar. Name = ScrollBarFrequencia Max = 5530000 Position = 0 Name = ScrollBarTaxa Max = 100 Position = 0 Criamos agora uma caixa de verificação, utilizando o componente TCheckBox. Este componente se encontra na aba Standard, e tem o seguinte ícone: 28

Figura 33: Ícone do componente TCheckBox. Após adicionar o componente ao formulário, altere as propriedades: Name = CheckBoxPolaridade Caption = Inverter Polaridade Nesse ponto só nos falta adicionar os dois botões para ligar e desligar o PWM. Para isso adicionamos dois componentes TButton que podem ser encontrados na aba Standard da barra de componentes. Esse componente possui o seguinte ícone. Figura 34: Ícone do componente TButton. motor. Temos que modificar as seguintes propriedades dos botões. Primeiro do botão para ligar o Name = ButtonLigar Caption = Ligar Em seguida as propriedades do botão para desligar o motor. Name = ButtonDesligar Caption = Desligar Um último detalhe que vamos modificar é a propriedade Caption do Form principal. Como copiamos o projeto do tutorial Base, essa propriedade possui o valor Projeto Base. Vamos modificar essa propriedade para PWMs: Ajuste pela Frequência. Com isso finalizamos a construção de nossa interface gráfica. A seguir a imagem dessa interface finalizada. 29

Figura 35: Interface finalizada. O próximo passo é implementar o código para controle dos PWMs. Para isso precisamos criar um manipulador para o evento OnClick do botão Ligar e um para o botão Desligar. Vamos criar primeiro o manipulador do botão que liga os motores. Para fazer isso podemos selecionar o componente TButton que possui o texto Ligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha em que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. Procedure TFormMain.ButtonLigarClick(Sender:TObject); Dentro desse manipulador vamos implementar o código que liga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOnFreq. Esse método possui a seguinte declaração. Procedure PwmOnFreq(pwm : Byte; frequency : Real; duty_cycle : Real; polarity : Byte); Esse método possui quatro parâmetros, o primeiro indicando o PWM que será ligado, o segundo informando um valor da frequência de cada sinal em Hz, o terceiro um valor para a duração de sinal de Ciclo Ativo em porcentagem e o quarto para definir a polaridade do sinal do PWM. O MEC1100 suporta até 8 PWMs, logo o primeiro parâmetro pode variar de 1 a 8. O parâmetro de período pode variar de 0 a 5530000 para os pinos 1 a 3 e 0 a 8000 para os pinos de 4 a 30

8 e a polaridade aceita 0 para negativo e 1 para positivo. Agora vamos implementar o código para acionar os PWMs. A seguir o código do manipulador do botão Ligar. Procedure TFormMain.ButtonLigarClick(Sender: TObject); // Liga e ajusta os parâmetros do PWM mec.pwmonfreq(strtoint(comboboxpwm.text), ScrollBarFrequencia.Position, ScrollBarTaxa.Position, strtoint(booltostr(not(checkboxpolaridade.checked)))); Como podemos observar, é muito simples ligar um PWM. Foi necessário apenas chamar o método PwmOnFreq com os parâmetros que obtivemos dos componentes TComboBox e TScrollBar. O item do TComboBox foi adicionado na ordem de modo que o valor dentro desse componente equivale ao parâmetro que deve ser passado ao método PwmOnTime para indicar o PWM que ele corresponde. Dessa forma é necessário apenas saber o número do PWM selecionado no TComboBox e passar esse como parâmetro. O parâmetro da frequência será o valor da propriedade Position do TScrollBar. Ele estará na faixa de 0 a 5530000 (clock máximo suportado pelo MEC1100) porque definimos a propriedade Max, que define o valor máximo de retorno da posição desse componente. Só que existe um porém: esse valor só é válido caso o pino de PWM escolhido seja 1, 2 ou 3. Nos demais pinos (4, 5, 6, 7 e 8), esse valor deve ser entre 0 e 8000, pois estes pinos possuem comportamento diferente. Visto estas diferenças, será necessário implementar um código que altere automaticamente o valor máximo dos componentes conforme a porta escolhida. Este código será implementado ainda neste tutorial. Por padrão o valor mínimo já é 0. A taxa de duração do Ciclo Ativo varia de 0 a 100, pois é uma porcentagem. Vamos fazer a definição do valor máximo dos TScrollBars. Para fazer isso, podemos selecionar o componente TComboBox que possui os valores dos PWMs, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o componente no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. procedure TFormMain.ComboBoxPWMChange(Sender: TObject); Dentro desse manipulador vamos implementar o código que ajusta o valor máximo dos TScrollBar. A seguir o código do manipulador: 31

procedure TFormMain.ComboBoxPWMChange(Sender: TObject); // Verifica o PWM selecionado através do indice do // ComboBoxPWM (vai de 0 a 7) if (ComboBoxPWM.ItemIndex <= 2) then // Define o valor maximo do scrollbar para os // indices menores ou igual a 2 (0, 1 e 2) ScrollBarFrequencia.Max:=5530000; end else // Define o valor maximo do scrollbar // para os indices para os demais ScrollBarFrequencia.Max:=8000; A partir deste momento, ao selecionar o número do PWM no TComboBox automaticamente o valor máximo do componente ScrollBarFrequencia serão alterados de acordo com o PWM escolhido. O índice varia de 0 a 7, conforme a posição dentro do TComboBox, por isso a comparação <= 2 pois o primeiro valor recebe o índice 1. Vamos criar agora o manipulador do botão que desliga o PWM. Para fazer isso podemos selecionar o componente TButton que possui o texto Desligar, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. Procedure TFormMain.ButtonDesligarClick(Sender:TObject); Dentro desse manipulador vamos implementar o código que desliga o PWM. O método que vamos utilizar para ligar os PWMs é o PwmOff. Esse método possui a seguinte declaração. Procedure PwmOff(pwm : Byte); Esse método possui um parâmetro indicando o PWM que será desligado. 32

Agora vamos implementar o código para desligar os PWMs. A seguir o código do manipulador do botão Desligar. Procedure TFormMain.ButtonDesligarClick(Sender: TObject); // Desliga o PWM mec.pwmoff(strtoint(comboboxpwm.text)); Também é possível e muito útil definir que, conforme se escolhe os valores na barra de rolagem, eles apareçam em um TLabel, facilitando a escolha do valor. Para isso, clique duas vezes sobre o ScrollBarFrequencia e implemente o seguinte código: procedure TFormMain.ScrollBarFrequenciaChange(Sender: TObject); // Exibir o valor na Label LabelFrequenciaHz.Caption:= inttostr(scrollbarfrequencia.position) + ' Hz'; Logo após, clique duas vezes sobre o componente ScrollBarTaxa e implemente o código: procedure TFormMain.ScrollBarTaxaChange(Sender: TObject); // Exibir o valor na Label LabelCicloAtivoPorc.Caption:= inttostr(scrollbartaxa.position) + ' %'; Além disso, podemos fazer com que o botão Ligar e Desligar seja ativado de acordo com o estado da conexão com o MEC1100. Para essa finalidade, podemos utilizar o componente TTimer, o qual já foi adicionado anteriormente no Projeto Base. Esse componente pode ser configurado para executar um método em intervalos pré-determinados. No nosso Projeto Base, ele foi configurado para verificar continuamente a presença de um MEC1100 conectado à porta USB. Dê um duplo clique sobre ele, para exibir o código que foi criado anteriormente. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo 33

if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; end... // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; Devemos então configurar o TTimer de modo que ele faça a verificação constantemente. A seguir, o código com a função adicionada. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; ButtonLerClick(Sender); // Ativa os botoes Ligar e Desligar ButtonLigar.Enabled := true; ButtonDesligar.Enabled := true; end else // Apaga LED. Muda cor de fundo do Shape 34

ShapeLED.Brush.Color := clgreen; // Muda texto para indicar erro de conexão LabelConnected.Caption := 'Desconectado'; // Muda cor do texto para vermelho LabelConnected.Font.Color := clred; // Desativa os botoes Ligar e Desligar ButtonLigar.Enabled := false; ButtonDesligar.Enabled := false; Com isso, se os PWMs já estiverem conectados, podemos fazer um teste de controle dos PWMs do MEC1100. Neste exemplo, recomendamos a utilização de um LED. Caso deseje, pode-se utilizar qualquer outro componente que interaja com um sinal PWM. Para testar o programa vamos no menu Run Run ou pressionamos F9. Se não houver nenhum erro o programa será compilado e executado. Com um MEC1100 conectado em alguma porta USB podemos testar se o programa está funcionando. Selecione a porta USB correta, selecione um PWM que está conectado e pressione o botão Ligar. O LED deverá piscar de acordo com os valores selecionados nos TScrollBars de ajuste de frequência e taxa de ciclo ativo. Teste algumas vezes com valores diferentes. Pronto, temos um programa que controla os PWMs e ajusta os seus parâmetros em uma determinada frequência. Sua aparência final ficou assim. Figura 36: Programa em execução. 35

Podemos selecionar nessa interface o pino de PWM que vamos controlar e definir os parâmetros para seu funcionamento. Em seguida é preciso apenas pressionar o botão Ligar e o PWM se ajustará aos parâmetros passados. Para desligar o PWM, basta pressionar o botão Desligar. Na figura anterior, o PWM do pino 8 está configurado para fazer um LED piscar 2 vezes por segundo (ou a cada 500 ms), com duração de 50% do tempo aceso (250 ms). Neste caso, será necessário ligar o cabo de conexão do LED no pino 8 da porta Servomores/PWM. Exemplo 3.1: Utilizando o PwmOnFreq como Gerador de Clock Um gerador de clock é um recurso utilizado para sincronizar dispositivos em uma mesma frequência. A cada ciclo de clock, os dispositivos controlados por ele realizam uma operação. Frequência é a quantidade de vezes que se realiza alguma coisa, no caso de um gerador de clock, é a quantidade de períodos (ondas) emitidos em 1 segundo, que é medido em Hertz (Hz). Um processador de 2 GHz é capaz de trabalhar a uma frequência de 2.000.000.000 Hz, ou seja 2.000.000.000 de sinais repetidos por segundo. Como vimos no tópico anterior, a porta PWM é capaz de emitir uma frequência, controlando a duração do ciclo ativo (tempo em que o sinal fica em 1, para cima ). Neste exemplo, vamos modificar o último programa para emitir um sinal de clock de frequência variável, mas com taxa de ciclo ativo fixo em 50%. A próxima figura exibe um exemplo de formato de onda emitido por um Gerador de Clock: Figura 37: Sinal de clock: 4 Períodos, totalizando 4 Hz. Vamos às alterações em nosso programa. Acrescente um componente Tbutton, da aba Stardard no formulário. Em seguida as propriedades do botão: Name = ButtonGerador Caption = Gerador de Clock O formulário deverá ficar como o da figura a seguir: 36

Figura 38: Formulário com o novo botão. Vamos criar o manipulador do botão que ativa o Gerador de Clock. Para fazer isso podemos selecionar o componente TButton que possui o texto Gerador de Clock, ir no Object Inspector, selecionar a aba Events e dar um duplo clique sobre a linha que está escrito OnClick. Uma forma mais fácil de fazer isso é apenas dar um duplo clique sobre o botão no Form e com isso o Delphi irá criar automaticamente um manipulador para o evento OnClick. O seguinte código será criado. procedure TFormMain.ButtonGeradorClick(Sender: TObject); Agora vamos implementar o código para acionar os PWMs. A seguir o código do manipulador do botão Gerador. Procedure TFormMain.ButtonGeradorClick(Sender: TObject); // Ajustar a taxa para 50% ScrollBarTaxa.Position := 50; // Liga e ajusta os parâmetros do PWM como Gerador mec.pwmonfreq(strtoint(comboboxpwm.text), ScrollBarFrequencia.Position, 37

ScrollBarTaxa.Position, strtoint(booltostr(not(checkboxpolaridade.checked)))); Além disso, podemos fazer com que o botão Gerador de Clock seja ativado de acordo com o estado da conexão com o MEC1100. Para essa finalidade, podemos utilizar o componente TTimer, o qual já foi adicionado anteriormente no Projeto Base. Esse componente pode ser configurado para executar um método em intervalos pré-determinados. No nosso Projeto Base, ele foi configurado para verificar continuamente a presença de um MEC1100 conectado à porta USB. Dê um duplo clique sobre ele, para exibir o código que foi criado anteriormente. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão LabelConnected.Caption := 'Conectado'; end... // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; Devemos então configurar o TTimer de modo que ele faça a verificação constantemente. A seguir, o código com a função adicionada. procedure TFormMain.TimerCheckTimer(Sender: TObject); // Verifica se há um MEC1100 respondendo if (mec.isconnected) then // Acende LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := cllime; // Muda texto para indicar conexão 38

LabelConnected.Caption := 'Conectado'; // Muda cor do texto para verde LabelConnected.Font.Color := clgreen; ButtonLerClick(Sender); // Ativa os botoes Ligar, Desligar e Gerador ButtonLigar.Enabled := true; ButtonDesligar.Enabled := true; ButtonGerador.Enabled := true; end else // Apaga LED. Muda cor de fundo do Shape ShapeLED.Brush.Color := clgreen; // Muda texto para indicar erro de conexão LabelConnected.Caption := 'Desconectado'; // Muda cor do texto para vermelho LabelConnected.Font.Color := clred; // Desativa os botoes Ligar, Desligar e Gerador ButtonLigar.Enabled := false; ButtonDesligar.Enabled := false; ButtonGerador.Enabled := false; Com isso, já teremos um Gerador de Clock. Neste exemplo, recomendamos a utilização de um LED. Caso deseje, pode-se utilizar qualquer outro componente que interaja com um sinal de clock, desde que seja conhecido suas especificações adequadas. Para testar o programa vamos no menu Run Run ou pressionamos F9. Se não houver nenhum erro o programa será compilado e executado. Com um MEC1100 conectado em alguma porta USB podemos testar se o programa está funcionando. Selecione a porta USB correta, selecione a saída PWM que está conectado o dispositivo que receberá o sinal e pressione o botão Gerador de Clock. O LED deverá piscar de acordo com a frequência selecionada no TScrollBar de ajuste de frequência. A taxa de ciclo ativo automaticamente posicionará em 50%. Teste algumas vezes com valores diferentes para frequência. Quanto maior o valor da frequência, mais vezes o 39

LED piscará por segundo, até tornar-se imperceptível ao olho humano. Pronto, temos um programa que gera um clock em qualquer frequência. 5 Conclusão Nesse tutorial vimos como controlar os PWMs no MEC1100. Com o projeto que criamos foi possível entender o funcionamento do método PwmOn, PwmOnTime, PwmOnFreq e PwmOff além do significado de seus parâmetros. Vimos também o que deve ser feito para ligar um PWM à porta de controle do MEC1100. Com isso já é possível explorar ao máximo tudo que o PWM pode oferecer. 40