Sistemul de operare MS-DOS, folosit de microcomputerele compatibile IBMPC, realizeaz controlul func iilor ecranului pentru scroll (defilarea

imaginii) prin scroll_text" i pentru pozi ionarea cursorului prin cursor_text_to". Afisajul standard n modul text video 3" este de 80 de caractere pe linie, cu ecranul avnd 25 de linii i 16 culori. Se impune rezolvarea urm toarelor aplica ii: 1.1 S se scrie programul surs n limbajul C++ (fie Turbo C++, fie Microsoft C++) folosind func ia int86" pentru controlul deplas rii cursorului pe ecran (scroll i pozi ie) cu numerotarea i analiza fiec rei linii de program surs . 1.2. Pentru comunica ia serial folosind portul serial RS 232 ntre dou microcomputere IBM-PC conectate back-to-back", s se scrie programul surs n limbajul C++ folosind clasa RS port" i cele patru func ii BIOS i intreruperea 14 hexazecimal pentru controlul standard al porturilor seriale. Se va numerota i analiza n detaliu fiecare linie de program surs . 1.3. S se scrie programul surs n limbajul C++ pentru accesul direct la memoria video RAM ce stocheaz informa iile video ale IBM-PC. Se folose te afisajul standard n modul video 3" iar memoria RAM ncepe de la adresa B0O0:0000 (unde B000 este valoarea registrului segment iar 0000 este valoarea offset). Se vor numerota i analiza n detaliu toate liniile programului surs . 1.4. S se conceap programul surs n limbajul C++ (de preferin folosind Turbo C++ V7.00) de

acces i control direct al porturilor seriale pentru computerele IBM PC echipate cu circuitul de interfa Intel 8250 ACE (Asynchronous Communications Element), la care portul COM2: are adresa de baz 0x2F8, iar registrul liniei de control LineCtrl are offset 3 fa de baz , f cnd ca adresa portului de I/O s

fie 0x2FB (0x2F8 + 3). Se va analiza n detaliu fiecare linie a programului surs . 1.5. Pentru circuitul de interfa serial I 8250 ACE ce echipeaz microcomputerele compatibile folosind Turbo C++ V7.00) de control

IBM - PC, s se scrie programul sursa n limbajul C++ (de preferin

prin ntreruperi, pe baza program rii circuitului folosit curent la controlul ntreruperilor I 8259 PIC (Programmable Interrupt Controller). Se vor folosi nivelele de ntrerupere 4 i 3 (vectorii 12 respectiv 11) iar permisia ntreruperilor se va face prin setarea bitului 0 al registrului de permisie a ntreruperilor IntEna al I 8250 ACE. Se va analiza n detaliu fiecare linie a programului surs .

Problema 1 1. // func iile MS-DOS pentru controlul deplas rii cursorului pe ecran (scroll i pozi ionare) // 2. #include <dos.h> // fi ierul header specific MS-DOS 3. #include <iostream.h> // fi ierul header I/O standard 4. int main(void) 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. 41. 42.

void scroll_text(int, int, int, int, int, int, int); // prototipurile func iilor void cursor_text_io(const int x_coiumn, const int y_row); scroii_text(1,0,0, 79, 25, 0, 0x20); // cur ecranul i l face verde scroll_text(1, 20, 5, 59,18, 0, 0x10); // face scroll ntr-un ecran albastru cursor_text_to(39 ,12); // pozi ioneaz cursorul n mijlocul ecranului cout'x'; // afi eaz un caracter return 0; } // // //mut ecranul text n sus sau n jos setnd octetul attribute a a cum este specificat // // pentru up_down=0 face scroll n sus, 1 scroll n jos // // xjeft, y_top & x_right & y_bottom specific coordonatele ferestrei // // num rul liniilor cu care se face scroll // // attribute seteaz byte-u! atributelor compatibile IBM PC // void scroll_text(int up_down, int xjeft, int y_top, int x_right, int y_bottom, int lines, int attribute) { union REGS registers; // variabil pentru re inerea regi trilor 8086 registers.h.ah = (unsigned char) (6 + up_down); // scroll n sus 6, n jos 7 registers.h.ai = (unsigned char) lines; // face scroll ntregii ferestre registers.h.bh = (unsigned char) attribute; // octetul pentru atribute registers.h.cl = (unsigned char) xjeft; // coloana de nceput, coordonata x registers.h.ch = (unsigned char) y_top; // rndul de nceput, coordonata y registers.h.dl = (unsigned char) x_right; // coloana de final, coordonata x registers.h.dh = (unsigned char) y_bottom; // rndul de final, coordonata y int86(Qx10, Sregisters, registers); //ntreruperea 10 Hexazecimal } // // // pozi ioneaz cursorul pentru text, col ul din stnga sus este coloana 0, rndul 0 // void cursor_text_to(const int x_column, const int y_row) { union REGS registers; // variabil pentru re inerea regi trilor 8086 registers.h.ah = 2; // comanda care seteaz pozi ia cursorului text registers.h.bh = 0; // seteaz pagina 0 registers.h.dl = (unsigned char) x_column; // coloan , pozi ia x registers.h.dh = (unsigned char) y_row; // rnd, pozi ia y int86(0x10, &registers, Sregisters); //ntreruperea 10 hexa }

Problema 2 1. // func iile MS-DOS pentru controlul portului serial al PC-lui // 2. #include <dos.h> // fi ierui header specific MS-DOS 3. #include <conio.h> // header-ul pentru accesul direct la consol folosind func iile MS-DOS l/O 4. #include <iostream.h> // fi ierul header l/O standard 5. #include "rsjib.h" // introduce propriul fi ier header 6. // // 7. // constructorul: ini ializeaz portul serial io_port (COM1: = 0, etc. //

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.

RS_port::RS_port(const int port) union REGS registers; // variabil pentru folosirea regi trilor 8086 io_port = port; // prime te num rul portului registers.h.ah = 0; // comand , ini ializare // seteaz rata de transfer la 9600, 8 bi i de date, nici unu! de paritate i 1 bit de stop registers.h.al = 0xe3; // rata de transfer setata la 9600 registers.x.dx = io_port; // la port int86(0x14, &registers, &registers); //ntreruperea 14 hexa } // -// // destructor, realizeaz oprirea oric rei activit i// RS_port::~RS_port(void) {/* n acest caz nu avem nevoie de nimic aici */} // // // returnarea st rii portului serial // // linia de stare byte-ul de sus (ah), starea modemului n byte-ul de jos (al) // int RS_port::status(void) { union REGS registers; // variabil pentru folosirea regi trilor 8086 registers.h.ah = 3; // comand , cite te starea registers.x.dx 0 port; // portului Int86(0x14, &registers, &registers); // ntreruperea 14 hexa return registers.x.ax; // returneaz starea } //. // // returneaz adev rat dac a fost primit un caracter de la portul serial// int RS_port::received(void) { int status = this->status(); // cite te starea if (status & OxeOO) // verific dac exist vreo eroare a. cout"\n\aread error on serial line" io_port i. ", status = " hex (status & OxeOO) dec endl; return (status & 0x100); // testeaz bitul DR al registrului de stare } //---------------------------------------------------------------------------------- // //transmiterea unui caracter pe portul serial// RS_port &RS_port::operator(const char character) // scrie pe port {

39. 40. 41. 42. 43. 44.

Problema 3 1. //accesarea direct a memoriei video RAM compatibil IBM PC, Turbo C++ // 2. typedef unsigned char far byte; // define te o loca ie a memoriei ca i un byte 3. byte *video_start = (byte *) OxBSOOOOGOL; // define te adresa de nceput a memoriei video RAM a PC 4. byte *video_text = (byte *) 0xB8000000L; // adresa pentru afi area unui caracter 5. int mainQ

6. 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. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53.

{ /. void clear_screen(int attribute); // prototipurile func iilor void position_text(const int x_column, const int y_row); void wrte_char(const char ch, const int attribute); void write_string(const char *string, const int attribute); clear_screen(0x20); // cur ecranul si l coloreaz n verde position_text(39, 12); // pozi ioneaz cursorul n mijlocul ecranului write_char('x', 0x17); // scrie caracterul 'x1 alb pe albastru position_text(33, 14); // i afi eaz un ir de caractere dedesubt write_string("hello John doe", 0x34); // ro u pe cian return 0; } // // // umple ecranul cu spa ii setnd octetul attribute la o valoare specific // void clear_screen(int attribute) { byte *video_mem = video_start; // ini ializarea pointerului spre memoria video RAM // terge 25 de linii de 80 de caractere (caracter plus byte-ul attribute) while (video_mem < video_start + 160 * 25) { *video_mem++ = "; // seteaz spa iul ca i caracter *video_mem++ = (byte) attribute; // seteaz byte-ul de atribute } } // // //scrie caracterul ch cu attributele lui la pozi ia curent a cursorului // void write_char(const char ch, const int attribute) { *video_text++ = ch; // scrie caracter *video_text++ = (byte) attribute; // seteaz byte-ul de atribute } //----------------------------------------------------------------------------------------------// // scrie irul de caractere cu attributele lui la pozi ia curent a cursorului // void write_string(const char *string, const int attribute) { while ('string !='\0') { *video_text++ = *string++; // scrie caracter *video_text++ = (byte) attribute; // seteaz byte-ul de atribute } } // // // pozi ioneaz textul pe ecran, col ul din stnga sus este coloana 0, rndul 0 // void position_text(const int x_column, const int y_row) { // seteaz adresa pentru unrm torul caracter // // fiecare caracter are 2 bytes (caracter plus atribute) // // i sunt 80 de caractere pe o linie (n direc ia y) //

54. 55.

video_text = video_start + y_row * 160 + x_column * 2; }

Problema 4 1. // cotrolui direct IBM/PC al circuitului 8250 // 2. #include <dos.b> // Turbo C++ fi ierul header specific MS-DOS 3. #inc!ude <conio.h> //Turbo C++header-ul pentru acces direct la consol 4. #include <iostream.h> // fi ierul header l/O standard 5. ffinclude "rsjib.h" // include fi ierul header propriu 6. //7. //define te adresele porturilor de baz a circuitului 8250 pentru porturile 0 la 3 al RS232 8. //(de la corn 1: la com4:) 9. static const short int rs_portsfJ = {0x3f8, 0x2f8, 0x3e8, 0x2e8 }; 10. // offseturile adreselor de baz ale registrelor circuitului 8250 11. enum {DataReg, IntEna, intldent, LineCtri, ModCtrl, LineStatus, ModStatus}; 12. // bi ii circuitului 8250 pentru starea liniei, starea modemului i regi trii de control al modemului 13. enum {DR = 0x100, THRE = 0x2000, CTS = 0x10, DTR = 0x1, RTS = 0x2}; 14. // // 15. // constructorul principal: ini ializeaz portul serial io_port (COM1: = 0, etc. // 16. RS_port::RS_port(const int port) 17. { 18. union REGS registers; // variabil pentru folosirea regi trilor 8086 19. io_port = port; // num rul portului 20. registers.h.ah = 0; // comand , ini ializare 21. // seteaz rata de transfer la 9600, 8 bi i de date, nici un bit de paritate i 1 bit de stop 22. registers.h.al = 0xe3; // rata de transfer 9600 23. registers.x.dx = io_port; // pentru port 24. int86(0x14, &registers, &registers); // ntreruperea 14 hexa 25. // seteaz bi ii DTR i RTS din registrul de control al modemului 26. outp(rs_ports[io_port] + ModCtrl, DTR + RTS); 27. } 28. //// 29. // destructorul, termin - realizeaz nchiderea oric rei aplica ii // 30. RS_port::~RS_port(void) 31. { 32. // seteaz to i bi ii pe 0 n registrul de control al modemului 33. outp(rs_ports[io_port] + ModCtrl, 0); 34. union REGS registers; // variabil pentru folosirea regi trilor 8086 35. 36. 37. 50. 51. // putch(character); // caracter ecou dac este nevoie registers.h.ah = 1; // comand , trimite un caracter registers.h.al = (unsigned char) character; // caracter 43. registers.x.dx = io_port; // la port int86(0x14, &registers, &registers);//ntreruperea 14 hexa if (registers.h.ah & 0x80) // se verific dac este vreo eroare

b.

cout "\nTransmit error on serial port" io_port

i. ", status" hex registers.h.ah dec endl; 52. 53. return *this; // returneaz referin a obiectului }

54. li- // 55. 56. 57. 59. // transmiterea unui ir de caractere pe portul serial // RS_port &RS_port::operator(const char *string) // scrie la port { while Cstring != '\0') // write until NULL found c. *this *string++; // use operator(char) above 59. return *this; // returneaz referin a

obiectului 60. 61. 62. 63. 64. 65. 66. d. 67. 68. 69. 70. 71. } //-------------------------------------------------------------- // // citirea unui carater de la portul serial// RS_port &RS_port::operator(char Scharacter) { union REGS registers; // variabil pentru folosirea regi trilor 8086 while (! this->received()) /* wait for character received */; registers.h.ah = 2; //comand , citire caracter registers.x.dx = io_port; // de la port int86(0x14, &registers, Sregisters); //ntreruperea 14 hexa character = char(registers.h.al); // returneaz caracter return *tnis; // returneaz referin a obiectului 72-}

73. 74. 75. 76.

// Header file rsjrb.h - PC serial line functions calling MS-DOS functions // class RS_port{ // declare a class to support RS232 serial ports on a PC int io_port; // number of serial port, COM1; = 0 public: e. RS_port(const int port = 0); // default constructor

77.

~RS_port(void);//destructor

f. g. h. i.

int status(void); // status of port int received(void); // character received ? RS_port &operator(const char character); // write char to port RS_port &operator(const char *string); // write char * to port

j. RS_port &operator(char &character); // read char from port 78. };

34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51.

} //-------------------------------------------------------------------------------------------- // // returneaz starea portului serial // // starea liniei n octetul superior (ah), starea modemului octetul inferior (al) // int RS_port::status(void) { int status = inp(rs_ports[io__port] + LneStatus); // cite te starea liniei // trece starea liniei n octetul superior i apoi cite te starea modemului status = (status 8) + inp(rs_portspo_port] + ModStatus); return status; // i returneaz valoarea } // -----------------------------------------------------------------------------------//

// func ie care returneaz true dac un caracter a fost primit de pe linia serial // int RS_port::received(void) { int status = this->status(); // preia starea if (status & 0xe00) // verifica dac exist vreo eroare cout"\n\aread error on serial line" io_port a. ", status =" nex (status & OxeOO) dec endl;

52. 53. 54. 55. 56. 57.

return (status & DR); // testeaz bitul DR n registrul de stare al liniei } //----------------------------------------------------------------------- // // func i pentru transmitera unui caracter la portul serial // RS_port &RS_port::operator(const char character) // scrie pe port {

58. b. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85. 86. 87. 88.

while (! ((this->status() & THRE) && (this->status() & CTS))) /* a teapt s se goleasc registrul de men inere a transmisiei i CTS */; // putch(eharacter); // caracter ecou dac este nevoie // transmite caracter

outp(rs_ports[io_port], character); return *this; }

// ntoarce referin a obiectului

//--------------------------------------------------------------------------------- // II func ie pentru transmiterea unui ir de caractere la portul serial // RS_port &RS_port::operator(const char *string) // scrie pe port { while (*string != '\0') *this *string++; return *this; } //--------------------------------------------------------------------------------- // // func ie pentru citirea unui caracter de la portul serial // RS_port &RS_port::operator(char &character) { while (! this->received()) I* a teapt primirea caracterului */; character = char(inp(rs_ports[io_portJ)); return *this; } // Fi ierul header rsjib.h - linia serial a PC-ului folosind func iile MS-DOS // class RS_port{ int io_port; public: RS_port(const int port = 0); // constructorul de baz ~RS_port(void); int status(void); // destructorul // starea portului // declararea unei clase pentru a suporta porturile seriaie pe un PC // cite te caracter // scrie pn este g sit valoarea NULL

// folose te operatorul(char) de dinainte

// ntoarce referin a obiectului

// ntoarce referin a obiectului

// num rul de porturi seriale, C0M1: = O

int received(void); // caracter primit ? RS_port &operator(const char character); // scrie caracter pe port

89. 90. 91.

RS_port &operator(const char *string); RS_port &operator(char &character); };

// scrie irul de caractere pe port // cite te caracter de pe port

Problema 5 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. // controlul prin ntreruperi a circuitului 8250 ACE // // Aceast program este realizat n Turbo C++ V3.00 // #include <dos.h> // fi ierul header specific MS-DOS #include <conio.h> // header-ul pentru acces direct la consol #include <iostream.h> // fi ierul header l/O standard #include "rs_lib3a.h" // include fi ierul header propriu // . //

// func ii statice - aceast versiune va putea folosi ntreruperile doar de la 2 porturi// . // este nevoie de func ii adi ionale pentru mai multe porturi, p_to_rs_interrupt2, etc. // RS_port *RS_port::p_to_rs_interruptO = 0; // pointer c tre obiectul RS_port RS_port *RS_port::p_to_rs_interrupt1 = 0; // pointer c tre obiectul RS_port //func ie care apeleaz agentul ntreruperilor necesar pentru obiect void interrupt far RS_port::call_rs_interruptO(...) // pentru Turbo C++ V3.00 { RS_port::p_to_rs_interruptO->rs_interrupt(); // apeleaz agentul pentru obiect } // func ie care apeleaz agentul ntreruperilor necesar pentru obiect void interrupt far RS_port::call_rs_interrupt1(...) // pentru Turbo C++ V3.00 { RS_port::p_to_rs_interrupt1->rs_interrupt(); // apeleaz agentul pentru obiect 21}

22. 23.

//-------------------------------------------------------------------------------------------- // // func ie pentru clasa RS_port pentru interfa a serial RS232 a circuitului 8250 //

24. 25. 28. 27. 28. 29.

// Receptorul este controlat printro ntrerupere cu un buffer de un singur caracter; trebuie // // extins bufferul cu o leg tur hardware RTS/CTS cnd ajunge la 70% // // PC-ul folose te 8259 PIC (programable interrupt controller) vezi manualele // // adresele portului l/O pentru 8259 PIC (Controller programabil al ntreruperilor) // enum {pic_ocw1 = 0x21, pic_ocw2 = 0x20}; // cuvintele 1 i 2 pentru opera ia de control // define te adresele de baz ale portului circuitului 8250 pentru porturile 0 la 3 ale RS232 (de la corni: la com4:) //

30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54.

const short int rs_basesQ = {0x3f8, 0x2f8, 0x3e8, 0x2e8 }; // registrul de offsets al circ. 8250 pentru adresele de baz // enum {DataReg, IntEna, Intident, LineCtrl, ModCtrl, LineStatus, ModStatus}; // bi ii pt. starea linie, starea modemului i registrul de control al modemului circ. 8250// enum {DR = 0x100, THRE = 0x2000, CTS = 0x10, DTR = 0x1, RTS = 0x2, OUT2 = 0x8}; // define te parametrii ntreruperilor de baz pentru portul serial, edita i a a cum se cere // corni: & com3: folosesc nivelul 4 de ntrerupere i com2: & com4: folosesc nivelul 3 // define te vectorul ntreruperilor, 8259 PIC 'interrupt enable' i 'end of interrupt' const short int rs_vect[] = {12,11,12,11},// vectorul de ntrerupere rs_inenable[j = {Oxef, 0xf7, Oxef, OxfT}, // int enabie rs_eoiQ = {0x64, 0x63, 0x64, 0x63}; // EOI //-------------------------------------------------------------------------------------------- // // constructorul de baz : ini ializeaz portul serial io_port {COM1: = 0, etc.) // RS_port::RS_port(const int'port) { union REGS registers; // variabil pt. folosirea regi trilor 8086 io_port = port; // noteaz nr. portului registers.h.ah = 0; // comand , ini ializare // seteaz rata de transfer la 9600, 8 bi i de date, nici unu! de paritate i 1 bit de stop registers.h.al = 0xe3; // rata de transfer 9600 registers.x.dx = io_port; // pt. port int86(0x14, &registers, &registers); // ntreruperea 14 hexa // seteaz vectorul agentului de ntreruperi i activeaz ntreruperile old_rs_interrupt = _dos_getvect(rs_vect[io_port]); // preia agentul curent if (p__to_rs_interaiptO == 0) // dac pointerul este deja folosit

55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68.

{ p_to_rs_interruptO = this; // pointer spre obiect _dos_setvect( rs_vect[io_port], call_rs interruptO); // seteaz agentul de ntreruperi } else // presupune ca altele sunt libere { p_to_rs_interrupt1 = this; // direc ionare spre obiect _dos_setvect{ rs_vect[io_port], call_rs_interrupt1); // seteaz agentul } rs_base = rs_bases[io_port]; // seteaz adresa de baz a portului outp(rs_base + IntEna, 1); // activeaz ntreruperea receptorului (bit 0) // activeaz nivelul de ntrerupere n 8259 PIC OCW1 (cuvntul 1 pt. controlul opera iilor) outp(pic_ocw1, inp(pic_ocw1) & rs_intenable[io_porfj); // OUT2 trebuie s fie setat n registrul de control al modemului pt. trimite ntrerupere spre 8259 PIC//

69. 70. 71. 72. 73. 74. 75. 76. 77. 78. 79. 80. 81. 82. 83. 84. 85.

outp(rs_base + ModCtrl, DTR + RTS + OUT2); // seteaz DTR, RTS i OUT2 } //II

// destructorul, termin - realizeaz nchiderea oric rei activit i care are loc // RS_port::~RS_port(void) { // ctear pointer to interrupt handler if (p_to_rs_interruptO == this) p_to_rs_nterruptO = 0; if (p_to_rs_interrupt1 = this) p_to_rs_interrupt1 = 0; // dezactiveaz nivelul de ntrerupere al 8259 PIC OCW1 (operation control word 1) outp(pic_ocw1, inp(pic_oew1) | ~rs_intenable[io_port]); outp(rs_base + IntEna, 0); // dezactiveaz toate ntreruperile seriale outp{rs_base + ModCtri, 0); // goie te registrul de control ai modemului _dos_setvect( rs_vect[io_port], oid_rs_interrupt); // reseteaz vechiul agent } //--------------------------------------------------------------------------------------------- // // Portul serial: agentul pt. ntreruperile receptorului pe portul serial io_port //

86. 87. 88. 89. 90. 91. 92. 93. 94. 95. 96. 97. 98. 99. 100. 101. 102. 103. 104. 105. 106. 107.

//cite te bufferul receptorului pt. a opri ntreruperea i pt. a trimite EOI (sfr itul ntreruperii) // // la 8259 OCW2 (operation contol word 2) pt. a recunoa te ntreruperea // void RS_port::rs_interrupt(void) { rs_stat_data = char(inp(rs_base + LineStatus)); // cite te starea liniei // dac caracterul este deja n buffer indic o eroare de rulare if (rs_data) rs_stat_data = char((rs_stat_data \ 0x2)}; rs_data = (char) inp(rs_base); // cite te caracterul // 8259 PIC sfr itul ntreruperii: bit EOI = 1, SL = 1, R = 0, L0-L2 = level outp(pic_ocw2, rs_eoi[io_port}); // trimite EOI la 8259 OCW2 } //----------------------------------------------------------------------- -// // func ie pt. returnarea st rii portului serial // // starea liniei n octetul superior (ah), starea modemului n octetul inferior (al) // int RS_port::status(void) { int status = inp(rs_base + LineStatus); // cite te starea liniei status = (status 8) + inp(rs_base + iViodStatus); // cite te starea modemului return status; // i returneaz valoarea } //-------------------------------------------------------------------------------// // func ie care returneaz true dac caracterul a fost primit de la linia serial RS_port::received(void) // 1Q8M

109. 110. 111. 112. 113. 114. 115. 116. 117.

{ if (rs_stat_data & Oxe) // exist eroare ?? cout "\n\aRead error on serial line, status =" (rs_stat_data & Oxe) endl; rs_stat_data = 0; // clear status return rs_data; // retum > 0 if character ready } //----------------------------------------------------------------------- // // func ie pt. trimiterea unui caracter pe portul serial //

118. 119. 120.

RS_port &RS_port::operator(const char character) // scrie pe port { whiie (I ((this->status() & THRE) && (this->status() & CTS))) 121 ./* a teapt golirea registrului de transmitere i CTS */; 122.// putch(character); // caracter ecou dac este nevoie

123.outp(rs_base, character); //transmite caracterul

124. 125. 126. 127. 128. 130.

return *this; // ntoarce referin a obeectului } //-//

// func ie pt. trimiterea unui ir de caractere pe portul serial // RS_port &RS_port::operator(const char *string) 12S.{ while (*string != '\0') // scrie pn se ntlne te NULL