Koodi selgitused:

1. testimiseks saate USB kaudu arvutist käske saata;
2. mootorite pöörlemine akuga ühendamisel on erinev;
3. saate mootoritega ise määrata pöörlemiskiiruse.

Pärast masina töö kontrollimist installige rakendus oma nutitelefoni või tahvelarvutisse. Kui loote esmakordselt ühenduse Bluetooth-mooduliga HC-05/06, peate siduma Androidiga (siis toimub sidumine automaatselt). Kui teil on ühenduse loomisega raskusi, lugege seda artiklit

Selles artiklis käsitleme Arduino ühendamist ja juhtimist Bluetoothi ​​​​kaudu.

Laialdaselt kasutatavat HC-06 hakatakse kasutama Bluetooth-moodulina.

Meie projektis lülitame sisse ja välja Bluetoothi ​​kaudu pordiga 13 ühendatud LED-i.

Alustame Androidi nutitelefoni rakenduse kirjutamisega. Rakendus kirjutatakse mugavas ja lihtsas programmeerimiskeskkonnas App Inventor. Programmid koostatakse veebis.

Järgige linki http://ai2.appinventor.mit.edu/. Seal palutakse teil sisse logida Google'i kontole, mille peate looma, kui teil seda veel pole.

Pärast sisselogimist suunatakse teid programmi, kus saate luua projekti, klõpsates nuppu "alusta uut projekti". Peate sisestama projekti nime. Nimetagem seda led_controliks.

Avaneb tühi rakenduse aken.

Siin asetame vajalikud komponendid. Valige vasakpoolsest aknast ListPicker ja pukseerige see projekti.

Parempoolses aknas oleva ListPickeri komponendi jaoks leidke atribuut Text ja muutke "Text for ListPicker1" väärtuseks "Valige BT-seade".

Avage vasakpoolses aknas vahekaart Layout, asetage rakendusse komponent HorizontalArrangement, muutke selle atribuudiks Width väärtuseks "Täida ema". Lisage horisontaalpaigutusele 2 nuppu, määrake igaühe atribuudiks Width väärtuseks "Täida ema". See peaks välja nägema selline:

Muudame nuppudel silte: esimene ütleb LED ON, teine ​​LED OFF.

Allpool lisame sildi ja tühjendame selle teksti.

Jääb vaid lisada komponent, mis korraldab andmeedastust Bluetoothi ​​kaudu. Avage vahekaart Ühenduvus ja asetage projekti BluetoothClient. See komponent ei ilmu telefoni ekraanile, vaid selle alla, sest see pole visuaalne.

Nüüd saate alustada programmi kirjutamist. Valige programmi paremas ülanurgas režiim Blocks.

Siin koostatakse programm graafikaplokkidest. Vasakul klõpsake komponendil ListPicker1 ja valige ListPicker1.BeforePicking.

Klõpsake uuesti ListPicker1 ja valige Seadista ListPicker1.Elements

Asetage see nagu ekraanipildil.

See annab meile loendi seotud Bluetooth-seadmetest. Nüüd loome ühenduse valitud seadmega. Kirjutage plokk nagu alloleval ekraanipildil.

Roosa plokk sildiga Ühendatud on esimene plokk vahekaardil Tekst. Sisestage tühjale väljale Connected.

Nüüd kirjutame nupukäitleja. Kui klõpsate esimesel nupul, saadetakse tekst "led_on" ja teisele klõpsates saadetakse "led_off". Samuti muutub silt Label1-s.

Jääb vaid projekt nutitelefoni alla laadida. Klõpsake nuppu Ehitamine ja valige allalaadimisviis.

Esimese valiku jaoks on teil vaja Internetti ja QR-koodi lugejat. Klõpsake ja oodake, kuni projekt on kokku pandud ja QR-kood genereeritud, seejärel avage nutitelefonis QR-koodi lugeja ja lugege koodi. Jääb vaid fail alla laadida ja installida.

Teise variandi puhul salvestatakse projekt .apk formaadis arvutisse ja saad selle igal mugaval viisil (näiteks USB kaudu) oma nutitelefoni alla laadida.

Nüüd alustame Arduino programmiga.

Andmete vastuvõtmine ja edastamine toimub COM-pordi kaudu, seega kasutame jada. Võtame signaale vastu tähemärgi haaval, moodustame stringi ja võrdleme genereeritud stringi led_on ja led_off käskudega.

Arduino

String val = ""; void setup() ( Serial.begin(9600); pinMode(13, OUTPUT); ) void loop() ( while (Serial.available()) ( //while andmed saabuvad char c = Serial.read(); // loe neid val += c //ja moodusta stringi viivitus (3) ( Serial.println(val); ) if (val == "led_on") ( digitalWrite(13, HIGH); ) else if (val == "led_off") ( digitalWrite(13, LOW); ) val = "" )

Laadige kood üles Arduinosse.

Nüüd saate ühendada Bluetooth-mooduli HC-06. See ühendab väga lihtsalt:

Vcc 5v (3,3 V võimalik)

KUI ÜHENDATUD MOODULIGA PROGRAMMI ARDUINOsse LAADIDA, TULEB VÄLJA VIGA, SEST NII MOODUL KUI PROGRAMMI LADIMINE KASUTAVAD RX- JA TX-PORTE!

Rakendage Arduinole toide. Bluetooth-mooduli LED-tuli peaks vilkuma, see tähendab, et see ootab ühendust. Võtke nutitelefon, leidke seadetest bluetooth, lülitage see sisse ja alustage otsimist. Otsige üles seade nimega hc-06 ja looge sellega ühendus. See ei pruugi esimesel korral õnnestuda. Pärast ühekordset edukat sidumist saate programmi oma nutitelefonis käivitada.

Esmalt klõpsake "Vali BT-seade" ja valige seotud seadmete hulgast moodul. Järgmisena vajutage LED-i sisse- ja väljalülitusnuppe. Kui kõik on õigesti tehtud, siis kõik toimib.

Tegime Bluetoothi ​​abil väga lihtsa rakenduse, ilma disainita või isegi kontrollimata, kas oleme mooduliga ühendatud või mitte. Järgmistes tundides teeme keerukamaid rakendusi ja tutvume paremini App Inventoriga.

Ja tööta temaga koos.

Mootori kilbi uuendamine

Selgus, et Motor Shield mooduli tootjad võtsid oma klientidelt võimaluse paigaldada oma toote peale teine ​​moodul. Ilmselt meeldib neile peal olla või lihtsalt tavalist kontaktpaneeli pigistada.

See nüanss mulle üldse ei sobi. Seetõttu otsustasin jootekolvi kätte võtta ja Motor Shieldi enda jaoks sobivasse vormi viia.

Rebisin ettevaatlikult originaalkontaktipesad välja ja viskasin minema.

Nende asemele paigaldasin tavalised.

Sellisel kujul on moodul muutunud palju mugavamaks kasutamiseks. Nüüd saan Bluetoothi ​​juhtmed korralikult pistikutega ühendada, mitte jootma neid tihedalt mootorikilbi kontaktidega.

Bluetoothi ​​moodul JY-MCU Arduino jaoks

JY-MCU Bluetoothi ​​moodul ise on üsna pisike. Tarnekomplekt sisaldab ühenduskaablit. Nõelte määramised on näidatud tagaküljel.

Seda saab toita 3,6-6V toiteallikast. See annab meile võimaluse ühendada see otse Arduinoga ilma regulaatorit või pingejaoturit kasutamata.

Seadmega ühendamisel kasutatav kood: 1234.

Bluetooth JY-MCU ühendamine Arduino Mega 2560-ga

Ühendus on üsna lihtne.

Ametlik ühendusskeem:

• JY-MCU TXT ühendage Arduino RX-iga (0).
• Ühendage JY-MCU RXD Arduino TX-ga (1).

Selle ühendusvalikuga peate iga kord enne visandi laadimist Bluetooth-mooduli toite välja lülitama. Ärge unustage seda.

Ma ei ole selle valikuga rahul, seetõttu otsustasin kasutada jadatoega diskreetseid porte.

Mitteametlik ühendusskeem:

• JY-MCU VCC on ühendatud +5V Arduinoga
• Ühendage JY-MCU GND GND Arduinoga
• JY-MCU TXT on ühendatud Arduino diskreetse PIN-koodiga 50
• Ühendage RXD JY-MCU-ga, et luua Arduino diskreetne PIN-kood 51

Nüüd saate visandeid üles laadida ilma Bluetooth-mooduli toite välja lülitamata.

Bluetoothi ​​turvalisuse tagamiseks otsustasin kasutada Proto Shieldi plaati ja miniatuurset jooteta leivalauda. Edaspidi ühendan sellega muud seadmed, juhtnupud ja näidikud.

Sketš roboti juhtimiseks Arduinos Bluetoothi ​​kaudu Androidi nutitelefoni kaudu

Oma visandis rakendasin järgmisi funktsioone:

• Edasi liikumine
• Tagurpidi liikumine
• Pööra vasakule
• Pööra paremale
• Edasiliikumisel sujuv vasakpööre
• Edasiliikumisel sujuv parempööre
• Tagurpidi liikumisel sujuv vasakpööre
• Tagurpidi liikumisel sujuv parempööre
• Peatus

Kiiruse seadistus 0%

Kiiruse seadistus 10%

Kiiruse seadistus 20%

Kiiruse seadistus 30%

Kiiruse seadistus 40%

Kiiruse seadistus 50%

Kiiruse seadistus 60%

Kiiruse seadistus 70%

Kiiruse seadistus 80%

Kiiruse seadistus 90%

Kiiruse seadistus 100%

Kasutasin sketšis funktsioone, et mitte dubleerida sarnaste sündmuste koodi.

#kaasa // Ühendage mootori juhtimisteek
#kaasa // Ühendage servode raamatukogu
#kaasa // Ühendage raamatukogu diskreetsete portide kaudu jadaga töötamiseks

//Mootorite jaoks objektide loomine
AF_DCMootori mootor1(1); //kanal M1 mootorikilbil – tagumine vasak
AF_DCMootori mootor2(2); //kanal M2 mootorikilbil – taga paremal
AF_DCMootori mootor3(3); //kanal M3 mootorikilbil – ees vasak
AF_DCMootori mootor4(4); //kanal M4 mootorikilbil – ees paremal

// Servo jaoks objekti loomine
Servo vsservo;

SoftwareSerial BTSerial(50, 51); // RX, TX

// Bluetoothi ​​käskude jaoks muutuja loomine
char vcmd;
// Looge muutujad mootorite kiiruste meeldejätmiseks
int vspdL, vspdR;
/* Loo muutuja, mille väärtus vähendab sujuvate pöörete ajal kiirust.
Praegune kiirus peab olema sellest väärtusest suurem. Vastasel juhul pöörlemissuunas olevad mootorid lihtsalt ei pöörle */
int vspd = 200;

void setup() (
// Bluetoothi ​​andmeedastuskiiruse määramine
BTSerial.begin(9600);
// Määrake andmeedastuskiirus kaabli kaudu
Serial.begin(9600);
// Valige viik, millega servo on ühendatud
vservo.attach(9); // või 10, kui see on ühendatud välimisesse pistikupessa
// Pöörake servot iga kord, kui see sisse lülitate, 90 kraadi
vservo.write(90);
// Määrake mootorite maksimaalne pöörlemiskiirus
vspeed(255 255);
}

void loop() (
// Kui andmeid on
kui (BTSerial.available())
{
// Lugege käske ja pange need muutujasse. char teisendab käsu märgi koodi märgiks
vcmd = (char)BTSerial.read();
// Saada pordile käsk, et neid saaks "Port Monitoris" kontrollida
Serial.println(vcmd);

// Edasi
if (vcmd == "F") (
vforward();
}
// Tagasi
if (vcmd == "B")
{
vbackward();
}
// Vasak
if (vcmd == "L")
{
vleft();
}
// Õige
if (vcmd == "R")
{
vright();
}
// Otse ja vasak
if (vcmd == "G")
{
vforwardleft();
}
// Otse ja õige
if (vcmd == "I")
{
vforwardright();
}
// Tagasi ja vasakule
if (vcmd == "H")
{
vbackwardleft();
}
// Tagasi ja paremale
if (vcmd == "J")
{
vbackwardright();
}
// Peatu
if (vcmd == "S")
{
vrelease();
}
// Kiirus 0%
if (vcmd == "0")
{
vspeed(0,0);
}
// Kiirus 10%
if (vcmd == "1")
{
vspeed(25,25);
}
// Kiirus 20%
if (vcmd == "2")
{
vspeed(50,50);
}
// Kiirus 30%
if (vcmd == "3")
{
vspeed(75,75);
}
// Kiirus 40%
if (vcmd == "4")
{
vspeed(100,100);
}
// Kiirus 50%
if (vcmd == "5")
{
vspeed(125,125);
}
// Kiirus 60%
if (vcmd == "6")
{
vspeed(150,150);
}
// Kiirus 70%
if (vcmd == "7")
{
vspeed(175 175);
}
// Kiirus 80%
if (vcmd == "8")
{
vspeed(200 200);
}
// Kiirus 90%
if (vcmd == "9")
{
vspeed(225 225);
}
// Kiirus 100%
if (vcmd == "q")
{
vspeed(255 255);
}
}
}

// Edasi
void vforward() (
vspeed(vspdL,vspdR);
vforwardRL();
}

// Edasi RL-ile
void vforwardRL() (
motor1.run(FORWARD);
motor2.run(FORWARD);
motor3.run(FORWARD);
motor4.run(FORWARD);
}

// Tagasi
void vbackward() (
vspeed(vspdL,vspdR);
vbackwardRL();
}

// Tagasi RL-i
void vbackwardRL() (
motor1.run(TAGASI);
motor2.run(TAGASI);
motor3.run(TAGASI);
motor4.run(TAGASI);
}

// Vasak
void vleft() (
vspeed(vspdL,vspdR);
motor1.run(TAGASI);
motor2.run(FORWARD);
motor3.run(TAGASI);
motor4.run(FORWARD);
}

// Õige
tühine vright() (
vspeed(vspdL,vspdR);
motor1.run(FORWARD);
motor2.run(TAGASI);
motor3.run(FORWARD);
motor4.run(TAGASI);
}

// Edasi ja vasakule
void vforwardleft() (
if (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
muidu
{
vspeed(0,vspdR);
}
vforwardRL();
}

// Edasi ja paremale
void vforwardright() (
if (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
muidu
{
vspeed(vspdL,0);
}
vforwardRL();
}

// Tagasi ja vasakule
void vbackwardleft() (
if (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
muidu
{
vspeed(0,vspdR);
}
vbackwardRL();
}

// Tagasi ja paremale
void vbackwardright() (
if (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
muidu
{
vspeed(vspdL,0);
}
vbackwardRL();
}

// Peatu
tühine vrelease())(
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
}

// Muuda kiirust
void vspeed(int spdL,int spdR)(
if (spdL == spdR) (
vspdL=spdL;
vspdR=spdR;
}
motor1.setSpeed(spdL);
motor2.setSpeed(spdR);
motor3.setSpeed(spdL);
motor4.setSpeed(spdR);
}

Bluetooth RC Car programm - robotauto juhtimine Android nutitelefonist

Installisin oma nutitelefoni Bluetooth RC Car programmi. Minu arvates on see parim tarkvara robotauto juhtimiseks.

Programm võimaldab teil edastada käske, kui vajutate nuppe või reageerite nutitelefoni kiirendusmõõturi andmetele, reguleerige liuguriga liikumiskiirust, lülitage sisse esi- ja tagatuled, lülitage sisse ja välja helisignaal, lülitage sisse ja välja hädasignaal.

Programm nõuab Androidi versiooni 2.3.3 või uuemat. Programmi suurus on 3 megabaiti.

Käskude loend:

• F – edasi
• B – tagasi
• L - vasakule
• R – õige
• G – otse ja vasak
• Mina – otse ja paremale
• H – tagasi ja vasakule
• J – tagasi ja paremale
• S – peatus
• W – esituled sisse lülitatud
• w – esituli on välja lülitatud
• U – tagatuli põleb
• u – tagatuli on välja lülitatud
• V – helisignaal on sisse lülitatud
• v – helisignaal on välja lülitatud
• X – hädaabisignaal on sisse lülitatud
• x - hädaabisignaal on välja lülitatud
• 0 – liikumiskiirus 0%
• 1 – liikumiskiirus 10%
• 2 – liikumiskiirus 20%
• 3 – liikumiskiirus 30%
• 4 – liikumiskiirus 40%
• 5 – liikumiskiirus 50%
• 6 – liikumiskiirus 60%
• 7 – liikumiskiirus 70%
• 8 – liikumiskiirus 80%
• 9 – liikumiskiirus 90%
• q – liikumiskiirus 100%

Nagu näete, on loovuse proovikivi üsna hea. Lisaksin ka võimaluse panna eraldi sisse parem ja vasak tuled esi- ja tagatuledele.

Olen esile tõstnud paksus kirjas käsud, mida visandis juba toetatakse. Ülejäänu kasutan mõnel muul otstarbel.

Käskude edastamise põhimõte: programmis nuppu vajutades edastatakse käsk Bluetoothi ​​kaudu üks kord ja nupu vabastamisel koheselt S-stopp käsk.

Töö demonstreerimine

Järgmisel korral plaanin robotiga ühendada ultraheli kaugusmõõtja ja rakendada takistuste vältimise algoritmi.

Ärgem ostkem hiinlastelt halbu mänguasju, vaid ostkem neilt odav ehituskomplekt-šassii, paar moodulit ja paneme käed külge!

Selle ma lõpuks sain: läbitav šassii, juhitav - TA-DA!!! - minu Android nutitelefonist.

Täna ehitame Bluetoothi ​​kaudu kaugjuhtimispuldiga naljaka auto. Kaasas Androidi juhtimisprogrammi allikad.

Korralik näide mänguasjast

Miks nii? Ilmselt sellepärast, et see saag müüdi STIHLi tööriistapoes. Usun, et STIHL tegi oma toodetest väikeses reklaamväljaandes mänguasja analoogi. Selle tulemusena sündis täiesti terve mõistusega mänguasi, mis on väga sarnane oma vanemale vennale. Kummist kett pöörleb, 80 protsenti juhtnuppudest on rakendatud. Seal on isegi käepidemega juhe sae kerimiseks, lüliti ja gaasinupp. Komplektis on varukett ja tööriist keti vahetamiseks.

Siin on mängusaag

Millest ma räägin? Oh jah, arhitektuurist! Pean silmas seda, et kui soovite, saate teha suurepärase mänguasja. Ja on, millele otsa vaadata.

Ehitame puldiga auto!

Ühel ilusal päeval lõpetas ühe auto parem ratas pöörlemise. Võtsin lahti ja kontrollisin mootorit - töötas.
Juhtplaadil on kolm mikrolülitust - Hiina on loll, ma ei leidnud mõistlikku dokumentatsiooni. Üks kiip on raadiosignaali vastuvõtja, millel on loogilised väljundid ja kaks sillamootori draiverit. Üks juhtidest on ebaõnnestunud. Ma ei saanud kohe diskreetsetest komponentidest sillamootori draiverit kokku panna.

Kohalikus raadioosade poes polnud midagi sobivat. Nii ma läksin kaugetesse riikidesse imeliste mikroskeemide järele. Korjasin oma asjad kokku, täitsin taskud kreekeritega, valasin tassi kohvi, käivitasin brauseri ja läksin... .
Leidsin parameetritele vastava mootoridraiveri ja tellisin kaks korraga. Igaks juhuks äkki on mõni vigane või põletan end ära. Siis hakkas tekkima idee oma autost. Pärast seda, kui pakk kuulsusrikkast Hiinast saabus, vahetasin edukalt juhi välja ja masin saigi remonditud.

Oma auto ideed riiulile jätmata valisin taas aluse - tulevase auto šassii. Šassiid on maismaatranspordi jaoks erinevad: roomik-, ratas-, kahe-, kolme-, neljarattalised jne.

Kuidas ma šassii valisin

Mõtete ja lähteülesannete soo

Mida me vajame masina kokkupanekuks?

Kokku:šassii + juhtplaat + Bluetooth moodul + juhtprogramm Androidile.

Üldine ühendusskeem

Skeem Proteuses

Mikrokontrolleri programm

Kood on piisavalt kommenteeritud. Eraldi tahaksin peatuda oma andmevahetuse rakendamisel.
Ma saan andmeid helipuhvri kaudu. Asi pole uus ja teostusi on palju.

Olen paigutanud helipuhvri funktsioonid eraldi teeki, mis koosneb:
päisefail ring_buffer.h ja funktsiooni rakendusfail ring_buffer.c
Teegi kasutamiseks peate selle lisama kausta main.c
#include "ring_buffer.h"

Järgmisena peate päisefailis konfigureerima teegi. Konfigureerimiseks peate määrama ainult neli direktiivi:
#define RX_PACKET_SIZE 7 // RxD paketi suurus #define BUFFER_SIZE 16 // Vastuvõtupuhvri suurus. Peab olema kaks korda suurem kui RX_PACKET_SIZE #define START_BYTE "s" // Algbait #define STOP_BYTE "e" // Lõpeta bait

Tegelikult pole enam midagi seadistada.

Koodi kasutamine Main.c-s konfigureerime mikrokontrolleri USART-i.
USART konfiguratsioonifunktsiooni helistamine
USART_Init(MYUBRR);

#define BAUD 9600 #define MYUBRR F_CPU/16/BAUD-1 void USART_Init(unsigned int ubrr) ( /* Määra boodikiirus */ UBRRH = (unsigned char)(ubrr >> 8); UBRRL = (signed char)ubrr; /* Luba vastuvõtja ja saatja */ UCSRB = (1<< TXCIE) | (1 << RXCIE)| (1 << TXEN) | (1 << RXEN); /* Set frame format: 8data, 2stop bit */ UCSRC = (1 << URSEL) | (0 << USBS) | (3 << UCSZ0); }

Andmepaketi vastuvõtmine

Nüüd jääb meil vaid aeg-ajalt puhvrit kontrollida. Selleks käivitasin taimeri, milles panin lipu, mis võimaldab helipuhvrit kontrollida
ISR(TIMER0_OVF_vect) ( TCNT0 = 0x64; ReadRingBuffer = 1; )

Põhitsüklisse lisame tingimuse lipu kontrollimiseks.
if (ReadRingBuffer) ( if (RB_read_buffer((uint8_t*)&RxPacket) == 1) Puhvri lugemine ( // Parsi paketti, tee midagi ) ReadRingBuffer = 0; )

Funktsioon RB_read_buffer kontrollib rõngaspuhvrit, kui paketi suurus, algus- ja lõppbaidid on paigas - pakett loetakse kehtivaks, funktsioon tagastab argumendina "1".
Suurema usaldusväärsuse huvides võib paketi varustada kontrollsummaga ühes minu kommertsprojektis. See tähendab, et lisaks suuruse ja start/stop baitide kontrollimisele lisatakse ka kontrollsumma kontroll. Aga praegu saame ilma selleta hakkama.

Kuidas pakendit lahti võtta

Minu vastuvõtupakett on organiseeritud struktuuri kujul.
struct RxPacket ( uint8_t StartByte; uint8_t käsk; int16_t Left_PWM; int16_t Right_PWM; uint8_t StopByte; ) RxPacket;

Funktsiooni kutsumine RB_read_buffer ((uint8_t*)&RxPacket ), argumendina edastame vastuvõtva paketi struktuurile osuti. See tähendab, et kui pakett on vastu võetud, sorteeritakse kõik RxPacketi struktuuris oma kohtadesse. Siis jääb üle vaid need andmed struktuurist lugeda, näiteks nii:
lCmd = RxPacket.Command; lLPWM = RxPacket.Left_PWM; lRPWM = RxPacket.Right_PWM;

Andmepakettide edastamine

Kus on algus- ja lõppbait ning teabeosa. Oleme USART-vastuvõtja juba lähtestanud.
Pakettedastuse algatamiseks helistage funktsioonile
void send_packet() ( // Kirjutage algusbait UDR-i registrisse UDR = START_BYTE; )
Selles näites kirjutan selles funktsioonis UDR-i registrisse ainult algusbaidi. See ei tundu palju, kuid samas funktsioonis saate rakendada pakendi ettevalmistamist või midagi muud kasulikku. Ja see on minu arvates loogilisem. See on isedokumenteeriva koodi mõttes mõistlik. See tähendab, et kui olen koodis, siis kirjutan lihtsalt väärtuse UDR-registrisse, seda võib tajuda kui ühe baidi ülekandmist ja isekõneleva funktsiooni väljakutsumist. send_packet()- Ma räägin sellest, et saadan andmepaketi.

Järgmisena, kui USART-saatja saadab UDR-registrist kogu baidi, kutsutakse välja edastuskatkestuse töötleja.
ISR(USART_TXC_vect) ( unsigned char * Pointer = (signed char *)&(TxPacket); staatiline märgita märk TxIndex = 1; if (TxIndex< sizeof(TxPacket)) { UDR = *(Pointer + TxIndex); TxIndex++; } else TxIndex = 1; }

Käitlejas deklareerin kursori muutuja ja määran sellele TxPacketi struktuuri aadressi. Järgmisena deklareeritakse staatiline muutuja - edastatud baidi indeks, millele deklareerimisel omistatakse väärtus 1 . Alustame ühega, sest oleme struktuurist esimese baidi juba saatnud. Üldiselt saab struktuur ilma algusbaidita nagunii hakkama, saadan selle eraldi, aga selle baidi deklaratsioon jäetakse struktuuris aru, kuidas pakett välja näeb.

Tingimus, kui (TxIndex< sizeof(TxPacket)) проверяет, что индекс меньше чем размер пакета. Если условие верно, то записываем байт в регистр UDR: UDR = *(Pointer + TxIndex);
TxIndexi juurdekasv. Kui USART edastab järgmise baidi, jõuame jälle käitlejasse, kuid edastatakse struktuurist järgmine bait ja nii edastatakse kõik struktuuri baidid. Kui TxIndex on suurem kui struktuuri suurus, ei ole tingimus tõene ja saame tulemuseks muidu TxIndex = 1; Kus TxIndex initsialiseeritakse, kuid UDR-registrisse ei kirjutata midagi, nii et töötlejat ei kutsuta enam enne, kui on algatatud järgmine paketiedastus. Seega on edastusprotsess täiesti automaatne ja isegi kui muudame paki struktuuri, ei pea käitlejat ümber kirjutama.

MK programmi kirjelduse raames jääb üle rääkida autojuhtide juhtimise rakendamisest. Juhti juhivad kolm signaali: A1 (B1), A2 (B2) ja PWMA (PWMB). A1 ja A2 on mõeldud draiveri sisse/välja lülitamiseks ja väljundi polaarsuse muutmiseks. PWMA-sisendisse suunatakse MK-st saadav PWM-signaal - saate reguleerida pöörlemiskiirust. PWM-signaali jaoks kasutasin kahte riistvaralist PWM-taimerit 1.
#define _WGM13 0 #define _WGM12 1 #define _WGM11 0 #define _WGM10 1 // Taimer 1 init TCCR1A = (1<< COM1A1) | (0 << COM1A0) | (1 << COM1B1) | (0 << COM1B0) | (_WGM11 << WGM11) | (_WGM10 << WGM10); TCCR1B = (0 << CS12) | (0 << CS11) | (1 << CS10) | (_WGM13 << WGM13) | (_WGM12 << WGM12); TCNT1 =0x0000; OCR1A = 0; OCR1B = 0;

Taimer on 16-bitine, kuid PWM on lähtestatud 8-bitiseks. Ja nagu te ilmselt juba märkasite, on mul vastuvõtvas paketis kaks väärtust PWM-i seadistamiseks, vastavalt vasaku ja parema draivi jaoks. Signeeritud muutujad on 16-bitised.
Ma selgitan, miks ma seda tegin.

Esiteks, tuli see Androidi programmist. Fakt on see, et Javas pole ühtegi signeeritud tüüpi ja ma olen selle reha otsa juba astunud. Ja numbrite 0–255 edastamiseks peaksin kuidagi kõrvale hiilima. Otsustasin valida lihtsama tee – saadan allkirjastatud 16-bitise numbri. Samas on signeeritud tüüpi 16 bitti vahemikus -32786 kuni 32768, mis on meile piisav.

Teiseks, minu arvates on see läbipaistvam - pöörlemiskiirust ja suunda kirjeldab vaid üks muutuja.

Ja kolmandaks, mida iganes võib öelda, meie eesmärkidel on võimatu hoida seda vähem kui kolmes baidis. Ohverdame veel ühe baidi, aga kõik saab selgeks: positiivne PWM väärtus tähendab edasipööret, negatiivne väärtus vastupidist pöörlemist.

Draivide juhtimiseks kirjutasin funktsiooni drive(int vasakPWM, int paremPWM);.
void drive(int leftPWM, int rightPWM) ( // Liiguta EDASI vasak ratas if (leftPWM > 0)( ClearBit(A2_PORT, A2_PIN); SetBit(A1_PORT, A1_PIN); ) // Liiguta TAGASI vasak ratas if (leftPWM< 0){ ClearBit(A1_PORT, A1_PIN); SetBit(A2_PORT, A2_PIN); } // Движение ВПЕРЁД правое колесо if (rightPWM >0)( ClearBit(B2_PORT, B2_PIN); SetBit(B1_PORT, B1_PIN); ) // Liiguta TAGASI parem ratas if (rightPWM< 0){ ClearBit(B1_PORT, B1_PIN); SetBit(B2_PORT, B2_PIN); } // Остановка if (leftPWM == 0){ ClearBit(A1_PORT, A1_PIN); ClearBit(A2_PORT, A2_PIN); } // Остановка if (rightPWM == 0){ ClearBit(B1_PORT, B1_PIN); ClearBit(B2_PORT, B2_PIN); } set_PWM((uint8_t)(abs(leftPWM)), (uint8_t)(abs(rightPWM))); }
Vastavalt PWM väärtusele juhitakse signaale A1 (B1), A2 (B2) ja PWM väärtus määratakse funktsiooni kutsumisega. set_PWM(vasakPWM, paremPWM).

Uff, mul läheb hingetuks...
Kokkuvõtteks: võttis paketi vastu, sõelus selle, edastas funktsioonile PWM-i väärtuse sõita.

Androidi rakendus autodele

Programmi põhifunktsioon- andmete edastamine moodulile HC-06 Bluetoothi ​​kaudu. Programmil on lihtne liides.

Ülaosas on mooduli valimiseks seotud Bluetooth-seadmete rippmenüü. Alguses seda loendit seal ei olnud, kuid artikli kallal töötamise lõpus otsustasin seda teha inimlikult, sest kõik ei saa lähtekoodist aru.

Järgmisena lülitab nupp "Väljas" sisse/välja side seadmega "HC-06". All vasakult paremale: vasaku kanali edastatud PWM väärtus, anduri tüüp, parempoolse kanali väärtus. Allpool on kaks liugurit kiiruse ja pöörlemistundlikkuse reguleerimiseks.

Programm rakendab kahte tüüpi masina juhtimist. Anduri tüübi vahetamiseks peate puudutama anduri nime: "Tilt" või "Shuffle".

1. Juhtige masinat telefoni kallutades. Telefoni nullasend on horisontaalne. Kui telefon on ette kallutatud, suureneb PWM väärtus proportsionaalselt kaldega vahemikus 0 kuni 255. Kui kallutate telefoni tagasi, väheneb PWM väärtus proportsionaalselt kaldega vahemikus 0 kuni -255

2. Puutejuhtimine. Minu kaubanimi seda tüüpi juhtseadise jaoks on "shuffle".

Kellasid ja vilesid pole. See näib olevat kõik.

Väike kärbseseen “suuskadel”

Kokkuvõte

Veel on ruumi tegutsemiseks, on ruumi kasvada. Saate kohandada šassiid, saate uuendada ja täiustada oma telefoni tarkvara.
Ja sellele tuleb jätk!

Selles materjalis soovitame õppida, kuidas saate kodus raadio teel juhitavat autot valmistada.

Masina valmistamiseks vajame:
- mänguauto;
- kaks Arduino Uno kaarti;
- kaks NRF24 raadiomooduli plaati;
- kondensaator 470 mF, 25 volti;
- L298N mootori juhiplaat;
- mootor;
- servoajam;
- analoogjuhtkang;
- laetavad akud;
- kroonpatarei;
- kaks sisse- ja väljalülitusnuppu;
- raam.

Esimene samm on kondensaatori jootmine raadiomooduli toitekontaktide külge. Samuti peate esmalt kokku panema akud, et saada mootori ja Arduino plaadi toiteks 12 volti koguvõimsust.

Vajalik on hoolitseda auto pöördesüsteemi eest. Selleks lõikasime välja esirataste kinnitamiseks mõeldud osa.

Nüüd tuleb masina kere ja rataste alumisse ossa teha 4 mm läbimõõduga augud.

Kogume kõike. Me sisestame kruvi rattasse ja kinnitame selle kahe mutriga.

Me sisestame teise kruvi korpusel olevasse auku ja kinnitame selle mutritega.

Lõpuks ei jää muud üle, kui panna ratas nurgaga masina korpuses oleva mutri peale ja kinnitada veel paari mutriga. Teeme sama teise rattaga.

Nüüd peate ühendama servoajami pöörleva süsteemiga.

Mootoril on ka spetsiaalsed kinnitusavad, millesse tuleb sisestada kaks kruvi, et mootor masina kere külge kinnitada.

Nüüd peate koodi Arduino tahvlile üles laadima. Artikli lõpus esitatakse nii vastuvõtja kood kui ka saatja kood.

Esitame skeemi juhtkangi või saatja kokkupanekuks.

Allpool näete vastuvõtja koostu skeemi.

Lõpuks jääb üle vaid isetehtud raadio teel juhitava auto elektroonika ja mehaanika kokku panna. Selle sisselülitamisel peate esmalt sisse lülitama juhtpaneeli, seejärel masina enda.

Nagu lubatud, anname allpool lingid plaadi programmeerimiseks vajalikele koodidele
Vastuvõtja kood: (allalaadimisi: 3609)
Saatja kood: (allalaadimisi: 2617)

Samuti esitame lühikesed juhised Arduino Uno plaatide püsivara vilkumise kohta. Plaat tuleb ühendada arvutiga USB-kaabli kaudu. Järgmisena peate ametlikult veebisaidilt () alla laadima tasuta programmi, installima selle, installima tahvli draiverid ja selle programmi abil välguma.

Kui kasutate Hiina tahvlit, siis saate selle draiveri alla laadida sellelt lingilt: