| Both sides previous revisionPrevious revisionNext revision | Previous revision |
| en:examples:communication:rs232 [2010/02/08 13:07] – mikk.leini | en:examples:communication:rs232 [2020/07/20 09:00] (current) – external edit 127.0.0.1 |
|---|
| | <pagebreak> |
| ====== RS-232 ====== | ====== RS-232 ====== |
| |
| //Vajalikud teadmised: [HW] [[en:hardware:homelab:controller]], [AVR] [[en:avr:usart]], [LIB] [[en:software:homelab:library:usart]], [LIB] [[en:software:homelab:library:module:lcd_alphanumeric]]// | //Necessary knowledge: [HW] [[en:hardware:homelab:controller]], [AVR] [[en:avr:usart]], [LIB] [[en:software:homelab:library:usart]], [LIB] [[en:software:homelab:library:module:lcd_alphanumeric]]// |
| |
| ===== Teooria ===== | ===== Theory ===== |
| |
| [{{ :examples:communication:comm_rs232_cable.jpg?220|RS-232 kaabel. Vasakpoolne pistik on "isane", parempoolne "emane"}}] | [{{ :examples:communication:comm_rs232_cable.jpg?220|Cable RS-232. Left plug is „male” and the right one is „female” plug."}}] |
| |
| RS-232 on füüsilise andmesideliidese standard, mida kasutatakse binaarandmete edastamiseks. Standard on kasutusel peamiselt arvutite jadaportides, mida kutsutakse kõnekeeles ka "COM" portideks. Tänapäeval on RS-232 suures osas asendunud USB liidesega, kuid oma lihtsuse tõttu kasutatakse hobirakendustes RS-232 edukalt edasi, eriti veel siis, kui on olemas USB - RS-232 muundurid. RS-232 standard määrab ära pistikud, elektrilised parameetrid ja signaalide tähenduse, kuid mitte protokolli. | RS-232 is a standard of physical data interface, which is used for delivering binary data. The standard is used mainly in serial ports of computers, which are also called “COM” ports in everyday language. Nowadays is the RS-232 largely replaced by USB interface, but due to its simplicity it is still used very successfully in hobby applications, especially if there are USB – RS-232 converters. The RS-232 standard determines the plugs, electrical parameters and meanings of the signals but not the protocol. |
| |
| RS-232 liidest kasutatakse peamiselt koos __UART-nimelise__ ? riistvaralise andmesidemooduliga, millel on protokoll standardiseeritud, kuid mis jällegi ei määra ära pistikuid jms. Seega RS-232 ja UART täiendavad teineteist. Kuna UART on enamasti üks moodul mikrokontrolleris, millel on digitaalsed sisendid-väljundid, mis ei vasta RS-232 elektrilistele parameetritele, siis omavahel viiakse need kokku spetsiaalsete nivoomuunduritega. Üks tuntumaid RS-232 TTL/CMOS nivoomuundureid on näiteks MAX232. | The RS-232 interface is used mainly with UART hardware data transmission module which protocol is standardized, but it does not determine the plugs or other things. So the RS-232 enhances the UART. Since the UART is usually one module of periphery of the microcontroller, which digital input-output does not correspond to the electrical parameters of the RS-232, they are connected together with a special leveling-converter. One best known leveling-converters between RS-232 and TLL/CMOS is MAX232. |
| |
| UART on lahtitõlgituna "universaalne asünkroonne vastuvõtja/saatja" (inglise keeles //universal asynchronous receiver/transmitter//). USART on peaaegu sama __asi__? kui UART, kuid selle erinevusega, et andmeid edastatakse koos taktsignaaliga. UART-i võib nimetada ka jadaliideseks. Jadaliides on andmete ülekandmise mehhanism, kus iga bitt edastatakse ükshaaval. Näiteks selleks, et edastada 1 bait, edastatakse kindla ajaintervalliga 8 bitti. Ehk siis füüsiliselt toimub jadaliidese liinil, mis on 1 mikrokontrolleri viik, kindla ajavahemiku järel selle viigu pingeväärtuse muutus kõrgeks või madalaks. Jadaliidesega on üldjuhul ühendatud 2 seadet, millest üks edastab infot (viigu väärtust muutes) ja teine võtab seda vastu (viigu väärtust registreerides). Edastava viigu lühend on TX, vastuvõtval RX. Info liigub ühel liinil alati ühes suunas. Andmete teistpidi saatmiseks kasutatakse teist liini. Andmed võivad kahel liinil samaaegselt liikuda ehk tegu on täisdupleks-siiniga. | UART means universal asynchronous receiver/transmitter. USART is almost the same, with the difference that the data is sent with clock signal. The UART may be called also a serial interface. The serial interface is a data transferring mechanism, where each bit is transmitted one by one. For example, to transmit 1 bait, 8 bits are transmitted with certain interval. This means that on the serial interface line, which is one pin of the microcontroller, the value of voltage is changed after certain time, once low and then high. Usually there are two devices connected to the serial interface. One is transmitting the information (by changing the value of the pin) and the other is receiving it (by registering the value of the pin). Transmitting pin is TX, and receiving pin is RX. The info is moving always to one direction on one line. For sending data to the other direction an other line is used. If data is moved on two lines at the same time, it is called full duplex bus. |
| |
| [{{ :examples:communication:comm_uart_frame.png?319|UART kaader, kus S on startbitt, 0-7 andmebitid, P paarsuse bitt (olemasolul) ja T stoppbitt (või 2)}}] | [{{ :examples:communication:comm_uart_frame.png?319|the frame of UART, where S is start-bit , 0-7 are data-bits, P is parity-bit (if existing) and T is stop-bit (or 2).}}] |
| |
| Andmete edastamine toimub UART liideses kaadri (inglise keeles //frame//) kaupa, milles on andmebitte olenevalt seadistusest 5 kuni 9. Enamlevinud andmehulk on siiski 8 bitti, ehk 1 bait. Peale andmebittide edastatakse kaadriga ka lisabitte, mille abil toimub andmete saabumise ja lõppemise hetke äratundmine vastuvõtja poolel. Esimest neist nimetatakse startbitiks, mis on alati 0, teist aga stoppbitiks (või bittideks), mis on alati 1. Enne stoppbitti võib tulla ka paarsuse bitt, mida kasutakse andmete korrektsuse kontrolliks. Paarsuse bitt näitab, kas andmebittide hulgas on paaris või paaritu arv ühtesid. See, kumba näitu see omab, sõltub UART liidese häälestusest. Paaruse bitti tänapäeval enam üldjuhul ei kasutata ja selle saab häälestuses ka ära keelata. Nii nagu saab paarsuse bitti seadistada, saab ka andmebittide ja stoppbittide arvu. | Transmitting data is done by frames of the UART interface, in which is 5-9 data bits (depending on the configuration). Most common is 8 bits (1 bait). In addition to the data bits also extra bits are transmitted with the frame, which are used to recognize the moments of arrival and ending of the data on the receiver’s side. The first is called start-bit and it is always 0. The second is called stop-bit (or bits), which is always 1. Before the stop-bit also parity bit may come. It is use to control regularity. The parity-bit shows whether in the amount of the data-bits is odd or even number of ones. Which reading it has depends on the configuration of the UART interface. The parity-bit is usually not used anymore and it can be banned in configuration. Like the parity-bit can be configured, also can the amount of data-bits and stop-bits. |
| | |
| | In addition to the frame structure, there is one more important parameter – it is //baud rate//, with which the number of transmitted symbols in one second is determined. Baud shows the number of symbols. When we are dealing with UART then 1 baud is 1 bit and that is why we talked about bits when we were talking about frame. Basically it does not matter which baud rate is used for data transmitting, but there is a certain amount of commonly used baud rates, which should be used. For example: 9600 bps, 19200bps, 38400 bps, 57600 bps, 115200 bps; |
| | |
| | Furthermore, it is worth to know that the RS-232 standard includes in addition to the data-signals (RX, TX) also data flow control pins DTR, DCD, DSR, RI, RTS and CTS, which are used for controlling the communication between the devices. For example they can be used to notify whether it is ready to receive data or not. Since the RS-232 interface’s original goal is to connect the computers to a modem, some signals are (were) useful rather for showing the state of the telephone lines. |
| |
| Peale kaadri struktuuri on veel üks tähtis parameeter - see on boodikiirus (//baud rate//), millega määratakse edastatavate sümbolite arv ühes sekundis. Bood näitab nimelt sümbolite arvu. UART puhul on 1 bood aga 1 bitt ja seepärast kaadri juures bittidest saigi räägitud. Põhimõtteliselt võib andmete edastamiseks kasutada ükskõik millist boodikiirust, kuid on olemas hulk üldkasutavaid boodikiirusi, mida tasub kasutada. Näiteks: 9600 bps, 19200 bps, 38400 bps, 57600 bps, 115200 bps. | ===== Practice ===== |
| |
| Lisainformatsioonina võiks teada, et RS-232 standard sisaldab peale andmesignaalide (RX, TX) veel vookontrolli viike DTR, DCD, DSR, RI, RTS ja CTS, mida kasutatakse seadmetevahelise suhtluse juhtimiseks. Näiteks võib seade nende kaudu teada anda, kas ta on valmis andmeid vastu võtma või mitte. Kuna RS-232 liidese originaalne eesmärk oli ühendada arvuteid modemiga, siis mõned signaalid on (pigem olid) kasutusel telefoniliini seisundi näitamiseks. | The Controller module board is equipped with one RS-232 type male plug. Through that can controller be connected to computer or to an other controller. For connecting to a computer a usual not inverted cable must be used, which one end is male and other one is female. For connection to an other controller a cable must be used where RX and TX and current control signals are perpendicularly inverted and both plugs are female. The inverted cable is also called zero modem cable. The following is an example program of using UART serial interface. When the program is started, it transmits a welcome through a RS-232 interface and displays messages, which are received. LCD and USART libraries are used. |
| | |
| ===== Praktika ===== | |
| | |
| Kodulabori kontrollerimoodulil on RS-232 isa-tüüpi pesa. Selle kaudu saab kontrolleri arvutiga või teise kontrolleriga ühendada. Arvutiga ühendamiseks tuleb kasutada tavalist pööramata kaablit, mille üks pistik on ema-tüüpi, teine isa-tüüpi. Teise kontrolleriga ühendamiseks tuleb kasutada kaablit, kus RX ja TX ning vookontrolli signaalid on risti keeratud ja mõlemad pistikud on ema-tüüpi. Pööratud kaablit nimetatakse ka nullmodemi kaabliks. Järgnevalt on toodud UART jadaliidese kasutamise näiteprogramm. Programm saadab käivitades RS-232 liidese kaudu tervituse ja kuvab sõnumeid, mis saabuvad. Kasutatud on LCD ja USART teeke. | |
| |
| <code c> | <code c> |
| // | // |
| // Kodulabori kontrollerimooduli arvutiga RS-232 kaudu liidestamine. | // Connecting the Controller module of the HomeLab to a computer through RS-232. |
| // Näide kasutab digitaalset sisend-väljundmoodulit koos LCD ekraaniga. | // The example is using digital input-output module with LCD. |
| // Arvuti terminalis sisestatud tekst kuvatakse LCD-l. | // The text inserted in the terminal of the computer is displayed on the LCD. |
| // | // |
| #include <homelab/usart.h> | #include <homelab/usart.h> |
| |
| // | // |
| // USART liidese määramine | // Determining USART interface. |
| // | // |
| usart port = USART(0); | usart port = USART(0); |
| |
| // | // |
| // Põhiprogramm | // Main program |
| // | // |
| int main(void) | int main(void) |
| unsigned char row = 1; | unsigned char row = 1; |
| |
| // USART liidese seadistamine | // The set-up of the USART interface. |
| usart_init_async(port, | usart_init_async(port, |
| USART_DATABITS_8, | USART_DATABITS_8, |
| USART_BAUDRATE_ASYNC(9600)); | USART_BAUDRATE_ASYNC(9600)); |
| |
| // LCD ekraani seadistamine | // The set-up of the LCD. |
| lcd_alpha_init(LCD_ALPHA_DISP_ON_BLINK); | lcd_alpha_init(LCD_ALPHA_DISP_ON_BLINK); |
| |
| // Ekraanil tervituse ütlemine | // Displaying welcome message on the screen. |
| lcd_alpha_puts("Ootan teadet"); | lcd_alpha_write_string("Waiting for the message"); |
| |
| // Kursori teise rea algusesse viimine | // Putting the cursor in the beginning of the second row. |
| lcd_alpha_gotoxy(0, row); | lcd_alpha_goto_xy(0, row); |
| |
| // Arvutile tere ütlemine | // Saying hello to the computer. |
| usart_send_text(port, "Tere, kirjuta midagi!\r\n"); | usart_send_string(port, "Hello, write something!\r\n"); |
| |
| // Lõputu tsükkel | // Endless loop |
| while (true) | while (true) |
| { | { |
| // Jadaliidesest märgi lugemine | // Reading the sign from the serial interface. |
| if (usart_try_read_char(port, &c)) | if (usart_try_read_char(port, &c)) |
| { | { |
| // Kas tegu on reavahetuse märgiga? | // Are we dealing with the sign of changing the row? |
| if (c == '\r') | if (c == '\r') |
| { | { |
| // Rea vahetamine | // Changing the row. |
| row = 1 - row; | row = 1 - row; |
| |
| // Rea tühjendamine eelmisest teatest | // Emptying the row from the previous message. |
| lcd_alpha_clr_line(row); | lcd_alpha_clear_line(row); |
| } | } |
| else | else |
| { | { |
| // Märgi otse ekraanile väljastamine | // Issuing the sign directly to the screen. |
| lcd_alpha_putc(c); | lcd_alpha_write_char(c); |
| } | } |
| } | } |
| </code> | </code> |
| |
| | [{{ :examples:communication:comm_hyperterminal.png?250|The window of the HyperTerminal}}] |
| | |
| | With Windows XP OS comes a program called HyperTerminal. It is opened from the //Start// menu by selecting //Accessories// →// Communications// → //HyperTerminal//. Select 9600 bps, 1 start-bit and 1 stop-bit without parity- and stream-control for configuration. When the HyperTerminal is opened during the time when the microcontroller is starting, there will be a welcoming message on the display. The letters inserted through the window are displayed in the alphanumerical LCD. By pressing //Enter// button the row is changed on the LCD. |
