UNIVERSITATEA din PETROȘANI

FA C UL T AT E A D E ING IN E RI E M E CA NI C Ă Ș I E L EC T RIC Ă

MICROCONTROLLERE
ÎNDRUMĂTOR DE LABORATOR

Autori:
Asist.Cercet.Drd.Ing. LÖRINCZ ALEXANDRA-ELISABETA
Asist.Cercet.Drd.Ing. RÎSTEIU MARIUS-NICOLAE
Referenți științifici:
Prof.univ.dr.habil.ing. Monica LEBA
Conf.univ.dr.ing. Olimpiu STOICUȚA

Descrierea CIP a Bibliotecii Naţionale a României

LÖRINCZ, ALEXANDRA-ELISABETA
Microcontrollere : îndrumător de laborator / Alexandra-
Elisabeta Lörincz, Marius-Nicolae Rîsteiu. - Petroşani : Universitas,
2017
Conţine bibliografie
ISBN 978-973-741-556-1

I. Rîsteiu, Marius-Nicolae

004

Copyright © 2017, Editura UNIVERSITAS şi autorii

Toate drepturile asupra acestei ediţii sunt rezervate editurii şi
autorilor

Tiparul executat la: Universitatea din Petroşani

Atelier Tipografie
 Cuvânt înainte

Acest îndrumător se adresează studenţilor din anul III

Calculatoare şi Automatică și Informatică Aplicată (Facultatea de
Inginerie Mecanică și Electrică de la Universitatea din Petroșani) la
disciplina Microcontrollere și Automate Programabile. Îndrumătorul
conține 12 lucrări de laborator care cuprind atât parte teoretică cât şi
parte aplicativă cu scopul deprinderii stilului de programare specific
limbajelor de programare embedded, în particular limbajul C.

Asist.Cercet.Drd.Ing. LÖRINCZ ALEXANDRA-ELISABETA

Asist.Cercet.Drd.Ing. RÎSTEIU MARIUS-NICOLAE
 CUPRINS

Laboratorul 1 - Concepte fundamentale 5

Laboratorul 2 - Logica digitală și electronică 11
Laboratorul 3 - Introducere în C 15
Laboratorul 4 - Porturile microcontrollerului 24
Laboratorul 5 - Interfața cu led/switch 28
Laboratorul 6 - Funcționalitatea debugger-ului 31
Laboratorul 7 - Finite state machines 34
Laboratorul 8 - Interfața serială – UART / USART 42
Laboratorul 9 - Întreruperi 47
Laboratorul 10 - Sunetul și DAC 51
Laboratorul 11 - ADC și achiziția de date 55
Laboratorul 12 - Sisteme – nivelul design 58
Regulamentul de protecția muncii 65
Norme de prevenire și stingere a incendiilor 67
Condiții de lucru în laborator 69
Proces verbal - pentru normele de tehnică și securitate 70
 LABORATORUL 1 –
Concepte Fundamentale

Atunci când învățăm un nou limbaj de programare este

tradițional cu începerea rulării unui program care transmite mesajul
“Hello World”. Mai târziu putem scrie propriile noastre programe,
dar în acest laborator vom rula un program simplu care este scris
pentru studenți. Intrările și ieșirile microcontrollerului provin de la
dispozitive fizice cum ar fi LED-uri. În consecință, mesajul nostru
“Hello World” ne cere să apăsăm un switch și să observăm un LED.
Scopul acestui laborator este de a lucra prin procesul de configurare
a sistemului de dezvoltare pentru placa cu microcontroller.
Sistemul va avea o singură intrare și trei ieșiri. Intrarea este un
switch numit SW1, care este conectat pe portul și pinul PF4. Cele trei
ieșiri (PF3, PF2, PF1) sunt conectate la un LED multi-color.
Culoarea LED-ului este determinată de valoarea celor 3 biți scriși pe
ieșiri. Dacă SW1 nu este apăsat, LED-ul oscilează între albastru-
roșu, iar dacă SW1 este apăsat LED-ul oscilează între albastru-verde.
Abordarea de bază pentru toate laboratoarele este de a dezvolta
sistemul și de a face debug folosind simulatorul. După ce i se face
debug softului, se v-a crea interfața actualelor componente la
LaunchPad și rularea softului pe un microcontroller real. În acest
laborator nu este nevoie să scriem nici un soft (doar să rulăm softul
care există) sau de a construi partea hardware (utilizăm doar
LaunchPad care deține deja LED-ul și switch-urile). Există trei pași
pentru instalarea software și detaliile pot fi găsite la
http://users.ece.utexas.edu/~valvano/edX/download.html.
Keil Installation - Primul pas este instalarea mediului de
dezvoltare integrat Keil uVision (IDE) pentru ARM. Acest IDE
include Editorul, Compilatorul, Simulatorul și debugger-ul. Ediția
MDK-Lite (32KB) nu cere serial number sau cheie pentru licență.
Un slide care arată procesul poate fi găsit la
http://users.ece.utexas.edu/~valvano/edX/KeilInstall.html
TExaS Installation - Al doilea pas este instalarea TestEXecute
and Simulate (TExaS). TExaS este un set de îmbunătățiri pentru
Keil care servește drept ajutor pentru aceste laboratoare. Această
instalare va fi de configurare a exemplelor de proiect și fișiere de
început pentru laboratoare. O prezentare a procesului poate fi găsită
aici http://users.ece.utexas.edu/~valvano/edX/TExaSInstall.html
Windows drivers installation - Al treilea pas este instalarea
driverelor dispozitivelor hardware pentru LaunchPad. Aveți nevoie
de LaunchPad hardware pentru a face acest pas. Dacă nu aveți
această placă acum sau nu aveți în plan să cumpărați kitul hardware,
puteți trece peste acest pas și efectuați laboratoarele în simulator.
Driverul de instalare depinde de sistemul de operare pe care îl aveți.
o Windows XP
o Windows Vista
o Windows 7
o Windows 8
o Windows 8.1

Part a) Pentru testarea corectitudinii instălării sistemului de

dezvoltare software se va rula un proiect existent numit Lab2. Nu
trebuie modificat codul deja scris. Prima dată trebuie rulat în modul
simulare. Sugerez modificarea sistemului Windows pentru afișarea
extensilor de fișiere.
1) Deschideți fișierul proiectului Lab2, care este fișierul Lab2 de
tipul uvproj în folderul Lab2.
2) Verificați dacă este configurat pentru a rula în simulator
3) Compilați proiectul selectând Build.
4) Porniți debugger-ul în modul simulator.
5) Rulați programul și interactionați cu switch-urile, observând
ieșirile LED-ului.

Part b) In scopul testării sistemului de dezvoltare software pentru

placa reală, trebuie să rulați Lab2 pe placa reală. Din nou, nu este
necesar să editați codul existent. Veți compila, downloada, și rula
proiectul Lab2 pe LaunchPad actuală. Pentru a rula programul pe
placa reala sunt necesari câțiva pași:

1) Deschideți fișierul proiectului Lab2, care este fișierul

Project.uvproj din folderul Lab2.
2) În Keil, executați Project->OptionsForTarget. În tab-ul Target,
selectați TExaS în Operating System derulați meniul. În tab-ul
Debug, click Use radio la dreapta și selectați Stellaris ICDI.

3) Compilați proiectul executând Project->BuildProject

4) Downloadați codul obiect în Flash EEPROM executând

Flash->Download

5) Porniți debugger-ul executând

Debug->Start/StopDebuggingSession

6) Rulați programul executând Debug->Run

1. Mediul de dezvoltare Keil uVision4

http://users.ece.utexas.edu/~valvano/edX/download.html
Placa de dezvoltare EK-TM4C123GXL

RAM (Random Access Memory) – Memorie cu acces aleator -

volatilă
ROM (Read-Only Memory) – Memorie care poate fi doar citită -
nevolatilă
 La adresa 0xE004FFFF ajung informații de tipul: nefolosite,
care nu se pot folosii, erori sau “gunoaie”. Fiecare locație poate să
conțină 8 biți de informație.

Numere de tip întreg ( int )

Unsigned (fără semn)

Ex: 10001101 = 141

Signed (cu semn); 0 = pozitiv + ; 1 = negativ -

Ex: 01000110 = 70
Ex: 10001101 = -115

0 -> bit de semn / indicator – în acest caz este +

1 -> 2⁷ = -128
-128 + 8+4+1 = -115

ARM (Acorn RISC Machine) este un computer pe 32 de biți

cu o arhitectură bazată pe seturi de instrucțiuni (ISA – Instruction Set
Arhitecture) care lucrează cu un set redus de instrucțiuni (RISC-
Reduced Instruction Set Computer), al cărui patent este deținut de
compania creatoare, ARM Holdings.
Seria ARM Cortex de nuclee cuprinde o gamă foarte largă de
opțiuni scalabile de performanță, care oferă designerilor o gamă
diversificată de alegeri, precum și posibilitatea de a utiliza nucleul
cel mai potrivit pentru aplicația lor, fără a fi forțați de o soluție „one-
size-fits-all”. Portofoliul cortex este împărțit în trei mari categorii:
• Cortex-A – aplicații de procesare a nucleelor pentru sisteme
„performance-intensive”.
• Cortex-R – nuclee de înaltă performanță pentru aplicații în timp
real.
• Cortex-M – microcontrollere cu nuclee pentru o gamă largă de
aplicații embedded.

Temă:
LED-ul să pâlpâie mai încet.
LED-ul să oscileze între albastru-galben.
 LABORATORUL 2 -
Logica Digitală și Electronică

Conectarea elementelor în serie

R  R1  R2!!! Vab  V1  V2
R1 R2
V1   Vab!!! V2   Vab
R1  R2 R1  R2

Conectarea elementelor în paralel

R1  R2
V1 V2 Vab!!! R  !!!
R1  R2

I  I1  I2!!!

R2 R1
I1   I!!! I2  I
R1  R2 R1  R2
Programul Keil uVision4 – Simulator

My computer – Local Disk(C:) -Keil - Labware – Lab4_IO

a). Options for target

b). Debug tab
c). Se bifează Use Simulator
d). Laboratorul corespunzător; Se închide fereastra apăsând butonul
OK.
e). Build – F7

a). Debug – CTRL + F5

b). Step – F11
c). Step out – CTRL + F11
d). Step over – F10 ( treci peste o funcție )
e). Run to cursor line – CRTL + F10
Verificarea unei variabile ( SW1 ) pin deschiderea ferestrei Watchx.

Selectarea unei variabile -> click dreapta -> Add ‘Sw1’ to... ->
Watch 1. Folosind butonul Step Over (F10) rulăm programul și
vedem că SW1 = 0x00000100 si SW2 = 0x00000001, adică
butoanele nu sunt apăsate.

Deschidem fereastra :
a). Peripherals
b). Selectam TExaS Port F
c). Se deschide fereastra TExaS edX Lab 4
d). Bifăm SW1
e). Se aprinde LED-ul în culoarea verde (Green)
 Programul Keil uVision4 –
Placa electronică EK-TM4C123GXL

a). Selectează butonul Options for target ‘I/O’

b). Se deschide fereastra Options for target ‘I/O’
c). Selectează tab Debug
d). Se bifează utilizarea plăcii electronice Stellaris ICDI
Se apasă butonul OK, după care compilăm programul (butonul
Build), iar apoi descărcăm programul în microcontroller
e). Download. Dacă nu avem nici o eroare putem face Debug.

Temă :
În momentul apăsării SW1 și SW2 să se aprindă LED-ul
albastru, iar dacă nu sunt apasate butoanele, să fie stins.
Dacă SW1 este apăsat si SW2 nu este apăsat atunci LED-ul să
fie roșu iar dacă SW1 nu este apăsat și SW2 este apăsat atunci LED-
ul să fie verde.
 LABORATORUL 3 - Introducere în C

1. IDE :
❖ Editor – Limbaj C
❖ Compiler – Limbaj C → Limbaj de asamblare
❖ Assembler – Cod asamblare → Cod mașină
❖ Linker
➢ startup.s ↘
➢ UART.c → One system
➢ main.c ↗
❖ Loader – One system → Memoria flash ROM.
❖ Debugger – Asigură verificarea programului pentru funcționare
corectă.

2. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C5_Keil_Starter → Intro.uvproj→ Open
Proiectul de început al acestui laborator este similar cu exemplul
C5_Room în care se introduc datele de intrare de la tastatură
folosind scanf și se realizează afișarea folosind printf. Scopul vostru
este de a scrie o funcție care acceptă doi parametrii de intrare
(lungime și lățime) și calculează aria suprafeței camerei
dreptunghiulare cu această lungime și lățime. Lungimea si lățimea
sunt introduse în metrii iar rezultatul ariei trebuie să fie în metrii
pătrați. Se calculează aria numai dacă ambele valori și lungimea și
lățimea sunt între 3 m și 20 m inclusiv. Returnează un rezultat zero,
în cazul în care lungimea este mai mică de 3 m, lățimea este mai
mică de 3 m, lungimea este mai mare de 20 m sau lățimea este mai
mare de 20 m. Vi se cere să scrieți funcția Calc_Area .
Abordarea de bază pentru toate laboratoarele va fi de a dezvolta
în primul rând și de a realiza depanare folosind simulatorul. După ce
software-ul este depanat, veți folosi componente reale pe Launchpad
și veți rula software-ul pe microcontrollere reale.
Primul pas este să scrieți funcția Calc_Area. În continuare vă
puteți testa funcția în modul de simulare. Intrările se realizează
folosind scanf iar apelul funcției și afișarea în fereastra UART se
realizează cu printf.
Utilizarea funcției printf();
#include <stdio.h> - include fișierul stdio.h din directoarele
standard.
#include “uart.h” – include fișierul uart.h – căutarea se face întâi în
directorul curent și după aceea în directoarele standard.
\n – new line
%ld – unsigned long varible

int main(void)
{
UART_Init(); // call subroutine to init uart lib
printf("This program calculates areas of square shaped
rooms\n");
}

Build → Debug

o View
o Select Serial Windows
o UART #1
Calcularea suprafeței unei camere

int main(void)
{
unsigned long side; //room wall meters
unsigned long area; // size squared meters
UART_Init(); // call subroutine to init uart lib
printf("This program calculates areas of square shaped rooms.\n");
side = 3; // 3 meters
area = side * side; //square meters
printf(“Area of the room with side of %ld m is %ld sqr
m\n”,side,area);
}

Vizualizarea valorii unei variabile:

o selectarea variabilei dorite
o click dreapta
o Add ‘side’ to...
o Watch 1
o variabilele side, area
Build → Debug → Run
Apelarea unei funcții ce returnează un număr
Pentru a rula programul pe placa reală va trebui să porniți
aplicația TExaSdisplay. Această aplicație vă permite să interacționați
cu operațiile scanf și printf care apar în microcontroller. Setările
implicite (căutați COM-ul portului și o rată de transfer de 115200
biți/sec) trebuie să funcționeze.
În cazul în care computerul are doar un singur dispozitiv de port
COM, valorile setărilor sunt implicite pentru deschiderea portului
COM și puteți trece la pasul 2.
În cazul în care computerul are mai multe dispozitive de port
COM, deschideți Device manager și faceți act de portul COM pentru
Stellaris Serial Port virtual (în această figură este COM13).

Figura anterioară - Device Manager arată un calculator cu mai

multe dispozitive de port COM. Pe acest computer Stellaris Virtual
Serial Port este pe COM13.
 Configurarea TExaSdisplay pentru a comunica cu portul COM
adecvat, executați > Setări și specificați numărul portului COM (în
acest caz, 13).
Pentru a vă conecta la microcontrollerul TExaSdisplay,
executați COM-> OpenPort. Puteți avea atât debugger Keil și
aplicația TExaSdisplay deschisă în timp ce sistemul de depanare
hardware / software-ul este combinat pe launchpad.
#include <stdio.h> // Diamond braces for sys lib: Standard I/O
#include "uart.h" // Quotes for user lib: UART lib
// Function Prototypes
//Compiler aid for "type checking"
unsigned long Calc_Area(unsigned long s); //Says Calc_Area
expects an unsigned long and returns an unsigned long
// Subroutines section
// MAIN: Mandatory subroutine for a C Program to be executable
int main(void)
{
unsigned long side; //room wall meters
unsigned long area; // size squared meters
UART_Init(); // call subroutine to init uart lib
printf("This program calculates areas of square shaped
rooms\n");
side = 3; // 3 meters
area = Calc_Area(side);
printf("Area of the room with side of %ld m is %ld sqr
m\n",side,area);
}
//Calculates area
// Input: side of a room (unsigned long)
// Output: area of the room (unsigned long)
//Notes: ...
unsigned long Calc_Area(unsigned long s)
{
unsigned long result;
result = s+s;
return(result);
}
int main(void)
{
unsigned long side; //room wall meters
unsigned long area; // size squared meters

UART_Init(); // call subroutine to init uart lib

printf("This program calculates areas of square shaped
rooms\n");

side = 3; // 3 meters
area = Calc_Area(side);
printf("\nArea of the room with side of %ld m is %ld sqr
m\n",side,area);

side = side + 3; // 3 meters

area = Calc_Area(side);
printf("\nArea of the room with side of %ld m is %ld sqr
m\n",side,area);
}
 Funcția IF, WHILE(1)

#include <stdio.h> // If a library is standard C library use the <>

braces
#include "uart.h" // If the library is user defined use quotes " "
unsigned long error = 0; //A global error count
unsigned long Calc_Area(unsigned long); // says Calc_Area
subroutine
void Initialize(void); // says Initialize takes no input returns none

int main (void)

{
// All variables used inside the main subroutine have to be
// declared first before we can write code.
unsigned long side, area;
Initialize(); // One time program initialization
UART_Init(); // call the subroutine defined in "uart.h"
// to initialize UART for printing
printf("\nThis program calculates areas of square rooms\n");
side = 3; // side is a variable that is currently set to 3 meters
while(side != 0)
{
printf("\nGive room side (Type zero to quit): "); // Prompt user
scanf("%ld", &side); // Get user input
area = Calc_Area(side);
if (area !== 0)
{
printf("\nArea of a square room of side %ld is %ld\n", side,
area);
}
else { printf("\nSide cannot exceed 25\n"); }
}
}
// Access global error count and set it to zero
void Initialize(void) {error = 0; }
// Computes the Area of a square room whose side is given
// Input: the side of the square
// Output: the area of the square whose side is less than 25
// Notes: The side has to be positive and less than or equal to 25

unsigned long Calc_Area(unsigned long side)

{
unsigned long result;
if (side <= 25)
{
result = side * side; // compute valid area
}
else
{
result = 0; // indicate invalid area
error = error+1; // increment gloabal error count
}
return(result);
}

Punctuație Descriere
; Sfârșitul declarației
: Definește o „etichetă”
, Separă elementele dintr-o listă
() Începutul și sfârșitul unei liste de parametri
{} Începutul și sfârșitul unei compuneri de instrucțiuni
[] Începutul și sfârșitul unui index de matrice
„„ Începutul și sfârșitul unui șir
‚‚ Începutul și sfârșitul unei constante caracter
Operator Descriere Operator Descriere
= Declarație de == Egalitate
atribuire
? Selecție <= Mai mic sau egal
< Mai mic >= Mai mare sau egal
> Mai mare != Neegalitate
! Negație << Deplasare stânga
~ Complement față de >> Deplasare dreapta
1
(inversare)
+ Adunare ++ Incrementare
- Scădere -- Decrementare
* Înmulțire && ȘI logic
/ Împărțire || SAU logic
% Rest împărțire += Adaugă valoare la
întreagă
| SAU inclusiv -= Scade valoare din
& ȘI *= Înmulțește valoarea
la
^ SAU exclusiv /= Împarte valoarea la
. Folosit pentru |= SAU valoare la
accesarea
partilor unei
stucturi
>>= Deplasare dreapta &= ȘI valoare la
valoare
%= Rest împărțire ^= SAU exclusiv
valoare valoare la
-> Selector indirect <<= Deplasare stânga
structură valoare
 LABORATORUL 4 -
Porturile Microcontrollerului

1. I/O :
a) Paralel
b) Serial
c) Analog
d) Time

2. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C6_InputOutput_Starter → C6_InputOutput.uvproj→ Open

• GPIO_PORTF_DATA_R (Registru Date) - 0x400253FC

(adresa registrului de date)
• GPIO_PORTF_DIR_R (Registru direcție) - 0x40025400 (adresa
registrului direcție)
• SYSCTL_RCGC2_R (Registru pentru clock) - 0x400FE108

PORTF (5 pini ce pot fi setați)

DIR (direcție) – locația 0x40025400

 DEN (Enable/Disable)

Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C6_InputOutput → C6_InputOutput.uvproj→ Open

void PortF_Init(void)
{
volatile unsigned long delay;
SYSCTL_RCGC2_R |= 0x00000200; // 1) activate clock
for Port F
delay = SYSCTL_RCGC2_R; // allow time for
clock to start
GPIO_PORTF_LOCK_R = 0x5C4F435B; // 2) unlock
GPIO Port F
GPIO_PORTF_CR_R = 0x0F; // allow changes to
PF4-0
// only PF0 needs to be unlocked, other bits can't be locked
GPIO_PORTF_AMSEL_R = 0x00; // 3) disable analog
on PF
GPIO_PORTF_PCTL_R = 0x00000000; // 4) PCTL GPIO
on PF4-0
GPIO_PORTF_DIR_R = 0x1E; // 5) PF4,PF0 in, PF3-
1 out
 GPIO_PORTF_AFSEL_R = 0x00; // 6) disable alt funct
on PF7-0
GPIO_PORTF_PUR_R = 0x12; // enable pull-up on
PF0 and PF4
GPIO_PORTF_DEN_R = 0x0F; // 7) enable digital
I/O on PF4-0
}
// 2. Declarations Section
// Global Variables
unsigned long In; // input from PF4
unsigned long Out; // output to PF2 (blue LED)
// Function Prototypes
void PortF_Init(void);

// 3. Subroutines Section
// MAIN: Mandatory for a C Program to be executable
int main(void)
{ // initialize PF0 and PF4 and make them inputs
PortF_Init(); // make PF3-1 out (PF3-1 built-in LEDs)
while(1)
{
In = GPIO_PORTF_DATA_R & 0x10; // read PF4 into Sw1
In = In>>2; // shift into position PF2
Out = GPIO_PORTF_DATA_R;
Out = Out&&0xFB;
Out = Out|In;
GPIO_PORTF_DATA_R = Out; // output
}
}
OR pentru a seta un bit
GPIO_DATA | 0X10 – Set

AND pentru a “curăța” un bit

GPIO_DATA & (~0X02)

Build → Debug → Run

Temă: →Keil →Labware → Lab6_BranchingFunctionsDelays

 LABORATORUL 5 - Interfața cu LED/Switch

1. Pseudocod:
a) Inițializarea porturilor
b) If SW1 nu este apăsat
Repetă pasul b.
c) Flash SOS o singură
dată
Delay 5 secunde
d) If SW2 nu este apăsat
Repeta pasul c. si d.
e) Mergi la pasul b.

a. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware → C7_SOS
→ C7_SOS.uvproj→ Open

int main(void)
{
PortF_Init(); // Init port PF4 PF2 PF0
while(1){
do {
SW1 = GPIO_PORTF_DATA_R&0x20; // PF4 into SW1 }
while(SW1 == 0x20);
do{
FlashSOS();
SW2 = GPIO_PORTF_DATA_R&0x01; // PF0 into SW2 }
while(SW2 == 0x01);
}
}
Build → Debug → Run

2. Interfață - SWITCH

Fișă de caracteristici:

3. Interfață - LED

D (Digital) = 1 logic
A (Analog) = 3.3 V

3.3V – Id * R – Vd = 0
R = ( 3.3 – Vd ) / Id
R = ( 3.3 – 1.8 ) /3 mA = 500 Ω →
folosim 470 Ω

D (Digital) = 0 logic
A (Analog) = 0 V

4. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C8_Security → C8_Security.uvproj→ Open
 Logic Analyzer – Setup PORTE.4

Build → Debug → Run

My computer → Local Disk (C:) → Keil → TExaSware →
TExaSdisplay
COM → Settings → COM Port (COM6) → OK
PD3 conectat în PCB lângă PE4 & între Rezistență și PE4 -
Vizualizare diagramă

Temă:
1. →Keil →Labware → Lab8_SwitchLEDinterface → PE0 intrare
(SW), PE1 ieșire (LED). Led-ul stă aprins, când butonul este apăsat
face blink.
• Program
• Montaj
• Verificare Logic Analyzer
• Verificare TExaSdisplay
2. →Keil →Labware → Lab7_Heart_Block
 LABORATORUL 6 –
Funcționalitatea Debugger-ului
1. SysTick Counter:

Setup:
a) Enable (CTRL) = 0
b) INIT (RELOAD)
c) Value (CURRENT): Ex: 0
d) CTRL – enable set, interrupt off, clock 16 MHz
2. Arrays

Ex: long Data[5] = {13,12,5,4,2};

Schimbarea unei valori de la o
anumită adresă
Data[3] are valoarea 4
Data[3] = 22;
Data[3] are acum valoarea 22

3. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C2_Toggle_PF1→ C2_Toggle_PF1.uvproj→ Open

My computer → Local Disk (C:) → Keil → TExaSware →

C9_Debugging→ C9_Debugging.uvproj→ Open
Se verifică timpul:
a) prin folosirea analizorului logic
b) prin citirea din fereastra watch1 a valorii time[1] -> valoare *
62.5 ns = rezultat / 1000000000 = val_rez

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab9_FunctionalDebugging→ Lab9
 LABORATORUL 7 - Finite State Machines

1. SysTick timer: Precizie Phase lock loop (PLL)

Oscilator intern / extern

PLL
- Ne lasă să creștem viteza sau să scădem viteza
- Compromis între viteză și consum de energie

Regiștri PLL
- Precizie mai mare cu cristal extern sau “acuratețe”
- Flexibilitate în a alege viteza:
o Consum
o Viteză
2. PLL - schimbări System Clock

Exemplu calcul delay – PLL

Pentru 100 ms - > 0.1 sec => 80000000

3. Finite State Machines (FSM)

- Orice sistem care are intrări și generează date pe ieșiri.
- Punem sistemul în diferite stări

5 “Lucruri”
- Setarea intrărilor
- Setarea ieșirilor
- Setarea stărilor
- Tranziția stărilor
o Graph (STG)
o Matrix
- Condiții pentru ieșiri
 Moore FSM
NextState = f (current_state, Input)
Output = g (current_state)
Mealy FSM
Output = h (current_state, Input)

Sistem: Recunoaște dacă secvența de biți citită până acum are un

număr impar de 1

- Input 1 bit
- Output 1 bit
- State
o Odd so far
o Even so far
- STG
- Output Determ. (Moore)
 Scriere sub formă de cod

4. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C10_Odd1sDetector→ C10-Odd1sDetect.uvproj→ Open

5. Motorul pas cu pas (Stepper Motor)

Trei motoare pas-cu-pas

Conectarea cu un microcontroller

Comenzi pentru un Stepper Motor

Funcționarea unui Stepper Motor

6. Se deschide programul µVision4 → Project → Open Project...
My computer → Local Disk (C:) → Keil → TExaSware →
C10_StepperRobot → C10- C10_StepperRobot.uvproj→ Open

7. Setarea unui semafor

Sensurile de trafic N-E

Starea (State) Ieșiri Pini

(Output)
Mașinile Nord 100 010 PB5 (Roșu)
Est
PB4 (Galben)
Est
Stop/Wait 100 011 PB3 (Verde)
mașinile din Nord Est
PB2 (Roșu)
Nord
Mașinile Est 001 101 PB1 (Galben)
Nord
Stop/Wait 010 111 PB0 (Verde)
mașinile din Est Nord
 0.01 sec Intrări 0 0 0 1 1 0 1 1
(Input)
3000 GoN GoN WaitN GoN WaitN
100001
500 WaitN GoE GoE GoE GoE
100010
3000 GoE GoE GoE WaitE WaitE
001100
500 WaitE GoN GoN GoN GoN
010100
10ns Nu sunt Mașini Mașini Amândouă
masini Est Nord sensuri

Grafic de tranziție

STyp FSM[4]=
{
{0x28,3000,{goN,waitN,goN,waitN}},
{0x21, 500,{goE,goE,goE,goE}},
{0x1C,3000,{goE,goE,waitE,waitE}},
{0x15, 500,{goN,goN,goN,goN}}
};
FSM ENGINE

S = goN;
while(1)
{
LIGHT = FSM[S].Out; // set lights
 SysTick_Wait10ms(FSM[S].Time);
Input = SENSOR; // read sensors
S = FSM[S].Next[Input];
}

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab10_TrafficLight → Lab10
 LABORATORUL 8 –
Interfața serială – UART / USART

1. UART (Universal asynchronous receiver/transmitter) Serial

Interface

Sincronizarea -> un “pod” al vitezei de asimetrie

Comunicație UART
2. Comunicația UART – TM4C123

Comunicația UART cu alte dispozitive

Frame pe 10 biți

Transmitere și recepționare date

- SR ( Shift register)
- UARTx – x = 0….7
- OE – Overrun error bit
- BE – Brake error bit
- FE – Frame error bit
- PE – Parity error bit

3. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C11_Network → C10- C10_Network.uvproj→ Open

Inițializare UART

Galben – Pe care UART îl folosim (UART1, UART5 ….),

configurăm regiștrii pentru UART1
Albastru – Ce pini folosim pentru UART-ul selectat de noi, Portul
și Pinii.
Registrul PCTL_R – 0x00220000 setăm ca PC4 și PC5 sunt
folosiți pentru UART
Se selectează automat ca intrare (Rx) sau ieșire(Tx) atunci când
selectăm folosirea UART-ului
Verde – Setare Baud rate
80,000,000 – bus clock
16 – constantă
115,200 – baud rate standard folosit în comunicație
64 – constantă
a). Funcția “void UART_OutChar(unsigned char data)”
b). Funcția” unsigned char UART_InChar(void)”
- Device driver – set of software I/O
- Successive Refinement – big idea fine detail
- Number conversions – number – ASCII string
- Loops – Unknown while Known for

Testarea programului cu două PCB-uri TM4C123

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab11_UART→ Lab11
 LABORATORUL 9 - Întreruperi
1. NVIC (Nested Vector Interrupt Controller)
Întreruperile sunt importante în/pentru microcontrollere. Cu
ajutorul lor poți obține execuția programului principal (main) și sări
într-o zonă predefinită dacă acolo este ceva important.
Diferite periferice pot declanșa aceste întreruperi, cum ar fi date
care ajung la USART, conversii ADC, depășirea timer-ului, etc.
NVIC sau Nested Vector Interrupt Controller este folosit
dinamic pentru a spune care întrerupere este mai importantă și pentru
activarea sau dezactivarea întreruperii.

Programul “AGLOMERAT” consumă foarte multe resurse.

Probabil că “TASK2” este pregătit dar trebuie să aștepte după
“TASK1”.
Soluția întreruperilor este ca atunci când un TASK este pregătit
să poată fi executat prin întrerupere.
Programul “main” conține o buclă, în aceasta avem anumite
funcții/taskuri (ALTCEVA) pe care noi le executăm tot timpul. În
momentul activării întreruperii, funcția din buclă se suspendă, se
execută “TASK1” sau “TASK2” după care revine în bucla main.

Condiții pentru configurare:

- Dispozitiv ARM
- Activare NVIC
- Bitul I (global) = 0; pentru activarea sau dezactivarea
întreruperilor
- Prioritatea – setarea unei prioriăți mai mari la un dispozitiv care
este cel mai important
Declanșatorul “Trigger” – poate fi un buton care declanșează
întreruperea

volatile unsigned long FallingEdges = 0;

void EdgeCounter_Init(void){
SYSCTL_RCGC2_R |= 0x00000010; // (a) activate clock for port F
FallingEdges = 0; // (b) initialize counter
GPIO_PORTF_DIR_R &= ~0x11; // (c) make PF4 in (built-in
button)
GPIO_PORTF_AFSEL_R &= ~0x11; // disable alt funct on PF4
GPIO_PORTF_DEN_R |= 0x11; // enable digital I/O on PF4
GPIO_PORTF_PCTL_R &= ~0x001F0000; // configure PF4 as
GPIO
GPIO_PORTF_AMSEL_R = 0; // disable analog
functionality on PF
GPIO_PORTF_PUR_R |= 0x11; // enable weak pull-up on
PF4
 GPIO_PORTF_IS_R &= ~0x11; // (d) PF4 is edge-sensitive
GPIO_PORTF_IBE_R &= ~0x11; // PF4 is not both edges
GPIO_PORTF_IEV_R &= ~0x11; // PF4 falling edge event
GPIO_PORTF_ICR_R = 0x11; // (e) clear flag4
GPIO_PORTF_IM_R |= 0x11; // (f) arm interrupt on PF4
NVIC_PRI7_R = (NVIC_PRI7_R&0xFF00FFFF)|0x01A00000;
// (g) priority 5
NVIC_EN0_R = 0x40000000; // (h) enable interrupt 30 in
NVIC
EnableInterrupts(); // (i) Clears the I bit
}

Handle Interrupts
Pentru “manipularea” întreruperii putem folosi denumiri de
funcții special definite.
void GPIOPortF_Handler(void)

2. PWM (Pulse Width Modulation)

Este o tehnică folosită pentru a varia în mod controlat tensiunea
dată unui dispozitiv electronic. Această metodă schimbă foarte rapid
tensiunea oferită dispozitivului respectiv din ON în OFF și invers.
Perioada de timp corespunzătoare valorii ON dintr-un ciclu ON-OFF
se numește factor de umplere (duty cycle) și reprezintă, în medie, ce
tensiune va primi dispozitivul electronic. Astfel, se pot controla
circuitele analogice din domeniul digital. Practic, asta înseamnă că
un LED acționat astfel se va putea aprinde / stinge gradual, iar în
cazul unui motor acesta se va învârti mai repede sau mai încet.
Factorul de umplere se exprimă în procente și reprezintă cât la
sută din perioada unui semnal acesta va fi pe nivelul ON. În figura
următoare se pot observa semnale PWM cu factori de umplere
diferiți. Astfel, se poate deduce foarte ușor formula pentru a obține
valoarea factorului de umplere (D):
D = t_on/(t_on + t_off) * 100 = pulse_width / period * 100

Astfel, tensiunea medie care ajunge la dispozitiv este dată de relația:

D * Vcc
Semnal PWM cu diferiți factori de umplere

3. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C12_DCMotor→ C12_DCMotor.uvproj→ Open

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab12_TuningFork→ Lab12
 LABORATORUL 10 - Sunetul și DAC
1. Digitalizare

ADC – Analog to Digital Converter

- Senzor de temperatură
- Biosenzor
- Senzor de proximitate
- Senzor optic etc

DAC – Digital to Analog Converter

- Controlăm motoare
- Speaker
- Dimarea luminii
- Bioactivator
- Controlăm aerul conditionat
Digitalizare
More levels - Computer – Analog – Better precision
Precision More bits per (number of levels) –
sample Resolution
More samples Fast processing – Faithful the digital
(Rate) More proc./time representation – Nyquist
Theorem
2. Modul Binary Wt

Sunetul are trei proprietăți:

- Frecvența
- Amplitudinea (Intensitate - cu cât e mai “tare” cu atâta este mai
mare unda)
- Shape (Forma) – pentru un pian este o anumită formă, pentru
trompetă altă undă etc

3. Modul R-2R
4. Se deschide programul µVision4 → Project → Open Project...
My computer → Local Disk (C:) → Keil → TExaSware →
C13_R2R3bit→ C12_R2Rbit.uvproj→ Open

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab13_DAC→ Lab13
 LABORATORUL 11 - ADC și Achiziția de date
1. ADC (Analog to Digital Converter)
Lumea înconjurătoare este alcătuită în esență din semnale
analogice : lumina, sunetul, căldura. Pentru a putea fi măsurate într-
un sistem de calcul digital, aceste semnale trebuiesc convertite în
valori numerice discrete. Un convertor analog – digital (ADC) este
un circuit electronic care convertește o tensiune analogică de la
intrare într-o valoare digitală. Aceasta poate fi reprezentată în mai
multe feluri în funcție de codificarea datelor: binar, cod Gray sau cod
complement al lui doi.

Semnal analogic

O caracteristică importantă a unui ADC o constituie rezoluția

acestuia. Rezoluția indică numărul de valori discrete pe care
convertorul poate să le furnizeze la ieșirea sa în intervalul de măsură.
Deoarece rezultatele conversiei sunt de obicei stocate intern sub
formă binară, rezoluția unui convertor analog-digital este exprimată
în biți.

Rezoluții diferite
2. Sistem de achiziții de date

Parametrii ADC:
- Precizia – 12 biți 4096
- Interval ( Range) – max 0V – max 3V
- Rezoluția – Interval/Precizie = (3V - 0V)/4096 = 0.7mV
detectabil la această valoare

Regiștrii de inițializare:
Regiștrii pentru captura unui test (sample)

3. Se deschide programul µVision4 → Project → Open Project...

My computer → Local Disk (C:) → Keil → TExaSware →
C14_ADCSWTrigger → C14_ADCSWTrigger.uvproj→ Open

Se verifică valoarea ADC în fereastra Watch1 a variabilei

ADCValue.
Peripherals → TExaS ADC

Temă:
My computer → Local Disk (C:) → Keil → Labware →
Lab14_MeasurementOfDistance→ Lab14
 LABORATORUL 12 - Sisteme – Nivelul Design
1. Systems-Level Design
- Switch x2, LED x2
- Întreruperi
- DAC – sunet – 4 biți
- ADC
- LCD

Modular Design:
- Call Graph
- Data-Flow
- Flow Chart

Ex:
Modul ADC: - ADC.h - Public Functions
- Prototypes
- ADC.c -Implementation

Main.c – Driver (Tester a modulului) – folosim/testăm modulul

- Maximizarea cuvintelor din module
- Minimizarea interdependenței

Dacă Modulul1 si Modulul2 schimbă multe date între ele atunci

putem minimiza (creăm un singur modul).
a) Call Graph

b) Data Flow Graph

c) Flow Chart

2. Display Nokia 5110

3. Se deschide programul µVision4 → Project → Open Project...
My computer → Local Disk (C:) → Keil → Labware →
Lab15_SpaceInvaders→ Lab15_SpaceInvaders.uvproj→ Open
Setarea pinilor folosiți
Inițializarea
int main(void)
{
TExaS_Init(SSI0_Real_Nokia5110_Scope); // set system clock to 80
MHz
Random_Init(1);
Nokia5110_Init();
Nokia5110_ClearBuffer();
Nokia5110_DisplayBuffer(); // draw buffer

Nokia5110_PrintBMP(32, 47, PlayerShip0, 0); // player ship middle

bottom
Nokia5110_PrintBMP(33, 47 - PLAYERH, Bunker0, 0);

Nokia5110_PrintBMP(0, ENEMY10H - 1, SmallEnemy10PointA, 0);

Nokia5110_PrintBMP(16, ENEMY10H - 1, SmallEnemy20PointA,
0);
Nokia5110_PrintBMP(32, ENEMY10H - 1, SmallEnemy20PointA,
0);
Nokia5110_PrintBMP(48, ENEMY10H - 1, SmallEnemy30PointA,
0);
Nokia5110_PrintBMP(64, ENEMY10H - 1, SmallEnemy30PointA,
0);
Nokia5110_DisplayBuffer(); // draw buffer

4. Se deschide folderul Lab15Files → SpaceInvadersArt →

SmallEnemy10pointA.nmp → Edit (Paint)
Se modifică poza după preferințe după care se salvează cu un nume
diferit ex: SmallEnemynew.nmp
Se deschide aplicația BmpConvert.exe
Se scrie denumirea dată după salvare a pozei
(SmallEnemynew) → Enter
Se creează automat un fisier .txt cu toate coordonatele animației.
Aceste coordonate le copiem în programul nostru din Keil.
Folosim funcția :
Nokia5110_PrintBMP(48,24,SmallEnemynew,0);
înainte de ClearBuffer();
Se compilează programul și se rulează pas cu pas pentru a vedea
diferența.

struct State
{
unsigned long x;
unsigned long y;
const unsigned char *image;
long life;
};
typedef struct State STyp;
STyp Enemy[4];
void Init(void)
{
int i;
for(i=0;i<4;i++)
{
Enemy[i].x=10*i;
Enemy[i].y = 10;
Enemy[i].image = SmallEnemy30PointA;
Enemy[i].life = 1;
}
}
void Move(void)
{
int i;
for(i=0;i<5;i++)
{
if(Enemy[i].x<72) {Enemy[i].x +=3;}
else {Enemy[i].life =0;}
}
}
void Draw(void)
{
int i;
Nokia5110_ClearBuffer();
for(i=0;i<5;i++)
{
if(Enemy[i].life >0)
{Nokia5110_PrintBMP(Enemy[i].x,Enemy[i].y,Enemy[i].im
age,0);}
}
Nokia5110_DisplayBuffer();
}
//------------------------------------------
Int main(void)
{
Random_Init(1);
Nokia5110_Init();
Init();
Draw();
while(1)
{
Move();
Draw();
Delay100ms(2);}
}

Timer2

Regiștrii:
- A clock enable bit, bit 2 in SYSCTL_RCGCTIMER_R
- A control register, TIMER2_CTL_R (set to 0 to disable, 1 to
enable)
- A configuration register, TIMER2_CFG_R (set to 0 for 32-bit
mode)
- A mode register, TIMER2_TAMR_R (set to 2 for periodic
mode)
- A 32-bit reload register, TIMER2_TAILR_R
- A resolution register, TIMER2_TAPR_R (set to 0 for 12.5ns)
- An interrupt clear register, TIMER2_ICR_R (bit 0)
- An interrupt arm bit, TATOIM, TIMER2_IM_R (bit 0)
- A flag bit, TATORIS, TIMER2_RIS_R (bit 0)

Timer1A_Handler(void);
 REGULAMENTUL DE PROTECȚIA MUNCII

• Studenții vor intra în laborator numai în prezența conducătorului

lucrărilor.
• În timpul lucrărilor de laborator studenții trebuie să respecte în
mod conștient o disciplină fermă impusă de necesitatea de a preveni
orice posibilitate de accident sau de declanșare a unui incendiu.
• Studenții intrați în laborator vor ramâne tot timpul la masa lor
de lucru.
• Studenții nu vor face legături la tabloul electric fără controlul
conducătorului lucrării.
• Studenții nu vor atinge tabloul electric după ce a fost pus sub
tensiune.
• Este interzisă schimbarea legăturilor în montajele aflate sub
tensiune. Pentru înlăturarea greșelilor deconectați de la sursa de
alimentare.
• Nu puneți mâna pe părțile metalice ale montajelor când acestea
sunt sub tensiune.
• Nu folosiți conductori cu izolație deteriorată și legături de
proastă calitate.
• Nu schimbați tensiunile surselor de alimentare cu montajul în
funcțiune.
• Sunt interzise manipulările fără rost de butoane, comutatoare,
întrerupătoare, de la aparatele și instalațiile din laborator. Este
interzisă acționarea butoanelor altor aparate aflate în apropiere și
care nu sunt utilizate pentru acea lucrare de laborator.
• În prima ședință de lucrări de laborator cu studenții,
conducătorul lucrării va face instructajul de protecția muncii, cu
studenții. Instructajul va fi consemnat într-un proces verbal semnat
de conducătorul lucrărilor și de către toți studenții care efectuează
lucrări practice în laborator.
• Se interzice efectuarea lucrărilor de laborator cu aparate și
instrumente sau alte accesorii ale acestora, defecte sau degradate. în
acest sens se va organiza revizia periodică a tuturor instalațiilor, iar
de la caz la caz se vor repara cele defecte.
• Studenții nu vor pune sub tensiune instalația, înainte de a fi
verificată de cadrele didactice.
• În cazul în care se constată o funcționare anormală, care indică
prezența unui deranjament, se va întrerupe imediat sursa de
alimentare. Punerea în funcțiune se va face numai după identificarea
si înlăturarea deranjamanetului.
• În caz de accidente prin electrocutare, se vor aplica măsurile de
prim ajutor prevăzute în actele privind protecția muncii, în vigoare.
• Se interzice cu desăvârșire orice alt fel de activitate a studenților
cu instalația sau aparatele din laborator în lipsa cadrelor didactice sau
a unei persoane special calificată pentru supravegherea lucrării.
• Pentru asigurarea condițiilor de igienă a muncii se va păstra
curățenia la locul de muncă, iar la începutul și sfârșitul orei de
laborator se va aerisi bine laboratorul.
• Toate tablourile principale de electroalimentare vor fi prevăzute
cu prize cu pământare.
• Toate legăturile electrice la rețeaua de curent alternativ (220 V)
se vor face numai cu prelungitoare prevăzute cu prize SHUKO -
prevăzute cu borne de nul.
• Schemele de montaj electric nu se vor pune sub tensiune decât
după ce au fost verificate de cadrul didactic și numai în prezența
acestuia.
• În timpul lucrării se va respecta disciplina în muncă.
• Iluminarea locului de muncă va fi de un nivel corespunzător și
cât mai uniformă.
• Sălile de laborator vor fi menținute în bună stare de ordine și
curățenie.
• Studenții au obligația de a verifica buna funcționare a tuturor
aparatelor, înaintea efectuării măsurătorilor sau a montajelor, și de a
atrage atenția conducătorului lucrărilor asupra aparatelor defecte sau
distruse sau asupra lipsei unor componente sau aparate.
 NORME DE PREVENIRE ȘI STINGERE A
INCENDIILOR

• Se interzice fumatul în laborator.

• Se interzice blocarea căilor de acces, accesul la hidranți, accesul
la stingătoare.
• Este interzisă depozitarea cârpelor folosite la curățirea
aparatelor pe calorifere sau în apropierea surselor de căldură, acestea
după folosire se vor pune în recipiente metalice cu capac, după care
vor fi evacuate din laborator.
• Lucrările de laborator efectuate de studenți se vor face sub
directa supraveghere a cadrelor didactice.
• Este interzisă blocarea ferestrelor cu pachete, materiale sau
aparate.
• Se va verifica periodic instalația electrică a aparatelor.
• Nu se vor folosi întrerupătoare, prize defecte .
• Este interzisă folosirea instalațiilor electrice improvizate.
• Nu este permis a se lăsa aparatele electrice nesupravegheate sub
tensiune.
• Exploatarea utilajelor acționate de electromotoare se va face în
limita sarcinilor, nefiind admisă suprasolicitarea lor.
• Toate părțile mecanice ale mașinilor unelte și utilajelor la care
se poate produce electricitate statică, vor fi prevăzute cu instalatie de
legare la pământ.
• Tablourile electrice, releele, contactoarele etc. vor fi prevăzute
cu carcase de protecție iar la tablourile electrice se vor întrebuința
numai siguranțe calibrate.
• Se interzice supraîncărcarea circuitelor prin racordarea mai
multor consumatori decât cei prevazuti pentru instalația respectivă.
• În caz de incendiu se va anunța unitatea de pompieri la telefon si
totodată se vor lua măsuri de stingere cu materialele P.S.I. din dotare.
• Este interzisă folosirea materialelor P.S.I. în alte scopuri.
• Este interzisă blocarea accesului si circulației la utilaje, la
panourile electrice, la materialele și la instalațiile pentru
semnalizarea sau stingerea incendiilor.
 După prelucrarea și însușirea Normelor pentru Protecția Muncii și
pentru Prevenirea și Stingerea Incendiilor, studenții vor completa și
semna un Proces Verbal.
 CONDIȚII DE LUCRU ÎN LABORATOR

• Accesul în laborator se face numai în prezența conducătorului

lucrărilor!
• Este interzisă modificarea setărilor stațiilor de lucru, descărcarea
sau copierea altor fisiere pe stații, partajarea resurselor (share),
instalarea sau dezinstalarea de aplicații, screen-saver, imagini
desktop etc!
• Navigarea pe Internet este permisă exclusiv în scop didactic, în
cadrul activităților organizate!
• Pornirea, oprirea sau restartarea computerelor se face numai cu
permisiunea conducătorului lucrărilor!
• La părăsirea laboratorului sistemele trebuie lăsate în starea în
care au fost găsite, iar scaunele aliniate câte două la mesele de lucru!
• Nerespectarea acestor reguli va determina sancționarea celor
vinovați: interzicerea accesului în laborator, sancțiuni administrative,
sancțiuni financiare, după caz!
 PROCES VERBAL - PENTRU NORMELE
DE TEHNICĂ ȘI SECURITATE

Subsemnatul/a................................................., având gradul didactic

................................................, am efectuat astăzi
…………………… instructajul de protecția muncii conform
“Normelor de protecția muncii” specifice Laboratorului de
......................................................................., studenților de la
specializarea .............................., anul ....., grupa ..........

Am luat la cunostință aceste prevederi și voi respecta normele

de protecție a muncii.

Nr.
Nume și prenume Semnătura
crt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40