Erinevused

Siin näed erinevusi valitud versiooni ja hetkel kehtiva lehekülje vahel.

Lõlita võrdlemise vaatele

Both sides previous revision Previous revision
Next revision
Previous revision
et:book [2010/02/19 13:36]
127.0.0.1 external edit
et:book [2018/12/27 12:53] (Hetkel kehtiv)
Rida 1: Rida 1:
-====== Eessõna ======+/​home/​www/​roboticlab/​homelab_data/​pages/​en/​start|Introduction.txt--- 
 + ​MISSING PAGE --- 
 +/​home/​www/​roboticlab/​homelab_data/​pages/​en/​preface|Preface.txt--- 
 + ​MISSING PAGE --- 
 +===== Guidelines ​=====
  
-Raamat, mida käes hoiad, on esimene praktiline mikrokontrolleri ja robootika käsiraamat eesti keeles, mis autorite lootuste kohaselt aitab robootikahuvilistel oma teadmisi laiendada ja paremaid lahendusi ehitada ning meelitab uusi huvilisi inseneriteadustega tegelemaTegemist on just Eesti vajadustest ja situatsioonist lähtuva praktilise abimehega, mida saab kasutada nii koolis, ülikoolis, hobirobootikas kui ka ettevõtetes praktiliste AVR mikrokontrolleritel põhinevate süsteemide õppimisel ja arendamiselKäsiraamat on suunatud nii õpetajale kui ka õpilasele, aidates mõlemal kiiremini ja tulemuslikumalt soovitud tulemuseni jõuda: õpilastel siis targemaks saada ja õpetajatel oma õppeaine lihtsamalt ja paremini õpilasteni viia :)+This guideline demonstrates how to use this site and Robotic HomeLab kit..
  
-**Platvorm**+This site is dedicated to the Practical Robotics and Microcontroller theory and practice including practical toolkit: Robotic HomeLab.
  
-Praktiliste harjutuste konkreetsuse huvides on baasplatvormiks valitud ATmega128 mikrokontrolleril põhinev Mehhatroonika ja Robootika Kodulabori komplektmis on paljudes Eesti koolides juba kasutuselAVR on PIC-i kõrval üks kõige levinumatest mikrokontrolleritest harrastuselektroonikute seas ja see on õppeotstarbeks igati sobilik.+When using Robotic HomeLab kitsfirst owner should [[http://​home.roboticlab.eu/​en/​start?​do=register|register]] himself in this site and claim supervisor rights.
  
 +The site has several sections (menu on the left) which are intended to use directly on the teaching process.
 +Following schematics describes which section (top division) is applied in sequence when introducing new topics to students.
  
-Raamat jaguneb tinglikult viieks osaks:+{{:method:​noe_kasutamine.png?​600|}}
  
-**1.** osa teeb kiire sissejuhatuse algajale või meeldetuletuse kogenud elektroonikule lihtsatest, kuid hädavajalikest elektriskeemi arvutusvalemitest. Need valemid ja nende rakendamisoskus tulevad kasuks mitmete praktiliste harjutuste läbimisel. Kiirtutvustus on ka C-keele kohta, mis annab näidete varal ülevaate keele süntaksist.+Additional material can be found in following links:
  
-**2.** osa annab ülevaate 8-bitilistest AVR seeria mikrokontrolleritest ATmega128 näitelPeatükk seletab eesti keeles lahti AVR-i andmelehtedes kirjutatu ja on abiks praktiliste harjutuste läbimiselAlgaja võib AVR-i tutvustuse esialgu vahele jätta ja pöörduda selle poole harjutuste käigus, sest tutvustus eeldab üldteadmisi,​ mida annavad harjutuste teoreetilised peatükid.+Robotic HomeLab II 
 +  ​"​Learning situations in an embedded system"​ Robolabor.ee Publisher 2013 [[http://​www.digar.ee/​arhiiv/​en/​nlib-digar:​270428|Access here]] 
 +  * [[et:​learningobjects|Videos and learning objects]] (content in Estonian language) ​
  
-**3.** osa kirjeldab praktiliste tööde aluseks olevat riistvara- ja tarkvaraplatvormiViimase juurde kuulub harjutuste jaoks loodud tarkvarateek,​ mis teeb levinuima mikrokontrolleri funktsionaalsuse kasutamise lihtsaks ja mugavaksVäheneb nnraua programmeerimise maht ja rohkem saab tähelepanu pöörata seadme toimeloogikaleTarkvarakeskkondadest on toetatud nii Windowsi kui ka Linuxi operatsioonisüsteemid.+Robotic HomeLab owner has month free access to DistanceLab environment [[http://​distance.roboticlab.eu/​device/​device_show/​28|Robotic HomeLab II testbed]]Claim your permissions from lab ownerSee [[https://​www.youtube.com/​watch?​v=sU5aBKzF_3g|video]] how it works.
  
-**4.** osas on praktilised harjutused, mis on konkreetsed näited enam levinud elektroonika- ja elektromehaanikaseadmete kasutamiseks AVR mikrokontrolleriga. Kõik harjutusülesanded on üles ehitatud ja teema järgi grupeeritud nii, et neid oleks õppimisel võimalikult mugav kasutada. Igal harjutuse peatükil on eraldi seadet ja selle tööpõhimõtet selgitav teooriaosa ning praktiline osa, mis õpetab seadet programmi kaudu juhtimaHarjutuste paremaks mõistmiseks on toodud ka lühinimekiri raamatu teistest seotud peatükkidestHarjutuste gruppide juurde kuuluvad harjutusülesanded,​ mida õpetaja saab kasutada täiendava harjutamise eesmärgilHarjutusülesanded on jaotatud kahte raskusastmesseIga teema sisaldab ka kordamisküsimusi,​ mis enamasti sunnivad antud teema kohta rohkem infot otsima.+See more about: 
 +  ​[[en:​kit:​conception]] 
 +  ​[[en:​files]] 
 +  ​Scientific papers: [[https://​www.researchgate.net/​publication/​228754249_Comprehensive_Blended_Learning_Concept_for_teaching_Micro_Controller_technology|Comprehensive Blended Learning Concept for teaching Micro Controller technology]] and [[https://​www.researchgate.net/​publication/​236156469_Microcontroller_based_intelligent_platform_for_research_and_education_in_mechatronics|Microcontroller based intelligent platform for research and education in mechatronics]].
  
-**5.** peatükk on samuti hea õppimise abiline, eriti projektitöö puhul. Peatükk näitlikustab,​ kuidas esitada projektitööna valminud lahendust ja selle dokumentatsiooni. Toodud on soovitatavad dokumentatsiooni punktid koos osalise näitelahendusega. 
  
-Loodame, et raamat on abimeheks nii noorele kui ka vanale robootika- ja mikrokontrollerite huvilisele ning toob mehhatroonika,​ kui suure perspektiiviga tulevikuala juurde uusi huvilisi. 
  
-Lumine ja pakasene Tallinn, jaanuar 2010+===== Authors =====
  
-Raivo Sell +The most content of this page is created by the developers of Robotic HomeLab solution. Copyright: ​Raivo Sell and Mikk Leini if not noted otherwise.
-====== Mikrokontrollerid ja robootika ======+
  
-=== Mikrokontrollerid ===+**RAIVO SELL** 
 +Tallinn University of Technology, senior researcher, Ph.D. Department of Mechatronics 
 +raivo.sell@ttu.ee
  
-[{{  :​images:​general:​intel_p8048h.jpg?​250|Maailma esimene mikrokontroller Intel 8048}}]+**MIKK LEINI** 
 +TUT Robotics Club NPO, member of the board
  
-Mikrokontroller on arvuti, mahutatuna ühe kiibi peale (inglise keeles //​computer-on-a-chip//​). Tegu on integraalskeemiga,​ mis sisaldab nii mälu, protsessorit kui ka sisend-väljundliideseid. Mikrokontroller programmeeritakse täitma mingit kindlat ülesannet nii, et kui funktsionaalsust tahetakse muuta või täiendada, siis tuleb kiibile uus programm ​ peale laadida. Mikrokontrollerid erinevad tavaarvutist (lauaarvuti,​ sülearvuti,​ server) mitmete aspektide poolest:+==== Other authors ====
  
-  ​Kõik funktsioonid on paigutatud ühe kiibi peale väiksemas ja kompaktsemas mahus. +**SVEN SEILER*
-  ​Programmeeritakse kindla ülesande täitmiseks. Funktsionaalsuse muutmiseks tuleb uus tarkvara peale laadida. +- AVR-CAN section
-  ​Väiksem voolutarve, kuna kõik füüsilised parameetrid on väiksemad ja vähem ressursinõudlikumad kui tavaarvutis. Mikrokontrolleri arendajad rõhuvadki tihti madalale voolutarbele,​ et mobiilsed lahendused suudaksid kauem aku pealt töötada. +
-  * Sihtotstarbelised sisendid ja väljundid. Mikrokontrolleritel on välja töötatud perifeeriad,​ et hõlbustada suhtlemist teiste mikrokontrollerite ja arvutitega (näiteid suhtluskanalitest USB, CAN, UART), aru saada füüsilistest reaalse maailma protsessidest (näiteks lüliti lülitus, temperatuuri mõõtmine) ja ise mõjutada ümbritsevat keskkonda (näiteks mootori käitamine, alarmsignaali käivitamine).+
  
-Mikrokontrollereid leidub väga palju seadmetesmida inimesed igapäevaselt kasutavad, näiteks kodutehnika (mikrolaineahi,​ telekas), mänguasjad (Lego NXT, rääkivad nukud), sõiduvahendid (auto, tõstuk) jmsNende laialdane kasutus on olnud võimalik tänu selleleet oma programmeeritavuse ja laialdase funktsionaalsuse tõttu on seadmetele lihtne lisada uusi omadusi. ​+**PEETER SALONG** 
 +Stoneridge Electronicssoftware engineer. 
 +- Linux installation for KontrollerLabLDR theory
  
-=== Robootika ===+**ÜLLAR SOON** 
 +- Exercise solutions for beginners
  
-Robootika ​on ala, mis ühendab endas teadmisi ja tehnoloogiat robotite ehitamisest. Tehnoloogia kiire arengu tõttu on aga üha hägustumas mõiste robot kui inimest asendav automaat. Robotina ei saa võtta ainult humanoidrobotit,​ autotööstuse koosteliini robotkätt, lennuki autopilooti,​ närvivõrkudel põhinevat tehisintelligenti või lihtsat koristusrobotit,​ vaid juba ka arvutis jooksvat tarkvara, mis teeb inimese eest mingi töö ära (näiteks raporti koostamine). Roboteid luuakse teadupärast ju inimese asendadamiseks teatud ülesannete täitmisel. Selleks on mitmeid põhjuseid: töökeskkond on inimesele liiga ohtlik, tootmishinda tuleb alandada, et inimtööjõu eest ei peaks enam maksma, nüri ja üksluine töö põhjustab palju eksimusi inimese töös või uued juhtimissüsteemid on piisavalt keerulised ja ajakriitilised,​ et inimene tuleb asendada automaatse otsustajaga. ​+**TARMO KOPLE** 
 +- Linux repository and automated installation ​on Ubuntu
  
-~~PB~~+**RAIN ELLERMAA**
  
-=== Mikrokontrollerid robootikas ​===+**HEIKO PIKNER** 
 +===== Feedback =====
  
-Kuna robootika valdkond on väga lai, siis järgnevalt piiritleme seda kui hobirobootikat,​ kus süsteemid ei ole väga keerulised ning on võimetekohased ehitada ka üksiktegijalHobirobootikas on levinumad mikrokontrollerid järgmised:+Please provide feedback if you have used or tested Robotic HomeLab kit.
  
-   * Atmel AVR perekonna mikrokontrollerid (ATmega, ATtiny ja muud) +[[https://​spreadsheets.google.com/​viewform?​formkey=dFdFcFJtX2dpRUpRM3NQQjByZmFEN3c6MQ|Online survey]] 
-   * Microchip Technology PIC perekonna mikrokontrollerid (PIC16, PIC24 ja muud) +===== Frequently Asked Questions =====
-   * ARM tehnoloogial põhinevad mikrokontrollerid+
  
-Väga tihti on kolmandad osapooled loonud arendusplaadid ja -keskkonnad eelnevalt mainitud mikrokontrollerite baasil. Kuna neid on palju, siis tasub välja tuua vaid tuntumad: Arduino (AVR-i baasil), BASIC Stamp (PIC-i baasil) ja Lego NXT (ARM-i baasil). Raamatus lähemalt käsitletavad Kodulabori arendusvahendid on loodud AVR ATmega128 mikrokontrolleri baasil.+====== Microcontrollers and Robotics ======
  
-Kuna mikrokontrollereid ja nende baasil loodud arendusplaate on väga palju, siis tekib kindlasti küsimus, et kuidas see kõige sobivam leida. Laias laastus võib vaadeldavad omadused jagada nelja kategooriasse - hind, füüsilised parameetrid,​ arenduskeskkond ja kasutajatugi. Füüsilistest parameetritest tasub jälgida järgmisi:+===== Microcontrollers =====
  
-   * protsessori töösagedus – määrab kiibi töökiiruse +[{{  :​images:​general:​intel_p8048h.jpg?​250|First microcontroller in the world: Intel 8048}}]
-   * programmimälu maht – kui suure mahuga programmi on võimalik kiibile peale laadida +
-   * andmemälu maht – kui suures mahus andmeid on võimalik käsitleda programmis +
-   * sisend-väljundviikude arv ja nende funktsioon – erinevatel väljaviikudel on erinevad võimalused +
-   * taimerite arv – oluline ajakriteeriumite täitmisel +
-   * voolutarve – oluline mobiilsetes lahendustes+
  
-Arenduskeskkonna ​all mõeldakse ​PC arvuti tarkvaramille abil saab kirjutada ja kompileerida programmilaadida programm mikrokontrollerisse ning siluda programmi töö käiguset avastada võimalikke viguSiinkohal saabki määravaks seekui mugav ja lihtne ​on kõiki neid toiminguid tehakuna programmi väljatöötamise käigus ​on see põhiline töökeskkondSiit jõuab ka neljanda kategooria ​kasutajatoe - juurdeehk kui lihtne ​on saada abi ja toetust võimalike ettetulevate probleemide lahendamiseksKõiki neid nelja eespool mainitud kategooriat vaagides peakski sobiva arendusplaadi leidma+A microcontroller is basically a computer which is placed on a single integrated circuit chip. It consists of memory, a processor, as well as input-output interfaces. Microcontrollers are programmed to run a certain task, which means, if there is a need to change or enhance its functionality,​ one must install a new program on the chip. Features that differentiate microcontrollers from other computers (PC, laptop, server, etc.) are: 
-====== ​Elektroonika ​======+ 
 +  * All functions are placed on a single chip in a smaller and more compact scale. 
 +  * It is programmed to perform a certain task; in order to change its functionality new  software must be installed. 
 +  * It consumes less power because ​all physical characteristics are smaller and less energy demanding than in a PC, laptop or server. Developers of microcontrollers concentrate on low energy demand so that mobile applications that use batteries can work longer. 
 +  * Single purpose inputs and outputs. Microcontrollers have so called peripheralswhich establish connections between a microcontroller and other microcontrollers or computers (e.g. USB, CAN, UART)help to understand the processes in the real physical world (e.g. switching actionstemperature measuring, etc. ) and help control conditions (e.g. control motor, trigger alert, etc.)   
 + 
 +Microcontrollers can be found in a variety of everyday items: household appliances (e.g. microwave ovens, TV-sets), toys (Lego NXT, talking dolls), vehicles (cars, hoists), etc. Microcontrollers’ wide usage has been possible because they are easy to program and have a wide range of functionalities;​ hence, it is very easy to add new features and upgrade the level of intelligence of the appliance they are in. 
 + 
 +===== Robotics ===== 
 + 
 +Robotics is a science that combines the technology and knowledge necessary to build robots. Due to the fast development of technology, the term robot, as an automatic machine that replaces humans, is not so clearly defined anymore. A robot is no longer just a humanoid robot, robotic hand at an auto assembly line, autopilot in aircraft, artificial intelligence built of living neurons or simple cleaning robot; it is also computer software that completes tasks meant for humans (for example, compiles reports). It is known that robots are built to replace humans at certain tasks. There are many reasons for this: dangerous working conditions, cheaper production, monotonous work may cause humans to err, new systems are so complex and time-critical,​ that automatic systems can make better decisions than humans. ​         
 + 
 +===== Microcontrollers in Robotics ===== 
 + 
 +Because of the breadth of robotics, we define it as hobby robotics; these systems are not too complex, and it is possible to build them by oneself. Common microcontrollers in hobby robotics are: 
 + 
 +  * Atmel AVR microcontrollers (ATmega, ATtiny, etc.) 
 +  * Microchip Technology PIC microcontrollers (PIC16, PIC24, etc.) 
 +  * Microcontrollers based on ARM technology. 
 + 
 + 
 +Quite often third parties have created development boards and environments based on microcontrollers mentioned herein before. For example: Arduino (AVR)BASIC Stamp (PIC) and Lego NXT (ARM). The necessities for developing HomeLab that are described in this book are based on the AVR ATmega128 microcontroller. 
 +A question arises from the large amount of microcontrollers and development boards available: how to find the most appropriate?​ Generally we can classify the following four properties: ​pricephysical characteristics,​ development environment and customer support. Notable physical characteristics are:  
 + 
 +  * processor operating frequency ​ - determines chip operating speed 
 +  * program memory capacity – determines the size of the program that can be installed ​on the chip 
 +  * data memory capacity – how much data can be processed in the program 
 +  * number of input/​output pins and their function – different pins have different possibilities 
 +  * number of timers – important for application timing criteria 
 +  * energy consumption – important for mobile applications 
 +  
 + 
 +Here the development environment is PC software, which allows creating and compiling programs, uploading programs to the microcontrollers and bridging in the programs during running in order to detect possible faultsHow easy and comfortable it is to do all that becomes decisive because during the development phase of the program it will be the primary working area. All this leads to the fourth characteristic,​ which is customer support. It is important that receiving help and support for solving possible issues is made as easy as possible. By considering all four mentioned properties, it should be possible to find the development board needed  ​ 
 +====== ​Electronics ​======
  
 {{:​images:​book:​ohms_law.png?​580|}} {{:​images:​book:​ohms_law.png?​580|}}
  
-Praktilistes harjutustes on kirjeldatud elektriskeememis on niivõrd tüüpilised,​ et on järgnevates peatükkides eraldi välja toodud. Nende tundmine on oluline praktilistest harjutustest arusaamiseks ja läbimiseks. Kindlasti tulevad need kasuks ka paljudes huviliste isiklikes projektides. +Some electronic circuits in practical examples are so common that they are separately described in the following chapters. It's important to learn them as they simplify the understanding of the examplesand will most probably help in building your own circuits too.
-===== Ohmi seadus =====+
  
-Ohmi seadust kasutatakse elektrijuhile rakendatud pinge ja juhti läbiva voolutugevuse vahelise sõltuvuse iseloomustamiseks. Iseloomustav tegur on juhi takistus ehk juhi omadus elektrilaengute liikumist takistada. Ohmi seaduse sõnastas Georg Simon Ohm järgmiselt:​ voolutugevus juhis on võrdeline juhi otstele rakendatud pingega ja pöördvõrdeline juhi takistusega. Valemi kirjapilt:+===== Ohm's Law =====
  
-[{{  :​images:​electronics:​ohms_law:​resistor_circuit.png?​180|Voolujuhi takistusrakendatud pinge ja läbiv voolutugevus}}]+Ohm's law states that the current through a conductor between two points is directly proportional to the potential difference or voltage across the two points, and inversely proportional to the resistance between them, provided that the temperature remains constant. 
 + 
 +The equation is as follows: 
 +[{{  :​images:​electronics:​ohms_law:​resistor_circuit.png?​180|Resistance of the conductorapplied voltage and current through the resistance}}]
  
 I = U / R I = U / R
  
-kus:+where:
  
-  * I on voolutugevus +  * I is current 
-  * U on pinge +  * U is voltage 
-  * R on takistus+  * R is resistance
  
-Ohmi seadusest on tuletatud mitmeid teisi valemeid, mida elektroonikas igapäevaselt kasutatakse. 
-===== Pingejagur ===== 
  
-Pingejagur on elektriahel,​ mille väljundpinge moodustab osa sisendpingestVäljundpinge suurus sõltub elektriahela moodustavate takistite takistuse suhtest. Kõrvaloleval skeemil on toodud kahe takistiga pingejaguri elektriskeem. Skeemi väljundpinge on arvutatav järgmise valemiga:+Several other equations that are used often in electronics are derived from Ohm's law. 
 +===== LED Resistor Calculation =====
  
-[{{  :images:​electronics:​voltage_divider:​voltage_divider_schematics.png?​180|Pingejaguri elektriskeem}}]+If the supply voltage is higher than the LED's voltage, the resistor has to be included in the circuit in series. ​ The resistor limits the current and produces the required voltage drop. To find the correct value for the resistor, the following equation is derived from Ohm's law:
  
-U<​sub>​2</​sub>​ = U<​sub>​1</​sub>​ ⋅ (R<​sub>​2</​sub>​ / (R<​sub>​1</​sub>​ + R<​sub>​2</​sub>​))+[{{  :​images:​electronics:​led_resistor:​led_resistor_schematics.png?​180|LED with series resistor}}]
  
-kus:+R = (Uin - Uf) / If\\ 
 +Ur = Uin - Uf\\ 
 +Pr = Ur ⋅ If\\
  
-  * U<​sub>​1</​sub>​ on sisendpinge +where:
-  * U<​sub>​2</​sub>​ on väljundpinge +
-  * R<​sub>​1</​sub>​ ja R<​sub>​2</​sub>​ on takistid+
  
-Valem tuleneb Ohmi seadusest, mille järgi:+  * R is resistance. 
 +  * Uin is supply voltage. 
 +  * Uf is LED voltage. 
 +  * If is LED current. 
 +  * Ur is voltage drop on the resistor. 
 +  * Pr is power of the resistor that is transformed into heat.
  
-I = U<​sub>​1</​sub>​ / (R<​sub>​1</​sub>​ + R<​sub>​2</​sub>​)+The current limiting resistor of an LED has to be not smaller than R, and at least with the power of Pr. 
 +===== Voltage Divider =====
  
-ning:+A voltage divider is an electrical circuit which divides the input voltage. The output voltage is a portion of the input voltage and the value of the output is dependent on the resistor ratio in the circuit. The schematics on the right includes two resistors.
  
-U<​sub>​2</​sub>​ = I ⋅ R<​sub>​2</​sub>​+The output of the circuit is calculated by the following equation:
  
-Pingejagurit kasutatakse tihti takistuslike andurite ühendamisel,​ kus üks takistitest asendatakse takistusliku anduriga (näiteks termistor). +[{{  :​images:​electronics:​voltage_divider:​voltage_divider_schematics.png?​180|Electrical schematics of the voltage divider}}]
-===== LED-i takisti arvutamine =====+
  
-Kui LED-i (valgusdioodion vaja toita kõrgema pingega, kui on selle päripinge, ja väiksema vooluga, kui toiteallikas välja annab, tuleb LED-iga järjestikku lisada takisti. Takisti piirab voolu ja tekitab vajaliku pingelangu. Õige takisti väärtuse leidmiseks saab kasutada Ohmi seadust:+U2 = U1 ⋅ (R2 / (R1 + R2))
  
-[{{  ​:images:​electronics:​led_resistor:​led_resistor_schematics.png?​180|LED järjestikku takistiga}}]+where:
  
-R = U<​sub>​r</​sub>​ / I<​sub>​f</​sub>​ = (U<​sub>​in</​sub>​ - U<​sub>​f</​sub>​) / I<​sub>​f</​sub>​\\+  * U1 is input voltage 
 +  * U2 is output voltage 
 +  * R1 and R2 are resistors
  
-kus:+The equation is derived from Ohm's law 
  
-  * R on takisti takistus. +where:
-  * U<​sub>​r</​sub>​ on pingelang takistil. +
-  * U<​sub>​in</​sub>​ on toitepinge. +
-  * U<​sub>​f</​sub>​ on LED-i päripinge. +
-  * I<​sub>​f</​sub>​ on LED-i voolutugevus. +
-\\ +
-Kuna takisti valimisel tuleb lähtuda ka selle soojuse eraldamise võimest, siis tuleb leida ka nõutav elektriline võimsus takistil:+
  
-P<​sub>​r</​sub> ​U<​sub>​r<​/sub> ⋅ I<​sub>​f</​sub>​ = (U<​sub>​in</​sub>​ - U<​sub>​f</​sub>​⋅ I<​sub>​f</​sub>​\\+U1 / (R1 + R2)
  
-Kokkuvõtvalt saab öelda, et LED-i voolu piirav takisti peab olema vähemalt sama suure takistusega,​ kui R ja vähemalt sama suure võimsusega,​ kui P<​sub>​r</​sub>​.+and:
  
-**Arvutusnäide:​**+U2 = I ⋅ R2
  
-LED ühendatakse 12 V pingegaValitud LED-i päripinge on 3 V ja pärivool 20 mA+A voltage divider is very often used together with resistive sensors (photo resistor, thermistor etc.) where one of the resistors is replaced by the resistive sensor. In this way, the change of the resistance of the sensor is easily transformed to the voltage change, which is compatible with the microcontroller'​s analogous input. 
 +====== Software development ====== 
 +{{:​images:​book:​c_code.png?​500|}}
  
-I<​sub>​f</​sub> ​20 mA 0,02 A+The most popular PC programming language C is widely used also in programming microcontrollers. C is relatively straightforward to provide language constructs that map efficiently to machine instructions. In C-language, there are minimal number of keywords but it includes many characters with different meanings that makes learning more difficult. Correct way to develop software is to model it first. For modelling purpose simple algorithms can be created. Easiest way to represent an algorithm is to use flowchart graphical representation. The next chapter gives a short overview of drawing flowcharts as a model of program and C-language syntax which is also used in practical examples. The beginners are recommended to read additional guides.  
 +===== Algorithms and flowchart=====
  
-R = (12 3) / 0,02 = 450 Ω+The algorithm is a step-by-step instruction,​ guideline or rule to perform some action or reach the solution for given problem. Flowchart is one of the way to represent algorithm graphically,​ where graphical elements like boxes, squares, circlesand arrows connecting them represent flow of control. Every element can represent on step in the instructions.  
 +   
 +Simplified flowchart elements:
  
-P<​sub>​r</​sub> ​(12 - 3) ⋅ 0,02 0,18 W+=== Start ===
  
-Lähim standardne takistus on 470 Ω ja võimsus 1/4 W, nii et sellise takisti valimegi. +Circle.
-====== C-keel ======+
  
-{{:images:book:c_code.png?500|}}+{{:​method:​algorithms:​algus.png|}} 
 + 
 +=== End === 
 + 
 +Filled circle inside bigger circle. 
 + 
 +{{:​method:​algorithms:​lopp.png|}} 
 + 
 +=== Action or expression === 
 + 
 +Rectangle. Inside rectangle a name of the action, name of the sub-routine or short description can be written. Similar actions can be included into one general action. 
 + 
 +{{:​images:​programming:​algorithm_action.png|}} 
 + 
 + 
 +=== Sequence === 
 + 
 +Arrow, by pointing next activity. 
 + 
 +{{:​method:​algorithms:​nool.png|}} 
 +  
 +=== Condition / Decision === 
 + 
 +Diamond (rhombus). Inside diamond is a logical expression and in most cases two arrows are drawn out from diamond. One is when logical expression results True (Yes/1) and other when expression result is False (No/0). Always both arrows have to be labeled. In special case only one arrow can be used as output from diamond. The case is when logical expression can clearly result only one solution, e.g. True. This is the case where for example endless cycle is used in program code (e.g. //while (true)//).  
 + 
 +{{:​images:​programming:​algoritmid_if.png|}} 
 + 
 +<​pagebreak>​ 
 +=== Data exchange === 
 + 
 +Trapezoid. Inside trapezoid a name or activity is described. In robotics it is usually used to communicate with sensors and user. For simplification also normal rectangle action can be used instead of trapezoid. 
 + 
 +{{:​images:​programming:​data_exchange.png|}} 
 + 
 + === Examples === 
 + 
 +Drawing flowchart diagrams one can use common office suits like MS Word or MS Excel or OpenOffice/​LibreOffice Writer or Calc but better results can be get by using special programs like MS Vision, OpenOffice/​LibreOffice Draw, Google draw or some special diagram creating software. 
 + 
 +Flowcharts describing microcontroller software usually do not have ends, instead whole main activity in an endless cycle. The exit condition of the endless cycle will never be true and therefore this is the case where condition block (diamond) can be represented only on exiting arrow. Condition it self can be notes simply True or 1. Creating diagrams it is important to keep in eye on the fact that if the program has forks, it can be done only through the diamond object. Junctions (two arrows are joining) can be described by special symbol, but in simple cases, one may simply have an arrow point to another arrow instead. 
 + 
 +<​pagebreak>​ 
 +Following examples illustrate the use of flowchart elements for describing simple algorithm. First example is simple routine by describing one way flow without any cycle or decision points. 
 + 
 +{{:​images:​programming:​algorithm_example1.png|}} 
 +<​pagebreak>​ 
 +Following example describes a system which detects 1 m area and if an object entering into inspected area an alarm is triggered for a 10 seconds. Alarm is working until the object is left from the inspected area. 
 + 
 +{{:images:programming:algorithm_example2.png?550|}} 
 +===== C Crash course =====
  
-Kauaaegne populaarne PC arvutite programmeerimiskeel C on laialt levinud ka mikrokontrollerite programmeerimisel. C on lakooniline riistvaralähedane keel, mis võimaldab kirjutada riistvara võimalusi efektiivselt kasutavat programmikoodi. C-keele süntaksis on võtmesõnu minimaalselt,​ kuid sisaldab palju erineva tähendusega märke, mis teevad keele õppimise raskeks. Järgnev peatükk sisaldab lühiülevaadet C-keele süntaksi osadest, mis on kasutusel ka praktiliste näidete juures. Algajal on C-keele kohta soovitatav lugeda täiendavaid materjale. +==== Program structure ​====
-===== Kiirkursus =====+
  
-==== Programmi ülesehitus ====+As a principle, program written in C-language can be in any form, even in one line, because the compiler assumes only the following of syntax rules. However, it is advisable to take care of program coding style for clearness and simplicity. Typical structure of a C-language program:
  
-Põhimõtteliselt võib C-keele programmi kirjutada ükskõik mis kujul, kas või üherealisena,​ sest kompilaator eeldab vaid süntaksireeglite järgimist. Samas on selguse ja lihtsuse huvides ikkagi soovitatav tähelepanu pöörata ka programmikoodi stiilile. Tüüpiline C-keele programmi ülesehitus:​ 
  
-<code c> +/* Include header files */ 
-/* Päisefailide kaasamine ​*/ +#include  
-#​include ​<​avr/​io.h>​ +#​include ​
-#​include ​<​stdio.h>​+
  
-/* Makro-deklaratsioonid ​*/+/* Makro declarations ​*/
 #define PI 3.141 #define PI 3.141
  
-/* Andmetüübid ​*/+/* Data type definitions ​*/
 typedef struct typedef struct
 { {
Rida 168: Rida 260:
 element; element;
  
-/* Globaalsed muutujad ​*/+/* Global variables ​*/
 element e; element e;
  
-/* Funktsioonid ​*/+/* Functions ​*/
 int main(void) int main(void)
 {  {
- // Lokaalsed muutujad+ // Local variables
  int x;  int x;
  
- // Programm+ // Program code
  printf("​Tere maailm!\n"​);​  printf("​Tere maailm!\n"​);​
 } }
-</​code>​ 
  
-==== Kommentaarid ==== 
  
-Programmi saab kirjutada teksti, mida ei kompileerita ja mis on programmeerijale abiks selgitamisel või märkmete tegemisel. Samuti saab kommentaare kasutada programmilõikude ajutiseks täitmisest kõrvaldamiseks. Näide kahte liiki kommentaaridest:​+==== Comments ====
  
-<code c> +Programmer can write random text into program ​code for notes and explanations that is no compiled. Comments can also be used for temporally excluding some parts of code from compiling. Examples of two commenting methods: 
-// Üherealine kommentaar+ 
-// Kommentaariks loetakse kahe kaldkriipsu järel olevat teksti+ 
 +// Line comment is on one line
 +// Text after two slash signs is considered as comment.
  
 /* /*
-  Mitmerealine kommentaar + Block comment can be used to include more than one line. 
-  Kommentaari algus ja lõpp määratakse kaldkriipsude ja tärnidega+ The beginning and the end of a comment is assigned with slash and asterisk signs.
 */ */
-</​code>​ 
  
-~~PB~~ 
  
-==== Andmed ==== 
  
-=== Andmetüübid ​===+==== Data ====
  
-C-keele baasandmetüübid:​+=== Data types ===
  
-Tüüp ​            ^ Miinimum ​   ​Maksimum ​  Bitte Baite ^+C-language basic data types: 
 + 
 +Type             ^ Minimum ​    Maximum ​   ​Bits Bytes ^
 | (signed) char    | -128        | 127        | 8     | 1     | | (signed) char    | -128        | 127        | 8     | 1     |
 | unsigned char    | 0           | 255        | 8     | 1     | | unsigned char    | 0           | 255        | 8     | 1     |
Rida 211: Rida 302:
 | (signed) long    | -2147483648 | 2147483647 | 32    | 4     | | (signed) long    | -2147483648 | 2147483647 | 32    | 4     |
 | unsigned long    | 0           | 4294967295 | 32    | 4     | | unsigned long    | 0           | 4294967295 | 32    | 4     |
-| float            | -3.4<​sup>​38</​sup> ​ | 3.4<​sup>​38</​sup> ​ | 32    | 4     | +| float            | -3.438  | 3.438  | 32    | 4     | 
-| double ​          | -1.7<​sup>​308</​sup> ​| 1.7<​sup>​308</​sup> ​| 64    | 8     |+| double ​          | -1.7308 | 1.7308 | 64    | 8     |
  
-Sulgudes olevat sõna "​signed" ​ei pea kasutama, kuna vaikimisi ongi andmetüübid bipolaarsed.+The word "​signed" ​in brackets is not necessary to use because data types are bipolar by default.
  
-AVR mikrokontrolleril ​//int// = //short// \\ +AVR microcontroller has //int// = //short// \\ 
-PC arvutil ​//int// = //long// \\+PC has //int// = //long// \\
  
-C-keeles puudub spetsiaalne teksti-andmetüüpSelle asemel kasutatakse ​//​char// ​tüüpi massiive ​(nendest edaspidija ASCII "​tähestikku",​ kus igal tähel ja märgil on oma järjekorranumber.+There is no special string data type in C-languageInstead ​//​char// ​type arrays ​(will be covered laterand ASCII alphabet is used where every char has its own queue number.
  
-=== Muutujad ​===+=== Variables ​===
  
-Programmis saab kasutada kindlat andmetüüpi mälupesasid ​muutujaidMuutujate nimed võivad sisaldada ladina tähestiku tähtinumbreid ja alakriipsuNimi ei tohi alata numbrigaMuutuja deklareerimisel kirjutatakse selle ette andmetüüpVäärtuse omistamiseks muutujale kasutatakse võrdusmärki ​(=). Näide muutujate kasutamisest:+Program can use defined type of memory slots variablesVariable names can include latin aplhabet charactersnumbers and underdashesBeginning with a number is not allowedWhen declarations to variables are being made, data type is written in front of itValue is given to variable by using equal sign (=). Example about using variables:
  
-<code c> + 
-// char tüüpi muutuja ​deklareerimine+// char type variable ​declaration
 char c; char c;
  
-// Muutujale ​väärtuse omistamine.+// Value is given to variable ​c.
 c = 65; c = 65;
-c = '​A';​ // A on ASCII märgisüsteemis samuti väärtusega ​65+c = '​A';​ // A has in ASCII character map also value 65
  
-// int tüüpi muutuja ​i20 deklareerimine ja algväärtustamine+// int type variable ​i20 declaration and initialization
 int i20 = 55; int i20 = 55;
  
-// Mitme unsigned short tüüpi muutuja deklareerimine+// Declaration of several ​unsigned short type variables
 unsigned short x, y, test_variable;​ unsigned short x, y, test_variable;​
-</​code>​ 
  
-=== Konstandid === 
  
-Konstante deklareeritakse samamoodi nagu muutujaidkuid ette lisatakse ​//​const// ​võtmesõnaKonstantide väärtust ei saa programmi käigus muutaNäide kasutamisest:+=== Constants === 
 + 
 +Constants are declarated in the same way as variablesexept //​const// ​keyword is added in front of data typeConstants are not changeable during program workExample about using them: 
  
-<code c> +// int type constant declaration
-// int tüüpi konstandi määramine+
 const int x_factor = 100; const int x_factor = 100;
-</​code>​ 
  
-=== Struktuurid === 
  
-Baasandmetüüpidest saab //struct// võtmesõnaga struktuure koostada. Struktuur on justkui kombineeritud andmetüüp. Tüüpi deklareeritakse //typedef// võtmesõnaga. Näide struktuurist andmetüübi loomise ja kasutamise kohta:+=== Structures ===
  
-<code c> +Basic data types can be arranged into structures by using //struct// keyword. Structure is a combined data type. Type is declarated with //typedef// keyword. Example about structures by creating and using data type: 
-// Uue punkti andmetüübi deklareerimine+ 
 + 
 +// Declaration of a new data type "​point"​
 typedef struct typedef struct
 { {
- // x ja koordinaat ning värvikood+ // x and coordinates and color code
  int x, y;  int x, y;
  char color;  char color;
Rida 263: Rida 354:
 point; point;
  
-// Punkti muutuja deklareerimine+// declaration of a variable as data type of point
 point p; point p;
  
-// Punkti koordinaatide määramine+// Assigning values for point variable
 p.x = 3; p.x = 3;
 p.y = 14; p.y = 14;
-</​code>​ 
  
-=== Massiivid === 
  
-Andmetüüpidest võib koostada massiive (jadasid). Massiiv võib olla ka mitmemõõtmeline (tabel, kuup, jne). Näide ühe- ja kahemõõtmelise massiivi kasutamisest:​+=== Arrays ===
  
-<code c> +Data types can be arranged into arrays. Array can have more than one dimensions (table, cube etc). Example about using one- and two-dimensional arrays: 
-// Üheja kahemõõtmelise massiivi deklareerimine+ 
 + 
 +// Declaration of one- and two-dimensional arrays
 char text[3]; char text[3];
 int table[10][10];​ int table[10][10];​
  
-// Teksti moodustamine tähemassiivist +// Creating a string from char array 
-text[0] = '​H'; ​ // Täht +text[0] = '​H'; ​ // Char 
-text[1] = '​i'; ​ // Täht +text[1] = '​i'; ​ // Char 
-text[2] = 0;    // Teksti lõpetamise tunnus ​(null-bait)+text[2] = 0;    // Text terminator ​(0 B)
  
-// Tabeli ühe elemendi muutmine+// Assigning new value for one element.
 table[4][3] = 1; table[4][3] = 1;
-</​code>​ 
  
-~~PB~~ 
  
-==== Avaldised ====+<​pagebreak>​
  
-Muutujate, konstantide ja väärtust tagastavate funktsioonidega saab koostada avaldisi (tehteid). Avaldise väärtusi saab omistada muutujatele,​ neid saab kasutada funktsiooni parameetritena ja erinevates tingimuslausetes.+==== Operations ====
  
-=== Aritmeetilised ​===+Variables, constants and value returning functions can be used for composing operations. The result of and operation can be assigned to a variable, it can be used as a function parameter and in different control structures. 
 + 
 +=== Arithmetic operators ​=== 
 + 
 +C-language supported artithmetic operations are addition (+), subtraction (-), multiplication (*), division (/) and modulo (%). Some examples about using operators:
  
-C-keeles toetatud aritmeetilised tehted on liitmine (+), lahutamine (-), korrutamine (*), jagamine (/) ja mooduli võtmine (%). Näited aritmeetiliste tehete kasutamisest:​ 
  
-<code c> 
 int x, y; int x, y;
  
-// Mooduli võtminekorrutamine ja väärtuse omistamine +// Modulomultiplication and assigning value 
-// x saab väärtuse ​9+// x gets value of 9
 x = (13 % 5) * 3; x = (13 % 5) * 3;
  
-// Liitev-omistav operaator +// Adding-assigning operator 
-// x väärtuseks saab 14+// x gets value of 14
 x += 5; x += 5;
  
-// Ühe lahutamise kiirmeetod +// Quick style method for subtracting 1 
-// x väärtuseks saab 13+// x gets value of 13
 x--; x--;
-</​code>​ 
  
-=== Loogilised === 
  
-Loogilised tehted on eitus (!), loogiline korrutamine ​(&&​) ​ja loogiline liitmine ​(||). Näide tehete kasutamisest:+=== Logical operators === 
 + 
 +Logical operators are negation NOT (!), logic multiplication AND (&&​) ​and logic addition OR (||). Example about using them: 
  
-<code c> 
 bool a, b, c; bool a, b, c;
  
-// Algväärtustamine+// Initialization
 a = true; a = true;
 b = false; b = false;
  
-// Eitus +// Negation 
-// c väärtus tuleb väär sest tõest eitati+// c will get a value of false because a is true
 c = !a; c = !a;
  
-// Loogiline korrutamine +// Logic multiplication 
-// c väärtuseks tuleb väär, sest üks operandidest on väär+// c will get a value of false because one of the operators is false
 c = a && b; c = a && b;
  
-// Loogiline liitmine +// Logic addition 
-// c väärtus tuleb tõene, sest üks operandidest on tõene+// c will get a value of true because one of the operators is true
 c = a || b; c = a || b;
-</​code>​ 
  
-**NB!** //bool// andmetüüp C-keeles tegelikult puudub, selle asemel on kasutusel täisarvud, kus 0 tähistab väära ja iga muu arv tõest väärtust. Näiteks Kodulabori teegis on defineeritud //bool// kui //unsigned char//. Konstant //true// tähistab seal väärtust 1 ja //false// väärtust 0. 
  
-=== Võrdlused ===+**NB!** //bool// data type in C-language is actually missing and instead integers are used where 0 marks false and every other value marks true. For example, in HomeLab library //bool// is defined as //unsigned char//. Constant //true// marks a value of 1 and //false// a value of 0.
  
-Arvude väärtuste võrdlemisel saadakse loogilised väärtused. Võrdlustehted on samaväärsus (=), erinevus (!=), suurem (>), suurem-võrdne (>=), väiksem (<) ja väiksem-võrdne (<=). Näide kasutamisest:​ 
  
-<code c> +=== Relational and equality operators ===
-int x 10, y 1;+
  
-// Suurem-kui võrdlustehemis on tõene +Logical values are a result of comparison of variable values. Equality operators are equal to (==)not equal to (!=), greater than (>), greater than or equal to (>=), less than ( 15) && (y < 4);
-// Tehte ümber on sulud vaid selguse pärast +
-bool b = (> 4);+
  
-// Erinevuse tehe 
-// Tehte tulemus on väär 
-b = (4 != 4); 
  
-// Aritmeetiline,​ võrdlus ja loogiline tehe üheskoos +=== Bit operations ===
-// b tuleb väär, sest esimene loogilise korrutise operand on väär +
-(x + 4 > 15) && (y < 4); +
-</​code>​+
  
-=== Bititehted ===+Bit operations are for data manipulation in binary numeral system. These can be applied only to integer type data. Bit operations are quite similar to logic operations but differ from them because operation is carried out with every single bit not the whole number. Bit operations in C-language are inversion (~), conjunction (&), disjunction (|), antivalency (^), left shift ().
  
-Bititehted on andmetega binaarses arvusüsteemis tegelemiseks. Neid saab rakendada kõigi täisarv-tüüpi andmetega. Bititehted sarnanevad loogiliste tehetega, kuid erinevad selle poolest, et tehe teostatakse iga bitiga eraldi, mitte kogu arvuga. C keeles on bititeheteks inversioon (~), konjunktsioon (&), disjunktsioon (|), antivalentsus (^), nihe vasakule (<<) ja nihe paremale (>>). 
  
-<code c> +// Declaration of unsigned ​bit char type variable 
-// Märgita ​8-bitise ​char-tüüpi muutuja deklareerimine +// Variable value is in decimal system, 101 in binary system
-// Muutuja väärtus on kümnendsüsteemis ​5, kahendsüsteemis ​101+
 unsigned char c = 5; unsigned char c = 5;
  
-// Muutuja ​disjunktsioon arvuga ​2 (kahendsüsteemis ​010) +// Disjunction of with a digit 2 (010 in binary
-// c väätuseks saab 7 (kahendsüsteemis ​111)+// c value will become ​7 (111 in binary)
 c = c | 2; c = c | 2;
  
-// Bitinihe vasakule ​võrra +// Bit left shift by 
-// c väärtuseks saab 28 (kahendsüsteemis ​11100) +// c value will become ​28 (11100 ​in binary
-c = c << ​2; +c = c  2) x = 5;
-</​code>​+
  
-Bititehted on hädavajalikud mikrokontrollerite registrite kasutamisel. Täpsemalt tutvustab neid AVR registrite peatükk. +// If x equals 5 and y equals 3 then the following code will be executed 
- +if ((x == 5) && (y == 3))
-~~PB~~ +
- +
-==== Funktsioonid ==== +
- +
-Funktsioon on programmilõik,​ mida saab selle nime järgi täitmiseks välja kutsuda. Funktsioonil võivad olla parameetrid ja funktsioon võib tagastada ühe väärtuse. Kui funktsioon ei tagasta väärtust, on selle tüüp //void//. Kui funktsioonil pole parameetreid,​ tuleb vanemat C-keele kompilaatorit kasutades //void// kirjutada ka parameetrite deklaratsiooni asemele. Näide liitmisfunktsioonist ja tagastamisväärtuseta funktsioonist:​ +
- +
-<code c> +
-// Kahe int tüüpi parameetriga funktsiooni deklareerimine +
-// Funktsioon tagastab int-tüüpi väärtuse +
-int sum(int a, int b)+
 { {
- // Kahe arvu liitmine ja summa tagastamine + // Random action 
- return a + b;+ y = 4; 
 + my_function();
 } }
  
-// Ilma parameetrite ja tagastatava väärtuseta funktsioon 
-void power_off(void) 
-{ 
-} 
-</​code>​ 
  
-Funktsiooni kasutamiseks tuleb see välja kutsuda. Funktsioon peab programmikoodis olema deklareeritud enne välja kutsumise kohta. Näide liitmisfunktsiooni väljakutsumisest. +//If// statement can be longer and include code which will be executed in case the statement is false. For thisafter //if// statement, //else// statement can be usedExample:
- +
-<code c> +
-int x; +
-int y = 3; +
- +
-// Liitmisfunktsiooni väljakutsumine +
-// Parameetriteks on muutuja ja konstandi väärtus +
-x = sum(y5); +
- +
-// Väljalülitamise funktsiooni väljakutsumine +
-// Parameetrid puuduvad +
-power_off();​ +
-</​code>​ +
- +
-C-keele programmi täitmist alustatakse //main// nimelisest funktsioonistmis teeb selle kohustuslikuks funktsiooniks. +
- +
-~~PB~~ +
- +
-==== Laused ==== +
- +
-=== Tingimuslause === +
- +
-Tingimuslause võimaldab vastavalt sulgudes oleva avaldise tõesusele täita või mitte täita tingimusele järgnevat lauset või programmilõiku. Tingimuslause võtmesõna on //if//. Näide kasutamisest: +
- +
-<code c> +
-// Avaldis on tõene ja lause x = 5 täidetakse,​ +
-// sest 2 + 1 on suurem kui 2 +
-if ((2 + 1) > 2) x = 5; +
- +
-// Kui x on 5 ja y on 3, siis täidetakse järgnev programmilõik +
-if ((x = 5) && (y = 3)) +
-+
- // Suvaline tegevus +
- y = 4; +
- my_function();​ +
-+
-</​code>​+
  
-Tingimuslause võib olla pikem ja sisaldada ka lauset või programmilõiku,​ mis täidetakse avaldise mittetõesuse korral. Selleks tuleb //if// tingimuslause järel kasutada //else// võtmesõna. 
  
-<code c> +// Is equal with 5 ? 
-// Kas on 5 ? +if (x == 5)
-if (x = 5)+
 { {
- // Suvaline tegevus+ // Random action
  z = 3;  z = 3;
 } }
-// Kui ei olnud 5, kas siis x on ? +// If this is false then might be equal with 
-else if (x = 6)+else if (x == 6)
 { {
- // Suvaline tegevus+ // Random action
  q = 3;  q = 3;
 } }
-// Kui ei olnud ega 6...+// If was not nor 6 ...
 else else
 { {
- // Suvaline tegevus+ // Random action
  y = 0;  y = 0;
 } }
-</​code>​ 
  
-~~PB~~ 
  
-=== Valikulause ​===+<​pagebreak>​ 
 + 
 +=== Switch statement ​=== 
 + 
 +When required to compare operations and variables with many different values, it is reasonable to use comparison statement with //switch// keyword. Example about using this:
  
-Kui on vaja võrrelda avaldist mitme erineva väärtusega,​ on mõistlik kasutada valikulauset //switch// võtmesõnaga. Näide kasutamisest:​ 
  
-<code c> 
 int y; int y;
  
-// Tingimuslause ​võrdlemiseks+// Switch statement for comparing ​y
 switch (y) switch (y)
 { {
- // y on 1 ?+ // is equal to 1 ?
  case 1:  case 1:
- // Suvaline tegevus+ // Random action
  function1();​  function1();​
  break;  break;
  
- // y on 2 ?+ // is equal to 2 ?
  case 2:  case 2:
- // Suvaline tegevus+ // Random action
  function2();​  function2();​
  break;  break;
  
- // Kõik muud juhtumid+ // All other cases
  default:  default:
- // Suvaline tegevus+ // Random action
  functionX();​  functionX();​
- // break lauset pole vaja+ // break operation not needed
- // kuna võrdlemine lõppeb nagunii+ // because the comparison ends anyway
 } }
-</​code>​ 
  
-==== Tsüklid ==== 
  
-Tsüklitega saab programmilõiku täita mitmeid kordi.+==== Loops ====
  
-=== while ===+Loops can be used for executing code several times. 
 + 
 +=== while loop === 
 + 
 +Code marked with //while// keyword is executed until condition in brackets is true. Example:
  
-//while// võtmesõnaga tähistatud programmilõiku täidetakse seni, kuni sulgudes olev avaldis on tõene. 
  
-<code c> 
 int x = 0; int x = 0;
  
-// Tsükkel kestab seni, kuni on väiksem kui 5+// Loop will execute until is smaller than 5
 while (x < 5) while (x < 5)
 { {
- // x suurendamine ühe võrra+ // x incrementation
  x++;  x++;
 } }
-</​code>​ 
  
-~~PB~~ 
  
-=== for ===+<​pagebreak>​ 
 + 
 +=== for loop === 
 + 
 +//for// keyword loop is similar to //while// loop exept there are described operation executed before the loop and operation executed in the end of every loop cycle. Example:
  
-//for// võtmesõnaga tsükkel sarnaneb //while// tsüklile, kuid lisaks on sulgudes ära määratud enne tsüklit täidetav lause ja iga tsükli ajal täidetav lause. 
  
-Näide: 
-<code c> 
 int i, x = 0; int i, x = 0;
  
-// Algul määratakse ​nulliksTsüklit täidetaks seni, kuni +// i is equal to 1 at the beginning of the loop
-// i on vähem kui 5. Iga tsükli lõpus suurendatakse ​ühe võrra+// Loop will be executed until is smaller than 5. 
 +// will be incremented in the end of every loop cycle.
 for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
 { {
- // x suurendamine ​võrra+ // x addition by 2
  x += 2;  x += 2;
 } }
  
-// Siinkohal tuleb väärtuseks ​10 +// here value is 10
-</​code>​+
  
-=== Tsüklis liikumine === 
  
-//​while// ​ja //​for// ​tsüklitest saab erandkorras väljuda ​//​break// ​võtmesõnaga. //​continue// ​võtmesõnaga saab alustada järgmist tsüklit ilma järgnevat koodi täitmata.+=== Halting loops === 
 + 
 +As and exception exit from //​while// ​and //​for// ​loops can be made with keyword ​//​break//​. ​To start the next loop cycle without executing the remaining code in loop, //​continue// ​keyword can be usedFor example: 
  
-<code c> 
 int x = 0, y = 0; int x = 0, y = 0;
    
-// Lõputu tsükkel, kuna on loogiline tõesus+// Infinite loop because ​is logic true
 while (1) while (1)
 {    ​ {    ​
- // Tsüklist väljutakse,​ kui on saavutanud väärtuse ​100+ // Exit the the loop cycle if becomes ​100
  if (x >= 100) break;  if (x >= 100) break;
   
- // x suurendamine,​ et tsükkel kunagi lõppeks ka+ // x incrementation to end loop at some time
  x++;  x++;
    
- // Kui on 10 või vähem, siis alustatakse järgmist tsüklit + // If is 10 or less then the next cycle is started 
- if (x <= 10) continue; + if (x  
-  +/home/www/​roboticlab/​homelab_data/​pages/​en/​programming/​algorithm_code.txt--- 
- // y suurendamine + MISSING PAGE --- 
- y++; +====== AVR microcontroller ======
-}+
  
-// Siinkohal on y väärtus 90 +{{:​images:​book:​avr.jpg?​580|}}
-</​code>​+
  
-====== ​AVR mikrokontroller ======+The following chapters introduce the AVR microcontroller,​ which this book is based on. In spite of being so small, a microcontroller is full of features that have been documented by Atmel in a manual almost 400 pages long. Besides that, there are a lot of additional specific documents. All that information has been compressed to a fast and simple overview of the subject, which helps a beginner to understand better the AVR and learn to read its datasheet.
  
-{{:​images:​book:​avr.png?​580|}}+===== Introduction =====
  
-Järgnevad peatükid tutvustavad AVR mikrokontrollerit,​ mille põhjal on koostatud kogu käesolev raamatMikrokontrollerolgugi et pisike, on täis mitmeid võimalusi, mille kasutamise kohta Atmel on kirjutanud peaaegu 400-leheküljelise juhendi ning lisaks mitmed spetsiifilised lisadokumendid. Kogu sellest infost on siinkohal tehtud kiire ja võimalikult lihtne ülevaade, mis aitab algajal paremini AVR mikrokontrolleri funktsionaalsusest aru saada ja selle dokumentatsioonis orienteeruda. +[{{  :​images:​avr:​avr_atmega128_smd.jpg?​182|ATmega128 in SMT package (TQFP64to be precise)}}]
-===== Tutvustus =====+
  
-[{{  :​images:​avr:​avr_atmega128_smd.jpg?​182|ATmega128 SMT pakendis ​(täpsemalt TQFP64)}}]+AVR is a series of 8-bit RISC microcontrollers produced by AtmelAVR follows Harcard architecture and therefore has separate program and data memory. For the program it has an internally overwriteable flash memory, for data there are static ​(SRAMand EEPROM memory. Controller'​s frequency is usually up to 16 MHz and performance is almost 1 MIPS per 1-megahertz cycle.
  
-AVR on Atmeli poolt toodetav 8-bitiste RISC mikrokontrollerite seeria. Harvardi arhitektuuri kohaselt on AVR-il eraldi programmi- ja andmemäluProgrammi jaoks on süsteemisiseselt ümberkirjutatav välkmälu (inglise keeles //Flash//)andmete jaoks staatiline (SRAM) ja EEPROM mäluTaktsagedus ulatub enamasti kuni 16 MHz ja jõudlus on peaaegu 1 MIPS megahertsise takti kohta.+The production of AVR microcontrollers began in 1997 and by now AVR is one of the most popular controllers with hobby electronics engineersThanks to cheap developing toolsthe diversity of peripherals in a single package and low power consumption the initial success was gainedToday, there is another reason for choosing AVR: the massive amount of information and tutorials built up over the years. The AVR technology is inevitably aging, but to stay in competition Atmel is also making new AVR microcontrollers with more up-to-date peripherals and 16- and 32-bit buses, first of which are from the 8-bit compatible XMega series and the latter from the brand new AVR32 series.
  
-AVR mikrokontrollerite tootmist alustati 1997aastal ja praeguseks on see vabakutseliste elektroonikute seas üks levinumaid. Esialgse edu tagasid odavad arendusvahendidmitmekesine perifeeria ühes korpuses ja madal voolutarveNüüdseks võib eeliseks lugeda suure infomaterjali ja õpetuste pagasitmis aastate jooksul tekkinud onParatamatult on AVR tehnoloogia vananevkuid konkurentsis püsimiseks teeb Atmel ka tänapäevase perifeeria ning 16- ja 32-bitiste siinidega AVR mikrokontrollereidmillest esimesed on 8-bitistega ühilduvast XMega ja teised täiesti uuest AVR32 seeriast.+Based on the type of the application,​ there are several types of AVR microcontrollers,​ each with a different configurationMost of the AVRs belong to the megaAVR serieswhich have a large program memoryTo balance off the megaAVR seriesthere is also the tinyAVR series, which have smaller packages and less featuresIn addition to thesethere are also different series of microcontrollers designed specifically for controlling USBCAN, LCD, ZigBee, automatics, lighting and battery-powered devices.
  
-Vastavalt rakenduste tüübile on ka AVR mikrokontrollereid olemas erineva konfiguratsiooniga. Suurema osa AVR-e moodustab ​megaAVR ​seeriamis on suure programmimälu mahugaVastupidiselt megaAVR seeriale on olemas tinyAVR seeria väiksemate kestade ja kärbitud võimalustegaLisaks on veel mikrokontrollerite seeriad spetsiaalselt USBCANLCD, ZigBeeautomaatika,​ valgustuse juhtimise ja akutoitega seadmete jaoks.+The following text describes the main features of megaAVR ​series microcontrollersusing one of the most popular controllers in this series, ATmega128, as an exampleThis controller is also in the HomeLab kitGenerallyall the AVR series microcontrollers'​ register namesmeanings and usage is organized in a way to enable the examples also to be used with other controllers by making only slight changes. The main differences are in the peripherals. The code samples of this introduction are written in assembler and Cusing AVR LibC.
  
-Järgnevalt on kirjeldatud peamisi megaAVR seeria mikrokontrollerite võimalusi selle seeria ühe levinuima kontrolleri - ATmega128 näitel, mis on kasutusel ka Kodulabori komplektis. Üldiselt on kõigil AVR seeria mikrokontrolleritel registrite nimed, tähendused ja kasutamise kord reglementeeritud nii, et näiteid saab väikeste muudatustega ka teiste kontrollerite puhul kasutada. Peamised erinevused esinevad perifeeria juures. Tutvustuse koodinäited on toodud assembleris ja C-keeles AVR LibC abil.+==== Physical Appearance ====
  
-=== Füüsiline kuju ===+[{{:​images:​avr:​avr_atmega32_dip.jpg?​200 ​ |ATmega32 in 40-pin DIP casing}}]
  
-[{{:​images:​avr:​avr_atmega32_dip.jpg?​200 ​ |ATmega32 40 jalaga ​DIP korpuses}}]+Like all other controllers,​ the AVR is also packaged in some standard shellThe traditional casing is DIP (also called DIL). DIP is a so-called casing on legs - all the pins extrude as legs, about 5 mm in length, from the black plastic casing. DIP casing is a sensible choice for hobby applications and prototypes, because there are cheap sockets available for it, so the microcontroller can easily be replaced, should it happen to malfunction or die. The legs are also a disadvantage of the DIP casing, because it requires holes to be drilled in the circuit board.
  
-Nagu kõik teisedki kiibidon AVR pakendatud mingi standardkesta sisse. Traditsiooniline kest on DIP (nimetatakse ka DIL). DIP on nii-öelda jalgadega kest - kõik kiibi viigud on umbes 5-millimeetriste jalgadena näpuotsasuurusest mustast plastist korpusest välja toodudDIP kest on mõistlik valik hobirakendustes ja prototüüpide puhul, sest selle jaoks on saada odavad pesad, kust saab mikrokontrolleri läbipõlemise korral lihtsalt kätte ja uuega asendada. Samas on jalad ka DIP kesta miinuseks, sest nende jaoks on vaja trükiplaadile auke puurida.+The surface mount casings (SMTalso called SMDare much more compact, because their pins are designed to be soldered straight to the board without the need to penetrate itSMT microchips are in thin, coin-sized rectangular casings with pins about 1 mm longA more precise hand and better tools are required for soldering SMT chips.
  
-Palju kompaktsemad on pindliides ehk SMT (nimetatakse ka SMD) kestadsest neil on jalad mõeldud mitte plaadi läbistamiseksvaid otse rajale kinnijootmiseksSMT kestas ​on kiibid ​ õhukesed umbes mündi suurused neljakandilised mustad korpusedmille jalad on umbes millimeetri pikkusedSMT kestas kiipide jootmisel ​on vaja täpsemat kätt ja paremaid töövahendeid.+AVRs are available in both DIP and SMT casings. The layout of the pins is designed as logically and electrically even as possible. For example, on larger chipsthe ground and supply pins are located on several sides of the microcontroller,​ the pins for an external oscillator are near the ground pin, the bus pins are in numerical order, the communication pins are next to each other etcAVRs digital pins are compatible with TTL/CMOS standard voltage levels. At 5 V supply voltage, 0 to 1 V means logical zero, which is also called zero, null, 0, low, ground, or GND. At the same supply voltage, 3 to 5.5 V means logical one, also called one, 1, high. This type of wide voltage range only applies to the inputs - the output voltage ​on a pin with no load is still 0 V or near supply voltagedepending ​on the state of the pinThe allowed analog voltage level on the ADC channels is 0 to 5.5 V.
  
-AVR-e on saada nii DIP kui SMT kestades. Viikusid on püütud loogiliselt ning elektriliselt ühtlaselt paigutada. Näiteks on maa ja toiteviigud suurematel kiipidel toodud mitmesse kiibi külge, välise kvartsi viigud on maa viigu lähedal, siinide viigud on numbrilises järjekorras,​ andmesideliideste viigud on kõrvuti jne. AVR digitaalsed viigud ühilduvad TTL/CMOS standardsete pingenivoodega. 5 V toitepinge juures tähistab pinge 0 kuni 1 V loogilist nulli, mida nimetatakse ja kirjutatakse elektroonikute kõnepruugis ka kui: null, 0, madal, maa, mätas, //ground// või GND. Sama toitepinge juures tähistab pinge 3 kuni 5,5 V loogilist üht, mille nimetused on: üks, 1, kõrge, //high//. Selline suur loogiliste väärtuse pingeskaala kehtib sisendite kohta - väljundpinge on ilma koormuseta AVR viikudel vastavalt olekule ikkagi 0 V või toitepinge lähedane. Tehnoloogiast tingituna on ka analoogpinge (ADC kanalid) väärtused lubatud sarnases 0 kuni 5,5 V vahemikus.+=== ATmega128 ===
  
-== ATmega128 ​==+To better understand the following examples on ATmega128, there is a pinout schematic of ATmega128 (SMT package) below. Next to each pin, is a text with its number, primary function and secondary (alternate) function in brackets. Supply pins are GND and VCC. AVCC and AREF are analog-to-digital converter'​s supply and reference voltage pins. XTAL1 and XTAL2 are for connecting an external crystal oscillator, resonator or clock generator. Pins PB0 to PG4 mark the bits of input-output buses. The secondary functions of pins are discussed in the corresponding chapters.
  
-Et järgnevatest näidetest ​ATmega128 ​kohta paremini aru saada, on välja toodud ATmega128 SMT kesta viikude skeem. Viikude juures on selle number, primaarne funktsioon ja sulgudes alternatiivne funktsioon. Toiteotsad on GND ja VCC. AVCC ja AREF on vastavalt analoog-digitaalmuunduri toite ja võrdluspinge viigud. XTAL1 ja XTAL2 on välise kvartsostsillaatori,​ resonaatori või taktigeneraatori jaoks. Viigud PB0 kuni PG4 tähistavad sisend-väljundsiinide bitte. Viikude alternatiivfunktsioonidest tuleb juttu vastavates peatükkides.+[{{  :​images:​avr:​avr_atmega128_pinout.png?​420 ​ |ATmega128 ​pinout}}] 
 +===== Registers =====
  
-[{{  :​images:​avr:​avr_atmega128_pinout.png?​420 ​ |ATmega128 viigud}}] +One of the toughest things for beginners to understand in a microcontroller is typically a register. When dealing with microcontrollers,​ it is impossible to get by without knowing what this device is. This book is in no way different, as the reader is also expected to familiarize him/herself with the concept of a register and therefore the following text will try to explain it in simple enough terms so that even a beginner can grasp the idea of a register.
-===== Registrid =====+
  
-Üks kõige raskemini mõistetavaid asju mikrokontrollerite juures on algajate jaoks tavaliselt "​register"​. Sellest mõistest ei pääse üle ega ümber, kui on soov mikrokontrolleritega tegeleda. Ka käesolev materjal eeldab, et lugeja saab tuttavaks registri mõistega ja seepärast on järgnevalt seda algajale ka võimalikult lihtsalt selgitatud.+==== Essence ====
  
-=== Olemus ===+[{{  :​images:​logic:​tape_buttons.jpg?​240|Tape player'​s buttons}}]
  
-[{{  :​images:​logic:​tape_buttons.jpg?​240|Kassetimängija nupud}}]+A register is like a panel of buttons on a home applianceIt has switches, which can be turned on or off. One of the best examples is a simple tape player. For those, who don't remember, the tape player has (had) 6 buttons, left to right:
  
-Register on nagu mõne kodumasina nuppude paneel. Seal on lülitid, mida saab sisse vajutada või välja lükata. Üks parim näide on kassetimängija. Kes veel mäletab, siis kassetimängijatel on (oli) vasakult paremale 6 nuppu:+  * Record 
 +  * Rewind 
 +  * Play 
 +  * Fast forward 
 +  * Stop 
 +  * Pause
  
-  * Salvestamine +Each button does something, but only when it is used correctly. For example, the stop button does nothing unless a tape is playing - only then will it do something visible and stop the playback. Forward and rewind buttons, on the other hand, can be pressed at any time, because the tape can be wound in both directions, no matter if it is playing or stopped. The recording begins only when the play and record buttons are pressed down simultaneously. Some may have tried to press down several or all buttons at once - in this case, the tape player might have done something unexpected or break altogether.
-  * Tagasikerimine +
-  * Mängimine +
-  * Edasikerimine +
-  * Stopp +
-  * Paus+
  
-Iga nupp teeb midagikuid ainult õigel kasutamiselNäiteks stopp-nupp ei tee  midagi ennekui kassett ​on mängima pandud ​alles siis teeb see midagi arusaadavat ja peatab mängimiseEdasivõi tagasikerimise nuppe võib aga igal ajal vajutadasest linti hakatakse kerima nii poole mängimise kui seismise ajalSalvestama hakkab kassetimängija aga ainult siiskui salvestamise nupp koos mängimise nupuga alla vajutada. Mõni on ehk proovinud mitu nuppu või kõik nupud korraga alla vajutada - sel juhul võis mängija mida iganes teha või üldse katki minna.+Microcontroller registers behave like buttons on a tape player - each button does somethingwhen used correctlyBy pressing the wrong buttonsa microcontroller usually won't break, but it won't work either. In reality, there are no buttons in the registers, instead there are a whole lot of transistors,​ which turn the electricity ​on and off. Simpler microcontrollers have 8 transistor-based switches in a single registerA register can be thought of as an 8-bit numberwhere every bit is marked by the state of one of those switchesFor examplea bit value of 1 can mean that the switch is on and 0 that the switch is off.
  
-Mikrokontrolleri registriga on sama lugu nagu kassetimängija nuppudega - iga nupuke paneb seal õigel kasutamisel midagi käima. Valesid nuppe vajutades mikrokontroller (enamasti) küll katki ei lähe, kuid ei tööta ka. Tegelikult registris selliseid nuppe nagu kodumasinatel muidugi pole, on hoopis hulk transistore,​ mis elektrit sisse ja välja lülitavad. Lihtsamatel mikrokontrolleritel on registris 8 transistoridel põhinevat elektrilist lülitit. Registrit võib aga käsitleda nagu 8-bitist arvu, milles iga bitt tähistab ühe lüliti olekut. Näiteks biti väärtus 1 võib tähendada, et lüliti on sees ja 0, et lüliti on väljas.+[{{  :​images:​logic:​register_buttons_and_bits.png?​240|Register'​s "​buttons"​ and bit values}}]
  
-[{{  :​images:​logic:​register_buttons_and_bits.png?​240|Registri "​elektrilülitite asendid"​ ja nende bitiväärtused}}]+Since the state of a register'​s switches can easily be displayed as a number, a register can be compared to a memory, which can hold data in the size of one number. By this comparison, we see that registers actually are memory slots. The difference between a register and a memory slot is that a memory slot only stores the information,​ but in a register this information actually controls something. For example, if a binary value of 01100001 is written to a register, then three imaginary buttons are pressed down and something happens.
  
-Kuna registri lülitite olekut saab väga hästi esitada arvuna ja vastupidisiis võib registrit võrrelda ka mäluga, mis suudab hoida ühe arvu suurust informatsiooniSelle võrdlusega jõudis jutt selleni, et registrid ongi mälupesadVahe mälupesaga seisnebki üldjuhul ainult selleset mälupesa ei tee muudkui hoiab informatsiooniregistris see informatsioon aga juhib midagiEhk kui pildil kujutatud registrisse kirjutada binaarväärtus 01100001siis kolm näilist lülitit lükatakse alla ja midagi hakkab toimuma.+On a tape player it is possible to press each button separatelybut in a register it is more difficult to change the value of one "​switch"​ or bitTypically it is necessary to change the entire content of the registerBefore moving on to bit changingone should know that there are a lot of registers in a microcontroller. Some parts of the microcontroller use tens of registers to control them. The variety of registers means that there has to be a way to distinguish between different registers and that is done by naming the registers. One registerfor exampleis called PORTBActuallythese names are just to make things easier for the developer and each name corresponds to a numeric address.
  
-Kui kassetimängijal võib igat nuppu eraldi vajutada, siis registrites on ühe "​lüliti"​ või biti muutmine keerulisem. Üldjuhul tuleb muuta kogu registri sisu korraga. Enne kui bittide muutmisest rääkida, tuleks aga teada veel seda, et registreid on mikrokontrolleris palju. Mõnede mikrokontrolleri osade juhtimiseks võib kasutusel olla ka kümneid registreid. Registrite paljusus tähendab, et registreid peab kuidagi eristama ja seda tehakse nimega. Üks ilus registri nimi on näiteks PORTB. Tõe huvides võib mainida, et tegelikult on nimed vaid inimese välja mõeldud asendused numbrilistele aadressidele.+==== Usage ====
  
-=== Kasutamine ===+To write to a register or read a value from it, it has to be addressed as a variable in C. The following example demonstrates writing a binary value to an imaginary register REG and then reading it to variable //reg//. Binary values are distinguished by 0b (leading zero), so that the compiler understands the numeric system.
  
-C-keele programmis registri väärtuse kirjutamiseks või lugemiseks tuleb selle poole pöörduda nagu muutuja poole. Järgnev näide demonstreerib väljamõeldud registrisse REG binaarväärtuse kirjutamist ja selle väärtuse muutujasse //reg// lugemist. Binaarväärtuse ette kirjutatakse 0b (ees on null), et kompilaator arvusüsteemist aru saaks. 
  
-<code c> 
   REG = 0b01100001;   REG = 0b01100001;
   unsigned char reg = REG;   unsigned char reg = REG;
-</​code>​ 
  
-Põhimõtteliselt registrite väärtuse kirjutamises ja lugemises midagi keerulist polegi, kuid keerulisemaks läheb lugu siis, kui soovitakse muuta registri üksikute bittide väärtust. Bittide muutmiseks tuleb enne selgeks saada binaartehted ja erinevad arvusüsteemid. Keegi ei keela tegutseda binaararvudega,​ kuid binaararvudega tegelemine on tülikas nende pikkuse tõttu ja tavaliselt kasutatakse nende asemel heksadetsimaalarve,​ mis on lühemad. 
  
-[{{  :​images:​logic:​logic_hexadecimal.png?​209|Heksadetsimaalnumbrid}}]+There is nothing difficult in writing and reading register values, but it gets a little tricky if only a single bit needs to be changed. To change bits, one needs to know how to do binary math and use different numeric systems. It isn't forbidden to deal only with binary numbers, but they can be a bit troublesome,​ because binary numbers are quite long, and this is why most people use shorter hexadecimal numbers.
  
-Heksadetsimaalarvus pole numbrid mitte 0 ja 1, nagu binaarsüsteemis,​ ega 0-st 9-ni, nagu kümnendsüsteemis,​ vaid 0-st F-ni. Üks heksadetsimaalnumber moodustub neljast bitist. Kõrvalolev tabel näitab heksadetsimaalnumbritele vastavaid binaararve. Binaararve teisendatakse heksadetsimaalarvuks lugedes bitte nelja kaupa, alates madalamast järgust. Järkusid loetakse paremalt vasakule ja nende nummerdamist alustatakse nullist. Näiteks binaararvu 1110 madalaima ehk 0. järgu väärtus on 0 ja kõrgeima ehk 3. järgu väärtus on 1. Eespool toodud näidisregistri binaarväärtus 01100001 on heksadetsimaalkujul 61, mis C-keeles kirjutatakse kujul 0x61 (ees on null).+[{{  :​images:​logic:​logic_hexadecimal.png?​209|Hexadecimal numbers}}]
  
-Üksikute bittide muutmiseks arvus (registrismuutujas või kus iganes) tuleb kasutada binaartehteidBinaartehe ​on tehe binaararvude vahelkus nende arvude iga biti vahel toimub omaette loogikateheEnamasti on mikrokontrollerites kasutusel neli binaartehetmillel kõigil on mitu nimetustJärgnevalt on toodud kõigile neljale binaartehtele vastav loogikatehe üksiku biti või bittidega.+In hexadecimalthe numbers are not only 0 and 1 as in binary, or 0 to 9 as in decimal, but instead 0 to F. A hexadecimal number consists of four bitsThe table on the right shows the binary numbers and their hexadecimal counterparts. Binary numbers are converted to hexadecimal by reading bits four at a timestarting from the lowest rankRanks are read from right to left and their numbers start from 0. For examplethe lowest ranked (rank 0) bit is 0 and the highest (rank 3) is 1In the previous example, the register'​s binary value is 01100001, which is 61 in hexadecimal and is written as 0x61 (leading zero) in C.
  
-[{{  :​images:​logic:​logic_all_4.png?​550 ​ |Eitusloogiline korrutamineloogiline liitmine ja mittesamaväärsus}}]+To change single bits in a number (register, variable or anywhere else for that matter) it is necessary to use binary operationsBinary operation is an operation between two binary numberswhere each bit of the numbers is subject to its own logical operation. Typically a microcontroller supports four binary operationseach having several names. The following section describes the logical operation behind each of these four binary operations with a single bit or multiple bits.
  
-~~PB~~+[{{  :​images:​logic:​logic_all_4.png?​550 ​ |Negation, logical multiplication,​ logical addition and exclusive disjunction }}]
  
-  * **Eitus / Inversioon** \\ Eitus muudab biti väärtuse vastupidiseks ehk 0 muutub 1 ja 1 muutub 0. C-keeles on eituse märk "​~"​. +<​pagebreak>​
-  * **Loogiline korrutamine / Konjunktsioon** \\ Kahte bitti korrutades on vastus 1, kui mõlemad bitid olid 1, muul juhul on vastus 0. C-keeles on korrutamise märk "&"​. +
-  * **Loogiline liitmine / Disjunktsioon** \\ Kahe biti liitmisel on vastus 1, kui vähemalt ühe biti väärtus oli 1, muul juhul on vastus 0. C-keeles on liitmise märk "​|"​. +
-  * **Mittesamaväärsus / Välistav disjunktsioon** \\ Kahe bitiga mittesamaväärsuse tehte korral on vastus 1, kui bittide väärtused teineteisest erinevad, muul juhul on vastus 0. C-keeles on mittesamaväärsuse märk "​^"​.+
  
-Nüüd on lühidalt selgitatud kõikmida läheb vaja üksikute bittide väärtuste muutmiseksKuid ilmselt jääb teooriast ikkagi väheks ja seepärast on järgnevalt toodud mõningad tüüpnäited registritega.+  * **Negation / Inversion** \\ Negation changes the bit's value to its oppositea 0 becomes a 1 and vice versaIn C, negation is marked with "​~"​. 
 +  * **Logical multiplication / Conjunction** \\ When multiplying two bits, the answer is 1 if both bits are 1 and in any other case 0. In C, logical multiplication is marked with "&"​. 
 +  * **Logical addition / Disjunction** \\ When adding two bits, the answer is 1 if at least one of the bits is 1 and 0 if both bits are 0. In C, logical addition is marked with "​|"​. 
 +  * **Exclusive disjunction / Exclusive OR / XOR** \\ Exclusive OR operation will return 1 if the two bits differ from each other (one is 1 and the other 0), otherwise the answer is 0. In C, exclusive disjunction is marked with "​^"​. 
 + 
 +This is all one needs to know to change single bits. The theory alone is probably not enough, though, and that is why there are some typical examples with registers in the next few paragraphs.
  
 ~~CL~~ ~~CL~~
  
-== Üksiku biti kõrgeks seadmine ​==+=== Setting a Single Bit High ===
  
-[{{  :​images:​logic:​op_bit_set.png?​230|Biti kõrgeks seadmise tehe}}]+[{{  :​images:​logic:​op_bit_set.png?​230|Setting a single bit high}}]
  
-Selleks et üks või enam bitte registris kõrgeks ehk üheks seada, tuleb kasutada loogilist liitmise tehetLiitmistehte üks operand peab olema register, ​teine binaararv, kus kõrge on ainult see bitt, mida ka registris soovitakse kõrgeks seadaSeda teist binaararvu nimetatakse ka bitimaskiksKõrvalnäites toodud tehe näeb C-keeles välja niimoodi:+To set one or more bits in a register high (1) a logical addition operation is neededOne of the operands of the operation must be the register ​and the other a binary numberwhere the only high bit is the one that needs to be set high in the registerThis binary number is called a bitmaskBelow is the code for the operation shown on the right:
  
 ~~CL~~ ~~CL~~
  
-<code c> 
-  // Oletame, et REG = 0x0F 
-  REG = REG | 0x11; // Üks meetod 
-  REG |= 0x11;      // Teine meetod 
-  // Siinkohal REG = 0x1F 
-</​code>​ 
  
-== Üksiku biti madalaks seadmine ​==+  // Let's suppose REG 0x0F 
 +  REG REG | 0x11; // First method 
 +  REG |0x11;      // Second method 
 +  // Now REG 0x1F
  
-[{{  :​images:​logic:​op_bit_clear.png?​229|Biti madalaks seadmise tehe}}] 
  
-Ühe või enama biti registris madalaks ehk nulliks seadmiseks tuleb kasutada loogilise korrutamise tehetTehte üks operand ​peab olema register, ​teine bitimask, kus madalaks on seatud vaid see bitt, mida ka registris soovitakse madalaks seadaKõrvalnäites toodud tehe näeb C-keeles välja nii:+=== Setting a Single Bit Low === 
 + 
 +[{{  :​images:​logic:​op_bit_clear.png?​229|Setting a single bit low}}] 
 + 
 +To set one or more bits in a register low (0) a logical multiplication operation is needed. One operand ​of the operation must be the register ​and the other a bitmaskin which the only low bit is the one that needs to be set low in the registerBelow is the code for the operation shown on the right:
  
 ~~CL~~ ~~CL~~
  
-<code c> 
-  // Oletame, et REG = 0x0F 
-  REG = REG & 0xFE; // Üks meetod 
-  REG &= 0xFE;      // Teine meetod 
-  // Siinkohal REG = 0x0E 
-</​code>​ 
  
-~~PB~~+  // Let's suppose REG = 0x0F 
 +  REG = REG & 0xFE; // First method 
 +  REG &= 0xFE;      // Second method 
 +  // Now REG = 0x0E
  
-== Üksiku biti inverteerimine == 
  
-[{{  :​images:​logic:​op_bit_invert.png?​229|Biti inverteerimise tehe}}]+<​pagebreak>​
  
-Ühe või enama biti registris inverteerimiseks tuleb kasutada mittesamaväärsuse tehetTehte üks operand peab olema register, ​teine bitimask, kus kõrgeks on seatud vaid see bitt, mida ka registris soovitakse inverteeridaKõrvalnäites toodud tehe näeb C-keeles välja järgmiselt:+=== Inverting a Single Bit === 
 + 
 +[{{  :​images:​logic:​op_bit_invert.png?​229|Inverting a single bit}}] 
 + 
 +To invert one or more bits in a register ​an exclusive disjunction operation is required. One of the operands of the operation must be the register and the other a bitmaskwhere the only high bit is the one that needs to be inverted in the registerBelow is the code for the operation shown on the right:
  
 ~~CL~~ ~~CL~~
  
-<code c> 
-  // Oletame, et REG = 0x0F 
-  REG = REG ^ 0x11; // Üks meetod ​ 
-  REG ^= 0x11;      // Teine meetod (rakendada tohib korraga ainult üht) 
-  // Siinkohal REG = 0x1E 
-</​code>​ 
  
-== Kogu registri inverteerimine ​==+  // Let's suppose REG 0x0F 
 +  REG REG ^ 0x11; // First method 
 +  REG ^0x11;      // Second method (use only one per inversion) 
 +  // Now REG 0x1E
  
-[{{  :​images:​logic:​op_reg_invert.png?​229|Bittide inverteerimise tehe}}] 
  
-Kogu registri bittide inverteerimiseks tuleb kasutada eitustehetSee on unaarne tehe ehk tal on ainult üks operand. ​Kõrvalnäites toodud tehe näeb C-keeles välja niimoodi:+=== Inverting the Whole Register === 
 + 
 +[{{  :​images:​logic:​op_reg_invert.png?​229|Inverting all bits}}] 
 + 
 +To invert all bits in a register, a negation operation is used. This operation is unary, which means it has only one operand. ​Below is the code for the operation shown on the right:
  
 ~~CL~~ ~~CL~~
  
-<code c> + 
-  // Oletame, et REG = 0x0F+  // Let's suppose ​REG = 0x0F
   REG = ~REG;   REG = ~REG;
-  // Siinkohal ​REG = 0xF0 +  // Now REG = 0xF0
-</​code>​+
  
-== Üksiku biti väärtuse lugemine == 
  
-[{{  :​images:​logic:​op_bit_get.png?​229|Biti lugemise tehe}}]+=== Reading the Value of a Single Bit ===
  
-Ühe või enam biti väärtuse lugemiseks registrist tuleb kasutada sama tehet, mis biti nullimisel ​loogilist korrutamistTehte üks operand peab olema register, ​teine bitimask, kus kõrgeks on seatud vaid see bitt, mille väärtust registrist lugeda soovitakseKõrvalnäites toodud tehe näeb C-keeles välja järgmiselt:+[{{  :​images:​logic:​op_bit_get.png?​229|Reading the value of a bit}}] 
 + 
 +To read one or more bits from a register the same operation is required as was used for setting a bit low logical multiplicationOne of the operands of the operation must be the register ​and the other a bitmaskwhere the only high bit is the one that needs to be read from the registerBelow is the code for the operation shown on the right:
  
 ~~CL~~ ~~CL~~
  
-<code c> + 
-  // Oletame, et REG = 0x0F+  // Let's suppose ​REG = 0x0F
   unsigned char x = REG & 0x01;   unsigned char x = REG & 0x01;
-  // Siinkohal ​x = 0x01 +  // Now x = 0x01
-</​code>​+
  
-~~PB~~ 
  
-== Biti nihutamine ==+<​pagebreak>​
  
-Tegelikult on paljudes programmeerimiskeeltes peale binaartehete veel mõned bitioperatsioonid,​ mis teevad programeerija elu lihtsamaks. Need on bitinihutuse operatsioonid,​ mis binaararvus nihutavad bitte kas vasakule või paremale poole. Nihutusoperatsioonide põhiline väärtus seisneb registritega tegeldes nende võimes bitijärkusid bitimaskiks teisendada ja vastupidi.+=== Shifting a Bit ===
  
-[{{  :​images:​logic:​op_bit_shift_left.png?​241|Bitinihe vasakule}}]+Many programming languages actually have a few additional bitwise operations, which make it easier for programmers. These are bit shifting operations that shift bits left or right in a binary number. The main advantage of shift operations in dealing with registers is their ability to convert bit ranks to bitmasks and vice versa.
  
-Kõrvaloleval pildil ​on toodud näide bitinihutuse operatsioonist vasakuleBitinihutus pole loogikaoperatsioon ja sel puudub vastav tähis, C-keeles on see aga "<<"​. ​Nihet vasakule kasutatakse bitijärgu bitimaskiks teisendamiseksNäitekskui soovitakse kuuenda biti (NB! järk on 5) maskisiis tuleb arvu nihutada vasakule 5 kordaNäites toodud operatsioon näeb C-keeles välja järgmiselt:+[{{  :​images:​logic:​op_bit_shift_left.png?​241|Shift left}}] 
 + 
 +The image on the right shows a shift-left operationAlthough bit shifting is not a logical operation and has no corresponding symbolin it is marked as ">" ​in CRight-shift is used to get the logical value of a bit from a bitmaskA previous example showed how to read the value of a single bit. Let's suppose the bit to be read is not of the lowest rankbut for example of rank 5. In this case, the result would be either 0x20 or 0x00but sometimes a result of or 0 is needed and that is when the right-shift comes to the rescueThe example operation on the right looks like this in C:
  
 ~~CL~~ ~~CL~~
  
-<code c> 
-REG = 0x01 << 5; 
-// Siinkohal REG = 0x20 
-</​code>​ 
- 
-[{{  :​images:​logic:​op_bit_shift_right.png?​241|Bitinihe paremale}}] 
- 
-Sarnaselt bitinihkega vasakule toimib ka bitinihke operatsioon paremale. Selle operatsiooni tähis C-keeles on ">>"​. Nihet paremale kasutatakse bitimaskist biti loogilise väärtuse leidmiseks. Eespool oli toodud näiteks üksiku biti väärtuse lugemise tehe. Oletame, et bitt, mida lugeda, pole aga madalaima järguga, vaid näiteks järguga 5. Sel juhul oleks lugemisel vastus kas 0x20 või 0x00, kuid vahel läheb vaja vastust 1 või 0 ja siis tulebki appi nihe paremale. Kõrvalnäites toodud operatsioon näeb C-keeles välja nii: 
- 
-~~CL~~ 
  
-<code c> +// Let's suppose ​REG 0x20
-// Oletame, et REG väärtus on 0x20+
 unsigned char x = REG >> 5; unsigned char x = REG >> 5;
-// Siinkohal on väärtus ​0x01 (ehk lihtsalt ​1) +// Now 0x01 (or simply ​1)
-</​code>​+
  
-Kui bitinihke operatsioonidega nihkub bitt madalaimast järgust paremale või kõrgeimast järgust vasakule, siis see bitt kaob. Mõnedes programmeerimiskeeltes on olemas ka roteeruvad bitinihke operatsioonid,​ kus "​servast"​ välja minev bitt tuleb teiselt poolt tagasi. C-keeles roteeruvad bitinihke operatsioonid puuduvad, kuid vajadusel saab need ise kirjutada. 
  
-Kõik toodud bitioperatsioonide näited toimivad peale registrite ka muutujatega ja konstantidegaViimased saavad muidugi ainult operandideksmitte vastusteks olla.+If a bit is shifted right from the lowest rank or left from the highest rank by the bit shifting operation, it disappears. Some programming languages also have rotating bit shift operations, where the bit doesn'​t disappear, but moves from the lowest rank to the highest or vice versaC doesn'​t have that kind of bit-shift operationsbut they can be written by the programmer if needed.
  
-=== AVR registrid ===+All bit operations work with not only registers, but with variables and constants as well. The latter can of course only be used as operands and not the result.
  
-Selleks et midagi reaalselt mikrokontrolleri registritega teha saaks, tuleb osata selle mikrokontrolleriga läbi saada. Kõigi mikrokontrolleritega käib kaasas üks või mitu andmelehte, kus on dokumenteeritud kogu mikrokontrolleri struktuur ja funktsionaalsus. Andmelehes on kirjeldatud ka registrid. Järgnevalt uurime, kuidas saada aru AVR-i andmelehe registrite kirjeldusest.+==== AVR Registers ====
  
-[{{  :​images:​logic:​avr_example_register.png?​580 ​ |Üks AVR register ​selle andmelehest}}]+To actually do anything with the microcontroller'​s registers, one needs to know how to use that particular microcontrollerEach microcontroller comes with one or several datasheets, which describe the whole structure and functionality of the microcontroller. The datasheet also describes the registers. The following will help understand the register ​descriptions in AVR datasheets.
  
-Pildil on toodud ATmega128 mikrokontrolleri register UCSRnA, mille pikem nimetus on "//​USART Control and Status Register A//". See on register, millega sätitakse AVR-i USART moodulit ja kust saab lugeda selle mooduli olekuid. Kõik AVR-i registrite nimed kirjutatakse suurte tähtedega, kuid tähelepanelik lugeja ilmselt märkab, et selles registris on väike n-täht. Väikese n-tähega tähistatakse nimelt mõne mooduli indeksit. Kuna ATmega128-s on 2 üsna sarnast USART moodulit, siis ei kirjeldata nende registreid topelt, vaid ühe korra ja n-tähe asemele peab lugeja arvestama kas "​0"​ või "​1"​. Seega ATmega128-s on registrid UCSR0A ja UCSR1A.+[{{  :​images:​logic:​avr_example_register.png?​580 ​ |One of AVRs registers from its datasheet}}]
  
-Registri sisu tähistab paksu piirjoonega 8 lahtriga kastIga lahter tähistab üht bittiKasti kohal on toodud biti järgud - suurenevad paremalt vasakule. Kuna AVR on 8-bitine mikrokontrolleron ka enamik registreid 8-bitised. Mõningad erandid on 16-bitised registridmis koosnevad tegelikult kahest 8-bitisest registristLisaks registritele on nimi ka igal registri bitil - täpselt nagu kassetimängija nuppudelgiIga biti kohta on andmelehes olemas selle selgitus. Biti nimed on samuti lühendid ja n-täht neis tuleb samuti asendada mooduli indeksigaMõnes registris pole kõiki 8 bitti kasutatud ja sel juhul tähistatakse biti lahter sidekriipsuga.+The image shows ATmega128 microcontroller'​s UCSRnA register, which stands for "USART Control and Status Register A"This register is used to configure AVR's USART module and read its statesAll AVR register names are written in capital lettersbut as the reader might noticethe register name contains also a lower case nA lower n is used to mark some module'​s indexSince ATmega128 has 2 almost identical USART modules, they are not described twice, but only once and the must be read as 0 or 1 by the userTherefore ATmega128 has registers UCSR0A and UCSR1A.
  
-Registri bittide all on toodud kaks ridakus on kirjas, kas bitt on loetav (R), kirjutatav (W) või mõlemat (R/W)Näiteks olekubitte ei saa üle kirjutada ja isegi siiskui seda programmis üritadaei omanda ​bit lihtsalt talle omistatavat väärtustBiti puhul, mida saab ainult kirjutada, on öeldud üks kindel väärtusmis selle lugemisel alati tulebBittide ​all teises reas on toodud vaikeväärtusmis on bitil pärast mikrokontrolleri käivitamist (inglise keeles //reset//).+The content of the register is marked by an 8-slot box with a bold line around it. Each slot marks one bit. Bit ranks are marked above the box - increasing from right to left. Since AVR is an 8-bit microcontrollermost of the registers are 8-bit as wellThere are some exceptionsa few registers are 16-bitbut they actually consist of two 8-bit registersJust as each register has a nameeach bit in the register also has a name - just like the buttons ​on a tape player. Each bit is described in the datasheet. Bit names are abbreviations as well and the lower n must be substituted with the module'​s indexjust like with register namesSome registers don't use all 8 bitsin this case the bit's slot is marked with a hyphen.
  
-Kui AVR-i registrite nimed viitavad tegelikult mälupesade aadressidelesiis biti nimede taga peitub selle biti järgu numberSeega registris bittidega manipuleerimiseks tuleb bitinimed nihutusoperatsiooni abil bitimaskiks teisendadaJärgnevalt on toodud mõned C-keele näitelaused eeltoodud USART 0 mooduli registri kasutamiseks.+Below the register'​s bits are two lineswhich state whether the bit is readable (R), writable (W) or both (R/W)For example, the status bits can't be overwritten and even if it's attempted in the program, the bit will remain unchangedIf the bit is marked as writable, reading it will always result in one specific value stated in the datasheet. The second line specifies the default value of the bit, which it has after the reset of the microcontroller.
  
-<code c> +While AVR register names point to an actual memory slot address, the bit names hold the rank number of the corresponding bit. Therefore it is necessary to transform the names to bitmasks using a shift operation, in order to manipulate with bits in a register. The following ​code contains a few example lines for using the USART 0 module'​s register.
-  // TXC0 biti kõrgeks seadmine +
-  UCSR0A |= (1 << TXC0);+
  
-  // U2X0 biti madalaks seadmine 
-  UCSR0A &= ~(1 << U2X0); 
  
-  // UDRE0 biti(maski) väärtuse lugemine +  // Set TXC0 bit high 
-  ​unsigned char u (UCSR0A & (1 << UDRE0));+  ​UCSR0A |= (1  
 +===== Architecture =====
  
-  // Siinkohal on u väärtus kas 0 või 32, +AVR has an internal 8-bit data busthrough which the data is moved between the arithmetic logic unit (ALU), status register ​(SREG), program counter (PC), random access memory (SRAM) and peripherals. The program, an array of commands that is executed in the ALU, comes from an address in the flash memory, specified by the program counter. The ALU has 32 8-bit general purpose registers, which are used as operands when carrying out instructions.
-  // mis võimaldab seda loogilises avaldises kasutada +
-  if (u) +
-  { +
-     // MPCM0 biti inverteerimine +
-     ​UCSR0A ^= (1 << MPCM0)+
-  }+
  
-  // Mõnikord on aga vaja saada konkreetne 0 või 1 väärtus,​ +[{{  :​images:​avr:​avr_atmega128_block_diagram.png?​580 ​ |Block diagram of ATmega128}}]
-  // selleks tuleb loetud bitti nihutada paremale +
-  u >>= UDRE0;+
  
-  // Siinkohal on u väärtus kas 0 või 1 +==== Instruction Pipeline ====
-</​code>​+
  
-===== Arhitektuur =====+AVR has a two-stage instruction pipeline. While one instruction is executed, the next is fetched from the program memory. This is why carrying out jump instructions takes 2 cycles on fulfillment of the jump condition. Since the new instruction is always fetched from the next memory address, it is necessary to discard the previously fetched instruction and fetch a new one when jumping to another address, because it was taken from an old, wrong location.
  
-AVR-il on sisemine 8-bitine andmesiin, mille kaudu liiguvad andmed arvutusüksuse (ALU), olekuregistri (SREG), programmiloenduri (PC), muutmälu (SRAM) ja perifeeria vahel. ALU-s täitmisele minev programm ehk instruktsioonide jada tuleb välkmälu aadressilt, mille määrab programmiloendur. ALU juurde kuuluvad 32 üldkasutatavat 8-bitist registrit, mida kasutatakse paljude instruktsioonide täitmisel operandidena.+==== General Purpose Registers ====
  
-[{{  :​images:​avr:​avr_atmega128_block_diagram.png?​580 ​ |ATmega128 struktuur}}]+General purpose registers R0-R31 are like buffers for storing and operating with memory and peripheral data. They simplify the architecture of the processor, because they are quickly accessible by the ALU, and the use of the data bus to read operands from the memory is not necessary for every operation. General purpose registers are used for performing all data-related arithmetical and logical operations.
  
-=== Käsukonveier ===+While programming in assembler, it is possible to store the urgent data in general purpose registers. While programming in C and a need to store a variable in a general purpose register arises, the variable is additionally defined as "​register"​. 
 +For example:
  
-AVR-i käsukonveier on kaheastmeline. Samal ajal kui üht instruktsiooni täidetakse,​ laetakse järgmine instruktsioon programmimälust ootele. See on ka põhjus, miks siirdekäskude täitmine võtab 2 takti siirdetingimuse täitumisel. Kuna uus instruktsioon laetakse käsukonveierisse alati järgmiselt mäluaadressilt,​ siis siiretel muule programmiaadressile tuleb eelnevalt laetud instruktsioon minema visata ja uus laadida, sest see oli vanast ehk siis valest kohast laetud. 
  
-=== Üldkasutatavad registrid ===+register char x;
  
-Üldkasutatavad registrid R0-R31 on justkui vahepuhvrid mälu ja perifeeria andmete hoidmiseks ning nendega toimetamiseks. Üldkasutatavad registrid lihtsustavad protsessori arhitektuuri,​ kuna ALU jaoks on need kiirelt kättesaadavad ja igal arvutusel ei pea operandide mälust lugemiseks kasutama andmesiini. Üldkasutatavaid registreid kasutatakse kõikide andmetega seotud aritmeetiliste ja loogiliste operatsioonide tegemiseks. 
  
-Assemblerkeeles programmeerides võib kiiret töötlust vajavaid andmeid üldkasutatavates registrites hoida. Kui programmeeritakse C-keeles ja on kindel soov muutuja hoidmiseks üldkasutatavat registrit kasutada, defineeritakse muutuja täiendavalt "​register"​ tüüpi. Näiteks:+==== Instruction Set ====
  
-<code c> +The instruction set of most AVRs consists of 90-133 different instructions. ATmega128 has 133 instructions. Instructions have either one, two or no operands. Most instructions take only one cycle to complete, but the more complex ones can use up to 5 cycles. For XMega, the successor of AVR, several instructions have been modified to use less cycles. Most instructions in AVR are used for jumps, moving and comparing data and executing arithmetic calculations. A status ​register ​is used for performing calculations and comparisons. It stores the output status of the ALU - whether the result was negative, positive, zero, exceeded the maximum allowed value (8 bits), needed to transfer a bit to the next operation etc (there are a few more complex cases).
-register ​char x; +
-</​code>​+
  
-=== Käsustik === 
  
-Enamiku AVR-ide käsustik koosneb 90-133 erinevast instruktsioonist. ATmega128-l on 133 instruktsiooni. Instruktsioonid on kas ühe, kahe või üldse ilma operandideta. Enamik instruktsioone täidab mikrokontrolleri protsessor ühe takti jooksul, kuid keerukamad kulutavad kuni 5 takti. AVR-i järeltulija XMega puhul on mitmeid instruktsioone täiendatud nii, et need kulutavad vähem takte. Suurem osa AVR-i instruktsioonidest on siireteks, andmete liigutamiseks,​ võrdlusteks ja loogilisteks ning aritmeetilisteks teheteks. Tehete ja võrdluste puhul on kasutusel olekuregister,​ kus märgitakse vastavate bittidena ära juhud, kui tehte tulemus ALU-s oli: negatiivne või positiivne, null, ületas maksimaalse võimaliku väärtuse (8-bitti), vajas biti ülekandmist järgmisesse tehtesse, ja veel paaril keerukamal juhul. 
  
-<​box ​100% round #​EEEEEE|Näide>​+This is a piece of code written in Assembler and consists of pure instructions,​ which adds 5 to the byte at random access memory address $100 (decimal 256). These instructions exist in all AVRs.
  
-Toodud on Assembleris ehk puhtalt instruktsioonidena kirjutatud kood, mis liidab muutmälus aadressil $100 (detsimaalarvuna 256) asuvale baidile juurde arvu 5. Kasutatud käsud on olemas kõigil AVR-idel. 
  
-<code asm> +ldi  r1, 5       ; ​Load the constant ​to general purpose register ​r1 
-ldi  r1, 5       ; ​Konstandi ​laadimine üldkasutatavasse registrisse ​r1 +lds  r2, $100    ; Load the byte from the memory to register ​r2 
-lds  r2, $100    ; Baidi laadimine muutmälust registrisse ​r2 +add  r2, r1      ; Add the value of r1 to r2 
-add  r2, r1      ; Registrile r2 registri ​r1 väärtuse liitmine +sts  $100, r2    ; Write the value of r2 back to the memory
-sts  $100, r2    ; Registri ​r2 väärtuse kirjutamine tagasi muutmällu +
-</​code>​+
  
-</​box>​ 
  
-=== Programmi pinumälu === 
  
-Pinumälu (inglise keeles //stack//) on andmete ülesehitus,​ kus viimasena mällu kirjutatud andmed loetakse välja esimesena. AVR-is saab pinumälu kasutada alamfunktsioonide,​ katkestuste ja ajutiste andmete juures. Alamfunktsioonide ja katkestuste täitmisel lisatakse eelnevalt pinumällu programmiloenduri aadress, mille pealt programm katkes. Kui alamfunktsioon või katkestus on töö lõpetanud, loetakse pinumälust aadress, kust programmi tööd jätkata. Ajutisi andmeid lisatakse pinumällu tavaliselt lühemate programmilõikude juures, mis ei vaja mälu reserveerimist kogu programmi ajaks. Lihtsamad assemblerkeele programmid on kirjutatud üldjuhul nii, et pinumälu kasutama ei pea, kuid selle võtavad kasutusele kompilaatorid,​ kui programmis on palju muutujaid ning funktsioone. 
  
-MegaAVR seeria mikrokontrolleritel on pinumälu füüsiline asukoht muutmälus, kuid mõnel tinyAVR seerial muutmälu üldse puudub ja pinumälu tarbeks on spetsiaalne üsna piiratud mahuga mälu. Sellistele, ilma muutmäluta mikrokontrolleritele kompilaatoreid üldjuhul pole.+==== Program Stack ====
  
-Kõrgtaseme keeles (PascalCC++) programmeerides ei pea otseselt mikrokontrolleri siseeluga kursis olemasest kompilaator valib ise vastavalt vajadusele üldkasutavaid registreid ja instruktsioonekuid see teadmine tuleb kasuksMikrokontrolleri instruktsioone on oluline tunda ajakriitilistes rakendusteskus protseduurid peavad toimuma loetud protsessori taktide jooksul.+Stack is a data structurewhere the last data written to the memory is read out first. AVR's stack can be used while operating with subroutinesinterrupts and temporary data. Before executing a subroutine or interruptthe address in the program counter where the program was interrupted is stored in the stack. When the subroutine or interrupt has finished its executionthis address is read back from the stack and the program continues from the address it left off from beforeStoring temporary data in the stack is usually used when dealing with shorter chunks of code, which do not require reserved memory throughout the execution of the program. Simpler assembler programs are usually written so that it is not necessary to use the stack, but if the program contains a lot of variables and functionsthe compilers automatically make use of it.
  
-===== Töötakt =====+The stack of MegaAVR series microcontrollers is physically located in the random access memory. Some tinyAVR series devices do not have a random access memory at all and the stack is realized as a separate, quite limited memory unit. Typically there are no compilers for devices with no random access memory.
  
 +To program in a high level language (Pascal, C, C++), it is not necessary to be familiar with the inner workings of the microcontroller,​ because the compiler is capable of selecting general purpose registers and instructions by itself, but knowing what goes on in the controller is certainly beneficial. It is necessary to know the instructions of the microcontroller when developing time-critical applications,​ where the operations have to be completed in a limited amount of cycles.
 +===== Clock =====
  
 +As with most digital electronics,​ an AVR also works at a constant frequency. A constant frequency assures the reliability of data exchange throughout the device. There are several methods for generating a clock signal for an AVR.
  
-Nii nagu enamik digitaalelektroonikat,​ töötab ka AVR kindlal taktsagedusel. Kindel taktsagedus tagab andmevahetuse töökindluse kogu kiibi ulatuses. Taktsignaali ehk töötakti genereerimiseks on AVR-i puhul mitu võimalust.+**Internal RC Oscillator**
  
-**Sisemine ​RC ostsillaator**+[{{  :​images:​avr:​avr_clock_ext_rc.png?​150|Using an RC oscillator}}]
  
-[{{  :​images:​avr:​avr_clock_ext_rc.png?150|RC ostsillaatori ühendus}}]+This is a internal clock generator, which does not need any external components. Its main disadvantages are low frequency and inaccuracy.
  
-See on kiibisisene taktigeneraator,​ mis ei vaja väliseid komponente. Puuduseks on suhteliselt madal sagedus ja ebatäpsus.+**External RC Oscillator**
  
-**Väline ​RC ostsillaator**+Works on the same principal as an internal ​RC oscillator and has no significant advantage over the internal one.
  
-Sama põhimõttega,​ nagu sisemine RC ostsillaator ja ei oma sisulist eelist eelmise ees.+**Crystal Oscillator**
  
-**Kvartsostsillaator**+[{{  :​images:​avr:​avr_clock_ext_crystal.png?​150|Using a crystal oscillator}}]
  
-[{{  :​images:​avr:​avr_clock_ext_crystal.png?​150|Kvartsostsilaatori ühendus}}]+Crystal oscillators use a crystal (usually quartz) that vibrates at its resonant frequency in the electric field and has a piezoelectic quality to produce an electric field during mechanical deformation (vibration). Crystal oscillators enable a precision of nearly 0.001%, which does not depend on the temperature.
  
-Kvartsostsillaatoris kasutatakse elektriväljas oma resonantssagedusel võnkuvat kristalli ja selle piesoelektrilist omadust mehhaanilisel deformatsioonil (võnkumisel) elektriväli tekitada. Kvartsostsillaatorit võimaldavad ligi 0,001% täpsust taktsagedust ja seda olenemata temperatuurist.+**Ceramic Resonator**
  
-**Keraamiline resonaator**+Ceramic resonators are similar to crystal oscillators,​ but are made from cheaper piezoelectric materials. Ceramic resonators are typically smaller than crystal oscillators,​ but are also less precise (~0.5%) and more sensitive to temperature changes.
  
-Tegu on kvartsostsillaatorile sarnaneva lahendusega,​ kus kasutatakse odavamat piesoelektrilist materjali. Resonaatorid on reeglina ka väiksemad kui kvartsostsillaatorid,​ kuid paraku on nad ka ebatäpsemad (~0,5%) ja temperatuuritundlikumad.+**External Clock Signal**
  
-**Väline taktsignaal**+[{{  :​images:​avr:​avr_clock_ext_clock.png?​150|Using an external clock signal}}]
  
-[{{  :​images:​avr:​avr_clock_ext_clock.png?​150|Välise taktsignaali ühendus}}]+An external clock signal can be generated with any device, provided that the frequency and amplitude (voltage) are in the correct range. For example, an external clock signal generator can be used to provide a clock signal to several microcontrollers at once.
  
-Välist taktsignaali võib tekitada ükskõik mis seade, peaasi et taktsagedus ja amplituut (pinge) oleks lubatud piirides. Näiteks võib skeemis kasutada eraldi taktigeneraatorit,​ mis takteerib mitut mikrokontrollerit.+===== Interrupts =====
  
-===== Katkestused =====+Interrupts in AVR can be caused by counters, communication interfaces, analog-to-digital converters, comparators,​ special input-output pins and several other functions, depending on the controller. Any interrupt can be allowed or disallowed by the unit that generates it. Regardless of the interrupt being allowed or disallowed, there is a 1-bit field (interrupt flag) in the corresponding unit of the controller, which is marked as true when the interrupt condition is fulfilled. If the interrupt flag is changed to true and the interrupt is allowed, the controller starts to execute the code specified for this interrupt.
  
-Katkestuse (inglise keeles //interrupt//) saavad ​AVR-il tekitada loenduridandmesideliidesed,​ analoog-digitaalmuundur,​ komparaator,​ spetsiaalsed sisend-väljundviigud ja mitmed muud funktsioonid,​ olenevalt kontrolleristIgat katkestust saab lubada või keelata seda genereerivas üksusesOlenemata katkestuse lubamisest või mitteon iga katkestuse jaoks vastavas kontrolleriüksuses 1-bitine andmeväli (lipuke, inglise keeles //interrupt ​flag//), mis märgitakse katkestust põhjustava sündmuse toimumisel tõeseksKui toimub nimetatud andmevälja muutumine ja katkestus on lubatud, hakkab kontroller täitma koodimis oli katkestuse toimumisel ette nähtud.+Every interrupt ​in the AVR microcontroller is tied to a specific event. Each event has a flag bit in the status registerwhich marks the occurring of the eventEvents are also tied to interrupt mask registers and the corresponding bitsIf the event'​s interrupt bit is left unmasked and an event occursthe processor halts executing the current program for a few duty-cycles and begins executing the interrupt ​programAfter the interrupt program has been executedthe processor resumes executing the paused main program.
  
-AVR mikrokontrolleris on iga katkestus seotud kindla sündmusega. Igal sündmusel on olekuregistris lipubitt, mis tähistab sündmuse juhtumist. Lisaks on sündmustega seotud katkestuste maskeerimise registrid ja vastavad bitid. Kui sündmuse katkestuse bitt on maskeerimata ja tekib sündmus, jätab protsessor mõne(kümne) töötakti jooksul käimasoleva programmi täitmise pooleli ning alustab katkestuse programmi täitmist. Pärast katkestuse programmi täitmist jätkab protsessor poolelijäänud programmi täitmist. 
  
-<box 100% round #​EEEEEE|Näide>​ 
  
-Katkestuste kasutamiseks ​AVR LibC teegiga tuleb kasutusele võtta ​//​interrupt.h// ​failKatkestusel täitmisele minev programmikood lisatakse pärast ​"​ISR"​-i nimelist võtmesõna. "​ISR" ​järele sulgudesse kirjutatakse katkestuse nimi. C-keele koodinäide:+To use interrupts with the AVR LibC library, it is necessary to include ​//​interrupt.h//​. ​The code that gets executed upon interrupt is written after the "​ISR" ​keywordThe text between the brackets after "​ISR" ​is the name of the interruptThe following is a language example:
  
-<code c> + 
-#​include ​<​avr/​interrupt.h>​+#​include ​
  
 ISR(XXX_vect) ISR(XXX_vect)
 { {
- // Tee midagi+ // Do something
 } }
-</​code>​ 
  
-</​box>​ 
  
-Globaalne, kõigi katkestuste toimumise lubamine, määratakse ära juht- ja olekuregistris SREG. Võimaluse kõiki katkestusi keelata või lubada tingib andmete kaitse vajadus. Kuna katkestused katkestavad käimasoleva programmi täitmise, võivad nad segada või rikkuda andmeid, mida põhiprogramm katkestamise hetkel kasutas. Sellist olukorda saab vältida kõikide katkestuste keelamisega enne tundlike andmetega tegelemist. Globaalne katkestuste keelamine on lihtne, kui seda saab teha ühe registri (SREG) muutmisega. Pärast kriitilise programmiosa lõppu saab katkestused uuesti lubada ja kõik katkestused,​ mille lipuke vahepeal ära märgiti, lähevad täitmisele. 
  
-~~PB~~ 
  
-<box 100% round #​EEEEEE|Näide>​+Global allowing of all interrupts is configured from the control and status register SREG. The option to allow or disallow all interrupts at once is there to help protect data. Since interrupts disrupt the execution of the main program, some data used by the main program may be disturbed or corrupted in the process. Situations like this can be avoided by simply disallowing all interrupts before processing such delicate data. Disallowing interrupts globally is easy, if it can be done by changing only one register (SREG). After the critical part of the program has been executed, the interrupts can easily be allowed again and all the interrupts that would have fired in the meantime are executed.
  
-Oletame, et programmis on kasutusel 16-bitine muutuja, mille väärtust muudab nii põhiprogramm kui ka katkestuse programmilõik,​ ja selle muutuja väärtus omistatakse hiljem teisele muutujale:+<​pagebreak>​
  
-<code c> 
-#include <​avr/​interrupt.h>​ 
  
-// Globaalsed ​16-bitised muutujad ​ja y+ 
 +Let's suppose there is a 16-bit variable in use in the program, which is changed by both the main program and the interrupt program and the value of this variable is later given to another variable: 
 + 
 + 
 +#include  
 + 
 +// Global ​16-bit variables ​and y
 unsigned short x, y; unsigned short x, y;
  
-// Suvaline katkestus, mis muudab ​väärtuse+// A random interrupt that changes the value of x
 ISR(XXX_vect) ISR(XXX_vect)
 { {
Rida 919: Rida 902:
 int main() int main()
 { {
- // Muutujale ​väärtuse omistamine+ // Give a value to x
  x = 0x1111;  x = 0x1111;
  
- // Globaalne katkestuste lubamine+ // Allow interrupts globally
  sei();  sei();
  
- // x väärtuse muutujasse ​laadimine+ // Give the value of to y
  y = x;   y = x;
 } }
-</​code>​ 
  
-Programm on väga lihtne - algul omistatakse muutujale x väärtus 0x1111 ja hiljem selle väärtus omakorda muutujale y. Kui vahepeal tekib katkestus, saab x-i väärtuseks 0x3333. Loogikareeglite järgi saab muutujal y programmi lõpus olla kaks võimalikku väärtust, kuid 8-bitise AVR peal on ka kolmas võimalus. Nimelt, 8-bitise arhitektuuriga toimub 16-bitiste andmete liigutamine 2 takti jooksul ja vahepeal tekkiv katkestus võib andmete ühtsust rikkuda. Niisiis võib peale 0x1111 ja 0x3333 ​ tekkida ka väärtus 0x3311. Et sellist asja ei juhtuks, tuleks katkestused enne operatsioone,​ mis toimuvad pikemalt kui 1 takti jooksul, ajutiselt keelata. 
  
-Toodud näites muutujale ​muutuja ​väärtuse omistamine ohutul meetodil:+The program itself is very simple - first, variable x is given a value of 0x1111 and later, its value is given to variable ​y. If an interrupt occurs between those two operations, ​gets a value of 0x3333. By logic, variable y can have two possible values by the end of the program, but on an 8-bit AVR there is also a third option. This is because 8-bit architecture needs 2 cycles to move 16-bit data and therefore a badly-timed interrupt can corrupt the integrity of the data. Consequently,​ y can have a value of 0x1111 or 0x3333, but it can also have a value of 0x3311 at the end of the program. To avoid getting the third, unwanted value, all interrupts should be temporarily disallowed before performing operations that take more than 1 cycle.
  
-<code c> +In the following example, the value of x is given to y using a safe method: 
- // Globaalne katkestuste keelamine+ 
 + 
 + // Disallow interrupts globally
  cli();  cli();
  
- // Laadimine+ // Give the value of x to y
  y = x;  y = x;
  
- // Globaalne katkestuste uuesti lubamine+ // Re-allow all interrupts again
  sei();  sei();
-</​code>​ 
  
-</​box>​ 
-===== Digitaalsed sisendid-väljundid ===== 
  
-Kõik AVR siinid on loetavad ja kirjutatavad,​ kui neid kasutada tavalises loogilises sisend-väljundrežiimis (inglise keeles //​input/​output//,​ ehk //I/O//). AVR siinid on nimetatud suurte ladina tähestiku algustähtedega A, B, C, jne. Mõnel AVR-il võib aga siin A puududa, kuigi siin B on olemas. Iga siin on 8-bitine ja iga biti jaoks on enamasti kontrolleri kestast välja toodud eraldi viik. Viikusid loendatakse arvudega alates nullist. Siini mõlema kasutussuuna jaoks on olemas kaks eraldi registrit. Lisaks on olemas iga siini kohta register siini reaalse toimimissuuna määramiseks,​ milles biti väärtus 1 näitab viigu kasutamist väljundina ja 0 sisendina. Kokku on iga siini kohta kolm registrit: 
  
-  ​* PORT - siini füüsilise väljundoleku määramiseks+===== Digital Inputs/​Outputs ===== 
-  * PIN - siini füüsilise sisendoleku lugemiseks+ 
-  * DDR - siini füüsilise suuna määramiseks.+All the buses on an AVR are both readable and writable, if they are used in the default logical input/​output (I/O) mode. AVR buses are named as letters from the beginning of the Latin alphabet: A, B, C etc. Some AVRs might not have bus A, though, if bus B exists. Each bus is 8-bit and each bit usually has its own pin on the controller. Pins are counted with numbers starting from zero. For both directions on the bus, there are two separate registers. In addition, there is a register to decide the real direction of the bus, where a bit value of 1 marks the bus as output and 0 as input. Altogether, each bus has three registers:​ 
 + 
 +  ​* PORT - for setting the output value of the bus
 +  * PIN - for reading the input on the bus
 +  * DDR - for setting the direction of the bus. 
 + 
  
-<box 100% round #​EEEEEE|Näide>​+Task: make pins 0-3 on bus B inputs, pins 4-7 outputs, set pin 5 high and read the values of pins 0-3 to a variable. The C code for it looks like this:
  
-Vaja on siini B viigud 0-3 teha sisenditeks,​ viigud 4-7 väljunditeks,​ seada 5. viik kõrgeks ja lugeda 0-3 viigu väärtus muutujasse. C-keele programmi kood on järgnev: 
  
-<code c> +#​include ​
-#​include ​<​avr/​io.h>​+
  
 int main() int main()
Rida 965: Rida 948:
  unsigned char x;  unsigned char x;
  
- // Viigud ​0-3 sisendiks, 4-7 väljundiks+ // Pins 0-3 as inputs, 4-7 as outputs
  DDRB = 0xF0;  DDRB = 0xF0;
  
- // Viienda viigu kõrgeks seadmine + // Set pin five as high 
- PORTB |= (1 << PIN5);+ PORTB |= (1  
 +===== External Interrupts =====
  
- // 0-3 sisendviigu väärtuse lugemine +External interrups are one of the most simple peripheral functions. Typically AVRs have 1 to 8 special pins, which are used to cause interrupts in the program when their logical value changes or they are at a certain state. Since this function is usually used to monitor external logical signals, these pins are called external interrupt pins.
- x = PINB & 0x0F; +
-+
-</​code>​+
  
-</​box>​+To use an external interrupt, the pin has to be configured as a standard IO input (it can also be used as an output, but in this case the interrupt can only be created by the controller itself). It is necessary to allow receiving interrupts and specify the condition that causes the interrupt to fire in the external interrupt configuration register. There are four possible conditions:
  
-Toodud näites on sisendeid kasutatud Hi-Z ehk kõrge impendatsiga ​(inglise keeles //high impedance//režiimis. Põhimõtteliselt on tegemist sisendiga, mis ei koorma peaaegu üldse signaaliallikat. Seda režiimi võib vaja minna, kui viiku kasutatakse andmesiinina. Kui viik on kasutusel nupu, lüliti või muu maad ning sisendit kokku ühendavas lahenduses, siis tasub sisendis kasutada //pull-up// takistitSelleks tuleb sisendrežiimis seada kõrgeks vastava viigu väljundbitt ​tulemusena lülitub toitepinge ja sisendi vahele takisti, mis hoiab sisendi pingenivood kõrgel, kui miski seda just alla ei tõmba. //Pull-up// takisti eesmärk on ära hoida sisendi "​ujumine"​ (inglise keeles //​floating//​) staatilise elektri ja muude häirete tõttu. Pärast kontrolleri käivitumist on kõik IO siinid vaikimisi kõrge impedantsiga sisendrežiimis.+  * Logical zero (voltage of 0V) 
 +  * Change in the logical value 
 +  * Descending front logical change from one to zero. 
 +  * Rising front logical change from zero to one.
  
-Enamasti on IO siinil olevaid viike peale loogiliste ühenduste kasutatud ka muu perifeeria tarbeks. Kui on soov kasutada viigu alternatiivfunktsiooni,​ tuleks tutvuda AVR-i andmelehega,​ kus on öeldud, mis režiimis peab IO viik olema. Näiteks ADC kanali sisendina kasutamiseks peaks viik olema sisendrežiimis ja PWM signaali genereerimiseks väljundrežiimis. Mõned perifeeriamoodulid määravad aga ise IO viigu režiimi. 
-===== Välised katkestused ===== 
  
-Välised katkestused (inglise keeles //​external ​interrupt//) on ühed lihtsamad perifeeria funktsioonidAVR-idel on tavaliselt 1 kuni 8 spetsiaalset viiku, mille loogilise väärtuse muutumisel või kindlal olekul tekitatakse programmis katkestus. Kuna enamasti kasutatakse seda funktsiooni kontrolleriväliste loogikasignaalide jälgimiseks,​ siis nimetataksegi vastavaid viike välise katkestuse viikudeks.+When the mode is set to logical zero, the interrupt ​will fire continuously as long as the pin has a value of zeroDuring this period the execution of the main program is stopped.
  
-Välise katkestuse kasutamiseks tuleks viik seadistada tavalise IO sisendrežiimi (võib ka väljundrežiimis kasutadaaga siis saab katkestust tekitada vaid kontroller ise)Välise katkestuse seadistusregistrites tuleb ära märkida katkestuste tekitamise lubamine ja tingimusmille peale seda tehaVõimalikke tekitajaid ​on neli:+Grouped by principlethere are two types of interrupts: synchronized to the controller'​s clock and asynchronousSynchronized interrupts work by remembering the values of the inputswhich means that the changes in logical values are found by comparing values read during two different clock cyclesIf the logical changes in the signal happen faster than the controller'​s duty-cycle, the interrupts either fire incorrectly or are skipped altogether. Asynchronous interrupts do not depend ​on the controller'​s clock and enable detecting faster changes in the external signal as well - the logical level must still be constant for at least 50 ns. ATmega128 has 4 synchronized and 4 asynchronous external interrupts.
  
-  * Loogiline null (pinge on 0V) +<​pagebreak>​
-  * Loogilise väärtuse muutus +
-  * Langev front - loogiline muutus ühest nulli. +
-  * Tõusev front - loogiline muutus nullist ühte.+
  
-Katkestuse tekitamiseks loogilise nulli valimisel tekitatakse katkestust järjest senikaua, kuni viigu väärtus on null. Põhiprogrammi töö on samal ajal peatatud. 
  
-Lähtudes tööpõhimõttelt,​ on väliseid katkestusi kahte liiki: kontrolleri taktiga sünkroniseeritud ja asünkroonsed. Sünkroniseeritud katkestused toimivad sisendite väärtuse meelespidamise teel, mis tähendab, et loogilised muutused leitakse kahel erineval taktil saadud väärtuste võrdlemise teel. Kui välise signaali loogilised muutused toimuvad kiiremini, kui käib töötakt, siis katkestused,​ kas ei teki õigesti või jäävad üldse vahele. Asünkroonsed katkestused ei sõltu kontrolleri taktist ja võimaldavad tuvastada ka kiiremini muutuvat välist signaali - loogilist nivood peab signaal hoidma vähemalt 50 ns. ATmega128-l on 4 sünkroniseeritud ja 4 asünkroonset välist katkestust. 
  
-~~PB~~+Task: Make ATmega128 pin number 9 (pin 7 on bus E) fire an interrupt if its value is changed. This pin corresponds to the INT7 external interrupt, which is synchronous.
  
-<box 100% round #​EEEEEE|Näide>​ 
  
-Vaja on panna ATmega128 viik number 9 ehk siini E viik 7 tekitama katkestust, kui selle väärtus muutub. Sellele viigule vastab väline katkestus INT7, mis on sünkroonne.+#​include ​
  
-<code c> +// The code of the external ​interrupt
-#include <avr/interrupt.h> +
- +
-// Välise katkestuse programm+
 ISR(INT7_vect) ISR(INT7_vect)
 { {
- // Tee midagi+ // Do something
 } }
  
 int main() int main()
 { {
- // Siini viigu muutmine sisendiks biti 7 nullimise teel + // Change pin 7 on bus to an input by changing bit to zero 
- DDRE &= ~(1 << PIN7);+ DDRE &= ~(1  
 +===== Analog-to-digital Converter =====
  
- // Siini E viigule 7 pull-up takisti määramine sisendi ujumise vastu +Analog-to-digital converter ​(ADC) transforms an analog voltage value to a digital value. The allowed voltage range on an ADC input of an AVR microcontroller is 0 to 5.5 V. The size of the digital value is 10 bits, but its precision is ±2 units. The error may be even larger, if the microcontroller'​s supply voltage is not protected from interference. AVR has a separate voltage supply and comparison voltage pin for ADC. The separate supply voltage helps to cut down the interference and it may not differ more than 0.3 V from the main supply voltage. Comparison voltage defines the maximum digital value. For example, if the comparison voltage is 3 V then an input with the same voltage will read as 210 - (1023).
- PORTE |= (1 << PIN7);+
  
- // Väliste katkestuste seaderegistris katkestuse 7 +AVR ADC works on the principal of successive approximation. In short, the measured voltage is compared to specific voltage levels and the results are reported as a bit array. This method is relatively slow, as each bit in the final result is calculated separately. AVR spends 13 clock cycles for each measuring, except the first (on start-up), which takes 25 cycles. These cycles are not the controller'​s duty cycles though, but instead special cycles allocated to the ADC unit by the frequency divider. The ADC frequency should be 50-200 kHz to achieve maximum precision, on higher frequencies the precision fades. In some cases it is more important to get a large number of readings instead of maximum precision, in which case using a larger frequency is totally justified. According to AVR documentation,​ one measuring takes 13-260 µs.
- // tekitajaks loogilise muutuse määramine +
- EICRB = (1 << ISC70)+
- +
- // Välise katkestuse 7 lubamine +
- EIMSK |= (1 << INT7); +
- +
- // Globaalne katkestuste lubamine +
- sei(); +
- +
- // Lõputu programmitsükkel +
- while (1) continue; +
-+
-</​code>​+
  
-</​box>​+The measured value can be read as an 8- or 10-bit value. Since AVR itself is an 8-bit device, it has two 8-bit registers for storing the ADC values. It is possible to specify in the settings whether the first two or the last two bits go to a separate register. If the two younger bits, which characterize the result less, are separated, the result can be read as an 8-bit value - a combination like that is called a left-aligned result. The other combination,​ where both registers are read and the value is in 10-bit format, is called a right-aligned result.
  
-Lisaks üksikute viikude tekitatavatele katkestustele on suurematel ​AVR-idel võimalik kasutada ka tervete gruppide viikude loogiliste väärtuste muutuste katkestusiNeid katkestusi nimetatakse lihtsalt viigu muutuse katkestusteks ​(inglise keeles //pin change interrupt//​)Need rakenduvad siiskui vähemalt ühe viigu väärtus grupis muutub. +A typical ​AVR has 8 analog voltage input channels, ATtiny series have only a few, some ATmega devices have 16, but there is always only one converter. To make it possible to use different inputs, the device has a built-in multiplexerThe input of the multiplexer is definable using a special register. The ADC unit has a few more properties: using the processor'​s sleep mode for converting to reduce the interference and the option to use an internal fixed comparison voltage ​(usually 2.65 Vin some models 1 V).
-===== Analoog-digitaalmuundur =====+
  
-Analoog-digitaalmuundur (inglise keeles //analog to digital converter//,​ lühend ADC) muundab analoogpinge väärtuse digitaalseks väärtuseks. AVR-i ADC analoogpinge sisend on lubatud 0-5,5 V piires. Digitaalne väärtus on 10-bitine, kuid selle täpsus on ±2 ühikut. Viga võib veelgi kasvada, kui kiibi toitepinget häirete eest ei kaitsta. ADC jaoks on AVR-il eraldi toite ja võrdluspinge viik. Eraldi toide on mürakindluse pärast ja see ei tohi kiibi toitepingest erineda rohkem kui 0,3 V. Võrdluspinge määrab maksimaalse digitaalse väärtuse. Ehk kui võrdluspinge on 3 V, siis sama pingega sisend annab väärtuseks 2<sup>10</​sup>​ - 1 ehk 1023.+<pagebreak>
  
-AVR ADC töötab võrdlusmeetodil (inglise keeles //​successive approximation//​). Lühidalt öeldes toimub mõõdetava pinge võrdlemine kindlate nivoopingetega ja tulemuste esitamine tõeväärtuste-,​ ehk bitijadana. See meetod on suhteliselt aeganõudev,​ sest iga biti leidmine lõppväärtuses toimub eraldi. AVR-il kulub töö ajal 13 takti ühe mõõtmise tegemiseks ja 25 takti kõige esimesel mõõtmisel (käivitusel). Need taktid pole aga kontrolleri töötaktid,​ vaid spetsiaalselt ADC üksuse jaoks sagedusjaguriga saadud taktid. Maksimaalse täpsuse saamiseks peaks ADC takt olema 50-200 kHz. Kõrgemal taktil kaob täpsus. Vahel on ka mõõtmiste suur arv olulisem kui täpsus ja siis on põhjendatud suurema sageduse kasutamine. Ühele mõõtmisele kuluvaks ajaks on AVR dokumentatsioonis antud 13-260 µs. 
  
-Mõõtetulemust saab kasutaja lugeda 8- ja 10-bitisena. Kuna AVR on 8-bitine, siis ADC mõõteväärtuste jaoks on sel kaks 8-bitist registrit. Seadistustes saab määrata, kas 10-bitisest väärtusest 2 esimest või 2 viimast bitti lähevad eraldi registrisse. Kui eraldatakse 2 noorimat ehk tulemust vähem iseloomustavat bitti, saab mõõtetulemuse 8-bitisena lugeda - sellist kombinatsiooni nimetatakse vasak-asetusega mõõtetulemuseks (//left align//). Teistpidist kombinatsiooni,​ kus kaht tulemusregistrit lugedes tekib 10-bitine arv, nimetatakse parem-asetusega mõõtetulemuseks (//right align//). 
  
-Mõõdetavaid analoogpinge sisendkanaleid on AVR-idel tavaliselt ​8, ATtiny seerial üksikud, mõnel ATmega seeria kiibil 16, kuid muundureid on siiski üks. Erinevate sisendite kasutamiseks on kiibis multiplekser. Multiplekseri sisend on spetsiaalse registriga määratav. ADC üksusel on veel mõned omadused: muundamine protsessori magamisrežiimis müra vähendamiseks ja sisemise fikseeritud võrdluspinge (2,56 V, mõnel ka 1 V) kasutamise võimalus.+Task: measure the voltage in ADC channel 3 of an ATmega128. The voltage is in range of 0-5 V and the result should be at 8-bit precision.
  
-~~PB~~ 
  
-<box 100% round #​EEEEEE|Näide>​ +#​include ​
- +
-Vaja on mõõta ATmega128 ADC kanali 3 pinget vahemikus 0-5 V 8-bitise täpsusega. +
- +
-<code c> +
-#​include ​<​avr/​io.h>​+
  
 int main() int main()
Rida 1060: Rida 1011:
  unsigned char result;  unsigned char result;
  
- // Võrdluspingeks ​AREF viigu valimine + // Choose ​AREF pin for the comparison voltage 
- //   (eeldatavasti on see ühendatud ​+5V toiteahelasse+ //   (it is assumed AREF is connected to the +5V supply
- // Multiplekseriga kanali ​valimine + // Choose channel ​in the multiplexer 
- // Tulemus on vasak-asetusega + // Left align the result 
- ADMUX = (1 << REFS0) | (1 << ADLAR) | (3);+ ADMUX = (1  
 +/​home/​www/​roboticlab/​homelab_data/​pages/​en/​avr/​dac.txt--- 
 + ​MISSING PAGE --- 
 +===== Counters/​Timers =====
  
- // ADC üksuse käivitamine, +Counterswhich in some sense can be called timers, are one of the most important sub-functions of a microcontroller. These enable to precisely time processes, generate signals and count events. A counter converts the number of input cycles to a binary value using an array of triggers. The maximum number of counted cycles depends on the length of this array, and this is marked by the length of the binary code. AVR has 8- and 16-bit counters. If a timer has reached its maximum value (255 in 8-bit and 65535 in 16-bit counters), the next cycle will generate an overflow and the counter resets back to 0. A counter'​s clock signal can come from the clock signal of the microcontroller,​ and in this case it is possible to decrease its value using a prescaler. Some AVRs have an internal independent clock signal generator, which can be modified to run faster using a frequency multiplier. Counters also differ in application cases and work modes.
- // teisendustakti seadmine ​16 korda aeglasemaks töötaktist +
- ADCSRA = (1 << ADEN| (1 << ADPS2) | (1 << ADSC);+
  
- // Mõõtmise lõpetamise ootamine +==== Counter'​s Default Mode ====
- while (ADCSRA & (1 << ADSC)) continue;+
  
- // 8-bitise tulemuse lugemine +In the default mode, a counter does nothing more than continually count sequential numbers. Its value can, of course, be read and changed from the program at any time. The only additional function in the default mode is to cause an interrupt on counter overflow. The default mode is typically used to execute a section of the program at certain intervals.
- result = ADCH; +
-+
-</​code>​+
  
-</​box>​ 
-===== Loendurid/​Taimerid ===== 
  
-Loendurid (inglise keeles //​counter//​),​ teatud mõttes taimerid (inglise keeles //timer//), on mikrokontrollerite ühed oluliseimad lisafunktsioonid. Nende abil saab protsesse täpselt ajastada, signaale genereerida ja sündmusi loendada. Loenduri tööpõhimõte seisneb sisendtaktide arvu trigerite ahela abil binaarväärtuseks teisendamises. Ahela pikkusest oleneb maksimaalne loendatavate taktide arv, mida tähistatakse kahendkoodi pikkusega. AVR mikrokontrolleril on loendurid 8- ja 16-bitised. Kui loendur omab maksimaalset väärtust (8-bitiste puhul 255, 16-bitiste puhul 65535), tekib järgmise taktiga ületäitumine (inglise keeles //​overflow//​) ja loendur alustab uuesti nullist. Loenduri taktsignaal saab tulla mikrokontrolleri töötaktist ja sel juhul on võimalik selle sagedust sagedusjaguriga (inglise keeles //​prescaler//​) ka vähendada. Mõnel AVR-il on sisemine eraldiseisev taktsignaali generaator, mille sagedust saab sageduskordistiga tõsta. Loendurid erinevad ka rakendusvõimaluste ja töörežiimide poolest. 
  
-=== Loenduri normaalrežiim ===+Task: Make an 8 MHz ATmega128 fire an interrupt every 10 ms (frequency 100 Hz). For this task, the 8-bit counter 0 is suitable.
  
-Normaalrežiimis ei täida loendur muud funktsiooni kui pidevat järestikulist arvude loendamist. Loenduri väärtust saab igal hetkel programmis muidugi ka lugeda ja muuta. Ainuke lisavõimalus normaalrežiimis on katkestuse tekitamine loenduri ületäitumisel. Normaalrežiimi kasutatakse tavaliselt mingi programmilõigu täitmiseks kindlate ajaintervallide järel. 
  
-<box 100% round #​EEEEEE|Näide>​ +#​include ​
- +
-Vaja on 8 MHz taktsagedusel töötav ATmega128 10 ms (sagedus 100 Hz) ajavahemiku järel katkestust tekitama panna. Ülesandeks sobib 8-bitine loendur 0. +
- +
-<code c> +
-#​include ​<​avr/​interrupt.h>​+
  
 ISR(TIMER0_OVF_vect) ISR(TIMER0_OVF_vect)
 { {
- // Loendurile sellise väärtuse omistamine, + // Give the counter such a value 
- // et järgmine ületäitumine tekiks ​10 ms pärast+ // that the next overflow occurs in 10 ms. 
- // Valem: 256 - 8 MHz / 1024 / 100 Hz = 177,785 = ~178+ // Formula: 256 - 8 MHz / 1024 / 100 Hz = 177,785 = ~178
  TCNT0 = 178;  TCNT0 = 178;
 } }
Rida 1104: Rida 1043:
 int main() int main()
 { {
- // Et esimene ületäitumise katkestus tekiks ​10 ms pärast+ // To make the first overflow interrupt fire in 10 ms as well
- // tuleb ka siinkohal loendur algväärtustada.+ // the counter needs to be initialized here.
  TCNT0 = 178;  TCNT0 = 178;
  
- // Sagedusjaguri teguriks ​1024+ // Prescaler value 1024
  TCCR0 = 0x07;  TCCR0 = 0x07;
  
- // Loenduri täitumise katkestuse lubamine + // Allow overflow interrupts 
- TIMSK |= (1 << TOIE0);+ TIMSK |= (1  
 +===== USART =====
  
- // Globaalne katkestuste lubamine +USART is a universal synchronous serial interface; UART, is a simplified version - universal asynchronous serial interface. The difference being that USART also uses a clock signal line to synchronize data, but UART only uses data lines. AVR's USART allows the use of full duplex communication,​ 5- to 9-bit data words (8-bit word = byte), 1 or 2 stop bits, three parity modes and a wide variety of baud rates. AVR microcontrollers typically have up to 2 USART interfaces, although some may have no USART. Data transmission is performed one word at a time - AVR converts the word it gets from the user to bits on the hardware level and transmits it independently and vice versa. The user controls USART by reading and writing configuration,​ status and data registers.
- sei();+
  
- // Lõputu programmitsükkel +Every configuration option has corresponding registers, which are quite easy to configure using the datasheet. The baud rate, though, is a bit more difficult to set. The clock signal for data transmission is generated from the controller'​s own clock, and the user can specify a number from to 4096, by which the controller'​s clock cycle is divided. The result is additionally divided by 2, 8 or 16, depending on the mode. The problem is, not all clock frequencies can be divided so that the result is a standard baud rate. With some frequencies,​ the baud rate can differ from the standard by up to 10%. AVR datasheets contain tables with typical clock frequencies,​ baud rates, the needed multiplier to reach that baud rate and the possible calculation error.
- while (1) continue; +
-+
-</​code>​+
  
-Näites toodud loendurile omistatava väärtusega siiski täpselt 10 ms järel katkestust ei tekitatasest vaja oleks loendurile omistada komakohaga väärtus, kuid see pole võimalikEt täpset katkestuse intervalli saadatuleb nii sagedusjaguri tegur kui ka loendurile täitumisel omistatav väärtus valida nii, et taktsagedus jaguks täpseltParaku pole see alati võimalikja eriti just 8-bitise loenduri puhul, sest selle väärtuste skaala on üsna väike. Täpsema ja suurema intervalli tekitamiseks saab kasutada 16-bitist loendurit.+Since data transmission takes place independently of the processor and much slowerit is necessary to confirm that the interface is ready for the next word before transmittingThis can be done by keeping an eye on the transmit buffer'​s ready bitwhich signifies if the buffer is ready to accept a new word or notThe controller starts with the ready bit enabled. As soon as a word is transmitted and the buffer is emptythe ready bit is set high.
  
-</​box>​+The arrival of a word is signified also by a special status bit. In addition to that, there are status bits to signify framing errors, parity errors and receive buffer overflows. Buffer overflow can occur when the last word is yet to be read from the buffer while a new one arrives - this is why it is always important to read the incoming words to the program as soon as possible, for example, by using an interrupt. There are three possible interrupt reasons: transmit buffer ready, transmit successful and receive successful.
  
-== Välise taktiga loendur ==+The transmit and receive buffers are physically separate registers, but share the same memory address and name. When writing to the shared register, the data is stored in the transmit buffer, and when reading from it, the data is read from the receive buffer. When using 9-bit words, the 9th bit is transmitted and read using one of the configuration registers.
  
-Loenduri taktsignaalina saab kasutada ka mikrokontrollerivälist signaali (inglise keeles //external clock source//). Selleks on AVR mikrokontrolleril Tn viik, kus n tähistab loenduri numbrit. Välist taktsignaali ja polaarsust saab valida sagedusjaguri registriga.+<​pagebreak>​
  
-== Sündmuste mõõtmine == 
  
-Kuna loendurid võimaldavad mõõta aega, on keerukamatel AVR mikrokontrolleritel võimalus riistvaraliselt mõõta ka aega, mil toimus mingi sündmus. Seda loenduri osa nimetatakse sündmuse püüdjaks (inglise keeles //input capture unit//). AVR-is on valida kahe sündmuse vahel: spetsiaalse sisendviigu või analoogkomparaatori võrdlustulemuse loogilise väärtuse muutus. Kui toimub valitud sündmus, kirjutatakse loenduri väärtus spetsiaalsesse registrisse,​ kust selle võib soovitud ajal välja lugeda. Kui sündmuse toimumise aeg on pikem kui loenduri ületäitumise aeg, tuleb tarkvaraliselt lugeda ka loenduri ületäitumisi (näiteks ületäitumise katkestusega) ja need lõpptulemusse arvestada. 
  
-<box 100% round #​EEEEEE|Näide>​+Task: Configure an 8 MHz ATmega128'​s USART0 interface to transmit 8-bit words asynchronously using 9600 bps baud rate, 1 stop bit and no parity bits. Send the symbol "​X"​.
  
-Vaja on 8 MHz taktsagedusel töötava ATmega128-ga mõõta välise 122 Hz - 100 kHz loogilise nelinurksignaali sagedust 1 Hz täpsusega. Programm on tehtud 16-bitise loendur 1 sündmuste püüdjaga. 
  
-<code c> +#​include ​
-#​include ​<​avr/​interrupt.h>​ +
- +
-unsigned long frequency;​ +
- +
-// Sündmuse toimumise katkestus +
-ISR(TIMER1_CAPT_vect) +
-+
- // Loenduri nullimine +
- TCNT1 = 0; +
- +
- // Tulemus on ainult siis arvestatav, kui +
- // loendur pole vahepeal üle täitunud +
- if (!(TIFR & (1 << TOV1))) +
-+
- // Sageduse arvutamine perioodi pöördväärtusest. +
- frequency = (unsigned long)8000000 / +
-             (unsigned long)ICR1;​ +
-+
- else +
-+
- // Sagedus on vähem kui 122 Hz +
- frequency = 0; +
- +
- // Loenduri ületäitumise lipukese nullimine +
- TIFR &= ~(1 << TOV1); +
-+
-}+
  
 int main() int main()
 { {
- // Tõusva frondi registreerimine,​ sagedusjaguri tegur + // Set baud rate to 9600 bps. Formula: 
- TCCR1B ​(<< ICES1) | (1 << CS10);+ //   ​multiplier = clock frequency / 16 / baud rate - 
 + //   ​UBRR ​8000000 / 16 / 9600 - = ~51 
 + UBRR0H = 0; 
 + UBRR0L = 51;
  
- // Sündmuse toimumise katkestuse lubamine + // Allow transmitting 
- TIMSK = (1 << TICIE1);+ UCSR0B ​= (1  
 +======HomeLab Kit ======
  
- // Globaalne katkestuste lubamine +{{:​kit:​kodulaboridjarobotid.jpg?​580|}}
- sei();+
  
- // Lõputu programmitsükkel +Robotic HomeLab is an ATmega2561 microcontroller based inter-related set of modules that are contained in a portable case. Various mechatronic and robotic experiments and exercises can be carried out with Robotic HomeLab kit, ranging from a simple flashing light to a complex device construction. Robotic HomeLab is primarily intended for schools and universities,​ as it includes methodological materials and exercises with solutions in addition to hardware. Robotic HomeLab has been integrated into a web environment,​ which is aimed for students and teachers to boost interaction between each other. In short, the Robotic HomeLab kit is a mobile tools suite with the purpose of learning and practicing at home, school or workplace.
- while (1) continue; +
-+
-</​code>​+
  
-Programmis tekib välise signaali tõusva frondi ajal sündmuse katkestusKatkestuse jooksul kontrollitakseega loenduri ületäitumine pole toimunud ​see saab juhtuda, kui signaali sagedus ​on alla 122 Hz (8 MHz / 2<​sup>​16</​sup>​)ja sel juhul ei kajasta loenduri väärtus reaalset perioodiSagedus arvutatakse 32-bitiste arvudega pöördväärtusena perioodist. Esimese asjana aga nullitakse loendursest taimer töötab samal taktil mis protsessor ja iga instruktsiooni täitmine, mis toimub pärast välist sündmust, lühendab mõõdetavat perioodi ning sellest tulenevalt rikub ka mõõtetulemust. Maksimaalsele mõõdetavale sagedusele seab piiri katkestuse programmiosa tööaeg.+Robotic HomeLab kit has been developed by Tallinn University of Technology and Estonian company ITT Group in cooperation with European partner universities and Leonardo da Vinci program supportRobotic HomeLab modules are bundled into different kits. The basic suitewhich teaches simple digital input and output operations, is called Robotic HomeLab Basic kit. The Add-on kit contains a modules and components for sensormotor and communication experimentsSeveral additional modules are integrated with Robotic HomeLab kit for advanced study like RFID technologymachine vision and WiFi.
  
-</​box>​+The Robotic HomeLab Basic kit and Add-on kit modules and components can be successfully used as a robot base platform and other mechatronics control systems. Robotic HomeLab versions are constantly evolving and, therefore every now and then please check whether new exercises have been published or module updates have been released. It is also worthwhile to check the version numbers of modules, some of the exercises and examples are available in newer versions. Significant value to Robotic HomeLab is added by VirtualLab and DistanceLab. DistanceLab allows Robotic HomeLab hardware platform to be used through the web.
  
-Sündmuste püüdmist ning nende aja registreerimist saab teha ka tarkvaraliseltSaab kasutada väliseid või muid katkestusi ja nende tekkimise ajal lugeda loenduri väärtus. Riistvaraline sündmuste püüdmine on siiski mõeldud eeskätt programmist sõltumatuks töötamiseks ja suhteliselt lühiajaliste (või tihedate) sündmuste mõõtmiseks.+HomeLab webpage\\ 
 +http://home.roboticlab.eu
  
-=== Signaali genereerimine ​===+DistanceLab webpage\\ 
 +http://​distance.roboticlab.eu 
 +===== Robotic HomeLab Hardware =====
  
-Keerukamate loenduritega saab peale signaali pikkuse mõõtmise ka signaali tekitadaSelleks on loenduril väärtuse võrdlemise üksus (inglise keeles //output compare unit//) ja võrdlustulemuse väljastusüksus (inglise keeles //compare match output unit//)Võrdlusüksusesse kuuluvad registrid sama bitilaiusega kui loendur ise ja nende registrite väärtusi võrreldakse loenduri väärtusega selle töö ajal. Hetkelmil loenduri väärtus saab võrdseks võrdlusüksuse registri väärtusega,​ saab tekitada katkestuse ja spetsiaalsete väljundviikude oleku muutuseValida on võrdusmomendil viigu kõrgeks muutumisemadalaks muutumise ja ümbermuutumise vahelVäljundviigu oleku muutused tekitavadki signaali.+The modules of the Robotic HomeLab are divided into different kits, allowing one to select the best option for the needs of a student or schoolThe simplest set is the Robotic HomeLab Basic kit including the components to carry out the basic microcontroller experimentIn addition to the microcontrollerthe kit consists of a User Interface module with LCD displayTogether with the Robotic HomeLab Basic kitthe Robotic HomeLab Add-On kit can be used; this includes different types of motors and sensors together with accessories and Communication module. The Robotic HomeLab Add-On kit cannot be used separately from the Robotic HomeLab Basic kit as the microcontroller is not included in the Add-On kit. In addition the RFID and Machine Vision modules are availableThe Robotic HomeLab Basic kit together with the Robotic HomeLab Add-On kit is convenient to use and carry to home for the robotic experiments.
  
-Mõnedel signaali genereerimise režiimidel on määratav ka loenduri suurim väärtus - loenduri füüsiline suurus jääb küll samaks, kuid mängus on võrdlusregister,​ mille väärtust ületades loendur nullitakse. Seda võimalust kasutades saab eespool toodud ülesandeid täpse ajalise katkestuse tekitamise kohta lahendada, kuid mõeldud on see pigem signaali perioodi muutmiseks. Lisaks sellele on võimalik loendurit seadistada režiimi, kus see toimib nii juurde- kui mahalugemisel.+==== Robotic HomeLab generations ====
  
-Loendurid ja nende abil genereeritavate signaalide režiimid on ühed keerulisemad perifeeriamoodulid AVR-ilKõigist neist kirjutamine läheks pikaks ja enamasti pole nende kasutamisel kõike detailselt teadaSeetõttu on järgnevalt kirjeldatud vaid üht levinuimat PWM signaali robootikas. Ülejäänut saab juba AVR dokumentatsioonist järgi uurida.+^  [[en:​hardware:​homelab:​gen3|Robotic HomeLab III generation]] ​ ^   
 +|  [[en:​hardware:​homelab:​gen3|{{:​kit:​baaskomplekt_3.png?​200}}]] ​ | 
 +^  [[en:​hardware:​homelab:​gen2|Robotic HomeLab II generation]] ​ ^ 
 +|  [[en:​hardware:​homelab:​gen2|{{:​kit:​basic_kit_v5.png?​150}}]] ​ | 
 +^  [[en:​hardware:​homelab:​gen1|Robotic HomeLab I generation]] ​ ^  
 +|  [[en:​hardware:​homelab:​gen1|{{:​kit:​basic_kit.jpg?​250}}]] ​ | 
  
-== Pulsilaius-modulatsioon == 
  
-Pulsilaius-modulatsioon (inglise keeles //pulse width modulation//,​ lühend PWM) on signaali tüüp, mille sagedus ja ühtlasi ka perioodid on konstantne (enamasti), kuid mõlema poolperioodi pikkus on muutuv. PWM signaale kasutatakse elektromehaaniliste,​ optiliste jms. seadmete juhtimiseks. Näiteks mudelismist tuntud servomootorite PWM signaal on 50 Hz sagedusega ja 1 ms kuni 2 ms pikkuse kõrge poolperioodiga. 
  
-<box 100% round #​EEEEEE|Näide>​+\\ 
 +\\
  
-Vaja on 8 MHz taktsagedusel töötava ATmega128-ga genereerida kaks kiirusreguleeritavat servomootori signaali. Viiguga PB5 (OC1A) tuleb genereerida pulsipikkus 1 ms ja viiguga PB6 (OC1B) pulsipikkus 2 ms. 
  
-<code c> +==== Robotic HomeLab III generation ====
-#include <​avr/​io.h>​+
  
-int main() +The modules of the Robotic HomeLab are divided into different kits, allowing one to select the best option for the needs of a student or school. The simplest set is the Robotic HomeLab Basic kit including the components to carry out the basic microcontroller experiment. In addition to the microcontroller,​ the kit consists of a User Inteface module with LCD display and Combo module. Together with the Robotic HomeLab Basic kit, the Robotic HomeLab Add-On kit can be usedthis includes different types of motors and sensors together with accessories. The Robotic HomeLab Add-On kit cannot be used separately from the Robotic HomeLab Basic kit as the microcontroller is not included. In addition the RFID and Machine Vision modules are available. The Robotic HomeLab Basic kit together with the Robotic HomeLab Add-On kit are convenient to use and carry to home for the robotic experiments.
-+
- // Viigud väljundiks +
- DDRB |= (1 << PIN5) | (1 << PIN6);+
  
- // Väljundid A ja B võrdusmomendil madalaks, +=== Robotic HomeLab Basic kit === 
- // "Fast PWM" režiim, sagedusjagur 8 +{{  :​kit:​baaskomplekt_3.png?​450|Robotic HomeLab Basic kit}}
- TCCR1A ​(1 << COM1A1) | (1 << COM1B1) | (1 << WGM11); +
- TCCR1B = (1 << WGM13) | (1 << WGM12) ​(1 << CS11);+
  
- // Suurim loenduri väärtus. Valem: +  * AVR ATxmega128A1U development board with SD card reader 
- //   TOP = 8 MHz / 8 / 50 Hz +  * User interface module 
- ICR1 = 20000;+    * 3 x LED (green, yellow and red) 
 +    * 3 x buttons 
 +    * 7-segment display 
 +    * Graphical LCD (128x160 px, 24-bit RGB) 
 +    * Speaker 
 +    * Potentiometer (11 bit  - 2048) 
 +    * Light dependent resistor 
 +    * Thermistor 
 +    * Microphone 
 +  * Combo module 
 +    * 4 x H-bridge DC motor drivers 
 +    * 1 x unipolar stepper motor driver 
 +    * 4 x Servo Encoder  
 +    * Connections for sensors 
 +    * Wireless module connection with Bluetooth module 
 +  * USB cable 
 +  * Micro SD card with USB adapter 
 +  * Example exercises with C-source code (examples) 
 +  * Software library 
 +  * Power supply 
 +  * Multimeter 
 +  * Software for programming in Assembler and C language 
 +  * Portable case 
 +<​pagebreak>​
  
- // Esimese mootori poolperiood 1 ms, teisel 2 ms +=== Robotic HomeLab Add-On kit === 
- OCR1A ​1000; +{{ :​kit:​lisakomplekt_3.jpg?​300|Robotic HomeLab Add-On kit}}
- OCR1B ​2000;+
  
- // Lõputu programmitsükkel +== Motors ==  
- while (1continue; +  * 2 x DC motor(w/ gearbox, wheel and coder
-} +  * RC mini servomotor 
-</​code>​+  * Stepper motor (unipolar)
  
-</​box>​ +== Sensors ​==
-===== USART =====+
  
-USART on universaalne sünkroonne jadaliides, UART aga selle lihtsustatud variant - universaalne asünkroonne jadaliides. Vahe seisneb selles, et USART kasutab peale andmeliinide ka taktsignaali liini, millega andmeid sünkroniseeritakse,​ UART aga mitte. AVR-i USART võimaldab täisduplekssidet,​ 5- kuni 9-bitiseid andmesõnu ​(8 biti puhul sõna = bait), 1 või 2 stoppbitti, kolme paarsuse režiimi ja laia boodikiiruste valikut. AVR mikrokontrolleritel on üldiselt kuni 2 USART liidest, kuid mõnel puudub USART üldse. Andmete edastamine toimub sõna kaupa, ehk AVR teeb riistvara tasandil kasutaja edastatud sõna bittideks ja edastab selle iseseisvalt ning vastupidi. Kasutaja juhib USART tööd seade-, oleku- ja andmeregistreid kirjutades ning lugedes.+  * Ultrasonic distance sensor with cable 
 +  * Infrared distance sensor with cable 
 +  * Line following module 
 +  * Passive infrared sensor ​(motion sensor) 
 +  * Humidity and temperature sensor 
 +  * Pressure sensor 
 +  * Accelerometer
  
-Kõikide seadistuste jaoks on olemas vastavad registrid, mida on üsna lihtne andmelehe abil seadistada. Natuke keerulisem on boodikiiruse seadmine. Taktsignaal andmete edastamiseks genereeritakse töötaktist ja kasutaja saab valida teguri 1-st 4096-ni, millega töötakt läbi jagatakse. Täiendavalt jagatakse saadud taktisignaali olenevalt režiimist veel 2, 8 või 16-ga. Probleem on selles, et kõiki taktsagedusi ei saa jagada nii, et tekiks standardne boodikiirus. Mõnede mikrokontrolleri taktsageduste puhul on boodikiiruse erinevus soovitust ligikaudu 10%. AVR andmelehtedes on toodud tabelid tüüpilistest taktsagedustest,​ boodikiirustest ja nende saamiseks vajalikust jagamistegurist ning tekkida võivast veast.+== Expansion modules ==
  
-Kuna andmete edastus toimub protsessorist sõltumata ja oluliselt aeglasemalt,​ tuleb enne saatmist veenduda, et liides on valmis uut sõna edastama. Selleks tuleb jälgida saatepuhvri valmisoleku olekubitti, mis näitab, kas sinna võib saatmiseks uue sõna kirjutada või mitte. Kui mikrokontroller käivitada, on see luba vaikimisi kohe olemas. Niipea kui sõna on saadetud ja puhvrisse pole uut sõna saatmiseks kirjutatud, muudetakse saatmise õnnestumise olekubitt kõrgeks.+  * Ethernet module 
 +  * Real time clock (RTC) module
  
-Sõna saabumist tähistab samuti spetsiaalne olekubitt. Lisaks on olekubitid vastuvõtmisel tekkiva kaadri vea, paarsuse vea ja vastuvõtja puhvri ületäitumise tähistamiseks. Puhvri ületäitumine tekib näiteks siis, kui eelmist saabunud sõna pole vastuvõtu puhvrist välja loetud - seepärast ongi oluline saabuvad sõnad kiiresti programmi lugeda, kasutades selleks näiteks katkestust. Kokku on kolm võimalikku katkestuse põhjust: saatepuhvri valmisolek, saatmise õnnestumine ja vastuvõtmise õnnestumine.+== Prototyping equipment ==
  
-Muide, saatepuhver ja vastuvõtupuhver on füüsiliselt küll erinevad registrid, kuid jagavad sama mäluaadressi ja neil on ühine nimi. Ühine andmeregister toimib nii, et sellesse kirjutades jõuab sõna saatepuhvrisse ja sellest lugedes tuleb see vastuvõtupuhvrist. Veel ühe täpsustusena tuleks arvestada, et 9-bitiste andmesõnade puhul edastatakse ja loetakse üheksandat bitti hoopis ühe seaderegistri kaudu.+  * Solderless prototyping board 
 +  * 20 x jumper cables
  
-~~PB~~+<​pagebreak>​
  
-<box 100% round #​EEEEEE|Näide>​+=== Robotic HomeLab additional modules ===
  
-Seadistada 8 MHz taktsagedusel töötav ATmega128 USART0 liides boodikiirusel 9600 bps asünkroonselt edastama 8-bitiseid sõnu 1 stop-bitiga ja ilma paarsuse bititaSaata märk "​X"​.+Additional modules are not packed into the cases but can be directly connected with Robotic HomeLab Communication modulePractical examples and exercises are provided for these modules.
  
-<code c> +  * High frequency RFID module with tags 
-#include <​avr/​io.h>​+  * Machine vision module 
 +  * WiFi module 
 +  * GPS module
  
-int main() +Robotic HomeLab kits can be used in addition to experiments as a base controller for a robotic or any other mechatronics system. Robotic HomeLab versions are in constant development so check for updates. Also note the version number because some examples or exercises work with only newer versions.
-+
- // Boodi kiiruseks 9600 bps seadmineValem: +
- //   ​Jagamistegur = taktsagedus / 16 / boodi kiirus - 1 +
- //   UBRR = 8000000 / 16 / 9600 - 1 = ~51 +
- UBRR0H = 0; +
- UBRR0L = 51;+
  
- // Saatja lubamine +=== Connecting Robotic HomeLab modules ===
- UCSR0B ​(1 << TXEN0);+
  
- // Asünkroonse režiimi seadistamine,​ andmesõna pikkuseks 8 bitti +{{ :​kit:​robotic_homelab_kit_assembled.jpg?​600 ​|}}
- // 1 stop-bitt, keelatud paarsuse bitt. +
- UCSR0C = (1 << UCSZ01) ​(1 << UCSZ00);+
  
- // Ootame, kuni andmepuhver on tühi ehk eelmine sõna on saadetud +== Connection table ==
- // Selles näites ei oma see küll mõtet, sest saadetakse alles +
- // esimest märki, küll tasub seda teha rohkemate märkide korral. +
- while (!(UCSR0A & (1 << UDRE))) continue;+
  
- // Märgi kirjutamine puhvrisse, kust see ka teele saadetakse +^AVR pin^Function^Header group^Device^ ^AVR pin^Function^Header group^Device^ 
- UDR0 = '​X';​ +|PA0|ADC0|PA-PB-PF|ADC 0| |PF0|OC0A/SDA|PA-PB-PF|I/O Port| 
-  +|PA1|ADC1|PA-PB-PF|ADC 1| |PF1|OC0B/​SCL|PA-PB-PF|I/​O Port| 
- // Lõputu tsükkel +|PA2|ADC2 / DAC0|PA-PB-PF|ADC 2| |PF2|OC0C/​RXD0|PA-PB-PF| | 
- while (1) continue; +|PA3|ADC3 ​DAC1|PA-PB-PF|ADC 3| |PF3|OC0D/TXD0|PA-PB-PF| | 
-} +|PA4|ADC4|PA-PB-PF|ADC 4| |PF4|SD card SS| |SD card| 
-</code>+|PA5|ADC5|PA-PB-PF|ADC 5| |PF5|SD card MOSI| |SD card| 
 +|PA6|ADC6|PA-PB-PF|ADC 6| |PF6|SD card MISO| |SD card| 
 +|PA7|ADC7|PA-PB-PF|ADC 7| |PF7|SD card SCK| |SD card| 
 +|PB0|ADC8|PA-PB-PF|ADC 8| |PH0| |PH-PJ-PK|Button S3| 
 +|PB1|ADC9|PA-PB-PF|ADC 9| |PH1| |PH-PJ-PK|Button S2| 
 +|PB2|ADC10 / DAC0|PA-PB-PF|ADC 10| |PH2| |PH-PJ-PK|Button S1| 
 +|PB3|ADC11 / DAC1|PA-PB-PF|Speaker| |PH3| |PH-PJ-PK|LED 3| 
 +|PB4|ADC12|PA-PB-PF|Microphone| |PH4| |PH-PJ-PK|LED 2| 
 +|PB5|ADC13|PA-PB-PF|LDR| |PH5| |PH-PJ-PK|LED ​1| 
 +|PB6|ADC14|PA-PB-PF|NTC| |PH6| |PH-PJ-PK| | 
 +|PB7|ADC15|PA-PB-PF|POT| |PH7| |PH-PJ-PK| | 
 +|PC0|OC0A/SDA|PC-PD-PE|DC 1A| |PJ0| |PH-PJ-PK|Stepper 1| 
 +|PC1|OC0B/​SCL|PC-PD-PE|DC 2A| |PJ1| |PH-PJ-PK|Stepper 2| 
 +|PC2|OC0C/​RXD0|PC-PD-PE|DC 3A| |PJ2| |PH-PJ-PK|Stepper 3| 
 +|PC3|OC0D/​TXD0|PC-PD-PE|DC 4A| |PJ3| |PH-PJ-PK|Stepper 4| 
 +|PC4|OC1A/​SS|PC-PD-PE|Servo 1| |PJ4| |PH-PJ-PK|DC 1B| 
 +|PC5|OC1B/​MOSI|PC-PD-PE|Servo 2| |PJ5| |PH-PJ-PK|DC 2B| 
 +|PC6|RXD1/​MISO|PC-PD-PE|Xbee RX| |PJ6| |PH-PJ-PK|DC 3B| 
 +|PC7|TXD1/​SCK|PC-PD-PE|Xbee TX| |PJ7| |PH-PJ-PK|DC 4B| 
 +|PD0|OC0A/​SDA|PC-PD-PE|ENC 1| |PK0| |PH-PJ-PK|LCD CS| 
 +|PD1|OC0B/​SCL|PC-PD-PE|ENC 2| |PK1| |PH-PJ-PK|LCD RS| 
 +|PD2|OC0C/​RXD0|PC-PD-PE|UART RX| |PK2| |PH-PJ-PK|LCD RST| 
 +|PD3|OC0D/​TXD0|PC-PD-PE|UART TX| |PK3| |PH-PJ-PK|LCD BL| 
 +|PD4|OC1A/​SS|PC-PD-PE| | |PK4| |PH-PJ-PK|7-seg MOSI| 
 +|PD5|OC1B/​MOSI|PC-PD-PE| | |PK5| |PH-PJ-PK|7-seg SCK| 
 +|PD6|D-| |USB| |PK6| |PH-PJ-PK|7-seg LATCH| 
 +|PD7|D+| |USB| |PK7| |PH-PJ-PK|| 
 +|PE0|OC0A/​SDA|PC-PD-PE|I/​O Port| |PQ0| |PA-PB-PF|USB LED| 
 +|PE1|OC0B/​SCL|PC-PD-PE|I/​O Port| |PQ1| |PA-PB-PF|USB State| 
 +|PE2|OC0C/​RXD0|PC-PD-PE|I/​O Port| |PQ2| | |LED 0| 
 +|PE3|OC0D/​TXD0|PC-PD-PE|I/​O Port| |PQ3| | |Button S0| 
 +|PE4|OC1A/​SS|PC-PD-PE|I/​O Port| |PDI|PDI_DATA|PDI|PDI Data| 
 +|PE5|OC1B/​MOSI|PC-PD-PE|LCD SDA| |RESET|PDI_CLOCK / RESET|PDI|PDI Clock and Reset| 
 +|PE6|RXD1/​MISO|PC-PD-PE|I/​O Port| |PRO|XTAL2| |XTAL| 
 +|PE7|TXD1/​SCK|PC-PD-PE|LCD SCL| |PR1|XTAL1| |XTAL| 
 +==== Robotic HomeLab II generation ====
  
-</​box>​ +The modules of the Robotic HomeLab are divided into different kits, allowing one to select the best option for the needs of a student or school. The simplest set is the Robotic HomeLab Basic kit including the components to carry out the basic microcontroller experiment. In addition to the microcontroller,​ the kit consists of a User Interface module with LCD display. Together with the Robotic HomeLab Basic kit, the Robotic HomeLab Add-On kit can be used; this includes different types of motors and sensors together with accessories and Communication module. The Robotic HomeLab Add-On kit cannot be used separately from the Robotic HomeLab Basic kit as the microcontroller is not included in the Add-On kit. In addition the RFID and Machine Vision modules are available. The Robotic HomeLab Basic kit together with the Robotic HomeLab Add-On kit are convenient to use and carry to home for the robotic experiments.
-====== Robootika Kodulabor ======+
  
-{{:kit:​kodulaboridjarobotid.jpg?​580|}}+=== Robotic HomeLab Basic kit ===
  
-**Mehhatroonika ja Robootika Kodulabor** on ATmega128 mikrokontrolleril põhinev omavahel seotud moodulite komplektmis on komplekteeritud kaasaskantavasse kohvrisse. Kodulaboriga saab teha erinevaid mehhatroonika- ja robootikaalaseid eksperimente ning harjutusi alates lihtsast tule vilgutamisest kuni keeruka seadme ehitamiseni. Kodulabor on mõeldud eelkõige koolidelesisaldades endas lisaks riistvarale ka metoodilist materjali ja harjutusülesandeid koos näidete ja lahendustega. Kodulabor on integreeritud oma veebikeskkonnagamis on suunatud õpilasele ja õpetajale ning võimaldab kasutajate omavahelist suhtlust. Lühidalt öeldes on Kodulabor mobiilne töövahendite komplektmida kasutatakse õppe ja harjutamise eesmärgil koduskoolis või töökohal.+[{{  :​kit:​basic_kit_v5.png?​400 ​ |Robotic HomeLab Basic kit}}] 
 +\\ 
 +\\ 
 +\\ 
 +\\ 
 +    ​AVR ATmega2561 development boardincluding EthernetSD card reader and integrated JTAG programmer 
 +    * User interface board (buttonsLEDsGraphical LCD7-segment indicator and buzzer) 
 +    * USB cable 
 +    * Example exercises with C-source code (examples) 
 +    * Software library 
 +    * Power supply 
 +    * Multimeter 
 +    * Software for programming in Assembler and C language 
 +    * Portable case
  
-Kodulabor on välja arendatud Tallinna Tehnikaülikooli ja Eesti ettevõtte poolt koostöös Euroopa partnerülikoolidega Leonardo da Vinci programmi toel. Kodulabori moodulid on komplekteeritud erinevatesse komplektidesse. Lihtsaim komplekt, millega saab teha esmaseid digitaalsete sisendite-väljundite eksperimente,​ on Kodulabori baaskomplekt. Andurite ja mootoritega eksperimenteerimiseks on vaja Andurite ja Mootorite lisakomplekti. Täiskomplekt sisaldab endas nii Kodulabori baaskomplekti,​ Andurite ja Mootorite lisakomplekti kui ka lisamooduleid. +=== Robotic HomeLab Add-On kit ===
-===== Integreeritud robootika õppe kontseptsioon =====+
  
-Tänapäevane inseneriõpe ei saa enam põhineda ühel konkreetsel õppeviisil,​ ammugi mitte enam klassikalisel ülikooli loeng-harjutus-tüüpi standardlahendusel. Tänapäeva õppija ei rahuldu enam rangelt ajastatud laboritundidega. Enamik noori (ja ka vanemaid õppijaid) elavad infoühiskonna täisväärtuslikku elu ja viidavad suure osa oma ajast internetis, mis tähendab, et klassikaliste meetoditega õppimisele jääb järjest vähem aega. Selle tõttu tuleb inseneriõpe tuua samuti üle infoühiskonda ja teha see atraktiivseks,​ kaotamata samal ajal kvaliteedis ja praktilise töö osakaalus.+[{{:​kit:​sensor_motor_kit.jpg?​330|Robotic HomeLab Add-On kit}}]
  
-Mehhatroonika ja robootika integreeritud õppe kontseptsioon sisaldab endas nii standardseid õppeabimaterjale kui ka uudseid lähenemisi,​ mis on metoodiliselt seotud ühtseks tervikuks. 
  
-Alljärgnev näide võib olla abiks koolile robootika õppesüsteemi käivitamiseks kui ka ideedeks rakendada erinevaid õppevõimalusi tehnikavaldkonna praktilises õppes.+== Sensor Module ==
  
-Õppe kontseptsioon sisaldab endas järgnevaid õppeabimaterjale:​ +  ​Analogous sensor and low-pass filter combined board with on-board sensors (temperature sensorlight intensity sensor, potentiometer and mic) 
-  ​Tavaline käsiraamat-õpik, näiteks "​Integrated Systems & Design"​ ISBN:978-9985-59-850-4. +  * Ultrasonic distance sensor SRF05 with cable 
-  * Praktiline harjutusülesannete kogunäiteks käesolev raamat. +  * Infrared distance sensor with cable
-  * Robootika Kodulabor. +
-  * Mehhatroonika Kauglabor. +
-  * Robootika õpetajate ja õpilaste võrgustik http://​www.roboticlab.eu.+
  
-Teoreetilised abimaterjalid koosnevad traditsioonilisest õpik-käsiraamatust ja harjutusülesannete kogust. ​+== Motor Module ==
  
-Praktiline osa koosneb Kodulaborist ja üle interneti robotite programmeerimise keskkonnast - Kauglaborist. Kodulaborid moodustavad Kauglaboriga ühtse terviku, mis tähendab, et õppija saab kodus harjutada üksikuid funktsioone,​ näiteks, kuidas juhtida erinevaid mootoreid või kasutada andureid ja samal ajal on võimalus üle interneti oma värskeid oskusi rakendada süsteemi juhtimiseks. Süsteemiks on reaalne seadmestik ​(näiteks mobiilne robot), mida saab programmeerida ja juhtida Kauglabori vahendusel. Robot on ehitatud samadest komponentidest,​ mis sisalduvad Kodulaboris,​ võimaldades nii omandatud oskusi kohe ka terviksüsteemi peal proovida. Roboti liikumisest ja tegemisest saab tagasisidet videokaamerate abil.+  * DC motor (w/ gear and encoder) 
 +  * RC servo motor 
 +  * Stepper motor (bipolar or unipolar stepper) 
 +  * Motor driver board 
 +  * Power supply divider
  
-Kodulabori veebikeskkond\\ +== Communication module == 
-http://​home.roboticlab.eu+  * Communication board, 2xRS232 
 +  * ZigBee or Bluetooth wireless unit
  
-Kauglabori veebikeskkond\\ 
-http://​distance.roboticlab.eu 
  
  
-~~PB~~+{{:​kit:​homelabv5.1.jpg?​400|}}
  
-Õppeprotsessi ühe teema/​laboritöö raames kirjeldab järgnev skeem.+=== Robotic HomeLab additional modules === 
 +Additional modules are not packed into the cases but can be directly connected with Robotic HomeLab Communication module. Practical examples and exercises are provided for these modules.
  
-{{  :​method:​metoodika.png?​580 ​ |}}+== RFID Module ==
  
-Teema algab sissejuhatava loenguga, mis võib toimuda klassikalise kontakttunnina,​ kaugloenguna ​(juhul kui õpetaja on eemalvõi videoloenguna. Videoloeng on oluline isegi sel juhul, kui toimub tavaloeng, võimaldades nii ka puudunud õpilastel loengumaterjalist osa saada või osalenud õpilastel soovi korral loeng üle vaadata. Teemat tutvustav loeng sisaldab endas praktilise näite koos läbitegemist ja õppetajapoolset protsessi kommenteerimist. +  * High frequency RFID reader 
-Teoreetilist osa toetab õpik ja harjutuste kogu teoreetiline osa.+  * Tag (2
 +  * Cable
  
-Teema tutvustusele järgneb iseseisev praktiline töö. Praktiline töö koosneb näitelahenduse katsetamisest,​ selle muutmisest vastavalt "​Soojendusülesandele"​ ja iseseisvast harjutusülesandest,​ mille määrab õpetaja praktiliste tööde "​Harjutusülesannete"​ osast. Praktiline töö teostatakse Kodulaboriga või mõne muu robootika komplektiga,​ mida toetab teoreetiline ja praktiline juhend, Kauglabor ja veebikeskkond. Olulisel kohal on siinjuures õpetajate ja õpilaste tugikeskkond ja võrgustik, mis peaks iseseisvale tööle igakülgset abi pakkuma. Foorumis saab küsida abi nii juhendajalt kui ka kaasõpilastelt.+== Machine Vision Module ==
  
-Praktilise harjutuse tulemused vormistatakse aruandeks ja saadetakse õpetajale või, kui kasutusel on e-õppe süsteem, laetakse koos töötavate masinkoodis lahendustega vastavasse süsteemi. Aruanne sisaldab tüüpiliselt töö kirjeldust ja lahenduse lähtekoodi,​ mis peab olema selgelt ja arusaadavalt kommenteeritud.+  * Intelligent camera module (CMUcam3)
  
-===== Robootika õpetamisest =====+==== Robotic HomeLab I generation ​====
  
-Ei ole mingi uudis, et infotehnoloogia tungimine igapäevaellu on muutnud paljude, kui mitte enamuse noorte õppimise stiili ja kommunikatsioonikanaleid. Tõenäoliselt saab õppija juba praegu olulise osa õpitava aine informatsioonist erinevate infotehnoloogia kommunikatsioonikanalite kaudu. Enne mingi probleemi lahendamist tehakse tihti kiire otsing internetist,​ leidmaks taustainformatsiooni või näitelahendusi. Kuna noorte igapäevasuhtlus ja tegevus on igati põimunud internetiga ja seal olevate erinevate võrgustikega,​ on igati loomulik, et koolitaja poolt pakutav õpetamismetoodika peab järgima üldisi trende ja leidma tee õppijani läbi tema poolt harjumuspärase suhtluskanali - interneti. Loomulikult ei välista interneti kasutamine traditsioonilisi õpetamise vorme, kuid ainuüksi nendest enam ei piisa. 
  
-Robootika ja mehhatroonika on tulevikku suunatud alad, mille õpetamisel tuleb samuti järgida tänapäeva trende ja uusi tehnoloogiaid. Samal ajal aga on see valdkond väga praktiline ja nõuab oskuste ning teadmiste omandamiseks praktilist katsetamist ja harjutamist. Kuigi on olemas ka virtuaalseid ülesandeid,​ ei asenda see praktilisi oma käega tehtud tegevusi. ​ 
-Järgnevalt püüame pakkuda ühe võimaliku praktilise juhendi, kuidas viia läbi ühte robootika ainet, kus on kasutusel erinevaid õpetamise vorme integreeriv lähenemine. Metoodika eeldab, et õpetajal on võimalus kasutada modulaarset praktilist robootika õppekomplekti - antud juhul Kodulaborit. 
  
-Mida pidada silmas õppeaine alustamisel.... +Robootika Kodulabori moodulid on jagatud erinevatesse komplektidesse,​ võimaldades valida sobivaima, sõltuvalt õpilase või kooli eesmärkidest. Lihtsaim komplekt on Robootika ​Kodulabori baaskomplekt,​ mis sisaldab endas kõike vajalikku mikrokontrolleri kasutamiseks ja lisaks ​Digitaalset ​sisend-väljund ​plaati koos LCD ekraaniga. ​Robootika Kodulabori baaskomplektiga ​saab kasutada ​Robootika Kodulabori ​lisakomplekti,​ mis sisaldab ​mootorite ja andurite plaate, ​erinevat tüüpi mootoreid, andureid ​ning nende tarvikuid. ​Robootika Kodulabori lisakomplekt ​töötab koos Robootika ​Kodulabori baaskomplektiga. Iseseisvalt lisakomplekti kasutada ei saa, sest see ei sisalda mikrokontrollerit. ​
- +
-  - **Grupi suurus** \\ +
-    Optimaalse õpilaste arvu laborikomplektiga tegutsemiseks määrab suuresti ära juba arvutikasutamise võimalus. See tähendab, et ühe arvuti taha mahub enamasti kuni 3 inimest nii, et veel kõik saavad toimuvast aktiivselt osa võtta. Suurema arvu juures ei näe osa õpilasi enam kirjutatavat koodi ja neil hakkab igav ning tunnitööga enam ei tegeleta. +
-  - **Praktiline töö ja aruandlus** \\ +
-    Praktiline töö on jagatud laboritöödeks,​ kus iga labori juures tuleb lahendada ülesanne programmiliselt ning tulemus vormistada aruandena. See võimaldab tööd õpilaste vahel jagada. Näiteks üks vastutab programmikoodi eest, teine aruande kirjutamise eest, kolmas riistvara ühendamise eest. Aruandes endas võib nõuda näiteks lisaks programmikoodile ka lahenduse kirjeldust tekstina, kasutatava algoritmi lahtiseletavat diagrammi, vastuseid käsitletud teema kohta käivatele küsimustele ja õpilaste nägemust labori plussidest ja miinustest. Viimane on hea võimalus uurida õpilastelt tagasisidet sellest, kas ülesanne oli liiga keeruline või lihtne, kui praktiline või huvitav ülesanne tundus, mida õpiti juurde jms. \\ Kindlasti tasub laborikomplekti käsitlev esimene programmeerimisülesanne koos läbi teha. Samaaegselt õpetajaga, kes selgitab toimingute tausta ja lahendab ülesannet ekraanil, teevad õpilased demonstreeritud ülesannet koos kaasa. Kogu protsess võiks olla kirja pandud etapiliselt,​ et mahajääjad või puudujad saavad juhendi järgi võimalusel ka ise tegutseda. Labori läbiviimise üks võimalik variant on järgnevalt toodud välja etappidena, mis võivad omakorda varieeruda vastavalt situatsioonile. +
-    * Laboritöö tutvustus +
-      * Õpetaja selgitab kõigepealt uut laboritööd,​ võttes läbi kogu teoreetilise materjali, ning hiljem uuritakse koos läbi selgitav näide (programmi kood). +
-      * Õpetaja jaotab labori materjali etappideks, nii et iga etapp koosneb teooriast ja koodi kirjutamisest. Seega kirjutatav programmikoodi näide valmib koos teooria selgitamisega. +
-    * Iseseisev ülesannete lahendamine. See toimub laboritöö juhendi järgi, kus on kirjas ülesanne, nõuded ja aruandluse vorm. Õpilased teevad tööd iseseisvalt,​ võimalusel saavad õpetajalt abi küsida. Eesmärk on, et õpilased jõuaksid ise lahenduseni. Kui  on võimalus anda õpilastele laborikomplekt koju kaasa, siis iseseisev töö ei pea toimuma kindla tunni ajal, vaid õpilased teevad tööd endale sobival ajal. +
-    * Tööde esitamine. Õpilased koostavad tehtud tööst aruande, kus nad vastavad lisaks õpetaja poolt määratud kordamisküsimustele. Aruandlus koos kompileeritud lahendusega (hex failina) saadetakse õpetajale kindlaks ajaks elektrooniliselt.  +
-    * Kontroll +
-      * Õpetaja kontrollib, kas lahendus töötab ning paneb hinde saadetud töö ja aruandluse alusel. +
-      * Õpetaja kontrollib, kas lahendus töötab ning palub grupil tööd kaitsta suuliselt nii, et üks õpilane peab selgitama teatud osas aruandest, teine õpilane teist osa, jne.  +
-  - ** Gruppide haldamine ** \\ +
-    Ülesannete lahendamisel võib alati tekkida grupp (grupid), kes on teistest aeglasem või alustasid hiljem. Sellisel juhul on tavaliselt probleemiks õpetaja tähelepanu koondumine mahajäänud grupi abistamisele ning teised peavad ootama ja igavlema, kuni mahajääja grupp on järele jõudnud. Analoogselt tekib probleem, kui klassis on üks grupp, kes jõuab töödega valmis teistest kiiremini. Mõlema probleemi lahendamiseks on võimalus kasutada kirjapandud ülesandeid või laborijuhendeid. Kuna kogu töö protsess ja nõutud osad on kirja pandud, siis saavad grupid ​ töötada iseseisvalt ning õpetajal on võimalus abistada neid, kellel tekib probleeme edasijõudmisega. Lisaks on erineva raskusastmega ülesandeid,​ mida saab jagada vastavalt grupi võimekusele või boonusülesandena nendele, kes on normülesanded juba ära jõudnud lahendada. +
-  - **Hindamine** \\ +
-    Kui õpetaja peab oluliseks, et kõik oskaksid programmeerida ning saaksid programmikoodist aru, siis võib õpetaja nõuda, et õpilased vahetaksid teatud osaülesande järel kohad, nii et igaüks saaks proovida programmeerimist. Teine võimalus on ülesande hindamisel küsida programmikoodi lahenduse kohta selgitust ükskõik milliselt grupi liikmelt ning viimase vastus määrab kogu grupiliikmete hinde. See sunnib gruppi töötama ühtsena ning hoolitsema, et kõik grupi liikmed saaksid aru, kuidas lahenduse üksikasjad töötavad. Kui selline lähenemine tundub ebaõiglasena,​ võib iseseisva töö kaitsmise organiseerida nii, et grupp peab lahendama õpilaste arvuga võrdse arvu töid. Iga õpilane peab kaitsma ühe töö. Millise, selgub alles kaitsmise käigus. +
-  - **Veaotsing** \\ +
-    Tihtipeale võivad programmi koodi kompileerimisel või riistvara valesti käsitlemisel tekkida mingid tüüpvead. Nende sümptomid tasub kindlasti kirja panna koos lahendusega,​ kuna sama viga, millele lahenduse leidmine võttis tunde, võidakse õpilaste poolt korrata. Tüüpprobleemide lahendused saab koondada Kodulabori tugikeskkonna foorumisse. +
-  - **Võistlus** \\ +
-    Üks võimalus motivatsiooni tõstmiseks ja kogu õppeprotsessi huvitavamaks muutmiseks on tekitada võistlusmoment,​ kus õpilastel tuleb mingile probleemile leida lahendus, mida kursuse lõpus ühiselt testitakse. Lahenduse headus peab olema mõõdetav (aeg, kaugus vms.). Võib tekitada ka erinevaid hindamiskriteeriume:​ nn. väljanägemine,​ optimaalne lahendus, huvitavaim tehniline lahendus jms. Ülesannet annab kindlasti siduda ka reaalse elu probleemidega (nt patareide sorteerija). Samas on võimalus kasutada ka mobiilseid platvorme, et lahendada hobirobootika tüüpülesandeid nagu joonejälgimine,​ labürindi läbimine jms.  +
- +
-~~PB~~ +
- +
-Järgnevalt on toodud näiteks tüüpiline laboritöö kirjeldus, mida võib kasutada praktilise töö lähteülesandena. +
- +
-<box 100% round #​EEEEFF|Laboratoorne töö Nr 3. Andurid ja analoog-digitaalmuundur>​  +
- +
-**Juhendaja**:​ Raivo Sell +
- +
-**Töö eesmärk** +
- +
-Tutvuda analoog-digitaalmuunduri tööpõhimõtte ja analoogsignaalide muundamisega,​ kasutades AVR ATmega128 8-bitist mikrokontrollerit. Lisaks tutvuda erinevate analoogväljundiga anduritega. Teha läbi lihtne harjutus analooganduri kasutamisest. +
- +
-**Tööks vajalikud vahendid** +
- +
-Kodulabori baasversioon,​ Andurite ja Mootorite lisakomplekt,​ AVR tarkvara. +
- +
-**Töö käik** +
- +
-  - Teha läbi näiteülesanne potentsiomeetriga. \\ http://​home.roboticlab.eu/​et/​examples/​sensor/​potentiometer +
-  - Teha ühine harjutus "​Soojendusülesanne"​ \\ http://​home.roboticlab.eu/​et/​exercises/​sensor +
-  - Teha grupi personaalne harjutusülesanne (mille määrab õppejõud vahetult enne töö alustamist) +
-  - Vastata kordamisküsimuste ühele küsimusele (küsimuse määrab õppejõud vahetult enne töö alustamist) +
- +
-**Aruanne** +
- +
-Tehtud töö kohta tuleb esitada elektrooniline aruanne, mis sisaldab: +
-  * Seletuskirja töö käigu kohta +
-    * Töö eesmärk +
-    * Lühikirjeldus tehtud töödest +
-    * Algoritm ja väljatrükk programmi algkoodist sammude 2 ja 3 kohta \\  NB! Lähtekood peab olema kommenteeritud ja värvitud (võib kasutada "​Programmer'​s Notepad"​ abi). +
-    * Küsimuse vastus (samm 4) +
-    * Järeldused ja kommentaarid +
-  * Ülesannete 2 ja 3 töötav lahendus HEX failina. +
- +
-Aruanne peab sisaldama nime, labori numbrit, teostamise kuupäeva, kaasosaliste nimesid (kui olid). Aruanne peab olema lühike, kuid sisutihe. Hinnatakse kvaliteeti, mitte kvantiteeti! Olge valmis lahenduse demonstreerimiseks juhendajale ja Teie poolt loodud programmikoodi kommenteerimiseks. Aruanded laadida üles e-õppe keskkonda vastava ülesande juurde. +
-Labori aruande esitamise tähtaeg on 1 nädal pärast töö tegemist. +
- +
-**Kirjandus** +
-  - Kodulabori tugikeskkond:​ http://​home.roboticlab.eu +
-  - ATmega128 andmeleht +
-  - Sharp infrapunaanduri andmeleht +
-  - http://​www.avrfreaks.net +
-</​box>​ +
-===== Kodulabori riistvara ===== +
- +
-Robootika Kodulabori moodulid on jagatud erinevatesse komplektidesse,​ võimaldades valida sobivaima, sõltuvalt õpilase või kooli eesmärkidest. Lihtsaim komplekt on Kodulabori baaskomplekt,​ mis sisaldab endas kõike vajalikku mikrokontrolleri kasutamiseks ja lisaks ​Digitaal-sisend/​väljundite ​plaati koos LCD ekraaniga. ​Baaskomplektiga ​saab kasutada ​Mootorite ja Andurite ​lisakomplekti,​ mis sisaldab erinevat tüüpi mootoreid, andureid ​ja nende tarvikuid. ​Lisakomplekt ​töötab koos Kodulabori baaskomplektiga. Iseseisvalt lisakomplekti kasutada ei saa, sest see ei sisalda mikrokontrollerit. Kodulabori täiskomplekt sisaldab endas Kodulabori baaskomplekti ja Andurite ja Mootorite lisakomplekti täies mahus ning lisaks veel kolme moodulit, milleks on Kommunikatsioonimoodul,​ RFID moodul ja Masinnägemise moodul. Täiskomplekt sobib rohkem õpetajale. Õpilastele ja kaasaskandmiseks on olulisel mugavam ja mõistlikum kasutada Kodulabori baaskomplekti üksi või koos Andurite ja Mootorite lisakomplektiga.+
  
 === Kodulabori baaskomplekt === === Kodulabori baaskomplekt ===
  
-[{{  :​kit:​basic_kit.jpg?​200|Kodulabori baaskomplekt}}] +[{{  :​kit:​basic_kit.jpg?​500  ​|Robootika ​Kodulabori baaskomplekt}}] 
- +\\ 
-  * AVR ATmega128 arendusplaat +  * AVR ATmega128 arendusplaat ​koos  
-  * Digitaal ​sisend-väljundplaat ​(nupud, LED-id, 2 x LCD väljund, 7-segment-indikaator) +  * JTAG programmaatora 
-  * 2 x 16 tähemärgiga taustavalgustusega ​LCD ekraan +  * Digitaalne ​sisend-väljund moodul ​(nupud, LED-id,​7-segment-indikaator) 
-  * JTAG programmaator ja silur (USB) + kaabel+  * LCD ekraan 
 +  * USB kaabel
   * Näiteülesanded koos C-lähtekoodiga (näidisharjutus)   * Näiteülesanded koos C-lähtekoodiga (näidisharjutus)
 +  * Tarkvarateek
   * Toiteplokk   * Toiteplokk
   * Multimeeter   * Multimeeter
   * Tarkvara assembler- ja C-keeles programmeerimiseks   * Tarkvara assembler- ja C-keeles programmeerimiseks
   * Kaasaskantav kohver   * Kaasaskantav kohver
 +<​pagebreak>​
  
-=== Andurite ja Mootorite lisakomplekt === +=== Robootika Kodulabori ​Andurite ja Mootorite lisakomplekt === 
-[{{  :kit:sensor_motor_kit.jpg?200|Andurite ja Mootorite ​lisakomplekt}}] + 
-**Mootorite moodul** +[{{:kit:sensor_kit.jpg?300|Robootika Kodulabori ​lisakomplekt}}] 
-  * Alalisvoolumootor (reduktoriga)+ 
 +== Mootorite moodul ​==  
 +  * Alalisvoolumootor (reduktori ja koodriga)
   * RC servomootor   * RC servomootor
-  * Samm-mootor ​(bipolaarne või unipolaarne samm-mootor)+  * Samm-mootor
   * Mootorite ajuriplaat   * Mootorite ajuriplaat
   * Toitejagur   * Toitejagur
-  * Ribakaabel 
  
-**Andurite moodul** +== Andurite moodul ​== 
-  * Analooganduri ​ja madalpääsu filtri ​kombineeritud plaat koos anduritega (temperatuuri andur, valgustugevuse andur, potentsiomeeter)+ 
 +  * Analoogandurite ​ja madalpääsfiltritega ​kombineeritud plaat koos anduritega (temperatuuriandur, valgustugevuse andur, potentsiomeeter ​ja mikrofon)
   * Ultraheli kaugusandur SRF05 koos kaabliga   * Ultraheli kaugusandur SRF05 koos kaabliga
   * Infrapuna kaugusandur SHARP koos kaabliga   * Infrapuna kaugusandur SHARP koos kaabliga
-  * Ribakaabel 
  
-~~PB~~ 
  
-=== Kodulabori täiskomplekt ===+<​pagebreak>​
  
-Kodulabori ​täiskomplekt sisaldab kõiki komponente Kodulabori baaskomplektist ja Andurite ja Mootorite lisakomplektist ning lisaks järgmisi mooduleid:+=== Kodulabori ​Täiskomplekt ===
  
-**RFID moodul**+Kodulabori Täiskomplekt on mõeldud õpetajale. See sisaldab kõik komponente Kodulabori baaskomplektis ja Kodulabori lisakomplketist ning lisaks järgmisi mooduleid:
  
-  ​Lugeja+[{{:​kit:​advanced_kit.png.jpg?​400|Robootika Kodulabori täiskomplekt}}] 
 + 
 +== Kommunikatsiooni moodul == 
 + 
 +  ​Kommunikatsiooni moodul (Bluetooth) 
 + 
 +== RFID moodul == 
 +  * Kõrgsageduslik RFID lugeja
   * Märk (2 tk)   * Märk (2 tk)
   * Kaabel   * Kaabel
  
-**Kommunikatsiooni ​moodul**+== Masinnägemise ​moodul ​==
  
-  * Bluetooth +  * Intelligentne kaameramoodul (CMUcam3)
-  * Ethernet +
-  * SPI+
  
-**Masinnägemise moodul**+{{:​images:​book:​examples.jpg?​580|}} 
 +==== Controller module ====
  
-  * Intelligentne kaameramoodul ​(CMUcam3)+The Controller module in Robotic HomaLab kit is a development board equipped with AVR ATmega series microcontroller and peripherial devices. 
 + 
 +Robotic HomeLab kit has currently three generation Controller modules. 
 +Below, you can choose a suitable Controller module documentation. 
 + 
 +ATXmega128A1U ​(version 3.x) 
 + 
 +[[en:​hardware:​homelab:​controller:​xmega128|{{:​kit:​controller:​kontroller_iii.png?​310}}]] 
 + 
 +ATmega2561 (version 1.x) 
 + 
 +[[en:​hardware:​homelab:​controller:​atmega2561|{{:​kit:​atmega2561.jpg?​300}}]]
  
-[{{  :​kit:​advanced_kit.png.jpg?​400 ​ |Kodulabori täiskomplekt}}] 
  
-Kodulabori baaskomplekti ja täiskomplekti saab edukalt kasutada lisaks eksperimentidele ka robotiehitamise baasplatvormina või muu mehhatroonikasüsteemi keskse juhtsüsteemina. Kodulabori versioonid on pidevas arengus ja aeg-ajalt tasub kontrollida,​ kas on ilmunud lisamooduleid või uuendusi. Samuti tasub kontrollida moodulite versiooni numbreid, kuna mõningad harjutused ja näited võivad olla koostatud uuematele versioonidele. +----
-==== Kontrollermoodul ====+
  
-Kodulabori keskseks mooduliks (kontrollermooduliks) on arendusplaadile paigaldatud mikrokontroller ​ATmega128. Lisaks mikrokontrollerile on plaadil veel mitmesuguseid perifeeriaseadmeid,​ pingealaldi ja ühenduspistikud. Kontrollermooduli plaat sisaldab endas järgmisi komponente:+ATmega128
  
-  * ATmega128-16AU mikrokontroller +[[en:hardware:homelab:controller:​atmega128|{{:​kit:​cpu_module.jpg?​320}}]]
-    * 8-kanaliga analoog-digitaalmuunudr (ADC) +
-    * 128 kB //​flash//​-mälu (programmi mälu) +
-    * 6 kanaliga programmeeritav PWM generaator +
-  * 4 kB EEPROM mälu (andmemälu) +
-  * Standardne 6-viiguga ISP (inglise keeles //in-system programming interface//​) programmeerimise liides +
-  * 14,7456 MHz taktigeneraator +
-  * Reaalaja kell RTC (inglise keeles //real time clock//)  +
-  * Programmeeritav oleku LED (PB7) ja toite indikaator-LED +
-  * Standardne RS-232 jadaliidese pistikupesa +
-  * Grupeeritud AVR viigud (1pordid D, B, E; 2pordid G, C, A; 3port F) +
-  * Taaskäivitamise (inglise keeles //reset//) nupp +
-  * JTAG 10-viiguga programmeerimise liides +
-  * 2,1 mm toitepistiku pesa +
-  * Pingestabilisaator ja valepolaarsuse kaitse+
  
-[{{  :​kit:​cpu_module.jpg?​580 ​ |Mikrokontrolleri arendusplaat - Kontrollerplaat}}] 
  
-Kontrollermooduli plaat on varustatud alaldiga ja pingestabilisaatorigaSisendpingeks sobib plaadile 6-15 VVoolukadude minimeerimiseks on soovitatav kasutada 6-9 V pingeallikat. Toite ühendamisel peab plaadil toite LED põlema hakkama. Kui see ei süttivõib põhjus olla puudulikus toitesühendamata jäänud toitesillas (toitepesa kõrval) või hoopis lühises Kontrollermooduli plaadil või temaga ühendatud seadmes. Mikrokontrollerit saab programmeerida nii ISP kui JTAG liidese kaudu. Kodulabori komplektiga kaasasolev JTAG-ICE programmaator toetab lisaks lihtsale programmi pealelaadimisele ka programmikoodi silumist. JTAG-ICE programmaatorit võib kasutada ka ISP režiimis. Programmeerimise viigud on ühendatud läbi multiplekserimis võimaldab kontrolleril töö ajal vastavaid viike kasutada ka teiste funktsioonide jaoks.+<​pagebreak>​ 
 +=== Controller module ATmega2561 v1.x === 
 +The main module of the HomeLab is a controller development board (controller board) equipped with the AVR ATmega2561 microcontrollerIn addition to the microcontrollerthe board consists of several peripherals,​ voltage stabilizer, connectors, JTAG programmer, EthernetSD memory card slotThe controller board has the following features: ​
  
-Kontrollermooduli plaat on varustatud oleku-LED-iga, mis on ühendatud mikrokontrolleri viiguga ​PB7LED süttib, kui viik seada madalasse olekusse ​(loogiline 0). Seda on hea kasutada lihtsa indikaatorina. ATmega128 mikrokontroller on varustatud kahe jadaliidesega,​ mille signaalid on MAX232 muunduriga teisendatud RS-232 nivoole. Ühe jadaliidese ​(UART1jaoks on standardne RS-232 DB-9 pistikteise jaoks piikriba.+  * ATmega2561-16AU microcontroller 
 +    * 8-channel 10-bit A/D converter 
 +    * 256 kB Flash memory (program memory) 
 +    * 4kB EEPROM memory (data memory) 
 +    * 6 channel programmable PWM 
 +  * Integrated JTAG programmer (based ​on FTDI2232) 
 +  * 14,7456 MHz clock 
 +  * Ethernet module with RJ45 connector 
 +  * SD memory card slot 
 +  * Status LED (PB7)and Power LED 
 +  * Programmable button ​(PC2and reset button  
 +  * All Atmega signals available ​on three connectors ​(1: ports D, B, E; 2: ports G, C, A; 3: port F with ADC I/O lines) 
 +  * 2,1 mm power socket 
 +  * Automatic power switch USB or external power supply 
 +  * Built-in voltage stabilizer, with 5 V and 3,3 V output 
 +[{{  :​kit:​atmega2561.jpg?​580 ​ |Controller module}}]
  
-Plaadile ​on paigaldatud lisamälu ​4 Mb Atmel AT45DB041B välkmäluMälu on ühendatud SPI liidese kaudu mikrokontrolleriga ja seda võib kasutada andmete salvestamiseksjuhul kui need peavad säilima ka pärast toite eemaldamist mikrokontrollerilt.+The module is equipped with a AC/DC rectifier circuit and a LDO voltage stabilizer (with low dropout) -an external feeder with voltage stabilization is not needed.  
 +The module can be powered with a step down transformer with an output voltage which is greater than 6 volts and lower than 15 volts. In order to reduce power losses it is recommended to use power supply between 6-9V.  The POWER LED signalizes a connected feed (“POWER” description on the board).  
 +All ATmega2561 signals are available on three connectors on the edge of the board. Connectors pin assignment is described in the next part of this instruction. It includes full descriptions of ATmega2561 pins and their alternative functions. The module is equipped with a microprocessor reset circuit (when power on) and a reset button for a microprocessor restart. A microprocessor can be programmed with an on-board JTAG programmer over USB or with an ISP interface 
 +To the seventh pin of port B (named as PB7) the status LED (described as PB7 on the board) is connected. This LED can be used as a status indicator of application software. Low state on PB7 pin causes the status LED to be lit.  
 +The module is equipped with SD memory card slotwhere it can be used as a standard microSD memory card. The memory card is connected to the microcontroller via the ISP interface and can be used to store data where data must be maintained even if the power supply is removed.
  
-[{{:kit:atmega_plaat.png?580|Kontrollerplaadi komponendid}}]+[{{:kit:atmega2561_sch.png?580|Components on the Controller board}}]
  
-=== Ühenduspesade viigud ja nende funktsioonid ===+== Connector Pins and Functions ​==
  
-{{:kit:pf.png?​450 ​ |}}+{{:kit:pf_2561.png?​450 ​ |}}
 ~~CL~~ ~~CL~~
-^Nr^Viik^Alternatiivfunktsioon ​kirjeldus^^+^Nr^Pin^Alternative function ​Description^^
 |1|VCC|- ​ |+5 V | |1|VCC|- ​ |+5 V |
-|2|GND|- ​ |Maa +|2|GND|- ​ |GND 
-|3|REF|AREF|ADC ​võrdluspinge sisend+|3|REF|AREF|Analog Reference Voltage For ADC | 
-|4|GND|- ​ |Maa +|4|GND|- ​ |GND 
-|5|PF0|ADC0|ADC ​sisendkanal ​0 | +|5|PF0|ADC0|ADC ​Input Channel ​0 | 
-|6|GND|-|Maa +|6|GND|-|GND 
-|7|PF1|ADC1|ADC ​sisendkanal ​1 | +|7|PF1|ADC1|ADC ​Input Channel ​1 | 
-|8|GND|-|Maa +|8|GND|-|GND 
-|9|PF2|ADC2|ADC ​sisendkanal ​2 | +|9|PF2|ADC2|ADC ​Input Channel ​2 | 
-|10|GND|-|Maa +|10|GND|-|GND 
-|11|PF3|ADC3|ADC ​sisendkanal ​3| +|11|PF3|ADC3|ADC ​Input Channel ​3| 
-|12|GND|-|Maa | +|12|GND|-|GND |
-|13|PF4|ADC4/​TCK|ADC sisendkanal 4 või JTAG taktsignaal| +
-|14|GND|-|Maa | +
-|15|PF5|ADC5/​TMS|ADC sisendkanal 5 või JTAG režiimivalik| +
-|16|GND|-|Maa | +
-|17|PF6|ADC6/​TDO|ADC sisendkanal 6 või JTAG andmete väljund| +
-|18|GND|-|Maa | +
-|19|PF7|ADC7/​TDI|ADC sisendkanal 7 või JTAG andmete sisend| +
-|20|GND|-|Maa ​|+
  
-~~PB~~+<​pagebreak>​
  
 {{:​kit:​pe-pb-pd.png?​450 ​ |}} {{:​kit:​pe-pb-pd.png?​450 ​ |}}
 ~~CL~~ ~~CL~~
-^Nr^Viik^Alternatiivfunktsioon ​kirjeldus^^ +^Nr^Pin^Alternative function ​Description^^ 
-|1 |PD7|T2 ​      ​|Taimer/Loendur2 taktsignaali sisend+|1 |PD7|T2 ​             |Timer/Counter2 Clock Input 
-|2 |PD6|T1 ​      ​|Taimer/Loendur1 taktsignaali sisend+|2 |PD6|T1 ​             |Timer/Counter1 Clock Input 
-|3 |PD5|XCK1 ​    ​|USART1 ​taktsignaali sisend/väljund+|3 |PD5|XCK1 ​           |USART1 ​External Clock Input/Output
-|4 |PD4|IC1 ​     |Taimer/Loendur1 sündmuste püüdja sisend+|4 |PD4|IC1 ​            ​|Timer/Counter1 Input Capture Trigger
-|5 |PD3|INT3/​TXD1|Väline katkestus 3 või UART1 andmete väljund+|5 |PD3|INT3/​TXD1 ​      ​|External Interrupt3 Input or UART1 Transmit Pin 
-|6 |PD2|INT2/​RXD1|Väline katkestus 2 või UART1 andmete sisend+|6 |PD2|INT2/​RXD1 ​      ​|External Interrupt2 Input or UART1 Receive Pin 
-|7 |PD1|INT1/​SDA |Väline katkestus 1 või TWI andmesignaal+|7 |PD1|INT1/​SDA ​       |External Interrupt1 Input or TWI Serial Data 
-|8 |PD0|INT0/​SCL |Väline katkestus 0 või TWI taktsignaal+|8 |PD0|INT0/​SCL ​       |External Interrupt0 Input or TWI Serial Clock 
-|9 |VCC|- ​       |+5 V+|9 |VCC|- ​              ​|+5V 
-|10|GND|- ​       |Maa+|10|GND|- ​              ​|GND 
-|11|PB7|OC2/OC1C |Taimer/Loendur2 või Taimer/Loendur1 võrdlustulemuse väljastusüksus (C)+|11|PB7|OC0A/OC1C/PCINT7|Output Compare and PWM Output A for Timer/Counter0, Output Compare and PWM Output C for Timer/Counter1 or Pin Change Interrupt 7
-|12|PB6|OC1B ​    |Taimer/Loendur1 võrdlustulemuse väljastusüksus ​B| +|12|PB6|OC1B/​PCINT6|Output Compare and PWM Output ​for Timer/​Counter1 or Pin Change Interrupt 6
-|13|PB5|OC1A ​    |Taimer/Loendur1 võrdlustulemuse väljastusüksus ​A| +|13|PB5|OC1A/​PCINT5|Output Compare and PWM Output ​for Timer/​Counter1 or Pin Change Interrupt 5
-|14|PB4|OC0      ​|Taimer/Loendur0 võrdlustulemuse väljastusüksus+|14|PB4|OC2A/PCINT4|Output Compare and PWM Output A for Timer/Counter2 or Pin Change Interrupt 4
-|15|PB3|MISO ​    ​|SPI //master// andmete sisend / SPI //slave// väljund+|15|PB3|MISO/PCINT3|SPI Bus Master Input/Slave Output or Pin Change Interrupt 3
-|16|PB2|MOSI ​    ​|SPI //master// andmete väljund / SPI //slave// sisend+|16|PB2|MOSI/PCINT2|SPI Bus Master Output/Slave Input or Pin Change Interrupt 2
-|17|PB1|SCK ​     |SPI taktsignaal+|17|PB1|SCK/PCINT1|SPI Bus Serial Clock or Pin Change Interrupt 1
-|18|PB0|SS ​      ​|SPI //slave// valik+|18|PB0|SS/PCINT0|SPI Slave Select input or Pin Change Interrupt 0
-|19|PE7|INT7/​IC3 |Väline katkestus ​või Taimer/Loendur3 sündmuste püüdja sisend+|19|PE7|INT7/​IC3/CLK0 |External Interrupt ​Input, Timer/Counter3 Input Capture Trigger or Divided System Clock
-|20|PE6|INT6/​T3 ​ |Väline katkestus ​või Taimer/Loendur3 taktsignaali sisend+|20|PE6|INT6/​T3 ​ |External Interrupt ​Input or Timer/Counter3 Clock Input
-|21|PE5|INT5/​OC3C|Väline katkestus ​või Taimer/​Loendur3 võrdlustulemuse väljastusüksus ​C| +|21|PE5|INT5/​OC3C|External Interrupt ​Input or Output Compare and PWM Output ​for Timer/​Counter3
-|22|PE4|INT4/​OC3B|Väline katkestus 4 või Taimer/Loendur3 võrdlustulemuse väljastusüksus B+|22|PE4|INT4/​OC3B|External Interrupt4 Input or Output Compare and PWM Output B for Timer/Counter3
-|23|PE3|AIN1/​OC3A|Komparaatori negatiivne sisend või Taimer/​Loendur3 võrdlustulemuse väljastusüksus ​A| +|23|PE3|AIN1/​OC3A|Analog Comparator Negative Input or Output Compare and PWM Output ​for Timer/​Counter3
-|24|PE2|AIN0/​XCK0|Komparaatori positiivne sisend või USART0 ​taktsignaali sisend/väljund+|24|PE2|AIN0/​XCK0|Analog Comparator Positive Input or USART0 ​external clock input/output
-|25|PE1|PDO/​TXD0 |ISP Programmeerimisliidese väljund või UART0 andmete väljund+|25|PE1|PDO/​TXD0 |ISP Programming Interface Data Output or USART0 Transmit Pin
-|26|PE0|PDI/​RXD0 |ISP Programmeerimisliidese sisend või UART0 andmete sisend|+|26|PE0|PDI/​RXD0/INT8 |ISP Programming Interface Data Input, USART0 Receive Pin or Pin Change Interrupt 8|
  
-{{:kit:pa-pc.png?​450 ​ |}}+{{:kit:pa-pc_2561.png?​450 ​ |}}
 ~~CL~~ ~~CL~~
-^Nr^Viik^Alternatiivfunktsioon ​kirjeldus^^ +^Nr^Pin^Alternative function ​Description^^ 
-|1 |GND|- ​ |Maa |+|1 |GND|- ​ |Gnd |
 |2 |VCC|- ​ |+5 V | |2 |VCC|- ​ |+5 V |
-|3 |PA0|AD0|Välismälu-liidese aadressi- ja andmebitt ​0 | +|3 |PA0|AD0|External memory interface address and data bit 0 | 
-|4 |PA1|AD1|Välismälu-liidese aadressi- ja andmebitt ​1 | +|4 |PA1|AD1|External memory interface address and data bit 1 | 
-|5 |PA2|AD2|Välismälu-liidese aadressi- ja andmebitt ​2 | +|5 |PA2|AD2|External memory interface address and data bit 2 | 
-|6 |PA3|AD3|Välismälu-liidese aadressi- ja andmebitt ​3 | +|6 |PA3|AD3|External memory interface address and data bit   ​
-|7 |PA4|AD4|Välismälu-liidese aadressi- ja andmebitt ​4 | +|7 |PA4|AD4|External memory interface address and data bit   ​
-|8 |PA5|AD5|Välismälu-liidese aadressi- ja andmebitt ​5 | +|8 |PA5|AD5|External memory interface address and data bit   ​
-|9 |PA6|AD6|Välismälu-liidese aadressi- ja andmebitt ​6 | +|9 |PA6|AD6|External memory interface address and data bit   ​
-|10|PA7|AD7|Välismälu-liidese aadressi- ja andmebitt ​7 | +|10|PA7|AD7|External memory interface address and data bit   ​
-|11|-  ​|-  ​|Pole ühendatud ​                            +|11|PG4|TOSC1|RTC Oscillator Timer/​Counter2 ​                   ​
-|12|-  ​|-  ​|Pole ühendatud ​                            +|12|PG5|OC0B|Output Compare and PWM Output B for Timer/​Counter0
-|13|PG2|ALE|Välismälu-liidese aadressi lukustussignaal ​+|13|PG2|ALE|Address Latch Enable to external memory ​           ​
-|14|-  ​|-  ​|Pole ühendatud ​                            +|14|PG3|TOSC2|RTC Oscillator Timer/​Counter2 ​                   ​
-|15|PC6|A14|Välismälu-liidese aadressi- ja andmebitt ​14| +|15|PC6|A14|External Memory interface address bit 14           ​
-|16|PC7|A15|Välismälu-liidese aadressi- ja andmebitt ​15| +|16|PC7|A15|External Memory interface address bit 15           ​
-|17|PC4|A12|Välismälu-liidese aadressi- ja andmebitt ​12| +|17|PC4|A12|External Memory interface address bit 12           ​
-|18|PC5|A13|Välismälu-liidese aadressi- ja andmebitt ​13| +|18|PC5|A13|External Memory interface address bit 13           ​
-|19|PC2|A10|Välismälu-liidese aadressi- ja andmebitt ​10| +|19|PC2|A10|External Memory interface address bit 10           ​
-|20|PC3|A11|Välismälu-liidese aadressi- ja andmebitt ​11| +|20|PC3|A11|External Memory interface address bit 11           ​
-|21|PC0|A8 |Välismälu-liidese aadressi- ja andmebitt ​8 | +|21|PC0|A8 |External Memory interface address bit            
-|22|PC1|A9 |Välismälu-liidese aadressi- ja andmebitt ​9 | +|22|PC1|A9 |External Memory interface address bit            
-|23|PG0|WR |Välismälu kirjutussignaal ​                 ​+|23|PG0|WR |Write strobe to external memory ​                   ​
-|24|PG1|RD |Välismälu lugemissignaal ​                  +|24|PG1|RD |Read strobe to external memory ​                    
-|25|-  ​|-  |Pole ühendatud ​                            +|25|GND|-  |GND                            ​
-|26|-  ​|-  |Pole ühendatud ​                            |+|26|3V3|-  |+3,3 V                             |
  
-~~PB~~ +<​pagebreak>​
-=== Ühendamine ===+
  
-Kontrollermooduli ühendamisel teiste moodulite ning seadmetega on esimeseks ja viimaseks tegevuseks toite eemaldamine ja ühendamine. Ajal kui plaat on pingestatud,​ on ohtlik seadmeid ühendada. Mooduleid ja seadmeid tuleb omavahel ühendada ettevaatlikult ja liigset jõudu kasutamata, kuna ribakaabliga võib vale käsitlemise tulemusena kontaktid kergesti kõveraks painutada. Programmaatori ühendamisel veenduge, et kaabel saaks õiget pidi. JTAG-ICE programmaatori puhul on ribakaabel suunatud plaadist eemale (punane triip toitepesa pool).+== Connecting ==
  
-[{{:​kit:​kit_test.jpg?​580|Kontrollerplaadi ühendamine toite ja programmaatoriga}}]+When connecting the controller module with other modules or devices, you must first make sure that the controller module power supply is not connected. Modules and devices must be connected to each other with care. It is important not to use excessive force, wrong handling may damage the module. For programming and to power with low currency (less than 500mA) you must only connect the controller module with a PC using an USB port. If you are using modules that need to use a greater current than 500 mA, you must use a separate power source. If a controller module is connected to a separate power source, then the module automatically does not use USB a power supply
  
-==== Digitaalne sisend-väljundmoodul ====+[{{:​kit:​atmega2561_connected.jpg?​580|Controller module connected to power supply and programmer}}]
  
-Digitaalne sisend-väljundmoodul on mõeldud lihtsamateks harjutusteks ja elementaarseks protsessi juhtimiseks. Moodulil on kolm nupp-lülitit ja kolm valgusdioodi (LED), mida saab kasutada AVR sisend-väljundviikudega. Lisaks lihtsatele valgusdioodidele on moodul varustatud ka LED numberindikaatoriga ja LCD ekraanide väljunditega. Digitaalset moodulit on mugav kasutada koos teiste moodulitega,​ võimaldades juhtida näiteks mootoreid ja kuvada andurite lugemeid. Moodul on varustatud:+==== User Interface Module ====
  
-  * Rohelise, kollase ja punase valgusdioodiga (LED) +Please select the module version:
-  * Kolme mikrolülitiga. +
-  * 7-segmendilise numberindikaatoriga. +
-  * Alfabeetilise LCD ühenduspistikuga. +
-  * Graafilise LCD ühenduspistikuga (alates versioonist 3.2). +
-  * Ultraheli kaugusanduri ühenduspistikuga (alates versioonist 3.3).+
  
-{{:​examples:​digi:​digital_io_board.jpg?350|}}+---- 
 +Version III 1.0
  
-=== Elektrilised ühendused ===+[[en:​hardware:​homelab:​digi:​v3_1|{{:​{{:​kit:​userinterface:​kasutajaliides_iii.png?​400|}}]]
  
-[{{  :​examples:​digi:​digi_io_port_schematics.png?​308|Digitaalse- ja Kontrollermooduli vaheline ühendus}}] 
  
-Digitaalne sisend-väljundmoodul on Kontrollermooduli plaadiga ühendatud ühe ribakaabliga porti PA/PC/PG, mis koondab endas 8-viigulisi porte PA ja PC ning 3-viigulist porti PG. Lisaks saab moodul ribakaabli kaudu ka toite (+V). Kui moodul on õigesti ühendatud, peab moodulil olev väike roheline LED //+5V_OK// põlema minema. Kui LED ei sütti, võib põhjuseks olla ribakaabli vale ühendamine.+---
 +Version ​5.3
  
-Moodul on varustatud kolme nupugaS1, S2 ja S3, mis on ühendatud vastavalt PC0, PC1, PC2 viikudega. Nuppude teine ots on läbi kaitsetakistite ühendatud maaga (loogiline 0). Moodulil olevad 5 mm LED-idLED1, LED2 ja LED3 on ühendatud vastavalt PC3, PC4 ja PC5 viikudega. LED-ide teine ots (anood) on ühendatud toitega (loogiline 1).+[[en:hardware:homelab:​digi:​v53|{{:​examples:​ui:​UI_v53.jpg?​350|}}]]
  
-[{{  :​examples:​digi:​digi_io_button_led_schematics.png?​580 ​ |Nuppude ja LED-ide ühenduse skeem}}]+ 
 +---- 
 +Version 5.0 
 + 
 +[[en:​hardware:​homelab:​digi:​v50|{{:​examples:​digi:​ui_v.jpg?​350|}}]] 
 + 
 +---- 
 + 
 +Version 3 
 + 
 +[[en:​hardware:​homelab:​digi:​v3|{{:​examples:​digi:​digital_io_board.jpg?​230|}}]] 
 + 
 +---- 
 + 
 + 
 + 
 +<​pagebreak>​ 
 +=== User Interface module === 
 + 
 +The User Interface module is designed for simple tasks and basic process control. Module has three push-buttons and three LEDs, which can be used as digital inputs and outputs of microcontroller. Additionally to simple LEDs the module is equipped with 7-segment indicator, graphical LCD display, alphanumeric LCD outputs and a buzzer. User Interface module is handy to use along with other modules enabling to control the output device behavior, like motors and display the sensor readings. The module is covered with plexiglass to protect the board from accidents. 
 + 
 +Module features: 
 +  * Three LEDs: green, yellow and red; 
 +  * Three push-buttons;​ 
 +  * 7-segment indicator;​ 
 +  * Graphical LCD; 
 +  * Alphanumeric LCD connector;​ 
 +  * Buzzer; 
 + 
 +{{:​examples:​ui:​UI_v53.jpg?​450|}} 
 + 
 +== Electrical connections == 
 +User Interface module is connected to Controller module to ports PA/PC/PG, which includes the 8-pin ports PA and PC and 6-pin port PG. 
 + 
 +User Interface module is equipped with three buttons S1, S2, S3 which are connected to ports PC0, PC1, PC2 accordingly. The other end of buttons are connected through the resistors to ground (logical 0). LED1, LED2 and LED3 on the module are connected to the ports PC3, PC4, PC5 accordingly. The anodes of LEDs are connected to the supply (logical 1). 
 + 
 +[{{  :​examples:​ui:​ui_button_led_schematics_v51.png?​580 ​ |Schematics of buttons and LEDs}}]
  
 ~~CL~~ ~~CL~~
  
-Digitaalne sisend-väljundmoodul on varustatud ühe 7-segmendilise numberindikaatorigamis on ühendatud kolme mikrokontrolleri väljundviiguga läbi ajuri A6275. ​Ajuri andmesignaal ​(S-IN) ​on ühendatud viiguga ​PC6, taktisignaal ​(CLK) viiguga ​PC7 ja lukustussignaal ​(LATCH) ​viiguga ​PG2.+User Interface module is equipped with 7-segment indicatorwhich is connected to the microcontroller ports through the driver ​A6275. ​Driver data bus (S-IN) ​is connected to pin PC6, clock signal ​(CLK) to the pin PC7 and latch signal ​(LATCH) ​to pin PG2.
  
-[{{  :​examples:​digi:​digi_io_7seg_schematics.png?480  |7-segmendilise numberindikaatori ühenduse skeem}}]+[{{ :​examples:​digi:​digi_io_7seg_schematics_v51.png?580  |Schematics of 7-segment indicator}}]
  
 ~~CL~~ ~~CL~~
  
-Digitaalmooduli plaadil ​on eraldi välja toodud ​port PA. See on ühendatud samaaegselt kahte erinevasse viikude gruppi, kus esimene grupp on ühendatud läbi nivoomuunduri,​ võimaldades ühendada 3,3 V pingel töötavaid seadmeid (näiteks graafiline ​LCD) ja teine grupp on ühendatud otse porti PA (5 V nivoo) ning on joondatud vastavalt standardse tekstilise ​LCD viikude järgi. +The graphical LCD display ​on the module is connected to port PA. In parallel the same port has external connector where all pins are aligned according to the standard 2 x 16 alphanumeric ​LCD 4 bit control. The user can choose whether to use the graphical or alphanumeric ​LCD. It is not possible to use both at the same timeThe graphical LCD's background lighting can be logically controlled by the softwareThe back-light intensity of the alphanumeric LCD is regulated with on-board resistor and graphical LCD back-light can be controlled by the softwareBoth LCD displays are connected to port PA but only one at a time can be used. When selecting the alphanumeric LCD the jumper should be removed to avoid random control of graphical LCD background light.
-Eraldi on välja toodud port PG kaks kasutamata viiku - PG0 ja PG1, kuhu on võimalik ühendada lisaseadmeid,​ nagu näiteks ultraheli andur (alates mooduli versioonist 3.3)NB! Ultraheli anduri ühendamisel jälgida toite ja signaali kaablite viike, mida ei tohi omavahel segamini ajada. Signaali kaabel tuleb ühendada viikudega, mis on plaadil tähistatud 1 ja 2Toitekaabel tuleb ühendada nii, et anduri maa (must juhe) oleks ühendatud plaadil oleva maa viiguga, mis on tähistatud märgiga GND.+
  
-[{{  :examples:digi:digi_io_porta_portg_schematics.png?​580 ​ |LCD ekraanide ühenduse skeem}}]+[{{:​examples:​ui:ui_lcd_schematics_v51.png?580|Schematics of LCD}}]
  
-=== Mooduli ühendamine ===+~~CL~~
  
-Mooduli ühendamine on soovitatav teostada alltoodud järjekorrasEnne ühendamist veenduda, et Kontrollermooduli toide oleks lahti ühendatud.+The buzzer is connected with controller board'​s pin PG5 and with VccIt's possible to generate sound with Robotic Homelab library or with your own software.
  
-  - Ühendada Digitaalne sisend-väljundmoodul Kontrollermooduliga,​ kasutades ribakaablit. +[{{  :​examples:​ui:​ui_speaker_schematics.png?​150 ​ |Schematics of buzzer}}]
-  - Ühendada vajadusel JTAG programmaator Kontrollermooduliga. +
-  - Ühendada Kontrollermooduli toide.+
  
-[{{:​examples:​digi:​digital_io_connection.jpg?​580|Digitaalse sisend-väljundmooduli ühendamine}}] +== Connecting the module ​==
-==== LCD moodul ​====+
  
-LCD moodul on moodul, mis hõlmab endas Digitaalse sisend-väljundmooduli ühendusi ja erinevat tüüpi LCD ekraaneDigitaalse mooduli külge on võimalik ühendada 5 V nivool töötavaid alfabeetilisi LCD ekraane ja 3,3 V nivool töötavaid graafilisi LCD ekraane (alates Digitaalmooduli versioonist 3.2). Alfabeetilise ekraani kontrastsuse reguleerimiseks on Digitaalmooduli plaadil väike potentsiomeeter (LCD_BG). Graafilise LCD ekraani kontrastsust reguleeritakse tarkvaraliselt. LCD ekraanid ühendatakse porti PA. Korraga saab kasutada ainult ühte LCD ekraani.+While connecting the module it is suggested to follow the order described belowBefore connecting any cables make sure that the power is removed from the Controller board.
  
-=== LCD ekraani ühendamine ===+  - Connect the User Interface module with the Controller module gently. 
 +  - If needed, connect the JTAG programmer with the Controller module. 
 +  - Connect the power supply with the Controller module.
  
-Mooduli ühendamisel on soovitatav järgida allolevat järjekorda ja enne ühendamist veenduda, et Kontrollermooduli toide on lahti ühendatud.+{{:​kit:​homelab_modules5.jpg?​500|}} 
 +==== Combo module ====
  
-  - Ühendada Digitaalne sisend-väljundmoodul Kontrollermooduliga kasutades ribakaablit. +=== Robotic HomeLab III generation ===
-  - Ühendada alfabeetiline või graafiline LCD ekraan Digitaalmooduliga (korraga ainult üks). +
-  - Ühendada vajadusel JTAG programmaator Kontrollermooduliga. +
-  - Ühendada Kontrollermooduli toide.+
  
-[{{:​examples:​display:​lcd_connection.jpg?​580|LCD ekraanide ühendamine}}] +---- 
-==== Andurite moodul ====+Version 1.0
  
-Andurite moodul koosneb integreeritud andurite ja madalpääsu filtri plaadist ning kaugusanduritest.+[[en:​hardware:​homelab:​combo:​v3_1|{{:​{{:​kit:​combo:​kombo_iii.png?​370|}}]]
  
-Anduri moodul on varustatud:+---- 
 +=== Robotic HomeLab II generation ===
  
-  * Ultraheli kaugusanduriga Devantech SRF05 koos kaabliga (mõõtepiirkond ​1-400 cm) {{:​kit:​datasheets:​srf05tech.pdf|andmeleht}} +Version ​1.3
-  * Infrapuna kaugusandur Sharp GP2Y0A21YK0F (mõõtepiirkond 10-80 cm) {{:​kit:​datasheets:​sharp_gp2y0a21yk0f.pdf|andmeleht}} +
-  * Valgustundlik andur (fototakisti) VT935G (takistus 18,5 kΩ 10 lux juures) {{:​kit:​datasheets:​ldr.pdf|andmeleht}} +
-  * Temperatuuriandur (NTC termistor) (takistus 10 kΩ 25 °C juures) {{:​kit:​datasheets:​ntc10k.pdf|andmeleht}} +
-  * Potentsiomeeter 5 kΩ+
  
-{{:examples:sensor:sensor_board.png?290|Andurite plaat}}+[[en:​hardware:​homelab:​combo:​v13|{{:​{{:kit:combo:combo_xbeega.jpg?350|}}]]
  
-=== Elektrilised ühendused ===+---- 
 +Version 1.2
  
-[{{:examples:sensor:sensor_schematics_portf.png?220|Andurite- ja Kontrollermooduli vaheline ühendus}}]+[[en:​hardware:​homelab:​combo:​v12|{{:​{{:kit:combo:combo_12.jpg?350|}}]]
  
-~~CL~~+---- 
 +Version 1.1
  
-== Andurid ==+[[en:​hardware:​homelab:​combo:​v11|{{:​kit:​combo:​combo_xbeega.jpg?​350|}}]]
  
-[{{  :​examples:​sensor:​sensor_schematics_sensor.png?​320|Andurite ühenduse skeem}}]+---- 
 +Version 1.0
  
-Andurid on ühendatud läbi silla (inglise keeles //​jumper//​),​ võimaldades mikrokontrollerisse suunata kas välise anduri signaali (ühendatud pistikusse CON2) või plaadil oleva anduri signaali. Vaikimisi on analoogsisenditega (ADC0-ADC3) ühendatud kõik plaadil olevad andurid. Andurite mooduli plaat võimaldab lisaks plaadil olevatele anduritele analoog-digitaalmuunduri sisenditesse ühendada ka väliseid analoogväljundiga andureid. Selleks saab kasutada kanaleid ADC4-ADC7, mis on välja toodud pistikust CON2. Tähelepanu tuleks pöörata aga asjaolule, et ATmega128 kasutab samu ADC4-ADC7 viike (PF4-PF7) ka JTAG programmaatori tööks. Mõlemat funktsiooni korraga kasutada ei saa, mikrokontrolleri saab seadistada kasutama vaid üht neist. Kui sellegipoolest soovitakse kasutada väliseid andureid koos JTAG programmaatoriga,​ tuleb sildade abil ADC0-ADC3 kanalid plaadil olevatelt anduritelt välistele viikudele ümber lülitada.+[[en:​hardware:​homelab:​combo:​v10|{{:​kit:​combo:​combo_xbeega.jpg?​350|}}]]
  
-~~CL~~+----
  
-== Madalpääsu filter ​== +<​pagebreak>​ 
-[{{  :​examples:​sensor:​sensor_schematics_lowpass.png?​320|Madalpääsu filtri ühenduse skeem}}]+=== Combo module III ===
  
-Madalpääsu RC filtri saab koostada analoogsisendite 0-3 vahele (viigud PF0-PF3)Madalpääsu filtri koostamiseks paigutatakse vastavatesse pesadesse takisti ja kondensaatorVaikimisi on madalpääsu filter koostatud kanalile PF0Takisti väärtuseks ​on 10 kΩ ja kondensaatori väärtuseks 100 nF.+Combo board is designed to connect external devices to the Robotic Homelab KitExternal devices are conditionally divided into three groups: sensors, motors and communication interfacesEach group of devices has its own set of connectors, which are separated from each otherFor example, connectors for sensors are located in the right part of the module, motors plugs are located ​on the left and communication interface plugs on top of the module.The plugs for sensors and communication interfaces are connected directly to the controller’s corresponding signal pins, but the connectors of motors are connected to the controller’s pins through the drivers. This allows Combo module to drive more powerful motors which are not drivable to the direct microcontroller pins.
  
 +Combo board is able to drive following motors:
 +  * 4 x DC motors
 +  * 1 x unipolar stepper motor
 +  * 4 x servomotor
 +
 +Connect following sensors:
 +  * 11 x analog
 +  * 8 x digital
 +  * 4 x coder
 +
 +Use the following communication interfaces:
 +  * UART (3,3 V supply)
 +  * Bluetooth / ZigBee / RFID / WiFi / GPS wireless communication modules
 +
 +The default is installed //​Bluetooth//​ BTBee Pro wireless communication module.
 +
 +[{{  :​kit:​combo:​kombo_iii.png?​499 ​ |Combo board with BTBee module}}]
 +
 +== Electrical connections ==
 +
 +The Combo module plugs are divided into three major groups. The connectors for sensors are located in the right side of the module, motors plugs are located on the left side and communication interface plugs in the top right of the module. The motor connectors are divided into three groups: DC motor, servo motor, and stepper motor. DC and stepper motor feeds come from the Controller module power cord, servo motors feed comes through 5V voltage regulator also from Controller module power cord. Servo motor connector is also multifunctional,​ which can optionally be connected to the encoder input, which is often used in conjunction with DC motor. Each connector pin is connected to the specific port, supply or ground on the Controller module. The following diagrams illustrate the position of a specific group of pins, connectors and connections with Controller module.
 +
 +**The group of sensors**
 +
 +{{:​kit:​combo:​combo_anduripistik.png?​500 |}}
 ~~CL~~ ~~CL~~
-~~PB~~+{{:​kit:​combo:​viigud.png?​500 |}}
  
-=== Mooduli ühendamine ===+~~CL~~ 
 +~~CL~~ 
 +<​pagebreak>​  
 +**The group of motors** 
 +~~CL~~ 
 +{{:​kit:​combo:​combo_mootoripistik.png?​500 |}} 
 +~~CL~~ 
 +{{:​kit:​combo:​viigud_mootorid.png?​500 |}}
  
-Mooduli ühendamisel on soovitatav järgida allolevat järjekorda ja enne ühendamist veenduda, et Kontrollermooduli toide on lahti ühendatud. 
  
-  - Ühendada moodul Kontrollermooduliga (20 soonega ribakaabel)NB! Kontrollermooduliga ühendatakse pistikupesamis on tähistatud nimega PF (CON1).  +== Sensors== 
-  - Ühendada vajadusel infrapuna kaugusandur (must juhe - GND). += ADC sensor inputs= 
-  - Ühendada vajadusel Digitaalmoodul ja LCD ekraan. +The Combo module has 11 ADC input for an analog sensorsThe sensor inputs are moved into the left part of the sensors connectorwhere each sensor has a separate ​GND, +3.3 V power supply and signal pin. GND connection is lowest.
-  - Ühendada vajadusel ultraheli kaugusandur (must juhe - GND).   +
-  - Ühendada Kontrollermooduli toide.+
  
-[{{:​examples:​sensor:​sensor_connection.jpg?​580|Andurite mooduli ühendamine}}] 
  
-==== Mootorite moodul ====+/* 
 +|ADC10|ADC9|ADC8|ADC7|ADC6|ADC5|ADC4|ADC3|ADC2|ADC1|ADC0^+3.3V| PF0 | PE4 | PE2 | PE0 | 
 +^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V| PF1 | PE6 | PE3 | PE1 | 
 +| GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | 
 +*/
  
-Mootorite moodul koosneb mootorite juhtplaadist ja erinevatest mootoritest. Mootoriplaat on  projekteeritud AVR ATmega128 kontrolleriplaadiga ühendamiseks,​ kuid seda saab edukalt kasutada ka teiste mikrokontrollerite ja mootoritega,​ sest sisaldab H-sildu (L293D), mis on mootorite juhtimisel üldlevinud.+{{:​kit:​combo:​viigud_analoog.png?500|}}
  
-Mootoriplaat eraldab mootorite toited juhtsignaalidest ning võimaldab ühe ribakaabliga ühendada kõik juhtsignaalid kontrollerplaadiga.+/* 
 +|ADC10|ADC9|ADC8|ADC7|ADC6|ADC5|ADC4|ADC3|ADC2|ADC1|ADC0^+3.3V|  
 +^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V^+3.3V| 
 +| GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | GND | 
 +*/
  
-{{:​examples:​actuator:​actuator_board.jpg?​400|Mootoriplaat}}+= Digital inputs = 
 +Combo board has 8 digital pins where to connect digital sensorsThe digital inputs are moved into the right part of the sensors connector
  
-Moodul võimaldab juhtida erinevaid mootoritüüpe ning kõigil tüüpidel võib olla erinev toitepinge. Mooduli (ühendus)võimalused:​+/* 
 +| PF0 | PE4 | PE2 | PE0 | 
 +| PF1 | PE6 | PE3 | PE1 | 
 +| GND | GND | GND | GND | 
 +*/
  
-  * 4 x alalisvoolumootor või 3 x alalisvoolumootor ja 2 x kooder. +{{:​kit:​combo:​viigud_digitaal.png?500|}}
-  * 2 x unipolaarne samm-mootor. +
-  * 1 x bipolaarne samm-mootor. +
-  * 2 x RC servomootor. +
-  * Eraldi UART pistik. +
-  * Juhtkiipide toite valiku sild JP1 (kontrollerplaadilt või väline). +
-  * Toite LED.+
  
-Mootorite mooduli toitepistik (PWR): 
  
-^ Viik  ^ Ühenduspunkt ​                    ^ Pinge   ^ Vool ^ += Supply voltage measurement circuit ADC0 = 
-| 1    | DC mootorid ​                     | kuni 36 V  | kuni 600 mA | +In additionit is possible to measure the supply voltage of the Combo module. In this case a jumber could be added to Vbat. ADC0 pin is then connected to a voltage divider. This option can be useful for robots to monitor the battery voltage while driving.
-| 2    | Bipolaarne samm-mootor ​          | kuni 36 V  | kuni 600 mA | +
-| 3    | Servomootorid ​                   | 4,8 - 6 V  | kuni 1 A    | +
-| 4    | Unipolaarsed samm-mootorid ​      | kuni 50 V  | kuni 500 mA | +
-| 5    | Loogika toide (valitav JP1 abil) | 5 V        |             ​| ​  +
-| 6    | Maa (GND)                        |            |             ​|  ​+
  
-NB! Pinge ja vool sõltuvad eelkõige kasutatavast mootorist ja ei tohi ületada mootori lubatavaid piirväärtusi. Kodulabori komplektis sisalduvate mootorite toide on üldjuhul 5 - 6 V ja vastavalt sellele on kaasasoleva harukaabli väljundpinged limiteeritud 5 või 6 V.+[{{:​kit:​combo:​cRef.png?​130|DC_REF schematic}}]
  
-=== Mootorid ===+^ Resistor^ Value^  
 +| Higher| 6.8k |  
 +| Lower| 1k   ​|  ​
  
-Mootori konkreetsed margid ja mudelid võivad Kodulabori komplektides varieerudakuid igas komplektis on alati 1 alalisvoolumootor1 samm-mootor (unipolaarne või bipolaarne) ja 1 RC servomootor.+= Coder= 
 +Coder shares pins of the //Servo// output to be able to use four servo motorsor obtain feedback from four codersor share the connector halves. The encoder is connected to //​Servo ​Encoder// connector.
  
-Allpool on toodud võimalikud mootorid, mis esinevad Kodulaborite komplektides.+[{{:​kit:​combo:​cServ-Enc.png?​330|Coder connection scheme}}]
  
-  * **Alalisvoolumootor** +^ AVR pin^ Signal^ 
-    * Micromotors L149.6.10 ​(reduktor{{:​kit:​datasheets:​actuators:​dc_gearmotor_6v_25rpm.pdf|andmeleht}} +| PC4(INT0C) | Coder | 
-    * Micromotors L149.6.43 (reduktor) {{:​kit:​datasheets:​actuators:​dc_gearmotor_6v_25rpm.pdf|andmeleht}} +PC5(INT1C) | Coder 
-    * Micromotors LE149.6.10 ​(reduktor + kooder{{:​kit:​datasheets:​actuators:​dc_gearmotor_6v_52rpm_encoder.pdf|andmeleht}} +PD0(INT0D) ​Coder 
-  * **RC servomootor** +PD1(INT1D| Coder |
-    * Robbe FS 100 {{:​kit:​datasheets:​actuators:​servo_robbe_fs100.pdf|andmeleht}} +
-    * E Sky EK2-0501 {{:​kit:​datasheets:​actuators:​servo_esky_ek2-0501.pdf|andmeleht}} +
-    * Futaba XT-S  +
-    * Hitec HS422 {{:​kit:​datasheets:​actuators:​servo_hs422.pdf|andmeleht}} +
-  * **Unipolaarne samm-mootor** +
-    * Ming Jong ST35 {{:​kit:​datasheets:​actuators:​stepper_motorst35.pdf|andmeleht}} +
-  * **Bipolaarne samm-mootor** +
-    * Moons 42PM {{:​kit:​datasheets:​actuators:​moons_bipolar_stepper_motors.pdf|andmeleht}} +
-    * Ming Jong ST28 {{:​kit:​datasheets:​actuators:​stepper_motor_st28.pdf|andmeleht}} +
-  * **Pieso heligeneraator** ​(valikuline)+
  
-[{{  :examples:motor:motors.jpg?​400  ​|Mootorid}}]+<​pagebreak>​ 
 += DC motors= 
 +DC motors is connected to the DC group of pins. Every pair of pins can control 1 dc motor, thus it's possible to manipulate 4 dc motors. ​Combo board uses [[http://​www.ti.com/​lit/​ds/​slvs855h/​slvs855h.pdf|DRV8801]] H-bridge to control dc motors. It's possible to manipulate some other device, what can be controlled digitally and it's current is smaller than 1,5 A and voltage does not exceed 16 V, beside dc motor with DC pins (Piezoelectric generator, relay etc).
  
-~~PB~~+[{{:​kit:​combo:​cHBridge.png?​300|DC motor connection scheme}}]
  
-=== Elektrilised ühendused ===+^ AVR pin   ^ Signal ​   ^ AVR\ pin ^ Signal ^ 
 +| PC0(OCC0A) | Motor\ 1A | PJ4 | Motor\ 1B | 
 +| PC1(OCC0B) | Motor 2A | PJ5 | Motor 2B | 
 +| PC2(OCC0C) | Motor 3A | PJ6 | Motor 3B | 
 +| PC3(OCC0D) | Motor 4A | PJ7 | Motor 4B |
  
-Mootoriplaat tuleb Kontrollermooduli plaadiga ühendada ühe ribakaabliga Kontrollerimooduli porti PE-PB-PD. Mootorite toited ühendatakse eraldi PWR pistikuga, kus igale mootori tüübile on võimalik anda erinev toitepinge, sõltuvalt kasutatavast mootori tüübist. Plaadil olevaid kiipe on võimalik toita välise toiteallikaga või otse kontrollerplaadilt. Selle määrab plaadil olev sild JP1. Kui sild ühendab viigud 1 ja 2, siis kiipide toide võetakse otse Kontrollermoodulist. Kiipide korrektse toite olemasolu saab kontrollida plaadil oleva väikese rohelise LED +5V abil. Mootoriplaadil on eraldi välja toodud ka UART ühendus, mis võimaldab läbi mootoriplaadi ühendada UART protokolliga ühilduvaid seadmeid.+{{:​kit:​combo:​viigud_dc.png?500|}}
  
-[{{  ​:examples:​motor:​actuator_schematics_port_pwr.png?​580 ​ |Mootorimooduli ja Kontrollermooduli plaatidevaheline ühenduspistikMootoriplaadi toite ühendus ja UART pistiku ühendus}}]+= Stepper motors = 
 +Stepper motors generally divided into two categoriesunipolar- and bipolar stepper motorsUnipolar stepper motors can be connect pins group //Unipolar Stepper//where the power cable must be connected to the //Vbat// pin. The remaining four pins are stepper motor driver coil pins. Bipolar stepper motor can be driven with the DC motor pins where one bipolar stepper motor requires two DC motor driver.
  
-== Alalisvoolumootor ==+[{{:​kit:​combo:​cStepper.png?​350|Unipolar stepper connection scheme}}]
  
-Alalisvoolumootorid ühendatakse pistikute gruppi DC1. Iga paari külge on võimalik ühendada üks mootor - kokku 4 mootorit. Mootori pistikuga 3 on paralleelselt ühendatud koodrite ENC1 ja ENC2 pistikud. Kui soovitakse kasutada mootoreid koos koodritega, siis mootoripistikut 3 samaaegselt kasutada ei saa (tarkvaraliselt muudetakse see sisendiks). Mootoreid juhitakse üldlevinud kahe integreeritud H-silla kiipidega L293D, mis mõlemad on võimelised juhtima samaaegselt kahte mootorit. Mootorid võib asendada ka muude täituritega (näiteks pieso heligeneraator,​ relee jms.), mida saab juhtida digitaalsete signaalidega ja millede maksimaalne vool ei ületa 500 mA.+^ AVR pin ^ Signal ^ 
 +| PJ0 | Winding 1A  | 
 +| PJ1 | Winding 2A  | 
 +| PJ2 | Winding 1B  | 
 +| PJ3 | Winding 2B  |
  
-~~PB~~+{{:​kit:​combo:​viigud_stepper.png?​500|}}
  
-[{{  :​examples:​motor:​actuator_dc_schematics.png?​580 ​ |Alalisvoolumootori ühenduse skeem}}]+= Servomotors= 
 +Servo is connected to //Servo - Encoder// pins. Ground wire (usually black or braun) is connected to the //GND// pin (lower pin). It's possible to use 4 servomotors at once. Signal pins on the Combo board is directly connected to the controller'​s timer'​s output pins.
  
-^ AVR viik ^ Juhtsignaal ^ AVR viik ^ Juhtsignaal ^ +[{{:​kit:​combo:​cServ-Enc.png?​400|Servomotor connection scheme}}]
-| PB4 | Mootor 1 1A | PD6 | Mootor 3 1A | +
-| PB7 | Mootor 1 2A | PD7 | Mootor 3 2A | +
-| PD0 | Mootor 2 1A | PD4 | Mootor 4 1A | +
-| PD1 | Mootor 2 2A | PD5 | Mootor 4 2A |+
  
-== Samm-mootorid ==+^ AVR pin ^ Signal ^ 
 +| PC4(OCC1A) | PWM  | 
 +| PC5(OCC1B) | PWM  | 
 +| PD0(OCD0A) | PWM  | 
 +| PD1(OCD0B) | PWM  |
  
-Mootoriplaat toetab kahe erinevat tüüpi samm-mootori kasutamistPlaadile on võimalik ühendada 2 unipolaarset samm-mootorit ja 1 bipolaarne samm-mootor. Bipolaarset samm-mootorit juhitakse H-sillaga L293D ja unipolaarset samm-mootorit transistorite jadaga ULN2803. Mootorite juhtsignaalide mustrid genereeritakse tarkvaraliselt. Samm-mootorite ühendamisel on oluline jälgida mähiste järjekorda. Unipolaarse samm-mootori toiteotsad ühendatakse viikudesse 1 ja 2. Kui tegemist on viie juhtmelise unipolaarse samm-mootoriga,​ siis toite ots ühendatakse viiku 2 ja viik 1 jääb vabaks. Samm-mootorite ühendused:+{{:​kit:​combo:​viigud_servo.png?500|}}
  
-^ Pesa viik  ^ Mähise ots ^ Unipolaar 1 ^ Unipolaar 2 ^ Bipolaar ^ 
-| 1  | 1   | + toide | + toide |      | 
-| 2  | 2   | + toide | + toide |      | 
-| 3  | 1a  | PE0     | PE4     | PB0  | 
-| 4  | 2a  | PE1     | PE5     | PB1  | 
-| 5  | 1b  | PE2     | PE6     | PB2  | 
-| 6  | 2b  | PE3     | PE7     | PB3  | 
  
 +== Serial interface==
  
-[{{:​examples:​motor:​stepper:​samm_mootorid_skeem.png?​580|Unipolaarse (vasakul) ja bipolaarse (paremal) samm-mootori mähised}}]+The Combo module can be connected to the external UART or SPI devices.
  
-[{{:examples:motor:actuator_stepper_schematics.png?580|Samm-mootorite ühenduse skeem}}]+[{{:kit:combo:cUART.png?200|The external UART device Schematics}}]
  
-== Servomootor ​==+== Wireless module ​== 
 +One of these modules can be connected to the Combo board: 
 +  * XBee/ZigBee module 
 +  * Bluetooth 
 +  * GPS module 
 +  * RFID module 
 +  * Wifi module 
 +All of these module communicate over the UART interface with the microcontroller. 
 +By default //​bluetooth//​ module //​BluetoothBee Pro// is connected to the Combo module..
  
-RC servomootorid ühendatakse mootoriplaadi pistikutesse PWM1 ja PWM2. Mootorid ühendatakse nii, et signaali juhe (tavaliselt kollane või valge) jääb viiku 1 (plaadi ääre pool). Sama-aegselt on võimalik kasutada kahte servomootorit. Mootorite juhtsignaalid on ühendatud otse kontrolleri taimerite väljundviikudega.+[{{:​kit:​combo:​cXBee.png?​450|Wireless connection scheme}}] 
 +~~CL~~
  
-^ AVR viik  ^ Juhtsignaal ^ +Combo board is connected with 4 wireless module'​s i/o pins, in addition XBee //DIO4// is connected to test LED. XBee pin //AD5// is connected to the voltage divider for measuring the voltage across the XBee wireless network.
-| PB5(OC1A) | PWM1        | +
-| PB6(OC1B) | PWM2        |+
  
-== Mootorite ühendused ==+BluetoothBee Pro module 
 +^ Pin from wireless module ^ Signal ^ Socket ^ 
 +| 20(MODE) ​              | MODE  | XBEEADC0 ​                    | 
 +| 19(STATUS) ​            | STATUS| XBEEADC1 ​                    | 
 +| 17(A_RST) ​             | XADC3 | XBEEADC3 ​                    |
  
-[{{  :​examples:​motor:​actuator_motor_con_schematics.png?​400 ​ |Mootorite ühendused}}] 
  
-~~PB~~+XBee module 
 +^ Pin from wireless module ^ Signal ^ Socket ^ 
 +| 20(AD0/​DIO0) ​          | XADC0 | XBEEADC0 ​                    | 
 +| 19(AD1/​DIO1) ​          | XADC1 | XBEEADC1 ​                    | 
 +| 18(AD2/​DIO2) ​          | XADC2 | XBEEADC2 ​                    | 
 +| 17(AD3/​DIO3) ​          | XADC3 | XBEEADC3 ​                    | 
 +| 11(RF_TX/​AD4/​DIO4) ​    | DIO4  | test LED (yellow) ​           | 
 +| 15(ASSOC/​AD5/​DIO5) ​    | PWR   | Connected with robot'​s power supply ​    | 
 +| 16(RTS/​AD6/​DIO6) ​      | RST   | Reset pin form controller module| 
 +==== Combo module ====
  
-=== Mooduli ühendamine ​===+=== Robotic HomeLab III generation ​===
  
-Mooduli ühendamisel on soovitatav järgida allolevat järjekorda ja kontrollerplaadi toitepistik ühendada alati kõige viimasena.+---- 
 +Version 1.0
  
-  - Ühendada Mootorite mooduli plaat Kontrollermooduli plaadiga, kasutades ribakaablit. +[[en:​hardware:​homelab:​combo:​v3_1|{{:​{{:​kit:​combo:​kombo_iii.png?​370|}}]]
-  - Ühendada mootor(id). +
-  - Ühendada Mootorite mooduli plaat toitekaabliga. +
-  - Ühendada Kontrollermooduli toide.+
  
-[{{:​examples:​actuator:​actuator_connection.jpg?​580|Mootorite mooduli ühendamine}}] +---- 
-===== Kodulabori teek =====+=== Robotic HomeLab II generation ​===
  
-Kodulabori teek moodustub mitmetest C-keele päisefailidest ("​.h"​ laiendiga) ja ühest staatiliselt C-keele teegi failist ("​.a"​ laiendiga). Teegi installeerimisel kopeeritakse kõik teegi failid AVR-GCC alamkaustadesse,​ kust kompilaator nad lihtsalt üles leiab. Kasutaja teeki või selle osasid oma rakenduse kausta kopeerima ei pea.+Version 1.3
  
-[{{  :images:homelab:library:homelab_library_files.png|Kodulabori teegi lähtekoodi failipuu}}]+[[en:​hardware:​homelab:​combo:​v13|{{:{{:kit:combo:combo_xbeega.jpg?350|}}]]
  
-Sellest, kuidas Kodulabori teeki reaalselt Windows ja Linux operatsioonisüsteemidega kasutama hakata, räägivad esimesed kaks praktilist harjutust. Erinevaid teegi osasid kasutavad erinevad harjutused. Eranditult tuleb igasse teeki kasutavasse projekti kaasata teegi "​.a"​ fail mis lingitakse kompilaatori poolt projekti kompileeritud failiga. Päisefaile tuleb kaasata vastavalt vajadusele. AVR-iga seotud teegi osade päisefailid asuvad "​homelab"​ kaustas, Kodulabori moodulitega seotud teegi osad "​homelab/​module"​ kaustas. Nimetatud kaustad asuvad kompilaatori juurkaustas ja neist failide kaasamiseks peab faili nime kirjutama suurendusja vähendusmärkide vahelNäide AVR-i viikude ja Kodulabori Mootorite mooduli teegi kaasamisest:​+---- 
 +Version 1.2
  
-<code c> +[[en:​hardware:​homelab:​combo:​v12|{{:​{{:​kit:​combo:​combo_12.jpg?​350|}}]]
-#include <homelab/pin.h> +
-#include <​homelab/​module/​motors.h>​ +
-</​code>​+
  
-Kui Kodulabori teeki ei kasutata, siis on vajalik AVR-i registrite kasutamiseks kaasata projekti: +---- 
-<code c> +Version 1.1
-#include <​avr/​io.h>​ +
-</​code>​ +
-Teegi kasutamise korral seda eraldi teha ei ole vaja, kuna on kaasatud juba failis //pin.h//.+
  
-Kodulabori veebilehel on vabalt kättesaadav Kodulabori teegi lähtekood, mida on võimalik kohandada vastavalt oma projekti vajadusteleAllalaetavas teegis on ka lisafunktsioone,​ mida käesolev raamat ei kirjelda. Järgnevad peatükid kirjeldavad teegi erinevaid osasid mida kasutatakse raamatu näidisprogrammides. +[[en:​hardware:​homelab:​combo:​v11|{{:​kit:​combo:​combo_xbeega.jpg?​350|}}]]
-==== Bitioperatsioonid ====+
  
-Bitioperatsioonide teek on üldkasutatav makrofunktsioonide kogum tüüpiliste bititehete teostamiseks. Neid funktsioone võib kasutada ükskõik milliste registrite või andmetüüpide puhul, sest makrofunktsioonidel pole kindlat andmetüüpi. Funktsioonid sobivad nii 8-, 16kui ka 32-bitiste muutujate ning registrite jaoks. Neid bitioperatsioone kasutavad kõik teised teegi osad, seepärast on lähtekoodi alampeatükis funktsioonid ka välja kirjutatud.+---
 +Version 1.0
  
-Bitiindeksiks loetakse biti järjekorranumbrit,​ alustades kõige vähemtähtsast (inglise keeles //least significant bit//, lühend LSB). Loendamine algab nullist. 8-bitiste arvude puhul on bitiindeksi väärtus 0-7, 16-bitiste puhul 0-15 ja 32-bitiste puhul 0-31.+[[en:​hardware:​homelab:​combo:​v10|{{:​kit:​combo:​combo_xbeega.jpg?​350|}}]]
  
-=== Funktsioonid ​===+---- 
 + 
 +===== HomeLab Library ===== 
 + 
 +HomeLab library is composed of several C language header files (with "​.h"​ extension) and one static library file (with "​.a"​ extension"​). Upon library installation,​ all these files are copied to the AVR-GCC subdirectories where the compiler finds them automatically. The user does not have to copy these files to his or her program folder. 
 + 
 +[{{  :​images:​homelab:​library:​homelab_library_files.png|HomeLab library source code files}}] 
 + 
 +Step-by-step AVR development software installation instructions for Windows and Linux are written in the first chapter of practical examples. Although different practical examples use various parts of the library, all of them must include a static library ("​.a"​ file) in the project. Only header files can be included selectively. Header files which are directly related to the AVR microcontroller are in the "​homelab"​ folder, HomeLab module specific files are in the "​homelab/​module"​ folder. Both these folders are in the compiler'​s root folder, and to include the files from them, less-than and greater-than signs are needed to specify the path. An example of how to include AVR pins and HomeLab motors library header files: 
 + 
 + 
 +#include  
 +#include  
 + 
 + 
 +If HomeLab library is not used, then the following avrlibc header file needs to be included into the project: 
 + 
 + 
 +#include  
 + 
 + 
 +In the HomeLab library, this file is already included in the //pin.h// file. 
 + 
 +HomeLab library installer is freely available on the HomeLab web-page. Users who are interested in customizing the library can also download the source code for it. The following chapters describe the functionality of the library.  
 +==== Bitwise Operations ==== 
 + 
 +Bitwise operations library contains a set of macro functions to do common bit manipulation operations. They are used by the rest of the library and can be used everywhere else. As the macro-functions have no type, they are compatible with any data type. 
 + 
 +Bit index is used to specify the bit in the binary number. Indexes are counted from zero, where zero represents the least significant bit (LSB). For example, an 8-bit number has 8 bits with indexes from 0 to 7 and a 16-bit number has 16 bits with indexes from 0 to 15. 
 + 
 +=== Functions ​===
  
   * **//​bit_mask(bit)//​** \\   * **//​bit_mask(bit)//​** \\
-    ​Bitiindeksi teisendamine bitimaskiksParameetrid+    ​Bit index to bit mask convertingParameters
-    * //bit// - Bitiindeks+    * //bit// - Bit index
-    * Tagastab bitimaski.+    * Returns bit mask.
  
   * **//​bit_set(value,​ bit)//** \\   * **//​bit_set(value,​ bit)//** \\
-    ​Muutujas kindla biti kõrgeks seadmineParameetrid+    ​Sets a specified bit in the variableParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks.+    * //bit// - Bit index.
  
   * **//​bit_clear(value,​ bit)//** \\   * **//​bit_clear(value,​ bit)//** \\
-    ​Muutujas kindla biti madalaks seadmineParameetrid+    ​Clears a specified bit in the variableParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks.+    * //bit// - Bit index.
  
   * **//​bit_set_to(value,​ bit, state)//** \\   * **//​bit_set_to(value,​ bit, state)//** \\
-    ​Muutujas kindla biti soovitud olekusse seadmineParameetrid+    ​Set a specified bit in the variable to desired stateParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks+    * //bit// - Bit index
-    * //state// - Tõeväärtus ​(//​true// ​või //false//).+    * //state// - State (//​true// ​or //false//).
  
   * **//​bit_invert(value,​ bit)//** \\   * **//​bit_invert(value,​ bit)//** \\
-    ​Muutujas kindla biti oleku ümberpööramine (madal kõrgeks ja vastupidi)Parameetrid+    ​Inverts a specified bit in the variableParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks.+    * //bit// - Bit index.
  
   * **//​bit_is_set(value,​ bit)//** \\   * **//​bit_is_set(value,​ bit)//** \\
-    ​Väärtuse kindla biti kõrgeloleku kontrollParameetrid+    ​Checks whether a specified bit in the variable is set or notParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks+    * //bit// - Bit index
-    * Tagastab tõeväärtuse ​//true//, kui bitt on kõrge ja //false//, kui bitt on madal.+    * Returns boolean value //​true// ​when bit is set and //​false// ​when bit is cleared.
  
   * **//​bit_is_clear(value,​ bit)//** \\   * **//​bit_is_clear(value,​ bit)//** \\
-    ​Väärtuse kindla biti madaloleku kontrollParameetrid+    ​Checks whether a specified bit in the variable is cleared or notParameters
-    * //value// - Muutuja+    * //value// - Variable
-    * //bit// - Bitiindeks+    * //bit// - Bit index
-    * Tagastab tõeväärtuse ​//true//, kui bitt on madal ja //false//, kui bitt on kõrge.+    * Returns boolean value //​true// ​when bit is cleared and //​false// ​when bit is set.
  
-=== Näide ​===+=== Example ​===
  
-Muutujas ​//b// kolmanda biti kõrgeks seadmine ja viimase ümberpööramine.+Setting up a third bit in the 8-bit variable ​//b// and inverting of the last one.
  
-<code c> + 
-#​include ​<​homelab/​bit.h>​+#​include ​
  
 int main(void) int main(void)
Rida 1889: Rida 1903:
  bit_invert(b,​ 7);  bit_invert(b,​ 7);
 } }
-</​code>​ 
  
-=== Lähtekood === 
  
-Järgnevalt on lühendatud kujul toodud teegi lähtekood, kust on näha, mis iga makrofunktsiooni taga peitub:+=== Source === 
 + 
 +The following is a shortened version of the bitwise operations library source code.
  
-<code c> 
-// 
-// Funktsioonid bittidega tegelemiseks 
-// 
-#define bit_mask(bit) ​           (1 << (bit)) 
-#define bit_set(value,​ bit)      value |= bit_mask(bit) 
-#define bit_clear(value,​ bit)    value &= ~bit_mask(bit) 
-#define bit_invert(value,​ bit)   value ^= bit_mask(bit) 
-#define bit_is_set(value,​ bit)   ​((value) & (bit_mask(bit))) 
-#define bit_is_clear(value,​ bit) (!((value) & (bit_mask(bit)))) 
-#define bit_set_to(v,​ b, x) v = ((x) ? (v | bit_mask(b)) : (v & ~bit_mask(b))) 
  
 // //
-// Funktsioonid bitimaskidega tegelemiseks+// Functions for handling bits.
 // //
-#​define ​bitmask_set(value, bitMask    value |= (bitMask) +#​define ​bit_mask(bit           ( 
-#define bitmask_clear(value,​ bitMask) ​  value &= ~(bitMask) +==== Pins ====
-#define bitmask_invert(value,​ bitMask) ​ value ^= (bitMask) +
-#define bitmask_set_to(v,​ m, x)         v = ((x) ? (v | (m)) : (v & ~(m)))  +
-#define bitmask_is_set(value,​ bitMask) ​ ((value) & (bitMask)) +
-</​code>​ +
- +
-==== Sisend-väljundviigud ​====+
  
-Viikude teek on ette nähtud ​AVR digitaalsete sisendja väljundviikudega opereerimiseksTeegi eesmärk on lihtsustada AVR viikude kasutamistKasutaja saab programmis luua soovitud viigu kohta käiva muutujamillele ta omistab spetsiaalse makrofunktsiooniga füüsilise viigu aadressi. Seejärel saab muutuja abil välja kutsuda erinevaid funktsioone viigu suuna ja olekute muutmiseks ning nende lugemiseks.+Pins library provides an easy way for operating with AVR digital input-output pinsThe user can create a pin related variable and do all the pin operations with that variableThis way there is no need to deal with the register names and bit indexes like it is done while programming in direct register access method. The pin's port and index must be specified only onceso the changes are easy to implement.
  
-Määrates viigu füüsilise siini (pordi) ja indeksi ära ainult ühe korra ja ühes kohas, on füüsiliste muudatuste korral lihtne programmi muuta. Näiteks, kui algul kasutatakse indikaatorina ühte LED-i, võib lihtsa tarkvara muudatusega teist LED kasutama hakata. Viigu muutujatest võib luua ka massiive, näiteks siinide koostamiseks.+=== Data Types ===
  
-=== Andmetüübid ===+  * **//pin//** \\ Data type to hold pin registers addresses and bit mask. To get the most efficent program, //pin// typed variables should be constant, and they should be initialized at the beginning of the program code. Intializing can be done with the macro function //PIN//, whose first parameter is the port letter (capital A, B, C, etc) and the other one being the pin index (0 to 7). Only existing ports and pins can be used.
  
-  ​* **//pin//** \\ Viigu registrite ja bitimaski hoidmise struktuurne andmetüüp. ​//pin//-tüüpi muutujad on konstantsed ja need tuleb väärtustada kohe programmi alguses. Väärtustamise lihtsustamiseks on makrofunktsioon //PIN//, mille esimene parameeter on siini tähis (suur ladina täht AB, C, jne) ja teine viigu number (0-7). +=== Constants === 
 +  ​* **//led_green, led_yellow, led_red//** - Homelab User interface board LEDs by colour 
 +  * **//LED1, LED2, LED3//** Homelab User interface board LEDs by LED numbers 
 +  * **//S1S2S3//​** ​Homelab User interface board buttons 
 +   
 +=== Functions ===
  
-=== Funktsioonid ===+  * **//void pin_setup_output(pin pin)//** \\ 
 +    Configures pin as an output. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_setup_input(pin pin)//** \\ 
 +    Configures pin as an input without pull-up resistor. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_setup_input_with_pullup(pin pin)//** \\ 
 +    Configures pin as an input with pull-up resistor. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_set(pin pin)//** \\ 
 +    Sets output pin high. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_clear(pin pin)//** \\ 
 +    Sets output pin low. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_toggle(pin pin)//** \\ 
 +    Inverts output pin state. Parameters:​ 
 +    * //pin// - Pin variable. 
 +  * **//void pin_set_to(pin pin, bool value)//** \\ 
 +    Sets output pin to desired state. Parameters:​ 
 +    * //pin// - Pin variable. 
 +    * //value// - Desired state boolean value. 
 +  * **//bool pin_get_value(pin pin)//** \\ 
 +    Gets pin value. Parameters:​ 
 +    * //pin// - Pin variable. 
 +    * Return boolean //true// when pin is high and //false// when pin is low. 
 +  * **//bool pin_get_debounced_value(pin pin)//** \\ 
 +    Reads pin value through the switch debounce filter. Filtering takes at least 8 ms and may last up to 100 ms, depending on when the bouncing ends. If the bouncing does not end, //false// is returned. Function uses software delay. Parameters:​ 
 +    * //pin// - Pin variable. 
 +    * Return pin boolean value - //true// when pin is high and //false// when pin is low or undetermined.
  
-  * **//void pin_setup_output(pin pin)//** \\ Viigu väljundiks määramine. Parameetrid:​ +=== Example ===
-    * //pin// - Viigu muutuja. +
-  * **//void pin_setup_input(pin pin)//** \\ Viigu sisendiks määramine ilma //pull-up// takistita. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-  * **//void pin_setup_input_with_pullup(pin pin)//** \\ Viigu sisendiks määramine koos //​pull-up//​-takistiga. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-  * **//void pin_set(pin pin)//** \\ Viigu väljundi kõrgeks määramine. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-  * **//void pin_clear(pin pin)//** \\ Viigu väljundi madalaks määramine. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-  * **//void pin_toggle(pin pin)//** \\ Viigu väljundi oleku pööramine. Madal olek muutub kõrgeks ja vastupidi. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-  * **//void pin_set_to(pin pin, bool value)//** \\ Viigu väljundi parameetriga määratud olekusse viimine. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-    * //value// - Tõeväärtuse muutuja. +
-  * **//bool pin_get_value(pin pin)//** \\ Viigu sisendi oleku lugemine ja funktsiooniga tagastamine. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-    * Tagastab tõeväärtuse. +
-  * **//bool pin_get_debounced_value(pin pin)//** \\ Viigu sisendi oleku lugemine läbi lüliti väreluse filtri ja selle tagastamine. Filtreerimine toimub minimaalselt 8 ms ja maksimaalselt 100 ms jooksul - olenevalt sellest, kui kiiresti lüliti värelemine lõppeb. Kui värelemine 100 ms jooksul ei lõpe, siis funktsioon tagastab //false//. Funktsioon kasutab tarkvaralist pausi funktsiooni viite teegist. Parameetrid:​ +
-    * //pin// - Viigu muutuja. +
-    * Tagastab tõeväärtuse.+
  
-=== Näide ===+Example of getting and setting a pin's value. Pin PC0 value is inverted and attached to pin PC3.
  
-Näide sellest, kuidas ühe viigu väärtus teha sõltuvaks teisest. Programmis omandab viik PC3 viigule PC0 vastupidise väärtuse: 
  
-<code c> +#​include ​
-#​include ​<​homelab/​pin.h>​+
    
 pin output_pin = PIN(C, 3); pin output_pin = PIN(C, 3);
Rida 1965: Rida 1974:
  bool value;  bool value;
  
- // Viigu väljundiks seadistamine+ // Configuring pin as an output pin
  pin_setup_output(output_pin);​  pin_setup_output(output_pin);​
  
- // Viigu pull-up ​takistiga sisendiks seadistamine+ // Configuring pin as an input pin with pull-up
  pin_setup_input_with_pullup(input_pin);​  pin_setup_input_with_pullup(input_pin);​
  
- // Lõputu tsükkel+ // Endless loop
  while (true)  while (true)
  {  {
- // Sisendviigu väärtuse lugemine+ // Getting an input pin value
  value = pin_get_value(input_pin);​  value = pin_get_value(input_pin);​
  
- // Väljundviigule vastupidise väärtuse omistamine+ // Setting an output pin value
  pin_set_to(output_pin,​ !value);  pin_set_to(output_pin,​ !value);
  }  }
 } }
-</​code>​ 
  
-==== Analoog-digitaalmuundur ==== 
  
-Analoog-digitaalmuunduri teek on AVR ADC mooduli kasutamise lihtsustamiseksTeegi muundamise funktsioonid on blokeeruvad ehk nende väljakutsumisel jääb protsessor muundamise lõppu ootamaMuundamise aeg sõltub ​ADC taktijagurist.+led_on, led_off, button_read commands example 
 + 
 +#include  
 +  
 +// Homelab buttons and LEDs are predefined in the library 
 + 
 +int main(void) 
 +
 + // Set LED pin as output 
 + pin_setup_output(led_green);​ 
 + 
 + // Set Button S1 pin as input 
 + pin_setup_input(S1);​ 
 + 
 + // Endless loop 
 + while (true) 
 +
 + // If button is pressed, turn on LED, if not pressed, turn LED off. 
 + if(button_read(S1) == true) 
 + led_on(led_green);​ 
 + else 
 + led_off(led_green);​ 
 +
 +
 + 
 +==== Analog to Digital Converter ==== 
 + 
 +This library provides functions to use AVR analog to digital converterAll the conversion functions in library are blocking, which means the processor waits as long as it takes to get the resultsThe conversion time depends on the ADC clock.
  
-=== Andmetüübid ​===+=== Data Types ===
  
-  * **//​adc_reference//​** \\ Analoog-digitaalmuunduri võrdluspinge valiku tüüpVäärtuste variandid ja tähendused+  * **//​adc_reference//​** \\ ADC reference voltage enumeration data typeOptions
-    * //​ADC_REF_AREF//​ - Võrdluspinge saadakse ​AREF viigult+    * //​ADC_REF_AREF//​ - Reference voltage from the AREF pin
-    * //​ADC_REF_AVCC//​ - Võrdluspinge saadakse ​AVCC viigult+    * //​ADC_REF_AVCC//​ - Reference voltage from the AVCC pin
-    * //​ADC_REF_2V56//​ - Võrdluspinge on sisemine ​2,56 V.+    * //​ADC_REF_2V56//​ - Internal ​2,56 V reference voltage.
  
-  * **//​adc_prescale//​** \\ Analoog-digitaalmuunduri taktijaguri valiku tüüpVäärtuste variandid+  * **//​adc_prescale//​** \\ ADC clock prescaler enumration data type. It determines the division factor of system clockOptions
-    * //​ADC_PRESCALE_2//​ - Jagamistegur ​2. +    * //​ADC_PRESCALE_2//​ - Division factor ​2. 
-    * //​ADC_PRESCALE_4//​ - Jagamistegur ​4. +    * //​ADC_PRESCALE_4//​ - Division factor ​4. 
-    * //​ADC_PRESCALE_8//​ - Jagamistegur ​8. +    * //​ADC_PRESCALE_8//​ - Division factor ​8. 
-    * //​ADC_PRESCALE_16//​ - Jagamistegur ​16. +    * //​ADC_PRESCALE_16//​ - Division factor ​16. 
-    * //​ADC_PRESCALE_32//​ - Jagamistegur ​32. +    * //​ADC_PRESCALE_32//​ - Division factor ​32. 
-    * //​ADC_PRESCALE_64//​ - Jagamistegur ​64. +    * //​ADC_PRESCALE_64//​ - Division factor ​64. 
-    * //​ADC_PRESCALE_128//​ - Jagamistegur ​128.+    * //​ADC_PRESCALE_128//​ - Division factor ​128.
  
-=== Funktsioonid ​===+=== Functions ​===
  
-  * **//void adc_init(adc_reference reference, adc_prescale prescale)//​** \\ ADC tööks ettevalmistamineParameetrid+  * **//void adc_init(adc_reference reference, adc_prescale prescale)//​** \\ 
-    * //​reference//​ - Võrdluspinge valik+    Initializes ​ADC. Parameters
-    * //​prescale//​ - Taktijaguri valik. Mida suurem on jaguri tegur, seda rohkem võtab muundamine aega, kuid seda mürakindlam see on.+    * //​reference//​ - Reference voltage selection
 +    * //​prescale//​ - Clock prescaler selection.
  
-  * **//​unsigned short adc_get_value(unsigned char channel)//​** \\ Soovitud ​ADC sisendkanali väärtuse muundamineFunktsioon on blokeeruvParameetrid+  * **//​unsigned short adc_get_value(unsigned char channel)//​** \\ 
-    * //channel// - ADC kanali ​number (0 kuni 7). +    Converts specified ​ADC channel analog value to digitalFunction is blockingParameter
-    * Tagastab ​10-bitise väärtuse.+    * //channel// - ADC channel ​number (0 to 7). 
 +    * Return ​10-bit digital value.
  
-  * **//​unsigned short adc_get_average_value(unsigned char channel, unsigned char num_samples)//​** \\ Soovitud ​ADC sisendkanali väärtuse mitmekordne muundamine ja keskmise võtmineFunktsioon on blokeeruvParameetrid+  * **//​unsigned short adc_get_average_value(unsigned char channel, unsigned char num_samples)//​** \\ 
-    * //channel// - ADC kanali ​number (0 kuni 7). +    Converts specified ​ADC channel analog value to digital desired number of times and calculates the averageFunction is blockingParameters
-    * //​num_samples//​ - Keskmistamiste arv. Lubatud arv on kuni 64. +    * //channel// - ADC channel ​number (0 to 7). 
-    * Tagastab ​10-bitise keskmistatud väärtuse.+    * //​num_samples//​ - Number of samples for calculation (to 64)
 +    * Return ​10-bit digital value.
  
-~~PB~~+=== Example ===
  
-=== Näide ===+For example ADC is initialized and two analog channel values are converted to digital. Value of channel 0 is assigned to variable //x// and averaged value of channel 1 to variable //y//.
  
-Näites seatakse analoog-digitaalmuundur töövalmis ja loetakse kahelt sisendkanalilt pinge. Kanali 0 pingemuundamise väärtus loetakse muutujasse //x// ja kanali 1 väärtus kümnekordse ümardamise tulemusena muutujasse //y//. 
  
-<code c> +#​include ​
-#​include ​<​homelab/​adc.h>​+
    
 int main(void) int main(void)
Rida 2031: Rida 2066:
  unsigned short x, y;  unsigned short x, y;
  
- // Analoog-digitaalmuunduri seadistamine + // Initializing ADC. Reference voltage from AVCC. 
- // Võrdluspinge tuleb AVCC viigultMuunduri töötakt + // Clock is times slower than system clock.
- // on korda madalam kontrolleri taktist.+
  adc_init(ADC_REF_AVCC,​ ADC_PRESCALE_8);​  adc_init(ADC_REF_AVCC,​ ADC_PRESCALE_8);​
  
- // Kanali ​muundatud väärtuse lugemine muutujasse x+ // Converting channel ​value.
  x = adc_get_value(0);​  x = adc_get_value(0);​
  
- // Kanali ​muundatud ja keskmistatud väärtuse lugemine muutujasse y+ // Converting and averaging channel ​value.
  y = adc_get_average_value(1,​ 10);  y = adc_get_average_value(1,​ 10);
 } }
-</​code>​ 
  
  
-==== Jadaliides ==== 
  
-Tegu on AVR universaalse jadaliidese kasutamise teegiga. Võimaldab asünkroonset andmete kirjutamist ja lugemist.+==== Serial Interface ====
  
-=== Andmetüübid ===+This library provides AVR asynchronous serial interface usage functions.
  
-  * **//​usart//​** \\ USART liidese registrite hoidmise andmetüüp. //​usart//​-tüüpi muutuja on konstantne ja see tuleb väärtustada kohe programmi alguses. Väärtustamise lihtsustamiseks on makrofunktsioon USART, mille parameetriks on liidese indeks (0 või 1). +=== Data Types ===
-  * **//​adc_usart_databits//​** \\ Andmebittide arvu valiku tüüp. Väärtuste variandid:​ +
-    * //​USART_DATABITS_5//​ - Andmebitte 5. +
-    * //​USART_DATABITS_6//​ - Andmebitte 6. +
-    * //​USART_DATABITS_7//​ - Andmebitte 7. +
-    * //​USART_DATABITS_8//​ - Andmebitte 8. +
-    * //​USART_DATABITS_9//​ - Andmebitte 9. +
-  * **//​usart_stopbits//​** \\ Stoppbittide arvu valiku tüüp. Väärtuste variandid:​ +
-    * //​USART_STOPBITS_ONE//​ - Üks stoppbitt. +
-    * //​USART_STOPBITS_TWO//​ - Kaks stoppbitti. +
-  * **//​usart_parity//​** \\ Paarsuskontrolli valiku tüüp. Väärtuste variandid:​ +
-    * //​USART_PARITY_NONE//​ - Paarsuskontrolli ja -bitti ei kasutata. +
-    * //​USART_PARITY_EVEN//​ - Ühtede paarisarvulisuse kontroll. +
-    * //​USART_PARITY_ODD//​ - Ühtede paarituarvulisuse kontroll.+
  
-=== Funktsioonid ​===+  * **//​usart//​** \\ Data type to hold USART inteface control, status and data register addresses. //usart// typed variables should be initialized at the beginning of the program code. For initializations,​ there is a macro-functions //USART//, whose only parameter is the index of interface (0 or 1). 
 + 
 +  * **//​usart_databits//​** \\ Data bits count enumeration data type. Options: 
 +    * //​USART_DATABITS_5//​ - 5 data bits. 
 +    * //​USART_DATABITS_6//​ - 6 data bits. 
 +    * //​USART_DATABITS_7//​ - 7 data bits. 
 +    * //​USART_DATABITS_8//​ - 8 data bits. 
 +    * //​USART_DATABITS_9//​ - 9 data bits. 
 + 
 +  * **//​usart_stopbits//​** \\ Stop bits count enumeration data type. Options: 
 +    * //​USART_STOPBITS_ONE//​ - One stop bit. 
 +    * //​USART_STOPBITS_TWO//​ - Two stop bits. 
 + 
 +  * **//​usart_parity//​** \\ Parity mode enumeration data type. Options: 
 +    * //​USART_PARITY_NONE//​ - Disabled. 
 +    * //​USART_PARITY_EVEN//​ - Even parity. 
 +    * //​USART_PARITY_ODD//​ - Odd parity. 
 + 
 +=== Functions ​===
  
   * **//​USART_BAUDRATE_ASYNC(baud)//​** \\   * **//​USART_BAUDRATE_ASYNC(baud)//​** \\
-    ​Makrofunktsiooni ​USART mooduli asünkroonse režiimi boodikiiruse registri väärtuse arvutamiseksParameetrid+    ​Macro function to calculate ​USART baud rate register value in asynchronous modeParameters
-    * //baud// - Boodikiirus+    * //baud// - Desired baud rate
-    * Tagastab boodikiiruse registri väärtuse.+    * Returns baud rate register value.
  
   * **//void usart_init_async(usart port, usart_databits data_bits, usart_stopbits stop_bits, usart_parity parity, usart_baudrate baudrate)//​** \\   * **//void usart_init_async(usart port, usart_databits data_bits, usart_stopbits stop_bits, usart_parity parity, usart_baudrate baudrate)//​** \\
-    ​Jadaliidese asünkroonseks seadistamineParameetrid+    ​Initializes asynchronous USARTParameters
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * //​data_bits//​ - Andmebittide arv+    * //​data_bits//​ - Data bits
-    * //​stop_bits//​ - Stoppbittide arv+    * //​stop_bits//​ - Stop bits
-    * //parity// - Paarsuse tüüp+    * //parity// - Parity mode
-    * //​baudrate//​ - Boodi kiirus, mis on arvutatud ​//​USART_BAUDRATE_ASYNC// ​makro funktsiooniga+    * //​baudrate//​ - Baud rate register value (can be calculated with //​USART_BAUDRATE_ASYNC// ​macro function)
-~~PB~~+
   * **//void usart_send_char(usart port, char symbol)//** \\   * **//void usart_send_char(usart port, char symbol)//** \\
-    ​Blokeeruv sümboli saatmise funktsioonFunktsioon ootab, kuni saatmise puhver tühjeneb ja kirjutab sinna saatmiseks uue sümboliParameetrid+    ​Blocking character transmissionFunctions wait until transmit buffer empties before writing a character to the bufferParameters
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * //symbol// - Saadetav sümbol.+    * //symbol// - Character to be sent.
  
   * **//void usart_send_string(usart port, char *text)//** \\   * **//void usart_send_string(usart port, char *text)//** \\
-    ​Blokeeruv teksti saatmise funktsioonParameetrid+    ​Blocking string transmissionParameters
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * //text// - Viit tekstileTekst peab lõppema binaarse 0 sümboliga.+    * //text// - Pointer to strin (char array)String has to end with null character.
  
   * **//bool usart_has_data(usart port)//** \\   * **//bool usart_has_data(usart port)//** \\
-    ​Sisendpuhvris andmete olemasolu kontrollParameetrid+    ​Checks for data in receive bufferParameters
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * Tagastab ​//​true//, ​kui sisendpuhvris on sümbol ja //​false// ​kui mitte.+    * Returns ​//​true// ​when there is a character in receive bufferand //​false// ​when not.
  
   * **//char usart_read_char(usart port)//** \\   * **//char usart_read_char(usart port)//** \\
-    ​Sisendpuhvrist sümboli lugemineEnne lugemist peab veenduma, et puhvris on sümbolParameetrid+    ​Reads a character from receive bufferBefore reading user must check if there actually is  a received characterParameters:  
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * Tagastab sümboli.+    * Returns character.
  
   * **//bool usart_try_read_char(usart port, char *symbol)//​** \\   * **//bool usart_try_read_char(usart port, char *symbol)//​** \\
-    ​Sisendpuhvri sümboli olemasolu kontroll ja selle lugemise ühisfunktsioonParameetrid+    ​Reads a character from receive buffer if there is anyParameters
-    * //port// - USART liidese muutuja+    * //port// - USART interface variable
-    * //symbol// - Viit sümbolileKui sisendpuhvris on sümbolsiis see kirjutatakse siia+    * //symbol// - Pointer to character variableIf there is a character in receive bufferit is written to the pointed variable
-    * Tagastab ​//​true//, ​kui sisendpuhvris oli sümbol ja //​false// ​kui mitte.+    * Returns ​//​true// ​when there was a character in receive bufferand //​false// ​when not.
  
-=== Näide ​===+=== Example ​===
  
-Jadaliidese seadmistamine töötab asünkroonselt ​andmebitiühe stoppbiti ja ilma paarsuse kontrollita boodikiirusel ​9600. Programm saadab teksti ja loeb sissetuleva sümboli.+USART interface is configured to use data bits, one stop bit, 9600 bps baud rate and no parity modeProgram sends a string, waits until some character is received and then reads it out.
  
-<code c> 
-#include <​homelab/​usart.h>​ 
  
 +#​include ​
 +
 +// Use USART interface 0.
 usart port = USART(0); usart port = USART(0);
  
 int main(void) int main(void)
-{+{
  char c;  char c;
  
- // Jadaliidese seadistamine + // Interface initialization. 
- usart_init_async(port,​ USART_DATABITS_8,​ USART_STOPBITS_ONE,​ + usart_init_async(port,​ 
- USART_PARITY_NONE,​ USART_BAUDRATE_ASYNC(9600));​+ USART_DATABITS_8,​ 
 + USART_STOPBITS_ONE,​ 
 + USART_PARITY_NONE,​ 
 + USART_BAUDRATE_ASYNC(9600));​
  
- // Teksti saatmine + // String sending. 
- usart_send_string(port,​ "Tere\n");+ usart_send_string(port,​ "Hello\n");
  
- // Sissetuleva sümboli ootamine+ // Waiting for incoming data.
  while (!usart_has_data(port)) {}  while (!usart_has_data(port)) {}
  
- // Sümboli lugemine+ // Read out the received character.
  c = usart_read_char(port);​  c = usart_read_char(port);​
 } }
-</​code>​ 
  
-==== Taimerid ==== 
  
-Käesolev taimerite teek katab suure osa ATmega128 taimerite funktsionaalsusest. Kuna AVR taimerid on erinevate kiipide vahel päris erinevad, siis ei saa nende kasutamiseks kirjutada universaalseid funktsioone. Ka kirjeldatavad ATmega128 funktsioonid on suures osas lihtsalt primitiivsed registri muutmise või lugemise funktsioonid,​ kuid siiski on nad loetavamad kui registrid.+==== Timers ====
  
-=== Andmetüübid ===+This library covers a large part of the functionality of ATmega128 timers. There are data types and functions which make usage of timers easier. Unfortunately,​ because of the complexity of AVR timers, there are no common functions to use different timers. Each of the timers has functions which start with the prefix of "​timer"​ and its index.
  
-  * **//​timer0_prescale//​** \\ Taimer 0 taktijaguri tegurite valiku tüüp. Väärtuste variandid ja tähendused:​ +=== Data types ===
-    * //​TIMER0_NO_PRESCALE//​ - Jagurit ei kasutata. +
-    * //​TIMER0_PRESCALE_8//​ - Jagamistegur 8. +
-    * //​TIMER0_PRESCALE_32//​ - Jagamistegur 32. +
-    * //​TIMER0_PRESCALE_64//​ - Jagamistegur 64. +
-    * //​TIMER0_PRESCALE_128//​ - Jagamistegur 128. +
-    * //​TIMER0_PRESCALE_256//​ - Jagamistegur 256. +
-    * //​TIMER0_PRESCALE_1024//​ - Jagamistegur 1024.+
  
-  * **//​timer2_prescale//​** \\ Taimer ​taktijaguri tegurite valiku tüüpVäärtuste variandid ja tähendused+  ​* **//​timer0_prescale//​** \\ Timer 0 prescaler enumeration data type. Options: 
-    * //​TIMER2_NO_PRESCALE//​ - Jagurit ei kasutata+    * //​TIMER0_NO_PRESCALE//​ - No prescaler (no division). 
-    * //​TIMER2_PRESCALE_8//​ - Jagamistegur ​8. +    * //​TIMER0_PRESCALE_8//​ - Clk / 8. 
-    * //​TIMER2_PRESCALE_64//​ - Jagamistegur ​64. +    * //​TIMER0_PRESCALE_32//​ - Clk / 32. 
-    * //​TIMER2_PRESCALE_256//​ - Jagamistegur ​256. +    * //​TIMER0_PRESCALE_64//​ - Clk / 64. 
-    * //​TIMER2_PRESCALE_1024//​ - Jagamistegur ​1024. +    * //​TIMER0_PRESCALE_128//​ - Clk / 128. 
-    * //​TIMER2_PRESCALE_T2_FALLING//​ - Taktsignaal tuleb hoopis ​T2 viigu langeval frondil+    * //​TIMER0_PRESCALE_256//​ - Clk / 256. 
-    * //​TIMER2_PRESCALE_T2_RISING//​ - Taktsignaal tuleb hoopis ​T2 viigu tõusval frondil.+    * //​TIMER0_PRESCALE_1024//​ - Clk / 1024. 
 + 
 +  ​* **//​timer2_prescale//​** \\ Timer prescaler enumeration data typeOptions
 +    * //​TIMER2_NO_PRESCALE//​ - No prescaler (no division)
 +    * //​TIMER2_PRESCALE_8//​ - Clk / 8. 
 +    * //​TIMER2_PRESCALE_64//​ - Clk / 64. 
 +    * //​TIMER2_PRESCALE_256//​ - Clk / 256. 
 +    * //​TIMER2_PRESCALE_1024//​ - Clk / 1024. 
 +    * //​TIMER2_PRESCALE_T2_FALLING//​ - Clock on pin T2 falling edge
 +    * //​TIMER2_PRESCALE_T2_RISING//​ - Clock on pin T2 rising edge.
  
   * **//​timer1_prescale//​** ​   * **//​timer1_prescale//​** ​
-  * **//​timer3_prescale//​** \\ Taimer ​1/3 taktijaguri tegurite valiku tüüpVäärtuste variandid ja tähendused ​("​n" ​tähistab ​või 3): +  * **//​timer3_prescale//​** \\ Timer 1/3 prescaler enumeration data typeOptions ​("​n" ​means or 3): 
-    * //​TIMERn_NO_PRESCALE//​ - Jagurit ei kasutata+    * //​TIMERn_NO_PRESCALE//​ - No prescaler (no division)
-    * //​TIMERn_PRESCALE_8//​ - Jagamistegur ​8. +    * //​TIMERn_PRESCALE_8//​ - Clk / 8. 
-    * //​TIMERn_PRESCALE_64//​ - Jagamistegur ​64. +    * //​TIMERn_PRESCALE_64//​ - Clk / 64. 
-    * //​TIMERn_PRESCALE_256//​ - Jagamistegur ​256. +    * //​TIMERn_PRESCALE_256//​ - Clk / 256. 
-    * //​TIMERn_PRESCALE_1024//​ - Jagamistegur ​1024. +    * //​TIMERn_PRESCALE_1024//​ - Clk / 1024. 
-    * //​TIMERn_PRESCALE_Tn_FALLING//​ - Taktsignaal tuleb hoopis ​Tn viigu langeval frondil+    * //​TIMERn_PRESCALE_Tn_FALLING//​ - Clock on pin Tn falling edge
-    * //​TIMERn_PRESCALE_Tn_RISING//​ - Taktsignaal tuleb hoopis ​Tn viigu tõusval frondil+    * //​TIMERn_PRESCALE_Tn_RISING//​ - Clock on pin Tn rising edge
-~~PB~~+
   * **//​timer1_ctc_top//​**   * **//​timer1_ctc_top//​**
-  * **//​timer3_ctc_top//​** \\ Taimer ​1/3 CTC-režiimi maksimaalse loenduri väärtuse valiku tüüpVäärtuste variandid ja tähendused ​("​n" ​tähistab ​või 3): +  * **//​timer3_ctc_top//​** \\ Timer 1/3 CTC mode top value enumeration data typeOptions ​("​n" ​means or 3): 
-    * //​TIMERn_CTC_TOP_OCRA//​ - Maksimaalne väärtus määratakse taimer ​1/3 võrdlusregistriga ​A. +    * //​TIMERn_CTC_TOP_OCRA//​ - Top value from timer 1/3 output compare register ​A. 
-    * //​TIMERn_CTC_TOP_ICR//​ - Maksimaalne väärtus määratakse taimer ​1/3 sündmuste loenduri registriga.+    * //​TIMERn_CTC_TOP_ICR//​ - Top value from timer 1/3 input capture register.
  
   * **//​timer1_fast_pwm_top//​**   * **//​timer1_fast_pwm_top//​**
-  * **//​timer3_fast_pwm_top//​** \\ Taimer ​1/3 kiire PWM režiimi maksimaalse loenduri väärtuse valiku tüüpVäärtuste variandid ja tähendused ​("​n" ​tähistab ​või 3): +  * **//​timer3_fast_pwm_top//​** \\ Timer 1/3 fast PWM mode top value enumeration data typeOptions ​("​n" ​means or 3): 
-    * //​TIMERn_FAST_PWM_TOP_256//​ - Maksimaalne väärtus on 255. +    * //​TIMERn_FAST_PWM_TOP_256//​ - Top value 255. 
-    * //​TIMERn_FAST_PWM_TOP_512//​ - Maksimaalne väärtus on 511. +    * //​TIMERn_FAST_PWM_TOP_512//​ - Top value 511. 
-    * //​TIMERn_FAST_PWM_TOP_1024//​ - Maksimaalne väärtus on 1023. +    * //​TIMERn_FAST_PWM_TOP_1024//​ - Top value 1023. 
-    * //​TIMERn_FAST_PWM_TOP_ICR//​ - Maksimaalne väärtus määratakse taimer ​1/3 sündmuste loenduri registriga+    * //​TIMERn_FAST_PWM_TOP_ICR//​ - Top value from timer 1/3 input capture register
-    * //​TIMERn_PAST_PWM_TOP_OCRA//​ - Maksimaalne väärtus määratakse taimer ​1/3 võrdlusregistriga ​A.+    * //​TIMERn_PAST_PWM_TOP_OCRA//​ - Top value from timer 1/3 output compare register ​A.
  
   * **//​timer1_fast_pwm_output_mode//​**   * **//​timer1_fast_pwm_output_mode//​**
-  * **//​timer1_fast_pwm_output_mode//​** \\ Taimer ​1/3 väljundite seadistuste valiku tüüp kiire PWM režiimisVäärtuste variandid ja tähendused ​("​n" ​tähistab ​või 3): +  * **//​timer1_fast_pwm_output_mode//​** \\ Timer 1/3 fast PWM mode outputs configuration enumeration data typeOptions ​("​n" ​means or 3): 
-    * //​TIMERn_FAST_PWM_OUTPUT_DISABLE//​ - Väljundisse PWM signaal ei jõua+    * //​TIMERn_FAST_PWM_OUTPUT_DISABLE//​ - No output
-    * //​TIMERn_FAST_PWM_OUTPUT_TOGGLE_ON_MATCH//​ - Väljund muutub vastupidiseks,​ kui loendur omistab võrdlusregistri väärtuse+    * //​TIMERn_FAST_PWM_OUTPUT_TOGGLE_ON_MATCH//​ - Output toggles on compare match
-    * //​TIMERn_FAST_PWM_OUTPUT_CLEAR_ON_MATCH//​ - Väljund läheb madalaks, kui loendur omistab võrdlusregistri väärtuse, ja kõrgeks, kui loendur jõuab nulli+    * //​TIMERn_FAST_PWM_OUTPUT_CLEAR_ON_MATCH//​ - Output clears on compare match
-    * //​TIMERn_FAST_PWM_OUTPUT_SET_ON_MATCH//​ - Väljund läheb kõrgeks, kui loendur omistab võrdlusregistri väärtuse, ja madalaks, kui loendur jõuab nulli.+    * //​TIMERn_FAST_PWM_OUTPUT_SET_ON_MATCH//​ - Output sets on compare match.
  
-=== Funktsioonid ​===+=== Functions ​===
  
-  * **//void timer0_init_normal(timer0_prescale prescale)//​** \\ Taimer ​normaalrežiimi seadistamineSelles režiimis loendab taimer ​255-ni (kaasa arvatudja ainuke tekkiv sündmus on ületäitumineParameetrid+  * **//void timer0_init_normal(timer0_prescale prescale)//​** \\ 
-    * //​prescale//​ - Taktijaguri tegur.+    Initializes timer in normal modeIn this mode the timer counts from 0 to 255 (including). Overflow interrupt can be used. Parameters
 +    * //​prescale//​ - Prescaler.
  
-  * **//void timer2_init_normal(timer2_prescale prescale)//​** \\ Taimer ​normaalrežiimi seadistamineSelles režiimis loendab taimer ​255-ni (kaasa arvatudja ainuke tekkiv sündmus on ületäitumineKaks taktijaguri tegurit võimaldavad taimeri taktsignaali allikaks seada ka T2 viiguParameetrid+  * **//void timer2_init_normal(timer2_prescale prescale)//​** \\ 
-    * //​prescale//​ - Taktijaguri tegur või taktsignaali allikas.+    Initializes timer in normal modeIn this mode timer counts from 0 to 255 (including). Overflow interrupt can be usedParameters
 +    * //​prescale//​ - Prescaler.
  
   * **//void timer0_stop()//​**   * **//void timer0_stop()//​**
-  * **//void timer2_stop()//​** \\ Taimeri ​0/2 peatamine.+  * **//void timer2_stop()//​** \\ 
 +    Stops timer 0/2.
  
   * **//​unsigned char timer0_get_value(void)//​**   * **//​unsigned char timer0_get_value(void)//​**
-  * **//​unsigned char timer2_get_value(void)//​** \\ Taimer ​0/2 loenduri hetkeväärtuse tagastamineParameetrid+  * **//​unsigned char timer2_get_value(void)//​** \\ 
-    * Tagastab ​8-bitise loenduri hetkeväärtuse.+    Returns timer 0/2 current valueParameters
 +    * Return ​8-bit timer value.
  
   * **//void timer0_set_value(unsigned char value)//**   * **//void timer0_set_value(unsigned char value)//**
-  * **//void timer2_set_value(unsigned char value)//** \\ Taimer ​0/2 loenduri uue väärtuse määramineParameetrid+  * **//void timer2_set_value(unsigned char value)//** \\ 
-    * //value// - Uus 8-bitine loenduri väärtus.+    Sets timer 0/2 valueParameters
 +    * //value// - New 8-bit timer value.
  
   * **//void timer0_overflow_interrupt_enable(bool enable)//**   * **//void timer0_overflow_interrupt_enable(bool enable)//**
-  * **//void timer2_overflow_interrupt_enable(bool enable)//** \\ Taimer ​0/2 ületäitumise katkestuse lubamine või keelamineKatkestuse vektor on TIMERn_OVF_vect ​kus "​n" ​on või 2. Parameetrid+  * **//void timer2_overflow_interrupt_enable(bool enable)//** \\ 
-    * //enable// - Tõeväärtus katkestuse lubamiseks või keelamiseks. ​//​true// ​lubab, //​false// ​keelab.+    Enables or disables timer 0/2 overflow interruptThe name of the interrupt vector is "TIMERn_OVF_vect" where "​n" ​represents ​or 2. Parameters
 +    * //enable// - //​true// ​to enable interrupt, //​false// ​to disable.
  
   * **//bool timer0_overflow_flag_is_set(void)//​**   * **//bool timer0_overflow_flag_is_set(void)//​**
-  * **//bool timer2_overflow_flag_is_set(void)//​** \\ Taimer ​0/2 ületäitumise toimumise kontrollimineParameetrid+  * **//bool timer2_overflow_flag_is_set(void)//​** \\ 
-    * Tagastab tõeväärtuse ​//​true//, ​kui ületäitumine on toimunud, ja //false//, kui pole.+    Checks timer 0/2 overflow flagParameters
 +    * Returns ​//​true// ​when overflow has happened, //​false// ​when not.
  
   * **//void timer0_overflow_flag_clear(void)//​**   * **//void timer0_overflow_flag_clear(void)//​**
-  * **//void timer2_overflow_flag_clear(void)//​** \\ Taimer ​0/2 ületäitumise sündmuse lipukese nullimine.+  * **//void timer2_overflow_flag_clear(void)//​** \\ 
 +    Resets timer 0/2 overflow flag.
  
   * **//void timer1_init_normal(timer1_prescale prescale)//​**   * **//void timer1_init_normal(timer1_prescale prescale)//​**
-  * **//void timer3_init_normal(timer3_prescale prescale)//​** \\ Taimer ​1/3 normaalrežiimi seadistamineSelles režiimis loendab taimer ​65535-ni (kaasa arvatudja ainuke tekkiv sündmus on ületäitumineParameetrid+  * **//void timer3_init_normal(timer3_prescale prescale)//​** \\ 
-    * //​prescale//​ - Taktijaguri tegur.+    Initializes timer 1/3 in normal modeIn this mode timer counts from 0 to 65535 (including). Overflow interrupt can be used. Parameters
 +    * //​prescale//​ - Prescaler.
  
   * **//void timer1_init_ctc(timer1_prescale prescale, timer1_ctc_top top)//**   * **//void timer1_init_ctc(timer1_prescale prescale, timer1_ctc_top top)//**
-  * **//void timer3_init_ctc(timer3_prescale prescale, timer3_ctc_top top)//** \\ Taimer ​1/3 CTC (inglise keeles ​//Clear Timer on Compare Match//​) ​režiimi seadistamineSelles režiimis taimer ei loenda mitte 65535-ni, vaid valitud registri väärtuseni ja tekitab soovi korral sinnani jõudes katkestuseParameetrid+  * **//void timer3_init_ctc(timer3_prescale prescale, timer3_ctc_top top)//** \\ 
-    * //​prescale//​ - Taktijaguri tegur+    Initializes timer 1/3 in CTC (//Clear Timer on Compare Match//​) ​modeIn this mode timer counts to specified top value. Overflow interrupt can be usedParameters
-    * //top// - Taimeri maksimaalse väärtuse registri valikValida saab kahe registri vahel, mille mõlema muutmiseks on omaette funktsioonid. Mõlemad registrid võib loenduri tippu jõudes katkestust tekitama seadistada.+    * //​prescale//​ - Prescaler
 +    * //top// - Timer top value selectionActual value must be specified with register selected as a top value holder.
  
   * **//void timer1_init_fast_pwm(timer1_prescale prescale, timer1_fast_pwm_top top, timer1_fast_pwm_output_mode output_a, timer1_fast_pwm_output_mode output_b, timer1_fast_pwm_output_mode output_c)//​**   * **//void timer1_init_fast_pwm(timer1_prescale prescale, timer1_fast_pwm_top top, timer1_fast_pwm_output_mode output_a, timer1_fast_pwm_output_mode output_b, timer1_fast_pwm_output_mode output_c)//​**
-  * **//void timer3_init_fast_pwm(timer3_prescale prescale, timer3_fast_pwm_top top, timer3_fast_pwm_output_mode output_a, timer3_fast_pwm_output_mode output_b, timer3_fast_pwm_output_mode output_c)//​** \\ Taimer ​1/3 kiire PWM tekitamise režiimi seadistamineSelles režiimis on valitav väärtusmilleni taimer loendab, ehk PWM signaali perioodTaimeril on PWM signaali genereerimise üksust ​(A, B ja C), millel kõigil on seadistatav väljundParameetrid+  * **//void timer3_init_fast_pwm(timer3_prescale prescale, timer3_fast_pwm_top top, timer3_fast_pwm_output_mode output_a, timer3_fast_pwm_output_mode output_b, timer3_fast_pwm_output_mode output_c)//​** \\ 
-    * //​prescale//​ - Taktijaguri tegur+    Initializises timer 1/3 in fast PWM modeIn this mode timer counts to a specified valuewhich also determines the period of the PWM signalTimer 1/has three 3 output compare units (A, B and C) to generate PWM signals. Overflow and compare match interrupts can be usedParameters
-    * //top// - Taimeri maksimaalse väärtuse valikValida saab konstantide ja kahe registri vahel. Mõlemad registrid võib loenduri tippu jõudes katkestust tekitama seadistada+    * //​prescale//​ - Prescaler
-    * //​output_a//​ - Väljundviigu ​seadistus+    * //top// - Timer top value selectionActual value must be specified with register selected as a top value holder
-    * //​output_b//​ - Väljundviigu ​seadistus+    * //​output_a//​ - Output compare unit pin configuration
-    * //​output_c//​ - Väljundviigu ​seadistus.+    * //​output_b//​ - Output compare unit pin configuration
 +    * //​output_c//​ - Output compare unit pin configuration.
  
   * **//void timer1_stop()//​**   * **//void timer1_stop()//​**
-  * **//void timer3_stop()//​** \\ Taimeri ​1/3 peatamine.+  * **//void timer3_stop()//​** \\ 
 +    Stops timer 1/3.
  
   * **//​unsigned char timer1_get_value(void)//​**   * **//​unsigned char timer1_get_value(void)//​**
-  * **//​unsigned char timer3_get_value(void)//​** \\ Taimeri ​1/3 loenduri hetkeväärtuse tagastamineParameetrid+  * **//​unsigned char timer3_get_value(void)//​** \\ 
-    * Tagastab ​16-bitise loenduri hetkeväärtuse.+    Returns timer 1/3 current valueParameters
 +    * Returns ​16-bit timer value.
  
   * **//void timer1_set_value(unsigned char value)//**   * **//void timer1_set_value(unsigned char value)//**
-  * **//void timer3_set_value(unsigned char value)//** \\ Taimeri 1/3 loenduri uue väärtuse määramineParameetrid+  * **//void timer3_set_value(unsigned char value)//** \\ 
-    * //value// - Uus 16-bitine loenduri väärtus.+    Sets timer 0/2 valueParameters
 +    * //value// - New 16-bit timer value.
  
   * **//​unsigned short timer1_get_compare_match_unitA_value(void)//​**   * **//​unsigned short timer1_get_compare_match_unitA_value(void)//​**
Rida 2252: Rida 2307:
   * **//​unsigned short timer3_get_compare_match_unitA_value(void)//​**   * **//​unsigned short timer3_get_compare_match_unitA_value(void)//​**
   * **//​unsigned short timer3_get_compare_match_unitB_value(void)//​**   * **//​unsigned short timer3_get_compare_match_unitB_value(void)//​**
-  * **//​unsigned short timer3_get_compare_match_unitC_value(void)//​** \\ Taimeri ​1/3 signaali genereerimise üksuse ​A/B/C võrdlusväärtuse tagastamineParameetrid+  * **//​unsigned short timer3_get_compare_match_unitC_value(void)//​** \\ 
-    * Tagastab ​16-bitise üksuse võrdlusregistri väärtuse.+   ​Returns timer 1/3 output compare unit A/B/C compare match register valueParameters
 +    * Returns ​16-bit compare match register value.
  
   * **//void timer1_set_compare_match_unitA_value(unsigned short value)//**   * **//void timer1_set_compare_match_unitA_value(unsigned short value)//**
Rida 2260: Rida 2316:
   * **//void timer3_set_compare_match_unitA_value(unsigned short value)//**   * **//void timer3_set_compare_match_unitA_value(unsigned short value)//**
   * **//void timer3_set_compare_match_unitB_value(unsigned short value)//**   * **//void timer3_set_compare_match_unitB_value(unsigned short value)//**
-  * **//void timer3_set_compare_match_unitC_value(unsigned short value)//** \\ Taimeri ​1/3 signaali genereerimise üksuse ​A/B/C võrdlusväärtuse määramineParameetrid+  * **//void timer3_set_compare_match_unitC_value(unsigned short value)//** \\ 
-    * //value// - Uus 16-bitine võrdlusväärtus.+    Sets timer 1/3 output compare unit A/B/C compare match register valueParameters
 +    * //value// - New 16-bit compare match register value.
  
   * **//​unsigned short timer1_get_input_capture_value(void)//​**   * **//​unsigned short timer1_get_input_capture_value(void)//​**
-  * **//​unsigned short timer3_get_input_capture_value(void)//​** \\ Taimer ​1/3 sündmuste loenduri väärtuse tagastamineParameetrid+  * **//​unsigned short timer3_get_input_capture_value(void)//​** \\ 
-    * Tagastab ​16-bitise sündmuste loenduri registri väärtuse.+    Returns timer 1/3 input capture register valueParameters
 +    * Returns ​16-bit input capture register value.
  
   * **//void timer1_set_input_capture_value(unsigned short value)//**   * **//void timer1_set_input_capture_value(unsigned short value)//**
-  * **//void timer3_set_input_capture_value(unsigned short value)//** \\ Taimer ​1/3 sündmuste loenduri registri väärtuse määramineParameetrid+  * **//void timer3_set_input_capture_value(unsigned short value)//** \\ 
-    * //value// - Uus 16-bitine sündmuste loenduri väärtus.+    Sets timer 1/3 input capture register valueParameters
 +    * //value// - New 16-bit input capture register value.
  
   * **//void timer1_overflow_interrupt_enable(bool enable)//**   * **//void timer1_overflow_interrupt_enable(bool enable)//**
-  * **//void timer3_overflow_interrupt_enable(bool enable)//** \\ Taimer ​1/3 ületäitumise katkestuse lubamine või keelamineKatkestuse vektor on TIMERn_OVF_vect, kus "​n" ​on 1 või 3. Parameetrid+  * **//void timer3_overflow_interrupt_enable(bool enable)//** \\ 
-    * //enable// - Tõeväärtus katkestuse lubamiseks või keelamiseks. ​//​true// ​lubab, //​false// ​keelab.+    Enables or disables timer 1/3 overflow interruptThe name of the interrupt vector is "TIMERn_OVF_vect" where "​n" ​represents ​1 või 3. Parameters
 +    * //enable// - //​true// ​to enable interrupt, //​false// ​to disable.
  
   * **//void timer1_compare_match_unitA_interrupt_enable(bool enable)//**   * **//void timer1_compare_match_unitA_interrupt_enable(bool enable)//**
Rida 2280: Rida 2340:
   * **//void timer3_compare_match_unitA_interrupt_enable(bool enable)//**   * **//void timer3_compare_match_unitA_interrupt_enable(bool enable)//**
   * **//void timer3_compare_match_unitB_interrupt_enable(bool enable)//**   * **//void timer3_compare_match_unitB_interrupt_enable(bool enable)//**
-  * **//void timer3_compare_match_unitC_interrupt_enable(bool enable)//** \\ Taimer ​1/3 signaali genereerimise üksuse ​A/B/C võrdluse sündmuse katkestuse lubamine või keelamineKatkestuse vektor on TIMERn_COMPx_vect, kus on "​n" ​on või ja "​x" ​on A, B või C. Parameetrid+  * **//void timer3_compare_match_unitC_interrupt_enable(bool enable)//** \\ 
-    * //enable// - Tõeväärtus katkestuse lubamiseks või keelamiseks. ​//​true// ​lubab, //​false// ​keelab.+   ​Enables or disables timer 1/3 output compare unit A/B/C compare match interruptThe name of the interrupt vector is "TIMERn_COMPx_vect" where "​n" ​represents ​or and "​x" ​represents ​A, B or C. Parameters
 +    * //enable// - //​true// ​to enable interrupt, //​false// ​to disable.
  
   * **//void timer1_input_capture_interrupt_enable(bool enable)//**   * **//void timer1_input_capture_interrupt_enable(bool enable)//**
-  * **//void timer3_input_capture_interrupt_enable(bool enable)//** \\ Taimer ​1/3 sündmuste loenduri katkestuse lubamine või keelamineKatkestuse vektor on //TIMERn_CAPT_vect//kus "​n" ​on või 3. Parameetrid+  * **//void timer3_input_capture_interrupt_enable(bool enable)//** \\ 
-    * //enable// - Tõeväärtus katkestuse lubamiseks või keelamiseks. ​//​true// ​lubab, //​false// ​keelab.+    Enables or disables timer 1/3 input capture interruptThe name of the interrupt vector is "TIMERn_CAPT_vect"where "​n" ​represents ​or 3. Parameters
 +    * //enable// - //​true// ​to enable interrupt, //​false// ​to disable.
  
   * **//bool timer1_overflow_flag_is_set(void)//​**   * **//bool timer1_overflow_flag_is_set(void)//​**
-  * **//bool timer3_overflow_flag_is_set(void)//​** \\ Taimeri ​1/3 ületäitumise toimumise kontrollimineParameetrid+  * **//bool timer3_overflow_flag_is_set(void)//​** \\ 
-    * Tagastab tõeväärtuse ​//​true//, ​kui ületäitumine on toimunud, ja //false//, kui pole.+    Checks timer 1/3 overflow flagParameters
 +    * Returns ​//​true// ​when overflow has happened, //​false// ​when not.
  
   * **//bool timer1_input_capture_flag_is_set(void)//​**   * **//bool timer1_input_capture_flag_is_set(void)//​**
-  * **//bool timer3_input_capture_flag_is_set(void)//​** \\ Taimer ​1/3 sündmuste loenduri lipukese kontrollimineParameetrid+  * **//bool timer3_input_capture_flag_is_set(void)//​** \\ 
-    * Tagastab tõeväärtuse ​//​true//, ​kui sündmus on toimunud, ja //false//, kui pole.+    Checks timer 1/3 input capture flagParameters
 +    * Returns ​//​true// ​when input capture has done, //​false// ​when not.
  
   * **//void timer1_overflow_flag_clear(void)//​**   * **//void timer1_overflow_flag_clear(void)//​**
-  * **//void timer3_overflow_flag_clear(void)//​** \\ Taimeri ​1/3 ületäitumise sündmuse lipukese nullimine.+  * **//void timer3_overflow_flag_clear(void)//​** \\ 
 +    Resets timer 1/3 overflow flag.
  
   * **//void timer1_input_capture_flag_clear(void)//​**   * **//void timer1_input_capture_flag_clear(void)//​**
-  * **//void timer3_input_capture_flag_clear(void)//​** \\ Taimer ​1/3 sündmuste loenduri lipukese nullimine.+  * **//void timer3_input_capture_flag_clear(void)//​** \\ 
 +    Resets timer 1/3 input capture flag.
  
-=== Näide ​===+=== Example ​===
  
-Näites seadistatakse taimer ​tavalisse loendamise režiimi ja lubatakse ületäitumise katkestus.+In the following program timer is started in normal mode with overflow interrupt.
  
-<code c> + 
-#​include ​<​homelab/​timer.h>​ +#include  
-#​include ​<​avr/​interrupt.h>​+#​include ​
    
-// Katkestuse programmilõik+// Overflow interrupt program.
 ISR(TIMER0_OVF_vect) ISR(TIMER0_OVF_vect)
 { {
Rida 2316: Rida 2382:
 int main(void) int main(void)
 {  {
- // Taimer ​normaalrežiimi,​ taktijagur 32+ // Initializing of timer in normal mode.
  timer0_init_normal(TIMER0_PRESCALE_32);​  timer0_init_normal(TIMER0_PRESCALE_32);​
  
- // Taimer ​ületäitumise katkestuse lubamine+ // Enabling timer overflow interrupt.
  timer0_overflow_interrupt_enable(true);​  timer0_overflow_interrupt_enable(true);​
  
- // Globaalne katkestuste lubamine+ // Global interrupts enabling.
  sei();  sei();
 } }
-</​code>​ 
  
-==== Viide ====+/​home/​www/​roboticlab/​homelab_data/​pages/​en/​software/​homelab/​library/​timer_xmega.txt--- 
 + ​MISSING PAGE --- 
 +==== Delay ====
  
-Tegu on tarkvaraliste ja riistvaraliste viite tekitamise funktsioonide teegi osagaViite funktsioone välja kutsudes jääb programm neid ettenähtud ajaks täitma ja muu programmivälja arvatud katkestuste,​ täitmine peatub.+This part of library contains functions to generate delays in the program with software algorithms or with hardware timersDelays do not block interruptstherefore interrupts interfere with software delays. Delay functions are not pre-compiled to be compatible with different clock frequencies.
  
-Viitefunktsioonid pole eelnevalt kompileeritud,​ sest mikrokontrolleri taktsagedus võib  erinevates rakendustes erineda. Need kompileeritakse iga kord uuesti.+=== Functions ===
  
-=== Funktsioonid ===+  * **//void sw_delay_ms(unsigned short count)//** \\ 
 +    Software delay in milliseconds. Function expects the usage of some compiler optimization mode. Parameters:​ 
 +    * //count// - Delay time in milliseconds. 0 to 65535 ms.
  
-  ​* **//void sw_delay_ms(unsigned short count)//** \\ Tarkvaraline viide millisekundites. Funktsiooni kasutamine eeldab kompilaatorilt optimeerimise kasutust. Parameetrid:​ +  * **//void sw_delay_us(unsigned short count)//** \\ 
-    * //count// - Viite aeg millisekundites. 0 kuni 65535 millisekundit. +    ​Software delay in microsecondsFunction expects the usage of some compiler optimization modeParameters
-  ​* **//void sw_delay_us(unsigned short count)//** \\ Tarkvaraline viide mikrosekundites. Funktsiooni kasutamine eeldab kompilaatorilt optimeerimise kasutust. Parameetrid:​ +    * //count// - Delay time in microseconds. 0 to 65535 μs.
-    ​* //count// - Viite aeg mikrosekundites0 kuni 65535 mikrosekundit. +
-  * **//void hw_delay_ms(unsigned short count)//** \\ Riistvaraline taimeril põhinev viide millisekundites. Funktsioon kasutab ATmega128 8-bitist taimerit 0. Olenevalt taktsagedusest võib tekkida kuni mõne millisekundi suurune viga. Täpsema viite saaks teha 16-bitiste taimeritega,​ kuid neid on tavaliselt muuks otstarbeks vajaParameetrid+
-    * //count// - Viite aeg millisekundites. 0 kuni 65535 millisekundit.+
  
-=== Näide ===+  * **//void hw_delay_ms(unsigned short count)//** \\' 
 +    Hardware timer based delay in milliseconds. Functions use ATmega128 8-bit timer 0. Depending of the clock frequency, up to several milliseconds delay error  may occur. Parameters:​ 
 +    * //count// - Delay time in milliseconds. 0 to 65535 ms.
  
-Mõlemat liiki viitefunktsioonide kasutamise näide:+=== Examples ===
  
-<code c> +Demonstration of both types of delays. 
-#​include ​<​homelab/​delay.h>​+ 
 + 
 +#​include ​
  
 int main(void) int main(void)
 {  {
- // Tarkvaraline viide 100 ms+ // Software base delay of 100 ms.
  sw_delay_ms(100);​  sw_delay_ms(100);​
   
- // Riistvaraline viide 100 ms+ // Hardware timer based delay of 100 ms.
  hw_delay_ms(100);​  hw_delay_ms(100);​
 } }
-</​code>​ 
  
-==== 7-segmendiline LED indikaator ==== 
  
-//Seotud mooduliga: [HW] [[et:​hardware:​homelab:digi]]//+/home/​www/​roboticlab/​homelab_data/​pages/​en/​software/homelab/library/buzzer.txt--- 
 + ​MISSING PAGE --- 
 +==== 7-segment LED Display ====
  
-See teek on spetsiaalselt loodud Kodulabori Digitaalse sisend-väljundmooduli plaadil asuva indikaatori kasutamiseks. 7-segmendilise indikaatoriga saab kuvada numbreid 0 kuni 9 ja mõningaid tähti.+//Related to: [HW] [[en:​hardware:​homelab:​digi]]//​
  
-=== Funktsioonid ​===+This library is intended to use a 7-segment LED display on the HomeLab Digital i/o module board. Numbers from 0 to 9 can be displayed with the library. 
 + 
 +=== Functions ​===
  
   * **//void segment_display_init(void)//​** \\   * **//void segment_display_init(void)//​** \\
-    ​Indikaatori juhtviikude seadmistamine väljundiks.+    ​Configures display driver control pins.
  
   * **//void segment_display_write(unsigned char digit)//** \\   * **//void segment_display_write(unsigned char digit)//** \\
-    ​Soovitud numbri kuvamine indikaatorigaParameetrid+    ​Displayes a digit on displayParameters
-    * //digit// - Number 0 kuni 9. Muude väärtuste puhul kuvatakse ​nagu //error// (viga).+    * //digit// - Number ​value from to 9. Any other case like "error" is displayed. 
 + 
 +=== Example ===
  
-=== Näide ===+Number 5 is showed on LED display.
  
-Näites on number 5 kuvamise protseduur. 
  
-<code c> +#​include ​
-#​include ​<​homelab/​module/​segment_display.h>​+
    
 int main(void) int main(void)
 { {
- // 7-segmendilise indikaatori seadistamine+ // Display initialization.
  segment_display_init();​  segment_display_init();​
  
- // Indikaatoril numbri 5 kuvamine+ // Digit displaying.
  segment_display_write(5);​  segment_display_write(5);​
 } }
-</​code>​ 
  
  
  
  
-==== Alfabeetiline LCD ==== 
  
-//Seotud mooduliga: [HW] [[et:​hardware:​homelab:​lcd]]//​+==== Alphanumeric LCD ====
  
-See teegi osa sisaldab Kodulabori alfabeetilise LCD kasutamise funktsioone.+//Related to: [HW] [[en:​hardware:​homelab:​digi]]//​
  
-=== Andmetüübid ===+This library contains functions to use the HomeLab alphanumeric LCD.
  
-  * **//​lcd_alpha_mode//​** \\ Ekraani algseadistuse valiku tüüp. Väärtuste variandid ja tähendused:​ +=== Data Types ===
-    * //​LCD_ALPHA_DISP_OFF//​ - Ekraani väljalülitamine. +
-    * //​LCD_ALPHA_DISP_ON//​ - Ekraani tööle lülitamine ilma kursorita (nähtamatu kursor). +
-    * //​LCD_ALPHA_DISP_ON_CURSOR//​ - Ekraani tööle lülitamine koos kursoriga. +
-    * //​LCD_ALPHA_DISP_ON_CURSOR_BLINK//​ - Ekraani tööle lülitamine koos vilkuva kursoriga.+
  
-=== Funktsioonid ===+  * **//​lcd_alpha_mode//​** \\ LCD configuration enumeration data type. Options: 
 +    * //​LCD_ALPHA_DISP_OFF//​ - Display off. 
 +    * //​LCD_ALPHA_DISP_ON//​ - Display on with invisible cursor. 
 +    * //​LCD_ALPHA_DISP_ON_CURSOR//​ - Display on with cursor. 
 +    * //​LCD_ALPHA_DISP_ON_CURSOR_BLINK//​ - Display on with blinking cursor.
  
-  * **//void lcd_alpha_init(lcd_alpha_mode disp_attr)//​** \\ Ekraani tööks seadistamine. Parameetrid:​ +=== Functions ===
-    * //​disp_attr//​ - Ekraani seadistuse valik.+
  
-  * **//​void ​lcd_alpha_clear(void)//** \\ Ekraani tühjendamine kõigist märkidestKursor viiakse pärast tühjendamist esimese rea algusesse.+  * **//​void ​lcd_alpha_init(lcd_alpha_mode disp_attr)//** \\ 
 +    Initializes LCDParameters:​ 
 +    * //​disp_attr//​ - Display configuration.
  
-  * **//​void ​lcd_alpha_clear_line(unsigned char line)//** \\ Ekraani ühe rea tühjendamine. Kursor viiakse pärast tühjendamist tühjendatud rea algusesse. Parameetrid:​ +  * **//​void ​lcd_alpha_clear(void)//** \\ 
-    ​* //line// - Rea number. Väärtus 0 või 1.+    ​Clears the whole display. Cursor is moved to the beginning of the first line.
  
-  * **//​void ​lcd_alpha_home(void)//** \\ Kursori esimese rea algusesse viimine. +  * **//​void ​lcd_alpha_clear_line(unsigned char line)//** \\ 
-  * **//void lcd_alpha_goto_xy(unsigned char x, unsigned char y)//** - Kursori soovitud positsioonile viimine. Parameetrid:​ +    ​Clears a line on displayCursor is moved to the beginning of cleared lineParameters: 
-    ​* //x// - X koordinaat (veeru number)Väärtus 0 kuni 15+    * //line// - Line number. 0 or 1.
-    * //y// - Y koordinaat (rea number)Väärtus ​või 1.+
  
-  * **//​void ​lcd_alpha_write_char(char c)//** \\ Sümboli kuvamine ekraani kursori positsioonil. Parameetrid:​ +  * **//​void ​lcd_alpha_home(void)//** \\ 
-    ​* //c// - ASCII sümbol.+    ​Moves cursor to the beginning of the first line.
  
-  * **//​void ​lcd_alpha_write_string(const char *s)//** \\ Teksti kuvamine ekraanil kursori positsioonist alatesParameetrid:​ +  * **//​void ​lcd_alpha_goto_xy(unsigned ​char x, unsigned char y)//** \\ 
-    * //s// - Teksti viit.+    Moves cursor to the desired position. Parameters
 +    * //x// - X coordinate (column number). 0 to 15. 
 +    * //y// - Y coordinate (line number). 0 to 1.
  
-  * **//​void ​lcd_alpha_write_string_p(const char *progmem_s)//** \\ Programmimälus asuva teksti kuvamine ekraanil kursori positsioonist alatesParameetrid+  * **//​void ​lcd_alpha_write_char(char c)//** \\ 
-    * //progmem_s// - Viit tekstile programmimälus.+    Writes a character to the cursor positionParameters
 +    * //c// - ASCII character.
  
-=== Näide ===+  * **//void lcd_alpha_write_string(const char *s)//** \\ 
 +    Writes a string to the display starting from the position of the cursor. Parameters:​ 
 +    * //s// - Pointer to string (char array).
  
-<code c> +  * **//void lcd_alpha_write_string_p(const char *progmem_s)//​** \\ 
-#include <homelab/module/lcd_alpha.h>+    ​Writes a string from program memory to the display starting from the position of the cursor. Parameters 
 +    * //progmem_s// - Pointer to string in program memory. 
 + 
 +=== Example === 
 + 
 +Demonstration of how to use alphanumeric LCD to display text. 
 + 
 + 
 +#​include ​
  
 int main(void) int main(void)
 { {
- // Ekraani seadistamine+ // LCD initialization.
  lcd_alpha_init(LCD_ALPHA_DISP_ON);​  lcd_alpha_init(LCD_ALPHA_DISP_ON);​
  
- // LCD ekraani puhastamine+ // Display clearing.
  lcd_alpha_clear();​  lcd_alpha_clear();​
  
- // Kursori (nähtamatu) teise rea algusesse viimine+ // Cursor to the beginning of second line.
  lcd_alpha_goto_xy(0,​ 1);   lcd_alpha_goto_xy(0,​ 1);
  
- // Teksti kuvamine + // Text displaying. 
- lcd_alpha_write_string("​Tere");+ lcd_alpha_write_string("​Hello");
 } }
-</​code>​ 
  
-==== Graafiline LCD ==== 
  
-//Seotud mooduliga: [HW] [[et:​hardware:​homelab:​lcd]]//​+==== Graphic LCD ====
  
-See teegi osa sisaldab Kodulabori graafilise LCD kasutamise funktsioone. Kuigi LCD on graafiline, puuduvad teegist hetkel siiski kujundite joonistamise funktsioonid.+//Related to: [HW] [[en:​hardware:​homelab:​digi]]//​
  
-=== Funktsioonid ===+This library contains functions to use the HomeLab graphical LCD. Although the LCD is capable of displaying graphical images, no such functions are implemented in the library. The LCD is used as a 14 x 6 character alphanumeric display.
  
-  * **//void lcd_gfx_init(void)//​** \\ Ekraani tööks seadistamine.+=== Functions ===
  
-  * **//​void ​lcd_gfx_backlight(bool set)//** \\ Ekraani taustvalgustuse lülitamine. Parameetrid:​ +  * **//​void ​lcd_gfx_init(void)//** \\ 
-    ​* //set// - Tõeväärtus taustvalgustuse töötamisest. //true// puhul taustvalgustus on sees, //false// puhul väljas.+    ​Intializes LCD.
  
-  * **//​void ​lcd_gfx_clear(void)//** \\ Kogu ekraani tühjendamine.+  * **//​void ​lcd_gfx_backlight(bool set)//** \\ 
 +    Switch LCD backlight on or off. Parameters:​ 
 +    * //set// - //true// when backlight on, //false// when off.
  
-  * **//​void ​lcd_gfx_clear_line(unsigned char line)//** \\ Ekraani ühe tekstirea kustutamine. Parameetrid:​ +  * **//​void ​lcd_gfx_clear(void)//** \\ 
-    ​* //line// - Rea number 0 kuni 5.+    ​Clears a whole display.
  
-  * **//​void ​lcd_gfx_goto_char_xy(unsigned char x, unsigned char y)//** - Märgi positsiooni valik teksti väljastamiseks. Parameetrid:​ +  * **//​void ​lcd_gfx_clear_line(unsigned char line)//** \\ 
-    ​* //x// - X koordinaat. Väärtus 0 kuni 13+    ​Clears a single text lineParameters: 
-    * //y// - Y koordinaatVäärtus ​kuni 5.+    * //line// - Line number. 0 to 5.
  
-  * **//​void ​lcd_gfx_write_char(char c)//** \\ Sümboli kuvamine ekraanil eelnevalt määratud positsioonilParameetrid+  * **//​void ​lcd_gfx_goto_char_xy(unsigned ​char x, unsigned char y)//** \\ 
-    * //c// - ASCII sümbol.+    Selects a position to write text toParameters
 +    * //x// - X coordinate. 0 to 13. 
 +    * //y// - Y coordinate. 0 to 5.
  
-  * **//​void ​lcd_gfx_write_string(char *s)//** \\ Teksti kuvamine ekraanil eelnevalt määratud positsioonist alatesParameetrid+  * **//​void ​lcd_gfx_write_char(char c)//** \\ 
-    * //s// - Teksti viit.+    Writes a character to the pre-defined positionParameters
 +    * //c// - ASCII character.
  
-=== Näide ===+  * **//void lcd_gfx_write_string(char *s)//** \\ 
 +    Writes a string to the display starting from the pre-defined position. Parameters:​ 
 +    * //s// - Pointer to string (char array).
  
-<code c> +=== Example === 
-#​include ​<​homelab/​module/​lcd_gfx.h>​+ 
 +Demonstration of using a graphical LCD. 
 + 
 + 
 +#​include ​
  
 int main(void) int main(void)
 { {
- // Ekraani seadistamine+ // LCD initialization.
  lcd_gfx_init();​  lcd_gfx_init();​
  
- // LCD ekraani puhastamine+ // Display clearing.
  lcd_gfx_clear();​  lcd_gfx_clear();​
  
- // Kursori (nähtamatu) ekraani keskele viimine+ // Cursor to the middle of the screen.
  lcd_gfx_goto_char_xy(5,​ 2);  lcd_gfx_goto_char_xy(5,​ 2);
  
- // Teksti kuvamine + // Displaying a text. 
- lcd_gfx_write_string("​Tere");+ lcd_gfx_write_string("​Hello");
 } }
-</​code>​ 
-==== Mootorid ==== 
  
-//Seotud mooduliga: [HW] [[et:​hardware:​homelab:​motor]]//​+==== Motors ====
  
-Mootorite teek võimaldab juhtida Kodulabori mootorite moodulit ja mootoreid, mis sinna ühenduvad. Olemas on alalisvoolu-,​ samm- ja servomootorite juhtimise funktsioonid. ​+//Related to: [HW] [[en:​hardware:​homelab:​motor]]//​
  
-=== Funktsioonid ​===+This library contains functions to control different HomeLab motors. There are functions for DC, stepper and servo motors. 
 + 
 +=== Data Types === 
 + 
 +  * **//​prescale//​** \\  PWM clock prescaler enumration data type. It determines the division factor of system clock. It is recommended to use the first two division factors. Options: 
 +    * //​TIMER2_NO_PRESCALE//​ - Division factor not used. 
 +    * //​TIMER2_PRESCALE_8//​ - Division factor 8. 
 +    * //​TIMER2_PRESCALE_64//​ - Division factor 64. 
 +    * //​TIMER2_PRESCALE_256//​ - Division factor 256. 
 +    * //​TIMER2_PRESCALE_1024//​ - Division factor 1024. 
 + 
 +=== Functions ​===
  
   * **//void dcmotor_init(unsigned char index)//** \\   * **//void dcmotor_init(unsigned char index)//** \\
-    ​Ühe alalisvoolu mootorikontrolleri juhtviikude seadistamine väljundiksParameetrid+    ​Initializes one of the DC motor controllersParameters
-    * //index// - Mootorikontrolleri numberVäärtus ​kuni 3.+    * //index// - Index of motor controller. 0 to 3.
  
   * **//void dcmotor_drive(unsigned char index, signed char direction)//​** \\   * **//void dcmotor_drive(unsigned char index, signed char direction)//​** \\
-    ​Alalisvoolu mootorikontrolleri juhtkäskParameetrid+    ​Drives one of the DC motor controllersParameters
-    * //index// - Mootorikontrolleri numberVäärtus ​kuni 3. +    * //index// - Index of motor controller. 0 to 3. 
-    * //​direction//​ - Mootori polaarsusVäärtus ​-1, 0 või +1. 0 puhul mootor seisabmuul juhul pöörleb vastavas suunas.+    * //​direction//​ - Motor polarity. -1, 0 or +1. In case of motor is stoppedotherwise it turns in given direction. 
 + 
 +  * **//void dcmotor_drive_pwm_init(unsigned char index, timer2_prescale prescaler)//​** \\     ​Initializes one of the DC motor controllers for speed control. In addition, you can set the appropriate prescaler, depending on the frequency of the PWM's you need. Parameters:​ 
 +    * //index// - Index of motor controller. 0 to 3. 
 +    * //​prescaler//​ - Clock prescaler selection. Interruptions can occur very quickly upset the program of work. For example, when the UH sensor is used, it is necessary to set the prescaler TIMER2_PRESCALE_8.  
 + 
 +  * **//void dcmotor_drive_pwm(unsigned char index, signed char direction, unsigned char speed) //** \\ 
 +Drives one of the DC motor controllers. Motor rotates in a predetermined direction and speed. Parameters:​ 
 +    * //index// - Index of motor controller. 0 to 3. 
 +    * //​direction//​ -  Motor polarity. -1 or +1.  
 +    * //speed// - Motor speed. ​ 0 to 255. 0 the engine is stopped and the 255 is the maximum possible speed. 
 + 
 +  * **//void unipolar_init(unsigned char index)//** \\ 
 +    Initializes one of the unipolar stepper motor controllers. Parameters:​ 
 +    * //index// - Index of motor controller. 0 or 1. 
 + 
 +  * **//void unipolar_halfstep(unsigned char index, signed char direction, unsigned short num_steps, unsigned char speed)//** \\ 
 +    Unipolar stepper motor half-stepping command. Functions is blocking as it is fulfilled as long as steps are done. Parameters:​ 
 +    * //index// - Index of motor controller. 0 or 1. 
 +    * //​direction//​ - Directions of rotation. -1 or +1. 
 +    * //​num_steps//​ - Count of half-steps. 
 +    * //speed// - Time of a single step in milliseconds.
  
   * **//void bipolar_init(void)//​** \\   * **//void bipolar_init(void)//​** \\
-    ​Bipolaarse mootorikontrolleri juhtviikude seadistamine väljundiks.+    ​Initializes bipolar stepper motor controller.
  
   * **//void bipolar_halfstep(signed char direction, unsigned short num_steps, unsigned char speed)//** \\   * **//void bipolar_halfstep(signed char direction, unsigned short num_steps, unsigned char speed)//** \\
-    ​Bipolaarse samm-mootori mootorikontrolleri poolsammumise juhtkäskFunktsioon on blokeeruv ehk seda täidetakse seni, kuni soovitud arv samme on tehtudParameetrid+    ​Bipolar stepper motor half-stepping commandFunctions is blocking as it is fulfilled as long as steps are doneParameters
-    * //​direction//​ - PöörlemissuundVäärtus ​-1 või +1. +    * //​direction//​ - Directions of rotation. -1 or +1. 
-    * //​num_steps//​ - Poolsammude arv+    * //​num_steps//​ - Count of half-steps
-    * //speed// - Ühe sammu tegemise aeg millisekundites.+    * //speed// - Time of a single step in milliseconds.
  
   * **//void servomotor_init(unsigned char index)//** \\   * **//void servomotor_init(unsigned char index)//** \\
-    ​Ühe servomootori juhtviikude väljundiks seadistamine ja taimer ​seadistamine ​PWM režiimiParameetrid+    ​Initializes one of a servo motor PWM signal generations units in ATmega128 timer 1PWM signal is 50 hz with high period of 1.5 ms ± 0.5 msParameters
-    * //index// - Servomootori numberVäärtus ​või 1.+    * //index// - Index of servo motor. 0 or 1.
  
   * **//void servomotor_position(unsigned char index, signed short position)//​** \\   * **//void servomotor_position(unsigned char index, signed short position)//​** \\
-    ​Servomootori juhtkäskKui juhitakse positsioneerivat servomootoritsiis muutub rootori asendkui lõputult pöörlevatsiis muutub pöörlemise kiirusParameetrid+    ​Servo motor pulse width control commandIf positioning servo motor is drivenits position is alteredif rotating oneits rotation speed is alteredParameters
-    * //index// - Servomootori numberVäärtus ​või 1. +    * //index// - Index of servo motor. 0 or 1. 
-    * //​position//​ - Rootori asend või pöörlemiskiirus (olenevalt mootorist)Väärtus ​-100 kuni +100. 0 on keskasend või peatumine.+    * //​position//​ - Position or rotation speed. -100 to +100. 0 corresponds to stop.
  
-~~PB~~+=== Example ===
  
-=== Näide ===+The following program demonstrates the usage of DC, stepper and servo motors.
  
-Järgnev näide demonstreerib kõiki teegi funktsioone. Järjest seadistatakse mootorikontrollerid ja liigutatakse mootoreid. 
  
-<code c> +#​include ​
-#​include ​<​homelab/​module/​motors.h>​+
    
 int main(void) int main(void)
 { {
- // Alalisvoolu mootorikontrollerite 0 ja 1 seadistamine+ // DC motors initialization.
  dcmotor_init(0);​  dcmotor_init(0);​
  dcmotor_init(1);​  dcmotor_init(1);​
  
- // Bipolaarse samm-mootori kontrolleri seadistamine+ // Bipolar stepper initialization.
  bipolar_init();​  bipolar_init();​
  
- // Servomootorite 0 ja 1 juhtsignaalide seadistamine+ // Servo motors initialization.
  servomotor_init(0);​  servomotor_init(0);​
  servomotor_init(1);​  servomotor_init(1);​
  
- // Üks alalisvoolu mootor pöörlema ühtpiditeine teistpidi+ // One DC motors drives forwardanother in backward direction.
  dcmotor_drive(0,​ -1);  dcmotor_drive(0,​ -1);
  dcmotor_drive(1,​ +1);  dcmotor_drive(1,​ +1);
  
- // Samm-mootori pööramine ​100 kraadi ühele poole ja seejärel + // Rotating the stepper motor 100 steps in one direction 
- // 2 korda kiiremini teisele poole+ // and then back with twice the speed.
  bipolar_halfstep(1,​ 100, 50);  bipolar_halfstep(1,​ 100, 50);
  bipolar_halfstep(-1,​ 100, 25);  bipolar_halfstep(-1,​ 100, 25);
  
- // Servomootorite vastassuunda keeramine+ // Rotating servo motors in opposite directions.
  servomotor_position(0,​ -100);  servomotor_position(0,​ -100);
  servomotor_position(1,​ +100);  servomotor_position(1,​ +100);
 } }
-</​code>​ 
  
  
 +This example demonstrates the speed adjustments of a DC motor. ​
  
  
-==== Andurid ====+#​include ​
  
-//Seotud mooduliga: [HW] [[et:​hardware:​homelab:​sensor]]//​+int main(void) 
 +
 +        unsigned char speed = 0; 
 +  
 + // DC motors initialization 
 +  dcmotor_drive_pwm_init(0,​ TIMER2_NO_PRESCALE);​
  
-See teegi osa sisaldab Kodulabori andurite kasutamise funktsioone.+  while(1) 
 +  {     
 + speed = 100;
  
-=== Andmetüübid ===+ // DC motors drives predefined speed and direction. 
 + dcmotor_drive_pwm(0,​ 1, speed);​  ​      
 +  } 
 +}
  
-  * **//​ir_distance_sensor//​** \\ Infrapuna-kaugusanduri kauguse arvutuse funktsiooni parameetrite struktuur. Kauguse arvutusvalem on  //a / (ADC + b) - k//. Struktuuri liikmed: +==== Encoders ====
-    * //a// - jagatav. +
-    * //b// - vabaliige. +
-    * //k// - korrigeerimiskonstant.+
  
-=== Konstandid ===+//Related to modules: [HW] [[en:​hardware:​homelab:​motor]]//​
  
-    * **//​ir_distance_sensor GP2Y0A21YK//​** - Sharp GP2Y0A21YK kaugusanduri parameetrite struktuuri objekt.+This library includes usage functions of Homelab'​s encoders.
  
-=== Funktsioonid ​===+=== Functions ​ === 
 +  * **//void encoder_init(unsigned char index)//** \\ 
 +   ​configures selected encoder and the input pins. Parameters:​ 
 +    * //index// - Number of the encoder. Value 0 to 1. 
 +    
 +  * **//void encoder_reset_pulses(unsigned char index)//** \\ 
 +    Resets and starts counting the selected encoder. Parameters:​ 
 +    * //index// - Number of the encoder. Value 0 to 1. 
 + 
 +  * **//​unsigned short encoder_get_pulses(unsigned char index)//** \\ 
 +    Request of counted encoder impulses. Parameters:​ 
 +    * //index// -  Number of the encoder. Value 0 to 1. 
 +    * Returns the number of pulses 
 + 
 + 
 +<​pagebreak>​ 
 + 
 +=== Example === 
 + 
 + 
 +// 
 +// Example of using the Homelab'​s encoders. 
 +// The number of pulses is displayed on LCD. 
 +// 
 +#include  
 +#include  
 +#include  
 +#include  
 +#include  
 +#include  
 + 
 +// Button pin 
 +pin button2 = PIN(C, 1); 
 +  
 + 
 +int main(void) 
 +
 + unsigned short pulses = 0; 
 + char text[16]; 
 + 
 + // Sets buttons 
 + pin_setup_input_with_pullup(button2);​ 
 + 
 + // Initialization of encoder  
 + encoder_init(0);​ 
 + 
 + // Reset and start counting 
 + encoder_reset_pulses(0);​ 
 + 
 + // LCD display initialization 
 + lcd_gfx_init();​ 
 +  
 + // Clear display 
 + lcd_gfx_clear();​ 
 +  
 + // Turning back light ON 
 + lcd_gfx_backlight(true);​  
 +  
 + // Displaying source code name 
 + lcd_gfx_goto_char_xy(3,​ 1); 
 + lcd_gfx_write_string("​Encoder"​);​ 
 +  
 + while (true) 
 +
 + pulses = encoder_get_pulses(0);​ 
 +  
 + 
 + // Generating a string 
 + sprintf(text,​ "​Pulsse:​ %d",​pulses);​ 
 +  
 +  
 + lcd_gfx_goto_char_xy(0,​ 3); 
 + lcd_gfx_write_string(text);​ 
 + 
 + 
 + // Button 2 is pressed 
 +     if(!pin_get_debounced_value(button2)) 
 +
 + // Reset and start counting 
 + encoder_reset_pulses(0);​ 
 + 
 + // Make a beep 
 + buzzer_sound (60, 100); 
 + 
 + // Erase previous number 
 + lcd_gfx_write_string(" ​   "); 
 + }  
 +  
 + // Software delay for 10 ms  
 + sw_delay_ms(10);​ 
 +
 +
 + 
 + 
 + 
 +==== Sensors ==== 
 + 
 +//Related to: [HW] [[en:​hardware:​homelab:​sensor]]//​ 
 + 
 +This library contains functions to use different sensors in the HomeLab kit. 
 + 
 +=== Data Types === 
 + 
 +  * **//​ir_distance_sensor//​** \\ 
 +    Infrared distance sensor distance calculation parameters structure. Formula for distance calculation is //a / (ADC + b) - k//. Structure members: 
 +    * //a// - Dividend. 
 +    * //b// - Non-linear constant. 
 +    * //k// - Linearizing constant. 
 + 
 +=== Constants === 
 + 
 +    * **//​ir_distance_sensor GP2Y0A21YK//​** \\ 
 +    Sharp GP2Y0A21YK distance calculation formula parameters. 
 + 
 +=== Functions ​===
  
   * **//signed short thermistor_calculate_celsius(unsigned short adc_value)//​** \\   * **//signed short thermistor_calculate_celsius(unsigned short adc_value)//​** \\
-    ​Termistori temperatuuri arvutamine Celsiuse kraadides ​ADC muunduri väärtusestFunktsioon põhineb teisendustabelilParameetrid+    ​Calculates thermistor temperature in Celsius degrees from ADC conversion resultFunctions use pre-calculated conversion tableParameters
-    * //​adc_value//​ - ADC teisenduse väärtus+    * //​adc_value//​ - ADC conversion result (10-bit with +5 V reference voltage).
-    * Tagastab temperatuuri Celsiuse kraadides ​-20 kuni 100 kraadi piires.+    * Returns temperature in Celsius degrees in the -20 to 100 degrees limit.
  
   * **//signed short ir_distance_calculate_cm(ir_distance_sensor sensor, unsigned short adc_value)//​** \\   * **//signed short ir_distance_calculate_cm(ir_distance_sensor sensor, unsigned short adc_value)//​** \\
-    ​IR kaugusanduri väljundpinge ​ADC väärtuse sentimeetriteks ümberarvutamise funktsioonParameetrid+    ​Calculates distance from ADC result received from IR distance sensor voltageParameters
-    * //sensor// - Kaugusanduri parameetrite struktuuri objekt+    * //sensor// - Distance sensor calculation parameters
-    * //​adc_value//​ - 10-bitine ​+5 V võrdluspingega ADC väärtus+    * //​adc_value//​ - ADC conversion result (10-bit with +5 V reference voltage)
-    * Tagastab kauguse sentimeetrites või -1, kui seda ei saanud arvutada.+    * Returns distance in centimeters or -1 if it cannot be calculated.
  
-  * **//​unsigned short ultrasonic_measure(pin trigger, pin echo)//** \\ +  * **//​unsigned short ultrasonic_measure_srf04(pin trigger, pin echo)//** \\ 
-    ​Ultraheli-kaugusanduri mõõtmise teostamise funktsioon. Funktsioon tekitab ​SRF04 kaugusmõõdiku päästikuimpulsi ja mõõdab kajaimpulsi saabumise aegaAja põhjal arvutatakse objekti kaugusMõõtmine võtab aega kuni 36 msFunktsioon eeldab ​14.7456 MHz mikrokontrolleri taktsagedustParameetrid+    ​Measures distance with ultrasonic distance sensor ​SRF04. ​Function generates a trigger pulse on one pin and measures the time of echo pulse on another pinDistance is calculated from the timeFunction expects a 14.7456 MHz clock frequencyMeasuring may take up to 36 ms. Parameters
-    * //trigger// - päästiku viigu muutuja+    * //trigger// - Trigger pin variable
-    * //echo// - kaja viigu muutuja+    * //echo// - Echo pin variable
-    * Tagastab kauguse sentimeetrites või 0, kui mõõtmine ebaõnnestus.+    * Returns distance in centimeters or when measuring failed. 
 +  * **//​unsigned short ultrasonic_measure_srf05(pin trigger_echo)//​** \\ 
 +    Measures distance with ultrasonic distance sensor SRF05 in one wire regime. Function generates a trigger pulse on the pin and measures the time of echo pulse on the same pin. Distance is calculated from the time. Function expects a 14.7456 MHz clock frequency. Measuring may take up to 36 ms. Parameters:​ 
 +    * //​trigger_echo//​ - Trigger/​Echo combined pin variable. 
 +    * Returns distance in centimeters or 0 when measuring failed.
  
-~~PB~~+=== Example ===
  
-=== Näide ===+The following program demonstrates usage of IR and ultrasonic distance sensor SRF05.
  
-<code c> 
-#include <​homelab/​module/​sensors.h>​ 
  
-// Ultraheli kaugusmõõdiku juhtviigud +#include  
-pin pin_trigger = PIN(G, 1); + 
-pin pin_echo ​   = PIN(G, 0);+// Ultrasonic distance sensor control pins. 
 +pin pin_triggerecho ​   = PIN(G, 0);
  
 int main(void) int main(void)
 { {
- unsigned short adc_value = 400; // näidisväärtus+ unsigned short adc_value = 400; // random ADC result.
  signed short distance;  signed short distance;
  
- // IR kaugusanduri ​ADC väärtuse sentimeetriteks teisendamine+ // Distance calculation from IR distance sensor ​ADC result.
  distance = ir_distance_calculate_cm(GP2Y0A21YK,​ adc_value);  distance = ir_distance_calculate_cm(GP2Y0A21YK,​ adc_value);
  
- // Ultraheli-kaugusanduriga mõõtmine + // Measuring with ultrasonic distance sensor. 
- distance = ultrasonic_measure(pin_trigger,​ pin_echo);+ distance = ultrasonic_measure_srf05(pin_triggerecho);
 } }
-</​code>​ 
  
-====== ​Praktilised näited ​====== +==== Ethernet ​====
-{{  :​images:​book:​kit_setup.jpg?​580| ​ }}+
  
-Praktilised näited on üles ehitatud ​ ühtse läbiva stiiliga ja võimalikult konkreetsed. Iga näide algab lühikese teoreetilise taustaga, andes nii vajalikud põhiteadmised harjutuses järgnevale praktilisele osale. Praktiline osa sisaldab endas tarkvara lähtekoodi kommenteeritud näidet. Üldjuhul on koodinäites kasutatud Kodulabori teeki, aga mõne näite puhul ka otsest registrite seadistamist. Natuke erineva struktuuri ja eesmärgiga on esimene peatükk, mis kirjeldab vajaliku tarkvara paigaldamist ja seadistamist. Näited on toodud Windowsi ja Linuxi keskkondade jaoks. Järgnevad peatükid ja praktilised näited sobivad mõlema operatsioonisüsteemi ja arendustarkvara jaoks.+//Necessary knowledge: [HW] [[en:​hardware:​homelab:​controller]]//​
  
-~~PB~~+The following part of library contains HomeLab Ethernet functions.
  
-**Ülesehitus**+=== Constants ===
  
-Praktiliste näidete peatükkide juures on toodud loetelu näite läbimiseks vajalikest eelteadmistestLoetelus on viited raamatu teistele peatükkidelemis on tähistatud teemakohaste ikoonidega:+    * **//static uint8_t mymac[6] = {0x54,​0x55,​0x58,​0x10,​0x00,​0x24}//​** - controller MAC address (you can choose a random address, but it is important to be unique in the network). 
 +    * **//static uint8_t myip[4] = {192,168,​1,​100}//​** - IP address corresponding to LAN, you must choose different last digit, if it is already present in the network. 
 +    * **//static uint8_t buf[BUFFER_SIZE+1]//​** - size of data buffer (usually 600+1 B).
  
-  * [HW] Näites kasutatud riistvara moodul 
-  * [LIB] Näites kasutatud tarkvara teegi osa 
-  * [ELC] Viide elektroonika baasteadmiste peatükile 
-  * [AVR] Viide AVR mikrokontrolleri mooduli peatükile 
-  * [PRT] Viide teisele harjutusele 
  
-**Näidete baastarkvara**+=== Functions ===
  
-Nagu eespool öeldud, on praktilised koodinäited koostatud Kodulabori teegi baasil. Teeki on kirjutatud enimkasutatavad AVR spetsiifilised operatsioonid ja Kodulabori moodulitega seotud protseduurid. Teegi kasutamine tähendab, et kasutaja ei pea moodulite töölepanekuks kirjutama riistvaralähedast,​ registritega toimetavat programmikoodi,​ kuigi see võimalus on alati olemas. Riistvaraga suhtleva tarkvara eraldamine näidetest ja harjutusülesannetest võimaldab kasutajal keskenduda oma algoritmi loomisele, mitte riistvaraga seotud eripäradele.+  * **//void ethernet_standby(void)//​** \\ 
 +    Brings Ethernet controller into sleep mode (low energy consumption).
  
-**Näidete koodistiil**+  ​* **//void ethernet_init(uint8_t ​*mac, uint8_t *ip)//** \\ 
 +    Ethernet controller initial setup with MAC and IP addresses. 
 +    Parameters:​ 
 +    * //*mac// - MAC address array. 
 +    * //*ip// - IP address array.
  
-Näidisprogrammid on kirjutatud ühtses stiiliset programmikood oleks ülevaatlikumÜhtne stiil teeb programmi loetavaks ja välistab kergemate süntaksivigade tekkimiseKindlat stiili on soovitatav järgida ka harjutusülesannete tegemiselStiili peamised iseloomustajad:​+  * **//​uint16_t ethernet_get_packet (uint16_t maxlenuint8_t* packet)//** \\ 
 +    Polls network until it receives packet addressed to it and containing data. 
 +    Parameters:​ 
 +    * //maxlen// - maximum allowed data buffer size. 
 +    * //*buffer// - array where to save received data for further operations. 
 +    * If the packet has arrived, returns the length of the received packet in bytes and in opposite case returns 0.
  
-  * Programmselle funktsioonid ja muutujad on ingliskeelsed ning väiketähtedega,​ kus sõnu eraldab alakriips+  * **//​uint16_t ethernet_analyse_packet(uint8_t *buf,uint16_t plen)//** \\ 
-  Funktsioonid on kujul //objekt_tegevus_subjekt//. +    Analyzes if received packet contains info about URL. Will respond to ping if needed
-  Olulisemad kohad programmis on kommenteeritud eesti keeles+    ​Parameters:​ 
-  Iga C-keele plokk (tähistatud loogeliste sulgudega { ja } ) algab ja lõpeb eraldi real+    ​* //*buf// - data array to analyze
-  Plokid on tabuleeritud tabulaatorklahvigaReasiseselt tabulaatorit ei kasutata. +    //plen// - length of received packet in bytes
-===== Alustamine =====+    Tagastab URL-i esimese tähemärgi aadressi. Kui URL on tühi, siis tagastab 0
 +    Returns the address of the first char in URLIf URL is empty, it will return 0.
  
-{{:examples:​install.jpg?580|}}+  * **//​uint16_t ethernet_load_data (uint8_t *buf,​uint16_t pos, const prog_char *progmem_s) 
 +//** \\ 
 +    Loads HTML-code for displaying webpage from controller program memory into TCP send buffer. 
 +    Parameters: 
 +    * //*buf// - data arrya to send using TCP. 
 +    * //pos// - data end address in buffer which must be maintained if data is loaded in queue. The first address is 0. 
 +    * //​*progmem_s//​ - string name that is saved into program memory and from where data is loaded into send array. 
 +    * Retruns end address of data array which can be input as a parameter for loading next HTML-code.
  
-AVR mikrokontrolleri programmeerimiseks on vaja koodi kirjutamise keskkondavastava keele kompilaatorit ja kompileeritud programmi kontrollerisse laadimise tarkvara. Mugavaim on kasutada kõigeks selleks spetsiaalset integreeritud arenduskeskkonda (IDE). AVR mikrokontrollerit on võimalik programmeerida paljudes erinevates programmeerimiskeeltesassembler, C, C++, Pascal, Basic jne. Käesolev raamat on suunatud C-keele kasutamisele mikrokontrolleri programmeerimiselAVR mikrokontrolleri C-keeles programmeerimiseks on olemas tasuta tarkvara nii Linuxi kui ka Windowsi operatsioonisüsteemidele. Järgnevad peatükid tutvustavadki mõlema keskkonna seadistamist.+  * **//void ethernet_print_webpage (uint8_t *buf,uint16_t dlen)//** \\ 
 +    Dislays webpage according to preloaded HTML-code. 
 +    Parameters: 
 +    * //​*buf// ​Data array where HTLM is preloaded. 
 +    * //​dplen// ​End address of data in buffer to be displayed as HTML-code.
  
-Kogu vajaliku installeeritava tarkvara harjutuste läbimiseks leiab Kodulabori veebilehelt. 
-==== Tarkvara Windowsi keskkonnas ==== 
  
-Järgnev juhend kirjeldab AVR arenduskeskkonna installeerimist ja kasutamist Windowsi operatsioonisüsteemis.+<​pagebreak>​
  
-=== Tarkvara paigaldamine ​===+=== Example ​===
  
-Enne paigaldamist tuleks hankida alljärgnev tarkvara, kas tootja või Kodulabori kodulehelt või Kodulabori kohvriga kaasas olevalt plaadilt. 
  
-**1. AVR Studio**+#include  
 +#include  
 +#​include ​
  
-AVR Studio 4 on IDE (inglise keeles //​Integrated Development Environment//), milles toimub tarkvara kirjutamine ja mikrokontrollerisse laadimine. Uusima AVR Studio versiooni leiab selle tootja, Atmeli, kodulehelt.+// Function for compiling webpage 
 +uint16_t ethernet_load_webpage(uint8_t on_off);
  
-**2WinAVR**+// MAC and IP must be unique in network, 
 +// same addresses in two devices are not allowed. 
 +// Random MAC address (usually no need to change it) 
 +static uint8_t mymac[6] = {0x54,​0x55,​0x58,​0x10,​0x00,​0x24};​
  
-WinAVR on GNU-GCC kompilaator AVR mikrokontrolleritele. See on vabavaramille leiab Sourceforge veebilehelt. WinAVR pakub installeerimisel välja kataloogi nimemis sisaldab lisaks nimele versiooni numbritkuid kataloog tuleks käsitsi muuta lihtsalt:+// IP according to LAN (you need to choose the last number) 
 +static uint8_t myip[4] = {192,168,1,100};
  
-  C:\WinAVR+//length of data array 
 +static uint16_t gPlen; ​
  
-**3. Kodulabori teek**+//Data buffer size 
 +#define BUFFER_SIZE 600 
 +static uint8_t buf[BUFFER_SIZE+1];​
  
-Kodulabori teek sisaldab programmi lihtsustavaid funktsioone AVR ja Kodulabori komplekti osade kasutamiseks. Teegi viimase versiooni leiab Kodulabori veebilehelt. Teek tuleb kindlasti installeerida samasse kataloogikus on WinAVR.+//LED PB7 variable 
 +pin debug_led = PIN(B7);
  
-**4.. Virtuaalne COM pordi ajur** 
  
-Ajur võimaldab arvutiga ühendada JTAG ICE programmaatori. Ajur tuleb installeerida enne programmaatori ühendamist arvutiga. Paigaldusprogrammi nimi on "CDM x.xx.xx.exe",​ kus "​x"​ tähistab versiooni. Seejärel tuleb ühendada programmaator arvutiga USB liidese kaudu ja lasta Windows-il teostada automaatne paigaldus. Olekuribal peaks nägema umbes sellist teadet.+int main(void) 
 +
 +  
 + uint16_t pktlen; 
 + char *str;  ​
  
-{{  :​examples:​install:​windows:​new_hardware_popup.png?​349 ​ |Uue pordi leidmise teade}}+ // LED PB7 is output 
 + pin_setup_output(debug_led);​ 
 +  
 + // Etherneti initialization with given addresses 
 + ethernet_init(mymac,​ myip);  
 +         
 +        while(1) 
 + { 
 + // Receive packets until it receives addressed to him with data 
 +    pktlen=ethernet_get_packet(BUFFER_SIZE,​ buf);
  
-Sõltuvalt sellest, kui palju virtuaalseid jadaporte on arvutisse eelnevalt paigaldatud ja kasutusele võetud, paigaldab Windows automaatselt järgmise järjekorranumbriga virtuaalpordi. Uus järjekorranumber genereeritakse ka USB pordi vahetamisel. AVR Studio mõned versioonid tunnevad JTAG ICE programmaatori ära ainult jadaportides COM1...COM9 ja silumise funktsiooni lubavad kasutada ainult jadaportides COM1...COM4. Kasutajal on võimalus pordi järjekorranumbrit muuta, kasutades ​//Device manager// töövahendit. [[et:​examples:​setup:​portissue|Vaata protseduuri veebilehelt]].+        ​// Performs packet preconditioning and answer to "​ping"​ packet.  
 +        ​// Returns packet URL. 
 +        gPlen=ethernet_analyse_packet(buf,​pktlen);​
  
-=== Projekti loomine ​===+ // If URL contains info, start analyzing it 
 +        if (gPlen!=0) 
 + {                
 +            // Load URL address part into "​str"​.  
 +            // The first 4 digits are IP address numbers. 
 +            str (char *)&​(buf[gPlen+4]);​ 
 +  
 + // Find string "/​1"​ from URL               
 + if (strncmp("/​1",​str,​2)==0) 
 +
 +                         // Load webpage 
 + gPlen ​ethernet_load_webpage(0);​
  
-AVR programmi kirjutamiseks tuleb luua uus projekt, mis tüüpiliselt sisaldab endas palju erinevaid faile: programmikoodi(e), päisefailekompileeritud programmi jne. Selleks et projektid oleks korrektselt eristatavadtuleks iga projekti jaoks luua uus kataloog ​(seda võimalust pakub uue projekti loomise abimees).+ // LED on 
 + pin_clear(debug_led);  
 +              
 +                  } 
 + // At nextfind string "/​0"​ from URL 
 + else if (strncmp("/​0"​,str,2)==0) 
 +
 +                         // Load webpage 
 + gPlen = ethernet_load_webpage(1);
  
-Uue projekti loomiseks tuleb läbida järgmised sammud:+ // LED on 
 + pin_set(debug_led);​ 
 +             
 +                  } 
 + // In other cases load webpage according to LED condition 
 +                 else  
 + {             
 +                    ​gPlen=ethernet_load_webpage(pin_get_value(debug_led));​ 
 +                 }                                     
 +  
 + // Display preloaded webpage ​                
 +                        ethernet_print_webpage (buf,​gPlen); ​                
 +
 +    } 
 +    return (0); 
 +}
  
-**1.** Avada AVR Studio ja vajutada nupule uus projekt (//New Project//). Juhul kui vastav aken automaatselt ei avane, valida menüüst //Project - New project//. Pärast sobivat sisestust vajutada nupule //Next//. 
  
-{{  :​examples:​install:​windows:​studio_welcome.png?​400 ​ |}}+// Webpage will be loaded by writing data into TCP send buffer 
 +uint16_t ethernet_load_webpage(uint8_t on_off) 
 +{ 
 +    uint16_t plen=0; ​
  
-**2.** Avaneb aken, kus tuleb märkida kompilaatori ja failide algseaded. Kompilaatoriks valida AVR GCC ja paremas akna osas sisestada projekti nimi ning algkoodi faili nimi. Algkoodi faili nimi peaks kindlasti lõppema laiendiga "​.c"​. Aknas on võimalik veel märkida va