Voorbeeld van het uitvoeren van waarden van analoge pinnen< 4 ; analogChannel++ ) { int sensorReading = analogRead(analogChannel) ; client.print ("
• ); klant.print(" "); for (int analogChannel = 0; analogChannel
op de analoge ingang"

klant.print(":

" ); client.print (sensorReading) ; client.print ("

") ;) client.println ("

" ); client.print (DELIMITER) ;

// Vergeet niet de verbinding te verbreken!

Bordelementen

Microcontroller ATmega328P Het hart van het Arduino Uno WiFi-platform is de 8-bit microcontroller van de AVR-familie - ATmega328P.

Microcontroller ATmega16U2 De ATmega16U2-microcontroller zorgt voor communicatie tussen de ATmega328P-microcontroller en de USB-poort van de computer. Bij aansluiting op een pc wordt de Arduino Uno WiFi gedetecteerd als een virtuele COM-poort. De firmware van de 16U2-chip maakt gebruik van standaard USB-COM-stuurprogramma's, dus er is geen installatie van een extern stuurprogramma vereist.

Stroompinnen chassisnummer:

Spanning van externe voeding (niet gerelateerd aan 5V van USB of andere gereguleerde spanning). Via deze pin kun je zowel externe stroom leveren als stroom verbruiken als er een externe adapter op het apparaat is aangesloten. 5V:

De pin krijgt een spanning van 5 V van de stabilisator van het bord. Deze stabilisator levert stroom aan de ATmega328-microcontroller. Het wordt niet aanbevolen om het apparaat via de 5V-pin van stroom te voorzien - in dit geval wordt geen spanningsstabilisator gebruikt, wat kan leiden tot een defect aan de kaart. 3,3 V:

3,3 V van de bordstabilisator. De maximale uitgangsstroom bedraagt ​​1 A.

GND: Conclusies van de aarde.
Het logische niveau van één is 5 V, nul is 0 V. De maximale uitgangsstroom is 40 mA. Op de contacten zijn pull-up-weerstanden aangesloten, die standaard zijn uitgeschakeld, maar softwarematig kunnen worden ingeschakeld.

PWM: pinnen 3, 5, 6, 9, 10 en 11
Hiermee kunt u 8-bit analoge waarden uitvoeren als PWM-signaal.

ADC: pinnen A0 – A5
6 analoge ingangen, die elk de analoge spanning kunnen weergeven als een 10-bits getal (1024 waarden). De ADC-capaciteit is 10 bits.

TWI/I²C: SDA- en SCL-pinnen
Voor communicatie met randapparatuur via een synchroon protocol, via 2 draden. Gebruik de Wire-bibliotheek om te werken.

SPI: pinnen 10(SS), 11(MOSI), 12(MISO), 13(SCK).
Via deze pinnen vindt communicatie via de SPI-interface plaats. Gebruik de SPI-bibliotheek om te werken.

UART: pinnen 0(RX) en 1(TX)
Deze pinnen zijn verbonden met de overeenkomstige pinnen van de ATmega16U2-microcontroller, die fungeert als USB-UART-converter. Wordt gebruikt om te communiceren tussen het Arduino-bord en een computer of andere apparaten via de seriële klasse.

LED-indicatie

USB Type-B-connector

De USB Type-B-connector is ontworpen voor het flashen van het Arduino Uno WiFi-platform met behulp van een computer.

Externe voedingsconnector

Connector voor het aansluiten van externe voeding van 7 V tot 12 V.

5V spanningsregelaar

Wanneer het bord is aangesloten op een externe voedingsbron, loopt de spanning door de MPM3610-regelaar. De stabilisatoruitgang is verbonden met de 5V-pin. De maximale uitgangsstroom bedraagt ​​1A.

3,3V spanningsregelaar

Stabilisator MPM3810GQB-33 met 3,3 volt uitgang. Levert stroom aan de ESP8266 WiFi-module en wordt uitgevoerd naar de 3,3V-pin. De maximale uitgangsstroom bedraagt ​​1A.

ICSP-connector voor ATmega328P

De ICSP-connector is ontworpen voor in-circuit programmering van de ATmega328P-microcontroller. Met behulp van de SPI-bibliotheek kunnen deze pinnen via de SPI-interface communiceren met uitbreidingskaarten. De SPI-lijnen worden naar een 6-pins connector geleid en worden ook gedupliceerd op de digitale pinnen 10(SS), 11(MOSI), 12(MISO) en 13(SCK).

ICSP-connector voor ATmega16U2

De ICSP-connector is ontworpen voor in-circuit programmering van de ATmega16U2-microcontroller.

Wil je een sms-bericht van je Android-smartphone naar je Arduino-bord sturen? In dit artikel lees je hoe je dat doet!

Wat je nodig hebt

• Android-smartphone met ondersteuning voor USB-hostmodus (d.w.z. OTG-ondersteuning) - de meeste apparaten met Android 3.1 en hoger ondersteunen deze modus. Test uw telefoon met de USB Host Diagnostics-app uit de Play Store;
• Arduino - elke versie. Ik gebruik Uno R3;
• USB-kabel voor Arduino;
• USB OTG-kabel - u hebt deze nodig om de Arduino USB-kabel aan te sluiten op de micro-USB-poort van de telefoon;
• Android Studio - u moet het installeren. Het is vrij eenvoudig om te doen. Android Studio maakt het ontwikkelen van apps eenvoudiger dankzij de aannames en het genereren van code. Dit is een van de beste IDE's. U kunt dit artikel ook gebruiken als handleiding voor het installeren van Android IDE.

Basiscomponenten van een Android-applicatie

Er zijn drie hoofdbestanden in een Android-applicatie:

MainActivity.java Hier bevindt zich de uitvoerbare Java-code die bepaalt hoe de applicatie zal functioneren. Activity_main.xml Bevat de lay-out van de applicatie, dat wil zeggen componenten: knoppen, componenten voor tekstweergave, enz. AndroidManifest.xml Hier definieert u wanneer de applicatie moet worden uitgevoerd, welke machtigingen deze nodig heeft en tot welke hardware deze toegang moet hebben.

Er zijn nog veel meer bestanden, maar ze zijn allemaal met elkaar verbonden via deze drie.

Een activiteit kan worden gekarakteriseerd als een scherm waarop de gebruiker interactie heeft met de telefoon. Activiteiten bevatten widgets zoals knoppen, tekstvelden, afbeeldingen enz. die helpen bij het overbrengen van informatie. Deze tutorial gebruikt slechts één activiteit, MainActivity, die gebruikersinvoer accepteert om naar de Arduino te sturen en ook de ontvangen tekst weergeeft.

Indeling

We zullen dezelfde lay-out gebruiken als de USB-app en Bluetooth-app. Het is eenvoudig en bevat de minimale widgets die nodig zijn om de verbinding tussen apparaten te testen.

Zoals u kunt zien, bevat het een EditText-widget om gegevens van de gebruiker te ontvangen, knoppen om de verbinding te starten, gegevens over te dragen, de verbinding te beëindigen en de TextView te wissen. De ontvangen gegevens worden weergegeven in een TextView (lege ruimte onder de knoppen).

Hier is een deel van de XML-code. Omdat de code voor de knoppen vergelijkbaar is, wordt deze hier niet weergegeven. De volledige code kan worden gedownload via de link aan het einde van het artikel.

Ik heb hier een RelativeLayout gebruikt, wat betekent dat elke widget relatief is gepositioneerd ten opzichte van de widgets eromheen. De lay-out kan eenvoudig opnieuw worden gemaakt op het tabblad Ontwerp, waar u widgets kunt slepen en neerzetten waar u maar wilt. We moeten beschrijven wat er zal gebeuren als de knop wordt ingedrukt. Hiervoor wordt de onClick-methode gebruikt. Geef de methodenaam op in de XML-code voor de knop. Om dit te doen, voegt u de regel toe:

Android:onClick="onClickMethode"

Beweeg nu uw muis over deze regel en aan de linkerkant zou een soortgelijke waarschuwing moeten verschijnen:

Klik op de optie "OnClick maken...". Hierdoor wordt de onClick-methodecode automatisch toegevoegd aan MainActivity.java. U moet dit voor elke knop doen.

USB-seriële bibliotheek

Het opzetten van een seriële verbinding in Android is behoorlijk arbeidsintensief omdat je veel dingen handmatig moet configureren, dus ik heb een paar bibliotheken gevonden die dit allemaal automatisch doen. Ik heb er een aantal getest en uiteindelijk gekozen voor de UsbSerial-bibliotheek van Github-gebruiker felHR85. Van de vergelijkbare bibliotheken die ik heb gevonden, is dit de enige die nog steeds wordt bijgewerkt. Het is vrij eenvoudig in te stellen en te gebruiken. Om de bibliotheek aan uw project toe te voegen, downloadt u het nieuwste JAR-bestand van Github. Plaats het in de libs-submap van uw projectmap. Klik vervolgens in de bestandsverkenner in Android Studio met de rechtermuisknop op het JAR-bestand en selecteer 'Toevoegen als bibliotheek'. Dat is het!

Algoritme voor programma-uitvoering

Dit is een korte schets van hoe we verder gaan. Elke activiteit heeft een onCreate() -methode, die wordt uitgevoerd wanneer de activiteit wordt gemaakt. Welke code u ook in het begin wilt uitvoeren, moet in deze methode worden geplaatst. Houd er rekening mee dat het lezen vanaf het apparaat asynchroon is, wat betekent dat het op de achtergrond werkt. Dit om ervoor te zorgen dat de gegevens zo snel mogelijk worden ontvangen.

Een verbinding openen

Laten we eerst een onClick-methode voor de knop Begin definiëren. Wanneer erop wordt geklikt, moet u naar alle aangesloten apparaten zoeken en vervolgens controleren of de VendorID van het aangesloten apparaat (Vendor ID) hetzelfde is als de VendorID van de Arduino. Als er een match wordt gevonden, moet de gebruiker om toestemming worden gevraagd. Elk USB-slaveapparaat heeft een leveranciers-ID en een product-ID, die kunnen worden gebruikt om te bepalen welke stuurprogramma's voor dat apparaat moeten worden gebruikt. Leveranciers-ID voor elk Arduino-bord is 0x2341 of 9025.

Public void onClickStart(View view) ( HashMap usbDevices = usbManager.getDeviceList(); if (!usbDevices.isEmpty()) ( boolean keep = true; for (Map.Entry entry: usbDevices.entrySet()) ( device = entry. getValue(); int deviceVID = device.getVendorId(); (deviceVID == 0x2341) //Arduino Leveranciers-ID (PendingIntent pi = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0); usbManager.requestPermission( apparaat, pi); keep = false; ) else (verbinding = null; apparaat = null; ) if (!keep) break;

Laten we nu een BroadcastReceiver definiëren om uitgezonden berichten te ontvangen om de gebruiker om toestemming te vragen en om automatisch een verbinding te starten wanneer het apparaat is verbonden en de verbinding te verbreken wanneer deze wordt verbroken.

// Broadcast-berichtontvanger om automatisch een seriële verbinding te starten en te sluiten. privé finale BroadcastReceiver broadcastReceiver = nieuwe BroadcastReceiver() ( @Override public void onReceive(Context context, Intent intent) ( if (intent.getAction().equals(ACTION_USB_PERMISSION)) ( boolean toegekend = intent.getExtras().getBoolean(UsbManager. EXTRA_PERMISSION_GRANTED); if (toegekend) ( verbinding = usbManager.openDevice(apparaat); serialPort = UsbSerialDevice.createUsbSerialDevice(apparaat, verbinding); if (serialPort != null) ( if (serialPort.open()) ( //Stel seriële parameters in verbindingen. setUiEnabled(true); // Schakel knoppen in UI in. serialPort.setDataBits(UsbSerialInterface.DATA_BITS_8); serialPort.setStopBits(UsbSerialInterface.STOP_BITS_1); tvAppend(textView,"Seriële verbinding geopend!\n"); else ( Log.d("SERIAL", "POORT NIET OPEN"); ) ) else ( Log.d("SERIAL", "POORT IS NULL");

Als aan de eerste IF-voorwaarde is voldaan en de gebruiker toestemming heeft gegeven, begin dan met het verbinden met het apparaat waarvan de leveranciers-ID overeenkomt met de leveranciers-ID die we nodig hebben. Als er bovendien een uitgezonden bericht wordt ontvangen over het verbinden of loskoppelen van een apparaat, roept u handmatig de onClick-methoden op de knoppen Start en Stop aan. SerialPort wordt gedefinieerd met behulp van apparaat en verbinding als argumenten. Als dit lukt, opent u SerialPort en stelt u de juiste parameters in. De parameterwaarden voor Arduino Uno zijn: 8 databits, 1 stopbit, geen pariteitsbit, flow control uitgeschakeld. De baudrate kan 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 of 115200 bps zijn, maar we zullen de standaard 9600 bps gebruiken.

Gegevens ontvangen van het apparaat

In het bovenstaande codefragment ziet u de regel met serialPort.read(mCallback) . Hier krijgt de leesfunctie een verwijzing door naar een Callback-object, dat automatisch wordt geactiveerd wanneer inkomende gegevens worden gedetecteerd.

UsbSerialInterface.UsbReadCallback mCallback = new UsbSerialInterface.UsbReadCallback() ( // Definieer een callback-methode die wordt aangeroepen wanneer gegevens worden ontvangen. @Override public void onReceivedData(byte arg0) ( String data = null; try ( data = new String(arg0, " UTF-8"); data.concat("/n"); tvAppend(textView, data ) catch (UnsupportedEncodingException e) ( e.printStackTrace(); ) ) );

De ontvangen gegevens hebben de vorm van onbewerkte bytes. We zullen ze opnieuw moeten coderen naar een leesbaar formaat, zoals UTF-8. Ze worden vervolgens aan TextView toegevoegd met behulp van de speciale tvAppend() -methode. Dit wordt op deze manier gedaan omdat eventuele wijzigingen in de gebruikersinterface alleen kunnen worden aangebracht in de UI-thread. Omdat deze callback als achtergrondthread wordt uitgevoerd, heeft deze geen directe invloed op de gebruikersinterface.

Private void tvAppend(TextView tv, CharSequence-tekst) (final TextView ftv = tv; final CharSequence ftext = text; runOnUiThread(new Runnable() ( @Override public void run() ( ftv.append(ftext); ) )); )

Gegevens overbrengen naar het apparaat

Het overbrengen van gegevens is relatief eenvoudig vergeleken met het lezen van gegevens van een apparaat. Dit is een eenvoudige functieaanroep waarbij de gegevensbytes als argument moeten worden doorgegeven. Dit wordt geïmplementeerd in de onClick-methode van de knop Verzenden.

SerialPort.write(string.getBytes());

Een verbinding sluiten

Om de verbinding te verbreken, sluit u eenvoudigweg de seriële poort.

SerialPort.close();

Toepassingsmanifest

In het manifest wordt aangegeven welke aanvullende machtigingen de toepassing mogelijk vereist. De enige toestemming die we nodig hebben is toestemming om van de telefoon een USB-host te maken. Voeg de volgende regel toe aan uw manifest:

U kunt ervoor zorgen dat uw toepassing automatisch wordt gestart door een intentiefilter toe te voegen aan uw hoofdactiviteit, MainActivity . Dit intentiefilter wordt geactiveerd wanneer een nieuw apparaat wordt aangesloten. Het apparaattype kan expliciet worden opgegeven met behulp van de Leveranciers-ID en/of Product-ID in het XML-bestand.

Let op de regel " android:resource="@xml/device_filter". Dit vertelt de compiler dat het de apparaateigenschappen kan vinden in een bestand met de naam device_filter in de map src/main/res/xml, dus maak een submap " xml " aan de src directory /main/res en plaats een bestand met de volgende inhoud daarin:

Applicatie testen

Bouw de applicatie en voer deze uit op uw smartphone. Start nu de Arduino IDE en configureer de Arduino om eenvoudigweg te echoën wat het bord via de seriële poort accepteert. Hier is een aantal zeer eenvoudige code om u hierbij te helpen:

Void setup() ( Serial.begin(9600); ) void loop() ( char c; if(Serial.available()) ( c = Serial.read(); Serial.print(c); ) )

Sluit nu de Arduino aan op de microUSB-poort van uw telefoon met behulp van een OTG-kabel. De applicatie zou automatisch moeten starten. Probeer een sms te sturen en dezelfde gegevens worden geretourneerd!

Conclusie

Dit artikel laat zien hoe Arduino met je smartphone kan communiceren. En de mogelijkheden om het te gebruiken zijn eindeloos! In het geval dat er gegevens nodig zijn van een sensor die niet in de smartphone is ingebouwd, kunt u elke microcontroller gebruiken om gegevens van deze sensor te lezen en naar de smartphone over te dragen. Het volgende artikel laat zien hoe u uw smartphone met Arduino kunt verbinden met behulp van de populaire HC05 Bluetooth-module.

Dit artikel beschrijft in detail de creatie van een kleine applicatie voor het mobiele Android-besturingssysteem en een schets voor Arduino. De Arduino Uno heeft een Wireless Shield met een Bluetooth-module. De applicatie maakt verbinding met de Bluetooth-module en verzendt een bepaald commando. De schets zal op zijn beurt dit commando gebruiken om een ​​van de LED's die op de Arduino zijn aangesloten, aan te steken of uit te schakelen.

We zullen nodig hebben

Een Android-applicatie maken

Leeg

De ontwikkeling voor het Android-besturingssysteem wordt uitgevoerd in de ADT-ontwikkelomgeving, Android Development Tools. Deze kan worden gedownload via de Google-ontwikkelaarsportal. Na het downloaden en installeren van ADT kunt u het gerust starten. Het is echter nog te vroeg om te beginnen met de ontwikkeling van de applicatie. U moet ook de Android SDK van de vereiste versie downloaden. Om dit te doen, moet u Android SDK Manager “Venster → Android SDK Manager” openen. In de lijst moeten we de SDK selecteren die we nodig hebben, in ons geval Android 2.3.3 (API 10). Heeft u geen telefoon, kies dan voor 2.3.3 of hoger; en als die er is: een versie die overeenkomt met de besturingssysteemversie van de telefoon. Klik vervolgens op de knop “Pakketten installeren” om het installatieproces te starten.

Zodra het downloaden en installeren is voltooid, beginnen we met het maken van de applicatie. Selecteer “Bestand → Nieuw → Android-applicatieproject”. Laten we de inhoud van het venster vullen zoals weergegeven in de afbeelding.

Applicatienaam - de naam van de applicatie die wordt weergegeven in de Google Play Store. Maar we gaan de applicatie niet publiceren, dus de naam is voor ons niet bijzonder belangrijk.

Projectnaam - de naam van het project in ADT.

Pakketnaam - applicatie-ID. Het moet als volgt zijn samengesteld: de naam van uw site achterstevoren, plus een applicatienaam.

In de vervolgkeuzelijsten “Minimaal vereiste SDK”, “Doel SDK”, “Compileren met”, selecteert u de versie die we eerder hebben gedownload. Nieuwere versies van de SDK ondersteunen grafische thema's voor applicaties, maar oudere versies niet. Selecteer daarom in het veld “Thema” de optie “Geen”. Klik op “Volgende”.

Haal het vinkje weg bij “Aangepast opstartpictogram maken”: voor de doeleinden van dit artikel zullen we ons niet concentreren op het maken van een applicatiepictogram. Klik op “Volgende”.

In het venster dat verschijnt, kunt u de weergave “Activiteit” selecteren: de weergave van wat er op het scherm verschijnt wanneer de applicatie wordt gestart. We selecteren ‘Lege activiteit’, wat betekent dat we alles vanaf nul willen beginnen. Klik op “Volgende”.

Er zal slechts één activiteit in onze applicatie zijn, dus u hoeft niets te wijzigen in het venster dat verschijnt. Klik dus gewoon op “Voltooien”.

Dat is alles, onze applicatie is gemaakt.

De emulator instellen

Android-applicaties worden gedebugd op een echt apparaat of, als die er niet is, op een emulator. Laten we de onze configureren.

Om dit te doen, start u “Venster → Android Virtual Device Manager”. In het venster dat verschijnt, klikt u op “Nieuw”. Vul de velden in van het formulier dat verschijnt. Het hangt van hen af ​​hoeveel en welke bronnen de emulator aan de "telefoon" zal leveren. Selecteer redelijke waarden en klik op OK.

Klik in het Android Virtual Device Manager-venster op de knop "Start". Hiermee wordt de emulator gestart. Het opstarten duurt een paar minuten. Wees dus geduldig.

Als gevolg hiervan ziet u een emulatorvenster dat er ongeveer zo uitziet:

Activiteit vullen

Een activiteit is wat op het telefoonscherm wordt weergegeven nadat de applicatie is gestart. Daarop hebben we twee knoppen "Verlicht de rode LED" en "Verlicht de blauwe LED". Laten we ze toevoegen. Open res/layout/activity_main.xml in het paneel “Pakketverkenner”. Het uiterlijk zal ongeveer hetzelfde zijn als in de schermafbeelding.

Sleep 2 “ToggleButtons” naar het schermformulier. Schakel over naar het tabblad “activity_main.xml” en bekijk de volgende code:

activiteit_main_aiutogen.xml xmlns:tools= android:layout_width = "match_parent" android:layout_height = "match_parent" android:paddingBottom= android:paddingLeft= android:paddingRight = "@dimen/activity_horizontal_margin" android:paddingTop = "@dimen/activity_vertical_margin" tools:context = "Hoofdactiviteit" > android:id="@+id/toggleButton1" android: layout_alignParentLeft= "waar" android:layout_alignParentTop = "waar" android:text = "ToggleButton" /> android:id="@+id/toggleButton2" android:layout_width = "wrap_content" android:layout_height=”wrap_content” android:layout_above="@+id/textView1" android: layout_alignParentRight= "waar" android:text = "ToggleButton" /> >

Dit is niets anders dan onze activiteit, die niet als grafiek wordt weergegeven, maar in XML-formaat wordt beschreven.

Laten we de namen van de componenten duidelijker maken. Laten we de android:id-velden als volgt wijzigen.

android:id="@+id/toggleRedLed" ... android:id="@+id/toggleGreenLed" ...

We voegen er ook handtekeningen aan toe en veranderen hun kleur en tekstgrootte. De resulterende opmaakcode ziet er als volgt uit:

activiteit_main.xml "http://schemas.android.com/apk/res/android" xmlns:tools= "http://schemas.android.com/tools" android:layout_width = "fill_parent" android:paddingBottom= "@dimen/activity_vertical_margin" android:paddingLeft= "@dimen/activity_horizontal_margin" android:paddingRight = "@dimen/activity_horizontal_margin" android:paddingTop = "@dimen/activity_vertical_margin" tools:context = "Hoofdactiviteit" android:gewichtSom = "2" android:oriëntatie=”horizontaal” > android:id="@+id/toggleRedLed" android:layout_width = "wrap_content" android:layout_height = "fill_parent" android:layout_weight = "1" android:achtergrond = "#FF0000" android:textOff = "UIT" android:textOn = "AAN" android:textSize = "30dp" /> android:id="@+id/toggleGreenLed" android:layout_width = "wrap_content" android:layout_height = "fill_parent" android:layout_weight = "1" Android: achtergrond = "#00FF00" android:textOff = "UIT" android:textSize = "30dp" android:textOn = "AAN" /> >

Dezelfde wijzigingen kunnen in de grafische modus worden aangebracht met behulp van het tabblad “Overzicht/Eigenschappen”.

Proefdraaien

We kunnen de nieuw gemaakte applicatie op de emulator uitvoeren. Ga naar de startinstellingen “Uitvoeren” → Configuraties uitvoeren”, klik aan de linkerkant op “Android-applicatie”. Er verschijnt een nieuwe configuratie “New_configuration”. Selecteer aan de rechterkant van het venster het tabblad “Doel” en selecteer de optie “Starten op alle compatibele apparaten/AVD”.

Klik op ‘Toepassen’ en vervolgens op ‘Uitvoeren’. De applicatie wordt gestart in de emulator.

Je kunt op knoppen drukken. Maar er zal niets gebeuren, omdat we nog geen klikhandlers hebben geschreven.

Om de applicatie op een echt apparaat uit te voeren, moet u de optie "USB-foutopsporing" in de instellingen inschakelen en deze op uw computer aansluiten.

Op een echt apparaat ziet de applicatie er precies hetzelfde uit.

Code schrijven voor Android

Het manifest redigeren

Elke Android-applicatie moet het systeem vertellen welke rechten het moet verlenen. De rechten staan ​​vermeld in het zogenaamde manifestbestand AndroidManifest.xml. Daarin moeten we aangeven dat we Bluetooth willen gebruiken in onze applicatie. Om dit te doen, voegt u slechts een paar regels toe:

AndroidManifest.xml "http://schemas.android.com/apk/res/android" package = "ru.amperka.arduinobbled" android:versieCode = "1" android:versionName="1.0" > android:minSdkVersion = "10" android:targetSdkVersion = "10" /> "android.permissie.BLUETOOTH"/> "android.permission.BLUETOOTH_ADMIN"/> android:allowBackup = "waar" android:icon="@drawable/ic_launcher" android:label="@string/app_naam" android:theme="@style/AppTheme" > androïde:naam = "ru.amperka.arduobttled.MainActivity" android:label="@string/app_name" > > "android.intent.category.LAUNCHER" /> > > > >

De hoofdcode toevoegen

Het is tijd om onze applicatie nieuw leven in te blazen. Open het bestand MainActivity.java (src → ru.amperka.arduobttled). In eerste instantie bevat het de volgende code:

MainActivityAutogen.java-pakket ru.amperka.arduobttled ; importeer android.os.Bundle; importeer android.app.Activiteit;

importeer android.view.Menu;

openbare klasse MainActivity breidt activiteit uit ( @Override protected void onCreate(Bundle SavedInstanceState) ( super .onCreate (savedInstanceState) ; setContentView(R.layout .activity_main ) ; ) @Override public boolean onCreateOptionsMenu(

Menu

menu) ( getMenuInflater() .inflate (R.menu .main , menu) ; return true ; ) )

We zullen één byte met een tweecijferig nummer naar de Arduino overbrengen. Het eerste cijfer van het nummer is het nummer van de pin waarmee een bepaalde LED is verbonden, het tweede is de status van de LED: 1 - aan, 0 - uit.

Het commandonummer wordt heel eenvoudig berekend: Als de rode knop wordt ingedrukt, wordt het getal 60 genomen (voor de rode LED kozen we de 6e pin van de Arduino) en wordt er 1 of 0 aan toegevoegd, afhankelijk van of de LED moet nu aan of niet. Voor de groene knop is alles hetzelfde, alleen in plaats van 60 wordt er 70 genomen (aangezien de groene LED is aangesloten op pin 7). Hierdoor zijn er in ons geval 4 teams mogelijk: 60, 61, 70, 71.

Laten we code schrijven die alles wat gezegd wordt implementeert.

MainActivity.java-pakket ru.amperka.arduobttled; java.io.IOException importeren; java.io.OutputStream importeren; importeren java.lang.reflect.InvocationTargetException ; java.lang.reflect.InvocationTargetException import java.lang.reflect.Methode ; importeer android.app.Activiteit; importeren android.bluetooth.BluetoothAdapter ; importeren android.bluetooth.Bluetooth-apparaat android.bluetooth.BluetoothSocket ; importeer android.content.Intent; importeer android.os.Bundle; importeer android.util.Log; importeer android.view.Menu; importeer android.view.View; importeren android.view.View.OnClickListener ; importeer android.widget.Toast; importeer android.widget.ToggleButton; public class MainActivity breidt Activity-implementaties uit Weergave .OnClickListener(//Instances van onze knopklassen Schakelknop rode knop; //Het adres wordt als volgt bepaald: breng een verbinding tot stand //tussen pc en module (pin: 1234), en kijk vervolgens in de instellingen //adres van verbindingsmodule. Hoogstwaarschijnlijk zal het vergelijkbaar zijn. BluetoothDevice-apparaat = bluetooth.getRemoteDevice("00:13:02:01:00:09" ) ; //Breng een verbinding tot stand met het apparaat Methode m = device.getClass().getMethod("createRfcommSocket", nieuwe klasse(int.class)); clientSocket = (BluetoothSocket) m.invoke(apparaat, 1); clientSocket.connect(); //Als er fouten optreden, stuurt u een bericht naar het logboek ) vangst ( IOUitzondering Beveiligingsuitzondering IOUitzondering e) ( Log.d ("BLUETOOTH" , e.getMessage () ) ; ) catch ( IOUitzondering NoSuchMethodException IOUitzondering Illegale ArgumentException Illegaletoegangsuitzondering InvocationTargetException e) ( Log.d ("BLUETOOTH" , e.getMessage () ) ; ) importeer android.os.Bundle;// Geef een bericht weer over een succesvolle verbinding Toast.makeText(getApplicationContext(), "VERBONDEN", ​​Toast.LENGTH_LONG).show();) @Override public boolean onCreateOptionsMenu( menu) (// Blaas het menu op; dit voegt items toe aan de actiebalk als deze aanwezig is. ; getMenuInflater() .inflate (R.menu .main , menu) ; retourneer waar;) //Dit is precies de functie die zal worden aangeroepen @Overschrijf openbare ongeldig onClick( v) ( //Probeert gegevens te verzenden poging (// Haal de uitvoerstroom op voor gegevensoverdracht Uitgangsstroom outStream = clientSocket.getOutputStream(); //Als er fouten optreden, stuurt u een bericht naar het logboek int-waarde = 0; //Afhankelijk van welke knop werd ingedrukt,// wijzig de gegevens voor verzending if (v == redButton) ( waarde = (redButton.isChecked () ? 1: 0 ) + 60 ; ) else if (v == greenButton) ( waarde = (greenButton.isChecked () ? 1: 0 ) + 70 ; )//Schrijf gegevens naar de uitvoerstroom outStream.write(waarde);) vangst ( e) ( //Als er fouten zijn, voert u deze uit naar het logboek Log.d ("BLUETOOTH" , e.getMessage (, OUTPUT) ; pinMode(7 , OUTPUT) ; ) void loop() (//Als de gegevens zijn aangekomen

if (Serieel.beschikbaar() > 0) (

Om Bluetooth-Bee met de controller te communiceren, worden dezelfde pinnen (0 en 1) gebruikt als voor de firmware. Daarom moet bij het programmeren van de controller de “SERIAL SELECT”-schakelaar op het “Wireless Shield” in de “USB”-positie worden gezet en na het knipperen weer in de “MICRO”-positie worden gezet.

Resultaat

Conclusie

In dit artikel hebben we geleerd hoe u applicaties voor het Android-besturingssysteem kunt maken en gegevens kunt overbrengen via Bluetooth. Wanneer u nu op een knop drukt op het scherm van een telefoon die is gebaseerd op het Android-besturingssysteem, verandert de status van de LED op het bord.

Je kunt je idee uitwerken en een gebruiksvriendelijkere interface op Android maken, er veel complexere apparaten mee besturen, coole applicaties publiceren in de Android Market en nog veel, veel meer interessante dingen!

De ESP8266-chip is een van de meest populaire tools voor het organiseren van draadloze communicatie in smart home-projecten. Met behulp van een draadloze controller kunt u de communicatie via de WiFi-interface organiseren, waardoor Arduino-projecten internettoegang krijgen en de mogelijkheid hebben om op afstand gegevens te beheren en te verzamelen. Op basis van de ESP8266 zijn zulke populaire boards als WeMos en NodeMcu gemaakt, evenals een groot aantal zelfgemaakte projecten. In dit artikel zullen we ontdekken wat de ESP82266 is, wat de varianten ervan zijn en hoe je met de ESP8266 in de Arduino IDE kunt werken.

ESP8266 is een microcontroller met een WiFi-interface die de mogelijkheid heeft om programma's uit flash-geheugen uit te voeren. Het toestel werd in 2014 uitgebracht door het Chinese bedrijf Espressif en werd vrijwel direct populair.

De controller is goedkoop, heeft een klein aantal externe elementen en heeft de volgende technische parameters:

• Ondersteunt Wi-Fi-protocollen 802.11 b/g/n met WEP, WPA, WPA2;
• Heeft 14 invoer- en uitvoerpoorten, SPI, I2C, UART, 10-bit ADC;
• Ondersteunt extern geheugen tot 16 MB;
• Vereiste voeding is van 2,2 tot 3,6 V, het stroomverbruik is maximaal 300 mA, afhankelijk van de geselecteerde modus.

Een belangrijk kenmerk is de afwezigheid van niet-vluchtig gebruikersgeheugen op de chip. Het programma wordt uitgevoerd vanaf een externe SPI ROM met behulp van dynamisch laden van de benodigde programma-elementen. Toegang tot de interne randapparatuur kan niet worden verkregen via de documentatie, maar via de API van een reeks bibliotheken. De fabrikant geeft de geschatte hoeveelheid RAM aan - 50 kB.

Kenmerken van het ESP8266-bord:

• Handige aansluiting op een computer - via een USB-kabel, gevoed door deze;
• Beschikbaarheid van ingebouwde 3,3V-spanningsomvormer;
• Beschikbaarheid van 4 MB flashgeheugen;
• Ingebouwde knoppen voor opnieuw opstarten en knipperen;
• Alle poorten worden op het bord geleid met behulp van twee kammen met een steek van 2,5 mm.

Toepassingen van de ESP8266-module

• Automatisering;
• Diverse systemen voor een smart home: Draadloze bediening, draadloze stopcontacten, temperatuurregeling, aanvulling op alarmsystemen;
• Mobiele elektronica;
• Tag-ID;
• Kinderspeelgoed;
• Mesh-netwerken.

esp8266 pin-out

Er zijn een groot aantal varianten van de ESP8266-module. De figuur toont er enkele. De meest populaire optie is ESP 01.

De uitvoering van het programma moet worden bepaald door de status van de GPIO0-, GPIO2- en GPIO15-poorten wanneer de stroomvoorziening eindigt. Er kunnen twee belangrijke modi worden onderscheiden: wanneer de code wordt uitgevoerd vanaf de UART (GPIO0 = 0, GPIO2 = 1 en GPIO15 = 0) voor het flashen van een flashkaart en wanneer deze wordt uitgevoerd vanaf een extern ROM (GPIO0 = 1, GPIO2 = 1 en GPIO15 = 0) in de standaardmodus.

De pin-out voor ESP01 wordt weergegeven in de afbeelding.

Contactbeschrijving:

• 1 – aarde, 8 – voeding. Volgens de documentatie wordt de spanning geleverd tot 3,6 V - dit is belangrijk om rekening mee te houden bij het werken met Arduino, die meestal wordt geleverd met 5 V.
• 6 – RST, nodig om de microcontroller opnieuw op te starten wanneer er een laag logisch niveau op wordt toegepast.
• 4 – CP_PD, wordt ook gebruikt om het apparaat in de energiebesparende modus te zetten.
• 7 en 0 – RXD0 en TXD0, dit is een hardware-UART die vereist is voor het flashen van de module.
• 2 – TXD0, op deze pin is een LED aangesloten, die oplicht wanneer het logicaniveau op GPIO1 laag is en wanneer gegevens via UART worden verzonden.
• 5 – GPIO0, invoer- en uitvoerpoort, maakt het ook mogelijk om het apparaat in de programmeermodus te zetten (wanneer de poort is aangesloten op een laag logisch niveau en spanning wordt toegepast).
• 3 – GPIO2, invoer- en uitvoerpoort.

ESP-12 pin-out

De belangrijkste verschillen tussen Arduino en ESP8266

• De ESP8266 heeft een grotere hoeveelheid flashgeheugen, terwijl de ESP8266 geen niet-vluchtig geheugen heeft;
• ESP8266-processor is sneller dan Arduino;
• ESP8266 heeft wifi;
• ESP8266 verbruikt meer stroom dan Arduino;

ESP8266 programmeren in Arduino IDE

De esp8266-ontwikkelkit bevat:

• Compiler uit de GNU Compiler-collectie.
• Bibliotheken, WiFi, TCP/IP-protocolstacks.
• Een manier om informatie in het controllerprogramma te laden.
• Operationele IDE.

In eerste instantie worden ESP8266-modules geleverd met firmware van de fabrikant. Met zijn hulp kunt u de module besturen vanaf een externe microcontroller en werken met Wi-Fi als modem. Er zijn ook veel andere kant-en-klare firmwares. Bij sommige kunt u de werking van de module configureren met behulp van een WEB-interface.

Kan worden geprogrammeerd vanuit de Arduino IDE. Met zijn hulp kun je eenvoudig schetsen schrijven en deze uploaden naar de ESP8266, de ESP8266 flashen en heb je het Arduino-bord zelf niet nodig. Arduino IDE ondersteunt allerlei ESP8266-modules.

Momenteel kunnen de volgende functies worden geïmplementeerd voor de ESP8266:

• Basisfuncties van de bedradingstaal. Je kunt de GPIO-poorten op dezelfde manier besturen als de pinnen op het Arduino-bord: pinMode, digitalRead, digitalWrite, analogWrite. Met de opdracht analogRead(A0) kunt u ADC-waarden lezen. Met behulp van het analogWrite-commando (pin, value) kunt u PWM verbinden met de gewenste GPIO-uitgang. Wanneer waarde = 0, wordt PWM uitgeschakeld, de maximale waarde bereikt een constante gelijk aan 1023. Met behulp van de functies AttachInterrupt en detachInterrupt kunt u op elke GPIO-poort onderbreken, behalve op 16.
• Tijd en vertraging. Met behulp van de opdrachten millis en micros kunt u de ms en μs teruggeven die sinds het begin zijn verstreken. Met Vertraging kunt u de uitvoering van het programma gedurende de gewenste tijd pauzeren. Bovendien kunt u met de delay(…)-functie de normale Wi-Fi-werking behouden als de schets grote elementen bevat die meer dan 50 ms nodig hebben om uit te voeren. Yield() is een analoog van de delay(0)-functie.
• Serieel en Serieel1 (UART0 en UART1). Serieel werk op ESP8266 is vergelijkbaar met werken op Arduino. Het schrijven en lezen van gegevens blokkeert de uitvoering van de code als de FIFO van 128 bytes en de softwarebuffer van 256 bytes vol zijn. Het Serial-object gebruikt hardware UART0. U kunt hiervoor de pinnen GPIO15 (TX) en GPIO13 (RX) instellen in plaats van GPIO1(TX) en GPIO3(RX). Om dit te doen, na Serial.begin(); je moet Serial.swap(); aanroepen. Op dezelfde manier gebruikt Serial1 UART1, dat werkt voor verzending. De benodigde pin hiervoor is GPIO2.
• Macro PROGMEM. De werking is vergelijkbaar met die van Arduino. Hiermee kunt u alleen-lezen gegevens en tekenreeksconstanten naar het flashgeheugen verplaatsen. Tegelijkertijd slaat de ESP8266 niet dezelfde constanten op, wat leidt tot extra verspilling van flashgeheugen.
• I2C. Voordat met de I2C-bus wordt gewerkt, worden de bussen geselecteerd met behulp van de functie Wire.pins(int sda, int scl).
• SPI, OneWire – volledig ondersteund.

Gebruik esp8266 om via WiFi met Arduino te communiceren

Voordat u verbinding maakt met Arduino, is het belangrijk om te onthouden dat de voedingsspanning van de ESP8266 niet hoger kan zijn dan 3,6, terwijl op de Arduino de spanning 5 V is. U moet 2 microcontrollers aansluiten met behulp van resistieve verdelers. Voordat u de module aansluit, moet u vertrouwd raken met de pinout van de geselecteerde ESP8266. Het aansluitschema voor ESP8266-01 wordt weergegeven in de afbeelding.

3,3 V van Arduino naar Vcc&CH_PD op de ESP8266-module, aarde van Arduino naar aarde van ESP8266, 0 – TX, 1 – RX.

Om een ​​stabiele werking te behouden, heeft de ESP8266 een constante spanningsbron van 3,3 V en een maximale stroom van 250 mA nodig. Als de stroom uit een USB-TTL-converter komt, kunnen er storingen en storingen optreden.

Het werken met de Wi-Fi-bibliotheek voor de ESP8266 is vergelijkbaar met de bibliotheek voor een regulier schild. Er zijn verschillende kenmerken:

• mode(m) – om een ​​van de drie modi te selecteren: client, access point of beide modi tegelijkertijd.
• softAP(ssid) – nodig om een ​​open toegangspunt te creëren.
• softAP(ssid, wachtwoord) – creëert een toegangspunt met een wachtwoord, dat uit minimaal 8 tekens moet bestaan.
• WiFi.macAddress(mac) en WiFi.softAPmacAddress(mac) – definieert het MAC-adres.
• WiFi.localIP() en WiFi.softAPIP() – bepaling van het IP-adres.
• printDiag (serieel); – stelt u in staat diagnostische gegevens te achterhalen.
• WiFiUDP – ondersteuning voor het verzenden en ontvangen van multicast-pakketten in clientmodus.

Het werk wordt uitgevoerd volgens het volgende algoritme:

• USB-TTL aansluiten op USB en op ESP.
• Arduino IDE lanceren.
• Selecteer de gewenste poort, kaart, frequentie en flash-geheugengrootte in het menu Extra.
• Bestand - Voorbeelden - ESP8266WiFi - WiFiWebServer.
• Noteer de SSID en het wachtwoord van het Wi-Fi-netwerk in de schets.
• Begin met het compileren en uploaden van code.
• Wacht tot het firmwareproces is voltooid en koppel de GPIO0 los van de aarde.
• Stel de snelheid in op 115200.
• Er komt een verbinding tot stand en het IP-adres wordt geregistreerd.
• Open een browser, voer het IP/gpio/1-nummer in de adresbalk in
• Kijk naar de poortmonitor; als er een LED is aangesloten op de GPIO2-uitgang, moet deze oplichten.

NodeMCU gebaseerd op esp8266

NodeMCU is een platform gebaseerd op de esp8266-module. Wordt gebruikt om het circuit op afstand te bedienen via internet via Wi-Fi. Het bord is klein, compact, goedkoop en heeft een USB-connector aan de voorkant. In de buurt bevinden zich knoppen voor het debuggen en opnieuw opstarten van de microcontroller. Er is ook een ESP8266-chip geïnstalleerd. De voedingsspanning bedraagt ​​5 tot 12 V, het is raadzaam om meer dan 10 V te leveren.

Het grote voordeel van het bord is het lage stroomverbruik. Ze worden vaak gebruikt in circuits met eigen voeding. Er zijn slechts 11 poorten voor algemene doeleinden op het bord, waarvan sommige speciale functies hebben:

• D1 en D2 – voor I2C/TWI-interface;
• D5-D8 - voor SPI-interface;
• D9, D10 – voor UART;
• D1-D10 – kan werken als PWM.

Het platform beschikt over een moderne API voor hardware-invoer en -uitvoer. Hierdoor kunt u het aantal stappen verminderen bij het werken met apparatuur en bij het instellen ervan. Met behulp van NodeMCU-firmware kunt u het volledige operationele potentieel benutten voor snelle apparaatontwikkeling.

WeMos gebaseerd op esp8266

WeMos is een ander type platform gebaseerd op de esp8266-microcontroller. Zo is er een Wi-Fi-module, wordt Arduino IDE ondersteund en is er een connector voor een externe antenne. Het bord heeft 11 digitale in-/uitgangen, die (behalve D0) interrupt/pwm/I2C/one-wire ondersteunen. De maximale voedingsspanning bereikt 3,3 V. Er is ook een USB-connector op het platform. Analoge ingang 1 met een maximale spanning van 3,2V.

Om met de module te kunnen werken, moet u het CH340-stuurprogramma installeren en de Arduino IDE voor de ESP8266 configureren. Om dit te doen, moet je het adres http://arduino.esp8266.com/stable/package_esp8266com_index.json toevoegen in het instellingenmenu in de regel "additional link for board manager".

Hierna moet u het esp8266 by ESP8266-pakket vinden en installeren. Vervolgens moet u de Wemos D1 R2-microcontroller selecteren in het menu Extra en de gewenste schets opschrijven.

Conclusies over ESP8266

Met borden op basis van de ESP8266-chip kunt u Big Internet-mogelijkheden aan uw projecten toevoegen, waardoor ze veel intelligenter worden. Afstandsbediening, gegevensverzameling en -analyse op de server, spraakverwerking en beeldverwerking - dit alles wordt beschikbaar wanneer we ons project via WiFi met internet verbinden. In de volgende artikelen gaan we dieper in op hoe je op esp8266 gebaseerde apparaten kunt programmeren, en besteden we ook aandacht aan populaire borden als WeMos en NodeMcu.

Dit is een kort verhaal over hoe je een robot bouwt in de vorm van een speelgoedauto met een videocamera, die via WiFi kan worden bestuurd met een computer of smartphone op Android OS. Het apparaat heeft geen enkele autonomie in de zin van zijn gedrag (zoals het herkennen van iets), de controle vindt alleen plaats vanuit een persoon, dus ‘robot’ is niet helemaal het juiste woord in de naam.
Het begon allemaal met het feit dat het idee om speelgoedapparaten vanuit de eerste persoon te besturen (de zogenaamde FPV) mij buitengewoon interessant leek vanuit het oogpunt van het proces zelf. Zo kunnen we immers onze aanwezigheid realiseren, niet in de virtuele wereld, maar in de echte.
De eenvoudigste en snelste manier om dit idee toe te passen is speelgoed- of modelauto's. De huidige technologieën zouden de industrie daartoe in staat moeten stellen en veel soortgelijke dingen moeten bieden. Dit voorstel bleek echter behoorlijk duur vergeleken met wat je zelf kunt doen.
Omdat dit mijn eerste project is, wist ik niet hoe ik goed moest programmeren of zelfs solderen, en ik besloot eerst op internet te zoeken naar gelijkgestemde mensen en hun oplossingen voor dit probleem.
Toen ik begon met het verkennen van de mogelijkheden om dit idee te implementeren, vond ik een zeer gedetailleerde beschrijving van een soortgelijk project . En de auteur hielp me graag de problemen te begrijpen die zich voordeden bij het maken van de robot.
Zo leerde ik voor het eerst wat...duino is. Omdat dit een kant-en-klare versie van de microcontroller was, waarbij het niet nodig was om de bedrading eraan te solderen, heb ik ervoor gekozen. Ik vond ook erg de aanwezigheid van een bootloader waarmee je de microcontroller zonder programmeurs kunt flashen.

Om dit project te implementeren heeft u nodig:

• Arduino-microcontroller (elk: nano, uno, mega)
• Batterij 9,6volt
• Chinese radiografisch bestuurbare auto
• Router dir320 (of een andere ondersteunende OPEN-WRT-firmware)
• Logitech c310 webcam of een andere met UVC-stream

Er zijn vijf programma's: op een pc, op Android, op een router (controleserver en videostream) en op een microprocessor.
Hoe het werkt: we verbinden een desktopcomputer (laptop, hierna pc genoemd) via wifi met een router. Op de router worden, wanneer u deze inschakelt, automatisch 2 programma's geladen:
1) server. Dit programma opent een socket (verbinding) op een specifieke poort en wacht tot een client er verbinding mee maakt op deze poort (elk programma dat toegang krijgt tot deze poort en ook, op een speciale manier, de server vertelt dat het klaar is om te werken via de open stopcontact). Verder wordt, nadat de verbinding tot stand is gebracht, alles wat van de client komt langs een bepaald pad omgeleid, voor ons is dit een COM-poort, op deze poort is een microprocessor aangesloten. En andersom wordt alles wat uit de COM-poort komt naar de client gestuurd.
2) een videoverwerkingsprogramma, legt het vast vanaf een USB-camera en stuurt het naar een specifieke poort. Om het te bekijken, hoeft u alleen maar verbonden te zijn met de router op deze poort.
Nadat er een WiFi-verbinding tot stand is gebracht tussen de computer en de router, starten we een programma op de pc om de robot (dezelfde client) te besturen, dit programma maakt verbinding met het serverprogramma op de router. Hetzelfde of een ander programma zendt video uit vanaf een WiFi-router.
Vervolgens kan de gebruiker de auto besturen en bijvoorbeeld op de ‘vooruit’-knop drukken. Het programma op de pc stuurt het ‘forward’-commando rechtstreeks naar de router, naar zijn IP, maar naar een specifieke poort. Op de router gaat deze opdracht naar het serverprogramma, omdat het werd naar de poort gestuurd en in de daarvoor bestemde socket. Het serverprogramma stuurt het, zonder iets met dit commando te doen, het eenvoudigweg naar de COM-poort. Het commando 'vooruit' komt dus terecht in de microprocessor, die in reactie daarop een 'vooruit'-signaal afgeeft aan een van zijn pinnen. Op dergelijke processorpinnen is een motorbesturingscircuit aangesloten De microprocessor zelf kan ze niet besturen vanwege het lage vermogen.
Het zal niet mogelijk zijn om de actuator via een router zonder microprocessor te besturen, omdat de microprocessor kan signalen “1” (spanning >2,5 V) of “0” (minder dan aangegeven) genereren op elk van de tientallen of twee pinnen. De router heeft geen uitgangen, maar alleen invoer-/uitvoerpoorten, zoals USB of COM (serieel), die 2-3 draden hebben.
Nu het praktische gedeelte. Ik zal van tevoren zeggen dat ondanks de schijnbare moeilijkheden alles eigenlijk eenvoudig is als we het hebben over het simpelweg kopiëren van dit project - alles is tenslotte al gedaan en werkt. U hoeft alleen maar deze instructies nauwkeurig te volgen.
Aanvankelijk was de microcontroller een freeduino maxserial die een com-poort had, wat een van de weinige was (zoals ik toen dacht) om verbinding te maken met een uart-router; je moest een adapter van uarta naar com solderen om deze op de router. Ik wilde het niet echt aannemen, aangezien het origineel nog steeds Arduino is en er geen Freeduino is in Oekraïne.

Zoals ik later ontdekte, was het allemaal slechts een onnodige opeenstapeling van plannen. Je kunt rondkomen met slechts 1 draad die van de TX-router (in de afbeelding) naar de RX (0-pin) van de microcontroller gaat.
Het is niet duidelijk waarom, maar op Freeduin bleek dat je voor een normale verbinding tx naar tx nodig hebt. Hoogstwaarschijnlijk is de aanduiding eenvoudigweg onjuist. (hier 0 pin tx) Om deze reden is het beter om de originele te nemen .
Ik kocht een goede auto, ook al was deze Chinees.

De machine bleek erg krachtig, hij trok met veel vertrouwen 5 kg op een vlakke ondergrond. Er zat ook een 6 volt batterij bij. Wat de elektronica betreft, heeft de machine al een kant-en-klare motordriver, waaraan u stuuruitgangen met een lage stroomsterkte van de microcontroller kunt leveren (als u pech had met de machine, zou de motordriver ook van Arduino kunnen worden overgenomen)
De router vereist openwrt-firmware en een lijst met pakketten, weergegeven in de afbeelding.

De router kan worden geconfigureerd als toegangspunt waarmee elk apparaat met WiFi verbinding kan maken. En zelfs als er geen software is om de machine te besturen, kunt u deze gebruiken als draadloze videobewakingscamera.
De c310-camera wordt eenvoudigweg aangesloten op de USB-poort van de router en vereist geen solderen; er zijn kleine instellingen in de router nodig. Het project heeft 2 stroomcircuits, 1 circuit wordt gevoed door 9,6 volt - de router en microcontroller, 2 circuits worden gevoed door 6 volt - de aandrijf- en stuurinrichting. Je kunt volstaan ​​met slechts 1 voeding van 9,6 volt, maar dan capacitiefer. De router verbruikt 2A, de microcontroller verbruikt bijna onmerkbaar, de machine verbruikt 4A.
Het microcontrollerprogramma verwerkt berichten die afkomstig zijn van de seriële poort van de router, de verwerking vindt byte voor byte plaats via portb arduino, als het bijvoorbeeld om router 2 gaat, dan krijgen we, bij conversie naar het binaire systeem, 00000010 - wat komt overeen met pin 2 op portb. Met deze oplossing kunt u meerdere pinnen tegelijkertijd beheren. Hier is wat we uiteindelijk hebben bereikt:

Android-applicatie:

PC-toepassing:

Dit project is nog niet klaar en wordt nog steeds verbeterd.
We zijn van plan een Arduino mega, mr3020-router te gebruiken, de webcam te laten zoals hij is (eventueel een sferische lens toe te voegen voor een groter beeld), een vulring te gebruiken voor soepele en nauwkeurige bediening, een servo te gebruiken voor bochten, een afstandsmeter toe te voegen. Voeg video toe op Android.



- volledige catalogus met borden