Escolar Documentos
Profissional Documentos
Cultura Documentos
ndice
1
Introduo................................................................................................................ 3
2.1
2.2
2.3
2.4
Alimentao..................................................................................................... 7
2.5
2.6
Parte mecnica................................................................................................ 8
3.2
3.3
4.2
4.3
4.4
4.5
4.6
Calibrao ..................................................................................................... 13
4.7
4.8
4.9
Concluses ............................................................................................................. 22
Perspectivas............................................................................................................ 23
Bibliografia ............................................................................................................ 24
Anexos .................................................................................................................... 25
8.1
8.2
Cdigo dos scripts do MatLab..................................................................... 34
8.2.1
Funo plota.m ....................................................................................... 34
8.2.2
Funo mapa_volume.m......................................................................... 35
8.3
8.4
8.5
Mapa de volume............................................................................................ 38
Introduo
Uma teconologia muito bem desenvolvida e amplamente utilizada nos dias
Fundamentos tericos
Este captulo discute os fundamentos de funcionamento dos vrios elementos
2.1
Bomba de combustvel
um componente indispensvel em veculos com motores de combusto
2.2
Bico injetor
Um bico injetor genrico composto por:
mola de retorno acoplada ao mbolo, faz com que a vlvula seja fechada.;
bocal pulveriza o combustvel.
Quando a bobina do solenide energizada, o mbolo da vlvula deslocado, de
modo que a mola de retorno contrada, o que abre a vlvula e permite que o
combustvel pressurizado chegue ao bocal. Esse bocal desenhado de modo a
pulverizar o combustvel no ar, o que facilita a queima do mesmo dentro dos cilindros
do motor. Quando a corrente que energiza o solenide cessa, a mola de retorno fecha o
bocal. A figura 2 mostra o bico injetor que foi utilizado nos testes ao longo do semestre,
e a figura 3 mostra um desenho esquemtico de um bico injetor genrico.
2.3
2.4
Alimentao
Os automveis, independente do seu porte, possuem uma bateria de 12 volts de
tenso, por isso que o sistema de injeo eletrnica de combustvel descrito nesse
relatrio utilizou como tenso de alimentao 12 volts. Tipicamente, em regime de
operao, a tenso da bateria de um veculo automotor varia na faixa de 10 a 14 volts:
esta variao influi diretamente na abertura do bico injetor, sendo um fator importante
que deve ser levado em considerao no clculo do tempo de abertura do mesmo.
2.5
Rede de comunicao
O protocolo de comunicao mais difundido na indstria automotiva o CAN
2.6
3.1
Parte mecnica
3.2
3.3
Atividades Desenvolvidas
Este captulo descreve as vrias melhorias implementadas no sistema de injeo
4.1
o circuito gravador de PIC. Este cabo era composto por dois conectores seriais machos e
os fios que, soldados aos conectores, estabeleciam a comunicao.
Como todos os grupos desenvolveram atividade semelhante, o cabo do sistema
de injeo eletrnica de combustvel foi marcado com a inscrio INJEO. Uma
10
4.2
ser testado. A placa de acionamento tambm precisava ser testada. Como o software do
semestre anterior no estava disponvel, um software de teste bastante simples foi
implementado: ele apenas acendia e apagava o LED da placa de acionamento.
O programa foi corretamente gravado no PIC, o que mostra que o gravador de
PIC e o cabo de comunicao serial estavam funcionando de maneira adequada, e o
programa foi corretamente executado na placa de acionamento, o que mostra que a
mesma no apresentava problemas.
Um detalhe notado nesse teste foi que a placa do circuito gravador de PIC
apresentava um pequeno defeito: o conector fmea onde o cabo de comunicao serial
era plugado se encontrava muito afastado para dentro em relao borda da placa, de
modo que um chanfro teve que ser feito na mesma para que os conectores pudessem ser
conectados adequadamente.
11
4.3
mesmo fosse transferido do computador para o PIC, era necessrio utilizar o circuito
gravador de PIC. Isso implicava em remover o PIC da placa de acionamento e coloc-lo
no circuito de gravao, para depois remov-lo do circuito de gravao e coloc-lo na
placa de acionamento, procedimento este muito delicado, uma vez que o PIC um
circuito integrado frgil que precisa ser manuseado com extremo cuidado, e que podia
levar a danos no PIC.
Para evitar esse risco potencial e o trabalho que o acompanhava, foi
desenvolvido um cabo que, ligado ao circuito gravador de PIC e placa de
acionamento, possibilitava a "gravao" do PIC com o mesmo ainda na placa de
acionamento.
Quando o cabo de comunicao estava devidamente soldado ao circuito de
gravao do PIC, um software de teste foi gravado ao PIC ainda na placa de
acionamento, para teste.
4.4
4.5
Ele estava ligado uma porta digital do PIC e um contato normalmente aberto. Para
que o boto funcionasse de maneira adequada, suas patas tiveram que ser ligadas
alimentao e ao ground de maneira adequada atravs de resistores.
Um software de teste foi desenvolvido e mostrou que o boto estava
adequadamente instalado no circuito, uma vez que ele se comportava da maneira
esperada
12
4.6
Calibrao
Aps o desenvolvimento do hardware, teve incio a fase de calibrao. A
inteno era apurar qual a quantidade de combustvel era injetada de acordo com um
tempo de abertura para uma determinada tenso de alimentao. O objetivo final destas
medies era levantar um mapa de injeo, onde teremos o tempo necessrio para
injetar determinado volume de combustvel em funo de tenso de alimentao do
circuito. O combustvel utilizado era gasolina automotiva.
Para que esta aferio fosse feita, um software foi desenvolvido, no qual um
tempo de abertura do bico injetor era determinado e o bico era acionado 500 vezes
enquanto o combustvel injetado era recolhido em um tubo de ensaio graduado, de
modo que o volume injetado em cada injeo pode ser estimado de maneira satisfatria.
Em um primeiro teste, a tenso de alimentao da bomba de combustvel foi
variada, mas a tenso de alimentao do circuito da placa de acionamento era mantida
constante em 12 volts. A incerteza das medies de 0,05 ml. Os resultados deste
teste esto dispostos na tabela 1.
Tempo de
10V
Abertura (ms)
11V
12V
13V
0,80
0,85
0,80
0,80
1,75
1,70
1,75
1,70
2,60
2,60
2,60
2,60
3,45
3,40
3,45
3,40
4,30
4,30
4,30
4,35
5,15
5,15
5,20
5,15
6,00
6,00
6,05
6,00
6,85
7,00
6,90
7,00
10
7,75
7,80
7,80
7,75
11
8,65
8,65
8,65
8,65
13
10V
Abertura (ms)
11V
12V
13V
14V
< 0,80
< 0,80
< 0,80
< 0,80
< 0,80
< 0,80
0,85
1,10
1,40
1,60
1,10
1,70
2,00
2,30
2,40
2,00
2,60
2,90
3,20
3,30
2,90
3,50
3,80
4,10
4,20
3,80
4,35
4,70
5,00
5,10
4,50
5,25
5,50
5,90
6,00
5,40
6,10
6,40
6,80
6,90
10
6,30
7,00
7,30
7,70
7,80
11
7,20
7,85
8,20
8,60
9,70
14
4.7
adequada, estes foram tratados no software MatLab em um script que plotava os dados
de maneira adequada.
15
16
4.8
Desenvolvimento do software
Com o mapa de calibrao pronto, o software do sistema de injeo eletrnica de
17
18
19
20
O formato das mensagens tratadas pelo PIC um quadro composto por 8 bytes
no formato:
struct frame
{
char comeo;
// 0x01
char id;
char comando;
char valor[4];
// 32 bits de dados
char crc;
// 0x02
} quadroRx;
4.9
software do sistema de injeo eletrnica pudesse ser testado, uma vez que a rede de
comunicao ainda no est operacional.
Esta alterao foi a adio de uma entrada serial fmea placa de acionamento,
de modo que a mesma pudesse ser ligada diretamente a um computador, de onde os
sinais da rede seriam emulados.
Como resultado dos testes, notamos que o software desenvolvido era grande
demais para a capacidade da memria RAM do PIC. Isso obrigou o software a ser
simplificado em alguns pontos.
21
Concluses
O trabalho descrito nesse relatrio foi extremamente valioso como experincia
22
Perspectivas
Como sugesto de futuros melhoramentos podemos citar vrios pontos.
O desenvolvimento mais urgente a ser feito o levantamento dos detalhes da
placa de acionamento. Agora que ela j conta com vrios tipos de componentes e
complicada, interessante poder contar com um desenho esquemtico do circuito, onde
qual componente est ligado a cada pata do PIC seja evidenciado de forma clara.
Outra possvel melhoria a otimizao do cdigo do software do sistema de
injeo eletrnica de combustvel. Como a memria do PIC no era suficiente para
comportar o programa que foi desenvolvido, este teve que ser simplificado. Com a
otimizao do cdigo, essas simplificaes, em especial na funo que interpola o mapa
de injeo poderiam ser eliminadas.
Uma possibilidade de melhoria futura a operao do sistema de injeo
eletrnica de maneira flexvel em combustvel. Essa alterao entretanto teria
conseqncias nos demais subsistemas do motor a exploso, de modo que ela deve ser
bem analisada antes de ser implementada.
Uma possibilidade iminente de melhoria a alimentao de cada cilindro do
motor atravs de vrios bicos injetores, e no apenas de um como feito atualmente.
Isso possibilitaria como vantagem melhor rendimento no consumo de combustvel.
23
Bibliografia
[1]
www.wikipedia.com
[2]
www.howstuffworks.com
[3]
www.microchip.com
[4]
www.ti.com
24
Anexos
8.1
Cdigo fonte
#include <16F877.h>
#include <MATH.h>
#include <stdlib.h>
#fuses HS,NOWDT,NOPROTECT,NOBROWNOUT,NOLVP
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
to 12
// Jumpers: 8 to 11, 7
#define TAMANHO_BUFFER 8
//metodos
int ler_tensao();
//le a tensao de alimentacao do circuito
float ler_mapa();
//le do mapa o tempo de injecao
void verifica_mensagem();
//trata mensagem recebida pela rede
void enviar_volume_injecao();
//envia pela rede o tempo de injecao
float interpola_tempo();
//faz a interpolacao do mapa de tempo de
injecao
float interpola_volume(); //faz a interpolacao do mapa de volume
void mostra_valores(); //mostra valores
//variaveis globais
struct quadroRx { // 8 bytes
//quadro de comunicacao serial
char comeco;
// 0x01
char id;
//
char comando; //
char valor[4]; // 32 bits de dados
char crc;
//crc de 8 bits, usa a funao do CRC.C no PICC
} quadro; //struct que recebe dados da rede
float CONST mapa_injecao[6][5] = {
{4.1215, 3.1787, 2.8945, 2.6112,
{5.0000, 4.3393, 4.0000, 3.6592,
{6.0928, 5.4372, 5.1116, 4.7791,
{7.2835, 6.5910, 6.2162, 5.8877,
{8.5833, 7.7194, 7.3728, 7.0000,
{9.6601, 8.8842, 8.5675, 8.1111,
};
// volume [ml] {2 4 6 8 10 12}
2.4473},
3.5251},
4.6720},
5.7768},
6.8890},
8.0000}
x tensao [V] {10 11 12 13 14}
//mapa de volume
float CONST mapa_volume[10] = {3.74, 4.2135, 4.6871, 4.9004, 5.1136,
5.2558, 5.4923, 5.6818, 5.9187, 6.0607}; // volume [ml]
// vetores com valores dos eixos do mapa de injecao
int CONST valores_volume[6] = {2, 4, 6, 8, 10, 12};
int CONST valores_tensao[5] = {10, 11, 12, 13, 14};
char buffer[TAMANHO_BUFFER] =
{NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
//buffer que armazena
dados recebidos pela rede
int tensao = 0;
//tensao de alimentacao do circuito
25
26
break;
}
}
/*
Quando o timer estoura entra na interrupcao:
realiza as contas para o calculo do tempo de injecao
*/
#INT_TIMER0
void timer_handler()
{
//o TIMER estoura em um tempo que depende da rotacao
//delay_ms(10000/rotacao);
output_high(PIN_C3);
delay_ms(tempo_injecao);
output_low(PIN_C3);
// ler tensao
tensao = ler_tensao();
tempo_injecao = ler_mapa();
// mostra os valores atuais
mostra_valores();
//delay_ms(300);
}
//-------------------------------------------------------------------void main() {
enable_interrupts(int_rda);
enable_interrupts(global);
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_256); //Define prescaler.
set_timer0(0); //Inicializa timer0 com 0
enable_interrupts(INT_TIMER0); //Habilita interrupes.
//inicializacao
setup_adc_ports( ALL_ANALOG );
setup_adc( ADC_CLOCK_INTERNAL );
set_adc_channel( 0 );
set_tris_b(0x00);
delay_us(10);
printf("\r\nPrograma iniciado\r\n\n");
//laco infinito
while(true){
//espera momento de iniciar injecao - interrupcao externa
while(input(PIN_B0)){
// ao soltar o botao ele entra no programa disparando o timer
if(!input(PIN_B0)){
//Inicializa timer0 com 0
set_timer0(0);
}
}
}
}
//-------------------------------------------------------------------/*
Funo para testes, que envia pela porta serial algum valor a ser
mostrado por exemplo no HiperTerminal do Windows (aba acessrios).
27
*/
void mostra_valores(){
// mostrando tensao
printf("\r\nTensao: %U [V]\r\n", tensao);
// mostra valor da variavel rotaqcao
printf("Rotacao: %lu [rpm]\r\n", rotacao);
// mostra valor da variavel borboleta
printf("Borboleta: %U [%%]\r\n", borboleta);
// mostra volume
printf("Volume: %f [ml]\r\n", volume);
// mostra tempo injecao
printf("Tempo de injecao: %f [ms]\r\n\n", tempo_injecao);
}
//-------------------------------------------------------------------/*
Este metodo atualiza a tensao de alimentacao do circuito em volts.
Ele le a tensao em uma das entradas analogicas do PIC, a qual esta
ligada a um divisor de tensao (razao de divisao 1/4), de modo que a
tensao medida eh um quarto da tensao de alimentacao do circuito.
Como a tensao maxima que a porta analogica considera eh 5 volts, a
alimentacao
do circuito nao pode exceder 20 volts.
possiveis valores retornados: de 0 a 20 volts.
*/
int ler_tensao()
{
int valor_adc = 0;
valor_adc = read_adc(); // 0 a 255
valor_adc = (valor_adc + 1)/12.8; // 0 a 20
return valor_adc;
}
//-------------------------------------------------------------------/*
Este metodo retorna o tempo de injecao de acordo com os valores das
variaveis TENSAO, ROTACAO e abertura da BORBOLETA.
*/
float ler_mapa()
{
//verifica se a rotacao e a posicao da borboleta ja foram
inicializadas
if ((rotacao == 0) || (borboleta == 0))
{
printf("rotacao ou borboleta errada\r\n");
return 0;
}
//transforma rotacao e posicao da borboleta em volume
volume = interpola_volume();
//depende da rotacao e da borboleta
//verifica se o volume esta dentro dos limites do mapa
if (volume > 8)
{
volume = 8;
}
28
if (volume < 2)
{
volume = 2;
}
//verifica se a tensao esta dentro dos limites do mapa
if (tensao > 14)
{
tensao = 14;
}
if (tensao < 10)
{
tensao = 10;
}
//le o mapa
tempo_injecao = interpola_tempo();
return tempo_injecao;
}
//-------------------------------------------------------------------/*
Este metodo analisa a consistencia das mensagens recebidas e extrai
delas as informacoes relevantes.
*/
void verifica_mensagem()
{
//analisa consistencia
//verifica byte de cabecalho
if (quadro.comeco != 'C')
{
printf("comeco errado\r\n");
return;
}
//verifica byte de id
if ((quadro.id != 'R') && (quadro.id != 'B') && (quadro.id != 'I'))
{
printf("ID errado\r\n");
return;
}
//verifica byte de comando
if ((quadro.comando != 'S') && (quadro.comando != 'L'))
{
printf("comando errado\r\n");
return;
}
//verifica CRC
if (quadro.crc != 'F')
{
printf("crc errado\r\n");
return;
}
//
printf("quadro OK\r\n");
//Se esta tudo OK, entao trata mensagem
if (quadro.comando == 'S') //ler conteudo da mensagem
{
29
//
//
//
}
if (quadro.comando == 'L') //responder essa mensagem
{
//
printf("quandro LOAD\r\n");
if (quadro.id == 'V')
{
//
printf("quadro injecao\r\n");
enviar_volume_injecao();
}
}
}
//-------------------------------------------------------------------/*
Este metodo envia para alguem pela rede o tempo de injecao.
Ele preenche a estrutura auxiliar ENVIAR e envia tudo pela rede.
*/
void enviar_volume_injecao()
{
long tempo;
// converte tempo
tempo = tempo_injecao*1000;
//cria quadro
quadro.comeco = 'C';
quadro.id = 'V';
//tempo de injecao
quadro.comando = 'S';
sprintf(quadro.valor, "%lu", rotacao);
quadro.crc = 'F';
//comando que envia os dados pela rede serial
printf("%c",quadro.comeco);
printf("%c", quadro.id);
printf("%c", quadro.comando);
printf("%c%c%c%c",
quadro.valor[0],quadro.valor[1],quadro.valor[2],quadro.valor[3]);
printf("%c", quadro.crc);
}
//--------------------------------------------------------------------
30
/*
Este metodo interpola qualquer valor de 0 a 100 de acordo com os
valores do
vetor mapa_volume.
Por exemplo, para o valor de abertura 8%, o metodo busca no vetor os
valores
dos pontos 5% e 10%, calcula a equacao da reta entre esses dois pontos
e
retorna o valor da reta para a posicao 8%.
Ele retorna os valores em microlitro (ul).
*/
float interpola_volume()
{
if(borboleta < 5)
{
aux1 = mapa_volume[1] - mapa_volume[0];
aux2 = aux1/5;
aux3 = borboleta*aux2;
aux1 = mapa_volume[0] + aux3;
return aux1;
//retorna valor interpolado
}
if((borboleta >= 5) && (borboleta < 10))
{
aux3 = (mapa_volume[2] - mapa_volume[1]) / 5;
reta: A*x+B
return mapa_volume[1] + (borboleta - 5)*aux3;
}
//fator A da
//B + A*x
31
{
aux3 = (mapa_volume[7] - mapa_volume[6]) / 15; //fator A da
reta: A*x+B
return mapa_volume[6] + (borboleta - 35)*aux3; //B + A*x
}
if((borboleta >= 50) && (borboleta < 75))
{
aux3 = (mapa_volume[8] - mapa_volume[7]) / 25; //fator A da
reta: A*x+B
return mapa_volume[7] + (borboleta - 50)*aux3; //B + A*x
}
if((borboleta >= 75) && (borboleta <= 100))
{
aux3 = (mapa_volume[9] - mapa_volume[8]) / 25; //fator A da
reta: A*x+B
return mapa_volume[8] + (borboleta - 75)*aux3; //B + A*x
}
}
//-------------------------------------------------------------------/*
INTERPOLACAO PELO METODO DO VIZINHO MAIS PROXIMO
*/
float interpola_tempo()
{
//ponto para calcular: mapa_injecao[volume][tensao]
// encontrar a menor distancia
float menor_valor = 10; // valor alto
int resultado[2] = {NULL, NULL};
int i,j;
for(i=0;i<=4;++i){
for(j=0;j<=5;++j){
// recupera um ponto da matriz do mapa de injecao
aux1 = valores_volume[j];
aux2 = valores_tensao[i];
// calcula a distancia entre o ponto que se deseja interpolar
e um ponto qualquer da matriz
aux3 = sqrt((aux1-volume)*(aux1-volume) + (aux2tensao)*(aux2-tensao));
//atualiza para menor valor: distancia
if(aux3 < menor_valor){
menor_valor = aux3;
// guarda o ponto mais proximo
resultado[0] = j;
resultado[1] = i;
}
//
printf("iteracao: %U %U | valores: %f %f %f %f | resultado:
%U %U\r\n", j,i,aux1,aux2,aux3,menor_valor,resultado[0],resultado[1]);
}
}
// temos a menor distancia do ponto de tensao e volume dado para um
// ponto mapeado: agora recuperamos o ponto referente a tal
distancia
return mapa_injecao[resultado[0]][resultado[1]];
}
//--------------------------------------------------------------------
32
//
C O M E N T A R I O S
/*
A variavel posicao determina a posicao do array buffer onde sera
gravado o proximo caracetere recebido pela rede, por isso essa
variavel eh incrementada a cada caractere recebido.
Como o buffer da rede um buffer circular, a variavel posicao eh
zerada quando o buffer esta cheio, ou seja, ela assume os valores
0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, ...
*/
/*
Quando o buffer fica cheio, significa que 8 bytes foram recebidos
pela rede, isto eh, um quadro de comunicacao inteiro (uma mensagem
inteira), de modo que quando isso acontece os dados recebidos devem
ser analisados pois eles podem conter informacao relevante para o
sistema de injecao eletronica de combustivel.
*/
/*
O mapa de injecao eh uma tabela do tipo [tensao(volts)] X [volume(ml)]
onde osvalores armazenados sao os tempos de injecao em milisegundos
para esses valores de tensao e de volume de combustivel.
float mapa_injecao[5][8];
mapa_injecao = [[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], [];
[], [], [], [], []];
*/
/*
struct { // 8 bytes
char comeco;
// 0x01
char id;
//
char comando; //
char valor[4]; // 32 bits de dados
char crc;
//crc de 8 bits, usa a funao do CRC.C no PICC
} quadroRx;
os possiveis valores dos campos sao:
comeco:
'C' - numero 1
id: id do
'R' 'B' 'I' 'V' -
conteudo da mensagem
rotacao
abertura da borboleta
tempo de injecao
volume de injecao
comando:
'S' - mensagem contem valor da variavel - ler esta mensagem (SAVE)
'L' - mensagem eh um pedido do valor da variavel - responder esta
mensagem (LOAD)
valor:
4 bytes de dados
33
crc:
'F' - numero 2
*/
/*
Como no mapa de volume que nos foi dado o volume a ser injetado nao
depende da rotacao, mas apenas da abertura da borboleta, o mapa
de volume na verdade eh um vetor de volume, que so depende da
abertura da borboleta.
Os valores em porcentagem de abertura armazenados no vetorsao:
0, 5, 10, 15, 20, 25, 35, 50, 75 e 100.
*/
/*
A variavel BORBOLETA so pode assumir valores entre 0 e 100,
representando
a porcentagem de abertura da borboleta do motor.
Isso implica em que o tratador das mensagens recebidas transforme os
valores recebidos em valores nesse intervalo.
O mesmo vale para a variavel ROTACAO. Valores deveme satr no intervalo
1000 a 6000 rpm.
*/
/*
A variavel TENSAO eh do tipo float e pode assumir qualquer valor entre
10 e 14 VOLTS.
*/
8.2
34
%%14 Volt%%
med14 = [nan 0 1.55 2.4 3.3 4.2 5.1 6.0 6.9 7.8 8.7 9.6];
med14 = med14./500;
p14 = plot(med14,'r');
legend('10 V','11 V','12 V','13 V','14 V',0);
matrixmedicoes = [med10; med11; med12; med13; med14];
figure
surf([1 2 3 4 5 6 7 8 9 10 11 12],[10 11 12 13 14],matrixmedicoes);
xlabel('Tempo Injeao (ms)'); ylabel('Tensao Alim (V)');
zlabel('Volume (ml)');
figure (3)
hold;
grid;
for i=1:12
for j=1:5
plot3(j,matrixmedicoes(j,i),i,'*');
end
end
%%med10(2:end);
vettempo = [2 3 4 5 6 7 8 9 10 11 12];
%tempo em ms
%%volinter = [1 2 3 4 5 6 7 8];
%volinter = [0.002 0.004 0.006 0.008 0.010 0.012 0.014];
%volume
injetado em ml
volinter = [0.002 0.004 0.006 0.008 0.010 0.012];
%volume injetado
em ml
tempo10
tempo11
tempo12
tempo13
tempo14
=
=
=
=
=
interp1(med10(2:end),vettempo,volinter,'spline');
interp1(med11(2:end),vettempo,volinter,'spline');
interp1(med12(2:end),vettempo,volinter,'spline');
interp1(med13(2:end),vettempo,volinter,'spline');
interp1(med14(2:end),vettempo,volinter,'spline');
35
end
volume = interp1(x(1:end), w(1:end), [0 .5 1 1.5 2 2.5 3.5 5 7.5
10],'linear')
for j=0:9
plot([0 .5 1 1.5 2 2.5 3.5 5 7.5 10],volume,'o');
end
volume2=volume;
for k=1:10
volume(k)=volume(k)-79;
volume2(k)=volume(k)*100/(128-79);
end
volume2
%o menor valor: 4,1s a 13V, 65% do maior
8.3
Lista de componentes
1 LED
2 diodos IN4007
2 transistores BC639
1 LM347 (regulador)
1 L7805 (regulador)
1 MAX 232 (rede)
1 36C4RLM (rede)
1 cristal de 20MHz
1 boto do tipo ON/OFF
1 boto do tipo apertar
Resistores:
1 de 100K
1 de 22K
1 de 2.2K
7 de 1K
1 de 3.5
Capacitores:
4 d e4.7uF / 50V
2 de 0.1uF / 100V
2 de 100uF / 16V
1 de 220uF / 35V
1 de 1nF
2 de 22pF
Conectores:
1 do tipo DB9
1 do tipo PHOENIX de 3 posies
1 do tipo JACK
36
8.4
37
8.5
Mapa de volume
38