Mini Tank Robot V3
0 kommentarer

Otroligt cool Mini Tank Robot från Keyestudio som erbjuder massor av underhållning, men inte minst också lärande! Det går att programmera den med Arduinos IDE men även med mixly. Dessutom kan du modulärt ersätta olika sensorer och ställdon. Så i det här lilla fallet får du något för pengarna! Videon nedan kommer att granska bara tre av de funktioner som roboten erbjuder, och samtidigt även en kort video av byggprocessen. På vår Github kan du hitta alla kodexempel för roboten , du kommer åt den här.


  • Viktig kunskap
  • APP
  • Konstruktion av tank
  • Konstruktion av tank med ultraljudssensor och fotoresistorer
  • Konstruktion av tank med Flamsensor och fläkt
  • IR fjärrkontroll
  • Ultraljudskamrat
  • Multifunktionell tank
  • Programmering med Mixly
  • Viktig kunskap

    För att programmera roboten kan det bli nödvändigt att installera en drivrutin på din Windows-dator, som säkerställer att datorn kan känna igen Arduino Uno när den är ansluten. Drivrutinen kan laddas ner här .

    Tanken har en 8x16 LED-matrisdisplay framtill, du har möjlighet att kostymera den själv, det finns en fantastisk hemsida där du enkelt kan rita det som behöver, varefter hemsidan själv omvandlar ritningen till hex-kod, som du kan implementera koden i Arduino. Hemsidan hittar du här .

    Tanken använder 2x 18650 batterier som inte ingår i paketet, dessutom ska ett CR2032 knappcellsbatteri som IR-fjärrkontrollen använder också användas. Detta kan köpas här på eBits!

    Det är möjligt att göra två generella ändringar av roboten . Du kan tänka dig att du får två robotar till priset av en robot. Ultraljud med fotoresistorer och flamsensor respektive fläkt. Bilden nedan visar de "två" robotarna

    APP

    Mini Tank Robot V3 är utrustad med en bluetooth-modul så att du kan styra tanken och dess många funktioner med telefonen. Det är möjligt att använda både Android- och Apple-telefoner. Ladda bara ner appen KeyesRobot.

    Google Play Butik

    https://play.google.com/store/apps/details?id=com.keyestudio.keyestudio

    App Store

    Öppna App Store → Sök KeyesRobot → ladda ner appen till telefonen

    När appen öppnas trycker du först på bluetooth-knappen i högra hörnet, en meny dyker nu upp där du kan ansluta till Mini Tank Robot V3 . Välj sedan roboten på bilden i mitten av skärmen. Nu presenteras du för en mängd funktioner som du kan använda för att styra roboten. Se presentationsvideon om det behövs.

    Konstruktion av tank

    Bildserien nedan granskar själva tankens konstruktion. Montera först 8x16 LED-matrisen, som skruvas fast på akrylskivan.

    Skruva sedan fast ovanstående akrylplatta med den monterade 8x16 matris-LED på akrylplattan.
    Här är Arduino Uno och motsvarande motorsköld monterade på roboten.
    När bluetooth-modulen är ansluten till motorskärmen är det viktigt att kontrollera att 5V och jord matchar mellan motorskärmen och bluetooth-modulen.
    Bilden nedan visar installationen av byglar. De kan alltid vridas 90 grader för att få motorn i fråga att gå i motsatt riktning.
    Bilden visar monteringen av motor A och -B, till motorskölden. Motor A är ansluten till höger sida om du ser roboten bakifrån och motor B är ansluten till vänster sida.


    Konstruktion av tank med ultraljudssensor och fotoresistorer

    Följande kommer att gå över inställningen av roboten med ultraljudssensorn och fotoresistorerna. Först monteras ultraljudssensorn på den böjda akrylplattan.

    Montera sedan servomotorn, här är det viktigt att servohjulet är vänt bort från ultraljudssensorn.
    src="https://cdn.shopify.com/s/files/1/0444/6932/1894/files/Skaermbilde_2022-10-11_kl._16.41.03_480x480.jpg?v=1665564224" alt="" src="https://cdn.shopify.com/s/files/1/0444/6932/1894/files/Skaermbilde_2022-10-11_kl._16.41.17_480x480.jpg?v=1665564244" alt="">

    Konstruktion av tank med Flamsensor och fläkt

    Bilderna nedan visar hur du kan byta till fläkt- och flamsensorer. Det är viktigt att notera att anslutningskablarna också måste bytas till de andra som ingår i paketet. Men var inte rädd, för de som passar fotoresistorerna passar inte i flamsensorerna.

    IR fjärrkontroll

    Följande exempel är baserat på att kunna styra roboten över infraröd. En liten fjärrkontroll ingår i paketet som använder ett litet 3V knappcellsbatteri. Dessa kan köpas från din lokala livsmedelsbutik.
    Koden nedan kommer att få dig igång, det är möjligt att köra framåt, bakåt och höger och vänster. Det är dock viktigt att två bibliotek importeras till dina bibliotek. Den kan hitta bibliotek under Dokument -> Arduino -> bibliotek.
    De två biblioteken hittar du här

     # include <IRremote.h>
     IRrecv irrecv(A2); //
     decode_results resultat; 
    lång ir_rec; // används för att spara IR-värdet
    
     //Array, som används för att spara data från bilder, kan beräknas av dig själv eller erhållas från modulverktyget 
    osignerad char start01[] = { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 , 0x80 , 0x40 , 0x20 , 0x10 , 0x10 , 0x10 , 0x10 , 0x ; 
    osignerad char front[] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x24 , 0x12 , 0x09 , 0x12 , 0x24 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0 
    osignerad char back[] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x24 , 0x48 , 0x90 , 0x48 , 0x24 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0 
    osignerat tecken kvar[ ] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x44 , 0x28 , 0x10 , 0x44 , 0x28 , 0x10 , 0x 0x 1 , 0x 0x 1 
    osignerad tecken höger[] = { 0x00 , 0x10 , 0x28 , 0x44 , 0x10 , 0x28 , 0x44 , 0x10 , 0x28 , 0x44 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0 
    osignerad char STOP01[ ] = { 0x2E , 0x2A , 0x3A , 0x00 , 0x02 , 0x3E , 0x02 , 0x00 , 0x3E , 0x22 , 0x3E , 0x00 , 0x00 , 0x } ; 
    osignerad char clear [ ] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x 0 , 0x 0 , 0x 0 , 0x 0 , 0x 0 
    # definiera SCL_Pin A5 //ställ klockstiftet till A5
     # definiera SDA_Pin A4 //ställ datastiftet till A4
    
     # definiera ML_Ctrl 4 //definiera riktningskontrollstiftet för vänster motor som 4
     # definiera ML_PWM 5 //definiera PWM-kontrollstiftet för vänster motor som 5 
    # definiera MR_Ctrl 2 //definiera riktningskontrollstiftet för den högra sensorn som 2
     # definiera MR_PWM 6 //definiera PWM-kontrollstiftet för den högra motorn som 9
    
     void setup () {
     Seriell . börja ( 9600 );
     irrecv.enableIRIn(); //initiera IR-mottagningsbiblioteket
     
    pinMode (ML_Ctrl, OUTPUT );
     pinMode (ML_PWM, OUTPUT );
     pinMode (MR_Ctrl, OUTPUT );
     pinMode (MR_PWM, OUTPUT );
    
     pinMode (SCL_Pin, OUTPUT );
     pinMode (SDA_Pin, OUTPUT );
     matrix_display( clear ); //Rensa skärmar 
    matrix_display(start01); //visa bilden av start
    
     }
    
     void loop () {
     if (irrecv.decode(&results)) { //ta emot värdet på IR-fjärrkontrollen
     ir_rec = resultat.värde;
     Strängtyp = "OKÄNDA" ; 
    String typlist[ 14 ] = { "OKNÄNDA" , "NEC" , "SONY" , "RC5" , "RC6" , "DISH" , "SHARP" , "PANASONIC" , "JVC" , "SANYO" , "MITSUBISHI" , "SAMSUNG" , "LG" , "WHYNTER" }; 
    if (results.decode_type >= 1 && results.decode_type <= 13 ) {
     typ = typlista[resultat.avkodningstyp];
     }
     Seriell . print ( "IR TYPE:" + typ + " " );
     Seriell . println (ir_rec, HEX);
     irrecv.resume();
     }
    
     switch (ir_rec) { 
    fall 0xFF629D : Car_front(); ha sönder //kommandot för att gå fram
     fall 0xFFA857 : Car_back(); ha sönder //kommandot för att gå tillbaka
     fall 0xFF22DD : Car_T_left(); ha sönder //kommandot att svänga vänster 
    fall 0xFFC23D : Car_T_right(); ha sönder //kommandot för att svänga höger
     fall 0xFF02FD : Car_Stop(); ha sönder //kommandot för att stoppa
     fall 0xFF30CF : Car_left(); ha sönder //kommandot för att rotera åt vänster 
    fall 0xFF7A85 : Car_right(); ha sönder //kommandot för att rotera åt höger
     default : break ;
     }
    
     }
    
     /******************motorn fungerar******************/
     void Car_front() {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 200 ); 
    digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 200 );
     matrix_display(front); //visa bilden för att gå fram
     }
    
     void Car_back() {
     digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, HIGH ); 
    analogWrite (ML_PWM, 200 );
     matrix_display(tillbaka); //visa bilden för att gå tillbaka
     }
    
     void Car_left() {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, HIGH );
     analogWrite (ML_PWM, 200 ); 
    matrix_display(vänster); //visa bilden för att rotera åt vänster
     }
    
     void Car_right() {
     digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 200 );
     matrix_display(höger); //visa bilden för att rotera åt höger
     }
    
     void Car_Stop() { 
    digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 0 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 0 );
     matrix_display(STOP01); //visa bilden för att stoppa
     }
    
     void Car_T_left() {
     digitalWrite (MR_Ctrl, LOW ); 
    analogWrite (MR_PWM, 255 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 150 );
     matrix_display(vänster); //visa bilden för att svänga vänster
     }
    
     void Car_T_right() {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 150 ); 
    digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 255 );
     matrix_display(höger); //visa bilden för att svänga höger
     }
    
     //denna funktion används för en punktmatris
     void matrix_display( osignerad char matrix_value[])
     {
     IIC_start(); //använd funktionen för att börja sända data
     IIC_send( 0xc0 ); //välj en adress 
    för ( int i = 0 ; i < 16 ; i++) //bilddata har 16 tecken
     {
     IIC_send(matrisvärde[i]); //data för att överföra bilder
     }
     IIC_end(); //avsluta dataöverföringen av bilder
     IIC_start();
     IIC_send( 0x8A ); //visa kontroll och välj pulsbredd 4/16
     IIC_end();
     }
    
     //villkoret att data börjar sändas
     void IIC_start()
     { 
    digitalWrite (SDA_Pin, HIGH );
     digitalWrite (SCL_Pin, HIGH );
     delayMikrosekunder ( 3 );
     digitalWrite (SDA_Pin, LOW );
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, LOW );
     }
    
     //tecknet på att överföringen av data upphör 
    void IIC_end()
     {
     digitalWrite (SCL_Pin, LOW );
     digitalWrite (SDA_Pin, LOW );
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, HIGH );
     delayMikrosekunder ( 3 );
     digitalWrite (SDA_Pin, HIGH ); 
    delayMikrosekunder ( 3 );
     }
    
     //sända data
     void IIC_send ( osignerad char send_data)
     {
     för ( byte mask = 0x01 ; mask != 0 ; mask <<= 1 ) //ecah-tecknet har 8 siffror, som detekteras en efter en
     { 
    if (send_data & mask) { //ställ in höga eller låga nivåer i ljuset av varje bit(0 eller 1)
     digitalWrite (SDA_Pin, HIGH );
     } annat {
     digitalWrite (SDA_Pin, LOW );
     }
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, HIGH ); //dra upp klockstiftet SCL_Pin för att avsluta överföringen av data 
    delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, LOW ); //dra ner klockstiftet SCL_Pin för att ändra signaler för SDA
     }
     }

    Ultraljudskamrat

    Litet roligt exempel som använder ultraljudssensorn för att följa din hand eller föremål, men samtidigt om handen eller föremålet kommer för nära kommer roboten att börja backa. Här är koden där det är möjligt att ändra önskade avstånd. Ett bra sätt att lära sig spela med ultraljudssensorer och se hur man konverterar till avstånd.

     /*
     keystudio Mini Tank Robot V3
     lektion 14 
    Ultraljudsföljningstank
     http://www.keyestudio.com
     */
     # definiera servoPin 10 //servots stift
    
     # define ML_Ctrl 4 //define definiera styrstiftet för den vänstra motorn som 4
     # definiera ML_PWM 5 //definiera PWM-kontrollstiftet för vänster motor som 5
     # definiera MR_Ctrl 2 //definiera styrstiftet för den högra motorn som 2 
    # definiera MR_PWM 6 //definiera PWM-kontrollstiftet för den högra motorn som 9
     # definiera Trig 12
     # definiera Echo 13
     flytavstånd ;
    
     void setup () {
     pinMode (servoPin, OUTPUT );
     pinMode (Trig, OUTPUT ); 
    pinMode (Echo, INPUT );
     pinMode (ML_Ctrl, OUTPUT );
     pinMode (ML_PWM, OUTPUT );
     pinMode (MR_Ctrl, OUTPUT );
     pinMode (MR_PWM, OUTPUT );
     procedur( 0 ); //ställ vinkeln på servo till 90° 
    fördröjning ( 500 ); //fördröjning på 500ms
     }
     void loop () {
     distans = checkAvstånd(); //distance tilldela avståndet som upptäcks av en ultraljudssensor
     if (avstånd >= 20 && avstånd <= 60 ) //avståndet som ska gå framåt
     {
     Car_front();
     } 
    annars om (avstånd > 10 && avstånd < 20 ) //intervallet som ska stoppas
     {
     Car_Stop();
     }
     annars om (avstånd <= 10 ) //intervallet att gå tillbaka
     {
     Car_back();
     }
     annars //eller annars, sluta
     {
     Car_Stop();
     }
     }
     void Car_front()
     { 
    digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 200 );
     }
     void Car_back()
     {
     digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, 200 ); 
    digitalWrite (ML_Ctrl, HIGH );
     analogWrite (ML_PWM, 200 );
     }
     void Car_left()
     {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, HIGH );
     analogWrite (ML_PWM, 200 );
     }
     void Car_right()
     { 
    digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, 200 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 200 );
     }
     void Car_Stop()
     {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 0 ); 
    digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 0 );
     }
    
     //en funktion för att styra servon
     void procedure( byte myangle) {
     int pulsbredd;
     for ( int i = 0 ; i < 5 ; i++) { 
    pulsbredd = myangle * 11 + 500 ; //beräkna värdet på pulsbredden
     digitalWrite (servoPin, HIGH );
     delayMikrosekunder (pulsbredd); //tiden som hög nivå upprätthåller är pulsbredd
     digitalWrite (servoPin, LOW ); 
    fördröjning (( 20 - pulsbredd / 1000 )); //Cykeln är 20ms
     }
     }
     //en funktion för att styra ultraljudssensorn
     float checkDistance() {
     statiskt flytavstånd ;
     digitalWrite (Trig, LOW );
     delayMikrosekunder ( 2 ); 
    digitalWrite (Trig, HIGH );
     delayMikrosekunder ( 10 );
     digitalWrite (Trig, LOW );
     avstånd = pulsIn (Eko, HÖG ) / 58,20 ; //2*29,1=58,2
     fördröjning ( 10 );
     retursträcka ;
     }

    Multifunktionell tank

    Här är ett exempel där många av de coola funktionerna är implementerade. Funktioner har kommenterats ut som du kan välja att använda istället. I implementeringen är det möjligt att styra roboten via bluetooth, samt komma åt fläkten, matrislysdioderna och mycket mer.
    Det är viktigt att ta bort bluetooth-modulen när du laddar upp koden nedan, annars kan fel uppstå under uppladdningen. Bluetooth-modulen kopplas sedan in igen.

     /*
     keystudio Mini Tank Robot V3
     lektion 22
     flera funktioner
     http://www.keyestudio.com
     */
     # include <IRremote.h>
     IRrecv irrecv(A2); //
     decode_results resultat; 
    lång ir_rec; //används för att spara IR-värdet
    
     //Array, som används för att spara data från bilder, kan beräknas av dig själv eller erhållas från modulverktyget 
    osignerad char start01[] = { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 , 0x80 , 0x40 , 0x20 , 0x10 , 0x10 , 0x10 , 0x10 , 0x ; 
    osignerad char STOP01[ ] = { 0x2E , 0x2A , 0x3A , 0x00 , 0x02 , 0x3E , 0x02 , 0x00 , 0x3E , 0x22 , 0x3E , 0x00 , 0x00 , 0x } ; 
    osignerad char front[] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x24 , 0x12 , 0x09 , 0x12 , 0x24 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0 
    osignerad char back[] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x24 , 0x48 , 0x90 , 0x48 , 0x24 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0 
    osignerat tecken kvar[ ] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x44 , 0x28 , 0x10 , 0x44 , 0x28 , 0x10 , 0x 0x 1 , 0x 0x 1 
    osignerad tecken höger[] = { 0x00 , 0x10 , 0x28 , 0x44 , 0x10 , 0x28 , 0x44 , 0x10 , 0x28 , 0x44 , 0x00 , 0x00 , 0x 00 , 0x 00 , 0x 00 , 0x 00 , 0x 0
     
    unsigned char leende [] = { 0x00 , 0x00 , 0x1c , 0x02 , 0x02 , 0x02 , 0x5c , 0x40 , 0x40 , 0x5c , 0x02 , 0x02 , 0x02 , 0x1c , 0x00 , 0x00 }; 
    osignerad char Avsky[] = { 0x00 , 0x00 , 0x02 , 0x02 , 0x02 , 0x12 , 0x08 , 0x04 , 0x08 , 0x12 , 0x22 , 0x02 , 0x02 , 0x02 , 0x ; 
    osignerad char Happy[] = { 0x02 , 0x02 , 0x02 , 0x02 , 0x08 , 0x18 , 0x28 , 0x48 , 0x28 , 0x18 , 0x08 , 0x02 , 0x02 , 0x 02 , 0x 02 , 0x 02 , 0x 02 , 0x 02 
    osignerad char Squint [ ] = { 0x00 , 0x00 , 0x00 , 0x41 , 0x22 , 0x14 , 0x48 , 0x40 , 0x40 , 0x48 , 0x14 , 0x20 ,x } ; 
    osignerad char Despise[] = { 0x00 , 0x00 , 0x06 , 0x04 , 0x04 , 0x04 , 0x24 , 0x20 , 0x20 , 0x26 , 0x04 , 0x04 , 0x04 , 0x04 , 0 ; 
    osignerat tecken Hjärta[ ] = { 0x00 , 0x00 , 0x0C , 0x1E , 0x3F , 0x7F , 0xFE , 0xFC , 0xFE , 0x7F , 0x3F , 0x1E , 0x000 , 0x000 , x 
    osignerade char eBits[ ] = { 0x7e , 0x52 , 0x52 , 0x00 , 0x7e , 0x4a , 0x7e , 0x00 , 0x7e , 0x00 , 0x02 , 0x7e , x 
    };
     
    osignerad char clear [ ] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x 0 , 0x 0 , 0x 0 , 0x 0 , 0x 0
     
    # definiera SCL_Pin A5 //ställ klockstiftet till A5
     # definiera SDA_Pin A4 //ställ datastiftet till A4
    
     # definiera ML_Ctrl 4 //definiera riktningskontrollstiftet för vänster motor som 4
     # definiera ML_PWM 5 //definiera PWM-kontrollstiftet för vänster motor som 5 
    # definiera MR_Ctrl 2 //definiera riktningskontrollstiftet för den högra sensorn som 2
     # definiera MR_PWM 6 //definiera PWM-kontrollstiftet för den högra motorn som 6
    
     char ble_val; //används för att spara Bluetooth-värdet
     byte hastigheter_L = 200 ; //starthastigheten för den vänstra motorn är 200 
    byte hastigheter_R = 200 ; // starthastigheten för den högra motorn är 200
     Stränghastigheter_l , hastigheter_r; //ta emot PWM-tecken och konvertera dem till PWM-värden
    
     //#define light_L_Pin D3 //definiera stiftet för den vänstra fotoresistorn
     //#define light_R_Pin A1 //definiera stiftet för den högra fotoresistorn
     int left_light;
     int right_light;
     
    int flame_L = 3 ; //definiera den analoga porten för vänster flamsensor till A0
     int flame_R = Al; //definiera den analoga porten för höger flamsensor till A1
    
     //koppla upp linjespårningssensorn
     # definiera L_pin 11 //vänster
     # definiera M_pin 7 //mitten 
    # definiera R_pin 8 //höger
     int L_val, M_val, R_val, flame_valL, flame_valR;
    
     //stiftet på 130-motorn
     int INA = 12 ;
     int INB = 13 ;
    
     //#define Trig 12
     //#define Echo 13
     flytavstånd ; //Lagra avståndsvärdena som upptäckts av ultraljud för att följa
     
    //Lagra avståndsvärdena som upptäckts med ultraljud för att undvika hinder
     int a;
     int a1;
     int a2;
    
     # definiera servoPin 10 //servoPin
    
     bool flaggor; // flagga oföränderlig, används för att gå in i och lämna ett läge
     void setup () {
     Seriell . börja ( 9600 ); 
    irrecv.enableIRIn(); //Initiera biblioteket för IR-fjärrkontrollen
    
     // pinMode(light_L_Pin, INPUT);
     // pinMode(light_R_Pin, INPUT);
    
     //definiera stiften för sensorer till INPUT
     pinMode (flame_L, INPUT );
     pinMode (flame_R, INPUT );
    
     // pinMode(Trig, OUTPUT);
     // pinMode(Echo, INPUT);
    
     pinMode (ML_Ctrl, OUTPUT ); 
    pinMode (ML_PWM, OUTPUT );
     pinMode (MR_Ctrl, OUTPUT );
     pinMode (MR_PWM, OUTPUT );
    
     pinMode (L_pin, INPUT ); //ställ stiften på linjeföljningssensorn till INPUT
     pinMode (M_pin, INPUT );
     pinMode (R_pin, INPUT );
     
    pinMode (servoPin, OUTPUT );
    
     pinMode (SCL_Pin, OUTPUT );
     pinMode (SDA_Pin, OUTPUT );
    
     pinMode (INA, OUTPUT ); //ställ INA till OUTPUT
     pinMode (INB, OUTPUT ); //ställ INB till OUTPUT
     
    matrix_display( clear ); //rensa skärmar
     matrix_display(start01); //showstart
    
     förfarande ( 90 ); //ställ vinkeln på servo till 90°
     }
    
     void loop () {
     if ( Seriell . tillgänglig ()) //om det finns data i den seriella bufferten
     {
     ble_val = Seriell . läs (); 
    Seriell . println (blöja_val);
     switch (diaper_val) {
     case 'F' : Car_front(); ha sönder //kommandot för att gå fram
    
     case 'B' : Car_back(); ha sönder //kommandot för att gå tillbaka
     
    case 'L' : Car_left(); ha sönder //kommandot för att svänga vänster
    
     case 'R' : Car_right(); ha sönder //kommandot för att svänga höger
    
     case 'S' : Car_Stop(); ha sönder //kommandot för att stoppa
     
    case 'e' : Tracking(); ha sönder //gå in i linjespårningsläget
    
     case 'f' : Confinement(); ha sönder //gå in i inneslutningsläget
    
     // case 'g': Avoid(); raster; //gå in i läget för undvikande av hinder
    
     // case 'h': Följ(); raster; //gå in i linjespårningsläget
     // case 'i': Light_following(); raster; //gå in i ljusföljande läge
     
    case 'j' : Four(); ha sönder //gå in i läget för att släcka eld
    
     case 'c' : fan_begin(); ha sönder //starta fläkten
    
     case 'd' : fan_stop(); ha sönder //stäng av fläkten
     
    case 'u' : speeds_l = Seriell . readStringUntil ( '#' ); speeds_L = String (speeds_l).toInt(); ha sönder //börja med att ta emot u, avsluta med att ta emot tecken # och konvertera till heltal
     
    case 'v' : speeds_r = Seriell . readStringUntil ( '#' ); speeds_R = String (speeds_r).toInt(); ha sönder //börja med att ta emot u, avsluta med att ta emot tecken # och konvertera till heltal
     case 'k' : matrix_display(Smile); ha sönder //visa "leende" ansikte 
    case 'l' : matrix_display(Asgust); ha sönder //visa "avsky" ansikte
     case 'm' : matrix_display(Happy); ha sönder //visa "glada" ansikte
     case 'n' : matrix_display(Squint); ha sönder //visa "Sad" ansikte 
    case 'o' : matrix_display(Despise); ha sönder //visa "föraktar" ansikte
     case 'p' : matrix_display(hjärta); ha sönder //visa heartbeat-bilden
     fall '1' : matrix_display(eBits); ha sönder //visa eBits bild 
    case 'z' : matrix_display( clear ); ha sönder // tydliga bilder
    
     default : break ;
     }
     }
     //följande signaler används för att skriva ut
     /*if(ble_val == 'x'){
     distans = checkAvstånd(); Serial.println(distans);
     fördröjning(50);
     }else if(ble_val == 'w'){
     left_light = analogRead(light_L_Pin);
     Serial.println(left_light);
     fördröjning(50);
     }else if(ble_val == 'y'){
     right_light = analogRead(light_R_Pin);
     Serial.println(right_light);
     fördröjning(50);
     }*/
    
       
    if (irrecv.decode(&results)) { //ta emot värdet som detekteras av IR-fjärrkontrollen
     ir_rec = resultat.värde;
     Seriell . println (ir_rec, HEX);
     switch (ir_rec) {
     fall 0xFF629D : Car_front(); ha sönder //kommandot för att gå fram 
    fall 0xFFA857 : Car_back(); ha sönder //kommandot för att gå tillbaka
     fall 0xFF22DD : Car_left(); ha sönder //kommandot för att rotera åt vänster
     fall 0xFFC23D : Car_right(); ha sönder //kommandot för att rotera åt höger 
    fall 0xFF02FD : Car_Stop(); ha sönder //kommandot för att stoppa
     default : break ;
     }
     irrecv.resume();
     }
    
     }
    
     /****************undvikande av hinder********************/
     /*void Undvik()
     {
     flagga = 0;
     medan (flagga == 0)
     {
     a = checkDistance(); //ställ in det främre avståndet som detekteras av ultraljudssensorn till a
     om (a < 20) {//när avståndet framtill är mindre än 20 cm
     Car_Stop(); //roboten stannar
     fördröjning(500); //fördröjning på 500ms
     förfarande (180); //servoplattformen svänger till vänster
     fördröjning(500); //fördröjning på 500ms 
    a1 = checkDistance(); //ställ in det vänstra avståndet som detekteras av ultraljudssensorn till a1
     fördröjning(100); //läsvärde
    
     procedure(0); //servoplattformen svänger till höger
     fördröjning(500); //fördröjning på 500ms
     a2 = checkDistance(); //ställ in rätt avstånd som detekteras av ultraljudssensorn till a2
     fördröjning(100); //läsvärde
    
     förfarande(90); //tillbaka till 90°
     fördröjning(500);
     if (a1 > a2) { //det vänstra avståndet är större än det högra
     Car_left(); //robotar svänger till vänster
     fördröjning(700); //sväng vänster i 700ms
     } annat {
     Bil_höger(); //robot svänger höger
     fördröjning(700);
     }
     }
     annars { //om frontavståndet ≥20cm, går roboten fram
     Car_front(); //gå fram
     }
     // ta emot Bluetooth-värdet för att lämna slingan
     if (Serial.available())
     {
     ble_val = Serial.read();
     if (ble_val == 'S') //ta emot S
     {
     flagga = 1; //ställ flaggan till 1, lämna loopen
     Car_Stop();
     }
     }
     }
     }*/
     
    /********************linjespårning******************/
     /*void Follow() {
     flagga = 0;
     while (flagga == 0) {
     distans = checkAvstånd(); //ställ avståndsvärdet till avstånd
     om (avstånd >= 20 && avstånd <= 60) //20≤ avstånd ≤60, gå fram
     {
     Car_front();
     }
     annat om (avstånd > 10 && avstånd < 20) //10< avstånd < 20, stopp
     {
     Car_Stop();
     }
     annars om (avstånd <= 10) //avstånd≤ 10, gå tillbaka
     {
     Car_back();
     }
     annars //eller annars, sluta
     {
     Car_Stop();
     }
     if (Serial.available())
     {
     ble_val = Serial.read();
     if (diaper_val == 'S')
     {
     flagga = 1; //gå ur slingan
     Car_Stop();
     }
     }
     }
     }*/
    
     /******************** lätt följe********************/
     /*void Light_following() {
     flagga = 0; 
    while (flagga == 0) {
     left_light = analogRead(light_L_Pin);
     right_light = analogRead(light_R_Pin);
     if (vänster_ljus > 650 && högerljus > 650) //gå fram
     {
     Car_front();
     }
     annars om (vänster_ljus > 650 && högerljus <= 650) //sväng vänster
     {
     Car_left();
     }
     annat om (vänster_ljus <= 650 && högerljus > 650) //sväng höger
     {
     Bil_höger();
     }
     annars //eller annars, sluta
     {
     Car_Stop();
     }
     if (Serial.available())
     {
     ble_val = Serial.read();
     if (ble_val == 'S') {
     flagga = 1;
     Car_Stop();
     }
     }
     }
     }*/
    
     /****************släcka eld********************/
     void Fire() {
     flagga = 0 ;
     while (flagga == 0 ) { 
    //läs det analoga värdet för flamsensorn
     flame_valL = analogRead (flame_L);
     flame_valR = analogRead (flame_R);
     if (flame_valL <= 700 || flame_valR <= 700 ) {
     Car_Stop();
     fan_begin();
     } annat {
     fan_stop();
     L_val = digitalRead (L_pin); //läs värdet på den vänstra sensorn
     M_val = digitalRead (M_pin); //läs värdet på den mellersta sensorn 
    R_val = digitalRead (R_pin); //läs värdet på den rätta
    
     if (M_val == 1 ) { //den mellersta upptäcker svarta linjer
     if (L_val == 1 && R_val == 0 ) { //om bara den vänstra upptäcker svarta linjer, sväng vänster
     Car_left();
     } 
    annars om (L_val == 0 && R_val == 1 ) { //om bara den högra upptäcker svarta linjer, sväng höger
     Bil_höger();
     }
     else { //gå fram annars
     Car_front();
     }
     }
     annars { //den mellersta upptäcker inte svarta linjer 
    if (L_val == 1 && R_val == 0 ) { //om bara den vänstra upptäcker svarta linjer, sväng vänster
     Car_left();
     }
     annars om (L_val == 0 && R_val == 1 ) { //om bara den högra upptäcker svarta linjer, sväng höger
     Bil_höger();
     }
     annars { //sluta annars
     Car_Stop();
     }
     }
     } 
    om ( Seriell . tillgänglig ())
     {
     ble_val = Seriell . läs ();
     if (ble_val == 'S' ) {
     flagga = 1 ;
     Car_Stop();
     }
     }
     }
     }
    
     /******************linjespårning********************/
     void Tracking() {
     flagga = 0 ;
     while (flagga == 0 ) { 
    L_val = digitalRead (L_pin); //läs värdet på den vänstra sensorn
     M_val = digitalRead (M_pin); //läs värdet på den mellersta
     R_val = digitalRead (R_pin); //läs värdet på den rätta
     if (M_val == 1 ) { //den mellersta upptäcker svarta linjer 
    if (L_val == 1 && R_val == 0 ) { //om bara den vänstra upptäcker svarta linjer, sväng vänster
     Car_left();
     }
     annars om (L_val == 0 && R_val == 1 ) { //om bara den högra upptäcker svarta linjer, sväng höger
     Bil_höger();
     }
     else { //or else, go front
     Car_front();
     }
     } 
    annars { //den mellersta upptäcker inte den svarta linjen
     if (L_val == 1 && R_val == 0 ) { //om bara den vänstra upptäcker den svarta linjen, sväng vänster
     Car_left();
     }
     annars om (L_val == 0 && R_val == 1 ) { //om bara den högra upptäcker svarta linjer, sväng höger
     Bil_höger();
     } 
    annars { //eller, sluta
     Car_Stop();
     }
     }
     om ( Seriell . tillgänglig ())
     {
     ble_val = Seriell . läs ();
     if (ble_val == 'S' ) {
     flagga = 1 ;
     Car_Stop();
     }
     }
     }
     }
    
     /****************förlossning********************/
     void Confinement() { 
    flagga = 0 ;
     while (flagga == 0 ) {
     L_val = digitalRead (L_pin); //läs värdet på den vänstra sensorn
     M_val = digitalRead (M_pin); //läs värdet på den mellersta
     R_val = digitalRead (R_pin); //läs värdet på den rätta 
    if ( L_val == 0 && M_val == 0 && R_val == 0 ) { //om ingen sensor upptäcker svarta linjer, gå framåt
     Car_front();
     }
     annars { //eller annars kan alla linjespårningssensorer gå tillbaka och svänga vänster
     Car_back();
     fördröjning ( 700 );
     Car_left();
     fördröjning ( 800 );
     } 
    om ( Seriell . tillgänglig ())
     {
     ble_val = Seriell . läs ();
     if (ble_val == 'S' ) {
     flagga = 1 ;
     Car_Stop();
     }
     }
     }
    
     }
    
    
     //han funktionen för att styra ultraljudet
     /*float checkdistance() {
     flytavstånd;
     digitalWrite(Trig, LOW);
     delayMicroseconds(2);
     digitalWrite(Trig, HIGH);
     delayMicroseconds(10);
     digitalWrite(Trig, LOW);
     avstånd = pulsIn(Echo, HÖG) / 58,20; // 2*29,1=58,2
     fördröjning(10);
     retursträcka;
     }*/
     
    //funktionen för att styra servo
     void procedure( int myangle) {
     int pulsbredd;
     pulsbredd = karta (minvinkel, 0 , 180 , 500 , 2000 ); //beräkna pulsen med värde
     for ( int i = 0 ; i < 5 ; i++) { 
    digitalWrite (servoPin, HIGH );
     delayMikrosekunder (pulsbredd); //tiden som hög nivå upprätthåller är pulsbredd
     digitalWrite (servoPin, LOW );
     fördröjning (( 20 - pulsbredd / 1000 )); //Cykeln är 20ms
     }
     }
    
     /******************fläkten roterar********************/
     void fan_begin() { 
    digitalWrite (INA, LÅG );
     digitalWrite (INB, HIGH );
     }
    
     /******************fläkten slutar rotera********************/
     void fan_stop() {
     digitalWrite (INA, LÅG );
     digitalWrite (INB, LÅG );
     }
    
    
     /******************punktmatris********************/
     ///denna funktion används för visning av punktmatris 
    void matrix_display( osignerad char matrix_value[])
     {
     IIC_start(); //använd funktionen för att börja sända data
     IIC_send( 0xc0 ); //välj en adress
     för ( int i = 0 ; i < 16 ; i++) //bilddata har 16 tecken
     {
     IIC_send(matrisvärde[i]); //data för att överföra bilder
     } 
    IIC_end(); //avsluta dataöverföringen av bilder
     IIC_start();
     IIC_send( 0x8A ); //visa kontroll och välj pulsbredd 4/16
     IIC_end();
     }
    
     //villkoret att data börjar sändas
     void IIC_start()
     {
     digitalWrite (SDA_Pin, HIGH );
     digitalWrite (SCL_Pin, HIGH );
     delayMikrosekunder ( 3 ); 
    digitalWrite (SDA_Pin, LOW );
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, LOW );
     }
    
     //sända data
     void IIC_send ( osignerad char send_data)
     { 
    för ( byte mask = 0x01 ; mask != 0 ; mask <<= 1 ) //ecah-tecknet har 8 siffror, som detekteras en efter en
     {
     if (send_data & mask) { //ställ in höga eller låga nivåer i ljuset av varje bit(0 eller 1)
     digitalWrite (SDA_Pin, HIGH );
     } annat { 
    digitalWrite (SDA_Pin, LOW );
     }
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, HIGH ); //dra upp klockstiftet SCL_Pin för att avsluta överföringen av data
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, LOW ); //dra ner klockstiftet SCL_Pin för att ändra signaler för SDA
     }
     }
     
    //tecknet på att överföringen av data upphör
     void IIC_end()
     {
     digitalWrite (SCL_Pin, LOW );
     digitalWrite (SDA_Pin, LOW );
     delayMikrosekunder ( 3 );
     digitalWrite (SCL_Pin, HIGH );
     delayMikrosekunder ( 3 ); 
    digitalWrite (SDA_Pin, HIGH );
     delayMikrosekunder ( 3 );
     }
    
     /******************motorn går******************/
     void Car_front() {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, hastigheter_R);
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, hastigheter_L); 
    matrix_display(front); //visa bilden av att gå fram
     }
    
     void Car_back() {
     digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, hastigheter_R);
     digitalWrite (ML_Ctrl, HIGH );
     analogWrite (ML_PWM, hastigheter_L);
     matrix_display(tillbaka); //visa bilden av att gå tillbaka
     }
    
     void Car_left() {
     digitalWrite (MR_Ctrl, LOW ); 
    analogWrite (MR_PWM, hastigheter_R);
     digitalWrite (ML_Ctrl, HIGH );
     analogWrite (ML_PWM, hastigheter_L);
     matrix_display(vänster); //visa bilden av att svänga vänster
     }
    
     void Car_right() {
     digitalWrite (MR_Ctrl, HIGH );
     analogWrite (MR_PWM, hastigheter_R);
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, hastigheter_L); 
    matrix_display(höger); //visa bilden av att svänga höger
     }
    
     void Car_Stop() {
     digitalWrite (MR_Ctrl, LOW );
     analogWrite (MR_PWM, 0 );
     digitalWrite (ML_Ctrl, LOW );
     analogWrite (ML_PWM, 0 );
     matrix_display(STOP01); //visa stoppbilden
     }

    Programmering med Mixly

    Som nämnt går det även att programmera med Mixly, som mer handlar om att bygga med byggstenar. Ett riktigt bra inträde i programmeringsvärlden. Programmet måste laddas ner och installeras på din PC.

    Windows https://www.dropbox.com/s/mb3vxcn30jwvwxv/Mixly%20for%20windows.7z?dl=0
    MAC https://www.dropbox.com/s/gcllwqpquwyy77c/Mixly_for_keyestudio_MacOS.zip?dl=0

    När du har laddat ner programmet är det viktigt att Arduino UNO väljs som styrelse.

    Bilden nedan visar hur ett enkelt blinkprogram ser ut när det byggs upp i Mixly.

    Du kan hitta kodexempel med hjälp av Mixly för programmering på vår GitHub, länken finns här.
    För att få en bra och heltäckande introduktion till användningen av Mixly föreslår vi att du tittar på följande dokumentation.

    Skriv en kommentar!

    Relevanta produkter

    TS101 digital loddekolbeTS101 digital loddekolbe i hånd
    TS101 digital lödkolv med USB C-försörjning
    Erbjudande prisFrån 1 113 kr
    14 i lager
    TS80P USB-C Loddekolbe kitTS80P Loddekolbe
    TS80P USB-C mini Lödpenna sats
    Erbjudande prisFrån 1 272 kr
    2 i lager
    bruge Loddekolbe Renser til at rengøre loddekolbespidsenLoddekolbe Renser
    Lyxigt rengöringsmedel för lödkolv
    Erbjudande pris142 kr
    8 i lager