Anexo 2:
Listagem dos programas:
Todos os programas foram escritos em PASCAL e compilados usando o Borland TurboPascal versão 5.0.
Todos os programas precisam, para seu funcionamento, que se instale previamente na memória do computador o programa residente PCL-812.EXE.
As versões seguintes são aquelas usadas na data de redação deste trabalho. É necessário salientar que os programas sofrem alterações com muita freqüência tanto em funções quanto em número.

program display;
{exibe na tela os valores de irradiação, temperatura, corrente e tensão. Pode usar uma escala de tensões de entrada diferente para cada canal. Usa conversão em modo cíclico}
uses crt;
var
param : array [0..55] of word;
{tabela de parâmetros da PCL-812PG}
buffer : array [9..15] of integer;
{reserva espaço para os resultados binários da conversão A/D. O valor 9..15 revela que pretendemos usar os canais de 9 a 15 da PCL-812PG}
data : array [9..15] of real;
{resultados das medições efetuadas já transformados em números reais}
gain : array [0..15] of word;
{escala de tensões de cada canal}
func : integer;
{define a função que o driver da PCL-812PG irá executar}
i : integer;
{variável auxiliar usada em loops de contagem}
{$L 812TPF}
{inclui o programa 812TPF como parte do programa objeto gerado aqui}
{$F+}
{permite o uso de chamadas distantes no programa}
procedure pcl812 (func:integer; var param:word); external;
begin
clrscr;
for i := 0 to 15 do gain[i] := 0;
gain[9] := 3;
gain[10] := 4;
gain[11] := 4;
gain[12] := 4;
gain[13] := 4;
{define a escala de tensões de cada canal}
param[0] := 0;
{vamos usar a primeira - e única - placa instalada no computador}
param[1] := $220;
{define o endereço da placa}
param[4] := 2;
{define a interrupção da placa}
param[5] := 1000;
param[6] := 1000;
{freqüência do trigger = 2 MHz / (param[5]*param[6]). Aqui temos 0,5 segundos}
param[7] := 0;
{usaremos trigger interno}
param[8] := 1;
{define modo cíclico de conversão}
param[10] := ofs (buffer[9]);
param[11] := seg (buffer[9]);
{indica o endereço de memória reservada para o buffer}
param[12] := 0;
param[13] := 0;
{os parâmetros 12 e 13 são usados para endereçar um buffer opcional}
param[14] := 7;
{define quantas conversões serão executadas em um ciclo. Ajustamos esse valor para 7 porque estamos usando sete canais de entrada}
param[15] := 9;
param[16] := 15;
{definem os canais inicial e final de cada ciclo de conversão}
param[17] := $FF;
{o valor $FF diz que a escala de tensões de cada canal deve ser lida da variável gain}
param[18] := ofs (gain[0]);
param[19] := seg (gain[0]);
{indica o endereço de memória onde está a tabela com as escalas de cada canal}
func := 3;
pcl812 (func, param[0]);
{inicializa o driver da placa}
func := 4;
pcl812 (func, param[0]);
{passa os parâmetros para a conversão analógico/digital}
func := 9;
pcl812 (func, param[0]);
{dispara o processo de conversão em background com gravação dos resultados no buffer via interrupções de hardware}
repeat
for i := 9 to 15 do data[i] := buffer[i] AND $FFF;
data[9] := 0.919686 * data[9] - 1912.529408;
data[10] := 0.038617 * data[10] - 79.719597;
data[11] := 0.037274 * data[11] - 73.330598;
data[12] := 0.038561 * data[12] - 84.620863;
data[13] := 0.037203 * data[13] - 81.550396;
data[14] := 0.00056738 * data[14] - 1.213049645;
data[15] := 0.01363014 * data[15] - 27.90089041;
{associa a cada resultado binário da conversão analógico/digital a respectiva grandeza física de acordo com a calibração previamente efetuada}
writeln ('Irradiance = ', data[9]:5:0);
writeln ('Temperature 1 = ', data[10]:5:0);
writeln ('Temperature 2 = ', data[11]:5:0);
writeln ('Temperature 3 = ', data[12]:5:0);
writeln ('Temperature 4 = ', data[13]:5:0);
writeln ('Current = ', data[14]:5:2);
writeln ('Voltage = ', data[15]:5:1);
{exibe os resultados}
gotoxy (1,1);
until keypressed;
clrscr;
func := 11;
pcl812 (func, param[0]);
{encerra o processo de conversão}
end.

program record;
{grava um arquivo com valores de corrente, tensão e também a evolução da temperatura do painel para posterior leitura pelo MATLAB. Gera os dados para o traçado das curvas I×V e permite também fixar a corrente do circuito no valor que desejarmos. Pode ser facilmente adaptado para fixar a tensão em vez da corrente}
uses crt, dos;
var
param : array [0..55] of word;
buffer : array [9..15] of integer;
data : array [9..15] of real;
gain : array [0..15] of word;
func : integer;
i, : integer;
cont : real;
{sinaliza a corrente que desejamos obter}
said : integer;
{define a tensão, em binário, aplicada à saída da placa}
comm : char;
{determina a ação que desejamos realizar}
arquivo : text;
{variável do programa que irá conter os valores lidos. Mais tarde essa variável será gravada no arquivo C_ELET.TXT}
{$L 812TPF}
{$F+}
procedure pcl812 (func:integer; var param:word); external;
begin
assign (arquivo, 'record.txt');
{identifica a variável do programa com o arquivo em disco}
rewrite (arquivo);
{limpa a variável. Os valores antigos se perdem}
for i := 0 to 15 do gain[i] := 0;
gain[9] := 3;
gain[10] := 4;
gain[11] := 4;
gain[12] := 4;
gain[13] := 4;
param[0] := 0;
param[1] := $220;
param[4] := 2;
param[5] := 1000;
param[6] := 100;
{freqüência do trigger = 2 MHz / (param[5]*param[6]). Aqui temos 0,05 segundos}
param[7] := 0;
param[8] := 1;
param[10] := ofs (buffer[9]);
param[11] := seg (buffer[9]);
param[12] := 0;
param[13] := 0;
param[14] := 7;
param[15] := 9;
param[16] := 15;
param[17] := $FF;
param[18] := ofs (gain[0]);
param[19] := seg (gain[0]);
param[20] := ofs (said);
param[21] := seg (said);
{indica o endereço de memória onde está o valor em binário da tensão de saída}
param[22] := 0;
param[23] := 0;
{os parâmetros 22 e 23 são usados para endereçar um buffer opcional para o conversor D/A}
param[24] := 1;
{define uma única conversão digital/analógica por ciclo}
param[25] := 0;
param[26] := 0;
{definem os canais inicial e final de cada ciclo de conversão D/A. A carga eletrônica é acionada através do canal 0}
func := 3;
pcl812 (func, param[0]);
func := 4;
pcl812 (func, param[0]);
func := 9;
pcl812 (func, param[0]);
func := 12;
pcl812 (func, param[0]);
{passa os parâmetros para a conversão digital/analógico}
said := 1100;
cont := 0;
{inicializa as variáveis}
repeat
comm := ' ';
{inicializa a variável}
for i := 9 to 15 do begin
data[i] := (buffer[i] AND $FFF);
delay (350); end;
{usamos um delay de 350 ms porque estamos com sete medições por ciclo com um trigger de 50 ms}
data[9] := 0.919686 * data[9] - 1912.529408;
data[10] := 0.038617 * data[10] - 79.719597;
data[11] := 0.037274 * data[11] - 73.330598;
data[12] := 0.038561 * data[12] - 84.620863;
data[13] := 0.037203 * data[13] - 81.550396;
data[14] := 0.00056738 * data[14] - 1.213049645;
data[15] := 0.01363014 * data[15] - 27.90089041;
{medições realizadas}
gotoxy (1,3);
writeln ('Irradiação = ', data[9]:5:0);
writeln ('Temperatura 1 = ', data[10]:5:0);
writeln ('Temperatura 2 = ', data[11]:5:0);
writeln ('Temperatura 3 = ', data[12]:5:0);
writeln ('Temperatura 4 = ', data[13]:5:0);
writeln ('Corrente = ', data[14]:5:2);
writeln ('Tensão = ', data[15]:5:1);
{exibe os resultados}
writeln (arquivo, data[9]:7:1, data[10]:7:1, data[11]:7:1, data[12]:7:1, data[13]:7:1, data[14]:7:3, data[15]:7:2);
{acrescenta os resultados à variável arquivo}
if keypressed then begin
gotoxy (1,11);
read (comm);
if comm = 'c' then begin
{o comando «c» corresponde a impor a corrente do circuito}
gotoxy (1,11);
write ('Qual a corrente desejada? ');
readln (cont);
gotoxy (1,11);
writeln (' '); end;
if comm = 't' then begin
{o comando «t» corresponde a traçar a curva I×V}
gotoxy (1,11);
writeln ('Traçando a curva IxV...');
said := 2000;
func := 13;
pcl812 (func,param[0]);
{realiza a conversão digital/analógico}
delay (1000);
{o painel vai ao curto-circuito}
cont := 0;
{buscaremos depois o circuito aberto}
gotoxy (1,11);
writeln (' '); end; end;
if data[14] > cont then said := said - 1 else said := said + 1;
{o sistema buscará o valor de corrente sinalizado pela variável cont}
if said < 0 then said := 0;
if said > 4095 then said := 4095;
{mantém a tensão de saida entre 0 e 5 V}
func := 13;
pcl812 (func, param[0]);
until comm = 'e';
{o comando «e» corresponde a encerrar o programa}
said := 0;
func := 13;
pcl812 (func, param[0]);
func := 11;
pcl812 (func, param[0]);
close (arquivo);
end.

program bateria;
{grava um arquivo com a evolução da corrente e da tensão durante os processos de carga e descarga da bateria. Chaveia o relê quando a tensão atinge os valores programados}
uses crt, dos;
var
param : array [0..55] of word;
buffer : array [14..15] of integer;
data : array [14..15] of real;
func : integer;
i, j : integer;
acc : integer;
{define a tensão, em binário, aplicada à saída que controla o relê}
arquivo : text;
{variável do programa que irá conter os valores lidos. Mais tarde essa variável será gravada no arquivo BATERIA.TXT}
{$L 812TPF}
{$F+}
procedure pcl812 (func:integer; var param:word); external;
begin
assign (arquivo, 'bateria.txt');
rewrite (arquivo);
param[0] := 0;
param[1] := $220;
param[4] := 2;
param[5] := 1000;
param[6] := 2000;
{freqüência do trigger = 2 MHz / (param[5]*param[6]). Aqui temos 1 segundo}
param[7] := 0;
param[8] := 1;
param[10] := ofs (buffer[14]);
param[11] := seg (buffer[14]);
param[12] := 0;
param[13] := 0;
param[14] := 2;
param[15] := 14;
param[16] := 15;
param[17] := 0;
param[20] := ofs (acc);
param[21] := seg (acc);
param[22] := 0;
param[23] := 0;
param[24] := 1;
param[25] := 1;
param[26] := 1;
{definem os canais inicial e final de cada ciclo de conversão D/A. O relê é acionado através do canal 1}
func := 3;
pcl812 (func, param[0]);
func := 4;
pcl812 (func, param[0]);
func := 9;
pcl812 (func, param[0]);
func := 12;
pcl812 (func, param[0]);
acc := 0;
func := 13;
pcl812 (func, param[0]);
{o relê está inicialmente desativado}
repeat
for i := 14 to 15 do data[i] := 0;
for j := 1 to 10 do begin
for i := 14 to 15 do data[i] := (buffer[i] AND $FFF) + data[i];
delay (2000); end;
for i := 14 to 15 do data[i] := data[i] / 10;
{calcula a média das últimas 10 medidas}
data[14] := 0.00056738 * data[14] - 1.213049645;
data[15] := 0.01363014 * data[15] - 27.90089041;
if data[15] >= 15.15 then begin
acc := 4095;
func := 13;
pcl812 (func, param[0]);
writeln ('Descarregar bateria.'); end;
if data[15] <= 11.5 then begin
acc := 0;
func := 13;
pcl812 (func, param[0]);
writeln ('Carregar bateria. '); end;
{chaveia o relê entre os limites de 15,15 e 11,5 V}
gotoxy (1,3);
writeln ('Corrente = ', data[14]:5:2);
writeln ('Tensão = ', data[15]:5:1);
writeln (arquivo, data[14]:7:3, data[15]:7:2);
until keypressed and (readkey = 'e');
{o programa se encerra ao pressionarmos a tecla «e»}
acc := 0;
func := 13;
pcl812 (func, param[0]);
{o relê é desativado antes de sair do programa}
close (arquivo);
end.