Autor: Hussein

1. Mis on robot? Maailma esimene robot.

robot on mis tahes automaatselt töötav masin, mis asendab inimtööjõudu

2. Robotite arendamis põlvkonnad. Nimeta ja seleta:

Esimene põlvkond. Esimese põlvkonna robotid olid lihtsa ehitusega ning neil puudus
ümbrusetaju ehk andurid. Oma tööd suutsid nad teha vaid mittemuutuvates tingimustes.
Näiteks robotkäsi, mis tõstab õlletehases pudeleid kastidesse. Robot sooritab identseid
liigutusi, aga kuna tal ei ole ümbritsevast keskkonnast mitte mingit signaali, st ta ei saa oma
tegevuse kohta mittemingisugust tagasisidet, siis keskonna muutuse korral ta enam ei tööta
korralikult. Selliseid roboteid tänapäeval enam ei loetagi õigeteks robotiteks.

• Teine põlvkond. Teise põlvkonda kuuluvad robotid (vt joonis 2), mis suudavad andurite läbi
  reageerida keskkonnas toimuvatele muutustele. Kuna robot suudab keskkonda tunnetada, siis
  roboti efektiivsus oleneb suures osas tarkvarast, mis teda juhib. Ka antud kursuse käigus
  kasutatavad robotid kuuluvad kõik teise põlvkonda, kui kasutada neil andureid keskkonna
  tunnetamiseks ning programmeerida nad iseseisvalt tegutsema.
• Kolmas põlvkond. Kolmas põlvkond on veel väljatöötamisel. Kolmanda põlvkonna robotid
  suudavad olukordi analüüsida ning õppida. Näiteks filmis „Mina, Robot” olev robot, mis suudab
  järeldusi teha ning sellest õppida, on kolmandast põlvkonnast.

Liigita järgnevad robotid põlvkondade kaupa:

• nõudepesumasin – pole roboot
• fikseeritud liikumisega – esimene
• robotkäsi – teine
• automaatselt süttiv lamp – kolmas
• ise keeli õppiv robot – viies

3. Miks manipulaatorid ei ole robotid? – Neil on staatiline baas ja seetõttu tegutsevad nad piiratud tööruumis.
4. Mis on masinate eelised võrreldes inimtööjõuga? – Robotid ei väsi
5. Millised kolm tingimust peavad olema täidetud, et teatud masinat või seadet saaks robotiks nimetada? – tajub oma keskkonda, teeb arvutusi otsuste tegemiseks ja sooritab tegevusi reaalses maailmas.
6. Millistes Eesti tööstusettevõtetes võiksid mehhatroonikud töötada? – 10 lines

booooo

• Robot – Robot on mehaaniline intelligentne seade, mis on võimeline iseseisvalt või välise abiga (inimese poolt) ülesandeid lahendama. Praktikas on robot tavaliselt elektromehhaaniline masin, mida juhib arvuti.
• Robootika – Robootika on tehnikateaduse ja tehnoloogia valdkond, mis tegeleb robotite ehitamiseks vajaliku rakendusteaduse ja tehnoloogia arendamisega: disain, konstrueerimine, algoritmide väljatöötamine, robotite valmistamine ja rakenduste leidmine. Robootika on tihedalt seotud valdkondadega nagu elektroonika, tehnikateadused, mehaanika, mehhatroonika ja tarkvara arendus.
• Manipulaator – Manipulaator on seade või masin, mida inimene juhib. Erinevalt väärarusaamadest pole manipulaatorid robotid, kuna neid juhib vahetult inimene. Manipulaatorid pole võimelised autonoomselt töötama.
• Mehhatroonika – Mehhatroonika on mitmekesine tehnikateaduste haru, mis ühendab endas mehaanika, elektroonika, arvutitehnika, tarkvaratehnika, juhtimisteooria ja süsteemidisaini, eesmärgiga jõuda välja parema toote loomiseni.
• Andur -Andur on seade, mis mõõdab mingit suurust ning teisendab selle elektriliseks signaaliks.
• Täitur – Täitur on automaatjuhtimissüsteemi osa, mis regulaatorist saadava signaali järgi mõjutab juhitavat protsessi.
• Kontroller – Kontrollerit võib tinglikult võrrelda ka väikese arvutiga, kus kõik funktsioonid (protsessor, mälu, sisend-väljund muundurid jms) on paigutatud ühele kiibile, ning seetõttu nimetatakse seda tihti ka mikrokontrolleriks.

Parts

1. USB pistik (USB – Universal Serial Bus) USB pistiku abil saab Arduino arendusplaadile voolu anda ja programmikoodi laadida. Arduino kasutab USB B tüüpi pistikut.
2. Voolupesa Voolupessa saab ühendada voolujuhtme, millega Arduinole voolu anda.
3. GND (ground, maandus) pesad Nende pesade kaudu käib vooluringi maandamine.
4. 5V pesa 5V pesa kaudu saab arendusplaadi külge ühendatavaid lisakomponente varustada 5-voldise vooluga. 3,3V pesa 3,3V pesa kaudu saab arendusplaadi külge ühendatavaid lisakomponente varustada 3,3-voldise vooluga.
5. Analoogpesad (A0–A5) Loetakse signaale analoogsensoritest ja teisendatakse need digitaalkujule. Analoogpesasid saab vajadusel kasutada ka signaali väljastamiseks.
6. Digitaalsed pesad (D0–D13) Nende abil saab lugeda ja väljastada digitaalsignaali.
7. Pulsilaiusmodulatsiooni (PWM) pesad Võimaldavad simuleerida analoogväljundit.
8. AREF pesa Kasulik juhul, kui on vaja lugeda analoogsisendit kindla võrdluspinge suhtes.
9. Lähtestamise nupp (Reset button) Taaskäivitab Arduino plaadile laaditud programmi. Kasulik testimisel ja koodi korduvaks käivitamiseks.
10. Toite LED tuli Läheb põlema, kui Arduino saab toidet. Kui LED ei sütti, võib plaat olla vigane.
11. TX ja RX LED tuled TX LED põleb andmete saatmisel, RX LED põleb andmete vastuvõtmisel.
12. ATmega328P mikrokontroller Juhtib Arduino Uno arendusplaadi tööd.
13. Pingeregulaator Reguleerib plaadile sisenevat pinget ja muudab selle sobivaks, kui sisendpinge on liiga suur.

Tanslation:

• Elekter/Электричество
• Elektriahi/Электрическая цепь
• Рисованная и принципиальная схема(примеры)
• Закон Ома
• Параллельное и последовательное соединение(опиши основные принципы)
• Микроконтроллер(примеры, картинки). Подробно разобрать составляющие платы Arduino Uno.
• Põhikomponeendid Arduino:

1. Valgusdiood (LED)/светодиод,
2. Nupp/кнопка,
3. Piesosummer/пищалка,
4. Fototakisti/фоторезистор,
5. Takisti/резистор,
6. Potentsiomeeter/потенцтометр,
7. Temperatuuriandur/термодатчик,
8. Servomootor/серводвигатель,
9. Mootor/моторчик,
10. Vedelkristallekraan/LCD экран

Быстрая сборка схем

Для надёжной сборки устройств создаются индивидуальные печатные платы. Если делать их самостоятельно, это займёт много времени и заставит повозиться с химикатами и паяльником. Индивидуальные платы с промышленным монтажом на заказ крайне дороги при малом тираже.Для быстрой сборки электрических схем без пайки и без проблем существует макетная плата. Её же называют макетной доской, макеткой или breadboard’ом.

Принцип работы

Под слоем пластика скрываются медные пластины-рельсы, выложенные по незамысловатому принципу:

Пример использования

Одну и ту же схему на макетной доске можно собрать множеством способов. Пример одной из конфигураций разберём для такой схемы:

На что стоит обратить внимание:ƒ

• Цвета проводов, конечно же, значения не имеют. Однако хорошим тоном являетсяиспользование красных проводов для линии питания и чёрных или синих для линии землиƒ
• Мы подключили источник питания к длинным боковым рельсам. Это позволяет не тянуть кнему самому большое количество проводов с разных участков схемы, а задача по его заменеили перемещению сильно упрощаетсяƒ
• Положение всей схемы на макетной доске не так важно. Важно взаимноеположение компонентов друг относительно другаƒ
• Схема по горизонтали побита на отдельные участки, которые легко воспринимать и изменятьпо отдельности

Конденсатор

Конденсатор — крошечный аккумулятор, который очень быстро заряжается и очень быстро разряжается.

Основные характеристики:

Кодирование номинала

Номинал в пФ записан на корпусе. Первые 2 цифры — основание, 3-я — множитель.

Например:

• 220 = 22 × 100 пФ = 22 пФƒ
• 471 = 47 × 101 пФ = 470 пФƒ
• 103 = 10 × 103 пФ = 10 000 пФ = 10 нФƒ
• 104 = 10 × 104 пФ = 100 000 пФ = 100 нФ

Автоматическое управление

Замыкать и размыкать цепь, измерять напряжение также можно, не вручную, а автоматически, по заданному алгоритму при помощи запрограммированного микроконтроллера.

Существуют «сырые» микроконтроллеры, выполненные в виде одной микросхемы. Они дёшевы при массовом производстве, но их программирование и правильное подключение — нетривиальная задача для новичка.

Чтобы решить эту проблему, существуют готовые платы или, как ещё говорят, вычислительные платформы. Они делают процесс взаимодействия с микроконтроллером очень простым. Типичным представителем этого семейства являются платы Arduino.

Robootikasüsteemid

Selles peatükis uurime robootika- ja mehhatroonikasüsteemi, selle komponente ning ülesehitust. Lisaks vaatame kontrolleri funktsionaalsust ja lihtsat digitaalsignaali.

Mehhatroonikasüsteem

Mehhatroonikasüsteem koosneb üldjuhul anduritest, täituritest ja neid juhtivast tarkvarast. Selliseid süsteeme nimetatakse ka tarkadeks seadmeteks, kuna sõltuvalt juhtimise keerukusest võivad seadmed teha keerukaid operatsioone, kohanduda keskkonnaga ja suhelda ümbritsevaga. Mehhatroonika üheks levinuimaks rakendusalaks on robootika. Robootikaga seostub igaühele mingi tark masin või humanoid (inimesesarnane robot), paljudele tööstusinimestele aga manipulaator, keevitus- või värvimisrobot, jne. Siit nähtub, et inimestel on robootikast tegelikult väga erinev arusaam ja robotiteks võib nimetada väga erinevaid seadmeid, erineva keerukuse ja võimekusega, kuni nad vastavad eelmises peatükis kirjeldatud nõuetele (andur-kontroller-täitur). Joonisel 1 on näidatud tinglik mehhatroonikasüsteem ja nooltega on näidatud süsteemi osade ja väliskeskkonna omavaheline infovahetus ja selle suund.

Joonis 1. Mehhatroonikasüsteem. Andurid saavad väliskeskkonnast informatsiooni, mida kontroller kasutab otsuste vastu võtmiseks ning väljendab seda läbi täiturite (näiteks liikumine).

Andurid hangivad erinevat tüüpi informatsiooni seadet ümbritsevast keskkonnast (näiteks temperatuur, teiste objektide kaugus, raadiosignaalid) või ka seadmest endast (näiteks liikumiskiirus, kiirendus, mootori pöörlemiskiirus) ning edastavad selle juhtimismoodulile. Juhtimismooduliks on tavaliselt kontroller, kus täidetakse mingit algoritmi ehk programmi. Vastavalt programmile ja anduritelt saadud informatioonile juhib kontroller täiturmehhanisme, milleks tihtilugu on elektrimootorid. Täituriteks võivad olla ka solenoidid, tehislihased, pneumosilindrid jms. Üldjuhul tekitavad täiturmehhanismid mingi liikumise, mõjutades seega väliskeskkonda. Näiteks võib tuua lihtsustatud auto turvasüsteemi ja avariisituatsiooni (joonis 2)

Joonis 2. Auto turvapadi ja süsteemi skemaatiline mudel

Turvapadja süsteem on tüüpiline mehhatroonikasüsteem. See koosneb kolmest olulisest osast: andur, kontroller ja täitur. Kiirendusandur registreerib järsu kiirenduse muutuse ja edastab vastava signaali kontrollerile. Kontrolleri algoritm katkestab kõik muud auto juhttegevused ja saadab püropadrunile, mis on ühendatud auto turvapadjaga, käivitussignaali. Püropadrun vallandab turvapadja, täites selle kiirelt gaasiga ja kaitstes nii autojuhti löögi eest vastu rooli. Ongi andurkontroller-täitur ahel läbitud ja võime öelda, et tegemist on mehhatroonikaseadmega

Mikrokontroller

Mehhatroonikasüsteemi üks olulisem komponent on mikrokontroller ehk lühidalt kontroller, kus toimub info töötlemine ja käskude väljastamine täituritele. Kontrollerit võib tinglikult võrrelda ka väikese arvutiga, kus kõik funktsioonid (protsessor, mälu, sisend-väljund muundurid jms) on paigutatud ühele kiibile, ning seetõttu nimetatakse seda tihti ka mikrokontrolleriks. Loomulikult ei ole sellisel juhul arvutusvõimsus võrreldav koduarvutiga, aga on täiesti piisav robootikasüsteemide juhtimiseks. Mikrokontroller on väliselt sarnane tavalisele loogikalülitusele, kuid oluliseks erinevuseks on, et tema väljundviike saab tarkvaraliselt programmeerida nii, et nad toimivad vastavalt soovile ja kontrolleri võimalustele. See tähendab, et üks ja sama füüsiline viik võib olla sõltuvalt programmist sisendiks (info või signaal liigub kontrolleri suunas) või väljundiks (kontroller saadab signaali või infot). Sisendiga võib ühendada näiteks erinevaid andureid ja väljunditega erinevaid täitureid. Signaalid on lihtsamal juhul loogilised digitaalsignaalid (0 või 1), kus 0 tähendab elektriliselt pinge puudumist ja 1 üldjuhul toitepinget (näiteks 5V). Erinevate mikrokontrollerite kuju ja digitaalsignaali graafiline esitus on toodud joonisel 3.

Joonis 3. Mikrokontrollerid erinevates korpustes (vasakul) ja lihtne digitaalsignaal: loogiline 0 ja loogiline 1 (paremal)

Kontrollerite üheks eripäraks on nende väga lai valik. On lihtsaid ja odavaid, mis sobivad lihtsamate protsesside juhtimiseks, ning on keerukaid ja võimsaid paljude sisend-väljund viikudega kontrollereid. Lisaks on kontrollerid jaotatud funktsionaalsuse ja rakendusvaldkonna järgi. Näiteks autotööstuses kasutatavatele kontrolleritele esitatakse erinevad nõudmised kui kodumasinates olevatele kontrolleritele.

Mehhatroonikasüsteemide ja robotite juhtimiseks on oluline tunda mikrokontrollerite võimalusi ja osata konkreetsele kontrollerile programmi koostada. Peatüki II tase tutvustabki kontrollerite põhilisi võimalusi ja funktsioone.

Kordamisküsimused:

1. Mis on mehhatroonikasüsteemi peamised osad?

andurid, täiturid, kontrollerid ja mehaanilised komponendid.

2. Mis on kontrolleri funktsioon mehhatroonikasüsteemis?

töötleb kasutaja käske ja tajutud signaale, et genereerida käsusignaalid, mis saadetakse süsteemi ajamile.

3. Milliste seadmete abil saab robot informatsiooni?

infrapuna- (IR) andurid, ultraheliandurid ja mahtuvusandurid.

4. Tooge kaks näidet (kontrolleriga ühendatavat seadet), kus mikrokontrolleri füüsiline viik peaksolema seadistatud a) väljundiks ja b) sisendiks.

Auto turvapadi ja süsteemi skemaatiline mudel ja Mikrokontrollerid erinevates korpustes (vasakul) ja lihtne digitaalsignaal: loogiline 0 ja loogiline 1 (paremal)

Mikrokontroller

Selles peatükis uurime mikrokontrolleri lihtsustatud arhitektuuri ja loetleme peamisi mikrokontrolleri funktsioone. Lisaks vaatame mikrokontrolleriga seotavaid erinevaid sisend/väljund seadmeid.

Mikrokontroller

Mikrokontrollerit võib võrrelda pisikese arvutiga, mis lisaks oma põhifunktsioonile: instruktsioonide täitmisele, omab ka küllalt laia kiipi integreeritud perifeeriaseadmete ja liideste hulka. Liidesed võimaldavad mingil kokkulepitud standardil toimivat andmevahetust. Mikrokontrolleri põhiosaks on keskprotsessor, mille ülesandeks on sarnaselt tavalise personaalarvuti protsessorile täita programmi käske. Erinevalt tavalisest arvutist on mikrokontrolleris samasse kiipi lisatud veel töömälu (RAM), andmemälu (EEPROM) ja programmimälu (Flash), katkestuste kontroller ja mitmed liidesed, millest tuleb allpool täpsemalt juttu. Mikrokontrolleri skeemi on võimalik näha joonisel 1. Kõik kasutatud lühendid on järgnevas tekstis selgitatud.

Joonis 1. Mikrokontrolleri lihtsustatud arhitektuur

Mälu

Kasutaja seisukohalt on oluline eristada kahte tüüpi mikrokontrolleri mälu. Esimeseks mälutüübiks on programmimälu (Flash), kuhu laetakse mikrokontrolleri kompileeritud tööprogramm, milles sisalduvad kasutaja poolt koostatud instruktsioonid kontrolleri tööks. Selle mälu suurusest sõltub, kui mahukat ja keerulist programmi on konkreetsele mikrokontrollerile võimalik laadida. Väiksematel 8- bitistel mikrokontrolleritel nagu näiteks ATtiny on selle mälu suuruseks 0,5 – 8 kB ja suurematel sama tooteperekonna liikmetel ATmega 4 – 256 kB ning 32-bitistel kontrolleritel kuni 512 Kb. Teiseks mälutüübiks on andmemälu ehk EEPROM, mida saab kasutada sarnaselt arvuti kõvakettaga andmete säilitamiseks ka siis, kui kontrolleri toide välja lülitada. Mälu maht võrreldes tavalise kõvakettaga on väga väike, nt ATmega32 puhul 1024 baiti. Suuremate andmemahtude puhul on aga suhteliselt lihtne ühendada kontrolleriga tavaline välkmälu kaart (SD kaart) ja salvestada andmed sinna.

Registrid

Registriteks nimetatakse mikrokontrolleri mälupesasid, millel on kindel aadress ja nimi. Piltlikult on tegemist nagu lülititega, mida saab programmiliselt sisse ja välja lülitada ning kus igal niinimetatud lülitil on oma otstarve ja tähendus, näiteks muudab viigu suunda, lülitab sisse mingi funktsiooni või väljendab sisendandmeid (vt joonis 2). Kui tegemist on 8-bitise mikrokontrolleriga, siis on enamus registreid ka kaheksakohalised. Piltlikult oleks tegemist kaheksast lülitist koosneva paneeliga.

Joonis 2. Kontrolleri registri ja kujuteldavate lülitite illustratsioon.

juhtprogramme – флагманские программы

keetamine – приготовление

värmine – раскраска

kokkupanek – сборка

kirendata – отправить

ohutumist – безопасность

täpsus – точность

kiirus – Скорость

kallis alustada – дорого начинать

täitur – ispolnitel

Buzzer

Skeem:

Komponendid:

1. Arduino Uno
2. Arendusplaat
3. Piezo Element

Töö protsess:

Buzzer on helisignaalseade, mis võib olla mehaaniline, elektromehaaniline või piesoelektriline (lühendatult pieso). Tüüpiliste sumistite ja piiksude kasutusalad on näiteks häireseadmed, taimerid, rongid ja kasutaja sisendi, näiteks hiirekliki või klahvivajutuse kinnitamine.

DHT11 ja DHT22

Skeem:

Komponendid:

1. Arduino Uno
2. Arendusplaat
3. DHT11
4. DHT22
5. 2 x 10 kΩ takisti

Mida need teevad:

DHT11 – on lihtne ja väga odav digitaalne temperatuuri ja niiskuse andur. See kasutab ümbritseva õhu mõõtmiseks mahtuvuslikku niiskusandurit ja termistorit ning väljastab digitaalsignaali andmesidekontaktis (analoogsisendipinke ei ole vaja). Selle kasutamine on üsna lihtne, kuid nõuab andmete kogumiseks hoolikat ajastamist.

DHT22 – on lihtne ja odav digitaalne temperatuuri ja niiskuse andur. See kasutab ümbritseva õhu mõõtmiseks mahtuvuslikku niiskusandurit ja termistorit ning väljastab digitaalsignaali andmesideklemmile (analoogsisendiklemmid ei ole vajalikud).

KATSE 6:

Töö kirjeldus:

See on mini alarm, mis mõõdab temperatuuri ja valgust.

Kasutatud komponendid:

1. Arduino Uno
2. Arendusplaat
3. TMP36
4. Potentsiomeeter
5. 10 kΩ takisti
6. 220 Ω takisti
7. Piezo
8. Fotoresistor
9. LCD Ekraan

Töö protsess:

Komponendid (fotoresistor ja temperatuuriandur) on resnosniable mesuring väärtused konkreetsete käskude kutsuda. Nii meie projekti jaoks saab midagi vähemalt teha.
Meie näites on sumisti. Siis väärtused või üks väärtused on liiga kõrge summeri mängib välja hädaolukorras. Vahepeal on naljakas laul mängib

Skeem:

Kood:

#include <LiquidCrystal.h>

const int potPin        = A3;
const int tempPin       = A4;
const int ldrPin        = A5;
const int lcdRs         = 11;
const int lcdEn         = 12;
const int lcdD4         = 4;
const int lcdD5         = 5;
const int lcdD6         = 6;
const int lcdD7         = 7;
const int musicPin      = 3;
const int alarmPin      = 3;

const int   switchThreshold = 512;   // pot > mid → system ON
const float tempThreshold   = 23.0;  // °C
const int   lightThreshold  = 200;   // ADC units

const int songLength = 18;
char notes[songLength + 1] = "cdfda ag cdfdg gf ";
int beats[songLength] = {
  1,1,1,1,1,1,4,4,2,1,1,1,1,1,1,4,4,2
};
int tempo = 150;  // madalam → kiirem

LiquidCrystal lcd(lcdRs, lcdEn, lcdD4, lcdD5, lcdD6, lcdD7);

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(musicPin, OUTPUT);
  pinMode(alarmPin, OUTPUT);
}

void loop() {
  // Lüliti/potentsiomeetri lugemine
  int controlVal = analogRead(potPin);
  bool systemOn = controlVal > switchThreshold;

  if (!systemOn) {
    // Süsteem OFF
    noTone(musicPin);
    noTone(alarmPin);
    lcd.clear();
    delay(500);
    return;
  }

  // TMP36 teisendus: V = raw*(5.0/1023); Temp = (V - 0.5)*100
  int   rawTemp = analogRead(tempPin);
  float voltage = rawTemp * (5.0 / 1023.0);
  float tempC   = (voltage - 0.5) * 100.0;

  // Fototakisti lugemine
  int lightVal = analogRead(ldrPin);

  Serial.print(tempC, 1);
  Serial.print(", ");
  Serial.println(lightVal);
  
  if (lightVal < lightThreshold) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Tuvastatud       ");
    lcd.setCursor(0, 1);
    lcd.print("pimedus          ");
  } 
  else if (tempC > tempThreshold) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Temp liiga       ");
    lcd.setCursor(0, 1);
    lcd.print("korge!           ");
  } 
  else {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Temp: ");
    lcd.print(tempC, 1);
    lcd.print((char)223);
    lcd.print("C");
    lcd.setCursor(0, 1);
    lcd.print("Light: ");
    lcd.print(lightVal);
  }

  // Alarmitingimus
  if (tempC > tempThreshold || lightVal > lightThreshold) {
    noTone(musicPin);
    tone(alarmPin, 1000); // alarm heli
  } else {
    noTone(alarmPin);
    tone(musicPin, 440);  // taustatoon
  }
 
  if (lightVal < lightThreshold) {
    noTone(musicPin);
    noTone(alarmPin);
  } else if (tempC > tempThreshold) {
    noTone(musicPin);
    playAlarmMelody();
  } else {
    noTone(alarmPin);
    playMelody();
  }
  delay(500);
}

void playMelody() {
  for (int i = 0; i < songLength; i++) {
    int duration = beats[i] * tempo;
    if (notes[i] == ' ') {
      delay(duration);
    } else {
      tone(musicPin, frequency(notes[i]), duration);
      delay(duration);
    }
    delay(tempo / 10);
  }
}

// Play alarm melody: 3 quick beeps
void playAlarmMelody() {
  for (int i = 0; i < 3; i++) {
    tone(alarmPin, 1000, 200);
    delay(250);
  }
}

// Map note character to frequency
int frequency(char note) {
  const char names[] = {'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C'};
  const int freqs[] = {262, 294, 330, 349, 392, 440, 494, 523};
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      return freqs[i];
    }
  }
  return 0;
}

Video:

Uued funktsioonid:

int frequency(char note) – Teisendab noodi tähe (nt ‘c’) helisageduseks (nt 262 Hz).

tone() – Mängib heli kindlal viigul, sagedusel ja (valikuliselt) kestusel.

noTone() – Peatab heli mängimise viigul.

LCD Ekraan

skeem:

Komponendid:

1. Arduino Uno
2. LCD Ekraan
3. Fotoristor
4. Arendusplaat
5. 220Ω takisti
6. Juhtmed

Mida skeem teeb?:

see on lihtne animatsioon 10-sekundilises tsüklis. See toimib nii, et konkreetsed pikslid lülitatakse sisse või välja. Kokkuvõttes: on võimalus näidata LED-ekraanil mida iganes soovite.

KATSE 5:

Töö kirjeldus:

see on temperatuuriandur aia jaoks, see annab välja uudiseid temperatursist

Asutatud komponendid:

1. Arduino Uno
2. TMP36 temperatuuriandur
3. Fototakisti
4. 10 kΩ takisti
5. 2 x 220 Ω takisti
6. 16×2 LCD-ekraan
7. Ühenduskaablid
8. Arendusplaat
9. :3

Töö protsess:

see on LCD-ekraan, mis näitab iga 2 sekundi järel temperatuuri ja valguse olekut. See töötab nii, et sellel on nimekiri piltidest, mida näidatakse koos konkreetse väärtusega. Sellel on temperatuuri sensor ja fotoresistor. Nende abil annab LCD-ekraan teavet. Täpsemalt öeldes: Ekraan on kahes reas – tekst koos ikooniga ülemises reas, temperatuur ja kellaaeg alumises reas – ning iga viienda läbimise järel asendub tavaline vaade reklaamiaknaga.
Töö on tehtud koos minu sõbra Maksimiga.

Skeem:

Kood:

#include <LiquidCrystal.h>

LiquidCrystal lcd(2, 3, 5, 6, 7, 8);
const int TEMP_PIN = A0, LDR_PIN = A1;
bool toggleVariant = false;
int lastIdx        = -1;  // eelmise sõnumi indeks

// Eemalda 'const' – nüüd on õige tüüp uint8_t*
byte icons[5][8] = {
  {0b00100,0b10101,0b01110,0b11111,0b01110,0b10101,0b00100,0b00000},
  {0,0b00110,0b01111,0b11111,0b11111,0b00000,0,0},
  {0b00110,0b01111,0b11111,0b00100,0b01010,0b10001,0,0},
  {0b01110,0b10101,0b11011,0b00100,0b11011,0b10101,0b01110,0},
  {0,0b01010,0b11111,0b11111,0b01110,0b00100,0,0}
};

const char* msgs[5] = {
  "Selge taevas",
  "Pilvine ilm",
  "Vihm varitseb",
  "Lumi langeb",
  "Armasta ilma"
};

const char* alts[5] = {
  "Taevas puhas",
  "Pilv katmas",
  "Tibutab vett",
  "Karge lumi",
  "Naudi ilma"
};

float readTemp() {
  float v = analogRead(TEMP_PIN) * (5.0 / 1023.0);
  return (v - 0.5) * 100.0;
}

int readLdr() {
  return analogRead(LDR_PIN);
}
int frameCount = 0;
void setup() {
  lcd.begin(16, 2);
  for (int i = 0; i < 5; i++) {
    lcd.createChar(i, icons[i]);
  }
  lcd.setCursor(0, 0);
  lcd.print("IlmaNurk");
  delay(2000);
  lcd.clear();
  Serial.begin(9600);
}

void loop() {
  frameCount++;
  // Iga 5. iteratsiooni järel näita reklaami
  if (frameCount >= 5) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("IlmaNurk soovitab");
    lcd.setCursor(0, 1);
    lcd.print("Joo teed! :)");
    delay(3000);
    frameCount = 0;
    return;
  }
  float t = readTemp();
  int l = readLdr();
  int idx = (l > 800) ? 4 : (t > 25) ? 0 : (t < 0) ? 3 : (l < 300) ? 2 : 1;
  
  if (idx != lastIdx) {
    lastIdx = idx;
    toggleVariant = false;
  }

  // vali kas peamine või variant
  const char* txt = toggleVariant ? alts[idx] : msgs[idx];
  toggleVariant = !toggleVariant;
  
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(txt);
  lcd.setCursor(15, 0);
  lcd.write(idx);

  lcd.setCursor(0, 1);
  lcd.print("T:");
  lcd.print(t, 1);
  lcd.print("C S:");
  lcd.print(millis() / 1000);
  
  Serial.print("Temp: ");
  Serial.print(t, 1);
  Serial.print(" C, Light: ");
  Serial.print(analogRead(LDR_PIN));
  Serial.print(", Index: ");
  Serial.println(idx);
  delay(2000);
}

Video:

Uued funktsioonid:

LiquidCrystal lcd() – konstrueerib objekti, mille kaudu juhitakse LCD-ekraani.
lcd.begin(cols, rows) – initsialiseerib ekraani mõõtude (cols × rows) jaoks.
lcd.setCursor(x, y) – seab kursori veeru x ja rea y positsiooni.
lcd.print(tekst) – kuvab ekraanil mustri kursoripositsioonist alates (C-string või arv).
const char* – tüübimääre, mis osutab muutumatule C-stringile (tekstile).
byte icons[5][8] = {} – defineerib massiivi, kuhu salvestatakse 5 kohandatud 8-baiti pikkust ikooni.
lcd.write(indeks) – kuvab ekraanil kohandatud sümbolit salvestatud indeksiga.
lcd.clear() – tühjendab kogu ekraani sisu ja liigub kursoriga algusse.

Näidis 1:

see on temperatuurianduri test. Siin pildil on näide, kuidas ühendada juhtmed temperatuurianduriga.
See on saanud võimaluse näidata, milline on temperatuur.

kood:

const int temperaturePin = 0;

void setup()
{
Serial.begin(9600);
}

void loop()
{

float voltage, degreesC, degreesF;
// kasutame analogRead(), mis tagastab sisendi väärtused vahemikul 0 ... 1023.
// koostasime getVoltage() funktsioon, mis tagastab pingeväärtus  0 ... 5,

voltage = getVoltage(temperaturePin);
degreesC = (voltage - 0.5) * 100.0;
// degreesC = voltage * 100.0;
degreesF = degreesC * (9.0/5.0) + 32.0;
Serial.print("voltage: ");
Serial.print(voltage);
Serial.print(" deg C: ");
Serial.print(degreesC);
Serial.print(" deg F: ");
Serial.println(degreesF);


//Ekraanil ilmub järgmine tekst: "voltage: 0.73 deg C: 22.75 deg F: 72.96"
delay(1000); // ootame 1 sek
}

float getVoltage(int pin)
{
return (analogRead(pin) * 0.004882814);
// teisendame pinge vahemikust 0,0 ... 5,0 V, vahemikku 0 до 1023.
}

Näidis 2:

Selles osas on servomootor. Servomootor on pöörlev või lineaarne ajam, mis võimaldab mehaanilises süsteemis nurk- või lineaarpositsiooni, kiiruse ja kiirenduse täpset juhtimist. See moodustab servomehhanismi osa ja koosneb sobivast mootorist, mis on ühendatud asendi tagasiside anduriga ja kontrolleriga. temperatuur

kood:

#include  <Servo.h> // nii teavitame Arduino IDE-t vajadusest kasutada Servo.h teeki (подключаем дополнительную библиотеку)
// Как только вы "подключаете" библиотеку, так сразу получаете доступ к этим функциям. Вы можете найти список функций в библиотеке
// сервопривода в: http://arduino.cc/en/Reference/Servo. Большинство библиотек доступно из меню "Файл / примеры".

Servo servo1; // Peame looma servo objekti nimega servo1 (объект управления сервоприводом)

void setup()
{
// Сейчас мы прикрепим (attach) объект servo1 к цифровому пину 9. Если вы собираетесь управлять более чем одним
// сервоприводом, Вы должны прикрепить каждый новый объект серво к своему, отдельному порту, причем это порт должен быть цифровым.
servo1.attach(9); //ütleme Arduinole, et infosuhtlus servo-objektiga servo käib läbi klemmi number 9. Tegu on digitaal-klemmiga--PWM digitaalne osa! Kontrollime, kas skeemil kasutame sama klemmi.
}
void loop()
{
int position;

servo1.write(90); //pööramise nurk =90
delay(1000); 
servo1.write(180); //pööramise nurk =180
delay(1000);
servo1.write(0); //pööramise nurk =0
delay(1000);

// servo positsiooni muutmine väike kiirusega pärisuunas:
for(position = 0; position < 180; position += 2)
{
servo1.write(position); // positsiooni muutmine
delay(20); 
}

// servo positsiooni muutmine väike kiirusega vastupäeva:
for(position = 180; position >= 0; position -= 1)
{ 
servo1.write(position); // positsiooni muutmine
delay(20); 
}
}

KATSE 4:

Töö kirjeldus:

Öövalgustuse loomine: lülitub sisse, kui on pime, lülitub välja, kui on valgus

Kasutatud komponendid:

Arduino Uno R3,

Positional Micro Servo,

White LED 3 tükki,

220 Ω Resistor 3 tükki,

Photoresistor,

10 kΩ Resistor

Töö protsess:

mulle ja mu sõbrale Maksimile tehti ülesandeks teha „nutikas aed“ (ma ei osanud seda lihtsamalt nimetada). Seal on süsteem, mis avab akna, kui ruumis on liiga kuum (me lihtsalt panime käe soojusandurile) ja kui on liiga pime, siis töötavad tuled.

Skeem:

Kood:

#include <Servo.h>

const int tempPin = A0;       // Temperatuuriandur (LM35, TMP36 jne)
const int ldrPin = A1;        // Fototakisti (LDR)
const int ledPin = 10;         // LEDi digitaalne väljund
const int servoPin = 9;       // Servo mootor SG90

Servo servo;
int currentAngle = 0;

void setup() {
  servo.attach(servoPin);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  // --- Temperatuuri lugemine ja teisendamine kraadideks ---
  int tempValue = analogRead(tempPin);
  float voltage = tempValue * (5.0 / 1023.0);
  float temperature = (voltage - 0.5) * 100.0; // TMP36 puhul

  // --- Servonurga määramine temperatuuri põhjal ---
  int targetAngle;
  if (temperature <= 25) {
    targetAngle = 0;
  } else {
    targetAngle = 180;
  }

  // --- Servo liigutamine sujuvalt ---
  if (currentAngle < targetAngle) {
    currentAngle += 3; // bigger step
    if (currentAngle > targetAngle) currentAngle = targetAngle;
  } else if (currentAngle > targetAngle) {
    currentAngle -= 3;
    if (currentAngle < targetAngle) currentAngle = targetAngle;
  }
  servo.write(currentAngle);
  delay(20); // sujuv liikumine

  // --- Valgustaseme lugemine ja LEDi juhtimine ---
  int lightLevel = analogRead(ldrPin);
  if (lightLevel > 500) {
    digitalWrite(ledPin, HIGH); // LED süttib, kui on pime
  } else {
    digitalWrite(ledPin, LOW);  // LED kustub, kui valgust piisavalt
  }

  // --- Andmete näitamine Serial Monitoris ---
  Serial.print("Temp: ");
  Serial.print(temperature);
  Serial.print(" C, Light: ");
  Serial.print(lightLevel);
  Serial.print(", Servo angle: ");
  Serial.println(currentAngle);
}

Video:

Uued funktsioonid:

Servo servo – Loob servo objekti.
servo.attach(pin) – Seob servomootori määratud piniga
#include <Servo.h> – Lisab servo raamatukogu.
servo.write(angle); – Liigutab servo määratud nurka (0–180°).
float – koma numbrid

Ülesanne nuppudega

skeem:

kirjeldus:

Meil on kaks nuppu, millest üks vastutab lambi sisselülitamise eest ja teine on vastutav selle väljalülitamise eest. Peamine adea on see, et siis kasutaja tahab valgust või mitte

kood:

const int button1Pin = 2;  //viik kunu on ühebdatud nupp1

const int button2Pin = 3; //viik kuhu on ühendatud nupp2

const int ledPin =  13;   

void setup()

{

  pinMode(button1Pin, INPUT); //algväärtuse nupu viigu sisendiks

  pinMode(button2Pin, INPUT); //algväärtuse nupu viigu sisendiks

  pinMode(ledPin, OUTPUT);   //algväärtuse LED viigu väljundiks
 

}

void loop()

{

  int button1State, button2State;  //nupu oleku muutujad

  button1State = digitalRead(button1Pin);// salvestame muutujasse nupu hetke väärtuse(HIGH või LOW)

  button2State = digitalRead(button2Pin);

  if (((button1State == LOW) || (button2State == LOW))   // kui nupu on alla vajutatud

      && !

      ((button1State == LOW) && (button2State == LOW))) // kui nupude on alla vajutatud

  {

    digitalWrite(ledPin, HIGH);  // lülitame LED sisse

  }

  else                          

  {

    digitalWrite(ledPin, LOW);  // lülitame LED välja

  }    	

  }

Ülesanne Photoresistoriga

skeem:

kirjeldus

siin on fotoresistor. Fotoresistori kasutatakse ddedektorit valguse ja teha midagi, siis on see tume või valgus. Siin töötab fotoresistor nii: kui on pime, siis süttib lamp, kui on pime, siis lülitab lamp välja.

kood:

const int sensorPin = 0;

const int ledPin = 9;

int lightLevel, high = 0, low = 1023; 

void setup()

{

  pinMode(ledPin, OUTPUT);

  Serial.begin(9600); // //Serial monitori seadistamine

}

void loop()

{

  // AnalogRead() kasutab väärtused vahemikus 0 (0 вольт) и 1023 (5 вольт).

  // AnalogWrite(),  kasutatakse, et LEDi sujuvalt sisselülitada 0(ei põle) kuni 255(põleb maksimalselt).
  lightLevel = analogRead(sensorPin); //loeme mõõdetud analoogväärtuse

  // Map() teisendab sisendi väärtused ühest vahemikust teisse. Näiteks, "from" 0-1023 "to" 0-255.

  // Constrain() saed muutujale kindlad piirväärtused.

  // Näiteks:  kui constrain() kohtub arvudega 1024, 1025, 1026.., siis ta teisendab need 1023, 1023, 1023..). Kui arvud vähem kui 0, siis teisendab need 0:. 

  // lightLevel = constrain(lightLevel, 0, 255);

  manualTune();  //

  //autoTune();  //

  analogWrite(ledPin, lightLevel);

  // Выражение выше, будет изменять яркость светодиода вместе с уровнем освещенности. Чтобы сделать наоборот, заменить в analogWrite(ledPin, lightLevel) "lightLevel" на "255-lightLevel". Теперь у нас получился ночник!

  Serial.print(lightLevel);     // prindime tulemused Serial Monitori (вывод данных с фоторезистора (0-1023))

  Serial.println("");          

  delay(1000);                

}

void manualTune()

{

  lightLevel = map(lightLevel, 300, 800, 0, 255); // kaardistame selle analoogväljundi vahemikku (будет от 300 темно, до 800 (светло)). 

  lightLevel = constrain(lightLevel, 0, 255);

} 

void autoTune()

{

   if (lightLevel < low)  

  {                      

    low = lightLevel;   

  }

  if (lightLevel > high)

  {

    high = lightLevel;

  }

  lightLevel = map(lightLevel, low+10, high-30, 0, 255);

  lightLevel = constrain(lightLevel, 0, 255);

katse 3

skeem:

Töö kirjeldus:

öövalgustus kahe režiimiga: päevarežiim ja öörežiim

Kasutatud komponendid:

• Arduino Uno
• 3x ledid
• Fotoristor
• Arendusplaat
• 3x 220kΩ takistit
• 1x 10kΩ takisti
• 8x Juhtme

Töö protsess:

see öine valgus töötab koosneb 3 ledist, mõnest resistrsist ja fotorestorist. Põhiidee on see, et lambid põlevad siis, kui on pime, ja lülituvad välja siis, kui on pime.

kood:

const int ldrPin = A1;      // Photoresistor (LDR) connected to A1
const int ledPin1 = 10;     // LED 1 (Digital)
const int ledPin2 = 11;     // LED 2 (Digital)
const int ledPin3 = 12;     // LED 3 (PWM for brightness)

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  Serial.begin(9600);  // Start serial communication
}

void loop() {
  // Read light level from LDR (0 = bright, 1023 = dark)
  int lightLevel = analogRead(ldrPin);

  // --- Control LED 1 (ON in complete darkness) ---
  if (lightLevel > 800) {
    digitalWrite(ledPin1, HIGH);  // Turn ON LED 1
  } else {
    digitalWrite(ledPin1, LOW);   // Turn OFF LED 1
  }

  // --- Control LED 2 (ON in moderate darkness) ---
  if (lightLevel > 500) {
    digitalWrite(ledPin2, HIGH);  // Turn ON LED 2
  } else {
    digitalWrite(ledPin2, LOW);   // Turn OFF LED 2
  }

  // --- Control LED 3 (PWM brightness, dim when dark) ---
  // Map LDR reading (200-800) to PWM brightness (0-255)
  int brightness = map(lightLevel, 200, 800, 0, 255);
  brightness = constrain(brightness, 0, 255);  // Limit to 0-255
  analogWrite(ledPin3, brightness);  // Set LED 3 brightness

  // Print light level to Serial Monitor
  Serial.print("Light Level: ");
  Serial.println(lightLevel);

  delay(100);  // Small delay for stability
}

Uued funktsioonid:

if (lightLevel > lightThreshold) – Kui valgustase on suurem kui läviväärtus, siis täidetakse esimene koodiblokk.

Video:

Uued funktsioonid:

if (lightLevel > lightThreshold) – Kui valgustase on suurem kui läviväärtus, siis täidetakse esimene koodiblokk.

Peamine ülesanne:

Mulle ja minu partnerile Maksimile tehti ülesandeks luua valguskett

Asjad, mida me vajasime ja kasutasime:

Arendusplaat (Arendusplaat pakub kõike vajalikku mikrokontrolleriga mugavaks töötamiseks),

4x RGB-LED (LED-moodul, mis suudab toota peaaegu kõiki värve, kasutades neid kolme peamist lisavärvi: Punane, roheline ja sinine),

12x 220 (OM) resistorit (Takisti on passiivne kahetermiline elektrooniline komponent, mis rakendab elektritakistust vooluahela elemendina),

1x 10k(OM) potenrsiomeeter (Potentsiomeeter on käsitsi reguleeritav muutuvtakisti, millel on 3 klemmi),

Juhtmed ühenduste loomiseks (juht lihtsalt liigutab elektrit),

Makettplaat komponentide paigutamiseks (Makettplaat koosneb elektrit mitte juhtivast plaadist)

Ühendamise skeem:

Meie lampidel on erinevad režiimid ja need on määratud potentsoimeetri pöörlemisega.

Sisekood:

// RGB-LED-ide ühendused
const int RGB_PINS[4][3] = {
  {13, 5, 9},   // LED 1: R, G, B
  {12, 4, 8},   // LED 2
  {11, 3, 7},   // LED 3
  {10, 2, 6}    // LED 4
};

see osa kirjandus ütleb meile, et traat on ühendatud nendes kohtades. See on näha pildil.

const int POT_PIN = A0;  // Potentsiomeeter

void setup() {
  // kõik LED-ide pinnid
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 3; j++) {
      pinMode(RGB_PINS[i][j], OUTPUT);
    }
  }
  Serial.begin(9600);
}

void loop() {
  int potValue = analogRead(POT_PIN);
  int mode = map(potValue, 0, 1023, 1, 5);
  mode = constrain(mode, 1, 5);

  Serial.print("Reziim: ");
  Serial.println(mode);

  switch (mode) {
    case 1: allOn(); break;
    case 2: waveEffect(); break;
    case 3: colorCycle(); break;
    case 4: redYellowAlternate(); break;
    case 5: discoEffect(); break;
  }
}

paneb potentsiomeetri seaded ja režiimid

// REŽIIMID

// 1. Kõik LED-id valged
void allOn() {
  // Valged LED-id
  setColor(0, 255, 255, 153);
  setColor(1, 255, 255, 255);
  // Sinised LED-id
  setColor(2, 255, 255, 255);
  setColor(3, 255, 255, 153);
  delay(500);
}

// 2. Laineefekt
void waveEffect() {
  for (int i = 0; i < 4; i++) {
    setColor(i, 0, 255, 0); // Roheline
    delay(100);
    setColor(i, 0, 0, 0);
  }
  for (int i = 3; i >= 0; i--) {
    setColor(i, 0, 0, 255); // Sinine
    delay(100);
    setColor(i, 0, 0, 0);
  }
}

// 3. Värvide tsükkel
void colorCycle() {
  // Punane
  for (int i = 0; i < 4; i++) setColor(i, 255, 0, 0);
  delay(500);
  // Roheline
  for (int i = 0; i < 4; i++) setColor(i, 0, 255, 0);
  delay(500);
  // Sinine
  for (int i = 0; i < 4; i++) setColor(i, 0, 0, 255);
  delay(500);
  // Kollane
  for (int i = 0; i < 4; i++) setColor(i, 255, 255, 0);
  delay(500);
}

// 4. Küünlaefekt (kollased toonid)
void redYellowAlternate() {
  // Esimene kombinatsioon: LED 1-2 punased, LED 3-4 kollased
  setColor(0, 255, 0, 0);
  setColor(1, 255, 255, 0);
  setColor(2, 255, 0, 0);
  setColor(3, 255, 255, 0);
  delay(500);
  
  // Teine kombinatsioon: LED 1-2 kollased, LED 3-4 punased
  setColor(0, 255, 255, 0);
  setColor(1, 255, 0, 0);
  setColor(2, 255, 255, 0);
  setColor(3, 255, 0, 0);
  delay(500);
}

// 5. Diskoefekt
void discoEffect() {
  for (int i = 0; i < 4; i++) {
    setColor(i, random(0, 255), random(0, 255), random(0, 255));
  }
  delay(100);
}

režiimid ja mida nad teevad

// Abifunktsioon LED-i värviseadistuseks
void setColor(int led, int r, int g, int b) {
  analogWrite(RGB_PINS[led][0], r);
  analogWrite(RGB_PINS[led][1], g);
  analogWrite(RGB_PINS[led][2], b);
}

lülitage kõik välja

Video:

Näidis 1:

Selles näites näete, et LED valgustus (antud olukorras punane) süttib sertan korda. Seda saab kasutada erinevate mustrite loomiseks, täpselt nagu koodis morse!

void setup()

{

  // pinMode() määrab töörežim

  pinMode(13, OUTPUT);   // 13-pini number, INPUT/OUTPUT(Sisend/Väljund).

}

void loop()

{

  digitalWrite(13, HIGH);   // Lülita sisse

  delay(1000);              // Ootab 1 sek  

  digitalWrite(13, LOW);    // Lülita välja

  delay(3000);              // Ootab 3 sek

  
  
  digitalWrite(13, HIGH);   // -... .- .-.. .-.. ...

  delay(3000);               

  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);
  
  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);
  
  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);
  
  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);
  
  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(1000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  digitalWrite(13, HIGH);

  delay(3000);
  
  digitalWrite(13, LOW);

  delay(1000);
  
  
  
  
  
  
  
  digitalWrite(13, HIGH);   // -... .- .-.. .-.. ...

  delay(1000);              // Ootab 1 sek  

  digitalWrite(13, LOW);    // Lülita välja

  delay(3000);
}

Näidis 2:

Sellel pildil on emaplaat, mis on saanud koodi, mis annab edasi leivaplaadi ja RGB-lambi.

Seal on transistorid mille vältida liiga palju võimu läheb lamp, sest me ei taha, et kogu asi põlema minna.

Kasutan Arduino, laendusplaat, juhtmed, 3 transistoridit (220 om) ja 1 RGB lamp

kood:

const int RED_PIN = 11;

const int GREEN_PIN = 9;

const int BLUE_PIN = 10;

int DISPLAY_TIME = 100;  // värvimuutuse kiirus

void setup()

{

  pinMode(RED_PIN, OUTPUT);

  pinMode(GREEN_PIN, OUTPUT);

  pinMode(BLUE_PIN, OUTPUT);

}

void loop()

{

mainColors();

showSpectrum();

}

void mainColors()

{

// Kõik LEDid on välja lülitatud

  digitalWrite(RED_PIN, LOW);

  digitalWrite(GREEN_PIN, LOW);

  digitalWrite(BLUE_PIN, LOW);

 delay(1000);

//Põleb punane

  digitalWrite(RED_PIN, HIGH);

  digitalWrite(GREEN_PIN, LOW);

  digitalWrite(BLUE_PIN, LOW);

  delay(1000);

// Põleb roheline

  digitalWrite(RED_PIN, LOW);

  digitalWrite(GREEN_PIN, HIGH);

  digitalWrite(BLUE_PIN, LOW);

  delay(1000);

// Sinine on sisse lülitatud

  digitalWrite(RED_PIN, LOW);

  digitalWrite(GREEN_PIN, LOW);

  digitalWrite(BLUE_PIN, HIGH);

  delay(1000);

// Kollane.

  digitalWrite(RED_PIN, HIGH);

  digitalWrite(GREEN_PIN, HIGH);

  digitalWrite(BLUE_PIN, LOW);

  delay(1000);

// Lilla

  digitalWrite(RED_PIN, LOW);

  digitalWrite(GREEN_PIN, HIGH);

  digitalWrite(BLUE_PIN, HIGH);

  delay(1000);

//Roosa

  digitalWrite(RED_PIN, HIGH);

  digitalWrite(GREEN_PIN, LOW);

  digitalWrite(BLUE_PIN, HIGH);

  delay(1000);

//Valge ehk kõik on sisse lülitatud

  digitalWrite(RED_PIN, HIGH);

  digitalWrite(GREEN_PIN, HIGH);

  digitalWrite(BLUE_PIN, HIGH);

  delay(1000);

}

// Vikerkaar. 

void showSpectrum()

{

  int x;

  for (x = 0; x < 768; x++)

  {

    showRGB(x);  // 

    delay(10);   // paus 0,001 sek

  }

}

// ShowRGB()  põhivärvid: 

// 0 = punane 

// 255 = roheline

// 511 = sinine

// 767 = jälle punane 

void showRGB(int color)

{

  int redIntensity;

  int greenIntensity;

  int blueIntensity;

  if (color <= 255)                

  {

    redIntensity = 255 - color;    // lülitakse välja punane

    greenIntensity = color;        // lülitakse sisse roheline

    blueIntensity = 0;             // sinine on välja lülitatud

  }

  else if (color <= 511)          

  {

    redIntensity = 0;                     // punane on välja lülitatud

    greenIntensity = 255 - (color - 256); 

    blueIntensity = (color - 256);        

  }

  else if (color >= 512)             

  {

    redIntensity = (color - 512);        

    greenIntensity = 0;                  

    blueIntensity = 255 - (color - 512);  

  }

  analogWrite(RED_PIN, redIntensity); // punase LED´i sujuv ümberlülitamine

  analogWrite(BLUE_PIN, blueIntensity);

  analogWrite(GREEN_PIN, greenIntensity);

}

Põhimõtteliselt toimib see nii, et see silub üleminekuid värvide vahel.

Katse 1 / Sissetöö

Mida ja miks?

Põhimõtteliselt see, mida ma tegin, on valgusfoor, et saada kogemusi robotite ehitamise alustega.

Selle töö jaoks kasutasin saiti nimega “Tinkercard“.

Mida ma kasutasin?

8 juhet,

5 resisotorit,

2 LED RBG lapmit

(allpool on pilt)

Mida nad on?

RGB LED on LED-moodul, mis suudab toota peaaegu kõiki värve, kasutades neid kolme peamist lisavärvi: Punane, roheline ja sinine.

Resistor on passiivne kahetermiline elektrooniline komponent, mis rakendab elektritakistust vooluahela elemendina.

Juhe on painduv juht, mida kasutatakse elektrienergia ja informatsiooni edastamiseks.

Kuidas see töötab?

Mis kõik komponendid võimu läheb läbi juhtmed ja tuled üles tuled. Takistid kontrollivad, kui palju energiat läheb lampidesse (ja nii ei põle).

(allpool on video nagu see toimib tegelikus elus)

Kood:

// esimene RGB-LED
const int RED_PIN = 11;
const int GREEN_PIN = 9;
const int BLUE_PIN = 10;

// teine RGB-LED
const int RED_PIN_2 = 7;
const int GREEN_PIN_2 = 5;
const int BLUE_PIN_2 = 6; 

siin ma panen mitu värvid ja läbi, mida pinadesse minna

// Traffic light timings (in milliseconds)
const int RED_TIME = 5000;       // 5 seconds red
const int RED_YELLOW_TIME = 2000; // 2 seconds red+yellow
const int GREEN_TIME = 5000;     // 5 seconds green
const int YELLOW_TIME = 2000;    // 2 seconds yellow

Ma olin laisk panema mingeid numbreid sinna, nii et ma olen pannud need omadused

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  
  pinMode(RED_PIN_2, OUTPUT);
  pinMode(GREEN_PIN_2, OUTPUT);
  
  // Start with all lights off
  digitalWrite(RED_PIN, LOW);
  digitalWrite(GREEN_PIN, LOW);
  digitalWrite(BLUE_PIN, LOW);
}

pin-režiimide panemine ja kõigi tulede väljalülitamine

void loop() {
  // Red light
  digitalWrite(GREEN_PIN_2, HIGH);
  digitalWrite(RED_PIN, HIGH);
  digitalWrite(GREEN_PIN, LOW);
  digitalWrite(BLUE_PIN, LOW);
  delay(RED_TIME);
 
  
  // Green light
  digitalWrite(GREEN_PIN_2, LOW);
  digitalWrite(RED_PIN, LOW);
  digitalWrite(GREEN_PIN, HIGH);
  digitalWrite(RED_PIN_2, HIGH);
  digitalWrite(BLUE_PIN, LOW);
  delay(GREEN_TIME);
  
  // Yellow light
  digitalWrite(RED_PIN_2, LOW);
  digitalWrite(RED_PIN_2, HIGH);
  digitalWrite(RED_PIN, HIGH);
  digitalWrite(GREEN_PIN, HIGH);
  digitalWrite(BLUE_PIN, LOW);
  delay(YELLOW_TIME);
  digitalWrite(RED_PIN_2, LOW);
}

Esimene lamp on suur, see suunab mulle pärast ühte või teist konkreetset tegevust näitab, mida teine lamp peaks tegema.
kui Sa tahad edasi vaadata vaata kommentaare

Video: ｡◕‿‿◕｡

Uued funktsioonid:
void loop()

(See on sisseehitatud Arduino funktsioon, mis
käivitub korduvalt pärast setup() funktsiooni. Siia kirjutatakse
programmi põhiloogika.)

digitalWrite(pin, value)

(See funktsioon seab digitaalse pin’i väärtuseks kas HIGH (sees) või LOW (väljas). Seda kasutatakse näiteks LED-ide sisse või välja
lülitamiseks.)

delay(ms)

(Peatab programmi kindlaks ajaks millisekundites. Näiteks delay(1000) peatab programmi üheks sekundiks)