Hacia el motor superconductor: estudio de las interacciones entre un rotor superconductor y un estator convencional

(1)

(2)

(3)

(4)

(5)

(6)

(7)

(8)

(9)

(10)

(11)

(12)

(13)

(14)

(15)

(16)

(17)

(18)

(19)

(20)

(21)

(22)

(23)

(24)

(25)

(26)

(27)

(28)

(29)

(30)

(31)

(32)

(33)

(34)

(35)

(36)

(37)

(38)

(39)

Anexo 3. Software usado para la caracterización de los motores

1. lectura de datos para la prueba estática

program leedatos.pas;

uses crt;

{$I c:\ernest\pascal\analog\analog.bib}

const

digioutaddrlow : word =$220+13; digioutaddrhigh: word =$220+14;

var

lastk,k,kk,j,l,ll,jj : integer; portlow : word;

porthigh : word; nom_fitxer: string; nom_aux : string; fitx : text; aa,bb,f : real; size : word; espai : longint; lect : word;

procedure inicialize; begin clrscr; {port[digioutaddrlow]:=0; portlow:=0; port[digioutaddrhigh]:=0; porthigh:=0;} end; begin clrscr; inicialize;

writeln('escriu el nom del fitxer sense extensi¢.');

writeln(' Es genera un fitxer extensi¢ . dat a c:\pepe'); readln(nom_fitxer); nom_aux:= 'c:\pepe\'+nom_fitxer+'.dat'; assign(fitx,nom_aux); rewrite(fitx); nosound; kk:=0; repeat kk:=kk+1; aa:=leevolt(0,100); bb:=leevolt(1,100); writeln(aa,' ',bb); writeln(fitx,aa,' ',bb); delay(100);

gotoxy(10,10);

(40)

until keypressed; close(fitx); end.

2

. programa para la excitación de la etapa de potencia y lectura del

par , la posición i la velocidad del motor en la prueba dinàmica

program trifasic.pas;

uses crt, dos;

{$I c:\ernest\pascal\analog\analog.bib}

type

binari = string;

const

digioutaddrlow : word =$220+13; digioutaddrhigh: word =$220+14; modecountaddr : word =$220+3 ; countreadaddr : word =$220 ;

var

ona, estat : array[1..12] of byte; pas : byte;

wait : word; a : real;

function pasabin(numero:byte):binari; var

j : byte; pasabi:binari;

begin

pasabi:='';

for j:=1 to 8 do begin

pasabi:=pasabi+char(48+numero mod 2); numero:=numero div 2;

end; pasabin:=pasabi; end; procedure inicialize; var j:byte;

ona1,ona2,ona3 : byte;

begin clrscr;

for j :=1 to 3 do ona[j]:=0; for j :=4 to 6 do ona[j]:=2; for j :=7 to 9 do ona[j]:=0; for j :=10 to 12 do ona[j]:=1; for j:=1 to 12 do

begin

(41)

ona2:=ona[(j+4)mod 12]; ona3:=ona[(j+8)mod 12];

estat[j]:=ona1 or 4*ona2 or 16*ona3 ; end; wait:=120; port[modecountaddr]:=$38; port[countreadaddr]:=$ff; port[countreadaddr]:=$ff; delay(20000); end; function readcount:word; var

prim, second :byte;

begin

prim:=port[countreadaddr]; second:=port[countreadaddr]; readcount:=prim+ 256*second; end;

procedure cicle(espera: word); var

j :byte;

begin

for j:= 1 to 12 do begin

port[digioutaddrhigh]:=estat[j]; {gotoxy(1,15);

writeln(pasabin(estat[j]),' '); a:=leevolt(0,100);

(42)

3. programa para el control de l motor paso a paso de frenado

.

program frena; uses crt,dos;

const prt :word =$378; var j,k,d : integer;

procedure frenar(x:integer);

var: integer; begin

for n:=0 to x do begin port[prt]:=3; delay(k); port[prt]:=9; delay(k); port[prt]:=12; delay(k); port[prt]:=6; end; end; procedure desfrenar(x:integer); var n:integer; begin

(43)

4. movimiento axial del estator, y adquisición y almacenamiento de los

datos de fuerzas de levitación.

Fuerzas.pas

Program forces;

Uses

Crt,t8255,sensors,motors,grafics,control;

Type

senyuelo = Integer;

Const

tmp_const: Real = 210; {210 pasos por segundo; retardo=1} sec: Real = 1.2; {margen de securitad de puntos medidos} n_mot: Integer = 2; {número de motores}

n_finestres: Integer = 4;

max_bucles_petits: Integer = 4; Var

Psi: Rsistema; retard: g_int; maxims,minims:g_int;

ms: g_mot; busca_fi: g_bool;

cnls: g_int; {canales de los sensores} cont: Integer;

process: Boolean; relax: Integer; N: Integer; nom_fitxer: String; nom_aux: String; fminx,fmaxx: Integer; fminz,fmaxz: Integer; espaiat,tram: Integer; vuit: Tgraf;

claus: Array[1..2] of conj_claus; marge: Array[1..4] of conj_limits; maxtmp: Real;

primer,ultim: Integer; n_bucles_petits: Integer;

incd: Integer; {incremento densidad puntos bucles pequeños}

interval: Integer; {relación puntos medida-pasos} int_aux: Real;

cicles: Integer; desti: LongInt; referencia: Integer; fitxer: Text;

Procedure prepara_fitxer(nom_fitxer:String;Var fitxer:Text); Var

nom_aux: String; Begin

nom_aux:=Concat('c:\tp60\isabel\',nom_fitxer,'.m'); Assign(fitxer,nom_aux);

Rewrite(fitxer);

(44)

Writeln(fitxer,nom_aux); Close(fitxer);

End;

Function cas_fc(Var mot:Rmotor):Boolean; Var

resposta: Char; Begin

mot.retard:=mot.retard*proporcio; mot.maxpos:=mot.maxpos*proporcio; mot.minpos:=mot.minpos*proporcio;

While (mot.mou_motor(DAVANT) AND (mot.pos<mot.maxpos) AND (mot.estat=DAVANT)) Do;

Writeln('FC Preparat. Continuem? (S/N)'); Readln(resposta);

If ((resposta<>'s') AND (resposta<>'S')) Then cas_fc:=False

Else

cas_fc:=True;

mot.pos:=mot.pos div proporcio;

mot.maxpos:=mot.maxpos div proporcio; mot.minpos:=mot.minpos div proporcio; mot.retard:=mot.retard div proporcio; End;

Begin

{ writeln(26946*14/60);}

process:=True; {True: ZFC; False:FC} relax:=0; {minutos a esperar} N:=1; {ciclos de medida} nom_fitxer:='cal';

fminx:=7000; {fuerzas estimadas según x} fmaxx:=9000;

fminz:=8400; { fuerzas estimadas según z} fmaxz:=9000;

espaiat:=2200; { 2200 pasos=5 mm retardo=1)}

tram:=2*625; { 440 pasos=1mmz (retardo=1); 420 pasos=1mmx (retardo=2)}

{ 625 pasos=1mmx (retardo=3)}

incd:=4; {incremento densidad puntos bucles pequeños}

vuit.init('c:\tp60\bgi',0); If vuit.acces Then

Writeln('Acceso a opciones gráficas');

retard[1]:=1; retard[2]:=3; ms[1]:=MZ; ms[2]:=MX;

busca_fi[1]:=false; busca_fi[2]:=False; minims[1]:=0; minims[2]:=-28716; maxims[1]:=37733; maxims[2]:=21345;

cnls[1]:=0; cnls[2]:=8; If

Psi.crea_sistema(n_mot,retard,ms,busca_fi,maxims,minims,cnls,n_finestr es) Then

Writeln('Ok. Motor amb retard=',retard[1]);

If N>2 Then

(45)

int_aux:=sec*((2*N-1)*Psi.mot[1].maxpos+4*(N-2)*int_aux)+relax*60*tmp_const Else int_aux:=sec*(2*N*Psi.mot[1].maxpos+4*(N-2)*int_aux)+relax*60*tmp_const Else

If Not(process) Then

int_aux:=sec*((2*N-1)*Psi.mot[1].maxpos+4*(N-1)*int_aux) Else

int_aux:=sec*(2*N*Psi.mot[1].maxpos+4*(N-1)*int_aux); maxtmp:=int_aux/tmp_const;

{x's} {min(x)} {max(x)} claus[1][1]:=1; marge[1][1]:=0;

marge[3][1]:=Psi.mot[1].maxpos;

claus[1][2]:=1; marge[1][2]:=0; marge[3][2]:=Psi.mot[1].maxpos;

claus[1][3]:=3; marge[1][3]:=0; marge[3][3]:=maxtmp; claus[1][4]:=2; marge[1][4]:=-1.1*tram; marge[3][4]:=1.1*tram;

{y's} {min(y)} {max(y)} claus[2][1]:=5; marge[2][1]:=fminx; marge[4][1]:=fmaxx; claus[2][2]:=4; marge[2][2]:=fminz; marge[4][2]:=fmaxz; claus[2][3]:=4; marge[2][3]:=fminz; marge[4][3]:=fmaxz; claus[2][4]:=5; marge[2][4]:=fminx; marge[4][4]:=fmaxx;

Psi.graf.asigna_indexs(claus[1],claus[2]);

Psi.graf.fin[1].title(' Psi1'); Psi.graf.fin[1].xnom('dist…ncia Z (pasos)'); Psi.graf.fin[1].ynom('forza X (A/D)');

Psi.graf.fin[2].title(' Psi2'); Psi.graf.fin[2].xnom('dist…ncia Z (pasos)'); Psi.graf.fin[2].ynom('forza Z (A/D)');

If Process Then

nom_aux:='Cas Zero Field Cooled' Else

nom_aux:='Cas Field Cooled'; Psi.graf.fin[3].title(nom_aux);

Psi.graf.fin[3].xnom('temps (segons)'); Psi.graf.fin[3].ynom('forza Z (A/D)'); Psi.graf.fin[4].title(' Psi3'); Psi.graf.fin[4].xnom('dist…ncia X (pasos)'); Psi.graf.fin[4].ynom('forza X (A/D)');

Psi.graf.asigna_limits(marge[1],marge[2],marge[3],marge[4]);

prepara_fitxer(nom_fitxer,fitxer);

If Not(process) Then

If Not(cas_fc(Psi.mot[1])) Then Exit; primer:=1; {**********************************} Psi.tmp.posa_zero; desti:=trunc(Psi.mot[1].maxpos/80)*77; interval:=2000;

(46)

primer:=1; delay(3000);

desti:=trunc(Psi.mot[1].maxpos/80)*6; interval:=5;

if Psi.cami(1,desti,true,primer,ultim,interval) then primer:=ultim+1;

desti:=trunc(Psi.mot[1].maxpos); interval:=5;

if Psi.cami(1,desti,true,primer,ultim,interval) then writeln('ultim=',ultim);

Str(cicles,nom_aux);

nom_aux:=Concat(nom_fitxer,nom_aux,'=['); escriu(fitxer,Psi.resultat,ultim,0,nom_aux);

primer:=1; desti:=0;

interval:=2000;

if Psi.cami(1,desti,true,primer,ultim,interval) then primer:=1;

For cont:=1 To n_motors Do Psi.mot[cont].tanca_port;

Repeat Until KeyPressed; vuit.fi;

(47)

5.

software necesario para el funcionamiento de fuerzas.pas

Motores.pas

Unit motors; Interface Uses Crt,t8255; Type

tipus_motor = (MX,MY,MZ);

cicle_motor = Array[1..8] of Byte; estat_motor = (DAVANT,ENRERA,DESACT); mascares = Array[1..2] of Byte;

{************************************} Rmotor = Object(Tt8255)

pos : LongInt; maxpos,minpos : LongInt; posicio: Real;

estat : estat_motor; retard : Integer; digfi : Tt8255; fi : mascares;

Function fi_carrera:Byte; Function mou_motor(sentit:estat_motor):Boolean; Function ini_motor:Boolean; Function crea_motor(rtard:Integer;m:tipus_motor; opcio:Boolean;maxim,minim:LongInt): Boolean;

Function pas: LongInt; Function situacio: Real; Function max_pos: LongInt; Procedure vis_motor;

Procedure mata_motor; End;

Const

cicle : cicle_motor = (7,5,13,9,11,10,14,6);} cicle : cicle_motor = (6,14,10,11,9,13,5,7);

pas_micra: Real = 2; {Conversión paso-micra} Implementation Function Rmotor.fi_carrera:Byte; Var fi_aux:Byte; aux:Byte; Begin fi_aux:=0; aux:=Port[digfi.base];

If (Port[digfi.base] And fi[1])=0 Then fi_aux:=1;

(48)

Else

fi_carrera:=fi_aux; End;

Function Rmotor.mou_motor(sentit:estat_motor):Boolean; Var

index_motor, index_motor_bis :Byte; aux:Byte;

Begin

mou_motor:=True; estat:=sentit; aux:=fi_carrera; Case aux of 0: Begin

Case sentit of

DAVANT: pos:=pos+1; ENRERA: pos:=pos-1; End; End; 1: Begin estat:=DAVANT; minpos:=pos; pos:=pos+1; End; 2: Begin estat:=ENRERA; maxpos:=pos; pos:=pos-1; End; Else Begin

Writeln('Error al motor. Problemas con los fines de carrera.');

estat:=DESACT; mou_motor:=False; End;

End;

If estat<>DESACT Then Begin

aux:=round(pos/retard+0.01*abs(pos/retard)); index_motor:=(aux And $7)+1;

index_motor_bis:=((aux-2) And $7)+1;

Port[base]:=cicle[index_motor]+cicle[index_motor_bis]*16;

{ posicio:=(2+((pos-1) div retard))/pas_micra; index_motor:=(1+((pos-1) div retard) And $7)+1;

index_motor_bis:=(1+(((pos-1) div retard)-2) And $7)+1; Port[base]:=cicle[index_motor]+cicle[index_motor_bis]*16;} End;

End;

Function Rmotor.ini_motor:Boolean; Var

sort : Boolean; i : Word;

c: Char; Begin

(49)

pos:=0;

While ((estat=DAVANT) And Not(sort)) Do sort:=Not(mou_motor(DAVANT));

If sort Then Begin

Writeln('Error al motor. Problemas con el segundo fin de carrera.');

ini_motor:=False; End

Else Begin

Writeln('Detectado primer fin de carrera. Ok. Pulsa una tecla');

Read(c); maxpos:=pos;

While ((estat=ENRERA) And Not(sort)) Do sort:=Not(mou_motor(ENRERA));

If sort Then Begin

Writeln('Error al motor. Problemas con el segundo fin de carrera.'); ini_motor:=False; End Else minpos:=pos; End; End; Function Rmotor.crea_motor(rtard:Integer;m:tipus_motor; opcio:Boolean;maxim,minim:LongInt): Boolean; Begin crea_motor:=True; retard:=rtard; Case m of MX: Begin base:=$1b5; fi[1]:=4; fi[2]:=2; End; MY: Begin base:=$1b4; fi[1]:=4; fi[2]:=2; End; MZ: Begin base:=$1b4; fi[1]:=8; fi[2]:=1; End; End; digfi.base:=$1b0; digfi.ini_port; If opcio Then

(50)

End;

Function Rmotor.pas: LongInt; Begin

pas:=pos; End;

Function Rmotor.situacio: Real; Begin

situacio:=posicio; End;

Function Rmotor.max_pos: LongInt; Begin

max_pos:=maxpos; End;

Procedure Rmotor.vis_motor; Begin

Write('Pos= ',pos,' MaxPos= ',maxpos); End;

Procedure Rmotor.mata_motor; Begin

tanca_port;

digfi.tanca_port; End;

(51)

6. programa para la lectura de datos de los sensores

sensores.pas

Unit sensors; Interface Uses Crt, basics; Type Rsensor=Object(Tbase) analog : Word; canal: Byte; valor,zero: Integer; Function leevolt(promig:Integer):Integer; Procedure ini_sensor; Procedure crea_sensor(ab:Word;cnl:Byte); End; Implementation Function Rsensor.leevolt(promig:Integer):Integer; Const

espera : Integer = 1; Var

i,k : Integer; j,Hsal,Lsal : Byte; parcial : Real; q : Byte;

Begin

parcial:=0;

For i:=1 To promig Do Begin

Port[analog+1]:=0; Port[analog]:=canal; For j:=1 to 8 Do

Hsal:=Port[analog+8]; For j:=1 to 8 Do

Lsal:=Port[analog+12]; Lsal:=Port[analog+2];

Hsal:=Port[analog+3] And $3F; parcial:=parcial+Lsal+256*Hsal; for q:=1 to espera Do;

(52)

End.

7. programa para la representación de gráficos en la pantalla

Graficos.pas

Unit grafics; Interface Uses Crt,basics,Graph; Type

conj_claus= Array[1..4] of Integer; conj_limits= Array[1..4] of Real;

{************************************} Tgraf=Object(Tbase)

Mx,My: Integer;

PathToDriver: String; GraphMode: Integer;

Constructor init(S:string;I:Integer); Function acces: Boolean;

Procedure fi; End; {************************************} Rseccio=Object(Tbase) buffer: Pointer; tamany: Word;

limits: Array[1..4] of Integer;

Constructor init(x1,y1,x2,y2:Integer); Destructor fi; Procedure agafa; Procedure posa; End; {************************************} Rpantalla=Object(Tbase)

bloc: Array[1..4] of Rseccio; Constructor init;

Destructor fi; End;

{************************************} Rgrafica=Object(Tbase)

int_limits: Array[1..4] Of Integer; real_limits: Array[1..4] Of Real; Procedure init(x1,y1,x2,y2:Integer); Procedure canvi_escala(x1,y1,x2,y2:Real);

Function obte_punt(x,y:Real;Var xp,yp:Integer):Boolean; Procedure dibuixa_punt(x,y:Real);

End;

{************************************} Reix=Object(Rgrafica)

(53)

grid: Boolean; t,x,y: String; Procedure activa; Procedure desactiva; Procedure canvi_escala(x1,y1,x2,y2:Real); Procedure nou(clau:Integer); Procedure xarxa(g:Boolean); Procedure title(nom:String); Procedure xnom(xtitle:String); Procedure ynom(ytitle:String); End; {************************************} Rfinestra=Object(Tbase)

n_finestres : Integer;

fin : Array[1..4] of Reix; {n_ventanas=4} cx,cy : conj_claus;

Procedure defineix_finestres(claus:conj_claus); Procedure asigna_indexs(claux,clauy:conj_claus); Procedure asigna_limits(minx,miny,maxx,maxy:conj_limits); End; Implementation Constructor Tgraf.init(S:String;I:Integer); Begin PathToDriver:=S; GraphMode:=I; End;

Function Tgraf.acces: Boolean; Var

GraphDriver: Integer; ErrorCode: Integer; LowMode: Integer; HighMode: Integer;

Begin { acces }

DirectVideo:=False; acces:=True; GraphDriver:=Detect; InitGraph(GraphDriver,GraphMode,PathToDriver); GetModeRange(GraphDriver,LowMode,HighMode); SetGraphMode(HighMode); ErrorCode:=GraphResult; ClrScr;

If ErrorCode<>grOk Then Begin

Writeln('Error en gr…fics: ',GraphErrorMsg(ErrorCode)); Writeln('Sin acceso a las opciones gráficas');

Delay(7500); acces:=False; End Else ClearDevice; Mx:=GetMaxX; My:=GetMaxY; End; { acces }

(54)

CloseGraph; End; Constructor Rseccio.init(x1,y1,x2,y2:Integer); Begin limits[1]:=x1; limits[2]:=y1; limits[3]:=x2; limits[4]:=y2; tamany:=Imagesize(x1,y1,x2,y2); GetMem(buffer,tamany); End; Destructor Rseccio.fi; Begin FreeMem(buffer,tamany); End; Procedure Rseccio.agafa; Begin GetImage(limits[1],limits[2],limits[3],limits[4],buffer^); End; {---} Procedure Rseccio.posa; Begin PutImage(limits[1],limits[2],buffer^,NormalPut); End; Constructor Rpantalla.init; Begin

bloc[1].init(0,0,GetMaxX div 2,GetMaxY div 2);

bloc[2].init(GetMaxX div 2,0,GetMaxX,GetMaxY div 2); bloc[3].init(0,GetMaxY div 2,GetMaxX div 2,GetMaxY);

bloc[4].init(GetMaxX div 2,GetMaxY div 2,GetMaxX,GetMaxY); End;

Destructor Rpantalla.fi; Var

i:Integer; Begin

(55)

real_limits[3]:=x2; real_limits[4]:=y2; End;

Function Rgrafica.obte_punt(x,y:Real;Var xp,yp:Integer):Boolean; Begin obte_punt:=True; xp:=Round((x-real_limits[1])*(int_limits[3]-int_limits[1]) /(real_limits[3]-real_limits[1])+int_limits[1]); yp:=Round((y-real_limits[2])*(int_limits[2]-int_limits[4]) /(real_limits[4]-real_limits[2])+int_limits[4]);

If (x<real_limits[1]) Or (x>real_limits[3]) Then obte_punt:=False;

If (y<real_limits[2]) Or (y>real_limits[4]) Then obte_punt:=False; End; Procedure Rgrafica.dibuixa_punt(x,y:Real); Var auxx,auxy:Integer; Begin

If obte_punt(x,y,auxx,auxy) Then PutPixel(auxx,auxy,LightGray); End;

Procedure Reix.activa; Var

p: Real; xx,yy: Integer; s: String; Begin SetColor(LightGray); SetTextStyle(TriplexFont,HorizDir,1); OutTextXY(int_limits[1]+15,int_limits[2]-30,t); SetTextStyle(SmallFont,HorizDir,4); OutTextXY(int_limits[3]-8*length(x),int_limits[4]+15,x); SetTextStyle(SmallFont,VertDir,4); OutTextXY(int_limits[1]-50,int_limits[2]+8*length(y),y); SetTextStyle(SmallFont,HorizDir,2); SetColor(DarkGray); Rectangle(int_limits[1],int_limits[2],int_limits[3],int_limits[4]); SetColor(LightGray); p:=real_limits[1];

While obte_punt(p,real_limits[2],xx,yy) Do Begin

PutPixel(xx,yy+1,LightGray); Str(p:1:1,s);

SetTextStyle(SmallFont,HorizDir,2); OutTextXY(xx-15,yy+3,s);

(56)

While obte_punt(real_limits[1],p,xx,yy) Do Begin PutPixel(xx-1,yy,LightGray); Str(p:1:1,s); SetTextStyle(SmallFont,HorizDir,2); OutTextXY(xx-30,yy-7,s);

If grid Then Begin SetColor(DarkGray); SetLineStyle(DottedLn,0,0); Line(int_limits[1],yy,int_limits[3],yy); SetLineStyle(SolidLn,0,0); SetColor(LightGray); End; p:=p+incy; End; Line(int_limits[1]-5,int_limits[4],int_limits[3]+5,int_limits[4]); Line(int_limits[1],int_limits[4]+5,int_limits[1],int_limits[2]-5); End; Procedure Reix.desactiva; Var

p: Real; xx,yy: Integer; s: String; Begin SetColor(Black); SetTextStyle(TriplexFont,HorizDir,1); OutTextXY(int_limits[1]+15,int_limits[2]-30,t); SetTextStyle(SmallFont,HorizDir,4); OutTextXY(int_limits[3]-8*length(x),int_limits[4]+15,x); SetTextStyle(SmallFont,VertDir,4); OutTextXY(int_limits[1]-50,int_limits[2]+8*length(y),y); SetTextStyle(SmallFont,HorizDir,3); Rectangle(int_limits[1],int_limits[2],int_limits[3],int_limits[4]); p:=real_limits[1];

While obte_punt(p,real_limits[2],xx,yy) Do Begin

PutPixel(xx,yy+1,Black); Str(p:1:1,s);

SetTextStyle(SmallFont,HorizDir,2); OutTextXY(xx-15,yy+3,s);

If grid Then Begin SetLineStyle(DottedLn,0,0); Line(xx,int_limits[4],xx,int_limits[2]); SetLineStyle(SolidLn,0,0); End; p:=p+incx; End; p:=real_limits[2];

While obte_punt(real_limits[1],p,xx,yy) Do Begin

PutPixel(xx-1,yy,Black); Str(p:1:1,s);

SetTextStyle(SmallFont,HorizDir,2); OutTextXY(xx-30,yy-7,s);

If grid Then Begin

(57)

Line(int_limits[1],yy,int_limits[3],yy); SetLineStyle(SolidLn,0,0); End; p:=p+incy; End; Line(int_limits[1]-5,int_limits[4],int_limits[3]+5,int_limits[4]); Line(int_limits[1],int_limits[4]+5,int_limits[1],int_limits[2]-5); End; Procedure Reix.canvi_escala(x1,y1,x2,y2:Real); Begin desactiva; real_limits[1]:=x1; real_limits[2]:=y1; real_limits[3]:=x2; real_limits[4]:=y2; incx:=(real_limits[3]-real_limits[1])/5; incy:=(real_limits[4]-real_limits[2])/5; activa; End; Procedure Reix.nou(clau:Integer); Const

lc: Array[1..4] Of Integer=(10,45,60,95); Var

aux: Array[1..4] Of Real; Begin

(58)

(59)

Procedure Rfinestra.defineix_finestres(claus:conj_claus); Var

cont: Integer; Begin

For cont:=1 To n_finestres Do Begin

fin[cont].nou(claus[cont]); fin[cont].xarxa(True); End;

End;

Procedure Rfinestra.asigna_indexs(claux,clauy:conj_claus); Var

For cont:=1 To n_finestres Do Begin

cx[cont]:=claux[cont]; cy[cont]:=clauy[cont]; End;

End;

Procedure Rfinestra.asigna_limits(minx,miny,maxx,maxy:conj_limits); Var

For cont:=1 To n_finestres Do

fin[cont].canvi_escala(minx[cont],miny[cont],maxx[cont],maxy[cont]); End;

(60)

8. control del sistema

Control.pas

Unit control; Interface Uses Crt,basics,t8255,sensors,motors,grafics; Type

g_bool = Array[1..2] of Boolean; {n_motores =2} g_mot = Array[1..2] of tipus_motor; {n_motores =2} g_int = Array[1..2] of LongInt; {n_sensores=2} grup_sensors = Array[1..2] of Rsensor; {n_sensores=2} grup_dades = Array[1..5] of Real;

{x,z,tiempo,s1,s2=1+n_motores+n_sensores}

dades =Array[1..1500] of grup_dades; {limite=1500, cambiar abajo, 8000 / (1+ n_motores + n_sensores)}

{************************************} Rdevice = Object(Tbase)

mot : Array[1..2] of Rmotor; {n_motores =2} lectors : grup_sensors;

conjunt : grup_dades; promig : Integer;

Function crea_device(n_mot:Integer;dretard:g_int;m:g_mot; ini:g_bool;dmaxpos,dminpos:g_int;cnl:g_int):Boolean; Function mou_i_llegeix(motor:Integer;sentit:estat_motor;pasos:Integer):Boolean; End; {************************************} Rsistema = Object(Rdevice)

tmp : Ttemps; graf : Rfinestra; resultat : dades; primer : Integer;

Function crea_sistema(n_mot:Integer;dretard:g_int;m:g_mot;ini:g_bool; dmaxpos,dminpos:g_int;cnl:g_int;n_fin:Integer):Boolean; Procedure dibuixa_fin(index:Integer); Function cami(motor:Integer;final:LongInt;llegeix:Boolean; Var actual,ultim:Integer;pasos:Integer):Boolean;

Procedure espera(minuts:Integer;Var actual: Integer); End;

Procedure escriu(Var fitxer:Text;Var

valors:dades;max,tipus:Integer;cadena:String); Function existfitxer(fitxer : String): Boolean; Procedure emergencia(recupera:dades;index:Integer);

(61)

proporcio: Integer = 4; {relación retardo motor sin leer/motor leyendo}

limit: Integer = 1500; {8000/(1+n_motor+n_sensores)}

n_motors: Integer = 2; n_sensors: Integer = 2; punts_per_minut: Integer = 60; promig_ini: Integer = 5;

Implementation Function Rdevice.crea_device(n_mot:Integer;dretard:g_int;m:g_mot;ini:g_bool; dmaxpos,dminpos:g_int;cnl:g_int):Boolean; Var cont: Integer; Begin crea_device:=True; n_motors:=n_mot;

For cont:=1 To n_mot Do Begin

If

Not(mot[cont].crea_motor(dretard[cont]*proporcio,m[cont],ini[cont], dmaxpos[cont]*proporcio,dminpos[cont]*proporcio)) Then crea_device:=False;

mot[cont].maxpos:=mot[cont].maxpos div mot[cont].retard; mot[cont].minpos:=mot[cont].minpos div mot[cont].retard; mot[cont].pos:=mot[cont].pos div mot[cont].retard;

mot[cont].retard:=dretard[cont];

mot[cont].maxpos:=mot[cont].maxpos*mot[cont].retard; mot[cont].minpos:=mot[cont].minpos*mot[cont].retard; mot[cont].pos:=mot[cont].pos*mot[cont].retard;

End;

For cont:=1 To n_sensors Do

lectors[cont].crea_sensor($170,cnl[cont]); promig:=promig_ini; End; Function Rdevice.mou_i_llegeix(motor:Integer;sentit:estat_motor;pasos:Integer): Boolean; Var

aux: Array[1..10] of Real; cont,cont2,cont3: Integer; Begin

For cont:=1 To n_sensors Do aux[cont]:=0;

cont3:=0;

For cont:=1 To pasos Do Begin

mou_i_llegeix:=mot[motor].mou_motor(sentit); If sentit<>mot[motor].estat Then cont:=pasos; For cont2:=1 To n_sensors Do

aux[cont2]:=aux[cont2]+lectors[cont2].leevolt(promig); Inc(cont3);

End;

For cont:=1 To n_sensors Do

(62)

Function Rsistema.crea_sistema(n_mot:Integer;dretard:g_int;m:g_mot;ini:g_bool; dmaxpos,dminpos:g_int;cnl:g_int;n_fin:Integer):Boolean; Var claus: conj_claus; cont: Integer; Begin crea_sistema:=crea_device(n_mot,dretard,m,ini,dmaxpos,dminpos,cnl); Case n_fin Of

1:claus[1]:=111; 2:Begin claus[1]:=211; claus[2]:=212; End; 3:Begin claus[1]:=221; claus[2]:=222; claus[3]:=212; end; 4:Begin claus[1]:=221; claus[2]:=222; claus[3]:=223; claus[4]:=224; End End; graf.n_finestres:=n_fin; graf.defineix_finestres(claus); End; Procedure Rsistema.dibuixa_fin(index:integer); Var cont,ix,iy: Integer; x,y: Real; Begin

For cont:=1 To graf.n_finestres Do Begin ix:=graf.cx[cont]; iy:=graf.cy[cont]; x:=resultat[index][ix]; y:=resultat[index][iy]; graf.fin[cont].dibuixa_punt(x,y); End; End; Function Rsistema.cami(motor:Integer;final:LongInt;llegeix:Boolean;Var actual,ultim:Integer;pasos:Integer):Boolean; Var

index: Integer; cont: Integer; min_pas: Integer; sentit0: estat_motor; sort: Boolean; Begin

sort:=False;

If final=mot[motor].pos Then sort:=True

(63)

If final<mot[motor].pos Then sentit0:=ENRERA Else sentit0:=DAVANT; End; mot[motor].estat:=sentit0; index:=actual;

While ((mot[motor].estat=sentit0) And Not(sort)) Do Begin

If llegeix Then Begin

If abs(final-mot[motor].pos)<pasos Then min_pas:=abs(final-mot[motor].pos) Else

min_pas:=pasos;

cami:=mou_i_llegeix(motor,mot[motor].estat,min_pas); For cont:=1 To n_motors Do

resultat[index][cont]:=mot[cont].pos; tmp.actualizar;

resultat[index][1+n_motors]:=tmp.cputime/100; For cont:=1 To n_sensors Do

resultat[index][1+n_motors+cont]:=conjunt[1+n_motors+cont]; dibuixa_fin(index);

Inc(index);

If index>limit Then Begin Writeln('Buffer excedit'); emergencia(resultat,index); index:=1; End; End Else cami:=mot[motor].mou_motor(mot[motor].estat); If (sentit0=DAVANT) AND (mot[motor].pos>=final) Then sort:=True;

If (sentit0=ENRERA) AND (mot[motor].pos<=final) Then sort:=True;

End;

ultim:=index-1; End;

Procedure Rsistema.espera(minuts:Integer;Var actual:Integer); Var

nsegons, conta: Integer; Begin

For nsegons:=1 To minuts*60 Do Begin

For conta:=1 To n_motors Do

resultat[actual][conta]:=mot[conta].pos; tmp.actualizar;

resultat[actual][1+n_motors]:=tmp.cputime/100; For conta:=1 To n_sensors Do

(64)

{ ********************************** } Procedure escriu(Var fitxer:Text;Var

valors:dades;max,tipus:Integer;cadena:String); Var

aux,cont,cont2:Integer; Begin

Append(fitxer); If tipus=0 Then

Writeln(fitxer,cadena); For cont:=1 To max-1 Do Begin

For cont2:=1 To 1+n_motors+n_sensors Do Write(fitxer,valors[cont][cont2],' '); If ((tipus=0) And (cont=max-1)) Then Writeln(fitxer,'];') Else Writeln(fitxer,';'); End; Close(fitxer); End; {**** ****************************** }

{ Torna True si existe el fichero y False si hay error } Function existfitxer(fitxer : String): Boolean;

{ función booleana que torna True si existe el fichero } Var f:File; Begin {$I-} Assign(f,fitxer); Reset(f); Close(f); {$I+}

existfitxer := (IOResult=0) And (fitxer <> ''); End; Procedure emergencia(recupera:dades;index:Integer); Var fitxer_emergencia: Text; Begin Assign(fitxer_emergencia,'c:\tmp\tmp.m'); If existfitxer('c:\tmp\tmp.m') Then

(65)

9. definición de los parámetros

Basics.pas

Unit basics; Interface Type Tbase=Object End; Implementation End.

10. control de puertos de entrada-salida

(66)

cputime:=time_aux+100*(LongInt(timecpu.Sec+60*(timecpu.Min+60*timecpu. Hour)))-t_ini; End; Procedure Tt8255.ini_port; Begin Port[base+11]:=$36; Port[base+11]:=$76; Port[base+11]:=$b6; Port[base+8]:=$2; Port[base+8]:=$0; Port[base+9]:=$32; Port[base+9]:=$0; Port[base+10]:=$64; Port[base+10]:=$0; Port[base+3]:=$80; Port[base+7]:=$80; Port[base]:=255; End; Procedure Tt8255.tanca_port; Begin Port[base]:=255; End; End.

3. programa de lectura de datos para la caracterización estática

(67)

f30(:,1)=(f30(:,1)+4.37)/0.0134; f30(:,2)=f30(:,2)*esc; f40(:,1)=(f40(:,1)+4.2)/0.0134; f40(:,2)=f40(:,2)*esc; f50(:,1)=(f50(:,1)+4.59)/0.0134; f50(:,2)=f50(:,2)*esc; f60(:,1)=(f60(:,1)+4.5)/0.0134; f60(:,2)=f60(:,2)*esc;

save 'd:\usuarios\granados\joan\f30.dat' f30 -ascii save 'd:\usuarios\granados\joan\f40.dat' f40 -ascii save 'd:\usuarios\granados\joan\f50.dat' f50 -ascii save 'd:\usuarios\granados\joan\f60.dat' f60 -ascii

[Y,I]=sort(f40);

for k=1 :500 40

k

[Y,I]=sort(Y); Y(:,2)=f40(I(:,1),2); n=size(Y);

for j=1 : n(1)-1 if Y(j+1,1)==Y(j,1) Y(j+1,1)=Y(j+1,1)+0.0001; end end end Xi=linspace(-20,338,180); Yi=interp1(Y(:,1),Y(:,2),Xi); F40=Yi; [Y,I]=sort(f50);

for k=1 :500 50

k

(68)

Yi=interp1(Y(:,1),Y(:,2),Xi); F50=Yi;

[Y,I]=sort(f60);

for k=1 :500 60

k

for j=1 : n(1)-1 if Y(j+1,1)==Y(j,1)

Y(j+1,1)=Y(j+1,1)+0.0001; end

end end

Xi=linspace(-20,338,180); Yi=interp1(Y(:,1),Y(:,2),Xi); F60=Yi;

cur=linspace(30,60,4) surf(cur,Xi,mat) shading interp view(-85,20)

zlabel('torque (Nxm)')

title('torque vs current & slip angle') xlabel('current (Amps)')

(69)

A2 Motor de flujo axial

A2.1 Simulaciones en el caso de polos de igual polaridad

encarados:

Fx= 5.4104 N/m

[image:69.595.81.507.179.415.2]

(70)

Fx= 7.441 N/m

[image:70.595.81.510.74.306.2]

Simulación del caso de

figura 2 polos del mismo signo enfrentados y rotor desplazado 4mm de la posición de inicio.

Fx= 4.0157 N/m

Simulación del caso de

(71)

figura 4 Simulación del caso de polos del mismo signo enfrentados y rotor desplazado 12mm de la posición de inicio.

Fx= -1.7422

(72)

Fx= -2.5613

(73)

[image:73.595.103.524.92.316.2]

Fx= -0.01147 N/m

0.0000 0.0483 0.0966 0.1449 0.1932 0.2415 0.2898 0.3381 0.3864 0.4347 0.4830 B( T)

Flux Density

(74)

0.0000 0.0483 0.0966 0.1449 0.1932 0.2415 0.2898 0.3381 0.3864 0.4347 0.4830 B( T)

Flux Density

Fx= 5.6014 N/m

- Simulaciones de polos de diferente polaridad encarados:

Fx= -20.893 N/m

(75)

[image:75.595.118.542.111.342.2]

figura 12 Simulación del caso de polos de distinto signo enfrentados y rotor desplazado 8mm de la posición de inicio.

Fx= 34,601 N/m

(76)

[image:76.595.114.536.75.321.2]

figura 14 Simulación del caso de polos dedistinto signo enfrentados y rotor desplazado 16mm de la posición de inicio.

Fx= 38.361 N/m

[image:76.595.100.528.84.702.2]

(77)

[image:77.595.98.534.98.668.2]

(78)

[image:78.595.104.536.96.316.2]

figura 18 Simulación del caso de polos de disitnto signo enfrentados y rotor desplazado 32mm de la posición de inicio.

figura 19 Simulación del caso de polos de disitnto signo enfrentados y rotor desplazado 36mm de la posición de inicio.

(79)

A2.2 Sistema de medidas para la caracterización estática

-Sistema de montaje y sujeción de todos los componentes

Todo el motor estará sumergido en nitrógeno líquido. Para ello se dispone de una caja de poliestireno expandido en la que se situaran los dos semiestátores y el rotor.

Figura 1 Placa base de fibra de vidrio, situada en el fondo del contenedor de nitrogeno. Sujeta 8 varillas roscadas en las que se efectuaran las conexiones de los devanados entre si y a la alimentación del motor.

En la parte inferior de la caja se colocará una placa de fibra de vidrio a la que se le han practicado 6 agujeros. Por estos agujeros se pasarán 8 varillas roscadas de acero inoxidable (Figura 1), que se sujetarán a la placa mediante dos contratuercas y arandelas. Estas varillas servirán para efectuar todas las conexiones eléctricas del sistema trifásico que forman los devanados del motor.

Cada una de los dos semiestátores se sujetarán mediante 6 tornillos a unas piezas de acero de forma triangular. Estas irán sujetas entre si por tres barras roscadas de M-10 que permitirán, si se requiere, modificar la posición relativa de

Fig. 2 Fotografia del semiestátor y la plancha de acero

(80)

ambos semiestátores. La figura 3 muestra el esquema de un semiestátor y la pieza que lo sujeta.

Esta pieza ha sido realizada cortando una plancha de 5mm de acero para conseguir un conjunto con suficiente rigidez para que aguante el peso del semiestátor y las fuerzas de origen magnético. La deformación que se producirá en el centro debe ser suficientemente pequeña para no afectar el movimiento del rotor.

Para generar el par de fuerzas se ha dispuesto una rueda de madera sujeta al eje del motor mediante un cojinete que la centra, pero no afecta la transmisión del par. Esta rueda lleva sujeta mediante tornillos una pieza de aluminio que es la encargada de empujar la célula de carga sujeta al eje. Así se transmite y se mide el par simultáneamente.

Tal como se muestra en la figura 4, el par de fuerzas se ejerce mediante un cable previamente enrollado en la periferia de la rueda y dos ruedas auxiliares. Un motor de corriente alterna se encarga de realizar el movimiento del cable, que se mantiene tensado mediante un contrapeso de 1 kg. aproximadamente.

El conjunto de piezas están sujetadas a una estructura de ángulo de hierro ranurado mediante tornillos y arandelas. Algunas de las uniones se han realizado con soldadura para garantizar dimensiones y rigidez. Una de las dos ruedas auxiliares se ha sujetado con una varilla de acero con un fuerte peso en la base. La rigidez del conjunto se ha completado con una barra de hierro ranurado sujeta al resto de la estructura mediante tornillos y abrazaderas.

(81)

Fig. 4 Dibujo esquemático del montaje efectuado para la caracterización estática del motor con el rotor superconductor. Se puede ver la situación de la pieza de empuje, la célula extensométrica en el eje del motor, y el potenciómetro acoplado a una tercera rueda , así como el sistema de arrastre formado por el motor, el cable y el contrapeso.

(82)

Fig. 5 Fotografia de la estructura donde pueden verse las partes indicadas anteriormente.

-Fuente de alimentación

El sistema de alimentación debe proveer las tensiones adecuadas para la célula de carga, el potenciómetro , y los sistemas de acondicionamiento de la señal.

Para ello se usará una fuente de alimentación de corriente continua comercial que dispone de salidas fijas de +15- 0 - -15 V, 2A y una salida que puede variar entre 0 y 30V, 2A. Esta última regulable en intensidad y ambas protegidas contra cortocircuitos.

- Célula de carga:

Se dispone en el ICMAB de una célula UTILLCEL, Mod 120 de 10 kg. El catálogo del fabricante indica que hay que alimentarla a 10V. Para alimentarla se usará la fuente regulable descrita en el parágrafo anterior.

Para la calibración de la misma se ha usado un dinamómetro de Fmax = 15 kp. Con el que se ha aplicado fuerza sobre el sistema célula de carga-amplificador. La salida del amplificador se ha conectado a la placa de adquisición de datos que se ha encargado de registrar los datos de salida del amplificador. La lectura de los mismos se ha realizado mediante un programa de lectura y tratamiento de datos (Dades.txt- Anexo 3). Además se ha puesto un voltímetro en

A B

Fig. 6 Esquema de conexiones de la célula de carga, donde pueden verse las entradas de alimentació( +in y –in) y las salidas (+out y – out).

(83)

paralelo para comprobar la validez de los mismos durante la fase de comprobación. Los datos obtenidos se muestran el la siguiente tabla y se han representado en la figura 7

Fuerza (N) 1 2 3 4 5 6 7 8 9 10 11

Tensión (V) 0.17 0.27 0.41 0.55 0.67 0.80 0.94 1.03 1.23 1.38 1.5

0 2 4 6 8 1 0

0 2

C a l i b r a c i ó n d e l a c é l u l a d e c a r g a

T

e

nsió

n (

V

)

F u e r z a ( N )

Fig. 7 Calibración de la célula de carga, donde puede apreciarse la linealidad de la misma para el rango de valores que se van a usar en la caracterización estática

-Acondicionamiento de la salida de la célula de carga

La placa de adquisición de datos conectada al ordenador tiene un margen de lectura de de +5 a –5 V. Para el rango de fuerzas que esperamos en nuestra prueba, las tensiones de salida de la célula son del orden de –4mV a +4mV. El circuito interface deberá multiplicar por 1000 estas tensiones para adaptarlas a las de entrada de la placa de adquisición de datos. La figura 8 muestra este circuito amplificador.

La siguiente tabla muestra los resultados obtenidos y la gráfica de los mismos permite observar la linealidad de la respuesta del sistema en el rango de valores en los que va a ser usada.

Fig. 8 Circuito amplificador para adaptar la señal procvedente de la célula

(84)

Se desea obtener la gráfica posición- par para distintos valores de corriente de alimentación. Puesto que lo que se mide es la fuerza ejercida sobre la célula de carga, hay que multiplicar este valor por la distancia de la célula al eje y así se obtiene el par. A partir de la lectura de tensión en voltios hay que realizar las siguientes operaciones:

N V célula

la de

pendiente 0.1363636

11 5 . 1

: =

Y para cada lectura de tensión:

) ( ) ( ) (

: F N

N V célula la de pendiente V tensión de lectura célula la sobre fuerza =

Y teniendo en cuenta que la célula se encuentra a 160 mm del eje:

) ( ) ) ( ( 1733 . 1 ) ( 16 . 0 1363636 . 0 ) ( ) ( : m N V m N V tensión de lectura tensión de lectura m d N F

par × = × = × =

τ

Este valor debe introducirse en el programa de lectura de datos para poder determinar el par a partir de la lectura de la tensión del amplificador de la célula de carga

-Lectura de la posición angular

Para la lectura de la posición angular, se gira la rueda del potenciómetro hasta que el contrapeso esta en su posición más alta. Esta es la posición que se tomará como referencia cero. En este punto se lee la tensión que proporciona el potenciómetro. Se da una vuelta completa al motor y se vuelve a leer la tensión. Con estas dos lecturas, se realiza la siguiente operación:

Lectura inicial: -5.079 V

Lectura tras una vuelta: -0.164 V

) ( 134 . 0 ) ( ) ( 164 . 0 079 . 5 360

: lecturaV lectura Grados

V Grados girado

Angulo × = ×

−

Este valor debe introducirse en el programa de lectura de datos para obtener la posición en grados a partir de la lectura en voltios del potenciómetro. Si además quiere tomarse el primer valor como cero, debe sumarse a todas las lecturas el valor de la primera lectura cambiada de signo. El programa Dades.txt (anexo 1), es el encargado de la lectura de estos datos.

(85)

A2.3 Sistema de medidas para la caracterización dinámica

- Sistema de freno para variar el par:

Se ha utilizado un freno de polvo magnético acoplado al eje del motor. Esencialmente consta dos partes móviles entre las que hay aceite con polvo de hierro y una bobina por la que se hace pasar intensidad. La bobina está situada de forma que puede provocar un campo magnético sobre el espacio ocupado por el polvo magnético. Una de las partes se sujeta al eje y la otra a una célula de carga.

Al incrementar la intensidad, las partículas de hierro se entrelazan, incrementando la viscosidad aparente del conjunto. Así la fuerza

del eje se transmite a la parte que presiona la célula de carga. La fuerza de esta célula por la distancia al eje mide el par. El freno comercial que hemos utilizado es .

Fig. 1 Esquema del freno de polvo magnético usado para la caracterización dinámica

FBB TYPE FRAT 120 FTQR 120

Tensión máxima: 24V c.c.

Par máximo: 12 Nm

Potencia máxima: 200W

Imax: 0.51A

- Control del freno:

Para controlar el freno se ha usado la fuente de intensidad programable KEITHLEY 228A a la que se ha conectado la bobina del freno de polvo magnético.

[image:85.595.337.533.159.308.2]

(86)

TEP 0 1

OLTS 0 0 0 0 0 0 0 0 0 0 0

MP .05 .1 .15 .2 .25 .3 .35 .4 .45 .5

EG.

TEP 2 3 4 5 6 7 8 9 0 1

OLTS 0 0 0 0 0 0 0 0 0 0

MP. .45 .4 .35 .30 .25 .20 .15 .10 .05

EG.

- Alimentación del motor.

Para la alimentación del motor se ha diseñado un ondulador trifásico controlado desde un ordenador. Esto permitirá modificar la frecuencia si se requiere en pruebas posteriores y en todo caso, permitirá conocer la posición del campo generado en el estator en cada instante. Con la lectura de la posición del rotor podremos conocer el ángulo de carga para cada par. Para ello se ha pensado en un ondulador como el que se muestra en la figura 6.67

Para cada

interruptor mostrado en la figura se han elegido 4 transistores Rectifier hexfet Power mosfets IRFP054, cuyas características principales se muestran en

la siguiente tabla. Se montarán sobre una superficie de aluminio a la que se unirán mediante

tornillo y tuerca. Esta superficie servirá de refrigerante, así que entre los transistores y la misma se colocará una capa de silicona que mejore la transmisión de calor. Para cada transistor se ha previsto una corriente que puede variar desde los 280 A para 25 ºC a los 256 A a 100 ºC

Fig 2 Esquema del ondulador usado para la caracterización dinámica del motor

Vbr D-S RDS(0n) Id (25ºC) Id(100ºC) Pd IRFP450 60 V 0.014 Ω 70 A 64 A 230 W

(87)

por ello que en las siguientes pruebas se ha alimentado el conjunto con 4 baterias de

[image:87.595.54.565.234.583.2]

40A-Hora. Según las necesidades podrán conectarse en serie y en paralelo y se dispondrá un circuito para la recarga de las mismas durante los periodos en los que no se realicen las pruebas. Esta es la alimentación dibujada en el circuito de la figura 3.

Fig 3 Esquema de una de las tres fases del ondulador montado para la caracterización dinámica del motor

- Transformador-rectificador-filtro:

(88)

KA/m. La pendiente de la línea de rebote (permeabilidad de rebote) es prácticamente tangente a la curva de histéresis, no existiendo prácticamente desmagnetización en el funcionamiento normal del motor como motor síncrono. Es por ello que a pesar del gran entrehierro, esta máquina tenga una inductancia equivalente relativamente grande y pueda conectarse, durante los transitorios de aceleración, a una tensión de 220V.

Si se sustituyen los imanes del rotor por superconductores, el caso es totalmente distinto y ahora se requiere una adaptación de impedancias. La tensión de alimentación depende de la intensidad que se quiera hacer pasar por el motor. Ya vimos que el conductor de cobre a temperatura de ebullición del nitrógeno permitía el paso de hasta 1700 A. Para nuestros propósitos (unos 120 A como máximo) deberemos disponer de un sistema regulador de tensión. Para ello se dispone un autotransformador trifásico que regula la tensión de entrada y un transformador toroidal en el que se ha devanado un segundo arrollamiento de 40 vueltas con una toma central.

Fig 4 Esquema de la fuente de c.c. para alimentar el ondulador

Los transformadores son de tipo toroidal. Se han usado 3 toriodales de INTELSA de 220 v en el primario y dos secundarios de 22V 5A.

Para nuestros propósitos se han bobinado nuevos secundarios formados por 10 hilos de cobre de 1mm en paralelo con los cuales se han dado 40 vueltas con una toma intermedia. Las tensiones en estas condiciones son de 7.6 V en cada mitad del secundario.

- Para cada rectificador de la figura se han usado 3 rectificadores en paralelo tipo FAGOR FB5006

B250/220-50

Cada uno puede proporcionar una intensidad media de 50A

- El filtro esta constituido por 36 condensadores SPRAGUE

EXTRALYTIC de 75 VDC y 4500µF cada uno, lo que hace un total de 162000

µF

- Para la conexión del primario del autotransformador trifásico a la red se ha usado un INTERRUPTOR magnetotérmico de MERLIN GERIN, MULTI9, de 4 polos, 380 V. y 5 A.

-Sensor para la determinación de la posición del rotor

- El sensor para determinar la posición del rotor se ha realizado a partir de las siguientes piezas:

hoja de poliéster con 360 divisiones

(89)

soporte ( madera contrachapada de 1 mm) con interior de celulosa para reducir el rozamiento

La figura 6.70 muestra las diferentes partes del sensor de posición y el esquema del conjunto. El papel de acetato con las 360 divisiones se sujeta a la parte superior del eje mediante un pequeño imán. Para sujetar la célula y dirigir el papel de acetato, se ha construido una caja de madera contrachapada, cuyo interior se ha forrado con celulosa para reducir el rozamiento.

Cada vuelta del rotor se detectan 360 pulsos que tras amplificarse, son

leídos por la placa de adquisición de datos. El resultado es que se conoce la posición del rotor con una resolución de un grado.

Fig 5 Esquema del sensor para medir la posición del rotor.

- Amplificador para le célula fotoeléctrica:

La salida de la célula fotoeléctrica se amplifica y se hace cuadrada para tener un pulso cada grado. Tras fijarla al nivel de 5V, se manda a la entrada de la placa de adquisición de datos y es leída por el programa.

[image:89.595.95.520.225.561.2]

(90)

Fig. 6 El Amplificador para la célula fotoeléctrica toma como tensión umbral 1V. Tras multiplicar la salida por 25,la señal es cuadrada y fijada a 5V.

- Amplificador para célula de carga:

Para la célula de carga se ha usado un amplificador diferencial que multiplica la entrada por 1000.

Fig. 7 Amplificador diferencial para la señal procedente de la célula de carga. La salida se puede poner como Vout= (V+out – V-out)1000

(91)

(92)

A1.1 Funcionamiento del motor de flujo radial

Inicialmente el motor se enfría sumergiéndolo en nitrógeno líquido. Esto se hace para que el rotor se enfríe en ausencia de campo magnético (zero field cooled). Posteriormente, se alimenta el estator. La simetría del campo magnético creado hace que el rotor se estabilice y centre.

La alimentación de las bobinas del estator se hace secuencialmente con pulsos cuadrados de tensión. La forma de alimentar cada una de las fases se muestra en la

figura 1

(a) (b) (c) (d)

(e) (f) (g) (h)

Fig. 1 Alimentación de las diferentes fases del estator en función del tiempo

En presencia de un campo magnético, los materiales superconductores se magnetizan creándose una red de vórtices de corrientes superconductoras. La creación de nuevos vórtices o la destrucción de ellos comporta un consumo energético. Al producir un campo magnético en el espacio ocupado por un superconductor, se provoca la magnetización del mismo y ello implica una energía asociada al proceso de desplazarlo. Como:

F dU

dx

= (1)

(93)

Siempre que cuando se realice un desplazamiento exista una variación de energía, se producirá una fuerza. Esto es lo que le ocurre a un superconductor cuando se acerca a un campo magnético, sufre una fuerza de repulsión que le impulsa hacia las zonas donde su magnetización se mantiene constante.

La curva de magnetización B(H) del superconductor está representada en la figura 2. Como se puede observar, presenta un comportamiento claramente histerético. La energía almacenada en el superconductor es el área de la curva de magnetización, según la

ecuación 2 : Fig. 2 Ciclo de histéresis del YBCO

∫

=

V

m HBdV

U

2 1

(2)

Si el rotor es colocado en el interior del estator, se magnetiza debido al campo existente. De esta forma, el punto de trabajo de la curva de magnetización se desplaza, lo que implica una variación de la energía en el superconductor.

La corriente de alimentación crea cuatro polos magnéticos, que inducen otros cuatro en el rotor. El superconductor queda entonces fijo en el interior del estator. Cualquier alteración de su posición relativa al campo supone un cambio del punto de trabajo en la curva anterior, lo que implica la aparición de una fuerza de recuperación según la ecuación 3:

(3) dV B M F V

∫

∇ = ( ) r

(94)

τ ϕ

= dU

d (4)

Donde τ es el par del motor

ϕ es el ángulo de giro

Gracias a la histéresis de magnetización, se produce un par que es el responsable del giro del rotor. Por todo lo explicado anteriormente, inicialmente el motor se comporta como un motor de histéresis.

Cuando el rotor está magnetizado, puede alcanzar el régimen de sincronía. El punto de trabajo de la curva de magnetización no varía, por lo cual, a partir de este momento desaparecen la pérdidas en el rotor y su par motor dependerá sólo del flujo atrapado, del flujo inductor y del ángulo que forman rotor y campo inductor.

A1.2 Sistema de medidas

La figura 1 muestra una fotografia del sistema montado para efectuar las medidas

[image:94.595.78.419.436.737.2]

La figura 2 és un esquema del montaje efectuado.

(95)

Alimentación de los motores paso a paso: El sistema consta de una fuente de alimentación continua de 40V y 2A, un sistema excitador de los motores y de un ordenador (figura 3).

Fig.4 Sistema de desplazamiento del rotor

[image:95.595.95.514.107.518.2]

(96)

- Fuente de alimentación

La fuente consta de un transformador de 220V a 24V (2 A), un puente de diodos y un condensador de 4700 µF (figura 4)

24 V

Fig.6 Esquema circuital de la fuente de alimentación para los motores paso a paso

La señal de salida obtenida es de tensión continua, de 40V y 2A de intensidad, lo que es suficiente para alimentar los dos circuitos excitadores (uno para cada motor).

-Excitador para motor paso a paso

(97)

[image:97.595.87.514.142.494.2]

El sistema representado en la figura 5, controla motores bipolares de dos fases, como es el caso de los dos motores paso a paso utilizados. La corriente máxima por fase es de 2A, lo que es más que suficiente.

Fig. 7 Sistema de excitación de los motores paso a paso

El corazón de este montaje son un par de circuitos integrados de SGS-Thomson Microelectronics, el L297 y el L298. El L297 genera las señales de control para cada una de las dos fases de un motor bipolar. Mediante la programación en sus dos entradas (compatibles TTL) permite la selección del sentido de rotación y del tamaño del paso (paso completo o semipaso). Según el caso, el motor avanza o retrocede un paso, o un semipaso, en el flanco descendiente de la señal aplicada a la entrada de reloj (CLK).

(98)

La amplitud del rizado residual (ripple) presente en la corriente del estator depende de la autoinducción del mismo así como del nivel aplicado en la patilla mode. Con un nivel alto en dicha entrada, las salidas del L298 se ponen en estado de alta impedancia durante el periodo de funcionamiento de los diodos de protección, que entran en conducción porque la tensión instantánea en bornes de los bobinados del estator sobrepasa ligeramente la tensión de alimentación, de forma que el campo del estator cae rápidamente.

Cuando la entrada MODE está a nivel bajo, uno de los transistores internos del L298 permanece activo durante el período de conducción de los diodos, lo que tiene como efecto mantener a un valor relativamente débil la tensión de freno en bornes del bobinado del estator, lo que conlleva una disminución menos importante de la fuerza del campo del estator, reduciendo así la amplitud del rizado residual. Esta opción permite mantener a una intensidad suficiente la corriente de control de un motor que presente una autoinducción de estator relativamente baja.

El divisor incorporado en el esquema, 4024, está destinado a proporcionar una señal de reloj cuando la salida del ordenador desde el que se controla el circuito no puede ser programado para conmutar a la velocidad de paso necesaria. El selector de velocidad, K1, permite escoger entre una de las siete frecuencias (velocidades de paso) posibles. Se puede colocar el dispositivo divisor de frecuencia fuera de servicio mediante la aplicación de un nivel bajo en la entrada GATE disponible sobre el circuito impreso. La entrada CLOCK funciona en este caso como una salida, lo que permite al ordenador seguir el número de pasos efectuados. Si se aplica un reloj externo a la placa de control se podrá simplemente eliminar 4024.

Control por el ordenador

(99)

Del ordenador se han obtenido los controles de todas las señales. Igualmente, ha proporcionado la señal continua de alimentación de 5V y GND (la cual es común con la GND de la fuente de 40 V).

Las señales de GATE, SYNC, RESET, H/F y ENABLE no han sido conectadas, dejándose en circuito abierto, ya que su uso no ha sido necesario.

La señal CW/CCW y CLK se controlan desde el programa en pascal, enviando las correspondientes señales en forma de pulsos.

Sistema de acondicionamiento de la señal

Hay dos señales de entrada a la tarjeta del ordenador, la que proviene de la sonda Hall y la del potenciómetro. La alimentación de ambos se hace con una fuente de tensión continua común de tres salidas: -12, 0 y +12V.

Para su correcta lectura, el voltaje de entrada a la tarjeta del ordenador ha de estar entre -5 a +5V. Para ello, se necesita un sistema que amplifique la señal cuando sea necesario y la sitúe entre los valores comentados anteriormente, pero sin sobrepasarlos. Para que la tarjeta no tenga sobretensiones que puedan dañarla, se ha colocado un limitador de tensión a ±5V a la salida de cada una de las señales.

El sistema de amplificación de la sonda es más delicado, ya que la señal es más débil y el ruido la afecta mucho más. Así que, se ha utilizado un amplificador de instrumentación (INA 110 Burr Brown).

-Acondicionamiento de la señal del potenciómetro

(100)

Fig.8 Diagrama de bloques del sistema de acondicionamiento de la señal del potenciómetro

A continuación se explicará con más detalle cada uno de los bloques.

- Fuente de alimentación

La fuente de alimentación suministra una tensión continua mediante tres salidas de +12, 0 y -12V. Para su construcción se ha utilizado un transformador de 220 a 12V y de 0.75 A, dos puentes de diodos, cuatro condensadores y dos referencias de tensión (figura 7)

Fig. 9 Esquema de la fuente de alimentación

El transformador convierte la señal proveniente de la red eléctrica (220V, 50Hz), en dos señales alternas de la misma frecuencia y de amplitud 12V. El objetivo de los puentes de diodos es transformar las señales de corriente alterna en continuas de 12 V, una de signo positivo y otra de signo negativo.

Posteriormente, el regulador de voltaje positivo (7812) convierte la señal continua de entrada en una de valor +12V. El regulador de voltaje negativo (7912) tiene la misma función, pero en este caso la señal de salida es de -12V. Por último, la función de los condensadores es filtrar la señal eléctrica.

(101)

El potenciómetro utilizado es multivuelta (diez vueltas), y con una resistencia de 1KΩ. En las medidas que se han realizado, se ha girado el rotor únicamente vuelta y media, por lo que la variación de resistencia requerida es de 150Ω. La sensibilidad del potenciómetro es pues de 150Ω/540º, lo que es igual a 0.28 Ω/º.

Los dos terminales del potenciómetro entre los que hay una resistencia fija de 1KΩ se han conectado entre los terminales de tensión +12 y -12V, por lo que la tensión de alimentación aplicada es de 24V. La alimentación se ha buscado simétrica porque la tensión de entrada a la tarjeta del ordenador es también simétrica, variando entre ±5V.

Fig.10 Conexión del potenciómetro

El tercer terminal de resistencia variable junto con la señal GND forman la tensión de salida. Cuando VO es nula, el potenciómetro se encuentra en el punto central, es decir, con una resistencia de 500Ω.

Amplificación

La excursión de la medida es de 1.5 vueltas, lo que indica que el extremo inferior se encuentra a -0.75 vueltas y el superior a +0.75 vueltas. Como la tensión de alimentación es de 24 V:

Extremo inferior = -0.75 vueltas 24V 10 vueltas

× =−1 8. V (5.1)

Extremo superior = 0.75 vueltas 24 V 10 vueltas

× =1 8. V (5.2)

(102)

Ganancia del amplificador = 5V 1.8V

±

± =2 78. (5.3)

El amplificador utilizado ha sido un no inversor como se muestra la figura 9

Fig. 11 Esquema del amplificador de la señal del potenciómetro

La relación entre la tensión de salida y la de entrada en un amplificador no inversor, como ya se conoce, viene dada por la ecuación 5.3:

V R

R V

o =(1+ 2

1 i

) (5.4)

Como la ganancia había de ser de aproximadamente de 2.78, los valores de las resistencias utilizados fueron de 1KΩ para R1 y un potenciómetro de 2.2KΩ para R2. El amplificador que se hizo servir era del tipo OP07CP.

- Limitador de tensión

(103)

Fig.12 Esquema del limitador de tensión

En este caso, los amplificadores actúan como comparadores. Cuando la amplitud de la señal de entrada está entre las referencias, la señal de salida es igual que la de entrada. Si supera las referencias, en cambio, la señal de salida es igual a una de las referencias.

Se ha utilizado un TL072, ya que el circuito integrado contiene dos amplificadores operacionales. Los diodos son de baja corriente de fugas.

La referencia de +5V se ha conseguido con un circuito integrado REF02, el cual da una tensión continua muy estable de esa amplitud. Para obtener la referencia de -5V se ha invertido la señal de salida del REF02 con un inversor de tensión (figura 11) [Thom].

Fig.13 Inversor de tensión para la referencia de -5V.

[image:103.595.171.450.78.305.2]

(104)

V R

R V

o = − 2

1

i (5.5)

Donde R1 = R2 = 1KΩ.

Acondicionamiento de la sonda Hall

El diagrama de bloques del funcionamiento de la sonda se muestra en la figura 12 Consta de una fuente de alimentación, una sonda Hall, un sistema de amplificación de la señal y un limitador de tensión.

Fig. 14 Diagrama de bloques del funcionamiento de la sonda Hall

A continuación se comenta con más detalle cada uno de los bloques.

- Fuente de corriente