// schakel de LED's in

1. digitalWrite(2,HOOG);
2. ) als (waarde == "0") (
3. // schakel de LED's uit

Nadat u de werking van de machine heeft gecontroleerd, installeert u de applicatie op uw smartphone of tablet. Wanneer u voor het eerst verbinding maakt met de Bluetooth-module HC-05/06, moet u koppelen met Android (dan wordt het koppelen automatisch uitgevoerd). Als u problemen ondervindt bij het verbinden, lees dan dit artikel

In dit artikel gaan we kijken naar het verbinden en besturen van Arduino via bluetooth.

De veelgebruikte HC-06 zal worden gebruikt als Bluetooth-module.

In ons project zullen we de LED die via Bluetooth op poort 13 is aangesloten, aan- en uitzetten.

Laten we beginnen met het schrijven van een applicatie voor een Android-smartphone. De applicatie wordt geschreven in een handige en eenvoudige programmeeromgeving, App Inventor. Programma's worden online samengesteld.

Volg de link http://ai2.appinventor.mit.edu/. Daar wordt u gevraagd in te loggen op een Google-account, dat u moet aanmaken als u er nog geen heeft.

Na het inloggen komt u in het programma waar u door op “start nieuw project” te klikken een project kunt aanmaken. U moet een projectnaam invoeren. Laten we het led_control noemen.

Er wordt een leeg toepassingsvenster geopend.

Hier plaatsen we de benodigde componenten. Selecteer ListPicker in het venster aan de linkerkant en zet deze neer in het project.

Zoek voor de component ListPicker in het venster aan de rechterkant de eigenschap Text en wijzig 'Text for ListPicker1' in 'Select a BT device'.

Open het tabblad Lay-out in het venster aan de linkerkant, plaats de component HorizontalArrangement in de toepassing en wijzig de eigenschap Breedte in "Vul bovenliggend". Voeg 2 knoppen toe aan de HorizontalArrangement, stel de eigenschap Breedte van elk ervan in op "Vul bovenliggend". Het zou er zo uit moeten zien:

Laten we de labels op de knoppen veranderen: de eerste zegt LED AAN, de tweede zegt LED UIT.

Hieronder zullen we een label toevoegen en de tekst ervan wissen.

Het enige dat overblijft is het toevoegen van een component die de gegevensoverdracht via Bluetooth organiseert. Open het tabblad Connectiviteit en plaats BluetoothClient in het project. Dit onderdeel verschijnt niet op het telefoonscherm, maar eronder, omdat het is niet visueel.

Nu kunt u beginnen met het schrijven van het programma. Selecteer rechtsboven in het programma de modus Blokken.

Hier wordt een programma samengesteld uit grafische blokken. Klik aan de linkerkant op de component ListPicker1 en selecteer ListPicker1.BeforePicking.

Klik nogmaals op ListPicker1 en selecteer Set ListPicker1.Elements to

Plaats het zoals in de schermafbeelding.

Dit geeft ons een lijst met gekoppelde Bluetooth-apparaten. Laten we nu verbinding maken met het geselecteerde apparaat. Schrijf het blok zoals in de onderstaande schermafbeelding.

Het roze blok met het label Verbonden is het eerste blok op het tabblad Tekst. Voer Verbonden in het lege vak in.

Laten we nu een knophandler schrijven. Wanneer u op de eerste knop klikt, wordt de tekst “led_on” verzonden, en wanneer u op de tweede klikt, wordt “led_off” verzonden. De inscriptie in Label1 zal ook veranderen.

Het enige dat overblijft is het downloaden van het project naar uw smartphone. Klik op Bouwen en selecteer een downloadmethode.

Voor de eerste optie heeft u internet en een QR-codelezer nodig. Klik en wacht tot het project is samengesteld en de QR-code is gegenereerd, open vervolgens de QR-codelezer op uw smartphone en lees de code. Het enige dat overblijft is het downloaden en installeren van het bestand.

Bij de tweede optie wordt het project in .apk-formaat op uw computer opgeslagen en kunt u het op elke handige manier (bijvoorbeeld via USB) naar uw smartphone downloaden.

Laten we nu beginnen met het Arduino-programma.

Het ontvangen en verzenden van gegevens gebeurt via de COM-poort, dus we zullen Serieel gebruiken. We zullen signalen karakter voor karakter ontvangen, een string vormen en vervolgens de gegenereerde string vergelijken met de led_on en led_off commando's.

Arduino

Tekenreeksval = ""; void setup() ( Serial.begin(9600); pinMode(13, OUTPUT); ) void loop() ( while (Serial.available()) ( //terwijl gegevens arriveren char c = Serial.read(); // lees ze val += c; //en maak een string delay(3) if (val != "") ( Serial.println(val); ) if (val == "led_on") ( digitalWrite(13, HIGH ) ;) else if (val == "led_off") ( digitalWrite(13, LOW); ) val = "" )

Upload de code naar Arduino.

Nu kunt u de HC-06 Bluetooth-module aansluiten. Het sluit heel eenvoudig aan:

Vcc 5v (3,3 V mogelijk)

ALS JE PROBEERT HET PROGRAMMA IN ARDUINO TE LADEN MET DE MODULE AANGESLOTEN, DAN ZAL ER EEN FOUT UITKOMEN, OMDAT ZOWEL DE MODULE ALS HET LADEN VAN HET PROGRAMMA GEBRUIKEN DE RX- EN TX-POORTS!

Schakel de Arduino in. De LED op de Bluetooth-module moet knipperen, dit betekent dat deze wacht op verbinding. Neem je smartphone, zoek bluetooth in de instellingen, zet hem aan en begin met zoeken. Zoek het apparaat met de naam hc-06 en maak er verbinding mee. Het kan zijn dat het de eerste keer niet lukt. Na één keer succesvol koppelen kunt u het programma op uw smartphone starten.

Klik eerst op “Selecteer BT-apparaat” en selecteer de module uit de gekoppelde apparaten. Druk vervolgens op de LED-aan- en uitknoppen. Als alles correct is gedaan, zal alles werken.

We hebben een heel eenvoudige applicatie gemaakt met behulp van Bluetooth, zonder ontwerp of zelfs maar te controleren of we verbonden zijn met de module of niet. In de volgende lessen gaan we complexere applicaties maken en beter kennis maken met App Inventor.

En werk met hem samen.

Upgrade van motorschild

Het bleek dat de fabrikanten van de Motor Shield-module hun klanten de mogelijkheid ontnamen om nog een module bovenop hun product te installeren. Blijkbaar vinden ze het leuk om bovenaan te staan ​​of gewoon in het normale contactpaneel te knijpen.

Deze nuance past helemaal niet bij mij. Daarom besloot ik de soldeerbout ter hand te nemen en het Motor Shield in een voor mij geschikte vorm te brengen.

Ik heb voorzichtig de originele contactdozen eruit gescheurd en weggegooid.

Ik heb normale in hun plaats geïnstalleerd.

In deze vorm is de module veel handiger in gebruik geworden. Nu kan ik de Bluetooth-draden goed op de connectoren aansluiten en niet stevig aan de contacten op het Motor Shield solderen.

Bluetooth-module JY-MCU voor Arduino

De JY-MCU Bluetooth-module zelf is vrij klein. De leveringsset bevat een kabel voor aansluiting. De pintoewijzingen zijn op de achterkant weergegeven.

Het kan worden gevoed via een 3,6-6V-voedingsbron. Dit geeft ons de mogelijkheid om hem rechtstreeks op de Arduino aan te sluiten zonder gebruik te maken van een regelaar of spanningsdeler.

Code gebruikt bij verbinding met het apparaat: 1234.

Bluetooth JY-MCU verbinden met Arduino Mega 2560

De verbinding is vrij eenvoudig.

Officieel aansluitschema:

• TXT op JY-MCU verbinden met RX (0) op Arduino
• Verbind RXD op JY-MCU met TX (1) op Arduino

Met deze verbindingsmogelijkheid moet u telkens voordat u de schets laadt de stroom naar de Bluetooth-module uitschakelen. Vergeet dit niet.

Ik ben niet blij met deze optie, dus besloot ik discrete poorten met seriële ondersteuning te gebruiken.

Onofficieel aansluitschema:

• VCC op JY-MCU is verbonden met +5V Arduino
• Verbind GND op JY-MCU met GND Arduino
• TXT op JY-MCU aangesloten op discrete PIN 50 op Arduino
• RXD op JY-MCU is verbonden met discrete PIN 51 op Arduino

Nu kunt u schetsen uploaden zonder de stroom naar de Bluetooth-module uit te schakelen.

Om de Bluetooth te beveiligen, besloot ik een Proto Shield-bord en een miniatuur soldeerloos breadboard te gebruiken. In de toekomst zal ik er nog andere apparatuur, bedieningselementen en displays op aansluiten.

Schets voor het besturen van een robot op Arduino via Bluetooth via een Android-smartphone

In mijn schets heb ik de volgende functies geïmplementeerd:

• Vooruit
• Achteruit bewegen
• Sla linksaf
• Sla rechtsaf
• Soepele bocht naar links bij vooruitrijden
• Soepele bocht naar rechts als je vooruit gaat
• Soepele bocht naar links bij het achteruit rijden
• Soepele bocht naar rechts bij het achteruit rijden
• Stop

Snelheidsinstelling 0%

Snelheidsinstelling 10%

Snelheidsinstelling 20%

Snelheidsinstelling 30%

Snelheidsinstelling 40%

Snelheidsinstelling 50%

Snelheidsinstelling 60%

Snelheidsinstelling 70%

Snelheidsinstelling 80%

Snelheidsinstelling 90%

Snelheidsinstelling 100%

Ik heb functies in de schets gebruikt om geen code voor soortgelijke gebeurtenissen te dupliceren.

#erbij betrekken // Sluit de motorbesturingsbibliotheek aan
#erbij betrekken // Sluit de bibliotheek voor servo's aan
#erbij betrekken // Verbind de bibliotheek om met serieel te werken via afzonderlijke poorten

//Maak objecten voor motoren
AF_DCMotormotor1(1); //kanaal M1 op motorschild - linksachter
AF_DCMotormotor2(2); //kanaal M2 op motorschild - rechtsachter
AF_DCMotormotor3(3); //kanaal M3 op motorschild - linksvoor
AF_DCMotormotor4(4); //kanaal M4 op motorschild - rechtsvoor

// Maak een object voor de servo
Servo versus servo;

SoftwareSeriële BTSeriële(50, 51); // RX, TX

// Maak een variabele voor Bluetooth-opdrachten
teken vcmd;
// Maak variabelen om de snelheid van de motoren te onthouden
int vspdL, vspdR;
/* Creëer een variabele waarvan de waarde de snelheid verlaagt tijdens vloeiende bochten.
De huidige snelheid moet groter zijn dan deze waarde. Anders draaien de motoren in de draairichting simpelweg niet */
int vspd = 200;

ongeldige setup() (
// Stel de Bluetooth-gegevensoverdrachtsnelheid in
BTSerial.begin(9600);
// Stel de gegevensoverdrachtsnelheid via de kabel in
Serieel.begin(9600);
// Selecteer de pin waarop de servo is aangesloten
vservo.attach(9); // of 10, indien aangesloten op de buitenste connector
// Draai de servo elke keer dat hij wordt ingeschakeld 90 graden
vservo.schrijven(90);
// Stel de maximale rotatiesnelheid van de motoren in
vsnelheid(255.255);
}

lege lus() (
// Als er gegevens zijn
if (BTSerial.beschikbaar())
{
// Lees de commando's en plaats ze in een variabele. char converteert de tekencode van de opdracht naar een teken
vcmd = (char)BTSerial.read();
// Stuur een commando naar de poort zodat deze kan worden gecontroleerd in de "Port Monitor"
Serieel.println(vcmd);

// Vooruit
als (vcmd == "F") (
vvooruit();
}
// Rug
als (vcmd == "B")
{
vachterwaarts();
}
// Links
als (vcmd == "L")
{
vlink();
}
// Rechts
als (vcmd == "R")
{
vright();
}
// Recht en links
als (vcmd == "G")
{
vvoorwaartslinks();
}
// Recht en goed
als (vcmd == "ik")
{
vvooruitrecht();
}
// Terug en links
als (vcmd == "H")
{
vachterwaartslinks();
}
// Terug en rechts
als (vcmd == "J")
{
vachterwaartsrechts();
}
// Stop
als (vcmd == "S")
{
vrelease();
}
// Snelheid 0%
als (vcmd == "0")
{
vsnelheid(0,0);
}
// Snelheid 10%
als (vcmd == "1")
{
vsnelheid(25,25);
}
// Snelheid 20%
als (vcmd == "2")
{
vsnelheid(50,50);
}
// Snelheid 30%
als (vcmd == "3")
{
vsnelheid(75,75);
}
// Snelheid 40%
als (vcmd == "4")
{
vsnelheid(100.100);
}
// Snelheid 50%
als (vcmd == "5")
{
vsnelheid(125,125);
}
// Snelheid 60%
als (vcmd == "6")
{
vsnelheid(150.150);
}
// Snelheid 70%
als (vcmd == "7")
{
vsnelheid(175.175);
}
// Snelheid 80%
als (vcmd == "8")
{
vsnelheid(200.200);
}
// Snelheid 90%
als (vcmd == "9")
{
vsnelheid(225.225);
}
// Snelheid 100%
als (vcmd == "q")
{
vsnelheid(255.255);
}
}
}

// Vooruit
ongeldig vforward() (
vsnelheid(vspdL,vspdR);
vvoorwaartsRL();
}

// Doorsturen voor RL
ongeldig vforwardRL() (
motor1.run(VOORUIT);
motor2.run(VOORUIT);
motor3.run(VOORUIT);
motor4.run(VOORUIT);
}

// Rug
ongeldig vachterwaarts() (
vsnelheid(vspdL,vspdR);
vachterwaartsRL();
}

// Terug naar RL
void vbackwardRL() (
motor1.run(ACHTERUIT);
motor2.run(ACHTERUIT);
motor3.run(ACHTERUIT);
motor4.run(ACHTERUIT);
}

// Links
leegte vleft() (
vsnelheid(vspdL,vspdR);
motor1.run(ACHTERUIT);
motor2.run(VOORUIT);
motor3.run(ACHTERUIT);
motor4.run(VOORUIT);
}

// Rechts
ongeldig vright() (
vsnelheid(vspdL,vspdR);
motor1.run(VOORUIT);
motor2.run(ACHTERUIT);
motor3.run(VOORUIT);
motor4.run(ACHTERUIT);
}

// Vooruit en links
void vforwardleft() (
als (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
anders
{
vsnelheid(0,vspdR);
}
vvoorwaartsRL();
}

// Vooruit en rechts
ongeldig vforwardright() (
als (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
anders
{
vsnelheid(vspdL,0);
}
vvoorwaartsRL();
}

// Terug en links
void vachterwaartslinks() (
als (vspdL > vspd) (
vspeed(vspdL-vspd,vspdR);
}
anders
{
vsnelheid(0,vspdR);
}
vachterwaartsRL();
}

// Terug en rechts
void vachterwaartsrechts() (
als (vspdR > vspd) (
vspeed(vspdL,vspdR-vspd);
}
anders
{
vsnelheid(vspdL,0);
}
vachterwaartsRL();
}

// Stop
ongeldig vrelease())(
motor1.run(RELEASE);
motor2.run(RELEASE);
motor3.run(RELEASE);
motor4.run(RELEASE);
}

// Verander de snelheid
void vspeed(int spdL,int spdR)(
als (spdL == spdR) (
vspdL=spdL;
vspdR=spdR;
}
motor1.setSpeed(spdL);
motor2.setSpeed(spdR);
motor3.setSpeed(spdL);
motor4.setSpeed(spdR);
}

Bluetooth RC Car-programma - bestuur een robotauto vanaf een Android-smartphone

Ik heb het Bluetooth RC Car-programma op mijn smartphone geïnstalleerd. Naar mijn mening is dit de beste software voor het besturen van een robotauto.

Met het programma kunt u commando's verzenden wanneer u op knoppen drukt of reageren op gegevens van de versnellingsmeter in uw smartphone, de bewegingssnelheid aanpassen met een schuifregelaar, de voor- en achterlichten aanzetten, het geluidssignaal in- en uitschakelen, aan en uit zetten het noodsignaal.

Het programma vereist Android-versie 2.3.3 of hoger. De programmagrootte is 3 megabytes.

Lijst met opdrachten:

• F – vooruit
• B-terug
• L – links
• R – juist
• G – rechtdoor en links
• I – recht en naar rechts
• H – terug en links
• J – terug en rechts
• S – stop
• W – koplamp aan
• w – koplamp is uit
• U – achterlicht aan
• u – het achterlicht is uit
• V – geluidssignaal is ingeschakeld
• v – geluidssignaal is uitgeschakeld
• X – noodsignaal is ingeschakeld
• x - het noodsignaal is uitgeschakeld
• 0 – bewegingssnelheid 0%
• 1 – bewegingssnelheid 10%
• 2 – bewegingssnelheid 20%
• 3 – bewegingssnelheid 30%
• 4 – bewegingssnelheid 40%
• 5 – bewegingssnelheid 50%
• 6 – bewegingssnelheid 60%
• 7 – bewegingssnelheid 70%
• 8 – bewegingssnelheid 80%
• 9 – bewegingssnelheid 90%
• q – bewegingssnelheid 100%

Zoals je kunt zien, is de proeftuin voor creativiteit behoorlijk goed. Ik zou ook de mogelijkheid toevoegen om de rechter- en linkerlichten afzonderlijk in te schakelen voor de koplampen voor en achter.

Ik heb de commando's die al in de schets worden ondersteund vetgedrukt gemarkeerd. De rest ga ik voor een ander doel gebruiken.

Het principe van het verzenden van commando's: wanneer u in het programma op een knop drukt, wordt het commando één keer via Bluetooth verzonden en wanneer de knop wordt losgelaten, wordt het S-stop-commando onmiddellijk verzonden.

Demonstratie van werk

De volgende keer ben ik van plan een ultrasone afstandsmeter op de robot aan te sluiten en een algoritme voor het vermijden van obstakels te implementeren.

Laten we geen slecht speelgoed van de Chinezen kopen, maar laten we van hen een goedkoop bouwpakket-chassis, een paar modules kopen en er de handen aan wagen!

Dit is wat ik uiteindelijk heb gekregen: een redelijk chassis, bestuurbaar - TA-DA!!! - vanaf mijn Android-smartphone.

Vandaag gaan we een grappige auto bouwen met afstandsbediening via Bluetooth. Bronnen van het besturingsprogramma voor Android inbegrepen.

Een goed voorbeeld van speelgoed

Waarom is dit zo? Waarschijnlijk omdat deze zaag in de STIHL gereedschapswinkel werd verkocht. Naar mijn mening heeft STIHL een speelgoedanaloog van zijn producten gemaakt in een kleine promotionele editie. Als resultaat werd een volkomen gezond speelgoed geboren, dat sterk leek op zijn oudere broer. De rubberen ketting draait, 80 procent van de bedieningselementen is geïmplementeerd. Er zit zelfs een snoer bij met handvat om de zaag op te winden, een schakelaar en een gasknop. De set bevat een reserveketting en gereedschap om de ketting te verwisselen.

Hier is een speelgoedzaag

Waar heb ik het over? Oh ja, over architectuur! Wat ik bedoel is dat als je wilt, je uitstekend speelgoed kunt maken. En er is iets om naar op te kijken.

Laten we een auto bouwen met afstandsbediening!

Op een mooie dag stopte het rechterwiel van een van de auto's met draaien. Ik heb hem uit elkaar gehaald en de motor gecontroleerd: hij werkte.
Er zijn drie microcircuits op de besturingskaart - China is dom, ik kon geen enkele redelijke documentatie vinden. Eén chip is een radiosignaalontvanger met logische uitgangen en twee brugmotordrivers. Eén van de chauffeurs is uitgevallen. Het lukte mij niet om onmiddellijk een brugmotordriver uit afzonderlijke componenten samen te stellen.

De lokale radio-onderdelenwinkel had niets geschikts. Dus ging ik naar verre landen voor wondermicroschakelingen. Ik pakte mijn spullen, vulde mijn zakken met crackers, schonk een kop koffie in, startte mijn browser en ging... .
Ik vond een motordriver die aan de parameters voldeed en bestelde er twee tegelijk. Voor het geval er ineens eentje defect is of ik mezelf verbrand. Toen begon het idee van een eigen auto te ontstaan. Nadat het pakket uit het glorieuze China was aangekomen, heb ik met succes de chauffeur vervangen en werd de machine gerepareerd.

Zonder het idee van mijn eigen auto op de plank te leggen, ging ik opnieuw de basis kiezen: het chassis van de toekomstige auto. Chassis zijn verschillend voor grondtransport: op rupsbanden, op wielen, met twee, drie, vier wielen, enz.

Hoe ik het chassis heb gekozen

Moeras van gedachten en referentietermen

Wat hebben we nodig om de machine te monteren?

Totaal: chassis + besturingskaart + Bluetooth-module + besturingsprogramma voor Android.

Algemeen aansluitschema

Schema in Proteus

Microcontroller-programma

De code is voldoende becommentarieerd. Ik wil graag apart stilstaan ​​bij mijn implementatie van gegevensuitwisseling.
Ik ontvang gegevens via een ringbuffer. Het ding is niet nieuw en er zijn veel implementaties.

Ik heb de functies van de ringbuffer in een aparte bibliotheek geplaatst bestaande uit:
header-bestand ring_buffer.h en functie-implementatiebestand ring_buffer.c
Om de bibliotheek te gebruiken, moet u deze opnemen in main.c
#include "ring_buffer.h"

Vervolgens moet u de bibliotheek in het headerbestand configureren. Om te configureren hoeft u slechts vier richtlijnen in te stellen:
#define RX_PACKET_SIZE 7 // RxD-pakketgrootte #define BUFFER_SIZE 16 // Ontvangstbuffergrootte. Moet tweemaal zo groot zijn als RX_PACKET_SIZE #define START_BYTE "s" // Startbyte #define STOP_BYTE "e" // Stopbyte

Eigenlijk valt er niets meer te configureren.

De code gebruiken In main.c configureren we de USART van de microcontroller.
De USART-configuratiefunctie oproepen
USART_Init(MYUBRR);

#define BAUD 9600 #define MYUBRR F_CPU/16/BAUD-1 void USART_Init(unsigned int ubrr) ( /* Stel baudrate in */ UBRRH = (unsigned char)(ubrr >> 8); UBRRL = (unsigned char)ubrr; /* Ontvanger en zender inschakelen */ UCSRB = (1<< TXCIE) | (1 << RXCIE)| (1 << TXEN) | (1 << RXEN); /* Set frame format: 8data, 2stop bit */ UCSRC = (1 << URSEL) | (0 << USBS) | (3 << UCSZ0); }

Een datapakket ontvangen

Nu hoeven we alleen nog maar af en toe onze buffer te controleren. Om dit te doen, heb ik een timer gestart waarin ik een vlag heb ingesteld waarmee de ringbuffer kan worden gecontroleerd
ISR(TIMER0_OVF_vect) ( TCNT0 = 0x64; ReadRingBuffer = 1; )

In de hoofdlus voegen we een voorwaarde toe om de vlag te controleren.
if (ReadRingBuffer) ( if (RB_read_buffer((uint8_t*)&RxPacket) == 1) De buffer lezen ( // Parseer het pakket, doe iets ) ReadRingBuffer = 0; )

Functie RB_leesbuffer controleert de ringbuffer, of de pakketgrootte, start- en stopbytes zich op de juiste plaatsen bevinden - het pakket wordt als geldig beschouwd, de functie retourneert "1". Als argument neemt de functie een aanwijzer waar het ontvangen pakket moet worden toegevoegd.
Voor een grotere betrouwbaarheid kan het pakket worden uitgerust met een controlesom; in een van mijn commerciële projecten heb ik precies dat gedaan. Dat wil zeggen dat naast het controleren van de grootte en start/stop-bytes ook een checksum-controle wordt toegevoegd. Maar voorlopig doen we het zonder.

Hoe demonteer ik het pakket?

Mijn opvangpakket is georganiseerd in de vorm van een structuur.
struct RxPacket ( uint8_t StartByte; uint8_t Commando; int16_t Left_PWM; int16_t Right_PWM; uint8_t StopByte; ) RxPacket;

Een functie aanroepen RB_read_buffer ((uint8_t*)&RxPacket ), als argument geven we een verwijzing door naar de structuur van het ontvangende pakket. Dat wil zeggen dat wanneer het pakket wordt ontvangen, alles op zijn eigen plaatsen in de RxPacket-structuur wordt gesorteerd. Dan hoeft u alleen nog maar deze gegevens uit de structuur te lezen, bijvoorbeeld als volgt:
lCmd = RxPacket.Command;

lLPWM = RxPacket.Left_PWM;

Hoewel verzending nog niet in mijn programma wordt gebruikt, is de mogelijkheid van verzending toch geïmplementeerd. Gegevens overbrengen is eenvoudiger. Laten we op dezelfde manier als voor het ontvangende pakket de structuur maken:
struct TxPacket ( uint8_t StartByte; uint8_t Rc5System; uint8_t Rc5Command; uint8_t StopByte; ) TxPacket;
Waar, er is een start- en stopbyte en een informatiegedeelte. We hebben de USART-ontvanger al geïnitialiseerd.
Roep de functie op om pakketverzending te starten void send_packet() ( // Schrijf de startbyte naar het UDR-register UDR = START_BYTE; ) In dit voorbeeld schrijf ik in deze functie alleen de startbyte naar het UDR-register. Het lijkt niet veel, maar in dezelfde functie kun je pakketvoorbereiding of iets anders nuttigs implementeren. En dit is naar mijn mening logischer. Het is logisch in termen van zelfdocumenterende code. Dat wil zeggen, als ik in code zit, schrijf ik eenvoudigweg een waarde naar het UDR-register, dit kan worden opgevat als het overbrengen van slechts één byte en het aanroepen van een zelfsprekende functie

verzend_pakket()
- Ik heb het over het feit dat ik een datapakket verstuur.< sizeof(TxPacket)) { UDR = *(Pointer + TxIndex); TxIndex++; } else TxIndex = 1; }

In de handler declareer ik een pointervariabele en wijs deze het adres van de TxPacket-structuur toe. Vervolgens wordt een statische variabele gedeclareerd: de index van de verzonden byte, waaraan de waarde wordt toegewezen wanneer deze wordt gedeclareerd 1 . We beginnen met één omdat we de eerste byte uit de structuur al hebben verzonden. Over het algemeen kan de structuur het toch zonder de startbyte doen; ik verzend deze afzonderlijk, maar de declaratie van deze byte blijft in de structuur achter om te begrijpen hoe het pakket eruit ziet.

Voorwaarde als (TxIndex< sizeof(TxPacket)) проверяет, что индекс меньше чем размер пакета. Если условие верно, то записываем байт в регистр UDR: UDR = *(Pointer + TxIndex);
TxIndex verhogen. Wanneer de USART de volgende byte verzendt, komen we opnieuw in de handler, maar de volgende byte uit de structuur wordt verzonden, en dus worden alle bytes van de structuur verzonden. Wanneer TxIndex groter is dan de grootte van de structuur, zal de voorwaarde niet waar zijn en zullen we eindigen in else TxIndex = 1;

Waar TxIndex wordt geïnitialiseerd, maar er niets naar het UDR-register wordt geschreven, wordt de handler dus niet langer aangeroepen totdat de volgende pakketverzending wordt gestart. Het overdrachtsproces is dus volledig automatisch, en zelfs als we de structuur van het pakket veranderen, hoeft de handler niet herschreven te worden.
Als onderdeel van de beschrijving van het MK-programma moet er nog gesproken worden over de implementatie van chauffeursmanagement. De bestuurder wordt bestuurd door drie signalen: A1 (B1), A2 (B2) en PWMA (PWMB). A1 en A2 zijn ontworpen om de driver aan/uit te zetten en de uitgangspolariteit te veranderen. Een PWM-signaal van de MK wordt naar de PWMA-ingang gestuurd - u kunt de rotatiesnelheid regelen. Voor het PWM-signaal heb ik twee hardware PWM-timers 1 gebruikt.<< 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;

#define _WGM13 0 #define _WGM12 1 #define _WGM11 0 #define _WGM10 1 // Timer 1 init TCCR1A = (1
De timer is 16 bits, maar de PWM is geïnitialiseerd op 8 bits. En zoals je waarschijnlijk al hebt gemerkt, heb ik in het ontvangende pakket twee waarden voor het instellen van PWM, respectievelijk voor de linker- en rechterschijf. Ondertekende variabelen zijn 16-bits.

Ik zal uitleggen waarom ik dit deed. Ten eerste

, het kwam uit een programma voor Android. Feit is dat er in Java geen ondertekende typen zijn en dat ik al op deze hark ben gestapt. En om getallen van 0 tot 255 te verzenden, zou ik op de een of andere manier moeten ontwijken. Ik besloot een eenvoudiger route te volgen: ik stuur een ondertekend 16-bits nummer. Tegelijkertijd zijn 16 bits van een ondertekend type van -32786 tot 32768, wat genoeg is voor ons. Ten tweede

naar mijn mening is het transparanter: de rotatiesnelheid en richting worden beschreven door slechts één variabele. En ten derde

Om de schijven te besturen heb ik een functie geschreven station(int linksPWM, int rechtsPWM);.
void drive(int leftPWM, int rightPWM) ( // Verplaats het linkerwiel VOORUIT als (leftPWM > 0)( ClearBit(A2_PORT, A2_PIN); SetBit(A1_PORT, A1_PIN); ) // Verplaats het linkerwiel TERUG als (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); ) // Verplaats rechterwiel TERUG als (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))); }
In overeenstemming met de PWM-waarde worden de signalen A1 (B1), A2 (B2) bestuurd en wordt de PWM-waarde ingesteld door de functie aan te roepen set_PWM(linksPWM, rechtsPWM).

Oef, ik ben buiten adem...
Samenvattend: het pakket ontvangen, geparseerd, de PWM-waarde doorgegeven aan de functie drijfveer.

Android-applicatie voor auto's

Hoofdfunctie van het programma- gegevensoverdracht naar de HC-06-module via Bluetooth. Het programma heeft een eenvoudige interface.

Bovenaan bevindt zich een vervolgkeuzelijst met gekoppelde Bluetooth-apparaten waarmee u een module kunt selecteren. In eerste instantie was deze lijst er niet, maar tegen het einde van het werken aan het artikel besloot ik het op een menselijke manier te doen, omdat niet iedereen de broncode zal kunnen begrijpen.

Vervolgens schakelt de knop “Uit” de communicatie met “HC-06” in/uit. Hieronder van links naar rechts: verzonden PWM-waarde van het linkerkanaal, sensortype, waarde van het rechterkanaal. Hieronder staan ​​twee schuifregelaars voor het aanpassen van de snelheid en rotatiegevoeligheid.

Het programma implementeert twee soorten machinebesturing. Om het sensortype te wijzigen, moet u de sensornaam aanraken: "Kantelen" of "Shuffle".

1. Bedien de machine door de telefoon te kantelen. De nulpositie van de telefoon is horizontaal. Wanneer de telefoon naar voren wordt gekanteld, neemt de PWM-waarde evenredig toe met de kanteling in het bereik van 0 tot 255. Wanneer u de telefoon naar achteren kantelt, neemt de PWM-waarde evenredig af met de kanteling in het bereik van 0 tot -255

2. Aanraakbediening. Mijn handelsnaam voor dit soort controle is ‘shuffle’.

Er zijn geen toeters en bellen. Dat lijkt alles te zijn.

Een beetje vlieg in de zalf op “ski’s”

Cv

Er is nog ruimte voor activiteit, er is ruimte om te groeien. U kunt het chassis aanpassen, u kunt de software voor uw telefoon upgraden en verbeteren.
En er komt een vervolg hierop!

In dit materiaal raden we aan om te leren hoe je thuis een radiografisch bestuurbare auto kunt maken.

Om een ​​machine te maken hebben we nodig:
- speelgoedauto;
- twee Arduino Uno-kaarten;
- twee NRF24 radiomodulekaarten;
- condensator 470 mF, 25 volt;
- L298N motorbesturingskaart;
- motor;
- servoaandrijving;
- analoge joystick;
- oplaadbare batterijen;
- kroonbatterij;
- twee aan- en uitknoppen;
- kader.

De eerste stap is het solderen van een condensator aan de voedingspinnen van de radiomodule. Je moet ook eerst de batterijen in elkaar zetten om een ​​totaal vermogen van 12 volt te krijgen om de motor en het Arduino-bord van stroom te voorzien.

Het is noodzakelijk om voor het draaisysteem van de auto te zorgen. Om dit te doen, knippen we het deel uit dat bedoeld is voor het bevestigen van de voorwielen.

Nu moet je gaten maken met een diameter van 4 mm in het onderste deel van het machinelichaam en de wielen.

Wij verzamelen alles. We steken de schroef in het wiel en zetten deze vast met twee moeren.

We steken nog een schroef in het gat in het lichaam en zetten deze vast met moeren.

Uiteindelijk hoeft u alleen nog maar het wiel schuin op de moer in de machinebehuizing te plaatsen en deze met nog een paar moeren vast te zetten. Hetzelfde doen we met het tweede wiel.

Nu moet u de servoaandrijving op het roterende systeem aansluiten.

De motor heeft ook speciale montagegaten waarin u twee schroeven moet steken om de motor aan de carrosserie van de machine te bevestigen.

Nu moet je de code uploaden naar het Arduino-bord. Aan het einde van het artikel wordt de code voor de ontvanger gepresenteerd, evenals de code voor de zender.

We presenteren een diagram voor het assembleren van een joystick of zender.

Hieronder ziet u een diagram van de ontvangerconstructie.

Uiteindelijk blijft het enige dat overblijft de elektronica en mechanica van een zelfgemaakte radiografisch bestuurbare auto in elkaar te zetten. Wanneer u het inschakelt, moet u eerst het bedieningspaneel inschakelen en vervolgens de machine zelf.

Zoals beloofd geven we hieronder links naar de codes die nodig zijn om het bord te programmeren
Ontvangercode: (downloads: 3609)
Zendercode: (downloads: 2617)

We zullen ook korte instructies geven over het flashen van firmware voor Arduino Uno-kaarten. Het bord moet via een USB-kabel op de computer worden aangesloten. Vervolgens moet u een gratis programma downloaden van de officiële website (), het installeren, de stuurprogramma's van het bord installeren en het flashen met dit programma.

Als u een Chinees bord gebruikt, dan kunt u het stuurprogramma downloaden via deze link: