Realizarea comenzii numerice a unei mașini de [610002]

1 | P a g e
Realizarea comenzii numerice a unei mașini de
prelucrare prin eroziune electrică cu electrod filiform

Capitolul I. Structuri hard de conducere a mașinilor de prelucrare prin
eroziune electrică cu electrod filiform

1.1 Considerații preliminare

Pentru transmiterea datelor între calculator și utilajul de prelucrare s -a utilizat interfața
paralelă de tip LPT: utilizarea pinilor (respectiv biților diferiților registrii) va fi analizată în
continuare în funcție de cele două variante de comandă numeri că utilizată:

I – prima variantă în care se comandă direct convertoarele de putere pentru comanda celor
două motoare pas cu pas (MPP) corespunzătoare celor două axe x și y; în acest caz sunt necesari
numai patru biți pentru comanda acestor convertoare de putere;

II – cea de -a doua variantă în care se utilizează structura inițială de comandă a MPP
proiectată la lansarea mașinii și anume: calculatorul comandă două memorii EPROM, care la
rândul lor adresează convenabil amplificatoarele de putere.; în această situație sunt necesari 8 biți
pentru adresarea EPROM -ului și anume 4 pentru fiecare axă.
În cazul de față vom folosi circuitul integrat LMD18245.
LMD18245 este un integrat de amplificare și în același timp driver pentru un motor de
curent continuu și mo tor pas cu pas. În aplicația noastră am folosit două motoare pas cu pas.
Principalele caracteristici ale integratului sunt:
-tensiunea de alimentare de maxim 55V și un curent de 3A
-protecție la supracurenți
-protecție la temperatu ră prin oprire(ieșirile pe OFF) la 1550C
-protecție asupra tensiunii

2 | P a g e
Principiul de funcționare este prezentat în figura 1.

Figura 1 Schema de funcționare a circuitului

Pentru aplicația noastră avem nevoie de următoarele semnale:

– Direction – folosit pentru stabilirea sensului
– semnalele M1 ,M2 , M3 , M 4 –pentru comanda fazelor motorului pas cu pas
Pentru aplicația prezentată avem nevoie de două circuite LMD18245 pentru alimentarea
motorului pas cu pas bipolar.

Schema de conectare este prezentată în figura 1.1.

3 | P a g e

Figura 1.1 Schema de conectare a circuitului

Observație: Impulsurile BREAK nu sunt folosite în cazul aplicației noastre, ele fiind
legate la masă.
Comanda driverului LMD18245 este realizată , de un integrat de tipul GAL care este o
arie programabilă de porți și care realizează comanda fazelor motorului precum și generarea
impulsurilor de direcție pentru cele două circuite LMD18245.Generarea direcției se face în
funcție de un semnal de sens ve nit de la calculator(mai exact de la portul paralel).Generarea
semnalelor de alimentare a fazelor se va face în funcție de frecvența de tact venită de la
calculator.

4 | P a g e

Figura 1.2 Modulul de comandă al motorului pas cu pas, folosit la mașina de prelucrare prin eroziune
electrică de tip ELEROFIL 10CNC

1.2 Schema bloc de principiu

În figura 1.3 se prezintă schema -bloc de interfațare între echipamentul tehnologic și
calcu lator, în varianta I se remarcă existența următoarelor canale input/output de vehiculare a
informațiilor:

1.3 Semnale utilizate în cadrul interfațării

O primă categorie de informații se vehiculează prin intermediul interfeței paralele LPT a
calculator ului:
– 2 linii a câte 2 biți fiecare (tact și sens) pentru comanda convertoarelor de putere aferente
celor 2 axe;
– 1 bit pentru citirea semnalului de avarie care include (însumează logic) nerespectarea
mai multe condiții necesare pentru derularea proce sului tehnologic: ruperea firului, atingerea
limitatorilor, pierderea proprietăților lichidului dielectric,..
Observație : În cadrul programului de comandă manuală, același bit este folosit pentru
recepționarea impulsurilor de nul, utilizate în cazul opera țiilor de centrare.
– 1 bit pentru comanda (oprire/pornire) generatorului de eroziune, comanda care se
efectuează strict în concordanță cu derularea programului (există momente stricte în care trebuie
oprit generatorul, de exemplu la apariția unei avarii. …);
– 1 bit intrare pentru sesizarea apariției unui scurt;

5 | P a g e
– 4 biti citiți de la pupitrul de comandă manuală, reprezentând comenzi de deplasări
manuale pe câte o axă (x+, x -, y+, y -), în situația în care comanda se face de la echipamentul de
comandă al mașinii;

Acești 4 biti sunt utilizați numai în cazul generării prin calculator a deplasărilor manuale,
fiind proiectată și situația generării acestor deplasări printr -un oscilator.

O a doua categorie de informații se vehiculează prin intermediul plăcii de dezvoltare , care
conține trei numărătoare reversibile pe 32 de biți (această placă împreună cu circuitele
specializate fac obiectul altei lucrari); utilizarea canalelor (numărătoarelor) se face în modul
urmator:

– primele două canale (numărătoare) sunt utilizate pentru preluarea informațiilor de la cele
două traductoare numeric incrementale liniare, aferente celor două axe x și y; fiecare dintre aceste
două traductoare generează două trenuri de impulsuri A și B decalate între el e; precedenta dintre
A și B determină incrementarea, respectiv decrementarea numărătorului, fizic rezultând astfel
sensul deplasării pe axa respectivă;

-al treilea canal (numărător) primește trenul de impulsuri de la generator; conț inutul
acestuia este citit (soft) periodic, existența unei diferențe între două citiri succesive, reprezentând,
de altfel, condiția de continuare a mișcării de avans (continuarea în fapt a procesului -tehnologic);

Pentru prelucrarea semnalelor A si B (tr enuri de impulsuri dreptunghiulare decalate la 90
de grade in funcție de sensul de mișcare) ce vin de la traductoarele de poziție s -au utilizat 2
circuite numărător LS 7166, si un al treilea pentru numărarea impulsurilor de la generator.
Circuitul de bază folosit pentru interfațarea traductorilor cu calculatorul este circuitul numărător
LS 7166.

6 | P a g e

Figura 1.4 Circuitul numărător LS 7166

Circuitul Ls 7166 este un numărător în cuadratura pe 24 de biți costruit in tehnologie
CMOS, care poate fi programat să lucreze in mai multe moduri( crescator, descrescator, in binar,
în cod BCD, ceas, un singur ciclu).
Circuitul are 20 pini iar semanlele aferente se pot observa în figura 1.4.

OPOTGenerator de
impulsuri
MasinaAcționare y
LC MPP
Acționare x
LC MPP
Interfa ță MPP Interfa ță mașinăComenzi
manualePornit/Oprit
Deplas ări x/y
Reset
P/O Generator
Scurtcircuitorigine y
origine x
avarie
Interfață paralelă LPTUCP
P
Soft
conducere
PeriferieNum ărător3
Num ărător2
Num ărător1
Placă de
dezvoltarePoziție y
Poziție xFrecven ță avans
y
y
PCBUS PC
2
2
2
2
244
4
Figura 1.5 Schema -bloc de interfațare între
echipamentul tehnologic și calculator

7 | P a g e

Modul de lucru este setat scriind un cuvânt de control în registrul de control (ICR). Există
3 regiștri de control, a câte 6 biți (2 biți sunt folosiți pentru a selecta registrul dorit) și unul cu 2
biți prin care se setează caracteristicile funcționale ale circuitului.

Pe lângă registrele de control mai exista registre de stare (OCR – Output status regist er),
registrul de presetare (PR – Preset register), registrul de cuadratură (QR -Quadrature register).
Cuvintele de control și de date sunt scrise în LS7166 prin magistrala de date (Data -Bus).

• Regiștrii circuitului LS 7166

Regiș tri interni sunt accesibili prin magistrala de intrare/ieșire (D0 -D7) pentru scriere sau
citire când semnalul CS=0. Semnalul de intrare C/D face selecția intre registrul de control
(C/D=1) și registrul de date (C/D=0) în timpul operației de scriere sau citire.

1) PR (Preset register)

PR este portul de intrare pentru CNTR (numărător). Numărătorul este încărcat cu date pe
24 de biți prin registrul PR. Datele sunt, inițial, încărcate în PR in 3 cicluri, î n ordinea aceasta:
octetul 0 (PR0), octetul1 (PR1) și octetul 2 (PR2).
Pointerul de adresare pentru PR0 /PR1/PR2 este incrementat automat cu fiecare ciclu.
Registrul este accesat cu WRITE când C/D=0 și CS=0

7 – – – – – – – – – – – -0 7 – – – – – – – – – – – -0 7 – – – – – – – – – – – -0

PR2
Byte2 PR1
Byte1 PR0
Byte0

Secvența standard pentru a încărca PR si pentru a citi CNTR (registrul numărător) este
următoarea:
1 → MCR ; Initializează pointerul ce adresează PR
WRITE PR ; Încarca octetul 0 în PR0
WRITE PR ; Încarca octetul 1 în PR1
WRITE PR ; Încarca octetul 2 în PR2
8 → MCR ; Transfera PR lui CNTR

8 | P a g e

2) MCR (Master Control Register – Registrul master de control).
Resetează registrii și încarcă operațiile. Este accesat de semnalul WRITE când C/D =1,
CS=0.

Resetează pointerul de adresă PR /OL
Transferă CNTR la OL (24 biti)
Resetează CNTR, BWT si CYT. Setează bitul SIGN
(CNTR =0, BWT= 0, CYT=0, SIGN=1)
Transferă CNTR la OL (24 biti)
Reseteaza COMPT (COMPT=0)
Master reset. Reset CNTR, ICR, OCCR,
QR,BWT,CYT, OL, COMP .Seteaza PR=FFFFFF
Selectează MCR

3) ICR (Input Control Register – Registrul control de intrare ).
Stabilește modul de lucru.
Este accesat de WRITE când C /D =1, CS=0.

Semnalul A este numărat crescător iar B descrescator
Semnalu A este numărat normal, B determină sensul.
Daca B=0 se va numara cresc ător, iar daca B=1
numărătorul va număra descrescător. (Obs. În timpul
numărării B poat e comuta doar când A =1)
NOP (nici o operație)
Incremetează CNTR cu unu (daca este activat A/B=1)
NOP
Decrementează CNTR cu unu (dacă A/B=1)
Dezactivea ză intrările A/B
Activează intrările A/B
Setează pinul 4 ca reset pt. CNTR
Seteaza Pin4 ca poarta de activare/dezactivare pt. A/B
Setează Pin3 pt.a activa CNTR
Setează Pin3 pt a active OL
Selectează ICR

9 | P a g e
4) Modul de adresare a registrelor

Dezactivează cipul pentru Scriere/Citire
Scrie în Registrul Master deControl (MCR)

Scrie în Registrul Control de Intrare (ICR)

Scrie la registrul control de iesire (OCCR)

Scrie la registrul de cuadratură (QR)
Scrie la registrul de presetare (PR)
Incrementează un contor de adresare

Citește de la poarta de iesire (OL)
și incrementează un contor de adresare

Citește starea registrului de ieșire (OSP)
X = nu contează

5) OSR (Output Status Register – Registrul Stare de iesire)

Indică starea numărătorului. Este accesat de READ când C/D =1, CS=0.

BWT. Borrow Toggle Fli -Flop. Basculează când CNTR
este depasit negativ generând un împrumut
CYT. Carry Toggle Flip -Flop. Basculează când CNTR
este depășit pozitiv, generând un transport (carry)
COMP. Compare Toggle Flip -flop. Basculează când
CNTR =PR
SIGN. Sign bit. Devine zero (=0) când CNTR este
depășit negativ
Devine unu (=1) când CNTR este depășit pozitiv
UP/DOWN. Indicatorul direcției de numărare în mod
cuadratură
U =nedefinit

10 | P a g e

6) OL (Output latch – registru/poartă de ieșire pentru numărător)

Acest registru este de fapt o poartă de ieșire pentru numărător ( CNTR) Valoarea pe 24 de
biți din numarator poate fi accesată efectuând în prealabil, un transfer de la CNTR la OL iar
apoi citind în trei cicluri de la OL octeții OL 0, OL1,OL2. Pointerul de adrese pentru OL este
automat incrementat cu fiecare ciclu de citire.
Este accesat cu READ cand C/D =0, CS=0.

Secven ța stanrd penutru acces ș i citire OL:

3→ MCR ;
READ OL ;
READ OL ;
READ OL ; Resetează pointerul de adresare al OL si transferă
CNTR la OL
Citește octetul 0 șin incrementează adresa
Citește octetul 1 si incrementează adresa
Citeș te octetul 2 si incrementează adresa

11 | P a g e

7) QR (Quadrature Register – Registrul Cuadratură)
Selectează modul de numărare în cuadratură.
Este accesat de: WRITE cand C/D=1, CS=0 .

Dezactivează modul cuadratură

Activează modul cuadratură x1

Activează modul cuadratură x2

Activează modul cuadratură x4

Selectează QR
X= Nu conteaz ă

8) OCCR (Output Control Register – Regist rul control de iesire)

Inițializează CNTR si modul de ieșire al numărătorului.
Este accesat de: WRITE cand C/D=1, CS=0.

12 | P a g e

Modul binary de numărare
Modul BCD de numarare
Modul normal de numărare
Modul de numărare fara ciclare. (CNTR este activat cu un semnal de Load sau
Reset și este dezactivat cu generare de semnal Carry sau Borrow.
Modul normal de numărare

Divide cu N modul de numărare

Modul binar sau BCD
Modul cea s cu 24 ore unde Octetul 0=sec, Octetul 1=min, Octetul 2=Hr.

Pinul 16 =CY, Pin 17=BW (active la zero)

Pin 16= CYT, Pin 17= BWT

Pin 16= CY, Pin17= BW (Active la unu)

Pin 16= COMP, Pin 17= COMP

Selectează OCCR

• Schema bloc de interfatare cu magistrala ISA

Circuitul comunică cu PC -ul prin magistrala ISA în felul următor: liniile de date ale
circuitului sunt legate la magistrala de date a procesorului prin care se programează circuitul si
se citesc valorile înscrise, iar liniile de adrese (A1 – A8) sunt folosite pentru a selecta circuitul
cu ajutorul unui decodificator de adrese.

13 | P a g e

Figura 1.6 Schema bloc de interfaț are a circuitului cu LS 7166 cu magistrala ISA

Pe placa de dezvoltare ( figura 1.7 ) sunt trei circuite numărător de tipul LS 7166; doua
aferente celor două traductoare (unul pentru axa X si altul pentru axa Y) si unul care numara
impulsurile care vine de la generator. Deasemenea mai există 3 circuite decodificator de adrese
(câte un decodificator pentru fiecare numărător) si trei optocuploare cu rol de protectie.

14 | P a g e

Figura 1.7 Placa de dezvoltare

1.4 Concluzii preliminare

Realizarea în primă faza a prototipului mașinii în cadrul laboratoarelor catedrei
Tehnologie mecanică, Facultatea de mecanică din cadrul UP Timi șoara și apoi implementarea în
cadrul diferitelor societăți industriale a relevat multiplele avantaje ale soluției propuse:
-prin utilizarea calculatoarelor compatibile IBM -PC s -a creat facilitatea de acces la toate
programele specifice domeniului (AUTOCA D, MASTERCAM….) și de asemenea la
echipamentele periferice specifice acestora;
-prețul de cost este foarte redus în afara calculatorului propriu -zis mai fiind necesară o
singura placă de dezvoltare , cu pret de aproximativ de 300 $;
-fiabilitatea echip amentului de conducere este dată de fiabilitatea calculatorului IBM -PC ,
care se știe a atins standarde exceptionale.

15 | P a g e
Capitolul II. Considerații asupra algoritmilor utilizați în cazul
implementării soft a echipamentelor de conducere a maș inilor -unelte cu
comandă numerică

2.1 Considerații generale

Datorită importanței covârșitoare pe care o au algoritmii de interpolare folosiți la
realizarea preciziei poziționărilor și traiectoriilor se prezintă bazele algoritmice utilizate la
elaborar ea pachetelor de programe.
S-au considerat următorii algoritmi:
-algoritmi de tip ADN
-algoritmi bazați pe calculul unui discriminant, în funcție de semnul căruia se apreciază
poziția punctului curent al traiectoriei aproximate față de curba reală;
-algoritmul diferenței coordonatelor, bazat pe emiterea de impulsuri pe cele două axe cu o
frecvență comandată după o anumită lege;
-algoritmi cu calculul direct al funcției prin metoda octanților.
În continuare se abordează algorimul bazat pe calculul unu i discriminant, algoritm utilizat
cu bune performanțe la conducerea cu calculatorul a mașinilor de prelucrare prin electroeroziune
cu electrod filiform .

2.2 Realizarea interpolării liniare

Fundamentul acestui algoritm este calculul unui discrimina nt D adecvat, al cărui semn
precizează poziția punctului curent al traiectoriei față de conturul nominal de prelucrat.
Schema de principiu este prezentată în figura 8.8 în care s -au utilizat aceleași notații cu
cele utilizate în cadrul sursei în limbajul C, prezentate la sfârșitul acestei lucrări.
x54, y54 – coordontele punctului inițial (punctul de început al interpolării liniare);
x64, y64 – coordonatele punctului final (punctul de sfârșit al interpolării liniare);
Coeficientul unghiular al dreptei de finite astfel prin două puncte este evident
panta = arctg ( =(y64 -y54) / (x64 -x54);
Se definește variabila suplimentară sm care are valoarea:

16 | P a g e
1 – în cazul în care panta<0, corespunzând deci unghiului cu valori în intervalul (90, 180)
grade;
-1 – în ca zul în care panta>=0, corespunzând deci unghiului cu valori cuprinse în
intervalul [0, 90] grade;
Se consideră un punct curent P, de coordonate x20, y20, propunându -ne în continuare să
determinăm poziția acestuia față de segmentul PinPfin; evident ca să s e poate defini un nou
segment de dreaptă PinP, al cărei coeficient unghiular m este definit de relația:
m = arctg ( = (y20 – y54)/(x20 -x54)
Mecanismul interpolării liniare impune testarea continuă a poziției punctului P și
corectarea poziției sale cu pa și astfel determinați încât să se asigure readucerea pe segmentul
nominal Pin,Pfin; în cazul punctului P, este evident că această readucere se face prin intermediul
unui segment dx paralel cu axa x; pentru comparație se prezintă pe aceeași figură cazul une i
poziții P’, la care readucerea pe segmentul PinPfin se face prin intermediul unui segment dy,
paralel cu axa y.
Se pune problema determinării unui criteriu de apreciere a necesității de a se face corecția
pe axa x sau ax a y;

Figura 1.8 Interpolarea liniară
Se definește discriminantul
delta= delta=sm*((x64 -x54)*(y20 -y54)-(y64-y54)*(x20 -x54));
În cazurile în care delta >0 sau segmentul de interpolare este paralel cu axa y, se comandă
efectuarea unui pas pe axa y, î n caz contrar comandându -se efectuarea unui pas pe axa x.
Observație: sensul mișcării se determină aprioric lansării algoritmului de interpolare prin
setarea unor variabile de sens, aferente celor două axe, și anume:
se1=1 pentru x54<x54 și -1 în caz cont rar
se2=1 pentru y54<y64 și -1 în caz contrar

X
'P(x' 20;y'2 0)dyP(x2 0;y20)dxPfin(x 64;y6 4)
Pin(x54 ;y54)Y

17 | P a g e

2.3 Interpolare circulară

Schema de principiu este prezentată în figura 1.9 .

Problema este asemănătoare cu interpolarea liniară, dar în această situație trebuie determinat un alt
criteriu care să determine condiția de efectuare a unui pas pe axa x sau axa y. Criteriul utilizat va fi
comparația distanței de la punctul studiat la centrul cercului cu raza acestuia:
-astfel în cazul punctului P, de coordonate x20,y20, distanța Pc este mai mare decât raza cercului
impunându -se efectuarea unui pas de corecție dx paralel cu axa x;
-în cazul punctului P', distanța sa până la centrul C al cercului este mai mică decât raza, și în
această situație se impune efectuarea unui pas de corecție dy paralel cu axa y;
Aceste raționamente au condus la determ inarea următoarei expresii pentru discriminatul delta:
delta=((x20 -i54)*(x20 -i54)-(x54-i54)*(x54 -i54)
+(y20 -j54)*(y20 -j54)-(y54-j54)*(y54 -j54)) * cadran;
Interpretarea semnului delta este identică cu situația interpolării liniare;
În paragraful următor este listat conținutul funcției C++ care implementează algoritmii de
interpolare implementați anterior.

C(i54;j54)P'dyPfin(x64;y64)
P(x20;y20)dx
Pin(x54;y54)Y
X
Figura 1.9 Interpolarea circulară

18 | P a g e

Capitolul III. Arhitectura programelor utilizate la comanda automată a
utilajului

3.1 Algoritmul de conducere adaptivă a avansului

În cazul prelucrării prin eroziune cu electrod filiform conducerea adaptivă a avansului are o
importanță excepțională însăși în condiționarea și continuitatea procesului de pelucrare în principal, și de
asemenea determină productivitatea prelucrării și prec izia suprafețelor; dependent de tipul de generator
utilizat informația asupra stării intestițiului este preluată și prelucrată în diferite moduri determinând și
condiționând efectuarea în continuare a mărimii de avans.
În cazul studiilor efectuate s -au ut ilizat generatoare de tip GEP, la care condiționarea avansului
este dată de prezența unui tren de impulsuri emise de generator; frecvența impulsuilor este o masură a
mărimii avansului posibil, practic generatorrul incorporând un convertor tensiune -frecvenț ă.
a) mișcarea de avans

În cadrul algoritmului elaborat, trenul de impulsuri generat de generator atacă intrarea unui
numărător; starea acestui numărător este citită periodic în cadrul programului cu instrucțiuni C de tipul:
nou= inport (ADRESA_BAZA+depl asament);
în care adresa de bază este adresa văzută de calculator pentru placa care conține numărătorul, iar
deplasamentul este adresa registrului component al numărătorului .
această valoare înteagă este comparată cu valoarea ultimei citiri ș i este permisă efectuarea în continuare a
avansului numai în situația în care există diferența nou # vechi printr -o instrucțiune de tipul:
if (nou != vechi)
{ se desfășoară mișcarea de avans}
Din examinarea relației de mai sus este evident că în lipsa impulsurilor de la generator nu se poate
desfășura în continuare mișcarea de avans intrându -se într -o buclă de așteptare cu testarea în continuare a
stării numărătorului
Se analizează în continuare distinct cele două situații considerate de comanda a MPP :
I. comanda directă a convertoarelor de putere

În această situație după cum s -a precizat semioctetul necesar pentru comanda convertorului are urmatoarea
componentă;
• bit 0(4) – sx=avansul pe axa x, egal cu 1 pentru sens pozitiv și 0 pentru sens negati v x;

19 | P a g e
• bit 1(5) – sy=avansul pe y cu aceași codificare
• bit 2(6) – tx=tactul pe axa x, valoarea 1 reprezentând palier la nivelul 1 logic, iar valoarea 0 palier
la nivelul 0 logic;
• bit 3(7) – ty=tactul pe axa y, cu aceasi semnificație;
Conform acestei codificări, de exemplu mișcarea pe axa y+ presupune următoarea succesiune de
semoiocteți transmiși spre convertor:
outport ( o | 0x60 & 0x7f);
– push1 (o & 0xdf);
• outport (0 & 0xdf);
outport ( o | 0x60 & 0x7f);
– push1 (o & 0xdf);
• outport (0 & 0xdf)
• ……………………………..
S-a notat cu o valoarea curentă a octetului, observându -se prezența unor operații logice la nivel de
bit înainte de transmiterea datelor spre convertor în scopul setării numai a biților specifici ș i neafectarea
celorlalți; astfel la primul outport s -au utilizat două etape:
-sau logic cu 0x60 = 0110 0000 cu efect de setare pe 1 a lui sy semnificând alegerea sensului + pe
y și de asemenea tx=1 cu rol de a inhiba un eventual tact nedorit pe axa x;
-etapa doua, corespunzând unui și logic cu 0x7f=0111 1111, cu efect de forțare ty=0
corespunzătoare primului front corespunzător unui tact;
A doua instrucțiune este push1 (o & 0xdf), punându -se deci în stivă 1( se va justifica la punctul
următor unde se vor trata revenirile din scurtcircuit) octetul curent dar după efectuarea funcției și logic cu
0xdf= 1101 1111.
II – Comanda memoriilor EPROM

b) retragerea în cazul existenței unui scurtcircuit

Prezența unui scurtcircuit este detectată prin interogarea un ui bit (deci efectuarea unui pooling),
bit componet al unuia dintre registrele componente ale interfeței paralele LPT a calculatorului; ciclul de
retragere din scurtcircuit are deci următoarea tanscriere în cod sursă C:
while (scurt !=)0 {
scurt = (( inpor t(0x379) & 0x80)
. desfășurare avans
…………….
}

20 | P a g e
Problema de maximă importanță care se pune în cadrul retragerii din scurtcircuit este ca traiectoria
de retragere să fie identică cu cea generată în cazul mișcării precedente de avans; dintre soluțiile utilizate
s-a optat pentru salvarea într -o stivă a codurilor tuturor pașilor efectuați în mișcarea de avans; se
analizează în continuare distinct cele două situații considerate:
I. comanda directă a convertoarelor de p utere

Succesiunea de instrucțiuni în această situație este următoarea:
f2=pop1(); extragerea din stiva creată la mișcarea de avans, urmată de transmiterea octetului spre
convertorul de putere;
outport(adr,f2);
push2(f2^0x30); salvarea într -o a doua s tivă a octetului transmis, dar cu complementarea
biților corespunzători lui sx și sy; aceasta s -a realizat prin aplicarea funcției sau exclusiv și folosirea măștii
0x30=0011 0000, biți 4,5 fiind complementați iar restul rămânând neschimbați;
f2=pop1(); ur mează al doilea grup de trei instrucțiuni corespunzătoare celui de -al doilea front
component al unui tact
outport(adr,f2);
push2(f2^0x30);

II – Comanda memoriilor EPROM

c) mișcarea de revenire în situații speciale

La acest punct se tratează situați a delicată în cazul în care retragerea în urma unui scurtcircuit a
generat situația nedorită de a se reveni în fraza precedenta; în cazul multor echipamente de comandă
numerică tradiționale apariția unui scurtcircuit în cazul trecerii de la o frază la prec edenta conduce în
multe situații la erori inadmisibile. Acest caz este detectat în program de prezența valorii negative a
indicelui global i1p; algoritmul este următorul:
while (i1p<0) {
f2=pop2();
outport(adr, f2); extragere din stiva creată la depla sarea în cazul scurtcircuitului și trimiterea spre
convertor în cazul primului front component al tactului;
f2=pop2();
outport(adr,f2);
………………………………………………….

21 | P a g e
}

3.2 Variante de utilizare

Din considerente de utilizare industrială s -au impus trei posibilități de lucru:
-prelucrare propriu -zisă – în care se comandă elementele de execuție avansul fiind stabilit adaptiv
în funcție de desfășurarea procesului;
-desenare – caz în care comanda se realizează cu un avans constant ; se utilizează pentru
verificarea în regim de comandă utilaj a programului;
-verificare – situație în care nu se comandă efectiv utilajul ci numai desenarea pe displayul
calculatorului.
Din punct de vedere soft diferenți erea între cele trei variante se realizează prin utilizarea unor
variabile întregi astfel:
-variabila timp care are valoare 0 în cazul desenării și vizualizării și o valoare întreagă pozitivă în
cazul prelucrării propriu -zise; ea se determină în corelație cu structura hard a blocului de avans specific
generatorului;
-variabila syncro=0 în cazul prelucrării propriu -zise și egală cu 1 în celelalte situații; apare în
cadrul instrucțiunii
nou = vechi + syncro;
în care nou și vechi sunt conținuturile actual ș i anterior a registrului numărător de impulsuri primite de la
generator;
-variabila scurt=0 în cazul desenării și vizualizării pentru a elimina chiar și teoretic posbilitatea de
a apariție a scurtului, evident în cazul prelucrării efectuându -se un pooling asupra unui bit special.

3.3 Algoritmi de corecție a traiectoriei

Este evident că datorită lucrului în bucla închisă de poziție se pune problema de a efectua reglajul
de poziție conform legilor specifice reglării automate prin comparația poziției prescrise (w) cu cea reală
(reacția r); problema se încadrează în teoria generală a sistemelor de reglare automată, sistemul prezentat
făcând parte din categoria sistemelor de reglare automată numerice (SRAN);
Conform teoriei SRAN trebuie determinate dou ă elemente specifice reglajului numeric:
a) legea de reglare -în urma studiului teoretic dar și a încercărilor experimentale ( descrise în paragrafele
următoare) – s-a optat pentru o lege neliniară de tipul tripozițional ( figura 1.10 ). Această lege asigură o
variație a abaterii între două limite amin și amax impuse din considerente de precizie dimensională.
Concretizând cele expuse anterior, se prezintă în figura 1.11 traiectoria nominală marcată prin punctele
A1,A2, …A 5 și cea efectivă marcată prin punct ele B 1,B2,…B 5…; perechile de puncte A k,Bk corespund câte

22 | P a g e
unei eșantionări respectiv câte unei citiri a traductorului de poziție; în fiecare situație se calculează
diferențele
delta x = xnominal -x efectiv și
delta y = ynominal – yefectiv;

În situația în care delta x sau delta y sunt mai mari decât o valoare admisă se efectuează corecția
traiectoriei prin întreruperea algoritmului de interpolare și executarea unui segment de corecție; în figura
1.12 s-au prezentat două situații:
-în cazul poz iției A 2, adeltax2,y2<valoarea admisă și deși există o eroare de traiectorie se
apreciază că aceasta se încadrează în zona de toleranța și nu se efectuează nici o corecție;
-în cazul poziției A 5, x5 sau y5 sunt mai mari decât eroarea admisă și în consecință corecția
de traiectorie se va manifesta prin executarea segmentului A 5A’5 de readucere pe traiectoria nominală ,
poziția A’ 5 fiind la limita identică cu poziția B 5, dar real și segmentul de core cție A 5A’5 este însoțit de
erori.

a2
a1=w-ru
amaxa
amaxtA1=B1x2
y2y5x5B2A2
A5
A5 B5
B6A6

Figura 1.11 Legea de reglare Figura 1.12 Traiect oria nominală
În programul elaborat segmentul de corecție este tratat ca orice segment care generează o
interpolare liniară, fiind posibile cele trei faze tehnologice de lucru analizate la anterior și anume: mișcare
de avans (a), retragere din scurtcircu it (b), revenire după scurtcircuit în cazuri speciale (c). În cadrul
experimentărilor efectuate s -au testat deferite valori ale valorii maxim admisibile ale erorii în domeniul
0.004 – 0.012 mm; o valoare prea mică a erorii admise conduce la o executare pre a frecventă a
segmentului de corecție generând o instabilitate a procesului.

23 | P a g e

b) timpul de eșantionare – este o caracteristică foarte importantă sistemelor de reglare numerice,
în acest context al reglării poziției având o semnificație deosebită în cazul reglării poziției; se impune
realizarea unui compromis productivitate -precizie de prelucrare, un timp de eșantionare prea mic generând
o bună precizie dar scăzând productivitatea datorită prezenței prea multor segmente de corecție; în cadrul
programelor el aborate timpul de eșantionare nu are o valoare absolută, ci este raportat ca un multiplu la
numărul de pași teoretici efectuați; s -au experimentat valori ale lui te cuprinse în domeniul (100,300)*
timpul pe pas elementar (teoretic); în figura 1.13 este pre zentată situația unei interpolări circulare, măsura
timpului de eșantionare fiind data convertită în mărimea unghiului  la care se efectuează citirea
traductorilor.

Figura 1.13 Interpolare circulară

Observație: în faza finală a cercetărilor s -a elaborat un algoritm de corectare a traiectoriei mai
performant schematizat în figura 1.14 astfel î n cazul unei interpolări liniare se propune realizarea
segmentului definit de punctele P inPfin; conform timpului de eșantionare stabilit se face prima citire a

C1
B1A1
Q1O
contur real
contur nominal
dimensiune
admisibil ă maxim ă
dimensiune admisibil ă
minimă

24 | P a g e
traductorilor de poziție depistându -se poziția punctului P 1; indiferent de eroarea de poziție a acestuia nu se
va mai efectua un segment de corecție ci în continuare interpolatorul își va propune executarea
segmentului P 1Pfin; similar la următoarele citiri interpolatorul își va propune executarea segmentelor P 2Pfin,
P3Pfin deși practic se vor executa segmentele:
PinP1, P1P2, P2P3, , P n-1 Pfin.
PinP1P2
P3Pfin
Figura 1.14 Algoritm de
corectare a traiectoriei

3.4 Gestiunea poziției nominale (utilizarea stivelor de poziție)

O problemă de maximă importanță în gestiunea preciziei poziției este gestionarea corectă a
poziției teoretice, prescrise în generarea unei traiectorii; problema abordată în cadrul de față es te total
diferită de problema corectării traiectoriei prin exploatarea informațiilor primite de la traductori,
referindu -se practic la corectitudinea conducerii în buclă deschisă..
Dificultatea problemei constă în coexistența celor trei tipuri de mișcări: prelucrare propriu -zisă (a),
retragere din scurt (b), revenire după scurt în cazul i1p<0;:
În scopul rezolvării problemei s -au creat un număr de patru stive de poziție (câte două pentru
fiecare axă x și y), care se gestionează în paralel cu stivele de m emorare a codurilor transmise spre
convertoarele de putere utilizate pentru comanda MPP.

a) prelucrare propriu -zisă

În această situație se salvează în stivele 3 și 5 ( figura 1.15 ) valorile prescrise pentru pozițiile pe
axele x și y , dezvoltându -se stivele respective; cele două stive sunt de tipul circular, în sensul că după
salvarea în stiva a unui număr de poziții (de exemplu 1000), salvarea noilor poziții se vor face peste cele
vechi cu pierderea evidentă a acestora. Simultan are loc și incrementar ea contorului teoretic i1p++ care
supervizează generarea teoretică a traiectoriei.

25 | P a g e

b) retragerea din scurtcircuit

Conform figurii se realizează o extragere din stivele 3 și 4 create la punctul a) concomitent cu
executarea pașilor respectivi și dec rementarea contorului global i1p –; noi pași efectuați sunt salvați în o a
doua pereche de stive 5 și 6 care vor fi exploatate la punctul c;

c) revenirea după scurt -circuit

Simultan cu incrementarea lui i1p++, se realizează extragerea valorilor poziț iilor din perechea de
stive 5 și 6, create în cazul existenței unui scurtcircuit.

Cod k+2
Cod k+1
Cod k Cod k+2Cod k+2=pop1( )prelucrare i 1p++
scurtcircuit
scurtcircuiti1p–
i1p–
i1p–revenire
pop 5( )
push 1 (cod convertor) push 2 (cod convertor)
X k+3=pop3( )scurtcircuit
push 3 (X k)
prelucrare propriuzis ăprelucrare i 1p++
scurtcircuit
X kX k+2X k+3
i1p–
X k+1=pop 5( )revenire
push 5 (X k)
scurtcircuiti1p–
i1p++
X k+1
X k+3X k+2X k+1
Figura 1.15

26 | P a g e

3.5 Algoritmi de comandă manuală a utilajului

Deși aparent în exploatarea unui echipament industrial cu comandă numerică programele de
comandă automată au un rol prio ritar, totuși lipsa unor programe de comandă manuală performantă
diminuează din performanțele utilajului.
Sarcinile acestui program sunt următoarele:
-apropierile rapide din poziția curentă în poziția convenabilă de start a programului principal;
-căuta rea punctului OM (O mașina sau fix punct); acesta poate fi unic pentru un utilaj dat (un
singur impuls index pe fiecare axă), sau pot exista mai multe impulsuri index decalate la fiecare 10 mm;
-centrarea piesei, echivalând cu resetarea numărătoarelor (pu nerea pe O) care contorizează
pozițiile pe cele două axe Din punct de vedere al operatorului există două strategii de lucru:
a) la începerea lucrului, după cuplarea mașinii la tensiune, se reperează OM, prin aceasta
punându -se pe 0 numărătoarele pe cele d ouă axe; apoi se caută punctul OP (O piesa) utilizându -se diferite
metode specifice tehnicilor de centrare (utilizarea însăși a palpării “electrice”, utilizarea palpării mecanice
în corelație cu afișajele poziției curente față de OM, …………………) . În momentul reperării OP operatorul
acționează o tastă a calculatorului generând astfel două acțiuni:
-resetarea celor două numărătoarea, din acest moment orice comandă fiind interpretată față de
noul 0;
-salvarea pe hard a distantelor XOPOM și YOMOP; aceasta salvare este utilizabilă (chiar
indispensabilă) în cazul întreruperii tensiunii, făcând posibilă reluarea lucrului fără repetarea operației de
centrare, care în general este o operație dificilă și de finețe; de asemenea cele două valori pot fi folo site în
cazul prelucrării unui lot de piese.
b) la începerea lucrului se efectuează prima dată centrarea (deci reperarea 0 piesa) și punerea
numărătoarelor la 0; apoi se caută 0 Masina fără a se mai pune numărătoarele pe 0, ci numai se notează de
către op erator distanțele XOpOm și YOpOm.

Este listată în continuare sursa C++ care realizează taskurile menționate anterior:

/* manee3.c – comanda manuală elerofir – incremental și cont
cu detectare OP si OM */
/* CITIRE TRADUCTORI */

27 | P a g e

y1
x1 Op1y2
x2 Op2
1mOMyOMOp1 1m Traductor
axa y
Traductor axa x
Figura 1.16

// OP OM SA APARA O SINGURA DATA
#include<stdio.h>
#include<conio.h>
#include<dos.h>
#include<graphics.h>
#include<iostream.h>
#define ADRTIRO 0x330
#define MINX 0x00 // 0x0 6
#define MINY 0x00 //0x60
#define TRAD 1 // =2 pt. YAL -K =1 pt. J.HEIDENHEIN
#define PAS 0.0005 // 0.001 BUL 0.0003 Oradea+TM ?? 0.0005TM
#define INTR 0x0F // întrerup hard asociată lui IRQ7

28 | P a g e
#ifdef __cplusplus
#define __CPPARGS …
#else
#defin e __CPPARGS
#endif

unsigned int i1,i2,i3,i4, v=1, v1=6*TRAD, k2=0, k, ms=0xff;
char var; // dictează modul de lucru al subrutinei tratare întrerupere
int count=0, count1=0;
int a1=1, a2=1,f1, se1, se2;
float x20=0, y20=0, x21,y21;
char fel,c,omop[10]="omop";
FILE *fpo, *fomop;

void manualcont (void);
void manualincr (void);
int modifica (void);
schimba_viteza(void);
void tastatura (void);
int kbstatus (void);
void delay1 (int);
float trad (int);
void pupitru (void);
void interrupt ( *oldhandler)(__CPPARGS);
void axax(void);
void axay(void);

void interrupt handler(__CPPARGS) {
int avarie,z2=0,kbst;
char *string;

29 | P a g e
// conținutul subrutinei de tratare întrerupere HARD -IRQ7 generată la
// pinul 10(ACK) LPT, care este t otodata bitul 6 al octetului (deci
// masca si=0100 0000=0x40) citibil inp(0x379).
// disable();
outportb(0x21,inp(0x21)|0x80);
outportb(0x20,0x20);
outport(0x37a, inp(0x37a) &0xfb); // ROGIF NU
count++;
if (fel=='o' || fel=='O') v1=1;
// Pt. a se face cel mult un pas din momentul întreruperii
gotoxy(50,50);
// delay(5000); // NU AICI ASTEPTARE
// printf("COUNT= %d sunt în subrutină ",count); // !!!!!!!!!!!
// oldhandler();

outportb(0x37a,inp(0x37a) | 0x01); // bit 0(pin1) pus pe 0 pt. E555,
// respectiv pe 1 în instructiunedat. complementării,
// raminere pe palier până la aceasta resetare
delay(20);
outportb(0x37a,inp(0x37a) & 0xfe); // repus pe 1=stare normala (0compl)
// outport(0x37a, inp(0x37a) |0x04); // ROGIF DA,
outportb (0x21,inp(0x21)&0x7f); // revalidare irq7
// }
}

void main (void) {
int pin14,f3, z5=0, kbst;
long l;
char car, oldIMR, newIMR, comanda;

30 | P a g e
int graphdriver=DETECT,gmod;
outport(0x37a, inp(0x37a) & 0xfb); // ROGIF NU
outport(ADRTIRO,0); // INITIALIZA RE placa AXA la inceput
// outport(ADRTIRO+0x00,'b'); // reset simultan pt.cele 3 canale TIRO
outport(ADRTIRO+0x5,0x4); //înscriu în octetul lsbmsb 0000.0100 ->
outport(ADRTIRO+0x9,0x4); // o axa este inițializată cu 2^18=262.144
x21=trad(0);
y21=trad(1);//citire inițială pt. a se stabili master -slave
printf(" \n poz citita x21=%6.3f y21=%6.3f", x21, y21);
initgraph(&graphdriver,&gmod,"c: \\bc\\bgi");
/* ecranul de prezentare */
clrscr();
setcolor(RED);
setbkcolor(CYAN);
settextstyle(0,0,3 );
outtextxy(10,110,"COMANDA MANUALA");
settextstyle(0,0,2.5);
setcolor(BLUE);
outtextxy(5,220,"POLITEHNICA & ELECTOSTAR TIMISOARA");
delay(2000);
closegraph();
printf("test1");delay(500);
// if((fomop=fopen(omop ,"rw+"))==NULL){
// printf("test1"); delay(500); puts("nu pot deschide fisierul OMOP");
// return;
// }
clrscr();
gotoxy(2,2);
// while(!feof(fomop)){ //fișier cu coordonatele OpOm

31 | P a g e
// c=getc(fomop); /* citire câte un caracter */
// printf("%c",c);
// }
// fclose(fomop);

while(1) { // ciclu infinit -ieșire cu CTRL -BREAK
// clrscr();
gotoxy(2,3);
printf(" \n deplasare continua sau incrementală ? C sau I");
printf(" \n căutare OMașina sau regim manual obișnuit ? O,Q sau M");
printf(" \n comandă pupitru comandă sau tast atura PC? ? p sau t \n ");
cin>>car>>fel>>comanda;
// scanf("%c %c %c", &car, &fel, &comanda);
if (fel=='o' || fel=='O') {
oldhandler = getvect(INTR);
setvect(INTR, handler);
outp(0x37a,inp(0x37a)|0x10);
outportb(0x21,inp(0x21)&0x7f);
outportb(0x20,0x20);
}

outport(0x37a, inp(0x37a) & 0xfd); // am citit starea existentă
//bitul 1=pin 14 pus pe 1 aici -> compl=0 -> REVITZKY ergim manual,
// masca &0Xfd=1111 1101 restul neschimbați și trimis înapoi
outport(0x37a, inp(0x37a) & 0 xfb);
outportb(0x37a,inp(0x37a) | 0x01); // bit 0(pin1) pus pe 0(compl 1) pt. E555,
delay(20);
outportb(0x37a,inp(0x37a) & 0xfe); // 555 1=0complstare normala -bit0(pin1)

32 | P a g e
//NU SE PUNE IMPLICIT PE 0 IN ORICE SITUATIE
// if (fel=='o' || fel=='O') {
// outport(ADRTIRO+0x00,'b'); // reset simultan pt.cele 3 canale TIRO
// outport(ADRTIRO+0x5,0x4); //înscriu în octetul lsbmsb 0000.0100 ->
// outport(ADRTIRO+0x9,0x4); // o axa este initializată cu 2^18=262.144

count=0; printf(" \n count= %d ", count);
if (comanda=='p' || comanda=='P') { // comanda pupitru
pupitru(); }
// de la tastatura sau panou selecția se face prin pin 17 – bit 3
else { // COMANDA PC tastatură
outport(0x37a, inp(0x37a) & 0xf7); } //selecție comanda tastatura
if ( car= ='c' || car=='C' )
{ manualcont(); }
if (car=='i' || car=='I')
manualincr();
clrscr();
setvect(INTR, oldhandler); // restaurare old
} // închidere while ciclu infinit
fclose(fomop);
}

void pupitru (void) {
int z5=0, kbst=0;
clrscr();
gotoxy(5,10);
printf(" \n COMANDA DE LA PUPITRU");
printf(" \n apasati CAPS -LOCK pt. iesire din acest mod de lucru \n");
// fopen(omop,"r");

33 | P a g e
// while(!feof(fomop)){ //fisier cu coordonatele OpOm
// c=getc(fomop); /* citire cite un caracter */
// printf("%c",c);
// }
outport(0x37a, inp(0x37a) | 0x08); // selectie comanda manuala pupitru
while (z5==0 ){ //CAPS -LOCK
kbst=kbstatus();
z5=(kbst & 0x40); // CAPS LOCK -OUT
x21=trad(0); y21=trad(1);
gotoxy(5,17);
printf(" poz citita x21=%6.3f y21=%6.3f COUNT=%d", x21, y21, count);
}
}

float trad (int axa) {
unsigned long impuls=0L;
int i, result[4], port;
long rez;
int tab1[4] = {0x5, 0xf, 0x4, 0xe}; //s -a schimbat de la 5,7,4,6
int tab2[4] = {0x9, 0xb, 0x8, 0xa};
int tab3[2] = {0xd,0xc};
// clrscr();
// printf(" \n");
for (i=0; i<=3; i++) {
if(axa==0) port=ADRTIRO+tab1[i];
else if(axa==1) port=ADRTIRO+tab2[i];
result[i]=inportb(port);
// printf(" i=%d r[i]=%d",i, result[i]);
}

34 | P a g e
// printf(" \n %3d %3d %3d %3d", result[1], result[3], result[0], result[2]);
impuls=1L*result[1]+256L*result[3]+256L*256*result[0];
// +256L*256*256*result[2]; // nu au rost 4 octeti
rez=(impuls -262144);
// printf(" \n imp=%9li", impuls);
// printf(" \n rez=%d ", rez);
return 0.001*rez*TRAD;
}

void manualcont (void){ // manual continuu
int kbst,z1=0,z2=0,z3=0,z4=0,z5=0,g=0,z8=0, tasman=0;
int g1=0,g2=0;
// float long x21,y21; // poz.citite
i1=6; i2=15; i3=0x60; i4=0xf0;
clrscr();
gotoxy(5,9);
print f("\n POZITIONARE CONTINUA DE LA TASTATURA");
printf(" \n mentineti apasat shift dr. -> X -, shift stg. -> X+");
printf(" \n ctrl -> Y+, alt -> Y -");
printf(" \nCAPS LOCK pt. terminare mod de lucru continuu de la tastaura \n");
printf("\n mentineti apasate NUM LOCK sau SCROLL LOCK");
printf(" \n atit timp cit doriti marirea sau micsorarea vitezei");
printf(" \n apasati INSERT pt. preluare 0Piesa <=> centrare \n");
// fopen(omop,"rw+");
// while(!feof(fomop)){ //fisier cu coordonate le OpOm
// c=getc(fomop); /* citire cite un caracter */
// printf("%c",c);
// }

35 | P a g e
while( z5==0) { // ramanere in bucla cu CAPS -LOCK
if ((fel=='O' || fel=='o' || fel =='q' || fel=='Q')
&& (count1!=count)) { // DECI VALIDEZ impuls nul
//varia nta ORADEA -Om nu mai pune pe 0 numarat. ci numai atentioneaza
//operatorul de găsirea ei și afisează și memorează dist OpOm

switch(var) {
case 'x': //xX0Masina IRQ7 ceruta de impuls de pe rigla
// outport(ADRTIRO+0x5,0x4); //inscriu in octetul lsbmsb 0000.0100 ->
// outport(ADRTIRO+0x7,0x00); outport(ADRTIRO+0x6,0x00);
gotoxy(2,2);
x21=trad(0); x20=x21;
printf(" FIX PUNCT X XOM fata de XOP =%6.3f", trad(0));
delay(4000);
gotoxy(2,2); printf(" ");
if ( fel=='q' || fel=='Q') { //resetare
}
if( fel=='o' || fel=='O')
fprintf(fomop," \n DXOpOm=%6.3f", trad(0));
break;
case 'y': // YOMașina IRQ7 cerută de impuls de pe r igla
// outport(ADRTIRO+0x9,0x4); // o axa este initializata cu 2^18=262.144
// outport(ADRTIRO+0xb,0x00); outport(ADRTIRO+0xa,0x00);
y21=trad(1); y20=y21;
gotoxy(2,4);
printf(" FIX PUNCT Y YOm fata de YOp =%6.3f", trad(1));
delay(40 00);
gotoxy(2,4); printf(" ");
if ( fel=='q' || fel=='Q') { //resetare

36 | P a g e
}
if( fel=='o' || fel=='O')
fprintf(fomop," \n DYOpOm=%6.3f", trad(1));
break;
default: break;
} // sfarit switch
} // sfârșit if OM

printf(" count=%d count1=%d", count, count1);
count1=count;
// outp(0x37a,inp(0x37a)|0x10); // ?????????????
kbst=kbstatus();
// printf(" kbst=%x var=%c", kbst, var);
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!
z1=((kbst & 0x01));// | (!(inport(0x379) & 0x80))); //X –
z2=((kbst & 0x02));// | ((inport(0x379) & 0x20))); //X+;
z3=((kbst & 0x04));// | ((inport(0x379) & 0x10))); //y+;
z4=((kbst & 0x08));// | ((inport(0x379) & 0x08))); //y -;
// tasma n=inport(0x379);printf(" \n man=%x ", tasman);
z5=(kbst & 0x40); // CAPS LOCK -OUT
z8=(kbst & 0x80); //INSERT – OPiesa valid
if(z1) { se1=0; axax(); var='x'; x20=x20 -v1*PAS; x21=trad(0);}
else {
if(z2) { se1=1; axax(); var='x'; x20+=v1*PAS; x21=t rad(0); }
else {
if(z3) { se2=1; axay(); var='y'; y20+=v1*PAS; y21=trad(1); }
else {
if(z4) { se2=0; axay(); var='y'; y20 -=v1*PAS; y21=trad(1);}
else {

37 | P a g e
if(z8) { // pt. INSERT 0p
// OPOPM O singura data1
switch(var) {
case 'x': // INSERT -> validez centrare <=> pun la 0 numarat
g1++;
// if(g1==1) {
// gotoxy(2,15);
// varianta ORADEA la centrare Op pun pe 0 traductor NU MEMOREZ nimic
// printf(" XOPiesa fata de XOMasina =%6.3f", trad(0));
// fprintf(fpo," \n XOPiesa fata de XOMasina =%6.3f", trad(0));
outportb(ADRTIRO+0x5,0x4); //înscriu în octetul lsbmsb 0000.0100 ->
outportb(ADRTIRO+0xf,0x00); //s -a schimabat adresa de la 0x7
outportb(ADRTIRO+0x4,0x00);
outportb(ADRTIRO+0xe,0x00); //s -a schimbat de la 0x6
x21=trad(0); x20=x21;
// }
break;
case 'y': // valdez centrare y
g2++;
// if(g2==1) {
// gotoxy(2,16);
// printf(" YO Piesa fata de YOMasina =%6.3f", trad(1));
// fprintf(fpo," \n YOPiesa fata de YOMasina =%6.3f", trad(1));
outportb(ADRTIRO+0x9,0x4);// delay(1);// o axa este initializata cu 2^18=262.144
outportb(ADRTIRO+0xb,0x00);// delay(1);
outportb(A DRTIRO+0x8,0x00);// delay(1);
outportb(ADRTIRO+0xa,0x00);// delay(1);
y21=trad(1); y20=y21;
// }

38 | P a g e
break;
}}
else schimba_viteza();
}}}}
gotoxy(5,20);
printf(" poz nominala x20=%6.3f y20=%6.3f v=%4d", x20,y20,v1);
printf(" \n poz citita x21=%6.3f y21=%6.3f", x21, y21);
} // inchid while
fclose(fomop);
}
int kbstatus(void){
union REGS ireg;
ireg.h.ah=0x02;
int86(0x16,&ireg,&ireg);
return ireg.h.al;
}

schimba_viteza (void) {
int kbst2, z5, z6;
// k2++;
// if ((k2 % 1000) != 0 ) /* nu intru în funcție decât la 1000 -apasare */
// { v=v; return;}
kbst2=kbstatus();
delay(1000); // viteza de schimbare printf(" \n kbst2=%x", kbst2);
z5 = kbst2 & 0x10; // starea scroll -lock
z6 = kbst2 & 0x20; // starea num-lock
if (z5) /* dublare v la apasare scroll -lock */
v1=v1*2;
if (z6) { /* injumătățire v la apasare num -lock */

39 | P a g e
v1=v1/2;
if(v1==0) v1=1;
}
}

void tastatura (void) {
union REGS ireg;
ireg.h.ah = 0x00;
int86 (0x16, &ireg, &ireg); /* aici asteapta pt. continuare
apăsarea unei taste ordinare, în caz contrar blocând continuarea */
a1 = ireg.h.al;
a2 = ireg.h.ah;
/* printf(" \n a1t=%x a2=%x", a1, a2); */
}

void manualincr (void) {
int kbst=0, z5=0, j1;
int inc2=1, z1=0, z2= 0,z3=0,z4=0;
char test;
v=10;
clrscr();
gotoxy(5,9);
printf(" \n MOD DE LUCRU INCREMENTAL DE LA TASTATURA \n");
printf(" \n apasati shift dr. -> X -, shift stg. -> X+");
printf(" \n ctrl -> Y+, alt -> Y -");
printf(" \nCAPS LOCK pt. terminare mod de lucru INCREMENTAL dela tastaura \n");
inc2=modifica();

while (z5==0) {

40 | P a g e
kbst=kbstatus(); z5 = kbst & 0x40;
delay(4000);
z1=((kbst & 0x01)); //X –
z2=((kbst & 0x02)); //X+;
z3=((kbst & 0x04)); //y+;
z4=((kbst & 0x08)); //y -;
if(z1) { se1=0; var='x'; for(j1=0;j1<inc2;j1++) axax(); }
else {
if(z2) { se1=1; var='x'; for(j1=0;j1<inc2;j1++) axax(); }
else {
if(z3) { se2=1; var='y'; for(j1=0;j1<inc2;j1++) axay(); }
else {
if(z4) { se2=0; var='y'; for(j1=0;j1<inc2;j1++) axay(); }
}}}
x21=trad(0); y21=trad(1);
gotoxy(5,15);
printf(" \n poz citita x21=%6.3f y21=%6.3f", x21, y21);

gotoxy(5,20);
printf (" doriti schimbare mărime increment D ??");
cin>>test; //scanf("% c", &test);
if (test == 'd' || test=='D') inc2=modifica();

} // inchid while CAPS -LOCK
}
int modifica (void) {
int k1=10, inc, inc1, n1=100;
gotoxy(5,22);
printf(" \n introduceti 1, 2, 3, 4 pentru incremente de ");

41 | P a g e
printf(" \n 1 mm, 0.1 mm, 0.01 mm , 0.001 mm");
scanf ("%d", &inc);
if (inc==1) inc1=n1;
if (inc==2) inc1=n1/10;
if (inc==3) inc1=n1/100;
if (inc==4) inc1=n1/1000;
inc1 = (k1 * inc1); /* k1 – factor de scara pt. marime increment */
return inc1;
}

void axay(void){
// bit0=pin2=sens x 1 -3=sens y 2 -4 tact x bit3 -5 tact y
int j=0;
if(se2==1){ /* sens y+ pe reper */
for(j=0; j<v1; j++) {
outport(0x378,0x21); //0x1a=0001 1010 impuls
delay(v);
outport(0x378,0xa1); //0x12=0001 0010 revenire
delay( v);
}}
if(se2==0){
for(j=0; j<v1; j++) {
outport(0x378,0x01 & ms);delay(v); // 0001 1000
outport(0x378,0x81 & ms);delay(v); // 0001 0000
}}
}
void axax(void){
int j=0;
if(se1==1){ /* sens x+ pe reper */

42 | P a g e
for(j=0; j<v1; j++) {
outport(0x378,0x11); delay(v);
outport(0x378,0x51); delay(v);
}}
if(se1==0){
for(j=0; j<v1; j++) {
outport(0x378,0x01 & ms);delay(v);
outport(0x378,0x41 & ms); delay(v);
}}
}

3.6 Utilizarea sistemului de întreruperi

Opțiunea pentru utilizarea sistemului de întreruperi a fost luată datorită particularităților
procesului condus, având semnificații deosebite; arhitectura programelor elaborate este similară atât în
cazul programelor de comandă automată cât și în cazul comenz ii automate, acest considerent justificând
tratarea unitară, în continuare subliniindu -se aspectele comune.
Conform celor precizate anterior, controlerul de întreruperi 8259 existent în cadrul calculatoarelor,
are o intrare și anume IRQ7 (sau IRQ5 în unel e siuații ) legată la interfața paralelă LPT, și anume la
registrul de comandă (adresa 27ah, 37ah, ……), fiind rezervat bitul 4 al acestui registru, respectiv pinul 10..
Conform structurii PC, liniei de întreruperi IRQ7 îi este asociată întreruperea ha rd 0xOF=INTR,
existentă în cadrul tabloul vectorilor de întreruperi al microprocesoarelor 80×86; în cadrul funcției
principale main() se realizează instalarea funcției de tratare a întreruperilor la adresa corespunzătoare
0xof:
oldhandler = getvect (INTR) ; salvare subrutină de tratare existentă la adresa INTR
setvect(INTR, handler); instalare subrutină nouă caracteristică aplicației de conducere
outp (0x37a, inp(0x37a)|0x10)); setarea corespunzătoare a registrului interfeței paralele
outp (0x21, inp(0x 21) & 0x7f); programarea controlerului 8259, din structura PC

43 | P a g e

outp (0x20, 0x20);
……………………….
setvect(INTR, oldhandler); restaurarea subrutinei inițiale de tratare a întreruperii
Subrutina propriu -zisă de tratare a î ntreruperii are o structură bloc similară diferind corpurile
specifice în cele două cazuri:

void interrupt handler () {
outp (0x21, inp (0x21) | 0x80); invalidare IRQ7, pentru a nu fi posibilă valdarea unei noi
întreruperi IRQ7, chiar în timpul servir ii celei anterioare, cu efecte dezastroase asupra sistemului;
outp (0x20, 0x20) programare controler 8259
blocare generator
corpul subrutiei
……………………………
outp ((0x21, inp(0x21) & 0x7f); revalidare IRQ7
}

În continuare se tratează distinct particularitățile subrutinei de tratare a întreruperii în cele două
situații.

a) comanda automată

În această situație întreruperea IRQ7 este folosită la întreruperea programului principal în
momentul apariției unei AVARII (ruperea fir ului, lipsa lichidului dielectric, depășirea limitelor de
cursă…………); sesizarea acestor momente critice în desfășurarea procesului are o importanță deosebită, de
o importanță excepțională fiind și promptitudinea cu care se sesizează necesitatea înt reruperii. Tocmai
aceste considerente au făcut să nu se opteze pentru utilizarea altor tehnici (de exemplu
interogare -pooling).
În corpul subrutinei se rămâne până ce operatorul semnalează calculatorului remedierea AVARIEI
și prin aceasta posibilitatea re luării procesului, de la valorile pozițiilor existente în momentul întreruperii

44 | P a g e
b) utilizarea întreruperii în cazul programelor de comandă manuală

În această situație sistemul de întreruperi este folosit pentru depistarea indexurilor de pe
traductorii de poziție; utilitatea acestora s -a expus în cadrul programului anterior.; sarcina subrutinei este
de a pune pe 0 numărătoarele aferente axei respective.
Deși ar fi fost de dorit ca această setare pe 0 a numărătoarelor să se facă chiar în cadrul subrutine i
de tratare, în urma mai multor încercări experimentale această operațiune a generat conflicte care au dus în
mod repetat la blocarea sistemului; instrucțiunile care au dus la blocarea sistemului, în cazul în care au
fost plasate în interiorul subrutinei au avut următoarea structură:
outport (ADRTIRO+0x5, ‘b’);
Datorită acestei dificultăți instrucțiunile de resetare s -au plasat în programul principal apărând
deficiența existenței unei întârzieri față de momentul citirii indexului.
Din punct de vedere s oft s-a introdus două variabile suplimentare count și count1, care memorează
numărul de citiri ale indexului; în cazul depistării diferenței, deci apariției unei noi cereri de întrerupere, se
face setarea pe axa respectivă
În cadrul programului sursă C pr ezentat în cadrul paragrafului anterior este cuprinsă și subrutina
de tratare a întreruperii.

3.7 Cercetări experimentale

S-au efectuat două tipuri de cercetări:
-cercetă ri experimentale calitative, care au avut ca obiect studiul procesului de prelucrare existând
posibilitatea soft de a analiza procesul la nivelul fiecărui pas;
-cercetări experimentale cantitative, care și -au propus determinarea dependențelor între variab ilele
de intrare și cele de ieșire;

3.7.1 Cercetări experimentale calitative

Aceste rezultate au fost obținute datorită facilităților oferite de programul C, care realizează
comanda automată a echipamentului de prelucrare; În acest scop se deschide u n fișier fpo.txt chiar în
cursul prelucrării în care se salvează succesiv diferite informații asupra procesului de prelucrare; mai
concret în varianta utilizată sunt salvate următoarele trei categorii de informații:

45 | P a g e
a) rezultatele citirilor periodice ale traductorilor de poziție și care se înscriu în variabilele reale
x21 și y21; pentru comparație sunt prezentate de asemenea și valorile omoloage ale acestora rezultate în
urma calculelor specifice interpolării x20 și y20; perioada de eșantionare între difer itele citiri este un
parametru al programului (variabila de intrare) existând un optim în alegerea sa;
b) modalitatea de efectuare a segmentului de corecție, în cazul în care diferența dintre valorile
comandate x20,y20 și cele citite de către traductori x 21,y21 depășesc o anumită valoare de prag impusă;
în această situație se indică modalitatea de efectuare a fiecărui pas, incluzând valorile calculate pentru
x20,y20;
c) modalitatea de efectuare a revenirii în cazul depistării unui scurtcircuit; evident în această
situație revenirea trebuie să se facă după exact aceeași traiectorie ca și în cazul prelucrării; fiind memorat
fiecare pas al revenirii se pot trage concluzii asupra duratei revenirii din scurtcircuit, exprimată în număr
de pași necesari la retrag ere;
În continuare este prezentat un segment din cadrul unui fișier generat de o deplasare după un arc
de cerc; succesiunea generică a deplasărilor de tipul a,b sau c sunt sugerate de dispunerea prezentate în
figura 1.17 . În figură se disting cele trei ti puri de segmente posibil de executat:

01234567
89
1011 12
13
14151617
18
19
20
21PPPPPPP
PPP
P
P
PPP
SSSC
C
C
contur
nominalP-prelucrare
C-corec ție
S-scurt circuit

46 | P a g e

Figura 1.17

a) segmente în care se realizează prelucrarea propriu -zisă notate cu indicativul p; în figura
menționată exemple de astfel de segmente sunt succesiunile: 0 -1-2-3-4-5-6-7… 10 -11-12-13-14…..
16-17-18-19-20-21….
b) segmente prin intermediul cărora se realizează corecția traiectoriei, în sensul readucerii
punctului curent al traiectoriei peste conturul no minal, aceste segmente fiind notate cu indicativul c; în
cazul figurii precizate se exemplifică succesiune 7 –8-9-10; (și în cazul corecției există posibilitatea de a
apărea scurtcircuite deci microsegmente sc care nu sunt notate în figură);
c) segmente p rin intermediul cărora se realizează retragerea în cazul depistării unui scurtcircuit;
aceste segmente sunt indicate prin prezența indicativului s în figură fiind exemplificate astfel segmentele
14-15-16;
În continuare este listată o secvență din fișierul amintit:
citiri x21=0.080 y21=0.004 x20=0.084 y20=0.001
citiri x21=0.164 y21=0.004 x20=0.168 y20=0.001
citiri x21=0.249 y21=0.004 x20=0.253 y20=0.001
citiri x21=0.333 y21=0.004 x20=0.338 y20=0.001
citiri x21=0.418 y21=0.004 x20=0 .423 y20=0.001
citiri x21=0.502 y21=0.004 x20=0.508 y20=0.001
prel ci1p=1 delta=0.000 x20=0.502 y20=0.004
prel ci1p=2 delta=0.000 x20=0.502 y20=0.004
prel ci1p=3 delta= -0.000 x20=0.503 y20=0.004
prel ci1p=4 delta=0.000 x20=0.503 y20=0.003
prel ci1p=5 delta= -0.000 x20=0.504 y20=0.003

47 | P a g e
prel ci1p=6 delta= -0.000 x20=0.504 y20=0.003
prel ci1p=7 delta=0.000 x20=0.504 y20=0.002
prel ci1p=8 delta= -0.000 x20=0.505 y20=0.002
prel ci1p=9 delta= -0.000 x20=0.505 y20=0.002
prel ci1p=10 delt a=0.000 x20=0.505 y20=0.002
prel ci1p=11 delta= -0.000 x20=0.506 y20=0.002
citiri x21=0.583 y21=0.002 x20=0.584 y20=0.000
citiri x21=0.649 y21=0.002 x20=0.646 y20=0.000
citiri x21=0.732 y21=0.002 x20=0.729 y20=0.000
citiri x21=0.815 y21=0.00 2 x20=0.814 y20=0.000
citiri x21=0.899 y21=0.002 x20=0.899 y20=0.000
citiri x21=0.982 y21=0.002 x20=0.984 y20=0.000
citiri x21=1.066 y21=0.002 x20=1.068 y20= -0.000
citiri x21=1.151 y21=0.002 x20=1.152 y20= -0.000
citiri x21=1.238 y21=0.002 x2 0=1.237 y20= -0.000
citiri x21=1.322 y21=0.002 x20=1.321 y20= -0.000
citiri x21=1.405 y21=0.002 x20=1.406 y20= -0.000
citiri x21=1.486 y21=0.002 x20=1.491 y20= -0.000
citiri x21=1.570 y21=0.002 x20=1.575 y20= -0.000
citiri x21=1.653 y21=0.002 x20=1.660 y20= -0.000
prel ci1p=1 delta=0.000 x20=1.653 y20=0.002
prel ci1p=2 delta=0.000 x20=1.653 y20=0.002
prel ci1p=3 delta= -0.000 x20=1.654 y20=0.002
prel ci1p=4 delta= -0.000 x20=1.654 y20=0.002
prel ci1p=5 de lta=-0.000 x20=1.655 y20=0.002
prel ci1p=6 delta=0.000 x20=1.655 y20=0.001
prel ci1p=7 delta= -0.000 x20=1.655 y20=0.001
prel ci1p=8 delta= -0.000 x20=1.656 y20=0.001
prel ci1p=9 delta= -0.000 x20=1.656 y20=0.001

48 | P a g e
prel ci1p=10 delta=0.000 x20=1 .656 y20=0.000
prel ci1p=11 delta= -0.000 x20=1.657 y20=0.000
citiri x21=1.739 y21=0.001 x20=1.740 y20= -0.000
citiri x21=1.827 y21=0.001 x20=1.825 y20= -0.000
citiri x21=1.915 y21=0.001 x20=1.910 y20= -0.000
citiri x21=1.999 y21=0.001 x20=1.994 y20= -0.000
citiri x21=2.004 y21=0.080 x20=2.004 y20=0.084
citiri x21=2.007 y21=0.161 x20=2.007 y20=0.165
citiri x21=2.011 y21=0.242 x20=2.013 y20=0.245
citiri x21=2.017 y21=0.319 x20=2.020 y20=0.322
citiri x21=2.028 y21=0.395 x20=2.028 y20= 0.398
citiri x21=2.040 y21=0.469 x20=2.039 y20=0.472
citiri x21=2.050 y21=0.541 x20=2.050 y20=0.544
citiri x21=2.060 y21=0.611 x20=2.063 y20=0.615
citiri x21=2.079 y21=0.681 x20=2.078 y20=0.684
citiri x21=2.093 y21=0.749 x20=2.094 y20=0.752
citiri x21=2.114 y21=0.814 x20=2.111 y20=0.819
citiri x21=2.129 y21=0.880 x20=2.130 y20=0.884
citiri x21=2.150 y21=0.945 x20=2.149 y20=0.948
popscurt i1p=2310 index1=0 noul virf=15d f2=b8 sc=200
popscurt i1p=2309 index1=0 noul virf=15c f2=b9 sc=184
popscurt i1p=2308 index1=0 noul virf=15b f2=a9 sc=185
popscurt i1p=2307 index1=0 noul virf=15a f2=99 sc=169
popscurt i1p=2306 index1=0 noul virf=159 f2=89 sc=153
popscurt i1p=2305 index1=0 noul vir f=158 f2=8a sc=137
popscurt i1p=2304 index1=0 noul virf=157 f2=7a sc=138
popscurt i1p=2303 index1=0 noul virf=156 f2=6a sc=122
popscurt i1p=2302 index1=0 noul virf=155 f2=5a sc=106
popscurt i1p=2301 index1=0 noul virf=154 f2=5b sc=90

49 | P a g e
citiri x21=2.168 y21=1.003 x20=2.168 y20=1.007
citiri x21=2.192 y21=1.066 x20=2.190 y20=1.069
citiri x21=2.213 y21=1.129 x20=2.213 y20=1.131
citiri x21=2.238 y21=1.187 x20=2.237 y20=1.190
citiri x21=2.259 y21=1.246 x20=2.262 y20=1.250
citiri x21=2.288 y21=1 .305 x20=2.287 y20=1.308
citiri x21=2.316 y21=1.362 x20=2.315 y20=1.365
citiri x21=2.340 y21=1.418 x20=2.342 y20=1.421
citiri x21=2.371 y21=1.472 x20=2.371 y20=1.476
citiri x21=2.402 y21=1.528 x20=2.400 y20=1.530
citiri x21=2.434 y21=1.580 x 20=2.430 y20=1.584
citiri x21=2.461 y21=1.631 x20=2.462 y20=1.636
citiri x21=2.495 y21=1.683 x20=2.494 y20=1.687
citiri x21=2.528 y21=1.732 x20=2.526 y20=1.738
citiri x21=2.563 y21=1.783 x20=2.560 y20=1.788
citiri x21=2.598 y21=1.830 x20=2.5 94 y20=1.836
citiri x21=2.633 y21=1.878 x20=2.629 y20=1.884
citiri x21=2.667 y21=1.927 x20=2.666 y20=1.932
citiri x21=2.703 y21=1.974 x20=2.703 y20=1.979
citiri x21=2.739 y21=2.020 x20=2.741 y20=2.025
citiri x21=2.779 y21=2.066 x20=2.780 y20=2.070
citiri x21=2.818 y21=2.111 x20=2.820 y20=2.115
citiri x21=2.858 y21=2.155 x20=2.860 y20=2.159
citiri x21=2.899 y21=2.198 x20=2.901 y20=2.201
citiri x21=2.940 y21=2.240 x20=2.943 y20=2.243
citiri x21=2.982 y21=2.279 x20=2.984 y20=2.283
citiri x21=3.028 y21=2.320 x20=3.028 y20=2.323
citiri x21=3.073 y21=2.360 x20=3.072 y20=2.363
citiri x21=3.117 y21=2.398 x20=3.117 y20=2.402

50 | P a g e
citiri x21=3.162 y21=2.436 x20=3.162 y20=2.440
citiri x21 =3.207 y21=2.474 x20=3.209 y20=2.477
citiri x21=3.254 y21=2.512 x20=3.257 y20=2.514
citiri x21=3.300 y21=2.546 x20=3.305 y20=2.549
citiri x21=3.354 y21=2.582 x20=3.354 y20=2.585
popscurt i1p=7955 index1=0 noul virf=3e1 f2=aa sc=186
popscurt i1p =7954 index1=0 noul virf=3e0 f2=ab sc=170
popscurt i1p=7953 index1=0 noul virf=3df f2=ac sc=171
popscurt i1p=7952 index1=0 noul virf=3de f2=9c sc=172
popscurt i1p=7951 index1=0 noul virf=3dd f2=9d sc=156
popscurt i1p=7950 index1=0 noul virf=3dc f2=8d s c=157
popscurt i1p=7949 index1=0 noul virf=3db f2=8e sc=141
popscurt i1p=7948 index1=0 noul virf=3da f2=8f sc=142
citiri x21=3.400 y21=2.614 x20=3.401 y20=2.616
popscurt i1p=8063 index1=0 noul virf=64 f2=6a sc=105
popscurt i1p=8062 index1=0 noul vir f=63 f2=5a sc=106
popscurt i1p=8061 index1=0 noul virf=62 f2=5b sc=90
popscurt i1p=8060 index1=0 noul virf=61 f2=5c sc=91
popscurt i1p=8059 index1=0 noul virf=60 f2=4c sc=92
popscurt i1p=8058 index1=0 noul virf=5f f2=4d sc=76
popscurt i1p=8057 index1=0 noul virf=5e f2=3d sc=77
popscurt i1p=8056 index1=0 noul virf=5d f2=3e sc=61
citiri x21=3.447 y21=2.645 x20=3.449 y20=2.648
citiri x21=3.496 y21=2.678 x20=3.501 y20=2.680
citiri x21=3.550 y21=2.707 x20=3.552 y20=2.711
citiri x21=3.604 y21=2.737 x20=3.606 y20=2.742
citiri x21=3.656 y21=2.768 x20=3.660 y20=2.772
citiri x21=3.716 y21=2.797 x20=3.715 y20=2.801
citiri x21=3.825 y21=2.852 x20=3.828 y20=2.856

51 | P a g e
citiri x21=3.885 y21=2.878 x20=3.886 y20=2.882
citiri x21=3.941 y21=2.904 x20=3.944 y20=2.907
citiri x21=4.004 y21=2.928 x20=4.005 y20=2.931
citiri x21=4.064 y21=2.952 x20=4.066 y20=2.954
citiri x21=4.126 y21=2.974 x20=4.127 y20=2.976
citiri x21=4.190 y21=2.993 x20=4.189 y20=2.997
citiri x21 =4.253 y21=3.014 x20=4.253 y20=3.017
citiri x21=4.319 y21=3.032 x20=4.317 y20=3.035
citiri x21=4.382 y21=3.049 x20=4.383 y20=3.052
citiri x21=4.451 y21=3.066 x20=4.450 y20=3.068
citiri x21=4.521 y21=3.081 x20=4.519 y20=3.083
citiri x21=4.589 y21=3.093 x20=4.586 y20=3.096
citiri x21=4.657 y21=3.105 x20=4.657 y20=3.108
citiri x21=4.726 y21=3.117 x20=4.725 y20=3.118
citiri x21=4.796 y21=3.125 x20=4.793 y20=3.127
citiri x21=4.858 y21=3.129 x20=4.861 y20=3.134
citiri x21 =4.929 y21=3.136 x20=4.929 y20=3.139
citiri x21=4.999 y21=3.140 x20=4.998 y20=3.143
citiri x21=5.065 y21=3.144 x20=5.068 y20=3.146
citiri x21=5.136 y21=3.144 x20=5.140 y20=3.147
citiri x21=5.213 y21=3.144 x20=5.217 y20=3.146
citiri x21=5.411 y21=3.141 x20=5.415 y20=3.136
citiri x21=5.475 y21=3.139 x20=5.477 y20=3.130
prel ci1p=1 delta=0.000 x20=5.476 y20=3.139
prel ci1p=2 delta=0.000 x20=5.476 y20=3.138
prel ci1p=3 delta=0.000 x20=5.476 y20=3.138
prel ci1p=4 delta=0.000 x20=5.4 76 y20=3.138
prel ci1p=5 delta=0.000 x20=5.476 y20=3.137
prel ci1p=6 delta=0.000 x20=5.476 y20=3.137

52 | P a g e
prel ci1p=7 delta= -0.000 x20=5.476 y20=3.137
prel ci1p=8 delta=0.000 x20=5.476 y20=3.136
prel ci1p=9 delta=0.000 x20=5.476 y20=3.136
prel ci1p=10 delta=0.000 x20=5.476 y20=3.135
prel ci1p=11 delta=0.000 x20=5.476 y20=3.135

3.7.2 Rezultate cantitative ale cercetărilor experimentale

Conform celor expuse anterior s -au considerat mai multe variabile de intrare și s -au măsurat mai
multe variabile de ieșire.
Se impun în acest cadru unele precizări asupra definirii următoarelor două variabile specifice
algoritmului de conducere adoptat;
-pragul de eroare pozițională admis – este definită ca abaterea admisibilă a traiectoriei reale față de
cea nominală; pentru exemplificarea din cadrul figurii 8.17 se definește practic o zonă de toleranță sub
forma unei coroane circulare cuprinse între două cercuri concentrice, corespunzătoare dimensiunilor
minime și maxim admisibile;
-perioada de eș antionare corespunzătoare citirii traductoarelor de poziție și simultan a verificării
încadrării în zona de toleranța; aceasta perioadă este materializată în cazul exemplificării din figura, pentru
a ușura perceptibilitatea acestei variabile sub forma unui pas unghiular .
În urma experimentărilor efectuate influența acestor două variabile are influențe substanțiale
asupra stabilității procesului de prelucrare; astfel în cazul adoptării unei perioa de de eșantionare mici și de
asemenea a unei zone de toleranță redusă, deși se obține evident o precizie dimensională mai bună apar
fenomene de instabilitate datorită proceselor de suprareglaj; este afectată astfel stabilitatea procesului prin
intercalarea prea multor segmente de corecție de tipul segmentului C1Q1 din figură; s -a observat chiar o
influență defavorabilă a suprareglajului asupra rugozității. Concluzionând se poate afirma de existența
unui compromis necesar a fi realizat la impunerea valorilor pentru cele două variabile de intrare analizate.

În continuare se analizează valorile obținute pentru diferitele variabile de ieșire (criterii de
performanță).
a) Rugozitatea

În scopul măsurării calității suprafeței cu rugozimetrel e avute la dispoziție s -au prelucrat
semifabricate pătrate de diferite dimensiuni și grosimi; limitarea la această formă a fost impusă de
restricția de a palpa o generatoare rectilinie specifică rugozimetrelor utilizate.

53 | P a g e
În cazul unui reper cu latura de 10 mm dar grosimea de 15 mm s -a determinat o medie a
măsurătorilor de 1.9 um Ra în cazul măsurătorilor pe o direcție în lungul firului și 2.7 um în cazul
măsurătorilor efectuate perpendicular pe direcția firului

Figura 1.18

Rezultate ale măsurărilor în sistemul Ra

Reper pătrat cu latura de 10 mm și grosime de 5mm
în lungul firului perpendicular pe fir
1.5 2.4
1.45 2.45
1.52 2.48
1.47 2.51
1.51 2.55
C1
B1A1
Q1O
contur real
contur nominal
dimensiune
admisibil ă maxim ă
dimensiune admisibil ă
minimă

54 | P a g e
1.52 2.56
1.6 2.45
1.61 2.5
1.6 2.46
1.57 2.51

b) Precizia dimensională și abaterea de la circularitate
Întrucât s -au folosit semifabricate circulare, cei doi parametri au fost determinați simultan prin
măsurarea diametrelor după mai multe orientări unghiulare și în cadrul diferitor secțiuni.
Abaterea de la circularitate a condus la următoarele rezultate, în tabelul următor prezentându -se
numai media măsurători lor abaterilor de circularitate:
Unitatea de măsură pentru perioada de eșantionare în experimentările efectuate este numărul de
pași efectuat de utilaj (un pas având 0.0005 mm =0.5 um), după care se efectuează citirea traductorilor de
poziție și implicit e fectuarea unui segment de corecție dacă se impune.
Concluzii asupra rezultatelor prezentate în tabel de mai jos:
diametrul
probei
[mm] grosime
proba
[mm] prag de eroare
pentru activare
seg. corecție
[mm] perioada de
eșantionare
convențională
[*] abatere de
circularitate
[mm]
6 1 0.010 170 0.020
6 1 0.009 170 0.015
6 1 0.009 170 0.016
6 1 0.009 100 0.014
6 10 0.009 170 0.03
20 1 0.009 170 0.017
20 10 0.009 170 0.035

– primele patru probe au fost efectuate în condiț ii aproximativ identice (diferind în cazul unei
singure probe) perioada de eșantionare; astfel s -a putut estima precizia dimensională (care reclamă
efectuarea măsurătorilor pe un lot de repere și prelucrarea statistică a rezultatelor); astfel pentru
dimens iunea de 6 mm și grosimea de 1 mm s -a obținut o precizie dimensională corespunzătoare clasei
a-7-a de precizie, în timp ce pentru grosimi de 10 mm, precizia dimensională corespunde claselor 8,9;

55 | P a g e
– surprinzător o dată cu creșterea diametrului la valoarea de 200 mm, toleranța dimensională nu a
crescut corespunzător conform fundamentelor teoriei toleranțelor; astfel pentru un diametru de 20 mm și
grosime de 1 mm, s -a obținut o precizie corespunzătoare claselor 6 -7, în timp ce în cazul probei cu
diametru 20 mm și grosimea de 10 mm corespunde clasa de precizie 8;
– se observă scăderea preciziei dimensionale o dată cu creșterea grosimii probei, la grosimi mari
fiind oportună evaluarea abaterii de cilindricitate și nu a celei de circularitate;
– așa cum se preconiza cele două variabile estimate perioada de eșantionare și pragul de eroare
pentru declanșarea mecanismului de corecție influențează precizia de prelucrare dar și stabilitatea
procesului.

3.8 Interfațarea traductorilor de poziție

Traductorii de poziție utilizați sunt de tipul traductorilor incrementali numerici liniari pentru
prelucrarea semnalelor generate de aceștia , semnalele A și B (trenuri de impulsuri dreptunghiulare
decalate la 90 de grade în funcție de sensul de mișcare) s -au utilizat circuite de interfață specializate de
tipul TCHT12024, 12016 produse de Texas Instruments
Este un circuit programabil, având următoarele posibilități de lucru selectabile prin valorile
aplicabile pinilor M1,M2,M3.
Conform celor precizate în pa ragraful 6.1 s -au utilizat cinci asemenea circuite, câte două (deci
patru octeți disponibili) pentru numărarea impulsurilor primite de la traductorii de poziție aferenți celor
două axe, și unul pentru gestionarea impulsurilor primite de la generator.

Mod M2 M1 M0 Funcții îndeplinite
0 0 0 0 numărător bidirecțional pe 16 biți
1 0 0 1 numărător simplu sincronizat cu A si determinare direcție
(sens)
2 0 1 0 idem, dar sincronizare cu B
3 0 1 1 numărător cu dublarera rezoluției sincron cu A și

56 | P a g e
determinare sens
4 1 0 0 idem, dar sincronizare cu B
5 1 0 1 numărător cu mărirea de patru ori a rezoluției, sincron cu
toate fronturile și deter minare sens
6 1 1 0 măsurarea duratei unui impuls
7 1 1 1 măsurarea frecvenței

Adresele utilizate pentru porturile respective, conform interfațatării cu magistrala ISA a
calculatorului sunt:

msb1 lsb1 msb2 lsb2
axa1 (x) o4h o5h 0eh ofh
axa2 (y) 08h 09h oah 0bh
axa3 0ch 0dh – –

Este esențială păstrarea ordinii de citire a celor patru octeți care compun valoarea poziției pe o
axa, în cadrul aplicației prezentate optându -se pentru combinația:

lsb1 lsb2 msb1 msb2

În final este prezentată funcția C care face citirea traductorilor, încărcarea porturilor circuitului și
asamblarea (compunerea) valorilor citite în scopul obținerii poziției curente în microni:

float trad (int axa) {
unsigned long impuls=0L;
int i, result[4], port;
long rez;
int tab1[4] = {0x5, 0xf, 0x4, 0xe}; //s -a schimbat de la 5,7,4,6
int tab2[4] = {0x9, 0xb, 0x8, 0xa};

57 | P a g e
int tab3[2] = {0xd,0xc};
// clrscr();
// printf(" \n");
for (i=0; i<=3; i++) {
if(axa==0) p ort=ADRTIRO+tab1[i];
else if(axa==1) port=ADRTIRO+tab2[i];
result[i]=inportb(port);
// printf(" i=%d r[i]=%d",i, result[i]);
}
// printf(" \n %3d %3d %3d %3d", result[1], result[3], result[0], result[2]);
impuls=1L*result[1]+256L*result[3]+256L*25 6*result[0];
// +256L*256*256*result[2]; // nu au rost 4 octeti
rez=(impuls -262144);
// printf(" \n imp=%9li", impuls);
// printf(" \n rez=%d ", rez);
return 0.001*rez*TRAD;
}
Anexe:
Programul sursă C

#include<stdio.h> /* fee10.c 02.07.1998 INT ERP. DELTA utilizare buton */
#include<conio.h> /* CORECTIE CU REDEFINIRE CITIRE TRADUCTORI */
#include<math.h> // Includ intreruperi avarie STIVE NOI cu 3 pop la un pas
#include <graphics.h> // LPT tetrade schimbate intre ele
#include <process.h>
#include <alloc.h>
#include <dos.h>
#define PI 3.1415926
#define BA 0x340

58 | P a g e
#define ADRTIRO 0x330
#define m 50
#define N1 333 // 100
#define N 1000 // 4000
#define MINX 0x00
#define MINY 0x00
#define GROSOLAN 0.05
#define PAS 0.0005 // 0.001 Bul 0.0005 Oradea 0.0003 cat. tm
#define TRAD 1 // =2 pt. YAL -K =1 pt. J.HEIDENHEIN
#define INTR 0X0F
#define COR 0.011 //!!! 0.011 mai bine
#ifdef __cplusplus
#define __CPPARGS …
#else
#define __CPPARGS
#endif

int tabs1[N], index1, tabs2[N], index2; // st ive secvente AXA sau EPROM
int index5, index3, index4, index6;//y20,x20prel y20,x20 scurt
float tabs3[N], tabs5[N], tabs4[N], tabs6[N];
int f1=0x00,count;
unsigned int nrscurt=0; /* nr de pasi inapoi la scoatere scurt */
int o=0xff;
int scurt=0, cadran=1;
int i,se1=1,se2=1,v,n,j,l,ind,ms=0x0f,kxy=1;
int i1=0x06, i2=15, i3=0x60, i4=0xf0; /* initializxari contori axa */
char tab1[15],tab[m],*buf1, *buf2,*buf4, buf3[30],buf5[50], regim;
float pas=PAS; /* !!! 0.001Bulgaria 0.00053 Rom si 0.0045 laser */
/* mm deplasare la un pas unghiular MPP */

59 | P a g e
int v=2, timp, syncro; /* viteza scurt si reveniri */
int tcw, ta, tb, tc, pa, pb, pc, cw;
FILE *fpo;
float x20, y20; // poz. moment
float x60, y60; // poz. finale de transmitere intre arce de c erc

double unghi(float,float,float,float);
void circdel (float, float, double, double, float, float);
void circular(float,float,float,float,float,float);
void algoritm (double, double, double, double, double, double);
void algoritmd (double, double, doubl e, double, double, double);
// void algoritm1(float,float,float,float);
float trans(void);
float trans1(void);
void axax(void);void axay(void);
void axaxd(void);void axayd(void);
void axaxy(void);
void interrupt (*oldhandler) (__CPPARGS);
void push1 (int); int pop1 (void); void push2 (int); int pop2 (void);
void push3 (float); float pop3 (void);
void push5 (float); float pop5 (void);
void push4 (float); float pop4 (void);
void push6 (float); float pop6 (void);
float trad (int);

void interrupt handler(__CPPARGS) {
int avarie,z2=0,kbst;
char *string;

60 | P a g e
// continutul subrutinei de tratare intrerupere HARD -IRQ7 generata la
// pinul 10(ACK) LPT, care este totodata bitul 6 al octetului (deci
// masca si=0100 0000=0x40) citibil inp (0x379).
// disable();
outportb(0x21,inp(0x21)|0x80);
outportb(0x20,0x20);
outport(0x378, inp(0x378) &0xfb); //37a ->378 defectare bit 2
count++;
setviewport(480,430,530,460,0);
outtext("AVARIE");
delay(2000);
// printf("COUNT= %d AVARIE ",count); // NO in regim grafic
while(z2==0) {
kbst=kbstatus();
z2=kbst & 0x02; // ramain in bucla pana se remediaza avaria
// operatorul semnalind prin apasarea lui SHIFT stg
}
// oldhandler();
clearviewport(); // sterf fereastra curenta
setviewport(0,0,getmaxx(),getmaxy(),0);
outportb(0x37a,inp(0x37a) | 0x01); // bit 0(pin1) pus pe 0 pt. E555,
// respectiv pe 1 in instructiunedat. complementarii,
// raminere pe palier pana la aceasta resetare
delay(20);
outportb(0x37a,inp(0x37a) & 0x fe); // repus pe 1=stare normala (0compl)
outport(0x378, inp(0x378) |0x04); // ROGIF DA,
outportb(0x21,inp(0x21)&0x7f); // revalidare irq7
// }
}

61 | P a g e
void initial (void){
int i, result[4], port, axa=0, bit;
unsigned long impuls;
float konst=0.001; / / constanta nr.impulsuri < -> mm deplasare
int tab1[4] = {0x5, 0xf, 0x4, 0xe}; //s -a schimbat din 5,7,4,6
int tab2[4] = {0x9, 0xb, 0x8, 0xa};
int tab3[2] = {0xd,0xc};
outport(0x378, inp(0x378) &0xfb); // ROGIF nU
outportb(0x37a,inp(0x37a) | 0x01); // bit 0(pin1) pus pe 0(compl 1) pt. E555,
delay(20);
outportb(0x37a,inp(0x37a) & 0xfe); // 555 1=0complstare normala -bit0(pin1)
outport(0x37a, inp(0x37a) | 0x02);// regim automat bit 1(pin14) pe 0=compl1
// bit=inport(0x37a); printf(" \n bit=%x",bit);
// INITIALIZARI TRADUCTORI TREBUIE EFECTUATE DE MANUAL, AICI PUNERE LA
PUNCT
// outport(ADRTIRO+0x00,'b'); // reset simultan pt.cele 3 canale TIRO
// outport(ADRTIRO+0x5,0x4); //inscriu in octetul lsbmsb 0000.0100 ->
// outport(ADRTIRO+0x9,0x4); // o axa este initializata cu 2^18=262.144
}

void main(){
int i,k,k1,z3=0,z4=0,z5=0,kbst=0; /* j indicator al poz. in fraza */
float x1,y1,x2,y2,x2v=0,y2v=0,i2,j2;
char c,numef[20],tab5[m],reg6;
unsigned dimens1,dimens2, dimens4;
FILE *fps;
int graphdriver=DETECT,gmod;
outport(0x378, inp(0x378) &0xfb); // ROGIF NU
// if((fpo=fopen("d: \\FILES \\FIR\\ORADEA \\fpo.txt","w"))==NULL) {
// puts("nu pot crea fisierul destinatie");

62 | P a g e
// return; }
initgraph(&graphdriver,&gmod,"c: \\bc\\bgi");
/* ecranul de prezentare */
clrscr();
setcolor(RED);
setbkcolor(CYAN);
settextstyle(0,0,3);
outtextxy(10,110,"NUMERIC CONTROL");
outtextxy(5,160,"FOR ELECTRICAL EROSION");
delay(2000);
clrscr();
closegraph();
printf(" \nnume fisier s ursa? :");
// printf(" \n prelucrare, desenare pe masina, vizualizare?? P sau D sau V \n");
scanf("%s" ,numef);
// scanf("%s %c",numef, &regim);

initial();
oldhandler=getvect(INTR);
outportb(0x37a,inp(0x37a)|0x10); // ACK 0001 0000
// outportb(0x21,inp(0x21)&0x7f);// !!!!!!!! NU MERGE AICI
outportb(0x20,0x20); //
if((fps=fopen(numef,"r"))==NULL){
puts("nu pot deschide fisierul sursa");
return;
}
initgraph ( &graphdriver, &gmod, "c: \\bc\\bgi");
setcolor(YELLOW);
circle( 10,10,.1);

63 | P a g e
dimens4=imagesize(8,8,12,12);
buf4=(char*)malloc(dimens4);
getimage(8,8,12,12, buf4);
putimage(2000,10,buf4,OR_PUT);
outportb(0x21,inp(0x21)&0x7f);//
// closegraph(); // numai pt HERCULRS

// initial(); prost plasat aici deoarece decu pleaza!
while(!feof(fps)){
for(j=0;j<m;j++){
c=getc(fps); /* citire cite un caracter */
if((c==' \n')&&(j<m)){
k1=m -j;
for(k=j;k<m;k++)
tab[k]='#';
break;
}
else tab[j]=c;
}
tab[m -1]='\n'; /* tab[j] contine o fraza */
for(j=0;j<m;j++){
if(tab[j]=='#') tab5[j]=' ';
else tab5[j]=tab[j];
}
kbst=kbstatus();z5=kbst & 0x40;
if (z5==0) regim='D';
else regim='P';
gotoxy(1,25); printf("%c",regim);
gotoxy(26,25);
sprintf(buf5," %s",tab5);

64 | P a g e
puts(buf5); /* varianta pt. 386 cu print dinamic */
/* printf(" \n apasati shift dreapta pt. oprire program"); */
for(j=0;j<m;j++){
if(tab[j]=='G') {ind=tab[j+1] -48; j+=2;}
if(tab[j]=='X')
{ x2=trans1();}
if(tab[j]=='I')
{ i2=trans1();}
if(tab[j]=='Y')
{ y2=trans1();}
if(tab[j]=='J')
{ j2=trans1();}

if(tab[j]=='M' && tab[j+1]=='2') {/* outport(0x378,0x00 )*/
exit(1);}
if(tab[j]=='M' && tab[j+1]=='6' // && regim!='V' && regim!='v'
) {
// deplasare fara fir // regim='D';
reg6='6'; //pt. a nu veni reg P sa porneasca
outport(0x378, inp(0x378) & 0xfb); // ROGIF NU
gotoxy(6,26); printf(" apasati CTRL pt. deplasare");
// pauza pt a rupe firul
while(z3==0) {
kbst=kbstatus();
z3=kbst & 0x0 4; // ramain in bucla pana se apasa CTRL
}
syncro=1;
setvect(INTR,oldhandler);
gotoxy(6,26); printf(" ");
}

65 | P a g e
if (tab[j]=='M' && tab[j+1]=='7' ) {
// prima fraza dupa o depl fara fir sau prel in ge neral
// regim='P';
outport(0x378, inp(0x378) |0x04); // ROFIF DA
gotoxy(6,26); printf(" apasati ALT pt prelucrare");
while(z4==0) {
kbst=kbstatus();
z4=kbst & 0x08; // ramain in bucla pana se apasa ALT
}
syncro=0;
setvect(INTR,handler);
gotoxy(6,26); printf(" ");
}

/* if(tab[j]=='M' && tab[j+1]=='3') {ms=0xff;}
if(tab[j]=='M' && tab[j+1]=='5') {ms=0xff;} pt. laser -freza */
} // inchid for
// initgraph (&g raphdriver, &gmod, "c: \\bc\\bgi");
if ( regim=='P' && reg6!='6') {
timp=0; // 13 PT. CLASIC eventual constanta de material
setvect(INTR,handler);
syncro=0;
delay(200);
outport(0x378, inp(0x378) |0x04);
}
else { // deci desenare, vizualizare
timp=0; syncro=1;
setvect(INTR,oldhandler);
scurt=0; // exclud posibilitatea scurtului
delay(200);

66 | P a g e
outport(0x378, inp(0x378) &0xfb); // ROGIF NU
}
if(ind==1) {
// if( !(regim=='V' || regim=='v')) { // la vizualizare nu ma leg de masina
x2v=trad(0); y2v=trad(1); // imbunatatire pt. a pleca din poz. momentan
if (regim == 'P') algoritm(x2v,y2v,x2,y2,0,0);
else algoritmd (x2v,y2v,x2,y2,0,0);
x2v=x2;y2v=y2;
}
if(ind==2 || ind==3){
circular(x2v,y2v,x2,y2,i2,j2);
x2v=x2;y2v=y2;
}
} //sfirsit while deci fisier
close(fps);
closegraph();
free(buf1);free(buf4);
delay(300);
outport(0x378, inp(0x378) &0xfb);
setvect(INTR,oldhandler) ;
printf(" \n Count=%d",count);
}

int kbstatus(void){
union REGS ireg;
ireg.h.ah=0x02;
int86(0x16,&ireg,&ireg);
return ireg.h.al;
}

67 | P a g e

void circdel (float x50, float y50, double uin0, double ufin0, float i50, float j50){
// interpolare circulara prin calculul direct al unui detrminant
float x51, y51,x61,y61;
float dun=ufin0 -uin0;
int k1, f2, inceput_fraza=10, nrscurt=0;
// clrscr();
x20=x50; y20=y50;
cadran=1; // vital pt. a nu influenta cadranul urmator
// printf (" \n uin=%5.3f ufin=%5.3f ind=%d x5=%5.3f y5=%5.3f ",
// uin0, ufin0, ind, x50, y50);

// x50-=i50; y50 -=j50;// incerc renuntarea la translatie
x60 = (x50 -i50)*cos(dun) – (y50-j50)*sin(+dun) + i50;
y60 = (x50 -i50)*sin(dun) + (y50 -j50)*cos(dun) + j50;
// printf (" \n tr uin=%5.3f ufin=%5.3f ind=%d x5=%5.3f y5=%5.3f x6=%5.3f y6=%5.3f ",
// uin0,ufin0,ind,x50,y50,x60,y60);

if ((uin0>PI/2 && uin0<PI) || (uin0==PI && ufin0<PI && ufin0>=PI/2)
|| (uin0==PI/2 && ufin0>PI/2 && ufin0<=PI))
{ cadran= -1;} // cad II
else {
if ((uin0>3*PI/2 && uin0<2*PI)||
(uin0==2*PI && ufin0<2*PI && ufin0>=3*PI/2)
|| (uin0==0 && ufin0<2*PI && ufin0 >= 3*PI/2)
|| (uin0==3*PI/2 && (ufin0>3*PI/2 || ufin0==0)))
cadran= -1; // IV
}
if (regim == 'P') algoritm(x50,y50,x60,y60,i50,j50);

68 | P a g e
else algoritmd (x50,y50,x60,y60,i50,j50);
}

void algoritm( double x54, double y54, double x64,
double y64, double i54, double j54) {
// double xi=x54, yi=y54; // coordonate curente
int nrscurt=0, inceput_fraza=10, sm, f2, sc=0, rev=0,z2=0,kbst=0;
long int i1p=0;
int g=0, se11, se22;
double delta;
float panta;
double x21, y21;
unsigned int lsb,msb,nou,vechi=0;
float num=x64 -x54;
x21=trad(0); y21=trad(1);
printf ("\n simulati val citite la inceput fraza x21,y21 =");
scanf("%f %f", &x21, &y21);
x54=x21; y54=y21; // imbunatatire pt. a pleca din poz. momentan
x20=x54; y20=y54; //PROTECTIE PT. A NU DETERIORA ALGORITMUL
if (num==0) sm= -1;
else { panta=(y64 -y54)/(x64 -x54);
if (panta>=0) sm= -1; else sm=1; }
if (x54<x64) se1=1; else se1= -1;
if (y54<y64) se2=1; else se2= -1;

// while ( !(fabs (x20 -x64) <= 5*pas && fabs(y20 -y64) <= 5*pas) ) {
while ( (fabs (x20 -x64) >= 5*pas) || (fabs(y20 -y64) >= 5*pas) ) {

g++; //inceput_fraza –; //intirziere la inceput de fraza

69 | P a g e
// if( inceput_fraza >0)
delay(timp);
// if (kbstatus() & 0x01) {
// delay(50);
// outport(0x37a, inp(0x37a) &0xfb);exit(1);
// } /* oprire cu shift dreapta */
// printf(" \n in nou=%d vechi=%d", nou,vechi);
nou=inportb(ADRTIRO+0xd); // AXA 3 TIRO
if(regim=='p' || regim=='P')
scurt=((inport(0x379)) & 0x80); // LPT pin 11< ->bit7
// gotoxy(2,0);
// printf(" \n in scurt=%d nou=%d vechi=%d regim=%c", scurt ,nou,vechi,regim);
if(( nou!=vechi) && (scurt==0)) /* == 1 pt. ADAcdt prelucrare */
// if (kbstatus() & 0x02) /* conditie simulata cu SHIFT STG */
{
// gotoxy(2,0);
// printf(" \n in scurt=%d nou=%d vechi=%d regim=%c", scurt,nou,vechi,regim );
i1p++; nrscurt=0;
if (ind==1) {
// if(y54==y64) delta=0;
// else if(x54==x64) delta=1.;
// else {delta=sm*((x64 -x54)*(y20 -y54)-(y64-y54)*(x20 -x54));}
// else
{delta=sm*((x64 -x21)*(y20 -y21)-(y64-y21)*(x20 -x21));}
// 1) x,y20 -> x,y21 pt ca dupa citire coord teoretice trebuie
// actualizatese realizeaza la citirig%140
// 2) x,y54 -> x,y21 pt a redefini seg. ramas de executat
}
else { // interpolare circulara

70 | P a g e
delta=((x20 -i54)*(x20 -i54)-(x54-i54)*(x54 -i54)
+(y20 -j54)*(y20 -j54)-(y54-j54)*(y54 -j54)) * cadran;// aspectul 2 inca
nu
if (ind==3) delta= -delta;
}
if ( delta>0 || num==0 ) {
axay(); // delay(1000); clrscr();
y20=y20+se2*pas; // y20=yi;
}
else{ if(delta<=0){
axax();// delay(1000); clrscr();
x20=x20+se1*pas; }
// else{ axaxy();
// x20=x20+se1*pas; y20=y20+se2*pas;}
}
if((g%170)==0) { // GRAFIC //g%170
kxy=2;
putimage(250+x20*kxy,200 -y20*kxy,buf4,OR _PUT);/* printare poz.
masina */
if (kbstatus() & 0x01) { exit(1);} /* oprire cu shift dreapta */
// if (kbstatus() & 0x01) { //oprire cu SHIFT dr.
// delay(50);
// outport(0x378, inp(0x378) &0xfb); // exit(1);
// while(z2= =0) {
// kbst=kbstatus();
// z2=kbst & 0x02; // ramain in bucla pana
se reporneste
// operatorul semnalind prin apasarea lui SHIFT stg
// }
// outport(0x378, inp(0x378) |0x04);

71 | P a g e
// z2=0;
// } /* oprire cu shift dr eapta */
}

push3(x20); push5(y20);
gotoxy(4,25);
sprintf(buf3,"x=%6.3f y=%6.3f ",x20,y20);
// outtextxy(20, 300, buf3); /* varianta pt. HERCULES */
puts(buf3); /* varianta pt >=CGA */
// if( !(regim=='V' || regim=='v')) { // la vizualizare nu ma leg de masina
if((g%140)==0) { // 140 VARIANTA CU UN SEGMENT DE CORECTIE
x21=trad(0); y21=trad(1);
// delay(5);
// gotoxy(2,3);
printf(" \n simulati val citite x21,y21 =");
scanf("%f %f", &x21, &y21);
// fprintf(fpo," \n citiri x21=%5.3f y21=%5.3f ",x21,y21);
// se11=se1; se22=se2; //salvare pt. a nu fi afectate de alg1;
gotoxy(2,2);
printf(" \n prel i1p=%9li delta=%5.3f x21=%7.3f y21=%7.3f x20=%6.3f
y20=%6.3f ",
i1p,delta,x21,y21,x20,y20);
// fprintf(fpo," \n prel i1p=%d delta=%5.3f x21=%5.3f y21=%5.3f x20=%5.3f
y20=%5.3f ",
// i1p,delta,x21,y21,x20,y20);
// delay(1000); // PENTRU TESTE
// if ( (fabs (x20 -x21) >= GROSOLAN || fabs(y20 -y21) >= GROSOLAN) ){
// printf(" \n CITIRE GRESITA"); exit(1);}
x20=x21; y20=y21; // 1) pt. ca teoreticele sa fie reale
num=x64 -x21;

72 | P a g e
if (num==0) sm= -1;
else { panta=(y64 -y21)/(x64 -x21);
if (panta>=0) sm= -1; else sm=1; }
if (x20<x64) se1=1; else se1= -1;
if (y20<y64) se2=1; else se2= -1;
// algoritm1(x21,y21,x20,y20);
// }
// se1=se11; se2=se22; // restaurari
// }
}
// delay(500); // ! SIMULARE
vechi=nou+syncro; sc=0; // !! SIMULARE
} // inch id prelucrarea

else { /* else de la if prelucrare deci scurt+revenire */
// scurt=inport(pa) & 0x01; // pe ADA
if(regim=='p'|| regim=='P')
scurt=((inport(0x379)) & 0x80); // LPT pin 11,bit7
/* mascare biti 1=7 -> scurt=bit0=PA08255 = pin 37 ADA1100 */
// while (kbstatus() & 0x04) /* conditie simulata cu ALT */
while (scurt!=0) /* retragere din scurt */
{
// if(regim=='p' || regim=='P')
scurt=((inport(0x379)) & 0x80); // LPT pin 11,bit7
nrscurt++;
if(sc!=0) i1p–;
sc=1;
// delay(1000); // SIMULARE
f2=pop1(); outport(0x378,f2); // trimitere sens inainte de tact

73 | P a g e
// fprintf(fpo," \n sens x20=%5.3f y20=%5.3f f2=%x ",x20,y20,f2);
push2(f2 ^ 0x30);// schimbat semnul p
delay(v);
f2=pop1 (); /* scoatere din stiva urmata de outporturi */
x20=pop3(); y20=pop5(); push4 (x20); push6(y20);
gotoxy(4,25);
sprintf(buf3,"x=%6.3f y=%6.3f ",x20,y20); puts(buf3);
// delay(300); //simulare
// gotoxy(2,3);
// print f("\n popscurt i1p=%9li index1=%d noul virf=%x f2=%x nrscurt=%d",
// i1p,index1, tabs1[index1], f2, nrscurt);
// fprintf(fpo, " \n popscurt i1p=%d index1=%d noul virf=%x f2=%x sc=%d",
// i1p, index1, tabs1[index1], f2, nrscurt);
outport (0x378, f2); rev=0;
// fprintf(fpo," \n front 1 x20=%5.3f y20=%5.3f f2=%x ",x20,y20,f2);
// i1= f2 & 0x0f; // pt. a nu fi salturi motor/ la var. EPROM
// i3= f2 & 0xf0;
// ce scot din s1 pun in s2 pt. eventuala rev.); */
push2(f2 ^ 0x30);// schimbat semnul prin sau exclusiv cu masca
//0x30=0011 0000, bitii 4=sx,5=sy ^1 ->complementati,restul neschimbat
// printf(" \n pushscurt index2 %d %x", index2, tabs2[index2]);
f2=pop1(); outport(0x378,f2); // al doilea front al tac tului
// fprintf(fpo," \n front 2 x20=%5.3f y20=%5.3f f2=%x ",x20,y20,f2);
push2(f2 ^ 0x30);// schimbat semnul
// printf(" \ns=%d",nrscurt);
if (nrscurt > N1) {
// printf("scurt");
gotoxy(2,9);
printf (" scurt prelungit apasati SHI FT STANGA dupa remediere nr=%d N=%d",
nrscurt, N);

74 | P a g e
outport(0x378, inp(0x378) &0xfb); // ROGIF NU
while(z2==0) {
kbst=kbstatus();
z2=kbst & 0x02; // ramain in bucla pana se remediaza avaria
// operatorul semnalind prin apasarea lui SHIFT stg
}
z2=0; // exit(1);
gotoxy(2,9);
printf ("
");

outport(0x378, inp(0x378) |0x04);
}
} // s -a terminat while scurt
} /* inchid else scurt+revenire */
while (i1p<0) { // situatia in care scurtul a dus la intrarea
// in fraza prec. si trebuie sa fac revenire din scurt
if(rev!=0) i1p++;
rev=1;
f2=pop2();
// delay(1000); // pt. simulare
outport(0x378,f2); push1(f2^0x30);
// i1=f2 & 0x0f; i3=f2 & 0xf0;
f2=pop2();outport(0x378,f2); push1(f2^0x30); // al doilea front al unui tact
f2=pop2();outport(0x378,f2); push1(f2^0x30); // al treilea outport
// gotoxy(2,4);
// printf(" \n rev<0PREL i1p=%9li index2=%d noul virf=%x f2=%x sc=%d",
// i1p, index2, tabs2[index2], f2,
nrscurt);
// fprintf(fpo, " \n revenire i1p=%d index2=%d noul virf=%x f2=%x sc=%d",

75 | P a g e
// i1p, index2, tabs2[index2], f2, nrscurt);
x20=pop4();y20=pop6();push3(x20);push5(y20);
// delay(300); // SIMULARE
gotoxy(4,25);
sprintf(buf3,"x=%6.3f y=%6.3f ",x20,y20);
puts(buf3);
}
// delay(150); // NUMAI PT. SIMULARE
// gotoxy(2,1);
// printf(" \n i1p=%9li x20=%f y20=%f sc=%d se2=%d", i1p, x20, y20, nrscurt, se2);
// fprintf(fpo, " \n i1p=%d xi=%f yi=%f sc=%d", i1p, xi,yi, nrscurt);
vechi=nou+syncro;
} /* inchid while mare atingere cota finala */
// x21=trad(0); y21=trad(1); // penru fraza urmatoare
// if( !(r egim=='V' || regim=='v'))
// algoritm1(x21,y21,x64,y64); // corijarea de sfirsit de fraza
}

float trad (int axa) {
unsigned long impuls;
int i, result[4], port;
float konst=0.001; // constanta nr.impulsuri < -> mm deplasare
long rez;
int tab1[4] = {0x5, 0xf, 0x4, 0xe}; // initial 5,7,4,6
int tab2[4] = {0x9, 0xb, 0x8, 0xa};
int tab3[2] = {0xd,0xc};
for (i=0; i<=3; i++) {
if(axa==0) port=ADRTIRO+tab1[i];
else if(axa==1) port=ADRTIRO+tab2[i];

76 | P a g e
result[i]=inportb(port);
// printf(" i=%d r[i]=%d",i, result[i]);
}
impuls=1L*result[1]+256L*result[3]+256L*256*result[0];
// +256L*256*256*result[2]; //nu au rost 4 octeti
rez=(impuls -262144);
// printf(" %d %d %d imp=%9li rez=%d",
// result[1],result[3],result[0],i mpuls, rez);
return 0.001*rez*TRAD;
}

void algoritmd( double x54, double y54, double x64,
double y64, double i54, double j54) {
// double xi=x54, yi=y54; // coordonate curente
int nrscurt=0, inceput_fraza=10, sm, f2, sc=0, rev=0,z2=0,kbst=0;
int g =0, multiplic=4;
double delta;
float panta;
float x21, y21; // double
float num=x64 -x54;
x21=trad(0); y54=trad(1);
printf(" \n simulati val citite la inceput fraza x21,y21 =");
scanf("%f %f", &x21, &y21);
x54=x21; y54=y21; // imbunatatire pt. a pleca din poz. momentan
x20=x54; y20=y54; //PROTECTIE PT. A NU DETERIORA ALGORITMUL
if (num==0) sm= -1;
else { panta=(y64 -y54)/(x64 -x54);
if (panta>=0) sm= -1;

77 | P a g e
else sm=1; }
if (x54<x64) se1=1; else se1= -1;
if (y54<y64) se2=1; else se2= -1;

while ( (fabs (x20 -x64) >= 3*multiplic*pas) || (fabs(y20 -y64) >= 3*multiplic*pas) ) {
g++;
if (ind==1) {
// if(y54==y64) delta=0;
// else if(x54==x64) delta=1.; // else
{delta=sm*((x64 -x54)*(y20 -y54)-(y64-y54)*(x20 -x54));}
// else
{delta=sm*((x64 -x21)*(y20 -y21)-(y64-y21)*(x20 -x21));}
}
else { // interpolare circulara
delta=((x20 -i54)*(x20 -i54)-(x54-i54)*(x54 -i54)
+(y20 -j54)*(y20 -j54)-(y54-j54)*(y54 -j54)) * cadran;
if (ind==3) delta= -delta ;
}
if ( delta>0 || num==0 ) {
axayd();axayd();axayd();axayd(); // delay(1000); clrscr();
y20=y20+multiplic*se2*pas; // y20=yi;
}
else{ if(delta<=0){
axaxd();axaxd();axaxd();axaxd();// delay(1000); clrscr();
x20=x20+mult iplic*se1*pas;
}}
if((g%170)==0) { // GRAFIC //g%170
kxy=2;
putimage(250+x20*kxy,200 -y20*kxy,buf4,OR_PUT);/* printare poz.
masina */

78 | P a g e
if (kbstatus() & 0x01) { exit(1);} /* oprire cu shift dreapta */
}
gotoxy(4,25);
sprintf(buf3,"x=%6.3f y=%6.3f ",x20,y20);
puts(buf3);
if((g%140)==0) { // 140 VARIANTA CU CITIRE PERIODICA
x21=trad(0); y21=trad(1);
// gotoxy(2,3);
printf(" \n simulati val citite x21,y21 =");
scanf("%f %f", &x21, &y21);
gotox y(2,2);
printf(" \n desen delta=%5.3f x21=%7.3f y21=%7.3f x20=%6.3f y20=%6.3f "
, delta,x21,y21,x20,y20);
// delay(1000); // PENTRU TESTE
// if ( (fabs (x20 -x21) >= GROSOLAN || fabs(y20 -y21) >= GROSOLAN) ){
// printf(" \n CITIRE GRES ITA"); exit(1);}
x20=x21; y20=y21; // Aspect 1) corectare pt. ca teoreticele sa fie reale
num=x64 -x21;
if (num==0) sm= -1;
else { panta=(y64 -y21)/(x64 -x21);
if (panta>=0) sm= -1; else sm=1; }
if (x20<x64) se1=1; else se1= -1;
if (y20<y64) se2=1; else se2= -1;
} // inchid corectie g%140
// delay(500); // ! SIMULARE
} // inchid while mare
}

void axay(void){

79 | P a g e
int oy,oyin ;
// bit4=pin6=sens x 5 -7=sens y 6 -8 tact x bit7 -9 tact y
if(se2==1){ /* sens y+ pe reper */
oyin = o & 0xdf;
outport(0x378, o= (o | 0x60) & 0x7f); delay(1); // 011*
// fprintf(fpo," y+ o=%x", o); // delay(1000);
/* sx neschimbat biti1=sy 2=tx (x inactiv -> tx ramane 1) pusi pe 1 ->
// masca si=05, bit 3=ty pus pe 0, front negativ -> masca sau=f7*/
oy= (o & 0xdf); // 1111 1101 fortez in stiva sy=0 restul neschimbat (o & 0xdf); // 1111 1101
fortez in stiva sy=0 restul neschimbat
outport(0x378, o=o | 0x80); // fata de primul out ty=1
// fprintf(fpo ," y+ o=%x", o); // delay(1000);
push1 (o & 0xdf); /* // 1111 1101 fortez in stiva sy=0 restul neschimbat */
push1 (oy);
push1 (oyin);
}
else { /* sens y – pe reper */
oyin = o | 0x20;
outport(0x378, o= (o | 0x40) & 0x5f); delay(1);
/* //sx neschimbat, restul cu masti 010* */
// printf(" y – o=%x", o); delay(1000);
oy= (o | 0x20); // 0000 0010 fortez in stiva sy=1, restul neschimbat
outport(0x378, o=o | 0x80); // fata de primul out tx=1
// printf(" y – o=%x", o); delay(1000) ;
push1 (o | 0x20); // 0000 0010 fortez in stiva sy=1, restul neschimbat
push1 (oy);
push1 (oyin);
}
}

80 | P a g e
void axayd(void){
if(se2==1){ /* sens y+ pe reper */
outport(0x378, o= (o | 0x60) & 0x7f); delay(1); // 011*
outport(0x378, o=o | 0x80); // fata de primul out ty=1
}
else { /* sens y – pe reper */
outport(0x378, o= (o | 0x40) & 0x5f); delay(1);
outport(0x378, o=o | 0x80); // fata de primul out ty=1
}
}

void axax(void){
int ox, oxin=o & 0xef ;
if(se1==1){
oxin=o & 0xef;
outport (0x378, o=(o | 0x90) & 0xbf); delay(1);
//sy neschimbat 10*1
// fprintf(fpo," x+ o=%x", o); // delay(1000);
ox= (o & 0xef);/* // 1111 1110 fortez in stiva sx=0, restul neschimbat */
outport (0x378, o=o | 0x40); // fata de primul out tx=1
// fprintf(fpo," x+ o=%x", o); // delay(1000);
push1 (o & 0xef); // 1111 1110 fortez in stiva sx=0, restul neschimbat
push1 (ox);
push1 (oxin);
}
else{ /* sens x – pe reper */
oxin=o | 0x10;
outport (0x378,o= (o | 0x80) & 0xaf); delay(1);
//sy neschimbat 10*0

81 | P a g e
// printf(" x – o=%x", o); delay(1000);
ox= (o | 0x10);/* // 0000 0001 fortez in stiva sx=1, restul neschimbat */
outport(0x378, o=o | 0x40); // fata de primul out tx=1
// fprintf(fpo, " x – o=%x", o); // delay(1000);
push1 (o | 0x10); // 0000 0001 fortez in stiva sx=1, restul neschimbat
push1 (ox);
push1 (oxin);
}
}

void axaxd(void){
if(se1==1){
outport (0x378, o=(o | 0x90) & 0xbf); delay(1);
outport (0x378, o= o | 0x40); // fata de primul out tx=1
}
else{ /* sens x – pe reper */
outport (0x378,o= (o | 0x80) & 0xaf); delay(1);
outport(0x378, o=o | 0x40); // fata de primul out tx=1
}
}

void axaxy(void){
// int v2,v1=v; v2=ceil(1.4*v1);

if(se1==1 && se2==1){ /* sens x+y+ pe reper */
outport(0x378,0x1f & ms); // 0001 1111
delay(0);
outport(0x378,0x13 & ms); // 0001 0011
}

82 | P a g e
if(se1== -1 && se2== -1){ /* sens x -y- pe reper */
outport(0x378,0x1c & ms);delay(0);//000 1 1100
outport(0x378,0x10 & ms); //0001 0000
}
if(se1==1 && se2== -1){ /* sens x+y – pe reper */
outport(0x378,0x1d & ms);delay(0); //0001 1101
outport(0x378,0x11 & ms); //0001 0001
}
if(se1== -1 && se2==1){ /* sens x -y+ pe reper */
outport(0x378,0x1e & ms);delay(0); //0001 1110
outport(0x378,0x12 & ms); //0001 0010
}
}

double unghi(float x10,float y10,float i10,float j10){
double un,un1;
float x9,y9;
x9=x10 -i10;y9=y10 -j10;
if(x9!=0) un=at an(fabs(y9/x9));
if(y9==0&&x9>0) un1=0;
if(y9>0&&x9>0) un1=un;
if(y9>0&&x9==0) un1=PI/2;
if(y9>0&&x9<0) un1=PI -un;
if(y9==0&&x9<0) un1=PI;
if(y9<0&&x9<0) un1=un+PI;
if(y9<0&&x9==0) un1=PI*1.5;
if(y9<0&&x9>0) un1= -un+2*PI;
if(y9==0&&x9==0) un1=0;
return un1;

83 | P a g e
}

void circular(float x5,float y5,float x6,float y6,float i5,float j5){
float r,x7,y7,x8,y8;
double u1,uin,ufin;
// clrscr();
x20=x5; y20=y5;
r=sqrt((x6 -i5)*(x6 -i5)+(y6 -j5)*(y6 -j5));
uin=unghi(x5,y5,i5,j5);
ufin=unghi(x6,y6,i5,j5);
// TREBUIE SA DESPARTI IN CADRANE
// printf (" \n uin=%f ufin=%f ind=%d r=%f", uin, ufin, ind, r);
if(ufin==0 && ind==3) ufin=2*PI;
if(ufin==2*PI && ind==2) ufin=0; if(uin==0 && ind==2) uin=2*PI;
// if(ufin==0 && ind==3) ufin=2*PI ;
// if(ufin==2*PI && ind==2) ufin=0; if(uin==0 && ind==2) uin=2*PI;

if(ind==3) { // G3 – sens trigonometric direct
if ( uin<PI/2 && uin>=0 ) { //initialul in cadranul I
if ( ufin<=PI/2 && ufin>0 && uin>ufin) { //finalul in cadranul I -5cad
circdel(x5,y5,uin,PI/2,i5,j5); circdel(x20,y20,PI/2,PI,i5,j5);
circdel(x20,y20,PI,3*PI/2,i5,j5); circdel(x20,y20,3*PI/2,2*PI,i5,j5);
circdel(x20,y20,2*PI,ufin,i5,j5); }
else{
if (ufin>0 && ufin <= PI/2 && uin<ufin) circdel(x5,y5,uin,ufin,i5,j5);
else {
if ( ufin>PI/2 && ufin<=PI) {
circdel(x5,y5,uin,PI/2,i5,j5);

84 | P a g e
circdel(x20,y20,PI/2,ufin,i5,j5);}
else { if ( ufin>PI && ufin<=3*PI/2) { //finalul in III
circdel(x5,y5, uin,PI/2,i5,j5);
circdel(x20,y20,PI/2,PI,i5,j5);
circdel(x20,y20,PI,ufin,i5,j5);}
else { circdel(x5,y5,uin,PI/2,i5,j5); circdel(x20,y20,PI/2,PI,i5,j5);
circdel(x20,y20,PI,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5);}
}}}}

if ( uin>=PI/2 && uin<PI ) { //initialul in cadranul II
if ( ufin>PI/2 && ufin<=PI && uin>ufin) { //initialul in cadranul II -5cad
circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,2*PI,i5,j5); circde l(x20,y20,2*PI,PI/2,i5,j5);
circdel(x20,y20,PI/2,ufin,i5,j5); }
else{
if ( ufin>PI/2 && ufin <=PI &&uin<ufin) circdel(x5,y5,uin,ufin,i5,j5);
else {

if ( ufin>PI && ufin<=3*PI/2) { //finalul in III
circdel(x5,y5,uin,PI,i5 ,j5); circdel(x20,y20,PI,ufin,i5,j5);}
else { if ( ufin==0 || ufin>=3*PI/2) {
circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5);}
else { circdel(x5,y5,uin,PI,i5,j5);
circdel(x20,y20,PI,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,2*PI,i5,j5);
circdel(x20,y20,0,ufin,i5,j5);}
}} } }
if ( uin>=PI && uin<3*PI/2 ) { //initialul in cadranul III

85 | P a g e
if ( ufin<=3*PI/2 && ufin>PI && uin>ufin) { //finalul in cadr anul III -5cad
circdel(x5,y5,uin,3*PI/2,i5,j5); circdel(x20,y20,3*PI/2,2*PI,i5,j5);
circdel(x20,y20,0,PI/2,i5,j5); circdel(x20,y20,PI/2,PI,i5,j5);
circdel(x20,y20,PI,ufin,i5,j5); }
else{
if ( ufin>PI && ufin <=3*PI/2 && uin<ufin) circdel (x5,y5,uin,ufin,i5,j5);
else {
if ( ufin==0 || ufin>3*PI/2) { //finalul in IV
circdel(x5,y5,uin,3*PI/2,i5,j5); circdel(x20,y20,3*PI/2,ufin,i5,j5);}
else { if ( ufin>0 && ufin<=PI/2) {
circdel(x5,y5,uin,3*PI/2,i5,j5);
circde l(x20,y20,3*PI/2,2*PI,i5,j5);
circdel(x20,y20,2*PI,0,i5,j5);}
else { circdel(x5,y5,uin,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,2*PI,i5,j5);
circdel(x20,y20,0,PI/2,i5,j5); circdel(x20,y20,PI/2,ufin,i5,j5);}
}} } }
if ( uin>=3*PI/2 ) { //initialul in cadranul IV
if ( (ufin>3*PI/2 || ufin==0) && uin>ufin) { //finalul in cadranul IV -5cad
circdel(x5,y5,uin,2*PI,i5,j5); circdel(x20,y20,0,PI/2,i5,j5);
circdel(x20,y20,PI/2,PI,i5,j5); circdel(x20,y20,PI,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5); }
else{
if ( (ufin==0 || ufin >3*PI/2)&& uin<ufin) circdel(x5,y5,uin,ufin,i5,j5);
else {
if ( ufin>0 && ufin<=PI/2) { //finalul in I
circdel(x5,y5,uin,2*PI,i5,j5); circdel(x20,y20,0,ufin,i5,j5);}
else { if ( ufin>PI/2 && ufin<=PI) {
circdel(x5,y5,uin,2*PI,i5,j5); circdel(x20,y20,0,PI/2,i5,j5);
circdel(x20,y20,PI/2,ufin,i5,j5);}

86 | P a g e
else { circdel(x5,y5,uin,2*PI,i5,j5); circdel(x20,y20,0,PI/2,i5,j5);
circdel(x20,y20,PI /2,PI,i5,j5); circdel(x20,y20,PI,ufin,i5,j5);}
}} } }
}
else { // G2 – sens trigonometric invers
if ( uin<=PI/2 && uin>0 ) { //initialul in cadranul I
if ( ufin<PI/2 && ufin>=0 && uin<ufin) { //initialul in cadranul I -5cad
circdel(x5,y 5,uin,0,i5,j5); circdel(x20,y20,0,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,PI,i5,j5); circdel(x20,y20,PI,PI/2,i5,j5);
circdel(x20,y20,PI/2,ufin,i5,j5); }
else{
if ( ufin>=0 && ufin <PI/2 && uin>ufin) circdel(x5,y5,uin,ufin,i5,j5); // final I
else {
if ( ufin>3*PI/2 && ufin<=2*PI) { // finalul in IV
circdel(x5,y5,uin,0,i5,j5); circdel(x20,y20,0,ufin,i5,j5);}
else { if ( ufin>PI && ufin<=3*PI/2) { //finalul in III
circdel(x5,y5,uin,0,i5,j5); circdel(x20,y20,0,3 *PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5);}
else { circdel(x5,y5,uin,0,i5,j5); // finalul in II
circdel(x20,y20,0,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,PI,i5,j5);
circdel(x20,y20,PI,ufin,i5,j5);}
}} } }
if ( uin>PI/2 && uin<=PI ) { //initialul in cadranul II
if ( ufin>=PI/2 && ufin<PI && uin<ufin) { //FIN in cadranul II -5cad
circdel(x5,y5,uin,PI/2,i5,j5); circdel(x20,y20,PI/2,0,i5,j5);
circdel(x20,y20,0,3*PI/2,i5,j5); circdel(x20,y20,3*PI/2, PI,i5,j5);
circdel(x20,y20,PI,ufin,i5,j5); }
else{ // finalul in II

87 | P a g e
if ( ufin>=PI/2 && ufin <PI && uin>ufin) circdel(x5,y5,uin,ufin,i5,j5);
else {
if ( ufin>=0 && ufin<PI/2) { // finalul in I
circdel(x5,y5,uin,PI/2,i5,j5); circd el(x20,y20,PI/2,ufin,i5,j5);}
else { if ( ufin>=3*PI/2 || ufin==0) { //finalul in IV
circdel(x5,y5,uin,PI/2,i5,j5); circdel(x20,y20,PI/2,0,i5,j5);
circdel(x20,y20,0,ufin,i5,j5);}
else { circdel(x5,y5,uin,PI/2,i5,j5); circde l(x20,y20,PI/2,0,i5,j5); //
final in III
circdel(x20,y20,0,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5);}
} }} }
if ( uin>PI && uin<=3*PI/2 ) { //initialul in cadranul III
if ( ufin<3*PI/2 && ufin>=PI && uin<ufin) { //finalul in cad ranul III -5cad
circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,PI/2,i5,j5);
circdel(x20,y20,PI/2,0,i5,j5); circdel(x20,y20,0,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,ufin,i5,j5); }
else{
if ( ufin>=PI && ufin < 3*PI/2 && uin>ufin) circdel (x5,y5,uin,ufin,i5,j5);
else {
if ( ufin>=PI/2 && ufin<PI) { //finalul in II
circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,ufin,i5,j5);}
else { if ( ufin>=0 && ufin<PI/2) {
circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,PI/2,i5,j5);
circdel(x20,y20,PI/2,ufin,i5,j5);}
else { circdel(x5,y5,uin,PI,i5,j5); circdel(x20,y20,PI,PI/2,i5,j5);
circdel(x20,y20,PI/2,0,i5,j5); circdel(x20,y20,0,ufin,i5,j5);}
}} } }
if ( uin>3*PI/2 || uin==0 ) { //initialul in cadranul IV
if (ufin>=3*PI/2 && uin<ufin) { //finalul in cadranul IV -5cad

88 | P a g e
circdel(x5,y5,uin,3*PI/2,i5,j5); circdel(x20,y20,3*PI/2,PI,i5,j5);
circdel(x20,y20,PI,PI/2,i5,j5); circdel(x20 ,y20,PI/2,0,i5,j5);
circdel(x20,y20,0,ufin,i5,j5); }
else{
if ( ufin >=3*PI/2 && uin>ufin) circdel(x5,y5,uin,ufin,i5,j5);
else {
if ( ufin>=PI && ufin<3*PI/2) { //finalulu in III
circdel(x5,y5,uin,3*PI/2,i5,j5); circdel(x20,y20, 3*PI/2,ufin,i5,j5);}
else { if ( ufin<PI && ufin>=PI/2) { //finalul in II
circdel(x5,y5,uin,3*PI/2,i5,j5);
circdel(x20,y20,3*PI/2,PI,i5,j5);
circdel(x20,y20,PI,ufin,i5,j5);}
else { circdel(x5,y5,uin,3*PI/2,i5,j5); circdel(x20,y 20,3*PI/2,PI,i5,j5);
circdel(x20,y20,PI,PI/2,i5,j5); circdel(x20,y20,PI/2,ufin,i5,j5); }
} }} }
}
}

void push1 (int secv1) { /* punere in stiva */
index1++;
if (index1 > N -1 ) index1=0;
tabs1[index1]=secv1;
}
int pop1 (void ) { /* extragere din stiva */
int varret1= tabs1 [index1];
tabs1[index1] = 0x00;
index1 –;
if (index1 < 0) index1=N -1 ;
/* printf (" \n index1=%d pop=%x", lst1 ->index1, varret1); */
return varret1;

89 | P a g e
}

void push2 (int secv2) { /* punere in stiva */
index2++;
if (index2 > N -1 ) index2=0;
tabs2[index2]=secv2;
}
int pop2 (void ) { /* extragere din stiva */
int varret2= tabs2 [index2];
tabs2[index2] = 0x00;
index2 –;
if (index2 < 0) index2=N -1 ;
/* printf (" \n index1=%d pop=%x", lst1 ->index1, varr et1); */
return varret2;
}

void push3 (float secv3) {
index3++;
if (index3 > N -1 ) index3=0;
tabs3[index3]=secv3;
}
float pop3 (void ) {
float varret3= tabs3 [index3];
tabs3[index3] = 0x00;
index3 –;
if (index3 < 0) index3=N -1 ;
return varret3;
}
void push5 (float secv5) {

90 | P a g e
index5++;
if (index5 > N -1 ) index5=0;
tabs5[index5]=secv5;
}
float pop5 (void ) {
float varret5= tabs5 [index5];
tabs5[index5] = 0x00;
index5 –;
if (index5 < 0) index5=N -1 ;
return varret5;
}

void push4 (float secv4) {
index4++;
if (index4 > N -1 ) index4=0;
tabs4[index4]=secv4;
}
float pop4 (void ) {
float varret4= tabs4 [index4];
tabs4[index4] = 0x00;
index4 –;
if (index4 < 0) index4=N -1 ;
return varret4;
}
void push6 (float secv6) {
index6++;
if (index6 > N -1 ) index6=0;
tabs6[index6]=secv6;
}

91 | P a g e
float pop6 (void ) {
float varret6= tabs6 [index6];
tabs6[index6] = 0x00;
index6 –;
if (index6 < 0) index6=N -1 ;
return varret6;
}

float trans1(void){
int j2;
float val;
j++;
for(j2=0;;j2+ +){
while(tab[j]==' ') j++;
if(tab[j]=='0'||tab[j]=='1'||tab[j]=='2'||tab[j]=='3'||tab[j]=='4'
||tab[j]=='5'||tab[j]=='6'||tab[j]=='7'||tab[j]=='8'||tab[j]=='9'
||tab[j]=='.'||tab[j]==' -'||tab[j]=='+')
tab1[j2]=tab[j++];
else { tab1[j2]='#';l=j2;break; }
}
val=trans();
return val;
}
float trans(void){
int poz,q,j1,sign=1,j2=0,f2=0,m1=12;
float tr=0.;
float t1[12];
for(j1=0;j1<l;j1++)
for(j1=0;j1<m1;j1++) /* depist primului # */

92 | P a g e
{if(tab1[j1]=='#') {f2=j1;br eak;}}
if(tab1[0]==' -') {sign= -1;j2=1;}
if(tab1[0]=='+') j2=1;
poz=f2;
for(j1=0;j1<m1;j1++) t1[j1]=0;
for(j1=j2;j1<f2;j1++){ /* poz punct */
if(tab1 [j1]=='.') {poz=j1;break;}
}
for(j1=j2;j1<f2;j1++){
if(j1<poz) /* -48 pt. ascii -> zec */
t1[j1 -j2]=(tab1[j1] -48)*pow10(poz -j1-1);
else{
if(j1>poz) t1[j1 -j2]=(tab1[j1] -48)*pow10(poz -j1);
else t1[j1 -j2]=0.;
}
}
for( q=0;q<f2 -j2;q++){
tr=tr+t1[q];
}
tr=tr*sign;
return tr;
}

93 | P a g e
\