Tuletõrjuja

• Illo Jõe
• Ly Orgo
• Ester Uibopuu
• Mikk Luige

1. Nädalaaruanne

2. Nädalaaruanne

3. Nädalaaruanne

Robot, mis peab leidma üles teeküünla ning selle kustutama. Oluline on disain.

• Maksimaalsed gabariidid on 20x20x20 cm.
• Peab olema koostatud valdavalt Kodulabori komponentidest
• Disain

Analüüsisime erinevaid kustutusmeetodeid. Valiku tegemisel lähtusime eelkõige idee atraktiivsusest ning seejärel realiseerimise võimalustest.

Toimus hääletamine ning otsustasime õhukahuri kasuks. Kõige olulisem oli meie jaoks lahenduse huvitavus ning erakordsus. Meetodid, mis said rohkem plusse, on ka rohkem kasutust leidnud või on liiga komplitseeritud tööpõhimõttega ning kohmakad. Õhukahur on üsna kompaktne, töökindel, huvitav, vähem realiseeritud. Peale esimese prototüübi postiivse tulemusega katsetamist, olime oma valikus kindlad.

Esimene õhukahuri prototüüp

Cadi mudel:

Lisanduvad veel kruvide, seibide jms hind.

Töötunde: 600, töötunni hind: 5 EUR, kokku: 3000 EUR

Õhukahuri käppmehhanism, mis haarab kahuri riidega trossi abil kinnitatud kuulist ning laseb siis lahti. Käppmehhanismi käitab alalisvoolumootor.

Õhukahur on šablooni järgi plastikust välja lõigatud. Et kahurit oleks servapidi mugavam ning kindlam ühendada, on vajalik nende ülekattuvus. Seega tuleb jälgida, et šablooni järgi lõigates jäetaks ühele servale piisavalt suur varu.

Õhulaine tekitamiseks on vajalik membraan, mis ei laseks läbi liigselt õhku ning suurus oleks valitud nii, et selle liikuvus võimaldaks efektiivset käigupikkust. Antud lahenduses on membraan kinnitatud õmblusega õhukahuri ühele servale. Teiselt kahuri servalt tulevad mitmed kummipaelad membraani keskele kokku. Kummipaelade pingutamisega on võimalik reguleerida vinnastuse jõudu ning membraani liikumise kiirust. Need suurused on olulised piisava õhulaine tekitamiseks ning omakorda ka sobiva mootori valikuks.

Membraani keskpunktis on kokku ühendatud kummid, membraan ning tross. Kummid ning tross on membraani suhtes eripooltel. Trossi teise otsa on kinnitatud kuul, mille haarab ning vabastab plastikust käpp, mida omakorda käitab alalisvoolumootor. Kuuli algasendisse viimiseks on kasutatud plastikust positsioneerijat. Haarats on valmistatud 5mm paksusest PMMA materjalist, kumerus on saadud kuumapuhuriga kuumutades.

Membraaniks kasutasime kumeeritud impregneerriiet, kuna membraan peab olema õhukindel, tugev ja samas liikumist mitte takistav. Alternatiivseks variandiks oli kile, kuid kasutatava kinnitusmeetodi puhul poleks kile tugevus ja vastpidavus olnud piisav.

Külgvaade

Lähivaade

Pealtvaade seletustega

Raami disainis kasutasime alumiiniumit ning hulgaliselt painutatud detaile, mis tegi roboti ehitamise keerulisemaks ja aeganõudvamaks. Mõnes kohas sai 90⁰ painutused asendatud vinkliga, kuna painutatud koht jäi liiga nõrgaks, mistõttu tekkisid painutustes praod.

Konstruktsioon

Konstruktsioon käpaga

Konstruktisioon käppmehhanismi ja mõningase elektroonikaga

Õhukahuri pinnalaotus

Piiraja

Vinnastusmehhanism

Roboti juhtimine toimub 5 anduri abil: 4 on fotodioodid leegi leidmiseks ning 1 on ultraheli kaugusmõõdik.

Toimub fotodioodide näitude võrdlemine ning vastavalt sellele roboti positsioneerimine.

Kood:

#include <stdio.h>
#include <stdlib.h>
#include <homelab/adc.h>
#include <homelab/module/lcd_alpha.h>
#include <homelab/module/sensors.h>
#include <homelab/delay.h>
#include <homelab/module/motors.h>
#include <math.h>
#include <homelab/pin.h>
 
//Ultraheli anduri viikude defineerimine.
pin pin_echo = PIN(E, 0);
pin pin_trigger    = PIN(E, 1);
pin pin_ground = PIN(E, 2);
pin pin_live    = PIN(E, 3);
 
 
 
int main(void)
{
 
    //Eelseadistused muutujate loomiseks, mootorikontrolleri viikude initsialiseerimine jne.
    char text[16];
    int sensor0,sensor1,sensor2,sensor3,threshold=1200,i=1,a=1;
    hw_delay_ms(100);
    dcmotor_init(0);
    dcmotor_init(1);
    dcmotor_init(2);
    servomotor_init(0);
    adc_init(ADC_REF_AVCC, ADC_PRESCALE_8);
 
    //Ultraheli anduri viikude seadistus.
    pin_setup_output(pin_ground);
    pin_setup_output(pin_live);
    pin_clear(pin_ground);
    pin_set(pin_live);
 
    scan();
 
    while(1)
    {
 
    detect();
 
 
    for (a = 0; a < 500; a++)
    {
        //Infrapuna anduritelt näitude sisse lugemine.
        sensor0 = adc_get_average_value(0,40);
        sensor1 = adc_get_average_value(1,40);
        sensor2 = adc_get_average_value(2,40);
        sensor3 = adc_get_average_value(3,40);
 
        //See koodijupp võrdleb kahelt keskmiselt infrapuna andurilt saadud väärtuste summat algselt seadistatud väärtusega "threshold", et ära tunda, millal küünal on leitud.
        //Kui küünal on leitud jääb robot seisma ja üritab küünalt kolm korda kustutada.
        //Kui küünalt ei ole leitud arvestab robot kõigi nelja infrapuna anduri väärtuse järgi suuna kuhu poole sõita.
        if (sensor1+sensor2>threshold)
        {
            drive(0,0);
            hw_delay_ms(2000);
            for (i = 0; i < 3; i++)
            {
                dcmotor_drive(2,-1);
                hw_delay_ms(1000);
                dcmotor_drive(2,0);
                hw_delay_ms(2000);
            }
            drive(-10,-10);
            hw_delay_ms(1000);
            scan();
        }
        else
        {
            max(15*(sensor2+sensor3)/(sensor0+sensor1+sensor2+sensor3) , 15*(sensor0+sensor1)/(sensor0+sensor1+sensor2+sensor3));
 
        }
    }
    }
}
 
//See funktsioon tagab efektiivsema keeramise. Main funktsioonis tuletatud sõidu suunale ja kahele mootori kiirusele lisatakse antud funktsiooniga järsema nurgaga keeramise puhul vastava külje mootori tagurpidi liikuma panemine. Samuti optimiseeritakse roboti kiirus, et vähemalt üks mootor töötaks otsides alati maksimum kiirusel.
int max( int speed0, int speed1)
{
    char text[16];
    if (speed0<speed1)
    {
        speed0=speed0*10/speed1;
        speed1=10;
    }
    else
    {
        speed1=speed1*10/speed0;
        speed0=10;
    }
 
    if (speed0<3)
    {
        speed0= speed0 -5;
    }
    if (speed1<3)
    {
        speed1= speed1-5;
    }
 
    drive(speed0, speed1);
    //}
    return 0;
 
}
 
 
 
 
//Antud funktsiooniga tekitatakse tarkvaraline vaste PWM-le. Selle funktsiooniga pannakse sõitmiseks vajalikud mootorid tööle kiirusega 0 kuni 10. Kiirus võib ka olla negatiivne.
void drive(int speed0,int speed1)
{
 
    if (speed0 >10) speed0=10;
    if (speed1 >10) speed1=10;
    if (speed0 <-10) speed0=-10;
    if (speed1 <-10) speed1=-10;
 
    dcmotor_drive(0,0);
    dcmotor_drive(1,0);
 
    if (abs(speed0)<abs(speed1))
    {
        hw_delay_ms(abs(10-abs(speed1)));  
        if (speed1!=0)
            dcmotor_drive(1,speed1/abs(speed1));
        hw_delay_ms(abs(speed1)-abs(speed0));
        if (speed0!=0)
            dcmotor_drive(0,speed0/abs(speed0));
    }
    else
    {
        hw_delay_ms(abs(10-abs(speed0)));  
        if (speed0!=0)
            dcmotor_drive(0,speed0/abs(speed0));
        hw_delay_ms(abs(speed0)-abs(speed1));
        if (speed1!=0)
            dcmotor_drive(1,speed1/abs(speed1));
    }
 
 
    return ;
}
 
 
//See funktsioon kontrollib ultraheli anduriga ega roboti ees ei ole takistust. Takistuse esinemisel robot tagurdab ja seejärel pöörab.
void detect()
{
    unsigned short distance;
    drive(0,0);
    distance = ultrasonic_measure(pin_trigger, pin_echo);
    if (distance<30)
    {
        drive(-10,-10);
        hw_delay_ms(1000);
        drive(-5,+5);
        hw_delay_ms(450);
    }    
}
 
//Scan funktsioon vaatab ringi ja otsib kõige suurema infrapuna väärtusega suunda kuhupoole sõita.
void scan()
{
    int i= 0,sensor0=0,sensor1=0,sensor2=0,sensor3=0, max= 0, m=0;
    for( i=0; i<=300; i++)
    {
        drive(0,0);
        sensor0 = adc_get_average_value(0,40);
        sensor1 = adc_get_average_value(1,40);
        sensor2 = adc_get_average_value(2,40);
        sensor3 = adc_get_average_value(3,40);
        drive(-5,+5);
        hw_delay_ms(10);
        if (sensor0+sensor1+sensor2+sensor3>max)
        {
            max=sensor0+sensor1+sensor2+sensor3;
            m=i;
        }
 
    }
    for( i=300; i>=m; i--)
    {
        drive(5,-5);
        hw_delay_ms(10);
        drive(0,0);
 
    }
}

Solidworksis robotit kujundades ei teinud me 3D mudelit 100% valimis, ei projekteerinud lõplikult vinnastusmehhanismi, mis oli viga. See tõttu sai lõpplahenduses kannatada roboti disain, mida oleks saanud vältida lõpliku 3D mudeli koostamisel. Sammuti ülehindasime mootori momenti, sest ei arvestanud hõõrdejõudu, mis tekib balcaster’ist ning põranda eripärast, oleksime pidanud arvestama suurema varuga. Sammuti ei hinnanud õigesti jõudu, mis läheb vaja õhuskahuri vinnastamiseks. Suure momendi tõttu vahetasime mootori võimsama vastu, mis omakorda tõstis meie roboti voolu tarvet, osald mootori tõttu, teisalt suure momendi pärast. Suurem voolutarve tõttu võiks mõelda aku kasutamise peale. Meie lisasime jadamisi rohkem patareisid, mis tegelikult pole pikaajaline lahendus. Roboti suur „vaenlane“ on Päike, ilusa ilmaga tahab minna akende poole, me küll lisasime päikese sirmi, mis tegi asja natuke paremaks, aga ei ellimineerinud viga. Ilmselt aitaks kui lisada väikesed torud IR andurite ette. Viimasena võiks välja tuua, et kui ei tea mis alumiiniumit kasutada on siis ära arvasta 90⁰ painutustega, kuna alumiinum võib painutuskohtadest katki minna, nagu juhtus meie raami painutamisega.