Structura unui program C. Structura unui program C

Ultima actualizare: 18.05.2017

Un program C constă dintr-un set de directive de preprocesor, definiții de funcții și obiecte globale. Directivele preprocesorului controlează transformarea textului înainte ca acesta să fie compilat. Obiectele globale definesc datele utilizate sau starea programului. Și funcțiile definesc comportamentul sau acțiunile unui program. Cel mai simplu program C care a fost definit în subiectele anterioare:

#include int main (void) (printf ("Bună lume! \ n"); return 0;)

Instrucțiuni

Cele mai simple blocuri ale unui program C sunt instrucțiunile. Fiecare instrucțiune efectuează o acțiune specifică. La sfârșitul instrucțiunilor în limbajul C, se pune punct și virgulă (;). Acest semn indică compilatorului să finalizeze instrucțiunea. De exemplu:

Printf ("Bună lume!");

Apel funcții printf care tipărește șirul „Hello world!” este o instrucțiune și se termină cu punct și virgulă.

Un set de instrucțiuni poate reprezenta un bloc de cod. Un bloc de cod este închis în acolade, instrucțiunile care alcătuiesc corpul acestui bloc sunt plasate între bretele de deschidere și de închidere:

(printf ("Bună lume!"); printf ("Adio lume!");)

Există două instrucțiuni în acest bloc de cod. Ambele instrucțiuni reprezintă un apel la funcția printf () și imprimă o linie specifică în consolă.

Directive pentru preprocesor

Pentru a scoate date către consolă din exemplul de mai sus, se folosește funcția printf (), dar pentru a utiliza această funcție astfel încât să devină disponibilă pentru noi într-un program C, este necesar să includem antetul stdio.h fișier la începutul fișierului cod sursă folosind directiva include.

Directiva include este o directivă de preprocesor. În plus față de aceasta include, există o serie de directive de preprocesor, de exemplu, definite.

Fiecare directivă de preprocesor este plasată pe o linie. Și spre deosebire de instructiunile obisnuite limbaje C care se termină cu punct și virgulă; , un semn de încetare a unei directive de preprocesare este o linie nouă. În plus, directiva trebuie să înceapă cu semnul hash #.

Directiva „include” determină direct în ce fișiere trebuie incluse acest locîn textul programului. În mod implicit, putem include fișiere standard din directorul așa-numitelor „fișiere antet”, care sunt de obicei furnizate cu biblioteci standard compilator. Și fișierul „stdio.h” este doar unul dintre acele fișiere de antet.

În general, termenul „fișier antet” în sine implică includerea textului fișierului tocmai la începutul sau în antetul programului. Prin urmare, fișierele antet sunt de obicei incluse la începutul codului sursă. În plus, fișierul antet trebuie inclus înainte de a apela funcțiile pe care le definește. Adică, de exemplu, fișierul stdio.h conține definiția funcției printf, deci acest fișier trebuie inclus înainte de a apela funcția printf.

Dar, în general, directivele de preprocesor nu trebuie să fie plasate la începutul fișierului.

La compilarea codului sursă, este declanșat mai întâi preprocesorul, care scanează sursă pentru liniile care încep cu caracterul #. Aceste linii sunt tratate ca directive de către preprocesor. Și în locul acestor directive, textul se transformă. De exemplu, în locul directivei #include se inserează codul din fișierul stdio.h.

Functie principala

Punctul de plecare pentru orice program C este funcția principală (). Cu această funcție începe execuția aplicației. Numele său principal este fix și este întotdeauna același pentru toate programele C.

O funcție este, de asemenea, un bloc de cod, astfel încât corpul ei este înconjurat de acolade, între care există un set de instrucțiuni.

Trebuie remarcat faptul că modificări ale acestei funcții pot fi găsite în diverse literaturi și exemple. În special, în loc de definiția de mai sus, am putea scrie diferit:

#include void main () (printf ("Bună lume!");)

#include int main () (printf ("Bună ziua, lume!"); return 0;)

Nu ar fi o eroare să folosești aceste definiții, iar programul ar tipări și șirul „Hello world” pe consolă. Și pentru majoritatea compilatorilor, asta ar fi bine.

În continuare, vom arunca o privire mai atentă asupra definiției funcțiilor, dar aici trebuie luat în considerare următorul aspect. Definiția unei funcții sub forma int main (void) este fixată în standardul limbajului C11. Compilatorii sunt ghidați în primul rând de standardul limbajului, specificația acestuia. Prin urmare, dacă folosim definiția dată în standardul limbajului, atunci există o șansă mai mare ca aceasta să fie acceptată de toți compilatorii. Deși din nou, repet, folosind a doua opțiune sau int main () mare greșeală Nu va fi.

Cel mai recent standard C11 poate fi vizualizat la

Fig. 1 Structura unui program C.

Structura interna programe

Program executabilîn C constă din 4 părți: zonă de comandă, zonă de date statice, zonă de date dinamice, zonă de stivă. vezi Fig. 2.

1. Zona de comandă conține instrucțiuni ale mașinii; instructiunile care trebuie urmate de microprocesor.

2. Zona de date statice pentru stocarea variabilelor cu care functioneaza programul;

3. Zona de date dinamice pentru plasarea datelor suplimentare care apar în timpul lucrului programului (de exemplu, variabile temporare).

4. Stiva este folosită pentru a stoca temporar date și a returna adresele de la funcții.

corp funcțional/ * corp funcțional * /

printf (" Salut Lume!");

prima linie - o directivă care conectează fișierul antet pentru intrare-ieșire standard. Există puțini operatori în C, dar există o bibliotecă de funcții. Pentru a le folosi, trebuie să le conectați, ceea ce face directiva - prima linie a programului. Simbolul # indică faptul că șirul trebuie procesat de preprocesorul C.

a 2-a linie - Nume functie principala principal (), această funcție nu returnează niciun parametru (voi vorbi despre asta puțin mai târziu). Un program C are întotdeauna funcția principal (). Execuția programului începe cu acesta.

a 3-a linie - începutul corpului funcţional. () definește corpul funcției (în Pascal, acestea sunt începutul și sfârșitul)

a 4-a linie - un comentariu, nu se compila, ci doar explica ceea ce se face.

a 5-a linie - funcția de bibliotecă - imprimați pe ecran, expresia dintre paranteze de pe această linie este un parametru de funcție, este întotdeauna cuprinsă între ghilimele.

; - acesta este un semn al operatorului C, este o parte a operatorului și nu un separator de operatori, ca în Pascal.

Sfaturi pentru ca programul să fie lizibil:

1) Alegeți nume semnificative

2) Folosiți comentarii

3) Utilizare linii goale pentru a separa o parte a unei funcții de alta

4) Plasați fiecare afirmație pe o linie diferită.

ELEMENTE DE BAZĂ ALE LIMBAJULUI SI

Considera elementele necesare, cu ajutorul căruia programul C ar trebui formatat:

1. Comentarii (1) - sunt folosite pentru a documenta programul. Orice program ar trebui să conțină comentarii: ce algoritm este folosit, ce face programul...

Ø 1 cale: / * Text * / - oriunde în program.

De îndată ce compilatorul întâlnește / ** /, le omite. Compilatorul ignoră / * * / deoarece nu poate interpreta un alt limbaj decât C. Adică, dacă doriți să excludeți o anumită linie din compilare, atunci includeți-o în / ** /.

Ø 2 sensuri: dacă comentariul este mare, atunci folosim acest tip

/ * Linia 1 - pentru orice comentariu de lungime

linia 3 * /

Ø 3 căi: // - text până la sfârșitul rândului.

2. Identificator este un nume care este atribuit unui obiect (variabilă). Folosește litere mici și litere mari, numere și subliniere. Literele mici și mari sunt diferite. (Nu diferă în BASIC). Dacă numiți un nume de variabilă, Nume sau NUME, atunci acestea vor fi variabile diferite.

Identificatorii încep cu o literă sau subliniere. De exemplu _name. Dar nu este recomandat să începeți cu _, deoarece acest semn este folosit pentru numele globale ale limbajului C.

V programare modernă adesea folosit pentru a crea identificatori Notație maghiară, unde anumite simboluri sunt folosite pentru a caracteriza identificatorul, de exemplu:

b - octet; ch este un caracter pe un singur octet;

w - cuvânt; f - steag;

l - cuvânt lung; fn - funcție;

u - nesemnat; p este un indicator;

c - contor; d - diferența de două pre-x

cz - șir; etc.

3. Cuvinte de serviciu - sunt cuvinte cu care anumite semnificații semantice sunt rigid comparate în limbă și care nu pot fi folosite în alte scopuri. Acestea sunt numele operatorilor, funcțiile bibliotecii, comenzile preprocesorului și așa mai departe. Aceste cuvinte nu pot fi folosite pentru a crea numele funcțiilor, variabilelor...

DATE ÎN PROGRAM ÎN SI

Fiecare program funcționează cu date... Ele sunt prezente în program sub formă de variabile și constante.

Sunt apelate date care se pot modifica sau cărora li se pot atribui valori în timpul execuției programului variabile.

Date care sunt setate la anumite valori și își păstrează valorile pe toată durata funcționării programului, se numesc constante.

constante

Constantele sunt valori fixe. Valoarea, odată setată, nu se mai modifică. Constantele sunt de diferite tipuri. Tipurile diferă în funcție de principiul plasării în memoria computerului și pentru o persoană în funcție de tipul de înregistrare. În C, există 7 cuvinte cheie folosite pentru a face referire tipuri diferite date: int, long, short, unsigned, char, float, double.

Tipuri de constante :

A) Întregi și întregi lungi ... Înregistrat în notație zecimală, octală și hexazecimală. Ele pot fi semnate sau nesemnate.

Sistemul zecimal: constante întregi ocupa 16 biți memorie și luați un interval de valori: -32768 până la +32767 (2 15) ... Dacă constanta este fără semn, atunci intervalul este dublat: 0 la 65535(datorită faptului că a 15-a cifră - semn este folosită sub număr). Pentru a indica un număr nesemnat, utilizați sufixul u (nesemnat) ca 123u.

Dacă numărul este mai mare de 40.000, atunci compilatorul îl va converti automat într-un număr negativ, deci sufixul u necesar: 40000u. În exemplul 123u, compilatorului nu îi pasă dacă există sau nu un sufix, deoarece acest număr este în intervalul 32767.

Număr întreg lung ia 32 de biți , interval de valori

± 2147483648 (semnat lung - lung). Daca pui sufixul l, atunci, în ciuda numărului, 32 de biți vor fi ocupați. De exemplu: -5326 l

0 – 4294967295 nesemnat lung- (nesemnat lung). Intervalul este mărit cu al 31-lea bit. Se folosesc sufixe ul de exemplu 32659ul.

Sistem octal :

Dacă numărul începe cu cifra 0, este interpretat ca un număr octal

16 biți 0 ¸ 077777

0100000 ¸ 0177777u

32 de biți 0200000 ¸ 01777777777l

020000000000 ¸ 037777777777ul

Sistem hexazecimal :

Dacă numărul începe cu caracterul 0x, atunci este interpretat ca hexazecimal

16 biți 0x0000 ¸ 0x7FFF

0x8000 ¸ 0xEFFFu

32 de biți 0x10000 ¸ 0x7FFFFFFFl

0x80000000 ¸ 0xFFFFFFFFul

b) Constante reale. Acestea sunt numere în virgulă mobilă. Ce contează parte fracționată... În mod implicit, toate constantele în virgulă mobilă sunt de tip dublă precizie. dubla ... Ocupă memoria 8 octeți (chiar dacă 0,0). Gama de valori ± 1 * 10 ± 307 , poate fi scris în formă științifică, de exemplu: 0,5e + 15 sau

1,2e-3 = 1,2 * 10 -8 = 0,0012.

Puteți forța un singur format de precizie pluti ... Numărul va ocupa 4 octeți , se folosește sufixul f(5,7 f). În consecință, intervalul este restrâns ± 1 * 10 ± 37

Precum și precizie extinsă – dublu lung - 10 octeți . (3,14 L)

Semnul + poate fi omis. Este permisă omiterea fie a punctului zecimal, fie a părții exponențiale, dar nu în același timp (.2; 4e16). Este posibil să nu scrieți partea fracțională sau întreagă, dar nu în același timp (100 .; .8e-5)

c) Constante de caractere. Este un set de simboluri folosite în calculatoare.

Împărțit în 2 grupe: tipărite și netipărite(coduri de control). O constantă de caracter include doar 1 caracter, care trebuie inclus în apostrofe și ocupări 1 octet memorie.

Orice personaj are dubla reprezentare în Tabelul ASCII... Într-un program sunt introduse constante simbolice ghilimele simple, la compilare, programul este înlocuit valoare numerică caracter din ASCII. Un caracter are 1 octet.

Caracterul "A" "a" "" "\ n"

Codul său este 65 97 32 10

Cum întreg tip datele „A” = 0101 8, 01000001 2, 41 16, 65 10. Nu trebuie să memorați coduri.

Codurile de control încep cu \ și sunt, de asemenea, incluse în apostrofe. Cele mai comune coduri de control sunt:

\ n - linie nouă

\ t - tabulare (deplasarea cursorului cu o valoare fixă)

\ b - pas înapoi (schimbați o poziție înapoi)

\ r - întoarcere transport (întoarcerea la începutul liniei)

\ f - Alimentare formular (alimentare hârtie pentru 1 pagină)

\ '- apostrof

\ "- citate

Ultimele trei personaje pot fi constante simbolice, și, de asemenea, utilizate în funcția printf (), astfel încât utilizarea lor ca simboluri poate duce la o eroare. De exemplu, dacă vrem să afișăm șirul „Caracterul \ se numește slash”, atunci operatorul ar trebui să arate astfel:

printf ("Caracterul \\ se numește slash");

A) Constante de șir - conțin o secvență de 1 sau mai multe caractere incluse în „”. 1 octet este cheltuit pentru orice caracter + 1 octet pentru așa-numitul caracter zero - un semn al sfârșitului unei linii. Caracterul zero nu este cifra zero, înseamnă că numărul de caractere din șir (N) trebuie să fie cu 1 octet mai mult (N + 1) pentru a indica sfârșitul șirului (compilatorul îl adaugă automat). De exemplu: „linia de text” este (13 + 1) octeți;

"Pace" -

Un program scris în C # este format din următoarele blocuri:

• declarație de spațiu de nume (un fel de container);
• declarație de clasă (esența principală a programului);
• metode de clasă (subrutine), cel puțin o metodă Principal;
• operatori și expresii;
• comentarii.

Un exemplu de cel mai simplu program

sa luam in considerare cel mai simplu program scris în C #. Va fi o aplicație de consolă care scoate șirul „Hello World” (un fel de clasic pentru primul program din practica unui programator). Codul unui astfel de program este afișat mai jos, să ne uităm la el:

// Conectarea spațiului de nume System folosind System; // Declarație de spațiu de nume spațiu de nume ProgramStructure (// Declarație de clasă de clasă Program (// Metoda principală static void Main (șir argumente) (// Ieșirea unui șir Console.WriteLine ("Hello World!"); // Instrucțiune auxiliară Console.ReadKey ();)))

Prima linie a acestui program este un comentariu. Comentariile nu afectează în niciun fel funcționarea programului, ele sunt necesare pentru persoana care va menține codul programului (modificarea acestuia, remedierea erorilor etc.).

A doua linie a programului ( folosind System;) este operatorul care conectează spațiul de nume standard Sistem... De fapt, avem acces la un set de clase disponibile în „container” Sistem... Așa cum se vede, șir dat constă din două cuvinte, primul ( cuvânt cheie folosind) înseamnă că dorim să includem spațiul de nume și al doilea Sistem- numele spațiului de nume necesar.

La sfârșitul celui de-al doilea rând există un caracter „;”, care indică sfârșitul instrucțiunii. Fiecare instrucțiune de program trebuie să se încheie cu acest simbol.

A patra linie a programului este din nou un comentariu, exact ca și rândurile 7, 10, 13, 15. Comentariile în C # încep cu caracterele „//” (două bare oblice, două bare oblice) și sunt valabile doar până la sfârșitul linia.

C # are și comentarii pe mai multe rânduri, uneori este mai convenabil să le folosim, le vom întâlni mai târziu.

A cincea linie ( Namespace ProgramStructure) își declară propriul spațiu de nume, se numește „ProgramStructure”. Un spațiu de nume este un fel de container și este delimitat de acolade (linia de deschidere 6 și linia de închidere 19) după numele său. Deci, totul dintre rândurile 6 și 19 aparține spațiului de nume Structura programului.

Linia 8 declară o clasă numită „Program”, aceasta este principala și singura clasă a programului nostru. După cum puteți vedea, cuvântul cheie este folosit pentru a declara o clasă clasă urmat de numele clasei. Este posibil să nu existe una, ci mai multe clase în program. De obicei, o clasă constă dintr-un set de metode care definesc așa-numitul comportament al clasei (funcționalitate, dacă vrei). Limitele clasei, precum și spațiile de nume sunt indicate prin acolade (liniile 9 și 18). În cazul nostru, clasa are o singură metodă, aceasta este metoda Principal.

Linia 11 declară metoda Principal... Această metodă este centrală pentru programul nostru, așa-numitul punct de intrare în program. Aceasta înseamnă că atunci când programul pornește, prima metodă va fi executată. Principal... Fiecare metodă are și margini, care sunt indicate și prin acolade (liniile 12 și 17).

Metodă Principal programul nostru conține doar doi operatori. Acești operatori apar pe liniile 14 și 16. Primul tipărește mesajul „Hello World!” Iar al doilea, este auxiliar, face ca programul să aștepte apăsarea unei taste de pe tastatură și nu îi permite să-și finalizeze execuția până în acel moment (fără acest operator, programul ar fi imprimat o linie și s-ar fi închis rapid, așa că noi nici nu a avut timp să citească ce tipărise).

Acum încercați să construiți și să rulați acest program în Visual Studio. Pentru asta ai nevoie de:

• porniți Visual Studio;
• crea proiect nou aplicație de consolă;
• copiați liniile 13-16 din exemplul de mai sus;
• introduceți aceste linii în metodă Principal un proiect creat în Visual Studio;
• apăsați tasta F5.

Am vorbit în detaliu despre cum să creați un proiect de aplicație consolă în Visual Studion în, vă sfătuiesc să îl citiți.

În ce constă programul

Pentru început, ar trebui să înțelegeți că un program nu poate fi citit și scris ca o carte: de la copertă la copertă, de sus în jos, rând cu rând. Orice program constă din blocuri separate. Începutul unui bloc de cod în C/C++ este indicat printr-o acoladă stângă (, sfârșitul acestuia este indicat printr-o dreapta bretele ondulate } .

Blocurile sunt tipuri diferiteși care dintre ele va fi executată când depinde de condițiile externe. În exemplu program minim se pot vedea 2 blocuri. În acest exemplu, blocurile sunt denumite definirea funcției... O funcție este doar un bloc de cod cu prenume pe care cineva îl poate folosi apoi din afară.

V în acest caz avem 2 funcții numite setup și loop. Prezența lor este necesară în orice program C++ pentru Arduino. S-ar putea să nu facă nimic, ca în cazul nostru, dar trebuie scrise. În caz contrar, veți primi o eroare în timpul compilării.

Clasici ale genului: LED intermitent

Să adăugăm acum programul nostru pentru ca măcar să se întâmple ceva. Pe Arduino, un LED este conectat la pinul 13. Poate fi controlat, ceea ce vom face.

void setup () (pinMode (13, OUTPUT);) void loop () (digitalWrite (13, HIGH); întârziere (100); digitalWrite (13, LOW); întârziere (900);)

Compilați, descărcați programul. Veți vedea că LED-ul de pe placă clipește în fiecare secundă. Să ne dăm seama de ce acest cod duce la clipirea în fiecare secundă.

Fiecare expresie este un ordin pentru ca procesorul să facă ceva. Expresiile dintr-un bloc sunt executate una după alta, strict în ordine, fără pauze sau comutare. Adică, dacă vorbim despre un anumit bloc de cod, acesta poate fi citit de sus în jos pentru a înțelege ce se face.

Acum să înțelegem în ce ordine sunt executate blocurile în sine, adică. funcții de configurare și buclă. Nu te gândi la ce înseamnă expresii specifice deocamdată, doar respectă ordinea.

De îndată ce Arduino pornește, butonul RESET este aprins sau apăsat, „ceva” apelează funcțiaînființat. Adică forțează ca expresiile din el să fie executate.

O singura data configurarea muncii termină, imediat „ceva” apelează funcția buclă.

De îndată ce bucla este terminată, imediat „ceva” apelează din nou funcția buclă și așa mai departe la infinit.

Dacă numerotați expresiile în ordinea în care sunt executate, obțineți:

void setup () (pinMode (13, OUTPUT); ❶) void loop () (digitalWrite (13, HIGH); ❷ ❻ ❿ întârziere (100); ❸ ❼... digitalWrite (13, LOW); ❹ ❽ întârziere (900) ; ❺ ❾)

Permiteți-ne să vă reamintim încă o dată că nu ar trebui să încercați să percepeți întregul program citind de sus în jos. De sus în jos, se citește doar conținutul blocurilor. În general, putem schimba ordinea declarațiilor de configurare și buclă.

void loop () (digitalWrite (13, HIGH); ❷ ❻ ❿ întârziere (100); ❸ ❼... digitalWrite (13, LOW); ❹ ❽ întârziere (900); ❺ ❾) void setup () (mod pin (13, OUTPUT) ); ❶)

Rezultatul nu va schimba nici un iota din acesta: după compilare, veți obține un fișier binar absolut echivalent.

Ce fac expresiile

Acum să încercăm să înțelegem de ce programul scris ajunge să clipească LED-ul.

După cum știți, pinii Arduino pot acționa ca ieșiri și intrări. Când vrem să controlăm ceva, adică să dăm un semnal, trebuie să punem pinul de control în starea de lucru pe ieșire. În exemplul nostru, conducem LED-ul pe pinul 13, deci pinul 13 trebuie setat la ieșire înainte de utilizare.

Acest lucru se face printr-o expresie din funcția de configurare:

PinMode (13, IEȘIRE);

Expresiile sunt diferite: aritmetice, declarații, definiții, condiționale etc. În acest caz, noi în expresia executăm apel de funcție... Tine minte? Noi avem al lor funcțiile de configurare și buclă, care sunt numite prin ceea ce am numit „ceva”. Asa ca acum noi numim functii care sunt deja scrise undeva.

Mai exact, în configurația noastră, numim o funcție numită pinMode. Setează pinul specificat la modul presetat: intrați sau ieșiți. Ce pin și despre ce mod vorbim este indicat de noi în paranteze, despărțit prin virgule, imediat după numele funcției. În cazul nostru, dorim ca al 13-lea pin să funcționeze ca ieșire. OUTPUT înseamnă ieșire, INPUT înseamnă intrare.

Sunt apelate valori de clarificare precum 13 și OUTPUT argumente ale funcției... Nu este deloc necesar ca toate funcțiile să aibă 2 argumente. Câte argumente are o funcție depinde de esența funcției, de modul în care autorul a scris-o. Pot exista funcții cu un argument, trei, douăzeci; funcțiile nu pot avea deloc argumente. Apoi să-i sun paranteze se deschide si se inchide imediat:

Fără întreruperi ();

De fapt, poate ați observat că nici funcțiile noastre de configurare și buclă nu acceptă niciun argument. Iar misteriosul „ceva” îi numește la fel cu paranteze goale la momentul potrivit.

Să revenim la codul nostru. Deci, din moment ce intenționăm să clipim LED-ul pentru totdeauna, pinul de control trebuie făcut o dată la ieșire și apoi nu vrem să ne amintim. Funcția de configurare este destinată ideologic pentru asta: configurați placa după cum este necesar, astfel încât să puteți lucra cu ea mai târziu.

Să trecem la funcția buclă:

buclă goală () (digitalWrite (13, HIGH); întârziere (100); digitalWrite (13, LOW); întârziere (900);)

După cum am menționat, este apelat imediat după configurare. Și este chemat iar și iar de îndată ce se termină. Funcția buclă este numită bucla principală a unui program și este concepută ideologic pentru a face o muncă utilă. În cazul nostru muncă utilă- LED-ul clipește.

Să parcurgem expresiile în ordine. Deci prima expresie este un apel la funcția digitalWrite încorporată. Este proiectat să furnizeze un zero logic (LOW, 0 volți) sau unul logic (HIGH, 5 volți) unui pin dat. 2 argumente sunt transmise funcției digitalWrite: un număr de pin și o valoare logică. Drept urmare, primul lucru pe care îl facem este să pornim LED-ul de pe al 13-lea pin, furnizându-i 5 volți.

Odată ce acest lucru este făcut, procesorul trece imediat la următoarea expresie. Avem acest apel la funcția de întârziere. Funcția de întârziere este, din nou, o funcție încorporată care face ca procesorul să dorm pentru o anumită perioadă de timp. Este nevoie de un singur argument: timpul în milisecunde pentru a dormi. În cazul nostru, aceasta este 100 ms.

În timp ce dormim, totul rămâne așa cum este, adică. LED-ul rămâne aprins. Imediat ce au trecut 100 ms, procesorul se trezește și trece imediat la următoarea expresie. În exemplul nostru, acesta este din nou un apel la funcția familiară digitalWrite încorporată. Adevărat, de data aceasta trecem valoarea LOW ca al doilea argument. Adică, setăm un zero logic pe al 13-lea pin, adică furnizăm 0 volți, adică oprim LED-ul.

După ce LED-ul este stins, trecem la următoarea expresie. Din nou, acesta este un apel la funcția de întârziere. De data asta ne culcăm timp de 900 ms.

Odată ce somnul s-a încheiat, funcția buclă se termină. La finalizare, „ceva” îl sună imediat din nou și totul se întâmplă din nou: LED-ul este aprins, aprins, stins, așteaptă etc.

Dacă traduceți ceea ce este scris în rusă, obțineți următorul algoritm:

Aprindem LED-ul

Dormiți 100 de milisecunde

Oprirea LED-ului

Dormiți 900 de milisecunde

Treceți la pasul 1

Deci avem un Arduino cu un far care clipește la fiecare 100 + 900 ms = 1000 ms = 1 sec.

Ce poate fi schimbat

Să folosim doar cunoștințele acumulate și să facem mai multe variații ale programului pentru a înțelege mai bine principiul.

Puteți conecta un LED extern sau alt dispozitiv care trebuie să „clipească” pe un alt pin. De exemplu, pe 5. Cum ar trebui să se schimbe programul în acest caz? Trebuie să înlocuim numărul cu al 5-lea oriunde ne referim la al 13-lea pin:

Compilați, descărcați, testați.

Ce ar trebui făcut pentru ca LED-ul să clipească de 2 ori pe secundă? Reduceți timpul de somn, astfel încât totalul să fie de 500 ms:

void setup () (pinMode (5, OUTPUT);) void loop () (digitalWrite (5, HIGH); întârziere (50); digitalWrite (5, LOW); întârziere (450);)

Cum să faci LED-ul să clipească de două ori la fiecare „clini”? Trebuie să-l dai foc de două ori, cu o scurtă pauză între pornire:

void setup () (pinMode (5, OUTPUT);) void loop () (digitalWrite (5, HIGH); întârziere (50); digitalWrite (5, LOW); întârziere (50); digitalWrite (5, HIGH); întârziere (50); digitalWrite (5, LOW); întârziere (350);)

Cum să faci dispozitivul să aibă 2 LED-uri care clipesc alternativ în fiecare secundă? Trebuie să comunicați cu doi pini și să lucrați în buclă cu unul sau altul:

void setup () (pinMode (5, OUTPUT); pinMode (6, OUTPUT);) void loop () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900); digitalWrite (6, HIGH); întârziere (100); digitalWrite (6, LOW); întârziere (900);)

Cum se face ca dispozitivul să aibă 2 LED-uri care s-ar comuta în felul unui semafor feroviar: ar fi unul atunci aprins? Trebuie doar să nu stingeți LED-ul aprins chiar acolo, ci să așteptați momentul comutării:

void setup () (pinMode (5, OUTPUT); pinMode (6, OUTPUT);) void loop () (digitalWrite (5, HIGH); digitalWrite (6, LOW); întârziere (1000); digitalWrite (5, LOW) ; digitalWrite (6, HIGH); întârziere (1000);)

Puteți verifica singur alte idei. După cum puteți vedea, totul este simplu!

Despre spațiu gol și cod frumos

În C ++, spațiile, întreruperile de rând și tabele nu au de mare importanta pentru compilator. Acolo unde există un spațiu, poate exista o întrerupere de linie și invers. De fapt, 10 spații la rând, 2 întreruperi de rând și încă 5 spații sunt toate echivalente cu un spațiu.

Spațiul alb este o unealtă de programator cu care poți fie să faci un program ușor de înțeles și intuitiv, fie să-l desfigurați dincolo de recunoaștere. De exemplu, să ne amintim programul pentru clipirea unui LED:

void setup () (pinMode (5, OUTPUT);) void loop () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900);)

O putem schimba astfel:

void setup () (pinMode (5, OUTPUT);) void loop () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900);)

Tot ce am făcut a fost să ne chinuim puțin spațiul gol. Acum puteți vedea clar diferența dintre codul slab și cel care nu poate fi citit.

Pentru a respecta legea nerostită a proiectării programelor, care este respectată pe forumuri, atunci când este citită de alți oameni, este ușor de perceput de dvs., urmați câteva reguli simple:

1. Întotdeauna, când începeți un nou bloc între (și), creșteți indentarea. De obicei sunt folosite 2 sau 4 spații. Alegeți una dintre valori și respectați-o peste tot.

Prost:

buclă goală () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900);)

Bun:

buclă goală () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900);)

2. Ca și în limbajul natural, folosiți un spațiu după virgule și nu îl precedați.

Prost:

DigitalWrite (5, HIGH); digitalWrite (5, HIGH); digitalWrite (5, HIGH);

Bun:

DigitalWrite (5, HIGH);

3. Plasați simbolul de pornire a blocului (pornit linie nouă pe nivelul actual liniuță sau la sfârșitul celei precedente. Un caracter de sfârșit de bloc) pe o linie separată la nivelul de indentare curent:

Prost:

void setup () (pinMode (5, OUTPUT);) void setup () (pinMode (5, OUTPUT);) void setup () (pinMode (5, OUTPUT);)

Bun:

void setup () (pinMode (5, OUTPUT);) void setup () (pinMode (5, OUTPUT);)

4. Folosiți linii goale pentru a separa blocurile de semnificații:

Bun:

Mai bine:

buclă goală () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900); digitalWrite (6, HIGH); întârziere (100); digitalWrite (6, LOW); întârziere ( 900);)

Despre punct și virgulă

S-ar putea să vă întrebați de ce există un punct și virgulă la sfârșitul fiecărei expresii? Acestea sunt regulile C++. Se numesc astfel de reguli sintaxa limbajului... Prin simbol; compilatorul înțelege unde se termină expresia.

După cum am menționat deja, rupturile de rând pentru el sunt o frază goală, așa că se concentrează pe acest semn de punctuație. Acest lucru vă permite să scrieți mai multe expresii simultan pe o singură linie:

buclă goală () (digitalWrite (5, HIGH); întârziere (100); digitalWrite (5, LOW); întârziere (900);)

Programul este corect și echivalent cu ceea ce am văzut deja. Cu toate acestea, este o formă proastă să scrii așa. Codul este mult mai greu de citit. Prin urmare, dacă nu aveți motive 100% întemeiate să scrieți mai multe expresii pe o singură linie, nu o faceți.

Despre comentarii

Una dintre regulile unei bune programe este: „scrie-ți codul astfel încât să fie atât de înțeles încât să nu aibă nevoie de explicații”. Acest lucru este posibil, dar nu întotdeauna. Pentru a le lămuri cititorilor săi câteva puncte deloc evidente din cod: colegii tăi sau tu însuți într-o lună, există așa-zise comentarii.

Acestea sunt construcții în codul programului care sunt complet ignorate de compilator și sunt semnificative doar pentru cititor. Comentariile pot fi pe mai multe rânduri sau pe o singură linie:

/ * Funcția de configurare este numită prima când Arduino este pornit și acesta este un comentariu pe mai multe linii * / void setup () ( // setați al 13-lea pin în modul de ieșire pinMode (13, IEȘIRE); ) bucla nulă () (digitalWrite (13, HIGH); întârziere (100); // sleep 100ms digitalWrite (13, LOW); întârziere (900);)

După cum puteți vedea, puteți scrie câte rânduri de comentarii doriți între simbolurile / * și * /. Și după secvența / /, tot ceea ce urmează până la sfârșitul rândului este considerat un comentariu.

Așadar, sperăm că cele mai de bază principii ale compunerii programelor de scriere au devenit clare. Cunoștințele acumulate vă permit să controlați programatic sursa de alimentare a pinii Arduino în conformitate cu anumite scheme de sincronizare. Acest lucru nu este atât de mult, dar totuși suficient pentru primele experimente.

C, cum ar fi variabilele statice și locale, matricele, pointerii, funcțiile etc., sunt la fel de aproape de arhitectură computere reale... Deci, un pointer este doar o adresă de memorie, o matrice este o zonă adiacentă a memoriei, variabilele locale sunt variabile situate pe stiva hardware, variabilele statice sunt în memoria statică. Un programator C are întotdeauna o idee destul de precisă despre modul în care programul pe care îl creează va funcționa pe orice arhitectură anume. Cu alte cuvinte, limbajul C oferă programatorului control complet asupra computerului.

Inițial, C a fost conceput ca un substitut pentru Assembler pentru scriere sisteme de operare... Deoarece C este un limbaj de nivel înalt, independent de arhitectură, textul sistemului de operare a fost ușor de portat de la o platformă la alta. Primul sistem de operare scris aproape în întregime în C a fost sistem Unix... În zilele noastre, aproape toate sistemele de operare utilizate sunt scrise în C. În plus, instrumente de programare care sistem de operare oferă dezvoltatorilor programe de aplicație(așa-numitele API - Application Program Interface), sunt seturi funcțiile sistemuluiîn limbajul C.

Cu toate acestea, domeniul de aplicare al limbajului C nu sa limitat la dezvoltarea sistemelor de operare. Limbajul C s-a dovedit a fi foarte convenabil în programele de procesare a textului și a imaginilor, în calculele științifice și de inginerie. Limbile orientate pe obiecte bazate pe C sunt excelente pentru programare în medii cu ferestre.

V aceasta sectiune vor fi date doar conceptele de bază ale limbajului C (și parțial C++). Acesta nu este un substitut pentru lectura tutorial completîn C sau C ++, de exemplu, cărți și.

Vom folosi compilatorul C++ în loc de compilatorul C. Faptul este că limbajul C este aproape în întregime inclus în C++, adică. un program C normal este un program C++ valid. Cuvântul „normal” înseamnă că nu conține nicio construcție proastă rămasă din versiuni timpurii C și nu este utilizat în prezent. Compilatorul C ++ este preferat în locul compilatorului C deoarece are un control mai strict al erorilor. În plus, unele constructe C++ care nu au legătură cu programarea orientată pe obiecte sunt foarte convenabile și, de fapt, sunt îmbunătățiri ale limbajului C. Acestea sunt, în primul rând, comentariile //, capacitatea de a descrie variabilele locale în orice punct al programului, nu doar la începutul unui bloc, și, de asemenea, setarea constantelor fără a utiliza operatorul #define preprocessor. Vom folosi aceste caracteristici ale C++, rămânând în esență în cadrul limbajului C.

Structura unui program C

Orice suficient program mareîn C (programatorii folosesc termenul proiect) constă din fișiere. Fișierele sunt compilate de compilatorul C independent unul de celălalt și apoi combinate de programul task builder, rezultând un fișier cu programul gata de execuție. Se apelează fișierele care conțin textele programului C iniţială.

În limbajul C fișiere sursă sunt de doua feluri:

• antet sau fișiere h;
• fișiere de implementare sau fișiere C.

Numele fișierelor antet au extensia „.h”. Numele fișierelor de implementare au extensiile „.c” pentru C și „.cpp”, „.cxx” sau „.cc” pentru C++.

Din păcate, spre deosebire de limbajul C, programatorii nu au reușit să cadă de acord expansiune unificată nume pentru fișierele care conțin programe C ++. Vom folosi extensia „.h” pentru fișierele antet și extensia „.cpp” pentru fișierele de implementare.

Fișiere antet conțin doar descrieri. În primul rând, acestea sunt prototipuri funcționale. Prototipul funcției descrie numele funcției, tipul de returnare, numărul și tipurile argumentelor sale. Textul funcției în sine nu este conținut în fișierul h. De asemenea, fișierele h descriu numele și tipurile de variabile externe, constante, tipuri noi, structuri etc. În general, fișierele h conțin numai interfețe, adică informații necesare pentru a utiliza programe deja scrise de alți programatori (sau de același programator anterior). Fișierele antet oferă doar informații despre alte programe. La traducerea fișierelor antet, de regulă, nu sunt create obiecte. De exemplu, în fișierul antet nu puteți defini o variabilă globală. Linia de descriere

definirea unei variabile întregi x este o eroare. Ar trebui folosită în schimb descrierea

ceea ce înseamnă că variabila x este definită undeva în fișierul de implementare (care este necunoscut). Numai cuvântul extern (extern). comunică informații despre o variabilă externă, dar nu definește acea variabilă.

Dosare de implementare, sau fișierele C, conțin texte de funcții și definiții ale variabilelor globale. În termeni simpli, fișierele C conțin programele în sine, iar fișierele h conțin doar informații despre programe.

Reprezentare textele sursă sub formă de fișiere antet și fișiere de implementare este necesar să se creeze proiecte mari având structura modulara... Fișierele antet sunt folosite pentru a transfera informații între module. Fișierele de implementare sunt module separate care sunt dezvoltate și difuzate independent unele de altele și sunt combinate pentru a crea un program executabil.

Fișierele de implementare pot include descrieri conținute în fișierele antet. Fișierele antet în sine pot folosi și alte fișiere antet. Fișier antet este inclus folosind directiva #include preprocesor. De exemplu, descrieri funcții standard I/O este activat folosind un șir

#include

(stdio - din cuvintele standard input / output). Numele fișierului h este scris între paranteze unghiulare, dacă acest h-