Professional Documents
Culture Documents
PROBLEMA 3: HARDWARE-IN-THE-LOOP
(HIL) COM O ATMEGA328P
SALVADOR - 2018
UNIVERSIDADE FEDERAL DA BAHIA
ENGENHARIA ELÉTRICA – SISTEMAS
MICROPROCESSADOS
SALVADOR - 2018
1. Introdução
O problema abordado baseia-se em criar um controlador, implementa-lo
no arduino sem o uso de sketches e comunica-lo via serial com o software
Matlab.
Este trabalho foi dividido em cinco seções, contendo Introdução, Objetivo,
Metodologia, Códigos e Conclusão. A seção 3 foi subdividida em cinco
etapas, que são referentes ao passo-a-passo da metodologia utilizada na
execução do projeto. Por sua vez, a seção 4 foi subdividida em duas,
contendo os códigos do arduino e do matlab.
2. Objetivo
Implementar um controlador no ATmega328p para interagir com uma
planta simulada através do ferramental disponível no software
Matlab/Simulink.
3. Metodologia
3.1. Softwares necessários
Alguns dos nossos integrantes da equipe já trabalharam com Arduino e
Matlab, usando o IDE do Arduino. Então descobrimos primeiro como
programar o Arduino em C usando o Atmel Studio. A primeira dificuldade foi
passar o código para o Arduino, sendo necessário fazer o download do
compilador AVRdude que é um utilitário que serve para manipular a memória
dos microcontroladores AVR. Com o programa instalador e usado como
ferramenta externa no Atmel Studio, foi possível escrever e reescrever
códigos no Arduino usando USB, sem a necessidade de uma placa
programadora.
O Matlab foi utilizado para pegar os dados enviados pelo Arduino na porta
serial, e aplicar na planta e retornar para o arduino o valor da planta em
100ms para que o controlador possa atuar novamente.
3.5. Teste
Foi configurado no matlab para que o nível da água inicie em 0m de altura,
e no Arduino inicie com o setpoint de 15 m. O arduino recebe do matlab o
valor do nível atual e calcula o erro entre o valor desejado e a altura atual do
nível da água, e multiplica essa diferença para o valor Kp (ganho
proporcional), do PID. Como foi escolhido o controlador mais simples, os
ganhos Ki e Kd são zeros. Por simplicidade, o valor de Kp é 1.
O Arduino, após o cálculo do valor a ser corrigido, envia o valor para o
Matlab, que coleta o dado e simula como a planta irá atuar com aquele sinal
durante 100ms. O valor da planta após 100ms é retornado para o Arduino,
que recebe o novo nível da água para calcular o novo erro e com isso aplicar
um sinal maior ou menor, dependendo do erro.
Depois de 10 segundo, o setpoint muda de 15m para a metade. E depois
de mais 10 segundo, o setpoint reduz novamente pela metade. A simulação
acontece durante como é possível visualizar no gráfico:
4. Códigos
4.1. Código Arduino (atmel studio)
/*
* HIL.c
*
* Created: 7/17/2018 10:43:03 AM
* Author : Ruffeny
*/
#include <stdlib.h>
#include <string.h>
#include <avr/io.h>
#include <util/delay.h>
/*******************************************************************
* constants & helper macros *
*******************************************************************/
/*******************************************************************
* variables *
*******************************************************************/
int error;
int p;
float kp=1;
/*******************************************************************
* functions *
*******************************************************************/
while (1)
{
ch = usart_GetSer();
/*******************************************************************
* main setup *
*******************************************************************/
int main (void) //
{ UBRR0H = (_UBRR) >> 8; // setup USART port
UBRR0L = (_UBRR); // "
//UCSR0B |= _BV(TXEN0); // "
//UCSR0B |= _BV(RXEN0); // "
//sbi(UCSR0B, TXEN0); // "
//sbi(UCSR0B, RXEN0); // "
UCSR0B |= 1<<TXEN0 | 1<<RXEN0; // "
/*******************************************************************
* main loop *
*******************************************************************/
while(1) //
{
uart_GetStr(input);
decimal = atof(input);
error = setpoint - decimal;
p = kp*error;
sprintf(teste,"%i",p);
usart_PutStr(teste);
usart_PutStr("\n");
t=t+1;
if (t==100){
setpoint = setpoint/2;
t=1;
}
} //
}
s = tf('s');
g = serial('COM9'); % atribui o objeto à porta serial
FT = 1/(s+5);
sistema = c2d(FT,1/100);
a = fgetl(g);
y(t) = str2double(a); %valor do controlador
x = y(t)*step(FT)+ultimovalor(t); %simulacao da
planta com a nova entrada
a = 0;
t=t+1;
ultimovalor(t+1) = x(12); %valor do sistema depois
depois de 100ms;
tempo(t) = t*0.1;
tempo(t+1) = (t+1)*0.1;
%fprintf(s,'%s',numero);
% a = fgetl(s);
% y(t) = str2double(s);
% ;
% a=0;%limpa buffer;
% pause(1);%pausa 1 segundo;
%end
fclose(g);
5. Conclusão
Através deste projeto, pudemos colocar em prática o nosso conhecimento
acerca de comunicação serial usando o protocolo USART.
Foi possível, mesmo sem o uso da IDE, programar o arduino usando a
linguagem C e obtivemos um resultado satisfatório com a comunicação entre
os softwares utilizados.
Conseguimos controlar uma planta virtual através de um controlador real,
sendo assim não houve a necessidade de um sistema físico para testar o
controlador, concluindo com êxito o objetivo do projeto.