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
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.
|
|
|
|
|
 |
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.
