Month: September 2025

RBG teooria

Posted on by Hussein

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);
}

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.

OOP

Posted on by Hussein

OOP-tehnikad

  • Inkapsulatsioon: Funktsionaalsus peidetakse objekti sisse, piirates otsest ligipääsu selle sisemistele detailidele.
  • Modulaarsus: Programm jagatakse sõltumatuteks mooduliteks, mis töötavad koos.
  • Polümorfism: „Mitu vormi“ – võimaldab alamklassidel muuta vanemklassi meetodite käitumist.
  • Pärilikkus: Üks klass (alamklass) saab pärida teiselt klassilt (vanemklassilt) omadusi ja meetodeid.

Sissejuhatus OOP-sse

Objektorienteeritud programmeerimises räägitakse klasside kirjeldamisest ja objektide loomisest nende kirjelduste alusel. Objektide käsitlemine toimub klassis määratletud meetodite kaudu (meetodid on põhimõtteliselt funktsioonid).

Klassid

Klass on kasutaja määratud andmestruktuur, mis seob andmeväljad (muutujad) ja meetodid ühtsesse tervikusse. Klass on nagu plaan, mille järgi saab luua piiramatult objekte.

Näide konstruktorist:

class Dog:
    # Klassikonstruktor
    def __init__(self, name):
        self.name = name

Konstruktorite tüübid Pythonis

  1. Vaikekonstruktor – kui konstruktorit ei määrata, loob Python selle automaatselt (__init__(self)).
  2. Mitteparametriseeritud konstruktor – ei võta lisaparameetreid.
  3. Parametriseeritud konstruktor – võtab vastu parameetreid ja võimaldab erinevaid algväärtusi.

Objektid

Objekt on klassi eksemplar ehk tegelik näide. See sisaldab atribuute (muutujaid) ja meetodeid.

Objekti loomise süntaks:

dog_name = Dog("Snoopy")

Objekti omadused:

  • Identiteet – igal objektil on ainulaadne ID.
  • Seisund – määratud atribuudi(te) väärtustega.
  • Käitumine – määratud meetoditega.

Pärilikkus

Omadused jaotatakse hierarhiliselt:

  • Vanemklass – sisaldab üldiseid omadusi ja võib sisaldada abstraktseid meetodeid.
  • Alamklass – pärib omadused ja laiendab neid.

Abstraktseid meetodeid ei saa kasutada enne, kui need on alamklassides implementeeritud.

Inkapsulatsioon

Inkapsulatsioon eraldab klassi sisemise toimimise selle liidesest (interface). See aitab hoida koodi stabiilsena, isegi kui sisemine toimimine muutub.

Näide inkapsulatsioonist ja privaatsetest muutujatest:

class Computer:

    def __init__(self):
        self.__sellingprice = 700  # privaatne muutuja

    def sell(self):
        print("Müügihind: {}".format(self.__sellingprice))

    def set_selling_price(self, price):
        self.__sellingprice = price

c = Computer()
c.sell()

# Püüame muuta hind otse
c.__sellingprice = 1000
c.sell()

# Muudame hind setter-meetodiga
c.set_selling_price(1000)
c.sell()

Väljund:

Müügihind: 700  
Müügihind: 700  
Müügihind: 1000

Polümorfism

Polümorfism tähendab, et sama meetod käitub erinevates klassides erinevalt.

Näide:

class Circle:

    def corners(self):
        print("Ringil pole nurki")

    def sides(self):
        print("Ringil on üks külg")

class Rectangle:

    def corners(self):
        print("Ristkülikul on neli nurka")

    def sides(self):
        print("Ristkülikul on neli külge")

# Ühine liides
def corners_test(shape):
    shape.corners()

# Objektide loomine
first_shape = Circle()
second_shape = Rectangle()

# Meetodi käivitamine
corners_test(first_shape)
corners_test(second_shape)

Väljund:

Ringil pole nurki  
Ristkülikul on neli nurka

Abstraktsioon

Abstraktsioon tähendab keskendumist olulisele ja ebaolulise peitmist. Kasutaja teab, mida funktsioon teeb, aga mitte kuidas see töötab.

Pythoni moodul abc (Abstract Base Class) võimaldab luua abstraktseid klasse.

Näide abstraktsioonist:

from abc import ABC

class Animal(ABC):

    def sleep(self):
        print("Ma lähen magama.")

    def speak(self):
        pass  # abstraktne meetod

class Human(Animal):

    def speak(self):
        print("Ma oskan rääkida.")

class Snake(Animal):

    def speak(self):
        print("Ma oskan sisiseda.")

class Dog(Animal):

    def speak(self):
        print("Ma oskan haukuda.")

class Lion(Animal):

    def speak(self):
        print("Ma oskan möirgata.")

# Objektide loomine ja meetodi kutsumine
human = Human()
human.speak()

snake = Snake()
snake.speak()

dog = Dog()
dog.speak()

lion = Lion()
lion.speak()

Väljund:

Ma oskan rääkida.  
Ma oskan sisiseda.  
Ma oskan haukuda.  
Ma oskan möirgata.

NikitaTöö

Posted on by Hussein

Siin olen loonud 2 tabelit nende omadustega (pidin lisama veel, sest triggerile ja nimede muutmiseks ei olnud sellest piisavalt).

see on käivitaja, mis võimaldab näha lisatud logisid

proovin…

meil on andmed!

(kõik andmed)

see on kustutamise põhjus

see töötab nii 😀

õigusid kasutajal

Ja ta ei saa teha SELLECT logi’sse

aga ta saab töötada models’is

— Töö uuede triggeridega —

Lisamine andmed:

— Lisamine triggerid:

Kontroll:

mongoDB

Posted on by Hussein

Mis on mongoDB

MongoDB on dokument-orienteeritud NoSQL-andmebaas, mis salvestab andmed JSON-sarnases vormis.

Kollektsioon
on dokumentide rühm, mis sarnaneb relaandmebaasi tabelile
ei nõua fikseeritud skeemi, aga tavaliselt hoitakse sees sarnase struktuuriga kirjeid

Dokument
on üks andmeüksus, esitatuna võtme-väärtuse paaridena (näiteks tekst, number, massiiv, sisemine objekt)
käitub nagu JSON-objekt, igaühel unikaalne _id-väli primaarvõtmena

mongoDB Kasutamine

Tabeli loomine

Ülemises osas on mongosh konsool, kus käsk show databases kuvab olemasolevad andmebaasid, seejärel lülitutakse andmebaasi mongo ja käivitatakse db.createCollection(“users”), mis tagastab { ok: 1 } ehk näitab, et users-kollektsioon loodi edukalt. Alumises osas on graafiline kasutajaliides, mis kuvab äsjaloodud users-kollektsiooni kokkuvõtet.

Andmete lisamine

Pildil näidatakse, kuidas MongoDB users kollektsiooni lisatakse uus dokument. Seejärel kuvatakse graafilises kasutajaliideses see äsja lisatud dokument.

Palju andmete lisamine

Pildil näidatakse, kuidas MongoDB users kollektsiooni lisatakse korraga mitu uut dokumenti. Graafilises kasutajaliideses on nüüd näha nii eelmisel pildil dokument kui ka need viis uut dokumenti.

Andmete otsimine kriteeriumi järgi

Pildid illustreerivad andmete otsimist MongoDB users kollektsioonist, kasutades find() käsku. Näidatakse, kuidas leida kasutajaid täpse väärtuse järgi. On toodud näide $or operaatori kasutamisest, et leida dokumente, mis vastavad vähemalt ühele mitmest määratud tingimusest. Veel näidatakse erinevate võrdlusoperaatorite kasutamist vanuse välja puhul: otsitakse, kes on nooremad kui teatud vanus ($lt), teatud vanuses või nooremad ($lte), vanemad kui teatud vanus ($gt), teatud vanuses või vanemad ($gte), ning kasutajaid, kelle vanus ei ole teatud kindel väärtus ($ne).

Sorteerimine

Pildil näidatakse MongoDB users kollektsiooni dokumentide sorteerimist. Vasakul sorteeritakse vanuse järgi kasvavalt ({age: 1}). Paremal sorteeritakse vanuse järgi kahanevalt ({age: -1})

Kirjete piiramine

Pildil näidatakse, kuidas MongoDB-s piirata tagastatavate kirjete arvu. Üleval kasutatakse db.users.find().limit(4), et saada maksimaalselt neli esimest dokumenti. Allpool kasutatakse db.users.findOne() kahel viisil: otsides konkreetse _id järgi ja otsides esimese dokumendi, mille vanus on 19.

Andmete muutmine

See uuendab esimest filtrile vastavat dokumenti, muutes määratud väljad uuteks väärtusteks.

Teie näite puhul:

See uuendab esimest kasutajat, kelle nimi on “aspir”, muutes nime “Dr.Aspirgurg” ja seades vanuseks 45 aastat.

t uuendab kõiki filtrile vastavaid dokumente, nimetades nimevälja ümber täisnimeks.

Teie näite puhul:

See nimetab nimi ümber täisnimeks kõigis kasutajate kollektsiooni dokumentides.

Andmete kustutamine

Saate kasutada meetodit deleteOne(), et eemaldada esimene dokument, mis vastab määratud filtrile.

Mitmekordne taotlus

Meetod, mis võimaldab mitme kirjutamisoperatsiooni (sisestamine, uuendamine, kustutamine, asendamine) teostamist ühe üleskutsega.

Parandab jõudlust, vähendades serverisse pöördumiste arvu.

Filter on päringu objekt, mis määrab MongoDB operatsioonides dokumentide valiku kriteeriumid.

Linkide tüübid

Kui kasutaja nimega „Ivan“ on olemas, siis tema postituste väli kirjutatakse üle selle massiivi.
Kui „Ivanil“ ei ole veel postituste välja, siis luuakse see.
Operatsioon mõjutab vaikimisi ainult esimest sobivat dokumenti (sest update() ilma valikuteta mõjutab ainult ühte).

Mongo ühendamine node jsiga

Kood impordib MongoClienti mongodb paketist.

See loob uue MongoClient’i koos ühendusstringiga MongoDB Atlas klastrile (pilvemongoDB).

Asünkroonne käivitamisfunktsioon:

Funktsioon start on deklareeritud asünkroonsena, et see saaks kasutada await’i asünkroonsete MongoDB operatsioonide jaoks.

Try-bloki sees (vigade püüdmiseks ja logimiseks):

konspekt teemaga

Posted on by Hussein

Programmeerimise ajalugu

Programmeerimise arengulugu hõlmab teekonda esimestest programmeerimiskeeltest kuni tänapäevaste tehnoloogiateni. See sisaldab olulisi saavutusi, mõjukaid isikuid ning erinevate programmeerimisparadigmade kujunemist ja arengut.

print("Tere, maailm!")

Süntaks

Süntaks on reeglistik, mis määrab, kuidas tuleb koodi kirjutada, et see oleks arvutile arusaadav. See hõlmab näiteks märksõnu, operaatoreid, kirjavahemärke ning loogilist koodi ülesehitust.

a = 5
b = 3

if a > b:
    print("a on suurem kui b")
elif a > b
    print("a on suurem")

Muutujad

Muutujad on nimelised kohad arvuti mälus, kuhu saab salvestada andmeid ja millele saab hiljem viidata. Igal muutujal on tüüp (nt int, float, string, bool) ja väärtus, mida saab programmi käivitamisel muuta.

nimi = "Anna"          # str – sõne
vanus = 25             # int – täisarv
kõrgus = 1.68          # float – ujukomaarv
on_õpilane = True      # bool – tõeväärtus

print(nimi, "on", vanus, "aastat vana.")

Lineaarsed programmid

Lineaarsed programmid koosnevad juhistest, mis täidetakse järjestikku, ilma harude või kordusteta.

Programmi voog on sirgjooneline – algusest lõpuni.

Tüüpilised tegevused: sisendi lugemine, arvutuste tegemine ja väljundi kuvamine.

nimi = input("Sisesta oma nimi: ")
vanus = int(input("Sisesta oma vanus: "))
print("Tere,", nimi)
print("Järgmisel aastal oled sa", vanus + 1, "aastat vana.")

Valikud

Valikulaused võimaldavad programmil teha otsuseid ja täita erinevaid koodiplokke sõltuvalt tingimuste tõesusest või väärusest.

  • if: Kui tingimus on tõene, täidetakse if-ploki kood.
  • elif (else if): Kui eelnev if või elif tingimus oli väär, kontrollitakse uut tingimust. Kui see on tõene, täidetakse vastav koodiplokk.
  • else: Kui ükski eelnevatest tingimustest ei olnud tõene, täidetakse else-plokk. Else on valikuline.
number = int(input("Sisesta arv: "))

if number > 0:
    print("Arv on positiivne.")
elif number < 0:
    print("Arv on negatiivne.")
else:
    print("Arv on null.")

Kordused

Tsüklid võimaldavad teatud koodiplokki mitu korda korrata.

  • for-tsükkel: Kasutatakse järjendite (nt loendid, sõned) kordamiseks kindel arv kordi. Sageli koos range() funktsiooniga.
for i in range(5):
    print("Tere", i)
  • while-tsükkel: Kordab koodiplokki, kuni mingi tingimus on tõene. Tingimust kontrollitakse enne iga kordust. Oluline on tagada, et tingimus muutuks tsükli sees, vältimaks lõputut tsüklit.
arv = 1
while arv <= 5:
    print("Arv:", arv)
    arv += 1

Tsükli juhtlausete näited:

  • break: katkestab tsükli kohe.
  • continue: jätkab tsüklit järgmise kordusega, vahele jättes ülejäänud koodi jooksvas tsüklis.
for i in range(10):
    if i == 7:
        break
    if i % 2 == 0:
        continue
    print(i)

Loendid

Loendid on järjekorras, muudetavad andmekogumid, mis võivad sisaldada erinevat tüüpi elemente.

  • Elementidele pääseb ligi indeksi kaudu (alates nullist).
  • Võimalikud toimingud: lisamine, eemaldamine, muutmine, sortimine, viilutamine.

Levinud meetodid: append(), insert(), remove(), pop(), sort(), reverse(), len().

ostunimekiri = ["leib", "piim", "juust"]
ostunimekiri.append("või")
ostunimekiri.remove("piim")
ostunimekiri.sort()

print(ostunimekiri)

Kasutaja funktsioonid

Funktsioonid on korduvkasutatavad koodiplokid, mis täidavad konkreetset ülesannet.

  • Aitavad koodi struktuureerida, muuta loetavamaks ja vähendada kordust.
  • Funktsiooni defineerimiseks kasutatakse märksõna def, millele järgneb nimi, sulud parameetritega ja koolon. Keha on taandatud.

Parameetrid ja argumendid:

  • Parameetrid määratakse funktsiooni defineerimisel.
  • Argumendid on väärtused, mida funktsiooni kutsumisel parameetritele antakse.

Tagastusväärtus:

  • Funktsioon võib midagi tagastada return abil.
  • Kui return puudub või on ilma väärtuseta, tagastatakse vaikimisi None.

Kohalikud ja globaalsed muutujad:

  • Funktsioonis määratud muutujad on kohalikud.
  • Funktsiooni välised muutujad on globaalsed.
def tervita(nimi):
    print("Tere,", nimi)

tervita("Kati")

def korruta(a, b):
    return a * b

tulemus = korruta(3, 4)
print("Tulemus on:", tulemus)

Sõnastikud

Sõnastikud on järjekorrata, muudetavad andmestruktuurid, mis hoiavad andmeid võtme-väärtuse paaridena.

  • Iga võti peab olema unikaalne ja muutumatu (nt sõne, arv). Väärtus võib olla suvaline tüüp.
  • Elementidele pääseb ligi võtme, mitte indeksi kaudu.

Levinud meetodid: keys(), values(), items(), get(), pop().

opilane = {
    "nimi": "Jaan",
    "vanus": 17,
    "klass": "11B"
}

print(opilane["nimi"])
opilane["vanus"] = 18
opilane["aadress"] = "Tallinn"

for võti, väärtus in opilane.items():
    print(võti, ":", väärtus)

Failidega töötamine

Failidega töötamine võimaldab andmeid püsivalt salvestada ja hiljem lugeda.

Faili avamine:

  • Kasutatakse open() funktsiooni, mille argumendid on failinimi ja töörežiim (nt 'r' lugemiseks, 'w' kirjutamiseks, 'a' lisamiseks, 'b' binaarrežiim).

Failist lugemine: read(), readline(), readlines().

Faili kirjutamine: write(), writelines().

Faili sulgemine:

  • Pärast töö lõpetamist tuleb fail sulgeda close() abil, et andmed salvestuksid õigesti ja ressursid vabaneksid.

Soovitatav: kasutada konstruktsiooni with open(...) as ...:, mis sulgeb faili automaatselt.

Erinevad failivormingud: .txt, .csv, .json.

# Kirjutamine
with open("andmed.txt", "w") as fail:
    fail.write("Tere, fail!")

# Lugemine
with open("andmed.txt", "r") as fail:
    sisu = fail.read()
    print(sisu)

Graafikute ja diagrammide loomine

Andmete visualiseerimine graafikute ja diagrammide abil aitab paremini mõista mustreid, trende ja seoseid.

Levinud Python’i teegid:

  • Matplotlib – põhiline ja laialt kasutatav
  • Seaborn – põhineb Matplotlibil, pakub kõrgema taseme kasutajaliidest statistilisteks graafikuteks
  • Plotly – võimaldab interaktiivseid graafikuid

Graafikute tüübid:

  • Joonisgraafik
  • Tulpdiagramm
  • Hajusdiagramm
  • Sektordiagramm
  • Histogramm

Kohandused:

  • Telgede nimed, pealkirjad, legendid, värvid, stiilid
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]

plt.plot(x, y)
plt.title("Lihtne joonisgraafik")
plt.xlabel("X telg")
plt.ylabel("Y telg")
plt.grid(True)
plt.show()

Graafiline kasutajaliides (GUI)

Graafiline kasutajaliides võimaldab kasutajatel suhelda programmiga visuaalsete elementide (aknad, nupud, tekstiväljad jms) kaudu, mitte ainult käsurea kaudu.

  • Tkinter: Python’i standardne GUI-teek, lihtne alustada, platvormiülene
  • CustomTkinter: moodsam ja visuaalselt atraktiivsem alternatiiv, pakub rohkem kohandamisvõimalusi

Põhimõtted GUI loomiseks:

  • Vidinate paigutamine aknasse
  • Sündmuste haldamine (nt nupuvajutused, hiire liigutused)
import tkinter as tk

aken = tk.Tk()
aken.title("Tere tulemast!")

silt = tk.Label(aken, text="Tere, kasutaja!")
silt.pack()

nupp = tk.Button(aken, text="Sulge", command=aken.destroy)
nupp.pack()

aken.mainloop()

Konspekt

Posted on by Hussein
Robootika kolm põhiseadust on reeglid, mille mõtles välja ulmekirjanik Isaac Asimov. Reeglid ilmusid esmakordselt 1942. aastal Asimovi lühijutus “Runaround”.
Need kolm reeglit on järgmised:
1. Robot ei tohi oma tegevuse ega tegevusetusega inimesele kahju teha.
2. Robot peab alluma inimese antud käsule, kui see ei lähe vastuollu esimese seadusega.
3. Robot peab kaitsma oma olemasolu, kuni see ei ole vastuolus esimese või teise seadusega.
Peale nende kolme seaduse mõtles Asimov hiljem välja ka nullseaduse, mis on järgmine:
0. Robot ei tohi oma tegevuse või tegevusetusega inimkonnale kahju teha.

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
  1. Miks manipulaatorid ei ole robotid? – Neil on staatiline baas ja seetõttu tegutsevad nad piiratud tööruumis.
  2. Mis on masinate eelised võrreldes inimtööjõuga? – Robotid ei väsi
  3. 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.
  4. Millistes Eesti tööstusettevõtetes võiksid mehhatroonikud töötada? – 10 lines
  • 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.

  1. USB pistik (USB – Universal Serial Bus) port. USB pistiku abil saab Arduino arendusplaadile voolu anda ja programmikoodi laadida. Arduino kasutab USB B tüüpi pistikut./Разъем USB (USB Порт) – Может использоваться для питания схем, а также для связи с компьютером.
  2. Voolupesa. Voolupessa saab ühendada voolujuhtme, millega Arduinole voolu anda. /Разъем Питания (от батареи) – Может использоваться с блоками питания 9 – 12 Вольт.
  3. GND (GND – ground, eesti k maandus) pesad. Nende pesade kaudu käib vooluringi maandamine.
  4. 5V (V – volt) pesa. 5V pesa kaudu saab arendusplaadi külge ühendatavaid lisakomponente varustada 5 voldise vooluga.
  5. 3,3V pesa. 3,3V pesa kaudu saab arendusplaadi külge ühendatavaid lisakomponente varustada 3.3 voldise vooluga.
  6. Analoogpesad (A0-A5) loevad signaali analoogsensoritest ja teisaldavad selle digitaalkujule, mida programm saab lugeda ja pärast signaali töötlemist digitaalpesa kaudu väljastada. Analoogpesa on võimalik vajadusel kasutada ka signaali väljastamiseks./Порты (Analog In, Power In, Ground, Power Out, Reset) – аналоговые, входящие, исходящие, питание и земля.
  7. Digitaalsed pesad (D0-D13). Nende abil saab lugeda ja väljastada digitaalsignaali. 15
  8. Pulsilaiusmodulatsiooni (Pulse-Width Modulation (PWM)) pesade abil saab simuleerida analoogväljundit./Порты (ARef, Ground, Digital, Rx, Tx) – опорное напряжение, земля, цифровые порты, порты приема и передачи данных.
  9. AREF pesa abil saab vajadusel lisapesana lugeda kindla tugevusega analoogsisendit.
  10. Lähtestamise nupp (Reset button) – Lähtestamise nupu vajutamisel taaskäivitatakse Arduino arendusplaadile laetud lähtekood. Kui programmi töö on katkenud saab nupu abil programmi taaskäivitada. Samuti on nupp mugav viis testimiseks, kui on tarvis koodi mitu korda jooksutada saab seda teha nupule vajutades. /(сброс) – ручной перезапуск платы Arduino, приводит к перезапуску вашей программы.
  11. Toite LED (LED – Light-emitting Diode) tuli. Toite LED tuli läheb põlema, kui Arduino arendusplaat on ühendatud vooluvõrguga. Kui pärast vooluga ühendamist tuli ei lähe põlema, on oht, et arendusplaadiga on midagi valesti./Индикатор (Индикатор питания) – сигнализирует о подаче питания на плату Arduino.
  12. TX (TX – Transmit) RX (RX – Receive) LED tuled – Nende LED tulede abil on aru saada, kui arendusplaat võtab andmeid vastu või saadab neid välja. Kui andmeid saadetakse, põleb TX LED tuli, kui andmeid vastu võetakse, põleb RX LED tuli./Индикатор (RX: Прием) – Используется для индикации приема данных, если конечно это прописано в программе.Индикатор (TX: Передача) – Используется для индикации передачи данных, если конечно это прописано в программе.
  13. ATmega328P mikrokontroller, juhib Arduino Uno arendusplaadi tööd.
  14. Pingeregulaator. Pingeregulaator reguleerib arendusplaadi vooluringi lastavat pinget. Kui pinge on liiga suur, muudab pingeregulaator selle plaadile sobivaks.

  • 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 экран

Под действием напряжения источника питания,UВольт
по проводникам и компонентам разного сопротивления,RОм
от высокого потенциала,+«плюс»
к низкому потенциалу–«минус»
переносится заряд,QКулон
формируя электрический ток определённой силы,IАмпер
который совершает полезную работу,WДжоуль
превращаясь в другую энергию с некой скоростью.PВатт

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

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

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

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

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

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

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

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

Конденсатор

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

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

Ёмкость (номинал)CФарад
Точность (допуск)±%
Максимальное напряжениеVВольт

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

Номинал в пФ записан на корпусе. Первые 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

Katse 6

Posted on by Hussein

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 &lt;LiquidCrystal.h&gt;

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 &gt; 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 &gt; 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 &lt; lightThreshold) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Tuvastatud       ");
    lcd.setCursor(0, 1);
    lcd.print("pimedus          ");
  } 
  else if (tempC &gt; 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 &gt; tempThreshold || lightVal &gt; lightThreshold) {
    noTone(musicPin);
    tone(alarmPin, 1000); // alarm heli
  } else {
    noTone(alarmPin);
    tone(musicPin, 440);  // taustatoon
  }
 
  if (lightVal &lt; lightThreshold) {
    noTone(musicPin);
    noTone(alarmPin);
  } else if (tempC &gt; tempThreshold) {
    noTone(musicPin);
    playAlarmMelody();
  } else {
    noTone(alarmPin);
    playMelody();
  }
  delay(500);
}

void playMelody() {
  for (int i = 0; i &lt; 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 &lt; 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 &lt; 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.

Katse 5

Posted on by Hussein

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.

Katse 4

Posted on by Hussein

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.

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