cocian@ulbra.edu.

br

• Introdução
O controle PI ou PID são utilizados para monitorar e controlar saída de um sistema comparando esta com sua
entrada, definindo o erro e deste erro calculando PI ou PID para controlar o nível de correção e a velocidade de
correção para que a saída se aproxime o máximos do valor definido na entrada.

O objetivo desse trabalho foi desenvolver em C++ um software supervisório é de simular este controle e
gerenciar as informações que deve enviar ao Arduino e interpretar as informações recebidas dele, o software
desenvolvido possibilita que o usuário defina o valor de RPM desejado, sistema é convertido este valor para uma
valor entra 0 e 255, valor esse necessário para a saída PWM do Arduino, após receber esta informação o Arduino
transfere esse valor para saída PWM, pino 9 o qual esta conectado ao base do TIP122 controlando o fluxo de
corrente do mesmo para controle do motor que esta conectado ao coletor do TIP e o emissor conectado ao terra,
enquanto os led’d infravermelho efetuam a contagem de RPM (Saída) gerador por esse motor, enviando esta
informação para ser tratada no software e comparada com o SetPoint (Entrada) e desta diferença definindo o erro do
sistema, erro este que será utilizado com os valores definidos pelo usuário de KP e KI para definir a correção do
valor a ser enviado novamente para o Arduino, após o calculo de PI ele acresenta ou diminui este valor do antigo
valor de entrada para o sistema fazer a correção de RPM.
O programa desenvolvido consiste em uma tela principal, onde o usuário pode conectar a porta Com3, neste
momento esta habilitado a enviar valores para o SetPoint,nesta tela temos também botões para salvar e abrir
arquivos, um espaço para editar informações e visualizar os valores de RPM encontrados durante o ultimo ensaio,
também temos um gráfico que mostra duas linhas que representão SetPont e valor real de RPM e uma tela acima que
pode ser visualida qual foram os valores de KP e KI definidos na segunda tela.

Fig. 1 – Diagrama de blocos para o programa “Controle PID”

Na segunda tela temos opições para alterar os valores de KP e KI que já vêm predefinidos que são 1,0 para KP e
0,0 para KI, nesta tela será possível vusializar dois campos que são onde devem escraver os valor desejados e no
final temois um botão escrito SetPoint que envia estes valores para a formula de PI e também fecha a tela.
 Descrição das Classes

Para o software em desenvolvimento nesse trabalho, são criadas quatro classes: “TForm1”, “TForm2”, “TPID”,
“TComPort”. A primeira e a segunda são referente as telas do programa, a terceira se refere a classe TPID emde é
realizado os cálculos de controle do Software e a ultima se refere a parte do programa da comunicação entre PC e
hardware, esta foi criada com auxilio de um item da biblioteca do Builder C++, denominada de ComPort1.

• Classe “TForm1”
A classe “TForm1”, derivada da classe “TForm” da VCL, é a classe que gera a tela inicial “Principal” do
programa. A próxima figura mostra a representação visual UML dessa classe. Os códigos de programa, “Unit1.h” e
“Unit1.cpp” relacionados a essa classe, estão listados nos apêndices II e III respectivamente.

Fig. 2 – Representação visual UML da classe “Unit1”

• Descrição das variáveis da classe “Unit1”:

TPID prop;
int SetPoint;
static double memoria[1000];
static int C = 0;
float ValorPWM,ST, RPM;
int RPMpassada;
int RPMatual;
float kP = 1.0;
float kI = 0;
float kD = 0;
float erro, ResultadoPID, PID;
FILE * arq;
int compare = 0;
float RPMatualvezes;
float RPMatualdividido;
float RPManterior;
• TPID prop – método utilizado para chamar a classe para calculo de PID;
• memoria[1000] – ponteiro para 1000 valores de RPM recolhidos;
• ValorPWM – valor de SetPoint transformadp para valor que o arduino ronheceria de 0 a 255;
• C – para contar posição onde deve ser alocado valor de RPM na memoria[1000];
• * arq – ponteiro para o arquivo *.txt para carregar e salvar os dados de RPM lidos diretamente do
• kP, kI, kD – setado valores de paremetros para o calculo de PID;

• Descrição dos eventos da classe “Unit1”:

• Botton1::OnClick – Mostra tela para comunicar com a porta Com3;
• Botton2::OnClick – desconecta a ComPort;
• Botton3::OnClick – Realiza o envio de dado do SetPoint para o timer para realizar o loop, caso o velor estaja
dentro dos limitas definidos;
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Fig. 3 – Fluxograma do evento “Botton3::OnClick”

• TForm1::ABRIR1Click - chama o OpenDialog1 para abrir um arquivo do tipo .txt ;

• TForm1::SALVAR1Click – chama o SaveDialog1 para salvar as alterações realizadas no Memo3 junto a os
dados do ultimo;
• TForm1::GRAFICO1Click – chama a tela 2, Form2;
•
•
•
Fig. 4– Fluxograma do evento “memoria[C]”

• Memoria[C] – atualiza as informações de valores PWM enviadas para o Arduino Fig. 4;

•
•
•
Fig. 5 – Fluxograma do evento “ TForm1::Button3Click”

• TForm1::Button3Click– O usuário digita um valor de Set Point e clica, o programa testa se o valor está entre os
limites pre definidos, se não apresenta uma mensagem de erro mostrando os limites corretos e se sim, faz um
calculo para transformar o Set Point em valor PWM e joga esse valor para o loop do timer;

•
•
•
•
•
•
•
•
•
•
•
•
•
•
• Fig. 6 – Fluxograma da rotina “Calculo PID”
• Calculo PID – Após o usuário digitar o valor de Set Point e ser testado como valido esse valor é transferido para
rotina timer, la antes de inicir o calculo temos um variável chamada de compare que tem como função limitar
o numero de valores transferidos para PWM, devido a resposta lenta do hardware não pode ser enviado um
valor para PWM a cada ciclo do timer, pois a velocidade ainda não sofreu a alteração do ultimo valor enviado
o que faz com que o sistema fique muito instável, atingindo zero de RPM e depois o máximo sem nunca
estabilizar, esta variável compare faz com o sistema envie uma informação fique recebendo o feedback no
mesmo ciclo mas só volte a calcular erro, PID e enviar os dados depois de 10 ciclos do timer, tempo
suficiente para o motor estabilizar, esta foi uma solução muito importante para estabilizar todo o sistema.
 • A cada comparação que o valor de compare é igual a 10 o controle realiza o calculo de erro que é a diferença
entre o Set Point e o valor de RPM atual, este erro é setado na variável e enviado para classe PID onde é
calculado o ganho necessário para o sistema com base nos valores de Kp e Ki digitados pelo usuário ou caso
o usuário não os defina são utilizado os valor pre estabelecidos que são kP = 1,0 e kI = 0,0 este valores podem
ser alterados a qualquer momento durante a execução do programa.
• Com o calculo realizado a classe devolve o valor denominado PID para rotina principal onde este valor é
somado levando em consideração o sinal ao valor de PWM já existente e jogando novamente na variável
ValorPWM esta informação é enviada pela porta Com3 para o Arduino onde é colocado este valor no pino 9
que está conectado ao transistor que controla a corrente do motor
•
•Fig. 7 – Fluxograma do evento “TForm2::Button1Click”

• Classe “TForm2”
A classe “TForm2”, derivada da classe “TForm” da VCL, é a classe que gera a tela de inserção dos valores de kP
e kI “Valores” do programa. A próxima figura mostra a representação visual UML dessa classe. Os códigos de
programa, “Unit2.h” e “Unit2.cpp” relacionados a essa classe, estão listados nos apêndices IV e V respectivamente.

Fig. 8 – Representação visual UML da classe “TForm2”

• Descrição das variáveis da classe “TForm2”:

• float kP e kI – Variaveis do tipo float para receber valores de kP e kI;
•
•
•
• Classe “TPID”
A classe “TPID”, é a classe onde ocorre os cálculos de PID utilizando as variáveis kP e kI informadas pelo usuário
relacionados a essa classe, estão listados nos apêndices VI e VII respectivamente.

Fig. 9 – Representação visual UML da classe “TPID”

• Descrição das variáveis da classe “TPID”:

• private: float P, error, I, D, kProp, kInt, kDer, PID, temp;– São variaveis privadas que só podem ser utilizadas
dentro do método PID que utiliza elas e joga para o timer uma variável public que pode ser utilizadas sem
restrição;
• public: float kP, kI, kD, e, Tempo; – Variaveis float public que podem ser utilizadas sem restrição.
As demais variáveis apresentadas na Fig. 9 são apresentadas “TPID”, o código será apresentado no apêndice VI
• .

• Descrição das Interfaces de Comunicação

A comunicação do software objeto desse trabalho com o hardare que nesse caso foi um kit microcontrolador
Arduino Mega, foi feira através da porta USB (Universal Serial Bus), endereço “COM3”. Caso ao conectar o Arduino
à USB do PC.
A leituras executadas pelo hardware são leituras analógica (0 a 255) para sinais de tensão de 0 a +5V (0 V 0 ; 5 V
255);
A informação enviada pelo hardware é composta por no máximo 5 caracter que software interpreta e converte em
inteiro.
 • Descrição das Interfaces Visuais
Neste item tesmos a descrição da telas de acesso do usuário.
Tela Principal, apresenta as teclas de conexão com a porta Com3, as teclas de acesso rápido para abrir e salvar
arquivo, espaço para o usuário escrever o SetPoint e o botão de enviar esta informação, espaço para comentários sobre
o ensaio e visualizar últimos valores lidos e gráfico de ação do sistema.

Fig. 10 – Interface visual “Principal”

Quando clicado na tela Principal o botão conectar abre esta janela chamada de Setup, para configurar a comunicação serial, deve-se
verificar a porta que esta conectada e e velocidade de comunicação que foi setada na lógica do Arduino, pois se ela for diferente não comunicará
corretamente.

Fig. 11 – Interface visual “Setup”

A segunda tela chamada valores que chamada na tela principal na aba SetPoint, tem os campos para escrever os valor de kP e kI e o
botão de SetPoint que envia estes valores para lógica.

Fig. 11 – Interface visual “Valores”

Na tela Principal temos o espaço para o usuário escrever o SetPoint, caso escreva ul valor fora dos limitas especificado no projeto e
clicar no enviar aparecerá uma janela de aviso que o valor esta incorreto e quais são os limites

Fig. 12 – Interface visual “Project1”

Na tela principal o usuário também tem a opção de alterar a cor do painel principal, somente necessário clicar em algum ponto da tela
que vai abrir a janela de seleção de cores onde somente necessário selecionar na cor desejada e clicar em ok.

Fig. 13 – Interface visual “Cor”

• Arquivos de Dados
O software em estudo salva dados em dois tipos de arquivo: *.txt.
No primeiro tipo de arquivo, do tipo *.txt, é gerado apenas um arquivo “arquivo” onde são salvos os dados dos
últimos ensaio realizado com o numero da amostra e o valor de RPM lido.

• Lista de Apêndices
• I – Descrição do Hardware;
• II – Listagem do Código “Unit1.h”;
• III – Listagem do Código “Unit1.cpp”;
• IV – Listagem do Código “Unit2.h”;
• V – Listagem do Código “Unit2.cpp”;
• VI – Listagem do Código “TPID.h”;
 • Considerações Finais e Conclusões
O presente trabalho foi um software supervisório para controle de RPM do motor com Arduino Mega, apresentou
facilidade na comunicação serial com um item da própria biblioteca, facilitando a configuração pois foi somente
incluir este item e fazer com que o botão chamado “conectar” ativa-se “ComPort1->Open();” abrira uma janela que só
é necessário definir a velocidade de comunicação e pronto.
Para o controle propriamente dito ouve dificuldade no momento da leitura dos valor pois o software estava lendo
em alguns casos mais ou até menos dígitos do que o valor real o alterava consideravelmente o resultado do calculo de
erro, acredito que o problema esta na velocidade de leitura em relação a velocidade de escrita do Arduino Mega na
porta Com3.
Uma melhoria que se tentou foi uma espécie de filtro para valores muito alto e valores muito baixos, mas não foi
implementado com sucesso, acrito que a implementação de forma adquada deste filtro traria um resultado muito bom
para o funcionamento do sistema como um todo.

Referências
1. Luis Fernando Espinosa Cocian, Engenharia de Processamento Digital II, Canoas: Ed. ULBRA, 2008, 276 p.
2. Luis Fernando Espinosa Cocian, Manual da Liguagem C, 1ª ed., Canoas: Ed. ULBRA, 2004, 500 p.
3. “C++ COMO UMA LINGUAGEM DE PROGRAMAÇÃO ORIENTADA A OBJETOS.” André Augusto Cesta.
4. Orientadora: Profa Dra Cecília Mary Fischer Rubira
5. Site: http://www.arduino.cc/en/reference/serial
6. Site: https://www.youtube.com/watch?v=BZZbGa9NXwo
7.

Sobre o Autor

Edison de Almeida Fernandes – graduando do

curso de Engenharia Elétrica da ULBRA –
Canoas. Alune de Engenharia de Processamento
Digital II, Programador do projeto em questão.

• Apêndice I – Descrição do Hardware

O hardware apresentado a seguir é um kit microcontrolador Arduino Mega. Para fazer o controle de corrente do
motor cc 5V e também fazer a contagem de RPM’s do motor através de um par de led’s ultravioletas.
A alimentação do motor se dá através de uma fonte externa de 5V e 0,55A, o positivo da fonte vai direto a o motor
e o negativo da fonte esta conectado ao emissor do transistor TIP122, conforme o valor de tensão da saída analógica
do Arduino (Pino 9) que esta ligado a base do TIP122 aumenta o transistor aumenta a circulação de corrente entre
coletor e emissor, coletor onde esta conectado o outro polo do motor.
O sinal de contagem do led ultravioleta esta conectado a entrada digital no pino 2 do Arduino, utilizando esta
informação para fazer a contagem de RPM

Fig. 1 – Microcontrolador Arduino Mega com Motor cc 5V e led’s ultravioleta

Fig. 2 – Fluxograma do software “Controle_do_Motor.ino”

A listagem do programa “Controle_do_Motor.ino”, instalado no microcontrolador é apresentada a seguir:

#define sensor 2 //Define sensor como 2
char buffer[18];
 int setpoint;
long rpmconta=0;

int TransistorPin = 9;

void setup()
{
Serial.begin(9600);
Serial.flush();
pinMode(TransistorPin, OUTPUT);
pinMode (sensor , INPUT);
}
void loop()
{
if (Serial.available() > 0) {
int index=0;
delay(100); // let the buffer fill up
int numChar = Serial.available();
if (numChar>15) {
numChar=15;
}
while (numChar--) {
buffer[index++] = Serial.read();
}
splitString(buffer);
}
rpmconta = 0; //Zera a variável que armazena a contagem de rotações
attachInterrupt(0, pegarpm, FALLING); //Habilita o pino 2(INT 0) para atender a
interrupção (pegarpm) por borda de descida (FALLING).
delay(250); //Aguarda 0,25 segundo
detachInterrupt(0); //Desabilita a interrupção
rpmconta = rpmconta * 8; //Multiplica a contagem por 8 para pegar o RPM
Serial.print(rpmconta, 5); //Imprime o valor de RPM na serial

}
void pegarpm()
{

rpmconta++; //Incrementa a contagem de rotações

void splitString(char* data) {

char* parameter;
parameter = strtok (data, " ,");
while (parameter != NULL) {
setLED(parameter);
parameter = strtok (NULL, " ,");
}

// Clear the text and serial buffers

for (int x=0; x<16; x++) {
 buffer[x]='\0';
}
Serial.flush();
}
void setLED(char* data) {
int Ans = strtol(data, NULL, 10);
Ans = constrain(Ans,0,255);
analogWrite(TransistorPin, Ans);
}

• Apêndice II – Listagem do Código “Unit1.h”

//---------------------------------------------------------------------------
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include "CPort.hpp"
#include <Chart.hpp>
#include <Series.hpp>
#include <TeEngine.hpp>
#include <TeeProcs.hpp>
#include <Menus.hpp>
#include <Buttons.hpp>
#include <Dialogs.hpp>
#include <ExtDlgs.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // IDE-managed Components
TGroupBox *GroupBox1;
TButton *Button1;
TButton *Button2;
TComPort *ComPort1;
TEdit *Edit1;
TMemo *Memo1;
TButton *Button3;
TChart *Chart1;
TFastLineSeries *Series1;
TTimer *Timer1;
TMainMenu *MainMenu1;
TMenuItem *PRINCIPAL1;
TMenuItem *GRAFICO1;
TMemo *Memo2;
TMenuItem *ABRIR1;
TMenuItem *SALVAR1;
TMenuItem *N1;
TMenuItem *FECHAR1;
 TSpeedButton *SpeedButton2;
TSpeedButton *SpeedButton3;
TColorDialog *ColorDialog1;
TOpenDialog *OpenDialog1;
TSaveDialog *SaveDialog1;
TOpenPictureDialog *OpenPictureDialog1;
TMemo *Memo3;
TFastLineSeries *Series2;
TLabel *Label6;
TEdit *Edit2;
TLabel *Label9;
TGroupBox *GroupBox2;
TGroupBox *GroupBox3;
TGroupBox *GroupBox4;
TLabel *Label1;
TLabel *Label2;
TLabel *Label3;
TLabel *Label7;
void __fastcall Button1Click(TObject *Sender);
void __fastcall Button2Click(TObject *Sender);
void __fastcall Timer1Timer(TObject *Sender);
void __fastcall GRAFICO1Click(TObject *Sender);
void __fastcall SpeedButton3Click(TObject *Sender);
void __fastcall SpeedButton2Click(TObject *Sender);
void __fastcall FormClick(TObject *Sender);
void __fastcall Button3Click(TObject *Sender);
void __fastcall SALVAR1Click(TObject *Sender);
void __fastcall ABRIR1Click(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm1(TComponent* Owner);
int i;
int y;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

• Apêndice III – Listagem do Código “Unit1.cpp”

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop
#include <stdio.h>
#include <time.h>
#include "TPID.h"
#include "Unit1.h"
#include <string>
#include "Unit2.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CPort"
#pragma resource "*.dfm"
TForm1 *Form1;
TPID prop;
int SetPoint;
static double memoria[1000];
static int C = 0;
float ValorPWM,ST, RPM;
int RPMpassada;
int RPMatual;
float kP = 1.0;
float kI = 0;
float kD = 0;
float erro, ResultadoPID, PID;
FILE * arq;
int compare = 0;
float RPMatualvezes, RPMatualdividido ,RPManterior;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
Memo1->Lines->Clear();
Memo2->Lines->Clear();
Memo3->Lines->Clear();

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

{
ComPort1->ShowSetupDialog();
ComPort1->Open();
Button1->Enabled=false;
Button2->Enabled=true;
Button3->Enabled=true;
Timer1->Enabled=true;
arq = fopen("arquivo.txt","w");
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
ComPort1->WriteStr(0);
Button1->Enabled=true;
Button2->Enabled=false;
Button3->Enabled=false;
Timer1->Enabled=false;
fclose(arq);
ComPort1->Close();

}
//-------------------------------------------------------------------------

void __fastcall TForm1::GRAFICO1Click(TObject *Sender)

{
Form2->Show();
}
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{

if (C > 1000){
C = 0;
}
C++;
ComPort1->WriteStr(ValorPWM);
AnsiString tempo;
kP = StrToFloat(Label1->Caption);
kI = StrToFloat(Label2->Caption);
clock_t start, end;
start = clock();
float acumulador;
AnsiString x;
static float Tempo;
ComPort1->ReadStr(x,5);
RPMatual = x.ToDouble();

RPMatualvezes = (RPMatual * 3);

RPMatualdividido = (RPMatual / 3);
if (RPMatual > RPMatualvezes){
RPMatual = RPManterior;
}
if (RPMatual < RPMatualdividido){
RPMatual = RPManterior;
}
RPManterior = RPMatual;
Memo1->Lines->Add( RPMatual );

if (compare == 10){
compare = 0;
erro = SetPoint - RPMatual;
//P
prop.constante2(kI);
prop.constante4(Tempo);
prop.constante1(kP);
prop.calculo1(erro);
ResultadoPID = prop.resultado1();
PID = ResultadoPID;

PID = ((50 * PID)/10000);

ValorPWM = ValorPWM + PID;

PID = 0;
if (ValorPWM < 0){
ValorPWM = 0;
}
}
compare++;
 ComPort1->WriteStr(ValorPWM);

memoria[C] = ValorPWM;

static int i = 0;
i++;
fprintf(arq, "%d\t%d\n", i, RPMatual);
Series1->AddXY(i, RPMatual, "", clTeeColor);
Series2->AddXY(i, Edit2->Text.ToDouble(), "", clTeeColor);
end = clock();
Tempo = 350 + end - start;
Memo2->Lines->Add(Tempo);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::SpeedButton3Click(TObject *Sender)

{
if(OpenDialog1->Execute())
Memo3->Lines->LoadFromFile(OpenDialog1->FileName);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::SpeedButton2Click(TObject *Sender)

{
if(SaveDialog1->Execute())
Memo3->Lines->SaveToFile(SaveDialog1->FileName);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormClick(TObject *Sender)

{
if(ColorDialog1->Execute())
Form1->Color = ColorDialog1->Color;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)

{

SetPoint=StrToFloat(Edit1->Text);

if(SetPoint< 0 || SetPoint > 10000)

{
ShowMessage(" Valor Inválido! Digite Valores entre 0 e 10000 RPM");
Edit1->SetFocus();
Edit1->SelectAll();
ValorPWM = 0;
}
else{
ValorPWM = ((28 * SetPoint)/20000);
Edit2->Text = (Edit1->Text);
 }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::SALVAR1Click(TObject *Sender)

{
if(SaveDialog1->Execute())
Memo3->Lines->SaveToFile(SaveDialog1->FileName);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ABRIR1Click(TObject *Sender)

{
if(OpenDialog1->Execute())
Memo3->Lines->LoadFromFile(OpenDialog1->FileName);
}
//---------------------------------------------------------------------------

• Apêndice IV – Listagem do Código “TForm2.h”

//---------------------------------------------------------------------------

#ifndef Unit2H
#define Unit2H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Chart.hpp>
#include <ExtCtrls.hpp>
#include <Series.hpp>
#include <TeEngine.hpp>
#include <TeeProcs.hpp>
#include "CPort.hpp"

//---------------------------------------------------------------------------
class TForm2 : public TForm
{
__published: // IDE-managed Components
TButton *Button1;
TEdit *Edit1;
TEdit *Edit2;
TLabel *Label1;
TLabel *Label2;
void __fastcall Button1Click(TObject *Sender);
void __fastcall Timer1Timer(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TForm2(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm2 *Form2;
//---------------------------------------------------------------------------
#endif

• Apêndice V – Listagem do Código “TForm2.cpp”

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
#include "TPID.h"
#include <string>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "CPort"
#pragma resource "*.dfm"
TForm2 *Form2;
float kP, kI, kD;
//---------------------------------------------------------------------------
__fastcall TForm2::TForm2(TComponent* Owner)
: TForm(Owner)
{

}
//---------------------------------------------------------------------------

void __fastcall TForm2::Button1Click(TObject *Sender)

{
kP=StrToFloat(Edit1->Text);
kI=StrToFloat(Edit2->Text);
Form1->Label1->Caption = Edit1->Text;
Form1->Label2->Caption = Edit2->Text;
Close();
}
//---------------------------------------------------------------------------

•
 •

• Apêndice VI – Listagem do Código “TPID.h”

class TPID {
private:
float P, error,I,D, kProp, kInt, kDer,PID,temp;

float AScaracteristica;
public:
void constante1 (float kP);
void constante2 (float kI);
void constante3 (float kD);
void constante4 (float Tempo);
float resultado1 (void);
void calculo1 (float e);

};

void TPID:: constante1 (float kP) {

kProp = kP;
}
void TPID:: constante2 (float kI) {
kInt = kI;
}
void TPID:: constante3 (float kD) {
kDer = kD;
}
void TPID:: constante4 (float Tempo) {
temp = Tempo;
}
float TPID:: resultado1 (void) {
return(PID);
}
void TPID:: calculo1 (float e) {
error = e;
I = I + (error * kInt) * (temp/1000);
P = error * kProp;
PID = P + I + D;
}