Transkripte
1. Einführung in diesen Kurs: Einführungen und
objektorientierter Ansatz mit Arduino und ESPs. Hallo und willkommen zu
diesem Online-Kurs. Ich bin draußen, weil es weiß, dass ich
ein Senior Developer in
der Laborumgebung bin , aber auch in Embedded-Systemen. In diesem Online-Kurs verfolge
ich praktischen Ansatz, dass wir gemeinsam einige Projekte
aufbauen. Zunächst gehen wir
die Theorie mindestens durch, implementieren
aber auch
im ersten Kapitel
die ersten Klassen
und drucken Code auf dem seriellen Monitor aus . Im nächsten Beispiel steuern
wir LEDs
zur Laufzeit in
verschiedenen Zuständen. Und das ist einer
der Hauptvorteile mit dem objektorientierten
Ansatz, den wir
hier viele
Dinge mit verschiedenen
Komponenten in Echtzeit
bearbeiten und anpassen können hier viele
Dinge mit verschiedenen
Komponenten in Echtzeit
bearbeiten und anpassen . Was ich mit verschiedenen
Staaten gleichzeitig meine. Wir haben es auch
mit anderen Komponenten zu tun, zum Beispiel Infrarotsensoren. Wenn wir also zehn
oder mehr Sensoren haben, wie können wir sie auswerten? initiieren wir. Du machst das zum Beispiel mit
einem Array. Und ich zeige Ihnen, wie
wir sie kontrollieren
und auf
einfache und bequeme Weise bewerten können . In der
Arduino-Umgebung
entwickeln wir in Embedded-Systemen
mit Mikrocontrollern. Dann müssen wir uns auch
mit eingeschränkter Verwendung in Büchern auseinandersetzen. Und dies ist eines unserer
nächsten beiden Beispiele. Wir kreieren eine Stirnlampe. Dieser Scheinwerfer hat nur einen Stoß. Dieser Druckknopf. Wir steuern drei
verschiedene Arten von leichter Stimme. Die erste ist eine Verknüpfung ,
da die Schaltfläche eingeschaltet wird. Der zweite. Wir drücken
den Knopf für 1 Sekunde, Sekunde, LET geht weiter. Wenn Sie die Taste drücken und länger
als zwei Sekunden
gedrückt halten, passt
die erste LED in unser letztes Beispiel. Wir machen das klassische
Spiel Rock Paper Scissor mit mehreren Motoren und erstellen die Spiellogik selbst
objektorientiert nach . Wenn Sie daran
interessiert sind , Ihren
eigenen Quellcode auf
die nächste Stufe zu bringen , um
sauberer zu schreiben und zu codieren und auch
strukturierter zu schreiben. Zögern Sie nicht und warten Sie
länger und holen diese Klasse und diesen Code objektorientiert
bei mir. Ich freue mich,
Sie in diesem Online-Kurs begrüßen zu dürfen.
2. Praktische Erfahrung vs. Theorie: Bevor wir mit
dem Programmierteil beginnen, möchte
ich mich
auf ein großes Thema konzentrieren. Das bedeutet
Praxiserfahrung im Vergleich zur Theorie. Ich bin mir bewusst und ich bin mir sicher
, dass
viele von Ihnen langjährige Erfahrung in der
Programmierung und auch in der
Entwicklung von Programmen haben viele von Ihnen langjährige Erfahrung in der . Aber hier in dieser Umgebung möchte
ich ein
bisschen aufgeschlossener sein. Das bedeutet, dass Sie natürlich Ihre eigene
Herangehensweise an einige Dinge haben. Und vielleicht
fragst du dich, warum machst du das
zu kompliziert? Es gibt sicherlich einen anderen
Weg, wie wir
solche kleineren Code-Teile implementieren können , zum Beispiel ist das in Ordnung. Das ist vollkommen in Ordnung. Sie können sich an
alle meine Versionen an
Ihren Ansatz anpassen und auch individuell für Sie
implementiert werden. Es gibt immer einige
Diskussionen wenn es um
Programmiersprachen geht, wenn es um die Implementierung von
quellcodierten Daten geht. Und nehmen Sie es nicht zu ernst, seien Sie aufgeschlossen und passen Sie
es Ihnen bei der Annäherung an.
3. Voraussetzungen für diesen Kurs: Voraussetzungen. Was kann ich davon ausgehen, dass
Sie zu
diesem Online-Kurs mitbringen , den ich hier
vier Hauptpunkte
gesammelt habe . Ich würde gerne sehr transparent
hier sein. Was Sie erwarten können, macht den
Online-Kurs rückgängig und
was nicht abgedeckt wird. Der erste wird natürlich sein, dass Sie einige
grundlegende Programmierkenntnisse mitbringen sollten. Das bedeutet, dass Sie über
die verschiedenen Arten
von Datentypen Bescheid wissen sollten . Sie sollten wissen, was ist,
wenn es sich um die grundlegenden,
grundlegenden Kenntnisse der Programmierung handelt,
da dies hier nicht
wirklich behandelt wird. Natürlich habe ich erklärt, was ich
bei der gesamten Dekodierung und
dann im Quellcode mache , aber es steckt kein tieferes
Wissen dahinter. Der zweite Teil ist auch, dass ich alle
Schaltpläne
usw. auf dem ESP 32
abdecke . Natürlich sind alle diese
Objekte verschuldet. Quellcode ist
für die Arduino-Umgebung anwendbar. Wenn Sie jedoch eine
äußere Einheit verwenden, normal n, nano
usw., Es ist immer
das gleiche Konzept, der gleiche Quellcode. Aber seien Sie sich bewusst, dass ich den ESP 3200 verwende weil er eine
Wi-Fi-Verbindung hat. Es ist sehr billig und Sie können es für Geräte
des Internets der Dinge verwenden. Es ist aber auch für
die Arduino-Umgebung anwendbar. Ich verwende Visual Studio Code mit dem Blut für die
männliche Blockierung. Und es ist ein
bisschen anders als der ursprüngliche Gewerkschafts-EDI, aber Sie können es verwenden. Es spielt keine Rolle, denn
Quellcode ist C plus plus und er funktioniert in fast
jeder Programmierung, Programmierung, welche zu verwenden ist. Ich habe dir auch gezeigt,
wie du
meinen Quellcode verwenden und
im Arduino EDI implementiert hast. Der letzte, ich denke auch einer
der Hauptpunkte ist, dass Sie sich für
eine objektorientierte Programmierung interessieren
sollten eine objektorientierte Programmierung denn am
ersten Anfang
sieht es für Sie wie ein
bisschen mehr auf der Quellcode,
mehr Codezeilen. Aber wenn Sie die Beispiele
wie hier
durchgehen , sind die
LEDs, die er
die großen Vorteile sehen kann , wenn wir objektorientiert
codieren , weil wir
flexibler sind, können
wir uns anpassen
bestimmte Situationen und wir können wirklich,
wirklich coole Programme
mit verschiedenen Arten von Komponenten auf
einfache und schnelle Weise erstellen. Und deshalb bringe ich diesen Punkt mit, denn
am ersten
Anfang schreiben wir, sieht
so aus, als würden
wir mehr Code schreiben, aber er ist praktischer, machbarer und anpassungsfähiger.
4. Haftungsausschluss: Ein paar Gedanken
zum Haftungsausschluss. Ich habe versucht, so vorsichtig wie
möglich zu sein , wenn es um Kinematik
geht. Und die
Quelle ist präzise und schaut sie immer wieder an. Aber ich bin nicht frei
von Fehlern. Das bedeutet, dass
ich vielleicht einen Fehler
bei Bahrain-Teilen gemacht habe und du
bringst alles zusammen. Und dann tun USP zum Beispiel, eine Autokompetenz wird
beschädigt oder noch schlimmer, sie könnte niedergebrannt werden. Denn oft, wenn man die
Komponenten im Wald miteinander
verdrahtet, wurden
sie sehr heiß. Und es
könnte auch an seinem verbrannten Stein vorkommen. Es könnte auch passieren wenn Sie in
einen offenen Kreislauf aufwachsen. Es besteht Lebensgefahr. Er konnte auf verschiedene Arten sichergestellt
werden. Sei immer aktiv auf dem
Byron-Pod und dem Codierteil. B auch sehr, sehr reflektierend, wenn es
um verschiedene Arten
von Komponenten geht . Zum Beispiel habe ich kein USP 32, das etwas
andere Pinbelegungen hat. Vielleicht hat Ihr ESP E2F gestartet. Wenn wir also
das Virus miteinander verbinden, überprüfen Sie
immer die GPIOs, die Daten zur Todesstrafe. Seien Sie sich bewusst, was wir tun und
implementiert und
an Ihre eigenen Versionen angepasst sind. Ich kann Ihnen nicht garantieren, dass
alles, was ich
Ihnen zeige, an Ihrem System funktioniert da es hier draußen zu
viele verschiedene Komponenten und Ansätze gibt. Aber in meinen vorherigen gezeigten Videos ist
es sehr einfach, den Risiken zu folgen oder
sich dessen bewusst zu sein , und dann haben
wir ein gutes Ergebnis.
5. ESP32 Pinout: Ein paar Worte zum
Thema Erdnuss. Wie Sie vielleicht wissen, steht
ein Gruppenrichtlinienobjekt oder für allgemeine
Input und Output. Das bedeutet, dass wir hier
zum Beispiel die
GPIO-Nummer 27 als Eingabe verwenden können . Also haben wir hier in reinem
Sensor Bewegungen erkennt. Und wenn Bewegung erkannt wird, können
wir
hier senden und signalisieren, um Pin 27 zu setzen. Aber in einem anderen Beispiel
war das I-SPY-Studientool. Wir können auch das Pin-GPO,
Pin 27 als Ausgang verwenden. Das bedeutet, dass
zum Beispiel eine LED
ausgelöst wird, dass die LED angefleckt oder blinkt. Daher sollten wir
auch wissen, dass es eine Pinbelegung und GPO P gibt,
und es hängt davon ab, welches Unternehmen, Hersteller und welche Verwendung Sie verwenden? Ich benutze es von der Wechselstromauslieferung. Und wie Sie hier sehen können, ist
dies die Pinbelegung für ESPs
32 aus einer festgelegten Lieferung. Und es ist ein bisschen anders
als andere Hersteller. Zum Beispiel habe ich hier
keine Erdverbindung. Das heißt,
überprüfe immer dein p-nau. Wenn es sich jedoch um
eine ESP-Zertifizierung handelt, sind
sie nicht immer gleich. Überprüfen Sie, ob das Gruppenrichtlinienobjekt auf
die Pinbelegungsreferenz
verweist damit Sie sicher sein können ,
damit Sie sicher sein können,
dass dieser Pin mir benötigt wird, was Sie benötigen. Zum Beispiel habe ich
hier keinen Erdungsstift oder der Pin 3534 wird
nur eingegeben. Nsc sind einige andere 32er , die ebenfalls 3232
nur als Input deklariert haben. Wir haben jung
für internen Blitz verwendet, empfehlen wir
niemals für andere
Verwendung, die gelben. Seien Sie sich also der
verschiedenen Arten bewusst. Wir haben auch
ein paar Touch-Pins benutzt. Wir haben auch einige AD-, AD- und DCM-Konverter ,
damit wir
Signale diese Daten übertragen können. Dies ist auch immer
erforderlich, wenn es
darum geht , Teile der TB
mit unterschiedlichen GPOs zu verdrahten, verschiedene Arten von ESPs haben
unterschiedliche GPIOs und Pinbelegungen. Und dann können wir
hoffentlich ein
gutes Verdrahtungsschema haben und können es auch implementieren.
6. VS-Code vs. Arduino-IDE: Warum sollten Sie
den Arduino EDA in
Visual Studio Code umstellen ? Und es gibt eine einfachere Antwort
, die Sie nicht müssen. Ich möchte Ihnen
hier nur meine Meinung zeigen, wie Sie, was ist der Workflow? Warum? Ich denke, Visual Studio Code ist etwas
bequemer, wenn es um die Entschlüsselung des
Tagesablaufs geht. Auf der linken Seite habe ich
es in deinem ED50 angesehen, Python 2 unter,
ich hatte gesagt, es sind Visual
Studio-Koordinaten. Sie können sehen, dass es im visuellen Overlay sehr
ähnlich ist, aber es ist im Kern und der Compiler befand sich in
einer Geschwindigkeitskurve. Und wenn wir es kompilieren, gibt es viele Unterschiede. Ich fühle das erste Beispiel , mit dem wir
es hier
in diesem Online-Kurs zu tun haben, hier sind die LEDs mit Objekten veraltet und ich zeige
Ihnen 1 als erstes. Wenn ich zum Beispiel hier auf Kompilieren klicke und auf die
linke Seite des Compilers klicke, kann man sehen, dass die Literatur, der Code 1,7 Sekunden benötigt.
Ich habe nicht richtig drauf geklickt. Wieder einmal neue EDA hinzugefügt. Es dauert doppelt so lang, vielleicht drittens so lang. Und das ist nicht so unbedingt, wenn wir nicht
wirklich Bibliotheken
von Drittanbietern implementiert haben , aber wenn wir es später tun, fürchtet
sie 678 externe Bibliotheken, dann erkennt man wirklich
und signifikanter Unterschied bei der Kompiliergeschwindigkeit von Kreisverkehr 20 Sekunden bis
über eine Minute in der RNA. Und das ist wirklich nervig
, wenn Sie nur einen
kurzen falschen Rechtschreibfehler machen . Und auch die Geschwindigkeit, wenn wir gefangen
werden, ist anders. Zum Beispiel erstelle ich
das Objekt rot
in den Konstruktor und wir
übergeben den Wert würde tun. Dann springen wir
ins Setup nur um dir den Unterschied zu zeigen. Dann tippe ich hier rote
zwei Punkte und ich sehe die
ganze Funktion, auf welche Weise ich in der Klasse implementiert habe
, mit der wir später zu tun haben. Zum Beispiel klicke ich
auf Fleischklammern und dann sehe ich, dass
ich eine ganze Zahl eingeben muss. gleiche Beispiel hier,
der gleiche Workflow, aber ein bisschen anders. Rote zwei Punkte. Es passiert nichts. Ich warte. Und ich hoffe, dass sich etwas mit Kontrolle und Raum
öffnet. Der Arduino wird dort geladen. Alle notwendigen
Funktionen. Jetzt hab ich es. Ich möchte
das Fleisch setzen und T
hat mich in ganzzahliger Verzögerung eingefügt, okay, ist bereits ausgewählt, damit ich es zum Beispiel
mit 500 überschreiben kann. Und es ist fertig. Nicht wirklich schnell, würde ich sagen. Aber natürlich kannst du
es an einem weiteren Beispiel machen. Als wir also Jahr
die
Objektweisungsfunktion geöffnet haben , könnten wir die Strg-Taste
und die linke Maustaste drücken. Und dann sollte es
zur Klasse selbst springen. Hier. Hier ist es sehr einfach zu markieren. Und hier ist es nicht geladen. weiß nicht, ob ich ungeschickt bin oder
es nicht schon geladen wurde. Ich habe es nicht bemerkt. Kontrollieren. Ich weiß es nicht. Es sollte funktionieren, aber nicht so schnell wie in Visual Studio
Code. Jetzt hat es geschehen. Wie Sie sehen können, fließt
Sandberg in den
Buchungsgeschwindigkeiten
etwas anders. Auch zu ihrer visuellen
Geschichte, Kurtisane,
meiner Meinung und einem wirklich großartigen Träger muss
ich Warp überspringen
, dass hier mein Arbeitsbereich ist. Blut von Indian, wirklich
toller Abhängigkeitsmanager. Dort muss man zum Beispiel
sagen, dass ich
den AnalogWrite aktualisieren möchte. Ich wollte zwei
Version 1.2 und alles oben haben. Wenn es eine neue Versionskunst gibt, komme
ich zum Update. Sofort. Ich könnte das Framework am
Upload-Teil und
auch am Monitor-Port festlegen . Das heißt, wenn ich den Code
hochlade, wird er auf einem bestimmten Monitor auf
derselben Port-Datenplattform geöffnet . Jeder sollte auch
automatisch Bericht erkennen. Aber hier habe ich es
eingerichtet, weil ich
oft mehr als zwei Arduinos an meinen PC
angeschlossen habe. Also würde ich
es gerne hier fest codieren lassen. Auch weil ich viel
Speicherplatz und wenig
FS-Management verwende . Und deshalb können
wir auch auf
ihrer Plattform das
Dateisystem-Image erstellen und auch Dateien aus
der Fondsrecherche in
den Code, auf unsere ESPs hochladen . Und das ist notwendig
, wenn wir interagieren wollen. Zum Beispiel kann der ESP 32 einen halben und
einen Webserver haben. Wenn wir eine Website erstellen, können wir etwas kalibrieren
oder einige, einige,
einige Werte eingeben , zum Beispiel, wie sollte es für unsere anderen Beispiele festgelegt werden
? Und ohne eine neue EDA müssen
wir Komponenten
von Drittanbietern installieren. Es ist ein bisschen, ja, nicht,
nicht intuitiv und einfach zu bedienen. Visual Studio-Code.
Es ist eine Menge Dinge integriert. Und auch einmal mehr ist
die Geschwindigkeit wirklich,
wirklich eine andere Dimension. Nur ein paar
Einblicke, wenn Sie zu
Visual Studio Code wechseln
möchten. Es gibt viele
gute YouTube-Videos , in denen Sie
Ihre ersten Beispiele machen können. Ich werde beschreiben und zeigen wie ich die Projekte
hier in diesem Kurs eingerichtet habe. Aber ich werde nicht
tief in die gesamte Mechanik
von Visual Studio Code eindringen. Justin beansprucht zuerst das Dedizierte, damit
Sie sich einen Überblick verschaffen.
7. Quellcode aus VS-Code in Arduino IDE: In diesem Video erläutern wir, wie
wir die Codes, den Quellcode aus
dem Visual Studio-Code,
an
die Arduino-Gewerkschafts-EDA übertragen können Quellcode aus
dem Visual Studio-Code,
an
die . Habe auf jeden Fall ein Beispiel. Dies ist das LED-Beispiel
von unserem ersten Sprung nach unten und vorausgesetzt, wir sind
bereits damit fertig. Und Sie möchten diese Art von Codes jetzt
übertragen. Auf der linken Seite befindet sich die
Arduino IDE Version 2. Und auf der rechten Seite
nach Visual Studio Code mit der Plattform Blogging. Und wie Sie sehen können, sehen
sie sehr ähnlich aus, aber sie sind
im Kern und der Compiler
ein bisschen anders. Und auch der visuelle Studio-Code ist viel schneller, wenn
es um das Kombinieren geht. Hier können Sie also
die Struktur
des Projekts sehen und Sie können sehen, dass es noch ein paar Fotos
gibt, diese beiden IF bearbeiten, aber da sich die anderen Fotos immer in der Oresteia
befinden, gleich wenn Sie ein neues
erstellen projekt. Zwei stammen von Visual Studio Code. Was für uns interessant ist, ist der Quellordner und wir haben drei Sui-Hauptdateien sind
LEDs dot CPP und LEDs dot H. Dies sind die Klasse
und die Klasse ist auch 100% kompatibel
mit der Arduino IDE. Und dann siehst du Hauptpunkt-CPP. Und sein Haupt-CPP er
ist unsere Hauptakte, und das ist unsere innere Akte, die Sie hier sehen können. Soweit kurz Einführung angeht. Und jetzt springen wir
in einen Entdecker und springen direkt
in diesen Ordner. Hier ist mein Projekt. Wieder einmal, die verschiedenen Arten von Projekten, klicke
ich auf LEDs, wie Sie sehen können, die gleiche
Struktur wie zuvor. Klicken Sie auf Quelle. Jetzt kopiere ich die Dateien
in einen Ordner. Nehmen wir an, es heißt
0.1, damit wir es
jetzt kopieren und hier einfügen können . Und so können wir einen Unterordner haben. Und jetzt haben wir die main.cpp umbenannt. Klicken Sie mit der rechten Maustaste darauf und änderte
den Namen in Punkt ausführen. Werden Sie die CPP los. Und ja, jetzt haben wir uns hier verändert. Die Erweiterung jetzt in
unsere Medienkopie, der Pfad. Geh zu ihnen. Datei öffnen. Gehe zu dem Ordner, den
wir gerade erstellt haben, und wir öffnen die Datei
, die wir umbenannt haben. Eine neue Instanz wird geöffnet wechselt nach links. Und was ich Ihnen jetzt
zeigen möchte, ist, dass ich deshalb dieses Beispiel ausgewählt habe weil sie verschiedene
Arten von Compilern haben. Kompilieren wir in
Visual Studio-Code. Genau das ist der Code. Und auch hier habe ich gesagt
, dass das 32 sein muss. Ist es hier eine ältere
Bibliotheken geladen? Wenn eine
Bibliothek eines Drittanbieters enthalten ist, können
Sie sie aus
der Bibliothek oder dem Manager herunterladen, aber in diesem Fall
brauchen wir es nicht mehr. Und dann gehen wir hierher
, um es zu kompilieren. Und wie Sie hier sehen können, kompiliert
der Visual Studio-Code den Code
erfolgreich. Aber hier ist die Arduino-IDE etwas
strenger, und Sie können sehen, die Fehlermeldung
heißt Array muss mit brace
enclose initialisierer
initialisiert werden. Und das ist, ich habe
es im Visual Studio-Code nicht gemacht. Deshalb
müssen wir
diese Zeilen nur auskommentieren und
müssen
uns natürlich später mit dem
Inhalt befassen, aber wir müssen zum Beispiel alle
Objekte initialisieren. Kompilieren Sie es also noch einmal neu. Und wie Sie jetzt sehen können, dauert es etwas länger
als der Visual Studio-Code. Es hat es
immer auch kombiniert. Jetzt können Sie
die Skizze zum Beispiel
sicherlich auf USBE hochladen , und Sie haben denselben Code mit erstellter Renovierung
an das Gericht, aber angepasst an
die Arduino EDA. Noch einmal. Dies sind
ein wenig Unterschiede
in der Kompilierung, aber im Allgemeinen
würden 99% implementiert. Sie können es für
Ihr bereits in edi implementieren, das von
Visual Studio-Codes stammt. noch einmal Probieren
Sie es noch einmal aus und
verwenden Sie Visual Studio Code. Es ist viel, viel schneller
beim Kompilieren. Und ich denke auch, dass es ein
bisschen bequemer zu da es viele gute Hauptfunktionen anstelle
von Visual Studio Code gibt, die Sie in Ihrem
täglichen Programmierleben verwenden können.
8. Online-Simulator: Wenn Sie während
Ihres Codierungsvorgangs häufig einige logische Teile testen
möchten , nur ein paar
Codezeilen, damit Sie nicht den
gesamten Code immer wieder kompilieren müssen. Daher
sind einige
Online-Simulatoren wirklich praktisch, denn dann schnappen Sie sich einfach
Dakota in umstrittene. Was kann we.com? Ähnliche IT-Projekte in Ihrem
Browser sind meiner Meinung nach, sind
wirklich nicht gut
und gut simulieren. Denn hier haben Sie, können Sie die ESP-Sicherheit nutzen
, um darauf zu klicken. Und dann hast du hier
den Online-Simulator. Und das Gute daran
ist, dass Sie auch einige,
einige Komponenten, ein
elektrisches Teil,
aber auch
externe Bibliotheken hinzufügen einige Komponenten, ein
elektrisches Teil, können. Und Sie können
hier auch Ihre Klassifikatoren einfügen ,
damit Sie
Ihr gesamtes Projekt
im Simulator testen können . Also erstes Beispiel, ich
werde hier eine LED erstellen, einer Bestellung
verbunden ist,
mit beispielsweise 25 bis GPIO auf der
Ketotik geht zu Boden. Dann ist der LED-Pin 25. Dies ist derselbe PinMode. Sie, PinMode. Geführter Pin. Falsch. Ausgang. In der Schleife. Wir machen eine Verzögerung. Nein, das ist nicht der beste Weg, aber es dient nur zu
Testzwecken. Dann klicken wir auf Assimilate. Und das Gute hier ist auch wenn wir anfangen, es
zu sehen, sollten
wir hier auch
die Konsole sehen , die
Serumkommunikation. Und wie du ihn siehst,
können wir dich perfekt hören. Testen Sie auch Komponenten und wie wir
die Komponenten und
auch unseren Code steuern können , wenn wir
einen sauberen Code haben oder nicht. Walkway.com, guter Simulator
zum Testen Ihres Codes.
9. Enum: In den folgenden nächsten Kapiteln erstellen
wir
etwas komplexere Codes und Quellcode und
Mitarbeiter, was wir auch überprüfen
möchten, mit welchen Zuständen wir es
gerade zu tun haben. Zum Beispiel, wenn
wir uns entwickeln und spielen, dann wollten wir wissen,
ob wir auf Benutzereingaben
warten, wir fertig
sind oder gerade spielen,
berechnen wir etwas. Und oft wird
dies mit Flex gemacht. So
könnten Sie beispielsweise
in diesem Fall eine
Pool-Variable definieren oder deklarieren , z. B. Warten von
Status
„falsch“ oder „Ballsaal“. Beginne. Gaming ist wahr. Dann
können Sie es in der Schleife mit einem IF überprüfen. Und in Bezug auf die Staaten könnten
Sie etwas berechnen, oh, warte, auf Benutzereingabedaten. Meiner Meinung nach gibt es einen
anderen bequemeren Weg, wenn es darum geht,
Zustände in C plus plus zu überprüfen. Und deshalb verwende ich
wirklich oft Enum. Enum ist es in vielerlei Hinsicht. Ich denke, der bessere
Weg zu wählen. Nicht. Es spiegelt sich wider, weil
Sie
bei den Enums eine Variable haben. In diesem Fall ein Status. Etwa drei Bundesstaaten werden kombiniert. Es gibt Ihnen also einen guten Überblick, wie viele
Zustände Sie in
Ihrem Programm definiert haben, in dem Sie ansprechen
könnten, dass Status ist ein Modell zum Beispiel. Und Sie können es auch
ausdrucken, Zeilenstatus drucken. Aber jetzt bekommst du nicht hierher und eine Zeichenfolge, weil dies nur der Variablenname
ist,
das bedeutet, dass wir
hier 0 bekommen, weil es 0 Index ist, wenn wir auf Pause
einstellen, dann bekommen wir und eins, das bedeutet, dass der Compiler
den richtigen Datentyp in der Enum auswählt , da Sie
hier auch einige andere Dinge deklarieren könnten. Aber ich gebe ihnen keinen Wert, setze
nur den Status ein. Und das ist es, was ich
denke, es macht es sehr praktisch
in der Programmierung. Nehmen wir ein bisschen
mehr Beispiel , um zu sehen, was ich hier meine. Zuallererst habe ich
den Normalzustand gesagt und wir drucken den Staat
aus. Dann möchte
ich beim ersten Stopp den
Funktionsprototyp definieren, da er später auf der Schaltfläche „
Es ist
AND“ -Funktionsprüfung wirklich gefunden wird. Also simulieren wir so
etwas wie unser Programm wartet auf einen Pattern-Klick und dann
ändern wir die Zustände. Freest Millionen, weil
ich nach zwei Sekunden
wechseln möchte , um automatisch dort zu
bleiben. Und deshalb habe ich
die Blink ohne Verzögerung implementiert . Ich bin mir sicher, jeder hat sich
schon damit auseinandergesetzt. Und wenn nicht so, nur Google
Blink ohne Verzögerung zu verzögern. Deshalb sitzen wir in den mittleren Jahren
hier. Und nach zwei Sekunden möchte
ich den
Status in Statusermüdung ändern, zum Beispiel haben wir gerade den Check-Button
beendet. Das Ende. Zum Beispiel mache ich
den Staat normal. Also lasst uns sehen. Wir starten das Programm Debra Thompson, um das
Setup Cs einzurichten. Wir ändern den Status so
, dass er wie gewohnt beginnt. Ich würde sagen, dass der Ehepartner sie Ehepartner
ausgibt, wir drucken den ersten Zustand aus, dann springen wir
in den Check-Button. Der Status wird geändert,
um wie gewohnt zu beginnen. Nach zwei Sekunden
wird der Status in Status-Fabrics geändert. Also haben wir hier drei
verschiedene Bundesstaaten. Und jetzt wollen wir es auch in
gedruckten verschiedenen Zuständen
visualisieren. Deshalb würde ich
Städte empfehlen und Fall wechseln. Fall wechseln. Wir wollen den Staat überprüfen. Wir haben es
hier nicht mit einer Schnur zu tun. Deshalb könnten wir hier gebrauchen, der Fall beginnt wie gewohnt. Wir schreiben
hier nur den Variablennamen, und dann schreiben wir hier. Lass uns zum Beispiel gehen. Dann begann der zweite Fall
als Pass oder Break. Pochen rein. Jetzt ist es Pausenzeit. Der letzte ist, dass es fertig ist. Mein Fall, es ist das College beginnt zu statisch und dann können
wir doping. Wir sind fertig.
Etwas mehr Rückblick. Und dann könnten wir es einfach überprüfen. Wenn du Recht hast oder nicht. Was bedeutet das Problem? Wir verzögern hier oft. Löschen ist gut. Wir sind bei T von 500s und
das ist zu viel. Noch einmal. Was haben
wir also hier? Ich klicke am ersten
Anfang auf Pause, es wird ausgedruckt,
da der Status ununterbrochen ist. Sera-Index. Dann
springen wir in den Check Button, überprüfen die Schaltflächenänderungen, um diese normal zu
starten, normal. Und danach, ja, sind wir mit dem Setup
fertig. Und dann in der Schleife ist
dies nicht die Tatsache,
dass wir
in diesem Fall springen , und jetzt wird
es ausgedruckt. Lass uns gehen, weil sie
gedacht haben, dass das keine Meile ist. Nach zwei Sekunden
wird
der Status geändert, da hier im Blinzeln ohne Verzögerung
die Logik einspringt und wir den Status
auf Status Ermüdung
setzen. Und so der Status, oh, wir sind fertig,
wo wir ihn ausdrucken. Dies ist nur ein kleiner Fall, ein kurzer Fall, in dem
Sie sehen können, wie wir den Status ändern
können, oder wir könnten auch
den Status in einem Projekt überprüfen. Und wie du siehst,
gibt er dir einen guten Überblick. Welche verschiedenen
Staaten haben wir und wie können wir sie auch ändern?
10. Struktur: Ich habe auch
regelmäßig Strukturen verwendet. Strukturen sind wirklich
eine bequeme Möglichkeit ,
verschiedene Arten von Variablen zusammenzufassen verschiedene Arten von Variablen , die verschiedene
Arten von Datentypen haben. Ich würde es auch nennen und
kleinere Leichtbauklasse. Wie ist es also, wie können wir eine Strategie C plus
in Arduino-Umgebung einsetzen? Zum Beispiel können wir eine Struktur
eingeben, dann geben wir ihnen
Strukturnamen, zum Beispiel Person down, und wir können einige Variablen definieren. Ich habe keine Zeichenfolge,
nenne ein ganzzahliges Alter. Boolescher Wert ist das
persönliche Kontingent oder nicht. Und nur zum Beispiel, wenn Gründe lang
Kontoguthaben in Dollar Cent. Und es ist immer eine gute
Praxis, wenn Sie sich
mit
Kontoguthaben, Geld usw. beschäftigen . Berechnen Sie
nicht mit Floats,
da es immer das Auge ist. Es könnte schwierig sein, wenn
wir mit
Floats bezüglich der
Dezimalstelle rechnen , oder es ist nicht einfach. Und deshalb würde ich auch empfehlen, dass wir
zum Beispiel mit einem Sinn
rechnen und ihn dann in
normalen Dollar visualisieren. Aber hier haben wir es
mit Dollar zu tun, mit Strukturen. Zum Beispiel. Jetzt konnten wir
es Person sehen, schwer, aber diese Klammern
Semikolon den Namen davon. Zum Beispiel wird y-Komma, der Befehl Alter 25, durch Komma codiert. Und dann können wir
zum Beispiel auf
ihrem Kontostand sitzen . Danach könnten wir auch
ihre verschiedenen
Arten von Variablen ändern . Deshalb tippe ich
Heavy Bird Point ein, und jetzt könnte ich
die Variable im Inneren ansprechen ,
zum Beispiel einen Namen. Mein neuer Name. Auch um den Punkt,
Quartal ist falsch. Ich drucke hier draußen. Jeder beim Namen und wenn
ich nicht falsch geschrieben werde, sollte
etwas
meinen neuen Namen ausdrucken , weil wir ihn von Harry Boats
überschrieben haben . Und wie Sie ihn sehen können,
haben wir jetzt darüber diskutiert, wie wir
eine Struktur definieren können, wie wir sie initialisieren könnten
und wie wir uns bei plötzlichen
Streiks
ändern könnten .
11. Grundlegende Einstellung eines leeren Projekts: In diesem Video
möchte ich Ihnen
meine Grundeinstellungen zeigen und wie wir ein leeres neues Projekt
in Visual Studio Code erstellen
können. Zuerst, wenn der Workspace und ich
auf die Plattform klicken, besitze
ich ein Menü, klicke auf Öffnen
und dann zeigt es mir, was meine Kernplattform
ist
oder so weiter. Worauf ich mich mit dir konzentrieren
möchte ist, dass ich auf Plattformen gegangen bin. Und hier ist die Rate,
du siehst, meine ausdrucksstarke
Version ist 3.5. Und natürlich, wenn Sie
zeigen, schauen Sie sich dieses Video an, vielleicht in ein oder zwei Jahren später, wird es
natürlich
eine andere Version sein. Und das könnte auch passieren
, dass einige meiner Code-Snippets nicht sofort funktionieren,
weil Sie einige Änderungen vorgenommen haben. Daher ist es notwendig,
dass Sie immer daran denken, dass Sie bestimmte Arten von Codes
anpassen müssen bestimmte Arten von Codes
anpassen wenn es um Updates
von der Plattform geht. Nur das du weißt,
als du sie beim Kompilieren bekommst, um zu sehen
, wo es passieren könnte. Außerdem haben wir in einem
früheren Video diskutiert, State Boards, ich verwende das
AEC-Lieferboard, gehörlose Kinder C4. Und hier kannst du auch durch deine Boards
stöbern. Und wenn Sie normalen ESP 32 haben, dann denke ich, dass Sie
dieses auch nehmen könnten oder nach einem ESP 32
suchen. Sie finden eine andere Art von Frameworks und
auch Hersteller. Jetzt gehen wir weiter zu den Projekten
und ich würde auf Home gehen auf Neues Projekt
klicken. Und zum Beispiel tippe
ich ein, OOP. In Toronto. Ich wähle die Boards aus. Ac-Lieferung. Ich verwende die ID oder
das innere Framework und wähle
hier meinen Standort aus. Und das ist alles, was
wir brauchen, um sie zu tun, ich klicke auf Fertig stellen und mein
Projekt wird erstellt. Und ich bin hier
im Arbeitsbereich links. Du siehst hier jetzt
meine 51, mein Projekt. Und das erste, was wir tun, ist hier auf der Plattform. Wir haben hier die allgemeinen
Einstellungen des Projekts geöffnet. Und ich würde Ihnen empfehlen,
die folgenden Änderungen vorzunehmen. Wir haben
beispielsweise 1152 Seren,
sera Framework und den
Upload- und Monitor-Port
versteckte Monitorgeschwindigkeit hinzugefügt beispielsweise 1152 Seren,
sera . Den Monitorport
oder den Port von Ihrem Gerät können Sie
von der Plattform aus abrufen, Sie verbinden Ihr Gerät
und klicken hier auf Geräte. Verbinden Sie sich also, klicken Sie auf Aktualisieren. Und wie Sie hier sehen können, ist
dies mein Port Drei der Grund, warum ich
hier und die Plattform bearbeitet werde. Ich füge auch hier und eine Bibliothek
von Drittanbietern hinzu. Es heißt AnalogWrite. Nichtsdestotrotz, wenn wir es benutzen, aber hier ist das
eines meiner grundlegenden Dinge. Ich setze es immer um. Der Bibliotheksleiter
von Blut von IO ist sehr, sehr gut. So können Sie Ihre
Bibliotheken und zum Beispiel Adafruit, Neil Pixel, nur zu
Trainingszwecken anklicken. Sie können darauf klicken. Und hier
sehen Sie die Beispiele, wie Sie es im Quellcode und
auch in
der Installation ansprechen können . Wenn Sie beispielsweise immer
die aktualisierte Version für eine bestimmte Version
haben
würden , kopieren
Sie einfach
hier diese Zeile, gehen Sie durch die
Deborah-Tendenzen im Labor und können sie dann
in Ihr Programm aufnehmen als normal. Und diese Waren sollen gehen, um damit zu beginnen. Sicher. Auf der linken Seite haben
wir hier jetzt
unser Menü, auf dem wir
uns erforschen werden, und das ist alles Projekt
und dann eine Quelle. Wir haben eine sichergestellte Akte. Und ich werde auch von Indien aus
arbeiten, um alles an erster
Stelle zu stellen. Justin Header
Ihrer Anmeldeinformationen, Ihre vielleicht Ihre
Lizenz usw. Wiederholtes Intro
an einem tatsächlichen Datum. Und dann bist du bereit zu gehen. Es ist auch sehr praktisch
, wenn Sie hier Ihre Plattformversionen eingeben . Das also auch Personen
von außen? Nein. Was waren Ihre Grundeinstellungen und wie haben Sie sich unter welchen Umständen entwickelt
? Dies sind nur ein paar
Einstellungen, die ich mache, wenn ich
ein neues Projekt beginne.
12. Aufbau eines Kurses und data: Beginnen wir mit den Grundlagen
der Klassenstruktur und auch mit Datenkapselung
und motorischem Praktikum. Also möchte ich hier beginnen,
indem ich das Haupt-CPP eröffne. Und was ich vorschlage, ist wir
hier alles
in einer Datei schreiben , nur zu
Trainingszwecken. Und das erste, was wir Klassen
deklarieren, ist, dass
wir in der Klasse tippen. Dann der Name der Klasse, geschweifte Klammern offen,
geschweifte Klammer geschlossen. Und am Ende
muss es ein Semikolon sein. Und das ist die Grundstruktur
der Klasse, die begrenzt. Ein Klassenelement ist auch
, dass wir hier definieren ob ihre Funktion oder die Variable
nach außen sichtbar ist oder nicht. Und das könnte, das ist, ähm, können wir mit
der Kennung öffentlich
und auch mit privat tun ? Alles, was
nach dem Privaten kommt, ist zum Beispiel, hier haben wir
eine Zeichenfolge namens name, und diese Elemente sind nur
innerhalb der Klasse sichtbar und zugänglich. In diesem nächsten Beispiel können
wir Ihren Nachnamen haben. Und natürlich haben wir
innerhalb der Klasse und an innerhalb aller Funktionen, die
wir später definieren,
einen Überschuss diesen Variablennamen
und auch den Inhalt der Variablen, wenn wir verwenden hier
ein paar öffentliche Dinge. Und natürlich könnte ich auch einen String-Dateinamen
eingeben. Dann haben wir X's auf diesen Variablen auch
außerhalb dieser Klasse und außerhalb dieser Klasse Mittel außerhalb dieser Struktur. Wenn wir
das Objekt später instanziieren, ist
es nicht möglich,
auf Ihre Dinge zuzugreifen
, die privat sind. Wir haben nur
Zugang zu Dingen , die wir
im öffentlichen Bereich definieren. Dies ist, dass wir uns dieser
Art von Mechanismus immer bewusst sind. Und weil es sich um
Datenkapselung handelt, bedeutet
das, dass wir nur Daten in die Öffentlichkeit
zeigen,
die
von außerhalb der Klasse zugänglich sind . Und das gibt uns auch eine
Sicherheitsfunktion, da wir hier einige sehr
vertrauliche Dinge hinzufügen können, aber es ist auch so, dass Sie hier einige Daten
nicht unbewusst
ändern. Daher geht es nicht
nur um die Datensicherheit, sondern auch in Sicherheitsfragen wenn wir hier
privat und öffentlich verwenden. Und die Öffentlichkeit zum Beispiel könnten
wir Ihre Zeichenfolge getName verwenden und sehen, dass hier ein Name
zurückgegeben wird. Und wie Sie sehen können, ist die Funktion selbst von außen öffentlich. Und diese Funktion kann
uns hier ein paar
private Variablen zurückgeben. Das werden wir später
lernen, Getter und Setter,
damit wir
Ihre öffentlichen Funktionen nutzen können , um private Elemente zu
erhalten. Es gibt auch andere Identitäten, die ich
mit Ihnen besprechen
möchte , und es
wird als geschützt bezeichnet. Geschützt ist nicht die Art, die
wir später verwenden , wenn wir einige Klassen
geerbt werden. Das bedeutet also, dass
wir im
geschützten Bereich die Variablen hier,
zum Beispiel String, mein zweiter Name ist
nur in
der Schülerklasse als
privat sichtbar , als privat behandelt. Aber später, wenn Sie
jemandem die Bibliothek geben und
die Bibliothek vererbt
wird, fungiert der Schutz als öffentlich. Dies bedeutet, dass Ihre
Kernklasse als privat
behandelt wird,
alles, was
nicht geschützt ist. Aber später, wenn
jemand geerbt hat, wird
es als öffentlich genutzt. Und das ist eine gute Sache,
wenn du dich entwickelst. Und eine Bibliothek, die später
an
andere Entwickler verteilt wird , damit sie ihr eigenes
Ding daraus machen
können. Aber du hättest gerne deine eigene Klasse
beschützt. Dies ist es,
was geschützt ist und es
könnte sehr, sehr praktisch sein. Also haben wir ein wenig über
die verschiedenen Arten
von Privat und
Öffentlichkeit gesprochen die verschiedenen Arten
von Privat und und geschützt uns
identifizieren, aber später werden wir
es in der
Praxis ein bisschen mehr sehen , wenn wir
die Objekte initiieren und programmieren Sie auch funktionaler, um nur in kurze Einführung zu passen, so richten wir eine
Klasse mit dem Namen, Spaltenklammern und dem
Semikolon am Ende ein. Und mit Privat und Öffentlichkeit ist
dies die üblichere Art und
Weise, wie wir es programmieren. Wir definieren unsere
Funktionen und Variablen.
13. Instanz und Konstruktor: Konzentrieren wir uns nun darauf, was
eine Instanz ist und was
nicht Konstruktor ist. Also zuerst
den Arduino-Rand,
den wir vor allem stellen. Und dann würde
ich auch in der Einrichtungszeit empfehlen, 0 begin einzugeben
, weil wir
danach vielleicht
nicht darüber nachdenken. Dann sind wir bereit zu gehen. Also haben wir jetzt den
ersten Schritt unserer Klasse beendet. Das sind also unsere bisherigen
Blaupausen. Und jetzt wollen wir uns in
der echten Programmierwelt unserer Klasse einrichten . Deshalb
initiieren wir ein Objekt. Und dies könnte
mit dem Klassennamen,
dann mit dem Variablennamen des
Objekts in meinem Fall geschehen , Idiom, dann Studenten, Klammer, offener Klammer
geschlossen und Semikolon. Und da sind wir los. Wir haben unser erstes
Objekt mit dem Namen Eddie initiiert. Dann springe ich hier
in das Setup. Und wenn ich 80 tippe, habe ich Zugriff auf alle
öffentlichen Mitglieder aus meiner Klasse. Und wie Sie sehen können, kann
ich nicht auf
den Namen oder den Nachnamen zugreifen , da dies privat ist. Also kann ich diese verwenden, die Funktion, die
ich hier definiert habe, und f x ist über die Funktion
für meine privaten Mitglieder. Dies ist eine unbequeme Art und Weise, wie wir programmieren können und wie können wir hier auf alle Elemente zugreifen. Als zweites Beispiel können
wir hier
und das zweite Objekt initiieren, und es heißt Julia. Und wie Sie auch hier sehen können, bekommen
Julia Dots einen Namen. Wir können hier auch auf das
Gleiche von Trulia zugreifen, aber wir haben bisher keinen
Datenspeicher. Es wäre also der nächste
Schritt, hier
einige Strings auszufüllen, damit
Sie auch die Namen unserer Objekte
hören können. Und natürlich könnten wir sagen, dass
er alle meine Daten festlegen würde. Und ich könnte
String sagen, Name eins, zuletzt für String und
so weiter und so weiter. Und ich könnte diese
Funktion danach aufrufen, aber
so möchte ich es nicht tun. Denn für das erste Setup
gibt es ein Konstrukt, wie
es Konstruktor genannt wird. Dieser Konstruktor nimmt uns unsere ersten Eingaben, wenn wir das Objekt initiiert
werden. Wie könnten wir
einen Konstruktor definieren, indem einfach den Namen aus
der Klasse der Öffentlichkeit hinzufügen. Es gibt also keinen Rückgabewert. In diesem Fall heißt es
Student und Insert. Wir könnten zum Beispiel String sagen,
FirstName. Und dann, wie wir es hier getan
haben, können wir sagen, dass die
Namen privat sind. Mitglied wird ein sein,
erhält den FirstName. Das ist jetzt also unser Konstruktor. Der Konstruktor wird aufgerufen wenn wir das Objekt initiieren. Und das Objekt ist hier initiiert und wie Sie
jetzt sehen können, haben wir einen Fehler da dieses
jetzt einen Eingabeparameter benötigt. Deshalb könnte ich Einheimische und Julia
sagen. Also nur um zu sehen, dies ist eine andere Art von tut nur die Deklaration
des Namens und dies ist
der Eingabeparameter. Jetzt wollen wir den Namen kriegen. Dies ist, dies ist eine
Rückgabe, ein Wert. Also müssen wir es hier in
serieller Druckzeile abdecken , Druckzeile. Und wir könnten auch an die
serielle Drucklinie kommen. Meine erste Klasse. Dann verbinde dich hier. Benutze pm, also T2
für dein Projekt. Um hier auf dem rechten Objekt zu sehen ist hier das richtige Projekt ausgewählt. Wir klicken auf Check und haben das Projekt
erstellt, und dann laden
wir es hoch. Also und auch der Serummonitor
würde sofort beginnen. Und wir sollten jetzt
drei Ausgabezeilen und
unseren seriellen Monitor erstklassig bekommen unseren seriellen Monitor erstklassig als der Name Marco's angezeigt werden
sollte. Und auch hier
sollte die Trulia ausgestellt werden. Sieht so gut aus. Bisher so gut. Ja, meine erstklassigen
Marker und Trulia. Also haben wir jetzt diskutiert,
was eine Instanz
oft aus der Klasse ist und
was kein Konstruktor ist.
14. Konstrukteur überladen: Oft ist es auch so, dass es keine
Anforderung gibt , dass wir nicht
nur einen Konstruktor brauchen, es wäre sehr praktisch, wenn wir einen zweiten oder dritten
haben, was uns mehr Möglichkeiten gibt mehr
zu haben
zum Beispiel
Eingabewerte. Dies ist auch, was wir implementieren
können, damit wir den Konstruktor
überlasten können, sind auch in diesem
heißt Polymorphismus. Und wie konnten wir das machen? Wir geben einfach den
Konstruktornamen ein und definieren hier. Und zweitens hat es
den gleichen Namen, aber andere Eingabewerte. Zum Beispiel, pinwheel
Ihre Saite. Vorname. Zum Beispiel können
wir hier sagen,
Name ist FirstName. Und hier könnten wir auch
etwas mit dem Windrad machen. Aber das dient nur zu
Trainingszwecken. Scrollen Sie ein wenig nach unten
und möchte Ihnen zeigen, ich jetzt eine ganze Zahl eingeben kann. Und wie Sie
sehen können, werden beide Objekte, beide Konstruktoren funktionieren,
weil dieser das erste
aufruft, ist der
Compiler auch auscheckt,
okay, es gibt nur eine Pyramide, eine dunkle String-Pyramide,
die ich habe wird das nehmen. Und das zweite hat
zwei Eingabeparlament, dass
unser erstes eine Ganzzahl ist. Der Compiler wird den zweiten
nehmen. Das ist kein praktischer Weg. Wie könnte die Tiefe unseres Programms? Weil es oft so ist
, dass wir gleichzeitig
mehr
Eingabewerte benötigen . Aber ich möchte
hier ein anderes Beispiel machen. So könnten wir zum Beispiel Ihre Zeichenfolge FirstName,
string, lastName, Nachname
nehmen . Und es heißt „Lot“. Dieser Nachname ist der Nachname. Also, jetzt bekomme ich
natürlich einen Fehler, weil wir nur mit zwei
Eingabeparametern
konstruiert haben . Und jetzt, wie Sie sehen können, haben
wir hier ein initiiertes
Objekt mit einem Konstruktor, und dies ist der
überladene Konstruktor. String, lastName,
return, Nachname. Das ist also unser privates
Mitglied und wir können mit
unserer öffentlichen Funktion auf
das private Mitglied zugreifen mit
unserer öffentlichen Funktion auf
das private Mitglied , Nachnamen
erhalten. Und wir ändern hier
GetName, um LastName zu bekommen. Und wir kompilieren es und
laden es auf unseren USBE 32 hoch. Und wenn alles gut funktioniert, haben
wir drei Zeilen
in unserer Zeremonie erledigt. Meine erstklassige Klasse, der Vorname von Eddie, gibt nur den
Nachnamen von Julia ein. Mal sehen, was unser
Programm ausdrucken wird. Fertig, lade es hoch. Dann
haben wir die Zeremonie eröffnet. Meine erstklassige Klasse, und es heißt
Marker, wie wir es hier haben. Und wir
drucken nur den LastName willen von
Julie und Julia aus. Wie Sie sehen können, bleibt das Überladungskonstruktor oder
Funktionskanal erhalten und wie wir ihn auf
unsere objektorientierte Weise verwenden können.
15. Übungsbeispiel: Interaktion von Kopfzeilen und CPP: In diesem Video werden wir den
objektorientierten Weg ein wenig
mehr
untersuchen und
alle
Arduino-Umgebungsaspekte
von der objektorientierten Weise abdecken alle
Arduino-Umgebungsaspekte
von der . Und deshalb würde ich
vorschlagen, dass wir
die Klasse und alle Objekte löschen die Klasse und alle Objekte , die
im Haupt-CPP definiert wurden. Weil wir jetzt
Ihre Header und CPP-Dateien definieren möchten. Und dies ist die Standardmethode,
objektorientiert zu programmieren und zu programmieren. Aber zuerst werden Sie alle
Dinge
los, die wir hier in der Haupt-CPP-Datei definiert und deklariert haben. Wenn Sie jedoch unter ED oder
im Visual Studio-Code
jetzt im Hauptordner
sind , ist dies
in meinem Fall
der Quellordner. Wir haben zwei neue Dateien erstellt, und es heißt Person Dot
h für die Header-Datei. Und auch neue Datei
mit Person-Punkt cpp. Wenn Sie sich nicht nur in
der rechten oberen Ecke befinden,
können Sie eine neue Datei
im Datei-Explorer erstellen. Und Sie können
hier auch die Erweiterung bearbeiten. Und einer der ersten Schritte
würde ich vorschlagen, mit der rechten Maustaste
auf Person Punkt h zu klicken und nach rechts zu
teilen, bis
wir die beiden Brände haben. In der Umgebung oder in einer
C Plus Plus-Umgebung ist
es sehr üblich, dass wir keine Datei
in der Header-Datei hatten. Es gibt meine Klassendefinition und die privaten und öffentlichen Mitglieder sowie die Funktionsprototypen. Ein Funktionsprototyp ist
nur die Deklaration
des Return-Parameters und des Namens der Funktion.
Nur ein Überblick. In der CPP-Datei aktiviert. Es gibt die ganze Logik innerhalb der gesamten
ausführenden Teile. Im Haupt-CPP definieren wir das Objekt und die Arbeit
, wer das Objekt ist. Aber zuerst möchte
ich
mit der Header-Datei beginnen. In der Header-Datei könnten
wir
unsere Klasse jetzt wie zuvor
in der CPP-Haupt-Datei definieren . Deshalb
machen wir hier in Klasse,
Person, geschweifte Klammern,
offenes Semikolon. Und wie wir es zuvor getan haben, konnte das private ganzzahlige
Alter in Detroit als Namen sehen. Sie stammten von der Öffentlichkeit, zum Beispiel
ein leerer Konstruktor. Und dann haben wir Funktion, sie heißt print all. Und wie Sie sehen können, keine geschweiften Klammern,
nur ein Semikolon. Und das ist der
Funktionsprototyp. Seit dem Compiler
wird es auf Funktion drucken alles in aber mit dem Namen drucken Sie alles
und kein Rückgabeparlament. Und die Funktion selbst
wird etwas später deklariert. Aber wir sind noch nicht fertig. Weil wir hier auch den
Include-arduino dot h brauchen , damit wir ein Übermaß von allem haben. Es gibt die Parameter
aus der Umgebung. Ich zeige dir einen
kleinen, denn wenn ich eine Zeichenfolge
als Phonem
nehme, bekomme
ich einen Fehler, weil das C Plus Plus nicht
schonungslos kennt, nur Zeichen. Daher schließen wir hier
Punkt h ein und der Fehler ist verschwunden. Eine Sache, die wir
auch wissen müssen, ist , dass
Ihre Daten Wachen enthalten .
Name Include Guard ist, wir könnten sagen, wenn n
definieren und einen Namen, würde
ich vorschlagen, dass
Sie es
genauso nennen wie die Datei einem Basiswert definieren Sie das Alter der
Person. Und wenn ja, was war es? Was macht der
Include Guard nicht? Sie enthalten Guards
zeigt den Compiler. Es gibt eine Datei
namens person dot h. Und wenn hier bereits
ein Code enthalten ist , fügen Sie ihn
nicht ein. Und wenn wir es einbeziehen sollten, gibt es keine Person, die Punkt
h definiert ist, dann schließe es ein. Also müssen wir
die Person Punkt h einbeziehen. Natürlich enthält die
Dot-CPP-Datei in Domain Dot H.Dies ist
also das erste Mal, dass ich das ganze Gericht einschließe. Aber ich habe auch in
die CPP aufgenommen oder in die
CPP einer Person enthält Punkt
h. und wie Sie sehen können, habe ich es zweimal aufgenommen. Und das wird auch, der Compiler wird
es zweimal verwenden und sagen, aber wir schließen immer noch Wachen ein. Es wird nur einmal
zum ersten Mal benutzt. Vielleicht wird es hier enthalten sein. Und dann sieht
der Compiler an dieser Stelle vielleicht einen harten, es gibt eine Definition von Person, Alter bereits vorhanden
und er würde es überspringen. Und das wird schnellerer Code und
auch im saubereren Kurs sein. Dazu gehören Wachen und Harnstoff der
Klassendefinition. Und das ist bisher unsere
fertige Header-Datei. Wir rühren Funktionsparameter und ihre Deklaration
der Variablen. Aber was war das die Logik. In der Person dot cpp können
wir also Ihren weißen
Druck definieren, oder zum Beispiel
Sarah Druckzeile H. Und wir können
sehen, Sarah Druckzeile H. Und wir können dass wir hier einen Fehler haben,
weil h nicht definiert ist. Warum ist es so, dass dies nur eine Funktion
ist. Es gibt keinen Hinweis
darauf, dass wir mit der Klasse
der Person
handeln wollen . Deshalb müssen wir den Klassennamen
einhalten. Es heißt Person Double
Points, Double Point. Und jetzt haben wir ein Übermaß
an allen Mitgliedern der Klasse. Und wie Sie sehen können, ist
der Fehler verschwunden. Und jetzt haben wir auch innerhalb der Klasse
gehandelt. Dies ist der Grund,
warum wir auch hier den Zugang zu
den privaten Mitgliedern haben. Und das ist es. Bisher haben wir
unsere erstklassige Klasse in
der Arduino-Umgebung
in gewisser Weise mit
dem Header und der CPP-Datei implementiert der Arduino-Umgebung
in gewisser Weise mit .
16. Getter: In diesem Video möchten wir jetzt die Getter und Setter
diskutieren
und was wir jetzt
jedes Mal tun können , wenn wir
auf private Mitglieder zugreifen möchten, eine funktionale öffentliche Funktion
nutzen, die Zugriff auf unsere,
unsere hat öffentliche oder private Mitglieder. Zum Beispiel, wenn wir uns
ändern möchten , den Lebenszyklus gebrannt haben, einige Variablen oder
auch wenn wir einige der
privaten Mitglieder erhalten
möchten . Bevor wir beginnen, möchten
wir jedoch noch ein paar private Variablen hinzufügen ,
damit wir
sie in unseren Beispielen verwenden können. Zum Beispiel eine ganzzahlige
Höhe nur zum Drehen Barbers String
LastName, String Sex. Und auch String-Adresse
für spätere Zwecke. String SIP-Land, Code und ein String-Land. Bisher so gut. Und als Funktion möchten wir später
gedruckte Person verwenden , Personendaten drucken
. Und natürlich
sollten wir
etwas nicht direkt
aus der Klasse ausdrucken . Wir sollten
einen Rückgabewert durchlaufen. Und danach sollten
wir
im Hauptprogramm etwas zum Debugzweck
ausdrucken. Aber hier ist es nur
ein Trainingszweck. Und ich würde sagen,
das wäre okay. Wir haben jetzt kein Objekt. Wir möchten einige
Objekte über den Konstruktor zuweisen. Daher fügen wir hier einige
Eingabezeichenfolgen unterstrichen
hinzu , damit ich die normalen privaten Mitglieder
und
die Eingabe-Darrow Mentoren nicht verwechseln würde, würde
ich für Name, Komma String, zugrunde liegendes
LastName, String sagen . Was brauchen wir sonst noch? Ja, Höhe, ich würde
sagen Integer Höhe. Das sieht gut aus. Ich kopiere den ganzen
Konstruktor. Okay? Der gesamte Konstruktor wechselt
zum CPP der Person und fügt ihn ein. Danach lösche ich die geschweiften
Semikolon-Klammern öffnen und schließen. Und jetzt, wie Sie sehen können, haben
wir einen Fehler, weil
wir wollen, wollen, oder wir sollten hier den Klassennamen
doppelblinden, doppelten Punkt
identifizieren müssen . Und jetzt haben wir Zugang
zu allen unseren Mitgliedern. Unterschreiben Sie für den Namen. Dies ist meine private Variable, die unsere Eingaben übergeben wird. Aber für die Partitur, als Name, dann Nachname, Nachname, verwenden Sie
einfach die automatische Vervollständigung, Sex und Sex ein Ende, wo
die Höhe Höhe ist. Lasst uns also irgendwelche Fehler sehen. Ja, etwas
falsch geschrieben, zum Beispiel, was
gefällt Ihnen hier nicht? Aha, aha, aha, kein Unterstrich. Was wir also hier machen, übergeben
wir die Eingabeparameter
an unsere privaten Variablen. Und dies wird aufgerufen,
wenn wir ein Objekt initiieren. also zu unserem Haupt-CPP wechseln, möchten wir
jetzt
einige neue Objekte hinzufügen. Deshalb
schreiben wir Person, das ist der Klassenname
und der Variablenname für das Objekt heißt AT person. Und innerhalb des
Personen-Konstruktors müssen wir für Namen,
Nachnamen, Geschlecht und Größe ausfüllen . Also Eddie, LastName,
Telefon und Moleküle. Eddie zum Beispiel. Männlich, 180 Zentimeter. Natürlich könnten wir auch
den Namen der Höhe
in Zentimetern ändern . Es wäre ein bisschen
klarer und
sauberer mit der zweiten Person. Es ist die Pot-Person. Es heißt, aber kein Geschlecht. Und es ist nur 25
Zentimeter höher. Unversorgte Person. Wir haben Julia Julia, weiblich. Und wir müssen
175 weibliche sie verstecken und sagten,
richtig, Ja, weiblich. Jetzt haben wir
drei Objekte initiiert. Und jetzt können Sie auch
die Hauptvorteile
der objektorientierten Weise sehen , denn wenn Sie
dies auf normale Weise tun würden, haben
Sie
hier 1234 Variablen deklariert. Natürlich haben wir
auch hier umgeleitet, hier für Virus
erklärt, aber für die zweite Person. wird auch für
Variablen acht
zusammengefasst benötigt , dann auch hier, jetzt haben wir 12 verschiedene Arten von Variablen, wenn Sie mit
dieser Art von Informationen im Code
umgehen möchten . Der Hauptvorteil in den
objektorientierten Wegen, die wir hier
haben, unsere Blaupause. Und diese
Informationen weisen wir unserem Blueprint zu. Und im Hintergrund werden
sie sich mit dem
Inhaber-Speichermanagement und
allen mit der Erklärung befassen . Wir haben sie gerade zum Blueprint
erstellt
und verwenden ihn immer
wieder so
oft, wie wir
Speicher- und CPU-Auslastung haben ,
damit wir sie verwenden können. Jetzt haben wir es gerade initialisiert. Aber wir hatten auch einige
gedruckte Personendaten. Diese Funktion
möchte ich null aufrufen, daher zeigt
Abby, und wie Sie sehen können, habe ich zwei Möglichkeiten,
weil wir hier nur zwei öffentliche Funktionen
haben. Der Konstruktor
wird nur
automatisch aufgerufen , wenn
wir das Objekt erstellen. Daher verwende ich
die Personendetails, keine Eingabeparameter. Und wir sind bereit zu gehen. Aber das Gleiche
bringt Details mit sich. Und auch Julia
möchte hier einige Daten ausdrucken. Eine Sache, die ich vermisst habe, zurück zu Person zu
gehen ,
ähm, weil wir bisher keine dieser
Funktionen
deklariert haben. Daher druckt welche
Person, Doppelpunkt, Doppelanleihen,
Personendaten. Jetzt wollen wir diese
serielle Druckfunktion verwenden. Print F-Funktion ist
sehr praktisch. Wir können hier und String benutzen. Und nachdem das Komma zum Beispiel zu
Variablennamen
gekommen ist, möchte
ich hier
den vollständigen Namen verwenden und ich
kann Ihre Texte mischen. Zum Beispiel name. Und das ist ein Platzhalter. Ich habe diesen Platzhalter beantwortet. Der sehr namensfähige Name
wird hier automatisch eingefügt. Der Platzhalter. Jetzt kann auch hier
innerhalb der Zeichenfolge hinzugefügt werden. Und zweite Variable,
zum Beispiel LastName, wie auch in String. Und hier wird hier die zweite
Variable für den
zweiten Platzhalter
verwendet. Und wie Sie sehen können, kann
ich nur
Ihre unsichere Variable verwenden. Es ist nicht wirklich Raketenwissenschaft. Aber was machen wir
jetzt, wenn wir Ihre Strings
und Ganzzahlen mischen? Auch das ist für uns kein Problem. Wir können hier und d für
integer verwenden, fügen Sie einen Platzhalter hinzu. Eine geringfügige Information an Sie. Mein Compiler und der
Visual Studio-Code konvertieren
die Zeichenfolge
automatisch in ein Zeichen. Und wie wir im Arduino wissen, gibt es etwas, das ich strähnen kann, aber in einem C plus gibt es keine Saite,
es gibt nur Zeichen. Und deshalb müssen einige
Compiler auch hier auf Come
Konversation zu einem Char konvertiert. Ich brauche es nicht, aber wenn Sie zum Beispiel in 3D
sind, gibt Ihnen hier Kompilierfehler nur zu den Strings hinzu, siehe zugrunde liegende
Unterstrich-Zeichenfolge STR. Und dann
sollte alles in Ordnung sein. So haben wir jetzt auch eine Prime
Print-Requisiten und Details
implementiert. Mal sehen, ob wir Recht haben. Ich schreibe ein
Projekt, wie du hier
siehst.
Hier ist die Warnung. Sie sollten
Ihre I-System-Zeichenfolge ändern, aber sie ist ungeladen, erwartet. Aber es ist implizite Konversation. In meinem Fall wird
alles gemietet. Nun. Also Erfolg. Zeig mir den seriellen Monitor. Neustart. Wir haben alles in einer Zeile
und wir könnten das ändern. Nun, da wir uns gerade am Ende
des Text
- und Zeilenumbruchs befinden, so dass wir hier
ein bisschen mehr über ein
besseres Ergebnis als eine Verbindung haben . Bleib einfach dran. Wir sind in der Nähe des Ergebnisses. Jetzt muss ich
den Boot-Button ausdrucken. Es ist seltsames Verhalten. Manchmal muss ich
es durch den
Boot-Button spülen , manchmal nicht. Wieder einmal wurde die neue Zeile neu gestartet. Hier haben wir Moleküle, LastName 86 m, Höhe
100, achtziger Jahre. Und wie Sie sehen können, sind dies die Informationen
unseres Konstruktors. Und auch hier und auch hier. Herzlichen Glückwunsch, Sie haben hier
Konstruktor
implementiert und Sie haben auch noch und
Getter-Funktion implementiert.
17. Setter: Aber was ist, wenn wir die
aktuelle Lebensdauer des Lebenszyklus
unseres Programms ändern wollen aktuelle Lebensdauer des Lebenszyklus ,
einige Informationen. Und trotzdem haben wir hier keinen
Zugriff auf unsere Mitglieder,
weil
ich, wie Sie sehen können, hier nicht zugreifen kann,
zum Beispiel, Name ist neuer Name. Wenn ich versucht habe, dies zu kompilieren, bekomme
ich einen Fehler,
da dies ein privates Mitglied ist, das privat ist. Was kann ich jetzt tun? Ich kann hier auch einige
öffentliche Funktionen verwenden, um darauf zuzugreifen. Also lasst mich sehen, was
wir jetzt tun können. Zum Beispiel
definieren wir hier und weißen gesetzten Nachnamen. Und wir sind ein
String-Unterstrich LastName. Und auch weiß gesetzt H, integer h.
Sieht bisher gut aus. Dann wechseln wir
zurück zu unserer Person dot h naught Person
, dass H plus CPP ist. Und jetzt
definieren wir hier weiß,
nichtig, gesetzt, Alter, ganzzahliges Alter. Und wir konnten sehen, dass Edge unterstrichen
ist H. Wir könnten das auch womit machen? Nachname setzen
nimmt ein Eingabeparlament
die Zeichenfolge lastName an. Und wir setzen im LastName
den Unterstrich LastName. Was ist das Problem? Wieder einmal müssen wir ihm
lose Person, doppelblinde,
doppelte Punkte zuweisen . Und jetzt haben wir die
richtige Referenz. Wir gehen zurück zum Haupt-CPP. Und jetzt könnte ich
zum Beispiel 80 sagen. Ich würde sagen, was für eine bis zu 55 Jahre eingestellt
ist. Und wir könnten sagen, dass Julia
LastName gesetzt hat, vielleicht ist sie Hochzeit. Und dann sehen wir es hier. Also lass mich sehen, was hier ist. Strings bestimmtes Alter. Was ist das Problem hier? In diesen Kontexten? Probieren wir es aus. Wenn es einen Fehler gibt. Nein, sieht gut aus für mich. Dann haben wir es noch einmal hochgeladen. Und lassen Sie mich sehen, ob wir hier
eine Änderung
von klarem Zeilenumbruch neu gestartet haben. Was ich bisher geändert habe,
ist, dass Julia einen neuen Nachnamen hat , aber
wir haben
hier nicht die CPP der H. Also Person zugewiesen . Ich würde gerne
ausdrucken, du bist auch das h. Dann gehen wir hier hin, H an diesem Punkt, zum Beispiel, es ist eine ganze Zahl 123 h. Und was ich
hier etwas mehr betonen
möchte ,
warum wir es tun Dies mit dem Setter und Getter ist, dass nicht nur die Daten
von unseren privaten Mitgliedern abrufen, sondern auch einen guten Weg haben , den wir bei einer gewissen
Logik hören können, bevor wir sie eingeben. Zum Beispiel könnten wir sagen,
wenn das Alter größer als 100 Jahre ist, sagten
wir, dass das h beispielsweise 299
ist, die
Datenbankbeschränkung oder was auch immer sonst
betrifft. Wir weisen die Variable unseren privaten Mitgliedern
zu. einmal haben wir hochgeladen. Und wie Sie sehen können, ist
dies auch ein guter Weg, wie
wir QRA sehen und auch
das höhere Qualitätsniveau
unserer gesamten Programmierung und
Datenverwaltung bündig halten können , um PM zu verwenden. Jetzt haben
wir uns hier wieder beim
aktuellen Lebensplan geändert, 155, wir haben das Alter festgelegt, während mein Bot, und im Setup haben wir etwas Logik
hinzugefügt und es hat hier den 99 Julia
LastName MANOVA. Wir sind von Anfang an deinem
Schrecken zugewiesen. Und dann
haben wir die Sekunden
im Setup den
Nachnamen zu Malware hinzugefügt. Dies ist das Prinzip von Settern und Gettern in der
objektorientierten Programmierung.
18. Vererbung: Eines der
Hauptkonzepte ist auch, dass wir die Klasse von
einer anderen Klasse
erben können . Das heißt, wir haben eine Blaupause,
einige allgemeine Aufzeichnungen. Und dann können wir
all diese Funktion verwenden, all diese Variablen
in unserer Klasse. Wenn Sie also ein wenig
über objektorientierte Weise googeln und recherchieren, ist
eines der
Hauptbeispiele immer im Allgemeinen und im Allgemeinen Heizung. Und dieses Fahrzeug ist eine Klasse. Und dann können Sie
alle Funktionen erben und nutzen und
an einen Sportwagen angepasst und an einen SUV und zwei
Autos, Autos, Autos usw. damit Sie das große Ganze bekommen. Es ist im allgemeinen Code. Und dann könnten Sie auch andere Klassen mit
einigen einzelnen Codes
angeben. Aber das ist auch mein
Fall, dass wir oft
verwenden, dass es uns eine API
gibt. Es wird eine Schnittstelle genannt, die wir
in der
Klasse für unseren eigenen Zweck verwenden und
an unseren eigenen Zweck angepasst werden können . Wie könnten wir
das in unserem Beispiel machen? Hier haben wir unsere
Objekte, unser Projekt, und wir erstellen
hier einige neue Dateien da wir jetzt der Person und dem Kunden hinzufügen
möchten. Und das könnten wir mit dem
neuen Dateikunden tun, dass H und neue Dateien Kunde dot cpp. Ich wechsle den Kunden
, der h nach rechts ist. Und jetzt können wir
hier all die Dinge erklären , die wir zuvor gemacht haben. Zunächst beginnen wir
mit der Klasse,
Klassenkunden-Semikolon . Dann brauchen wir hier am
Arduino wie zuvor. Und wir müssen Wachen einbeziehen , weil ich es dir später zeigst. Das ist notwendig. Aber wie können wir es jetzt machen? Sie haben für die
Klassenperson an den Kunden geerbt. Daher eine öffentliche Person mit einem doppelten
Punkt. Jetzt haben wir einen Fehler, weil Person hier nicht enthalten ist. Fügen Sie Person Punkt
h. ein. Und jetzt haben wir die
Person
erfolgreich an die Kundenklasse geerbt. Und wie Sie hier sehen können, haben
wir eine
Person, die H einschließt , um
Person Punkt h einzuschließen, Die dritte. Und deshalb ist es notwendig , dass wir
Wachen einbeziehen müssen, nicht immer
wieder den ganzen Code enthalten. In dieser Kundenklasse könnten
wir also auch
seine eigenen privaten Dinge definieren. Zum Beispiel ganzzahlige
Kunden-ID, Ganzzahl, Umsatz, öffentlich, z. B.
Kunden-ID, Ganzzahl, Zahl. Und was wirklich
notwendig ist , wenn wir etwas
erben, müssen
wir den Konstruktor
aus unserer Basisklasse verwenden. Und wie können wir das machen? Wir gehen weiter zum Kunden und sagen, dass
wir persönliche
Doppelanleihungsperson
verwenden,
das bedeutet, dass wir geerbt haben und denselben Konstruktor
in unserer geerbten Klasse verwenden. Perfekt. Bisher so gut. Was wir jetzt tun, ist, dass wir wieder auf Kunden-CPP
wechseln. Schließen Sie Kunden Dot h
ein, schließen Sie Arduino Dot h ein. Und wir können Ihre weiße
Kundendoppelbindung,
doppelte Bindung, gesetzte
Kundenidee, ganzzahlige Zahl festlegen. Und man könnte sagen, dass die
Kunden-ID Nummer ist. Bisher nichts, besonders
was wir hier nicht sehen, aber was wir x's bei
unserem Kunden haben, ist älter. Oder was wir nutzen können, ist die
ganze Funktion, die
wir hier bereits hatten. Das bedeutet, dass wir das Alter festlegen können, Nachnamen festlegen können, aber wir können auch die Details
drucken. Also schauen
wir uns die Haupt-CPP-Datei genauer an. Unter Julia würde ich sagen, dass wir ein neues Objekt
erstellen
und es heißt Kunde, weil dies unser neuer
geerbter Klassenroboter ist und ein Kunde ist. S haben wir hier erklärt, wir operieren. Wir verwenden
denselben Konstruktor. Das heißt, wir haben hier
einen Roboter oder einen Freund eine Nadel
benutzen und er ist einer. Die Fünf. Hi. Werfen Sie einen genaueren
Blick darauf, warum ist es kaputt? Weil wir diesen Kunden nicht
einbezogen haben, dot h. und jetzt sollten wir uns
auf Kunden, Kunden, wenden. Jetzt kompiliert es. Also haben wir
hier initiiert und neues Objekt,
es heißt Robert. Und wir haben auch
den Konstruktor geerbt. Jetzt möchte ich hören, wie Robert Personendetails ausdruckt und
erneut in unseren ESPN hochlädt. Und in der Zwischenzeit
möchte
ich noch einmal betonen , dass wir hier die Details
der gedruckten Person nicht erklärt haben . Dies wird
automatisch von
der Person dot h verwendet , da wir
alle Funktionen geerbt haben. Wenn also alles richtig
läuft, sollten
wir Ihnen auch
alle Informationen
von unserem Roboter besorgen . Das ist die Eröffnungszeremonie abgeschlossen. Wir sehen Robert Nachname Casinos, Alter, Geschlecht und Größe, 195. Und wir haben erfolgreich eine komplette Klasse
geerbt , sie
angepasst und
nutzen auch die Funktion
unserer Basisklasse. Und natürlich
können wir hier unsere
eigene funktionale
Kunden-ID verwenden . So können wir auch hier einstellen Roboterset Kunden
die Dysfunktion ist nur in der,
in der Kundenklasse verfügbar . Und deshalb könnte ich zum Beispiel 255
sagen. Und es wird funktionieren
wie zuvor. Das Konzept ist also, dass wir eine Basisklasse
verwenden
und an
eine neue Klasse geerbt werden und alle
Funktionen nutzen, die unsere neue Klasse
öffentlich
zugänglich sind. Das ist es, was
vererbt ist und warum wir es regelmäßig
objektorientiert verwenden.
19. Vererbte Funktion überladen: Was wäre, wenn wir die gedruckten
persönlichen Daten auch
in unserer Kundenklasse verwenden möchten , denn in der Person für Sie ist es absolut sinnvoll, dass
wir Alter,
Geschlecht und Größe ausdrucken , aber
nicht als Kundensicht. Und deshalb können wir genau dort
ein Oval überladen, Personendetails in
unserer geerbten Klasse drucken, und das machen wir jetzt. Deshalb gehen wir den Kunden
diesen Vorteil und sagen, wir möchten
eine Verkaufsnummer hinzufügen und Alter, Geschlecht und Typ loswerden
. Daher würde unsere
Hilfsfunktion set
aufrufen, Verkäufe zusammenfassen. Und wir definieren ganzzahlige Verkäufe mit einem zugrunde liegenden
und weißen Druck. Alle Verkäufe. Wie nennen wir das
print all print. Kostüm-Person. Es heißt „
persönliche Daten drucken“. Ja, das
wollen wir jetzt überschreiben. Es erklärt
dem Kunden jetzt erneut, dass H wir zum Kunden CPP springen können. Das erste, was der Kunde
doppelt blind ist, einige Zellen
doppelt blind sein . Und wir haben ganzzahlige Verkäufe. Und wir sehen, dass die Verkäufe, dies ist die private Variable, bei diesen Verkäufen sind. Aber wir
fügen hier nicht ein Plus hinzu, also werden
sie in der Haupt-CPP zusammengefasst , die
wir hier verwenden könnten. Zum Beispiel Robert, einige Verkäufe. 1505200. Ich möchte
hier nochmal 150 hinzufügen. Wir haben also
dreihundertfünfzig, fünfhundertfünfzig und fünfzig in einer Zusammenfassung. Und dies sollte
in die Details der gedruckten Person ausgedruckt und Personendaten gedruckt werden. Wir haben bereits in der Person
erklärt, aber wir wollen Alter, Geschlecht usw.
loswerden. Deshalb definieren wir
hier noch einmal diese Funktion. Seien Sie also überladen,
drucken Sie Personendaten aus. Und ich springe zurück zu
Person CPP und kopiere alle Dinge, die wir hier
gemacht haben, und füge es ein. Und ich würde das gerne
loswerden. Und diese Verkäufe. Der Umsatz. Ist das eine Ganzzahl? Okay? Was können wir also sehen? Jetzt? Wir sehen, dass
wir einen Fehler in Bezug auf Namen und Nachnamen haben,
wie heißt? Es heißt. Wir können nicht auf den Namen zugreifen
, weil er nicht deklariert wurde. Die X's sind nicht verboten. Warum ist das so? Werfen wir also einen Blick auf den Kundenpunkt h. Wir haben hier nicht für
Namen oder Nachnamen deklariert ,
weil er vererbt wurde. Wir sind nicht, wir treffen uns nicht. Es ist nicht nötig, es einzulösen. Dann
schauen wir uns persönlich an Punkt h. Dies ist privat, und wie wir wissen, ist
alles Privat nur von Person, von einem Objekt
aus
zugänglich , von
der Person dot h. Aber wir sind jetzt in einem Kunden. Also haben wir geerbt, aber
wir haben keinen Zugang. Was können wir tun, wie wir es zu
Beginn
des Diskurses getan haben ? Wir kennen drei Mitglieder
einer Klasse und wir könnten dies
ändern, um sie zu schützen. Was ist jetzt geschützt? Geschützt bedeutet, dass es in der Personenklasse
privat ist, aber für alle
geerbten Klassen öffentlich ist. Und wie Sie sehen können, haben wir
jetzt keinen Fehler. Das ist wirklich ein guter
Weg, weil jemand vielleicht
diese ganze Datenkapselung
für seine eigene Klasse speichern möchte . Aber ist kein Entwickler für
Open-Source-Projekte und sagt, okay, du kannst all meine Sachen benutzen. Aber bitte habe ich auf deine Weise geerbt
und bearbeitet. Und mit dem geschützten Staat. Jetzt haben wir die Funktion „
Druckdetails“ übernommen und überlastet. wir noch einmal alle Dinge
hoch springen zurück zum Haupt-CPP. Und was sich geändert hat ist Eddie gekauft und sollte es
wirklich alle Details
aus der Klasse
ausdrucken alle Details
aus der Klasse
ausdrucken ,
natürlich von der Person. Wir sollten hier die Verkäufe zusammenfassen und
die neue
Verkaufsfunktion, neue Linie,
ausdrucken . Und wie Sie sehen können, hat Robert erfolgreich nur für Name, Nachname und die Verkäufe,
die hier zusammengefasst sind. Dies ist ein Hauptkonzept, das Sie geerbte Funktion überladen
können. Seien Sie sich der geschützten
und öffentlichen Mitglieder bewusst. Und wir könnten hier auch
einige eigene Funktionen hinzufügen, aber wir könnten sie auch überlasten. Und ich denke, das ist wirklich
praktisch, wenn es
um die öffentliche und
Open-Source-Entwicklung geht . Wir haben also viel Potenzial, wo wir es nutzen können. Drucken Sie also Personendaten aus.
20. Einführung in die Zusammenfassung von OOP: Wenn Sie mir alle Schritte dieser
praktischen Übungen mitverfolgt haben, kann
ich Ihnen gratulieren,
weil Sie jetzt
die grundlegenden Konzepte des
objektorientierten Ansatzes gelernt haben , was wir hier brauchen dieser Online-Kurs für
die Arduino-Umgebung. Dies sind wirklich
die Kerngrundlagen. Ich möchte eine kurze Zusammenfassung
machen ,
damit wir
alle bisherigen Erkenntnisse zusammenfassen können. Zunächst haben wir uns die Syntax
genauer angesehen, wie wir eine Klasse definieren können, wie wir eine Klasse schreiben können und was ist
Datenkapselung? Das heißt bei den öffentlichen
und privaten Mitgliedern, sollte es
aber auch schützen. Einmal. Danach haben wir ein Objekt
initiiert. Wir haben es in der Hauptakte gemacht. Und wir
verwenden auch Konstruktor. So
könnten erste Eingabeparameter
unsere privaten Mitglieder im
Initiationsprozess verwenden und festlegen . Dann haben wir über
den Getter und den Setter gesprochen. Wie könnten wir also die
öffentliche Funktion nutzen , um
auf private Mitglieder zuzugreifen, und wie wir
Daten während unserer Codierung aus der
Lebenszykluslebensdauer ändern könnten . Und danach haben wir uns auch die Vererbung genauer
angeschaut und wie wir
Klassen in zwei anderen Klassen erben konnten. Wie könnten wir die Klasse verwenden, die geerbte Klassenfunktion. Wie könnten wir Funktion überladen, die wir geerbt werden
Hauptkonzept. Und danach versuchen wir auch, die verschiedenen Arten
der Datenkapselung zu hören ,
zum Beispiel
mit den
geschützten, so dass wir
Xs in der geerbten Klasse haben , aber nicht in der Basisklasse. Dies war, um die Grundlagen zu finden. Und jetzt springen wir
direkt in unsere Übungen ein.
21. Berechnung von Verdrahtungs- und series: Fangen wir mit
dem Verkabelungsteil an. Wir haben auf der rechten
Seite den ESP 32. Das erste, was
wir tun, ist, dass wir den Boden mit
dem Steckbrett
verbinden. Und jetzt haben wir hier eine LED. Und diese LED hat zwei Kollektoren. Der erste ist, dass eine
Bestellung die Plusseite ist, und es ist auch da, der seitliche Verbindungsstift. Und dann haben wir den Knorpel. Es ist der Minus-Teil. Und wie Sie sehen können, haben
wir hier und den Widerstand, bevor wir die LEDs
anschließen. Und das ist notwendig
, weil wir
den Grundstrom für die LED zu begrenzt haben. Und wie können wir das machen? Es gibt viele
verschiedene Websites, auf denen Sie
es berechnen können , da es für
jede andere Farbe erforderlich ist , die Sie implementieren. Sie müssen sich für
den richtigen Widerstand entscheiden. Und das wird mit
einem Arduino Uno mit dem Fünffachen berechnet. Seien Sie sich bewusst, dass wir hier in
diesem Beispiel verwenden und verwenden Sie be 32. Und früher war es 32
hat eine Ausgangsspannung, Spannung am GPA oder vom
Kreisverkehr, 3,3 Volt. Deshalb müssen wir hier die Werte
so
anpassen , dass wir den richtigen
Widerstand an den richtigen Ohm erhalten. Lasst uns zum Beispiel ein bisschen runter
gehen. Dies ist die ganze Berechnung. Wir müssen also sehen, dass die
Gesamtspannung in unserem Fall
3,3 Volt minus der
Spannung an der LED beträgt , da wir
nur eine bestimmte
Spannung an der LED haben wollen , damit der richtige Grundstrom
des Die LED befindet sich an der LED. Und deshalb müssen wir es hier
machen und berechnen. Also lasst uns direkt hineinspringen. Zum Beispiel. Wir möchten für
die rote LED diesen Widerstand berechnen. Daher sagen wir, dass
die Hauptspannung 3,3
Volt minus 1,6 Wörter für
die LED beträgt und der Rest davon muss
die 1,7-Spannung für den Widerstand steigen oder fallen muss. Bei der
1,7-Volt-Nachverfolgung des Widerstands erhält
die LED nur 1,6 Volt
und auch 0,02 Ampere. Und das ist es, was wir brauchen. Also sind wir jetzt
noch nicht fertig mit unserer Berechnung, denn wir haben
nur hier die Spannung, die
sich am Widerstand zusammenklappen lässt. Dann haben wir 1,7 Volt geteilt
zwei Grund- oder Hauptstrom. Das ist 0,02 und pass. Und als Ergebnis bekommen
wir, lasst uns
einen genaueren Blick darauf werfen. 58 Ohm Wie Sie sehen können, gibt es einen kleinen Unterschied. Aber in den Hauptkontexten würde
ich vorschlagen, dass Sie
beispielsweise auch
die Melodie von 20 Ohm verwenden . Es kann nicht beschädigt werden oder sollte aufgrund von LEDs nicht
beschädigt werden. Aber es wird nicht hell oder ist so hell, weil es nicht die volle Spannung bekommen
kann. Aber in meinem Fall habe ich auch 220 oder 110
Ohm für alle benutzt . Nur zu Schulungszwecken ist
es einfacher zu verwenden, ist
es einfacher zu verwenden wenn Sie sich in einer
produktiven Umgebung befinden. Ich empfehle Ihnen, den genau Widerstand
genau Ohm zu
berechnen , da es
sich auch um
die Haltbarkeit oder die Lebensdauer der LED
und der Komponenten handelt. Jetzt wissen wir
über den Widerstand Bescheid. Lassen Sie uns prüfen, wie wir alles miteinander
verbinden können. Wie
prüfen Sie Ihrer Meinung nach, ob es sich um einen Ausgangspin handelt? Und dann verbinden Sie
den Ausgangspin vom ESP 32 mit dem Widerstand, den Widerstand mit der ungeordneten
Liste, je länger Teil. Und dann verbinden Sie den
zweiten Teil der Kathode mit
den Minus- oder
Erdungsteilen. Und das war's. Nehmen Sie so viele oder so
viele LEDs wie Sie möchten. Ich habe hier 3691215 LEDs. Es zeigt
Ihnen also ein bisschen
mehr, was wir mit dem
objektorientierten Ansatz machen können. Und wenn man nur
zwei oder drei LEDs hat, ist
es nicht so viel. Es ist okay. Und, aber Sie sehen die Hauptvorteile, wenn Sie Ihrem Projekt fünf oder mehr
LEDs
hinzufügen.
22. Die LED mit einem Objekt steuern: Lassen Sie uns nun ein paar
Funktionen zu unserem Programm hinzufügen. zunächst mit der rechten Maustaste
auf den Deckel dot h und teilt sie zu schreiben,
so dass wir
auf der rechten Seite
die Header-Datei haben . Und wir öffnen uns auf der
linken Seite, um Punkt CPP zu löschen. Und weil dies der Fall ist, möchten
wir die
Funktionalität hinzufügen. Zuallererst, schließen Sie die LED ist dot h ein, damit wir Zugriff
auf unsere Klassenelemente haben. Als nächsten Punkt würde
ich empfehlen den Arduino dot h einzubeziehen, damit wir hier
alle Zugriff auf die
Arduino-Umgebung haben . Zunächst möchte
ich den Konstruktor definieren. Der Konstruktor ist
als Hauptmethode , die
aufgerufen wird, wenn wir das Objekt später
im Hauptpunkt cpp
erstellen. Der Konstruktor hat also einen Hier - und Eingabeparameter und er
heißt Integer Pin. Wir sind also LEDs, LEDs wie der
Klassenname heißt. Und dann rufen wir
den Konstruktor an. Es ist der gleiche Name
wie der Klassenname. Dann haben wir ein
Eingabeparlament. Es heißt Pin, geschweifte
Klammern öffnen, schließen. Also haben wir hier
unsere Funktionalität. Was machen wir jetzt
mit dem Konstruktor? Der Konstruktor nimmt die
Pin-Nummer, den GPO-Arm. Und so speichern wir die Pin-Nummer in den privaten variablen Pin, LED, Pin, es dort, Pin. Und dann ist es
in der Klasse gespeichert. Und später können wir es
ausschalten und einschalten. Und das waren verschiedene
Arten von Objekten. Und im zweiten Teil würde
ich empfehlen, dass
wir
mit Pinellia Reh auf den PinMode zugreifen oder diese definieren. Und es ist ein Output, weil
wir LEDs haben und diese Woche Anleihen
Belohnungen für den GPIO
wollen. So könnte der PinMode
auch außerhalb
der Setup-Funktion aufgerufen werden , da ich sie
später geöffnet habe. Wir können hier ein Objekt erstellen, zum Beispiel Deckel, weiße und dann
die geschweiften Klammern, der Konstruktor wird
aufgerufen und weiß,
der erste ist bei GPO 12., in meinem Fall wird geschlossen Klammern. Und jetzt haben wir
unser erstes Objekt geschaffen. Es heißt weiße
aus den Klassen-LEDs mit dem Konstruktor
12. Ganzzahl. Und so haben wir hier die Sets, die private variable Pin-LED, und wir haben den Pin-Modus eingestellt. Wieder einmal, warum wir hier auf
die private Variable zugreifen
können , weil wir es
hier innerhalb der Klasse zu tun haben. Wir können mit dieser sehr realen
Pin-LED nicht zugreifen, dies ist nicht möglich. So weiter. Jetzt möchten wir
die Funktionalität hinzufügen. Zum Beispiel könnten wir weitermachen geschweifte
Klammern ein- und ausschalten. Und so könnten wir sagen,
digitale Pin-LED hoch. Und wir bekommen hier einen Pfeil, während
er eigen ist, weil wir hier
definieren UND in Deckelpunkt-CPP
funktionieren. Aber wir sind nicht
an der Klasse dran. Deshalb müssen wir identifizieren, sie vor der Funktion stehen. Es ist der Klassenname
Doppelblind, Doppelpunkt. Und jetzt wird die Zuverlässigkeit
erkannt und wir können die LED
als x-Funktion
einschalten. Wir würden es ausschalten. Es ist ausgeschaltet. Digitale Rechte, Pin-LED und niedrig. Ich habe einen zusätzlichen Fehler bekommen. Warum ist das so, denn
schalten Sie sein Ohr und seinen Eingabeparameter aus. Und das dient auch zu
Trainingszwecken. Warum ist es so analog zu Bullen, analog zu schlechtem Protokoll von und
wie wir bereits erwähnt haben, nicht analog und digitales
Weiß mischen und deshalb passe
ich hier und
bool Variable, die wir überprüfen können, ob
analog von ihm wahr ist. Dann müssen wir die LED mit Analog
ausschalten. Rechts unten
rechts Pin LED 0. Sonst könnten wir
digitale Rechte nutzen. Der nächste, der nächste Fehler tritt hier auf da AnalogWrite
nicht definiert ist. Warum ist das so? Da ich es also nicht
einbezogen habe, müssen
wir
einen weiteren richtigen Punkt h einbeziehen. Und jetzt sind wir Angst
und einfache Logik. Mit der Funktion „Ausschalten gehen
wir hier ein
und wahr oder falsch. Wenn es stimmt, schalten wir die
LED mit Amilorid ab. Wie beim DigitalWrite, dem AnalogWrite, den
wir später
zum Fading on oder vier verwenden . Sagen Sie Detektoren, damit wir
das Licht in verschiedene
Arten von Aspekten einstellen können . So etwas schüchtern oder
verblasst und nicht nur mit der vollen
Helligkeit
befleischen. Das ist der Grund, warum ich hier bin. Machen Sie einen kleinen Umweg, um Ihnen zu
zeigen, wie wir Ihnen
auch einige
Eingabeparameter usw. übergeben können. Jetzt haben wir hier die
Funktionalität innerhalb des Konstruktors. Wir haben die Funktion
und die Ausschaltfunktion eingeschaltet. Und jetzt möchte ich
es in unser Hauptprojekt umsetzen. Hier
ist also schon der Weiße definiert. Jetzt kann ich hierher gehen,
indem ich einen weißen Punkt eintippe. Und hier sehen Sie
alle Funktionen
, die in der Header-Datei definiert sind. Sie haben jedoch nur eine gewisse Logik
hinzugefügt, um sie einzuschalten. Und in der Schleife machen wir
hier und verzögern nur für
Trainingszwecke für fünf Sekunden. Und dann können wir weiße sagen, ausschalten, Klammern einschalten. Und hier haben wir
den Vorschlag. Bitte geben Sie uns hier
in der Bullenvariablen an. Und ich kann erkennen, aha, wovon ist es Bool Analog? Wenn du
deine sehr reichen,
sehr gut beschreibst , dann
musst du nicht
darüber nachdenken, was ich hier gemeint habe? Analog von ist falsch, weil
wir nicht richtig digital sind. Und das sollte
für das erste Beispiel funktionieren. Dann schlage ich vor, dass
wir auf die Tischplatte klicken. Ich habe mein
Breadboard mit meinem PC verbunden. Dies ist eine alte Skizze
, die läuft. Dann lege ich es. Zuallererst überprüfe ich
es mit dem Compiler. Wenn ich etwas
falsch geschrieben habe, ist es nicht. Es sieht aus, als ob Waren
die gesamte Skizze hochladen und auf die Schaltfläche klicken, um das Ganze zu
spülen. Jetzt wird es hochgeladen und dann sollte
es nur Erfolg haben. Ich habe das falsche Programm. Ich muss
für den englischen Teil auf LEDs wechseln, noch
einmal
das richtige Projekt hochladen. Sie sehen hier können Sie
das Projektverzeichnis ändern. Und weil ich hier geöffnet habe, viele verschiedene
Möglichkeiten für unsere Projekte. Verbinden, noch einmal, Putten. Und jetzt sollte nur die erste LED, die weiße, die fleischig sein
sollte, eingeschaltet sein, wie Sie sehen können, nach fünf Sekunden
sollte sie sich sehr gut ausschalten. Jetzt würdest du vielleicht sagen:
Okay, es macht Sinn, aber es gibt viel mehr Codes
zu schreiben als ich es gewohnt bin. Ich habe ich könnte es auch hier
definieren. Das stimmt, aber bleib dran. Jetzt können wir
zum Beispiel zwei weitere LEDs sagen . Zum Beispiel grün ein rot, ein Jahr die richtigen Pins. Man könnte sagen, dass grün ein, roter eingeschaltet ist,
das hat funktioniert. Und dann sagen
wir auch hier nach Verzögerung, dass
der grüne und der rote ausschalten
sollten. Klicken Sie mit der rechten Maustaste auf
Dokumenten-Up Und dann tut es mir leid, LED sollte sich einschalten und
nach fünf Sekunden sollte
sie ausschalten. noch einmal gebootet. Und wie Sie hier sehen können, sieht
es so aus, als ob
einige LEDs eingeschaltet sind. Betrachten wir drei
LEDs und nach fünf Sekunden, die losgehen. Perfekt, unsere Skizze funktioniert, aber es sieht so aus, als wären sie an,
aber das liegt daran,
dass aber das liegt daran ich ein paar Strahler habe und
dies ist das Spiegelbild davon. Also ist es ausgeschaltet. Noch einmal. Starten Sie den ESPN neu. Wie Sie sehen können, werden die drei LEDs, die
wir hier deklariert haben, weiter und
danach ausgeschaltet. Dies ist ein einfacher Weg. Ich möchte Ihnen
vorstellen, wie der objektorientierte Weg viele Vorteile hat , denn
hier haben wir ein Muster. Mit diesem Muster können
wir viele,
so viele LEDs ansprechen , wie wir wollen. Und wenn wir etwas
im Abschaltteil ändern
möchten , müssen
wir es
hier einfach machen und alle
LEDs sind betroffen. Im nächsten Video möchten
wir noch
einige Funktionen hinzufügen, möchten
wir noch
einige Funktionen hinzufügen damit
Sie sehen können, dass wir auch verschiedene Arten von
Funktionen für die LEDs verwenden
können.
23. Headerfile: Ich fühle ein neues Projekt
in Visual Studio Code. Und du kannst mir auch
mit dem
anderen Zwischenprodukt folgen , erstelle
einfach ein neues Projekt. Dann habe ich in
die analoge
Rechtebibliothek der Hauptdatei aufgenommen die analoge
Rechtebibliothek der Hauptdatei wir brauchten, weil wir
ein PBM-GPIOs verwenden möchten , damit wir
die Ausgangsspannung in
verschiedene Arten von Steckplätzen einstellen können die Ausgangsspannung in ,
damit wir verblassen können zum Beispiel unsere LEDs. Seien Sie sich bewusst, wenn wir externe Bibliotheken
verwenden. Auch GoTo-Plattform. Und verweisen Sie hier auf
die Bibliotheksabhängigkeit. Auch wenn Sie bei der EDA sind, können
Sie hier
auf der linken Seite den Bibliotheksmanager verwenden und das
Analog einschließen, oder? Ich bin mir nicht sicher, ob es
bereits im Kern
des ASPE 30 enthalten ist , um es beim Kompilieren nur einen
Test zu geben, dann sollten Sie
Erfolg oder einen Fehler bekommen. Dann musst du
die Bibliothek hinzufügen. So weiter. Dann gehen
wir als Exponent in das
Quellverzeichnis und erstellen zwei neue Dateien. Wir beginnen mit
der Header-Datei, und sie heißt LED's dot h. und auf die gleiche
Weise fügen wir
dann CPP-Dateideckel Punkt CPP hinzu . Okay? Wir beginnen mit
Deklaration oder definieren die Dinge in den
LEDs in der Header-Datei. Die Header-Dateien
geben einen guten
Überblick darüber, welche Variablen wir verwenden und welche Funktionen
wir
später im LED-Punkt CPP implementieren , meine Ansätze wir sind, ich verwende das fertige Projekt und füge alles in
Reichtümer in die Header-Datei ein. Denn dann
hast du ihnen einen guten Überblick , was wir gerade entwickeln. Dies ist, wo ich für einen
großartigen Vorteil in der Programmierung halte. Wenn Sie mit
einigen anderen Programmierern ausgetauscht werden, gibt
Encoder-Detektor, Daten, einen guten
Überblick über das Projekt. Zuallererst machen
wir die Include-Guards. Wenn N def LED Schaden ist, ist mein Ansatz, es heißt, es ist
der gleiche wie die Datei. Definieren Sie dann am Ende Deckel. Und wenn es eine kleine Erinnerung ist, hilft
uns
der Include Guard, dass der Code
nur einmal
vom Compiler implementiert wird . Wenn wir also
viele Includes von
den LEDs Punkstar verwenden , prüft
das Programm. Bist du schon implementiert? Wann nicht implementiert? Wenn ja, werden sie nicht implementiert. Ich
würde Ihnen auch empfehlen, zur Hauptdatei
zu springen und
die Include-LEDs dot h zu machen , damit wir auf
die Programmierteile vorbereitet sind. Wenn wir
die Header-Datei einbeziehen, wird
die CPP-Datei ebenfalls
automatisch eingeschlossen. Springen zurück zu LEDs dot h. Und jetzt beginnen wir
damit, unsere Klasse zu deklarieren. Geschweifte Klammern öffnen sich,
geschweifte Klammern geschlossen und am Ende ein
Semikolon. Bisher so gut. Dann tippen wir
privat und öffentlich. Und jetzt könnten wir einfach
mit der Erklärung beginnen. Eine Sache fehlt
und wir müssen diesen Arduino
Punkt h
einbeziehen. Warum ist das
so, damit wir
von ihrer Umgebung aus auf
alle anderen Funktionen zugreifen können. Also fangen wir mit
den privaten Variablen an, also Pin LED und dann haben
wir Helligkeit. Dann haben wir einen
ganzzahligen Fade-Betrag. Und wir haben Jahr- und
Bool Crusade-Modi. Dann habe ich hier
fünf unsignierte Lungen hinzugefügt. Und ich bin mir sicher, dass Sie
den Blink bereits kennen , ohne die Funktionalität zu
verzögern. Und natürlich
musste ich nur eine implementieren, denke
ich eine vorherige Version, aber ich möchte sicher sein und speichern. Also habe ich fünf von ihnen implementiert weil wir später für
die frühen Tage unterschiedliche Kontrollmechanismen
haben für
die frühen Tage unterschiedliche Kontrollmechanismen und so
auf sichere Weise sind. Okay? Der öffentliche Teil, wir haben hier eine Menge Funktionen, die wir später implementieren
werden. Ich füge
es nur mit der rechten Maustaste und wir können Dokument formatieren sagen. Wir verwenden einen Konstruktor
zum Ein- und Ausschalten der Funktion. Und die
Ausschaltfunktion hat auch ein Eingabeparlament und Pool-Analogon von, weil
wir uns nicht mischen sollten. Dies ist nur eine Erinnerung. Mischen Sie nicht analog
und digital, oder? Es ist dieselbe LED, die
nicht wirklich funktionieren wird. Entscheiden Sie einfach, ob Sie
es mit DigitalWrite einschalten möchten. Drehen Sie auch die Angebote
digital nach rechts, und es ist das Gleiche
wie analog, oder? Deshalb haben wir eine
Funktion und wir prüfen, ob Sie mit
Analog von eingeschaltet
sind oder nicht? So können wir dieses Fade
Down mit Millisekunden überprüfen. Wir haben eine
Zielfunktion, f Funktion. Wir verwenden unser Ausschalten
nach einer Verzögerungsfunktion. Wir werden sagen, es sind die LEDs
und wir haben auch nicht auf den Pulsatmodus eingestellt, damit wir ihn in die Schleife setzen
können. Und das ist alles, was du sehen kannst. Hier. Es gibt uns nur
einen wirklich guten Überblick , welche Funktion wir später
implementieren werden. Bisher so gut. Und im nächsten Video
definieren
wir zunächst unsere ersten
Funktionen in der späten Zeit, es ist eine Punkt-CPP-Datei.
24. Toggle LED: In diesem Video möchten wir jetzt
hinzufügen und funktionieren, was unsere LED ein- oder ausschaltet. Und das war stattdessen
, wo wir es nicht wissen, ist es ein- oder ausgeschaltet? Es sollte
also automatisch automatisch sein. Identifizieren Sie, ob es aktiviert ist oder nicht. Also die Zielfunktion, wir sind hier in den LEDs dot
CPP und ich tippe weiß ein. Es ist
Klammern ein- und ausgeschaltet. Jetzt schreiben wir
Ihre digitale rechte
Pin-LED n-Tier zum
Beispiel Hi oder niedrig. Aber jetzt möchte ich
den Status von der LED haben. Ich möchte, dass du es weißt.
Deshalb könnten wir digital sagen, es dort anheften. Und die Pin-LED referenziert uns oder gibt uns zurück, ob der
GPA oder er eingeschaltet ist oder nicht. Wenn also die LED
blinkt und R eingeschaltet ist und wir hier digitale
Lese-Pin-LED schreiben. Wir reduzieren uns auf höher. So liefert es uns zum Beispiel hoch oder niedrig. Aber ich möchte jetzt das Gegenteil davon
haben. Deshalb könnte ich
ein Ausrufezeichen machen. Und das wird meine Signale
invertieren. Wenn ich also mit zwei
Ausrufezeichen hierher
komme , wird
es niedrig sein. Und das ist äußerst
praktisch, denn jetzt können wir das digitale
Lesen und Invertieren
hinzufügen. Wenn wir also ein High bekommen, also die LED eingeschaltet ist, bekommen
wir hier den
hohen Teil V, der es umgekehrt hat. Also werden wir niedrig und das digitale Recht
schaltet die LED aus. Auf der anderen Seite, wenn es niedrig ist, gibt uns
die digitalen Lesevorgänge
zurück und tief. Wir haben es umgekehrt. Und deshalb sind wir nicht high. Sehr bequeme Funktion. Und damit wir
zurück zu den LEDs springen können, siehe Hauptteil. Und jetzt werden wir die Verzögerung
los, denn
Verzögerungen sind
beim Programmieren immer schlecht. Wenn
wir beispielsweise nach MQTT auf Sender
- oder Schrittmotoren übertragen, besteht ein Bedarf an
der Schleifenfunktion. Das heißt, die Funktionen haben
immer eine Verbindung. Und wenn wir hier mit Verzögerungen
arbeiten, hat
die Verbindung
Schwierigkeiten, weiterzumachen. Und deshalb wird das Programm
nicht sehr gut funktionieren. Oder für den Fall, dass es so oder so
nicht funktioniert. Daher ist es
notwendigerweise
die Verzögerungen loszuwerden . Und jetzt wollen wir hier
UND-Funktion
implementieren , die
unsere LEDs alle zwei Sekunden ein- oder ausschaltet . Deshalb verwenden wir die
Blink ohne Verzögerung Logik. Und ich bin sicher, du hast schon Dysfunktion
gehört, aber ich habe es
hier noch einmal erklärt. Also brauchen wir hier die aktuelle Lebensdauer
des Programms. Der Lebenszyklus
liegt hier also in Millisekunden. Vorherige Millis
ist hier nicht definiert. Wir gehen also zum
oberen Teil und definieren eine lange Zeit
ohne Vorzeichen, da die
vorherigen Millionen
eine wirklich große Zahl sein könnten , da wir in Millisekunden
sprechen. Es wird also empfohlen, lang
und keine ganze Zahl zu verwenden. Wie funktioniert diese Logik
in wenigen Worten. Zum Beispiel haben wir
hier eine Lebensdauer von 1 Sekunde. Wenn der Code 1 Sekunde Tausend ist,
sind tausend Millisekunden mit tausend Millisekunden mit
Ihren 1000s vorherigen Millis 01 minus 0 ist 1000. Tausend ist nicht größer
als zweitausend, zweitausend n,
zum Beispiel zehn. Dann haben wir 2010
mehr als 2000er Jahre. Und diese Logik,
wenn die Bedingung wahr ist und der Code hier aufgerufen
wird, dann fehlt eine Sache. Wir setzen das
vorherige Dorf auf
den aktuellen Millis zurück , denn
im nächsten Schritt, zum Beispiel
2050 minus 2010, weil dies das letzte Mal
war, dass die If-Bedingung wahr war, dann haben wir die neue Bedingung
ist nicht größer als 2000er Jahre. Wenn zum Beispiel 1 Sekunde später, ist
3.050 minus 2010 nicht
größer als 2000er Jahre. Aber zum Beispiel sind in
den nächsten zwei Sekunden für Tausende 50 minus 2010
größer als zweitausend. Es stimmt. Und die vorherigen Millis
werden auf 44.050 eingestellt und so weiter. Und so haben wir alle zwei Sekunden eine einfache Logik
. Aber wir wollen unsere
LEDs umschalten. Wie können wir das machen? Zum Beispiel, weiß zu schreiben, Kleinkind, rotes umgeschaltet. Und was war es? Es
war das rote, grüne. Sie können eine einfache
Logik sehen, in der wir hier die LEDs ein- und
ausschalten
können. Und natürlich überprüfe
ich in der
Toggle-Funktion nicht, ob es sich um ein
Analog oder Digital handelt, oder? Es dient auch zu
Schulungszwecken,
Ihnen zu visualisieren , was mit
Eingabeparametern usw. möglich ist. Aber hier schalten Sie einfach die LEDs um und
schalten Sie das Projekt auf das richtige Projekt. Dann mal sehen, ob
wir etwas
furchterregendes falsch geschrieben haben oder ob der Compiler uns ein grünes Zeichen
gibt, ja. Dann lade das ganze Programm hoch. Wo sind wir je nach
Tischcam? Da sind wir los. Und wie Sie sehen können, wird
das Programm hochgeladen. Nichts ist es. Wir haben es bereits hochgeladen
und sind alle zwei Sekunden, die LEDs werden ein
- und ausgeschaltet. Also fragst du dich vielleicht: Okay, cooles Ding, aber ich könnte das auch mit einer
Funktion hier draußen
schaffen. Zum Beispiel, weiß umschalten
und dann aufrufen. Und für Weiß, Rot und
Grün stimmt das. Aber später, wenn Sie
verschiedene Arten früherer
Millis verwenden , zum Beispiel mit unterschiedlichen Lebensdauer
und Lebenszyklen, erhalten
Sie das volle Potenzial des objektorientierten Weges. Dies ist nur ein erster einfachster
Schritt, in dem Sie sehen können was möglich ist und wie flexibel der
objektorientierte Weg ist.
25. Deaktivieren der LED nach x Sekunden: In diesem Video möchten
wir jetzt
die Funktionen „Turn nach Verzögerung“ hinzufügen . Also schalten die drei LEDs hier um. Seit wir mit dem USP begonnen haben. Also detune, das ist okay. Und jetzt möchten wir den Skizzenelementen
drei weitere LEDs hinzufügen . Drei LEDs sollten
nach einer bestimmten,
bestimmten Verzögerungszahl ausgeschaltet werden. Und das
wollen wir jetzt umsetzen. Deshalb springen wir in
die LED Eliten dot cpp. Ich kopiere die ganze Funktion aus
der Header-Datei, so dass wir hier genau die
Deklaration kopieren. Lassen Sie uns doppelte Bindung, Doppelanleihen, geschweifte Klammern öffnen und schließen. Und so haben wir hier die Funktion, die sich nach Verzögerung
ausschaltet. Es verfügt über zwei
Eingangsleistungszähler, zehn Millisekunden, so dass wir jede Entität
auswählen können, wie lange sie eingeschaltet sein soll und auch ob sie mit Analog von
eingeschaltet ist oder nicht. Deshalb
müssen wir
auch das Blink-Prinzip ohne
Verzögerung oder eine Logik implementieren , aber ein bisschen anders. Zuallererst wollen
wir die aktuellen
Millis haben, nichts Neues hier. Aber wenn der Zustand wir jetzt
hier haben, hat sich etwas geändert. Wir nehmen die aktuellen
Millis und die vorherigen Millis,
ich verkürze mich. Es ist hier privat definiert
. Wir können es dir
auch auf Englisch benutzen. Schalten Sie zum Beispiel aus. Und jetzt sagen wir, dass
anders als der aktuelle Millis minus
der vorherige
Millis-Ausschalten kleiner ist als
die Millisekunden, die wir an
den Eingabeparameter übergeben. Und auch etwas Neues ist
da, weil wir den vorherigen
Minister nicht zurücksetzen und abschalten wollen . Wie wir es zuvor getan haben, sagten
wir, dass diese
Millionen-Abzweigung aktuelle Minuten ist, aber wir setzen den vorherigen
Nahen Osten nicht zurück. Warum? Weil wir nur einmal wollen, dass diese Logik ausgeführt wird. Also, aber wir wollen den
anderen Teil davon. Und im anderen
Teil sagen wir,
schalten Sie die LED mit Analog von aus. Ausschalten ist also die Funktion, die hier
in unserer LED-Klasse
verwiesen wird . Und das Ausschalten nimmt eine True oder False auf und richtet die Pin-LED ein, die wir zuvor definiert haben. Und das war's. Das war's. Was wir hier haben,
ist in der Logik enthalten. Gehen wir zur CPP-Haupt-Datei. Und jetzt möchte ich hier noch ein paar LEDs
hinzufügen. Deshalb ist ich LED blau, einer ist auf meinem GPO, 16. Dann habe ich LED ist rot, eine ist auf 15. Hab das schon. Ich möchte, dass ein gelber auf 19 ist, und ich möchte, dass weißes
Tool auf GPIO 14 ist. Dann schalte ich die
LED-Leuchten ein, um es einzuschalten. Blauer hat sich eingeschaltet. Und der gelbe schaltet sich ein. Natürlich könnte ich
es auch hier in diesem Teil einschalten, heißt, es hängt davon ab, was
Sie implementieren möchten. Und ich behalte meinen
Code auch gerne so allgemein wie möglich. Und es heißt „Ausschalten nach Verzögerung“, als wir den Namen geändert haben. Es ist also offensichtlicher nach einer Verzögerung ein- und ausgeschaltet. Dann könnten Sie hier zum Beispiel auch
hinzufügen, dass Sie
es nicht mit einer separaten Zeile einschalten müssen. Dann können Sie zum Beispiel auch
das Ein- oder Ausschalten nach
Verzögerung aufrufen . Aber ich würde es gerne allgemeiner
haben. Also schalte ich es einfach ein. Dann ist dieser Teil das Ein- und Ausschalten,
was wir vorher gemacht haben. Und jetzt kann ich weiß sagen , um nach
Verzögerung offene Klammer auszuschalten. Jetzt sehe ich zwei Parameter,
die ganzzahligen Millisekunden. Ich möchte den
ersten nach zwei Sekunden ausschalten, und es ist nicht mit Analog. Sieh richtig aus? Ups. Dann habe ich das Blaue
und ich habe eins geantwortet. Es nennt sich gelber. Der blaue sollte sich nach vier Sekunden
ausschalten, beendet den gelben
nach zehn Sekunden. Wir haben hier also zwei oder mehr gleichzeitige Prozesse
, bei denen FEA, das Blinken und das
Umschalten alle zwei Sekunden stattfinden. Und auch das weiße
bis blaue und das gelbe sollte sich nach einer bestimmten Zeit
ausschalten. Mal sehen, was der
Compiler sagt. Wenn Sie irgendwo etwas
Verschüttung haben, sieht
es bisher gut aus. Dann haben wir hier die blinkende
Skizze gerade los. Dann klicken wir auf Uploads. Klicken Sie auf den Button
, damit sie gespült werden kann. Nte Jetzt Taste. Lass es mich jetzt fleischen. Führte zu blauer Abschaltung
nach zwei Sekunden. Nach vier Sekunden. Nach zehn Sekunden. Ja. Und das sind die in der
Schleife, die wir hier haben,
umschalten, bis Unendlichkeit Unendlichkeitsschleife
ist. Also
starten wir das Programm noch einmal neu. Das Weiß ist, der Y2 ist nach zwei Sekunden des blauen
nach vier Sekunden und die LED wird nach zehn Sekunden gelb
sein. Und du siehst, dass der parallele Prozess mit dem Toggle läuft. Und ich denke, dies ist nur ein gutes Beispiel dafür, dass
Sie sehen können, wie der
objektorientierte Weg
Sie bei
verschiedenen Arten von
Prozessen gleichzeitig unterstützt . Das wirklich zur gleichen Zeit. Aber Sie können sehen, dass es
keinen Unterschied gibt , einen
visuellen Unterschied. Wenn Sie
diese Art von Logik also
normal mit der Fabrik implementiert haben, mussten
Sie hier
drei verschiedene frühere
Millis definieren , da Sie verschiedene Arten von Logik
benötigen. Blinzeln ohne Verzögerungen,
denn hier
haben wir zwei Sekunden,
vier in zehn Sekunden. Und wie Sie sehen können,
müssen Sie drei Funktionen
mit fast der gleichen Logik schreiben ,
aber nicht mit den gleichen Variablen. Und das ist nicht gut, wenn wir Code für
dasselbe
reproduzieren. Es ist nie eine gute Idee,
denn jetzt habe ich hier
ein Muster, das ich ändern
könnte, wie
ich es möchte. Und wie Sie sehen können, können
wir diese Funktion
nur mit einer Zeile aktivieren und
aufrufen. Hier haben wir also das erste Beispiel unserer
objektorientierten Art und Weise.
26. Verblendung: Jetzt wollen wir
implementieren und verblassen. Verblassen. Fading bedeutet
, dass wir die LED Schritt für Schritt in kleinen Werten einschalten,
damit wir
sie reibungsloser ausschalten können. Und deshalb
gehe ich zum Deckelpunkt CPP und wir implementieren
Fade-on-Funktion. Ich hab das kopiert.
Dann o das Eintippen Weißen führt doppelblind,
doppelblind, einfügen. Ich habe hier die Funktion. In dieser Funktion implementieren
wir unsere Blink ohne Verzögerung Logik. Deshalb habe ich hier
die aktuellen Millis. Und jetzt treten wir
genauso ein wie in der Schleife. Das heißt, wir haben
Ihre aktuellen Millis, auf denen
wir auf die
bisherigen Immobilien zugreifen. Sie sehen, dies ist eine
andere Art von Variable, die wir erhalten, die in Sekunden über die Funktion,
den Nahen Osten,
weitergeben . Das bedeutet, dass zum Beispiel alle oder alle zwei Sekunden, drei Sekunden darauf, diese
Logik aufgerufen wird. Und in dieser Funktion können
wir jetzt die vorherige
Millisekunde auf
den aktuellen Millis einrichten ,
so dass wir immer wieder
in die Bedingung eintreten. Jetzt sagen wir, wenn die Helligkeit 25
ist, also weniger als 255, dann könnten wir ihren Wert
erhöhen. Und das könnte
zum Beispiel sein, zuerst drucken
wir die
Helligkeitsstufe aus. Und dann sehen wir
noch einen Blick, oder? Wir sehen die Pin-LED und wir haben Tiefe,
Helligkeitswert. Die Helligkeit ist
am Anfang auf
zwei Serum eingestellt , oder? Und danach erhöhen
wir den
Helligkeitswert um
den Fade-Betrag. Und tödliche Wunde ist auch in privater Variable
, die wir hier haben. Und die Untersuchung ist auf fünf festgelegt. Das bedeutet jede
Zeile oder jede Schleife. Wir erhöhen die
Helligkeit um fünf. Die LED sollte also Schritt die
Helligkeitsstufe
erhöhen. Bisher so gut. Rechtsklick Dokument formatieren. Und wir haben
unsere Füße auf Funktion hier implementiert. Analogwrite könnte auch
einen Assert-Assert-Wert haben. Zum Beispiel hängt der
Maximalwert davon ab , welche Bibliothek Sie verwenden, aber er sollte auch
mit zwei Parametern arbeiten. Dann gehe ich zurück
zur Hauptschleife. Und ich muss
es auf mehr Objekte initialisieren. Ich würde sagen, dass wir
sammeln. Lass es mich sehen. Ich nehme den LED-Bildschirm
zwei ist auf dem Pin, grün bis 25, und wir
fügen das blaue Tool hinzu. Und es ist auf dem GPIO 17. Am Ende der Schleife verlassen
wir
alles wie zuvor. Also haben wir hier unsere
drei Toggles, Stunden, drei LEDs, die sich
nach den letzten Sekunden ausschalten. Und jetzt sehen wir,
dass
Grün
zum Beispiel in Millisekunden verblassen wird. Und wir müssen Blau
auf 600 Millisekunden verblassen. Bisher so gut, sicher. Mal sehen, was der
Compiler sagt. Wenn wir
etwas falsch geschrieben haben oder nicht. Dann schalten wir
die Kamera ein. Sieht gut aus. Dann laden wir die Skizze hoch und Spülen ist stabil für sie. Jetzt
sollten alle Prozesse aufgerufen werden. Ja, und wie Sie sehen können, diese beiden Funktionen hier haben
diese beiden Funktionen hier die grüne
und die blaue. Der blaue erhöht
600 Millisekunden, fünf Schritte, der grüne
ist ein bisschen schneller. V3 schalten um und die anderen
sind bereits ausgeschaltet. Also werde ich noch einmal
den seriellen Monitor starten, weil wir etwas
in eine Zeremonie eingefügt haben, Zeit kommt hier durch. Und jetzt, wie Sie sehen können, habe ich zwei Nachrichten, war nicht wirklich klar. Ich hätte hier zum Beispiel auch
den PIN-Wert hinzufügen sollen. Aber Sie können hier sehen, dass eine
LED bei 80 und die andere bei 255
liegt, die bereits
verblasst ist. Und hier haben wir
nur das Blaue. Wie Sie sehen können, wird
es jeweils
600 Millisekunden um fünf erhöht. Und ich sage es noch einmal. Hier sieht man das
volle Potenzial
des objektorientierten
Weges , denn hier
haben wir den Sturz. Wir müssen
Funktionsenden ausschalten , die
Fading-Funktion. Und das alles in einem Programm, parallele Prozesse,
gleichzeitige Prozesse. Und wie Sie sehen können, haben wir Angst und einen
wirklich guten
Überblick darüber, was wir hier tun. Es gibt nicht wirklich
viele Koordinaten. Weil Sie sehen können, ob
Aidan, was gespeist wird, können
wir zurückspringen und
hier die Logik eines Fades sehen. Dies ist ein
Hauptvorteil neben diesen parallelen Prozessen,
die wir hier sehen können, der Code ist sehr
sauber und sehr klar. Und auch für einige Dritte
könnte, würde ich sagen, etwas
schneller in die Logik
einarbeiten, etwas
schneller in die Logik
einarbeiten weil sie eine
gute Struktur hat.
27. Pulsate: Jetzt wollen wir
eine andere Parallelfunktion
hinzufügen eine andere Parallelfunktion , die als
Pulsate Funktion bezeichnet wird. Wir möchten die LED
leicht und reibungslos einschalten und
dann auch reibungslos ausschalten. Und ich habe es pulsiert genannt, also kopieren wir es auf unsere
Deckel dot cpp, weiß. Verdoppelte Bond-Doppelpunkte. Und wir fügen
noch die Funktion hinzu. Und jetzt könnten wir
mit den Codes von selbst beginnen. Und wie zuvor verwenden
wir hier die Blink
ohne Verzögerung Logik. Gleiche Zeit wie jedes Mal. Wir sagen hier, wenn aktuelle Millis. Die Lebensdauer, der Lebenszyklus
der Codes
abzüglich der vorherigen
Mitte wird also fortgesetzt. Habe, wir haben
es hier definiert, wir sagen es. Und dann sagen wir geschweifte
Klammern an aus. Als erstes, was wir tun, geben
wir die
vorherigen Millis an die aktuellen Millis
weiter, so dass jeder Kreis, die if-Bedingung überprüft
wird. Dann sagen wir im nächsten Schritt, dass Helligkeit
plus gleich Fade Amount ist. Und fade-Betrag wird auf
fünf gesetzt, wie wir es zuvor
im Schicksal auf S- und X-Punkt getan haben.
Wir müssen hinzufügen, wenn Helligkeit 0 entspricht oder die
Helligkeit gleich zwei, 55 ist. Warum brauchen wir es? Wir brauchen eine Logik, die uns
das Design oder das Design vom Radio
aus der Vorschubmenge hinzufügt das Design oder das Design vom . Denn wenn wir im
Helligkeitsstufen Serum sind, sollte
der Fade-Betrag
das Vorzeichen plus haben, damit wir
jeden Kreis, 51015 usw., hinzufügen . Wenn wir das Niveau von 255 erreicht haben, sollte
der Fade-Betrag das Vorzeichen auf Minus
ändern. Wir zählen also
auf 255250 Iterator. Und deshalb können
wir in
dieser einfachen Logik das Vorzeichen
ändern, den Betrag verblassen. Dieser minus fade-Betrag. Denn wenn wir den Wert
senken und
auf 0 minus kommen, ist
gleich Minus Plus und es steigt. Wenn wir den oberen Betrag erreicht haben, um den
Betrag zu verblassen , ist ein Minuszeichen. Und wir gehen auf einfache
Logik ein, aber effektiv. Und als letztes müssen
wir ein
weiteres Protokoll hinzufügen, richtig? Pin LED. Und wir sehen die
Helligkeitsstufe. Das ist alles, was wir tun müssen. also zurück
zum Hauptteil springen, beginnen
wir, einige neue
Variablen zu hören, einige neue Objekte. Und ich würde vorschlagen, die gelbe Röhre
hinzuzufügen. Es ist auf meiner Pin 21
und lese um zu schreiben. Ich weiß nicht, ob es die
richtige Anstecknadel für ein Formular ist. Und ganz am
Ende unserer Skizze. All diese drei Prozesse
wie das Umschalten möchten sich ausschalten und verblassen. Wir behalten es in der Skizze. Und jetzt sagen wir Rot, um zu pulsieren. Zehn zum Beispiel und sehr schnell. Und gelb um es zu sagen. Um 50 ein bisschen länger. Überprüfe einfach, ob wir ein paar
Pfeile haben, die die Nocke einschalten. Und wie Sie sehen können, ist
dies die
Beispielskizze von früher. Ich klicke auf Hochladen. Dann beschäftigen wir uns wieder
einmal PM. Und die Uploads sollten beginnen. Oben. Versuchen Sie dann, die Kamera zu fokussieren. Wie du
hier siehst, wo füttert ich jetzt? W2 pulsiert
sehr, sehr langsam. Und hier haben wir den
Gelben, der auch
sitzt und nicht der
blaue, der sich nur diesem
ernährt, geht weiter. Und natürlich pulsiert
der rote sehr
schnell. Für Prozesse laufen also verschiedene Arten von
Prozessen im Gange. Und wie Sie sehen können, denke ich, dass sieben oder acht LEDs
verschiedene
Funktionen haben . Wieder einmal
schalten wir diese Realität ein und aus. Diese haben wir verblassen
und wir haben
den totalen Einstieg gleichzeitig pulsiert
. Ich denke, das geschieht wirklich
nur durch ein paar Codezeilen. Und wie Sie sehen können, ist es ein wirklich, wirklich guter Überblick und
hat eine gute Struktur.
28. Objekte in Array Instantiate: In diesem Video
möchte ich Ihnen noch einmal
das Potenzial des
objektorientierten Weges zeigen . Deshalb
möchte ich einen Bereich erstellen
und dann in diesem Bereich speichern
wir alle
Objekte, damit wir ihn
iterieren können und
ein bisschen herumspielen können. Deshalb habe ich die Variable erstellt und const
int weil es ist, ich habe hier 15 LEDs. Und wenn wir
danach hier etwas
in einem Breadboard ändern , brauche
ich hier nur eins und Veränderung sollte alles angepasst haben. Also erstellen wir
jetzt ein neues Array. List ist der Klassenname, das ist der Array-Name, den ich aufrufe. Es. Alle Leads zum Beispiel. Und wir müssen sagen, wie
groß die Gegend sein sollte. Es ist cool, es hat 15 Slots. Dann machen wir hier ein paar
geschweifte Klammern, Semikolon. Und in den geschweiften Klammern könnten
wir sagen, lass uns 12. Dies ist das Gleiche
wie zuvor. Also sieh dir einfach mal an. Wir haben das Objekt
weiß in dieser Form initiiert, sagen
wir, lass uns nur
den Klassennamen, das ist der Objektname,
das ist der Konstruktor. Aber wir könnten auch
so etwas machen. Es ist das gleiche Verfahren, es ist das gleiche Objekt. Wir erstellen ein Objekt. Und wir haben dies mit Deckeln initiiert, den Klassennamen und
den Konstruktor. Und diese Methode werden wir hier im Auge
alle LEDs
verwenden , denn hier haben
wir den Namen keinen Namen. Wir speichern das
Objekt nur im Array. Mal sehen, wie
wir das machen könnten. Ich habe mich vorbereitet,
bereits vorbereitet es bedeutet, dass wir
unser erstes Objekt, zweites Objekt, drittes usw. haben. Also in Ordnung, wie ich
es hier auf dem Breadboard habe. Und so können wir danach
etwas verlieren, wie
ich den Lügendetektor jage. Kann sehen, dass 15 Objekte
hier gespeichert werden. Und das
müssen wir tun, weil wir
es
einzeln mit der PIN-Nummer initiieren müssen. Das ist also obligatorisch. Alle Deckel haben 15
Objekte. Bisher. Wir brauchen nichts im Setup, da
es bereits
in der Klasse erstellt wurde , die wir
von PinMode haben, es ist besser. Jetzt möchte ich jedes Jahr weiter
verblassen. Sind jede der LEDs
gleichzeitig. Deshalb habe ich HIER
UND funktioniert. Nennen wir es Fade in und machen Sie
dann Ihre for-Schleife. Und das ist der automatische Vorschlag. Sie können Integer sagen. Und für Leads Num bedeutet
das 0 bis weniger als 15. Also müssen wir uns leisten, es wird iteriert. Und dann können wir zum Beispiel Daten
sagen , oder es
heißt Allele. Jetzt nennen wir alles Leads. Führt. Dann durchlaufen wir das
erste, das zweite usw. Dann können wir einen Punkt machen. Und wir können sagen, verblassen
auf 150 Millisekunden. Dies ist das Gleiche
wie zuvor. Wenn wir
hier zum Beispiel das gelbe Objekt haben, könnten
wir auch gelb sagen,
um zu zeigen, verblassen auf 150. Und wir könnten gelb sagen, ein Schicksal auf bla, bla, bla. Dies ist das gleiche
Verfahren wie hier, da alle Objekte
in unserem Array gespeichert
sind und wir
darauf zugreifen können, wenn wir iterieren. Also hier ist das Objekt
und dann können wir mit der Klasse
darauf zugreifen . Bisher so gut. Dann müssen wir die
Funktion in unserer Schleife aufrufen. Mal sehen, was der
Compiler sagt. Wenn alles
stimmt, sieht es gut aus. Verbinden Sie den USP
, um
sicherlich ihren
Computerbildschirm zu überwachen, hochzuladen, dann
die Kamera zu wechseln und zu blinken. Jetzt war alles
das Force Up J-Projekt. Lade es wieder einmal hoch, war das Setup für uns
im falschen Verzeichnis. Jetzt ist es also richtig. Projekte sollten zusammengestellt werden. Mal sehen. Da sind wir los. Jeder von ihnen ist, jede der LEDs wird
leicht verblassen , wieder
einmal neu gestartet. Und wie Sie es sehen können, ist
es gleichzeitig. Aber tatsächlich ist es nicht
wirklich gleichzeitig. Es ist ein wenig
verzögert jede LED, aber das ist es, was wir
wollen und jetzt ist es einfach für uns, eine andere Funktion zu erstellen. Zum Beispiel wollen wir
fortfahren, es geht alles weiter. Und dann ändern wir uns
hier, nicht die Fades. Es heißt Erlös innerhalb von 20 Jahren. Und in der Schleife rufen wir alles
unkommentiert auf. Dies können Sie
alle Dinge vorher nicht kommentiert sehen, da wir nur die Array-Funktion
verwenden möchten. Präsentieren.
Lädt erneut die gesamte Skizze hoch. Gefleischt, benutze PM. Und jetzt sollten
die älteren LEDs reibungslos ein- und ausschalten. Perfekt. Wie Sie sehen können, haben wir Kavya
und eine sehr bequeme Möglichkeit ,
viele der LEDs zu steuern . Zum Beispiel können wir
Hunderte und Tausende von LEDs nur mit vier
oder fünf Codezeilen steuern. Und das denke ich, was
wir später auch benutzen. Das ist es, was so mächtig ist,
weil wir hier eine Möglichkeit haben, viele Komponenten
gleichzeitig zu steuern. Und das ist auf eine sehr einfache Art und Weise.
29. LED: Lassen Sie uns hier eine
weitere Funktion hinzufügen einfach zu implementieren ist und wir möchten eine
LED-Verfolgungsfunktion erstellen. Das bedeutet, dass die frühen Tage von
links nach rechts
weitergehen sollten . Und wenn es oben erreicht hat, sollte
sich die LED von
links nach rechts ausschalten und dann wieder von vorne
beginnen. Also nennen
wir es zum Beispiel Jason. In dieser Funktion
schalten
wir zunächst alle LEDs ein. Also verwenden wir hier auf for-loop und wir
sehen hier nicht pulsieren. Wir sehen uns zerrissen. Und wir verwenden die Ebene
einbetten, aber es ist nur zu
Trainingszwecken, damit wir sehen, okay, Es gibt Ihre Unterlage
und es hat einen schöneren Effekt. Dann wollen wir alle LEDs
ausschalten. Also in der gleichen Funktion, die Sie
verwenden, und im zweiten Stock, da diese zuerst iteriert wird. Und hier ist die zweite Schleife. In der zweiten Schleife haben
wir
diese Funktion bereits und sie
heißt Turn für Verzögerung. Wir müssen Parameter eingeben. Die erste ist die Ausschaltverzögerung. Wir sehen 50 Millisekunden
und ist es ein Analogon von No? Das ist der Grund,
warum wir falsch sagen. Zum Beispiel
haben wir hier in Verspätung. Und jetzt könnten wir hier sagen, lass mich ihn sehen. Das war's. Kompilieren Sie es einfach. Sieht gut aus. Eine Sache, die ich verpasst habe,
dass ich die Funktion aufrufen muss, natürlich in der Schleife. Jagen, lädt
das Ganze hoch. Mal sehen, wie es aussieht. Normalerweise sollte es also von links nach rechts
beginnen. Wenn ich alle
Pins richtig eingegeben habe, gemäß der Reihenfolge
hier, die Breadboards? Ja. Von links nach rechts geht
es weiter und wenn
es oben erreicht hat, wird es reibungslos ausgehen. Und wie Sie hier sehen können, haben
wir viele Möglichkeiten, mit denen wir
die LEDs steuern,
ausschalten, einschalten und
wirklich, sehr bequem
mit diesem Bereich und der Bereich ist der alte oder
Ältere Objekte speichert. Viel Spaß beim objektorientierten Codieren und auch mit Arrays.
30. Verdrahtung: Und der vibrierende Teil für dieses
Projekt ist sehr, sehr einfach. Wir haben unseren ESP 32 und hier sind die Infrarotsensoren HV 210
so viel Sie benötigen. In meinem Handwerksprojekt
habe ich also eine Zitrone der Sensoren. Und in diesem Übungsbeispiel hier für diesen
Kurs habe ich fünf. Und es wird empfohlen
, hier
einen Spannungswandler zu verwenden , damit Sie
Ihre externen Pakete,
z. B. 12 Volt, anschließen können . Und dieser Spannungswandler wandelt die Spannung
in fünf Volt um, und diese fünf Volt
gehen an das Steckbrett. Und damit können Sie
hier Ihre Sensoren, den ESP, einschalten. Also sollte das Dual auch dann zu fünf
verbunden sein. Aber ich überspringe diese Zeile,
weil ich mit
dem USB mit Strom versorge , weil wir ihn
programmieren und ein 0 monotone
wollen. Also will ich dich nicht
auf Root-Funktion haben. Das ist der Grund,
warum ich hier übersprungen bin. Wenn fünf Volt Pin. Dann auf der rechten Seite haben
wir hier unser LCD und LED
sollen den Mörtel simulieren. Und wir verbinden uns hier mit
dem Knorpel von
der Elite zu Boden. Dann gehen
wir aus der ungeordneten
Liste, den größeren Pins, zum Widerstand und
dann zur Pin-Nummer 13. Das Muster wird
mit Masse verbunden. Und auf der anderen Seite verbinden
wir uns
ohne Widerstand
an GPR 12., weil wir hier
den
Eingangs-Pull-Up-Widerstand des ESP 32 verwenden . Lassen Sie uns also einen genaueren Blick darauf werfen
und wie ich es umgesetzt habe. Sie können sehen, dass dies mein Setup
ist. Hier. Wir haben die LED und den
Druckknopf und die fünf Sensoren. Einer von ihnen
wird die Autokade sein. Und wie Sie Ihr
kleines Potentiometer sehen können, kann
es vorkommen, dass diese Sensoren die anderen
stören. Dann muss man es mit
einigen Virustrends in
Verbindung bringen, wie ich es hier habe. Und dann
sollte es gut funktionieren. In meinem Fall funktioniert es also einwandfrei. Ich habe es mit einigen
Kabeln hier auf dem Steckbrett verbunden,
das bedeutet, dass der Boden und der VCC und die Ausgangspins angeschlossen
sind, wenn
es hier der Virus ist. Das ist also alles, was wir brauchen.
31. Projekt und Kurs erstellen: Wir beginnen mit
einem neuen neuen Projekt, das ich bereits erstellt habe, das hier in dieser Ära
enthalten ist. Und meine bisherigen Texte, dann möchte ich die Plattform
öffnen, jedes Ende hier sind wir, kopieren und fügen Sie aus den
vorherigen Projekten ein. Das Geld ist also Geld. Diese Geschwindigkeiten laden Ports hoch. Und ich schließe wie immer den AnalogWrite ein
, damit wir es hier haben. Sparen Sie, schließen Sie es. Öffnen Sie erneut Domain CPP. Und jetzt wollen wir eine Klasse implementieren , die identifiziert, welcher
dieser Sensoren ausgelöst wird. Und deshalb
beginnen wir damit, unsere, unsere Klassen zu erstellen. Aber vorher
siehst du, wie ich
die ganzen Virion-Teile implementiert habe. Also war ich früher 32 auf
dem Breadboard Plus und begründete das Steckbrett
, so dass jeder von ihnen ein Netzteil
hat. Und der linke Pin von jedem von ihnen einem
der GPIOs aus dem ESP 32 verbunden, und das war's bisher, die ganze moderne Logik wird
später implementiert, denn jetzt wollen wir uns nur noch konzentrieren auf, ich bin der objektorientierte Weg, wie wir hier auf
die Infrarotsensoren zugreifen können. Dann
erstellen wir zunächst zwei neue Dateien. Klicken Sie mit der rechten Maustaste auf Quelle, neue Datei. Und wir nennen
es IR unseren Sensor oder eine Punkt-h-neue Datei
oder sin dot cpp M. Klicken Sie mit der rechten Maustaste, teilen Sie durch
rechts, schließen Sie diese. Also haben wir unser
Schema von früher und ich möchte
mit der Header-Datei beginnen. Zuallererst Klasse, der Sensor, geschweifte Klammern, Semikolon,
dann privat, öffentlich. Dann brauchen wir hier einen
Tag, einschließlich Arduino. Und wir wussten, dass wir auch
einen Include Guard brauchen, wenn N def Sensor das Alter unterstreicht
und wir das Jahresende haben, genau das Ende
definieren. Und wenn ja, fragen Sie sich vielleicht warum ich diese ganze
Sache immer wieder eintippe. Es war gut. Ich würde sagen, Übung auch
für Sie, dass Sie wissen, das
sind die
Voraussetzungen für den Unterricht. Und wenn Sie es
immer wieder tun, können
Sie zum Beispiel auch eine Vorlage kopieren und einfügen. Aber am ersten Anfang mache
ich es
gerne Schritt für Schritt. Sie können also auch verschleierte
Referenzen sehen, bei denen es sich befindet. Dann springen wir zur CPP-Datei und
wir nehmen hier
den Sensorpunkt h und den Arduino ein. Sie dann im Haupt-CPP Fügen Sie dann im Haupt-CPP ERs und self.age ein. So wurden alle Referenzen
bisher gemacht. Und jetzt können wir mit
der Definition
der Klasse selbst fortfahren. Und ich möchte die gesamte
Header-Datei ausfüllen , damit Sie
einen guten Überblick erhalten , was wir brauchen und was
wir implementieren. sind also, der
zentrale Pin wird der GPO-Status-Tensor sein, wir erkennen, wenn
es nicht geändert wird. Auch im vorherigen Zustand benötigen
wir Daten, um zu identifizieren, welcher
Sensor ausgelöst wird. Intellekt den Punk, oder
wir nennen es Punkte. Weil wir das zum Beispiel auch
sagen wollten, gibt
uns
der mittlere fünf Punkte, zehn Punkte, 20 Punkte, ein Spiel. Zählen Sie Iterationen, ERs und werden ausgelöst, wird
motorisch ausgelöst. Später können wir
auch Spaß und
Logik haben, um den Mörtel zu starten und zu
beenden. Dann können wir
den Konstruktor implementieren. Also nehmen wir die Erd-Sonne
hierher, also ist es der GPI offen. Und wir sagen auch, dass wir die Punkte haben
wollen. Zum Beispiel habe ich das
ein bisschen anders
als diesen Punkt genannt , so dass wir
hier unklar sind , dass ich eine Unterscheidung bin. Dann brauchen wir hier noch eine,
drei weitere Funktionen. Klicken Sie mit der rechten Maustaste, Format,
Dokument, Check, ER, Trigger. Und dies wird
in der Schleife implementiert, damit wir wissen , welche der
US-Volkszählung ausgelöst wird. Und das Kalibrieren stoke lachen, heißt
es zum
Beispiel Kalibrierung. Dies ist unnötig
, dass wir iteriert haben und uns
auch
einige Entzündungen ersparen. Dies ist nur zum Debugzweck und dann
ausgestochen,
wird das Motortor auf einen glatten Gang
und eine neue Version davon hinausgestochen. Also überschreiben wir diese Funktion. Das wird ordentlich sein. Ich
merke, dass ich das verstehe. Dies wird benötigt, Aus- und
Wiedereinschalten des Motors zu
steuern. Bisher ist die
Header-Datei fertig. Die CPP-Datei ist
die Haupt-CPP-Datei als
Referenz und Name eingerichtet. Im nächsten Video können wir
mit dem logischen Teil beginnen.
32. Address einzeln: Fangen wir mit dem
Quellcode und der Logik an. Also beginnen wir mit
der Definition des Konstruktor-Klassennamens
IR-Sensor oder einer Doppelbindung, Doppelbindung I, unserer und so weiter. Und wir haben ganzzahlige
GPIO-Pin- und
Integer-Unterstriche ,
geschweifte Klammern. Und im Inneren sind wir X, sagt Sensor, Pin ist GPO oder Pin. Dann sagen wir, dass Punkte auf den
Punkten stehen und wir haben hier und PinMode Schulden
Sensorpin ist ein Input, weil wir den ER-Wert wollen und
diese noch nicht gestartet haben. Ich würde anfangen Sensor ist eins. Dies wird in
der nächsten Funktion benötigt. Dies ist also die erste,
die erste Einweihung. Wir wechseln zur
CPP-Haupt-Datei. Und jetzt könnten wir
die fünf Objekte an
unsere fünf Sinne richten . Und wie könnten wir das tun, unser Sinn oder ist unser
Notsinn oder ist der Klassenname. Dann würde ich sagen, unser
Sensor ist Notaufnahme, Sinn. Die erste besteht darin, anzuheften. Mein erster Pin ist
14 und ich habe
Punkte tendenziell 2345 zugewiesen . Der zweite Satz oder so für die Arten und den zweiten
Sensor ist kein Pin Sieben. Siebenundzwanzig,
sechsundzwanzig, fünfundzwanzig. Und wir haben den letzten bei r0. Dann geben wir ihnen die
Punkte für 2050 Hundertstel. Und der letzte bekommt 0 Punkte,
denn dies wird später auf unserer Motorkade Watergate identifizieren, ob wir den Motor
starten oder nicht. Okay, bisher so gut. Jetzt könnten wir auch
hier auf Funktion implementieren , zum
Beispiel Checkpoints. Checkpoints befinden sich auf
den Checkpoints. In dieser Funktion könnten wir diese Objekte
ansprechen. Zum Beispiel
sind Sie zentral. Und hier könnten wir sagen Check
Trigger, Check Trigger. Ist es eine Autokade? Nein. Warum setze ich die Motorkade
auch in dieser Funktion ein? Weil ich gerne Trigger-Funktionen
deaktivieren möchte. Welcher meiner Sensoren wird im
gesamten Projekt ausgelöst? Jetzt wenn eine Motorkade, so sage ich den Rest von ihnen. Ich bin Kraftsensor 2345. Dies ist ein wirklich bequemer
und nicht sehr guter Weg. Aber zuerst
zeige ich dir, wie du das im kleinen Umweg machen
kannst . Und danach
machen wir hier einen Array-Sohn, wieder zu ERs
wechseln. Und so weil wir jetzt die Check
Trigger-Funktion
implementieren wollen . Prüfen Sie die
Trigger-Funktion ist also nicht weiß. Äh, es ist nicht unwürdig, ist ein ganzzahliger ERS-Sensor oder eine
Doppelbindungs-Doppelprüfungs-Notaufnahme oder Trigger-Motorkaden. Und jetzt implementieren wir fast das Gleiche wie
mit dem Balanced the Button. Und jetzt würden Sie sich fragen, warum sollte ich eine
Bone-Funktion für eine Notaufnahme machen, vernünftige Wahl und
analoge Lese-Anweisung. Und warum ich das mache,
ist, dass ich
deine Funktion haben möchte , die gerade damit beginnt, zum Sensor
zurückzukehren. Zunächst einmal wird es normal
sein, wenn ich ausgelöst werde. Der Sensor wie dieser
wird ausgelöst, ausgelöst, ausgelöst, ausgelöst, ausgelöst, ausgelöst,
ausgelöst, ausgelöst, nicht ausgelöst. Und ich möchte so etwas haben , dass es
in der Logik ausgelöst wird, aber jetzt gibt es
mir die Punkte zurück. Das möchte ich in meinem Projekt
haben. Also passiert nichts und
wenn der Marmor verschwindet, dann muss
ich mir ihre Punkte ärgern und nur einmal und
nicht fünf- oder sechsmal. Und deshalb könnten wir
wirklich den gleichen Ansatz verwenden wie zuvor. Wir sagen also, dass der vorherige
Zustand beginnt zu zensieren und der
Statussensor ein digitaler
Lesesensor-Pin ist. Also lesen wir den Sensor und geben ihn
an den vorherigen Zustand weiter. Und jetzt sagen wir, wenn der
vorherige Zustand höher ist und der Starttürsensor niedrig ist, das heißt, sein Ziel, dann haben wir E-Fehler, sendet oder ausgelöst, ist nicht wahr, ist Millis, weil
wir es wollen messen Sie die Zeit als debouncing. Wenn wir sonst sehen könnten,
ob der vorherige Zustand
jetzt niedrig ist und der Statussensor
ist, was denken Sie? Dann haben wir hier die
Logik, in der wir jetzt
erkennen können , wie lange die
Jahre und so ausgelöst haben. Und ich möchte sagen, dass hier, wenn Millionen minus ER
einen ziemlich guten Menschenverstand senden, unter
zehn Millisekunden ausgelöst
werden. Nichts sollte
passieren, wenn und sonst. Ich könnte hier sagen, sollte
etwas passieren. Und ich könnte sagen, wenn Motortore, ist
dies der Eingabeparameter. Wenn dies ausgelöst
wird, könnte ich 0 print sagen. Insgesamt. Wir implementieren
dies später, aber ich möchte
es hier abdecken, weil es
einen Eingabeparameter hat und ihr
Lied alle steigen sollte, ausgelöst wenn der Motor
ebenfalls ausgelöst wird. Und wenn es
ein Motor gut ist oder nicht, möchte
ich den Sensorstift
ausdrucken. Bisher so gut. Das ist unsere
Hauptlogik zu Nase. Wenn also unzensiert erkannt wird, wie ich es hier abdecken würde, werden die Millis an einen Sensor weitergegeben und danach wird der Sensorstift
ausgedruckt. Mal sehen, was
der Compiler sagt. Und ich verbinde
das Ganze. Und hochgeladen. Plötzlich
schalten wir die Kamera ein. Hier sind meine Sensoren
und jetzt bedecke ich den ersten und
jetzt verlasse ich den ersten und
lösche den Punkt, ich bekomme
den Sensorstift
auch beim zweiten zurück . Der dritte, der vierte
brauchte ein bisschen nach
unten. Und der fünfte. Und auch hier
gibt es uns ein sehr,
sehr sauberes Ergebnis
von jedem der Pins. Und das ist es, was ich will. Ich will einen Marmor, der
durch die LEDs geht und
mir das Gefühl von Schmerz zurückgibt. Oder später handelt
es sich um Punkte, die hier deklariert
wurden. Dies ist das erste, was
wir jetzt implementiert haben, hat ein klares und einfaches Ergebnis.
33. Objekte in Array: Bisher haben wir unsere Logik
vorerst unser Hauptprogramm getestet und es funktioniert sehr gut. Aber es ist nicht sehr gut. Kodieren Sie es, weil wir
fünf separate Zeilen haben und jede Zeile, die wir
identifizieren müssen , ob unser ER-Sensor
ausgelöst wird, sie werden gebildet. Wir passen unseren Quellcode jetzt an einen objektorientierteren
Weg an, damit wir auch einige
Bereiche hören
können. Wie konnten wir das machen? Wir sagen unseren Sensor, den Klassennamen, und dann nenne
ich ihn unser Array. Hier ist der Platzhalter. Wie viele Bereiche brauchen wir? Geschweifte Klammern öffnen und
schließen. Bevor wir das machen? Ungewöhnlich für sie, weil der
letzte mein Motor sein wird bekomme diesen Sensor, der
uns anzeigt molto start oder nicht. So und auch hier haben wir
die Halle nicht davon überzeugt, Punkte zu überprüfen. Unser IR-Sensor-Array
sollte sich also hier treffen und
const int z. B. num, ER, Sends oder Sensoren sind 44. Für Sensoren, die
uns die Punkte geben. Man identifiziert uns, ob
der Motor anspringt. Also sitze ich hier, die Num Num ER-Sensoren und sie sind bequem hier, dass ich später die Zahlen für
entsprechend 7810 und alle
Schleifen ändern kann die Zahlen für
entsprechend 7810 und alle
Schleifen ändern entsprechend 7810 und alle , die kein Wärmefluss
sind. Ein Hold von For-Schleifen
, die später kommen. Wir werden automatisch angepasst. Es heißt also
Jahressensor, dieser Sensor an. Hier haben wir jetzt eine andere geschweifte Klammern
für jedes Objekt. 40 ist der Pin, zehn ist da. Ich mache einen Punkt. Dann das zweite Objekt,
Pin 2720 Punkte, bestimmtes Objekt 2650,
Fotoobjekt 25100 Punkte.
Das Motortor. Wir lassen es
dort liegen, weil dies ein separater Weg sein
sollte. Dann überprüfen Sie Punkte, die wir
brauchen, und verfolgen Sie weiter. Also für das Tablet. Damit wir die automatische Vervollständigung hierher
bekommen. Ich verwende hier eine
ganze Zahl und zwei für die Zählung und setze
hier die Zahl IRR-Zentren ein. Es iteriert also bis 01234. Dann, ja, ich würde unser Array
sagen
und dann identifizieren, welches
Objekt zeigt. Und ich könnte sagen, Check Trigger. Und es ist falsch, weil
Sie nur einmal
die Punkte sind und ein Sensor manuell adressiert werden
sollte. Und das sind die
modalen Tore, denn je mehr Ziel getrennt ist, ist
Watergate wahr. Ja. Das ist alles, was
wir ändern müssen. Also
noch einmal hochgeladen, kein Kompilieren. Eran schalte die Kamera ein. Ich habe zusätzliche LED hinzugefügt, die auch
im Geigenteil implementiert ist, aber wir kommen
später dazu, so weiter. Zeremonie Dan sollte das
gleiche Ergebnis wie zuvor sein, aber mit etwas Veränderung funktioniert
alles gut. Deshalb haben wir jetzt
das gesamte Programm auf einfachere Weise und einfacher übernommen das gesamte Programm auf einfachere Weise . Wenn wir also etwas
ändern müssen, ist
es sehr, sehr einfach. Und wie ich
in meinem Projekt erwähnt habe, habe
ich hier 11 Sensoren hinzugefügt und überlege, ob du etwas ändern
musst, und ich bin nicht wirklich
flexibel genug. Und es war diese Konstruktion. Wir können unseren Code
einfacher anpassen.
34. Motor aus dem Handumdrehen: In diesem Video
möchten wir jetzt den Motor simulieren. Der Motor ist hier, die LED, und benutze
den Druckknopf. Wir können den Mörser anfangen. Und wenn der Marmor hoch
geht, hoch, oben, oben oben auf unserem Galton
Board, gibt es die Autokade. Dies ist das Zentrum. Und wenn der Marmor an diesen ERs trifft oder
vorbeikommt, wird der Motor
ausgeschaltet und diese Funktionalität
möchten wir implementieren. Jetzt müssen wir daher
zur Haupt-CPP gehen. Und wir deklarieren hier
zwei weitere Variablen. Hier. Die Integer-LED ist eine Ganzzahl. Button ist, also schauen wir uns mal an. Mein Knopf ist auf dem Pin 12.
und D ist in einem CERT-Team. Dann müssen
wir im Setup Modi anheften. Pinmodus-Taste ist
ein Eingangs-Pull-Up, und die PinMode-LED ist ein Ausgang. Entweder Loop-Funktion. Wir möchten prüfen, ob auf
den Button geklickt wird. Deshalb sagen wir „if“. Und wie können wir das
mit dem digitalen Lesebutton machen? Und es muss niedrig sein, weil ich den
Knopf an das Tief angeschlossen habe, an den Boden und einmal
einen Stift an den GPIO. Und deshalb würde ich sagen, wenn digitale Lesetaste
niedriger ist , als etwas passieren
sollte. Und in diesem Fall ist
DigitalWrite LED hoch. Also schalten wir den Motor und hier schalten wir die LED ein. Dann
wird der nächste Teil sein, wenn die
Motorkade ausgelöst wird, unser Sensor am Ende sollte
er ausschalten. Deshalb schalten wir es
zurück auf den ER-Sensor um, damit wir Zugriff auf unsere Variable haben. Wir müssen sagen,
externe Integer-LED. Und so sagen wir das Programm. Bitte schauen Sie außerhalb
dieses Programms nach. Diese Variable muss auf der
externen Seite
identifiziert werden , da x Begriff
außerhalb dieser Datei definiert ist. Die Autokade ist also da. Wenn Sie einmal Motorkaden haben, können
wir sagen, ob dies
ausgelöst wird DigitalWrite LED und es ist niedrig. Schauen wir uns den Compiler an. Und Lester, ESPN. Das Camp. Sind wir dran? Noch einmal ist der serielle
Monitor bereits geöffnet. Sun jetzt
verbinden wir das Flushing. Mal sehen, was los ist. Die normalen Punkte
sollten wie zuvor funktionieren. Und wenn ich jetzt wechsle, tauche auf, drücke den Knopf. Und das ist die Autokade. Und Motorkade wird zu einem M.
Entlasten
ausgelöst . Ja. Nett. Und die Punkte werden wie zuvor
funktionieren. Also jetzt
haben wir in unserem Fall den Knopf gedrückt und
das habe ich auch nicht getan. Das erste Konzept, das
Modell wird verhungert sein. Modell, Modell, Modell bringt den Marmor nach
oben. Es gibt einen Sensor. Der Sensor wird ausgelöst,
damit der Motor davon absteigt. Nicht zu viel. Zu viele Murmeln kommen
auf einmal an die Spitze. Und dann
geht der Marmor Teil des
runter,
also haben wir uns abgeschaltet. Dann löst es einen
der Sensoren aus und dies gibt uns nun später
den Sensor, die Punkte, die geliefert
werden.
35. Auswertung der IR-Sensoren: In diesem Video
möchte ich jetzt Kalibrierungsmethode
implementieren und implementieren. Denn wenn Sie
an das gesamte Projekt denken, würde
ich gerne sehen, wie oft jeder Sensor ausgelöst wird
und welche Punkte sind. Ich komme zurück. Denn wie Sie hier sehen können, haben
wir hier und Rückgabewert, aber wir haben
es hier keine Rückgaben implementiert, und dies muss implementiert werden. Zunächst möchte ich also
prüfen, ob wir die Punkte
zugewiesen haben. Punkte werden zugewiesen. Und jetzt möchte ich zu diesem Zeitpunkt hier
anrufen. Wenn es sich jedoch um
eine Motorkade handelt oder nicht, die Kalibrierungsmethode, könnte
die
Kalibrierungsmethode sein Es ist
ein weites Gefühl, unsere
Doppelbindungs-Doppelpunkt-Kalibrierung. In dieser Funktion
möchte ich nur zurückkommen und
Texte, weil ich nur
an Pin-Punkten interessiert bin. Und wie oft benutze ich es? Und deshalb habe ich
und Membervariablen, privates Mitglied, das in Dauer
aufgerufen wird. Und das iterieren wir. Und jetzt sehe ich
seriellen Druck f. Und ich möchte
drei Variablen haben. Der erste könnte Sensor sein, und er wird Sensorstift genannt. Dann könnte ich auch einen
zweiten Wert hinzufügen. Und es sind die Punkte. Auch ein ganzzahliges Format. Und die Punkte sind die Punkte. Und als letztes können
wir hier auch die
Iterationen, Dauern hinzufügen. Und es ist auch eine ganze Zahl, und es heißt
Count-Iterationen. Wir kommen jedes Mal zurück
und der Sensor wird ausgelöst. Dieser Liniensensor-Pin
zeigt, Iteration. Sieht gut aus. Ein bisschen mehr. Klammern würden
in diesem Format sagen. Und das Ende
mache ich einmal Zeilenumbruch. Und das sieht bisher gut aus. Dann wählen wir das richtige Projekt aus und
laden das Ganze hoch. Und jetzt sollten wir
hier ein Feedback in
unserem Serummonitor erhalten , wenn der
Compiler keinen Fehler sieht. Aber ich denke, es
sieht bisher gut aus. Dann laden wir
die ganze Skizze hoch. Öffne den Zeremoniedamm. Und wie zuvor könnten wir
hier anfangen, den Motormotor, und wir sehen hier den
Motorsensorstift 0,30 Punkte, Iteration eins, Iteration 234
und die Diverger, die beginnen, haben
wir hier zehn Punkte. Wir haben hier Zweiter, 20 Punkte, 50 Punkte, 100 Punkte. Und die verschiedenen
Iterationen
würden iterieren. Sehr, sehr gut. Das ist was ich will. Und jetzt können Sie sich vorstellen, dass
Sie dies in
einem automatischen Prozess machen könnten. Es gibt. Marvelous geh hoch, geht runter. Es wird die
Punkte und die Iterationen sammeln. Und dann kann man hier
auch zusammenfassen,
Normalverteilung, wenn
alles gut gelaufen ist. Aber das ist nicht das, was ich im
produktiven Umfeld will. Dies dient nur zur Kalibrierung. Wir können das ausschalten. Und auch hier der zentrale Schmerz. Ich will nicht, ich
will nur die
Punkte zurückbekommen, die ich will. Und deshalb könnten wir beispielsweise
sagen, dass hier eine neue Variable definieren. Es heißt ganzzahlige Ausgabe. Und wir geben es
ganz am Ende zurück,
damit wir sicher sind, dass es etwas
gibt. Geh wieder her. Wir könnten sagen, dass die Ausgabe zum Beispiel
0 Punkte beträgt. Jetzt müssen Sie sich vorstellen, wenn Sie einige andere Logik haben, zum Beispiel können Sie einige Bonuspunkte,
einige Bonushebel usw.
hinzufügen .
Es ist immer eine gute
Idee, dies in
eine äußere Variable zu setzen und
gib nicht nur die Punkte ein. Dann gehen wir zurück
zum Haupt-CPP, denn hier geht der
Rückgabewert nirgendwohin. Deshalb würde ich hier auch
auf D2L innerhalb einer neuen Variablen
implementieren , es heißt „Get Points“. Und wir sehen hier gibt mir genau diese
Punkte in diesem Raum. Und wenn Galton
größer als 0 zeigt, weil 0 unser Motortor ist, dann zB Zentimeter die
Punkte über MQTT oder senden Sie sie
über serverseitige Ereignisse. Serverseitige Ereignisse
befassten sich auch in diesem Online-Kurs in Rockpaper-Scherenübungen. So könnten wir dort auch
über Websites im ESP dort anfangen , oder wir können
ihre Punkte bearbeiten und an unsere Website
zurücksenden. Aber hier könnten wir auch, ja, einen Druck
nur zum Debugzweck in Betracht ziehen. Punkte D. Und wir kommen wieder
hierher, Deck hat einige Punkte bekommen weil das kein guter
Ansatz ist, wenn wir
es hier im Main zu tun haben. Und wenn wir von unserer ganzen Klasse
zurückkommen, nur die Punkte und
die gesamte Logik werden
nur die Punkte und
die gesamte Logik
im Hauptteil implementiert. Also es ist noch einmal,
wir laden unsere Datei hoch. Und mal sehen, was
der Compiler sagt. Normalerweise verschütten Das ist
immer ein gutes Zeichen. Dann das
Ganze noch einmal hochladen und jetzt
sollte die Zeremonie
etwas klarer sein. Ich habe den Zeilenumbruch verpasst. Also 11010202050, Eins 100. Und die Motortore auch. Die Motorkade sollte sich
außerhalb der for-Schleife befinden, und dann ist es innerhalb der bisher verkauften
Waren, die wir jetzt auch auf die
Punkte und die Motorkade
implementiert haben .
36. Übersicht über das Bastelprojekt: Sehen wir uns also das
fertige Projekt an. Zuallererst wird der
Marmorlift von einem so
kleinen Motoneuron
angetrieben. Und der Motor ist
an der Unterseite befestigt. Wenn ich also
hier meinen Knopf drücke, ist er über
MQTT verbunden, Marmor Lift One. Und hier ist die Motorkade
, die den Motor ausgelöst hat. Also wird der
Motor wieder weiter gehen und
weitergehen, wird der
Motor wieder weiter gehen und
weitergehen bis die Motorkade ausgelöst
wird. Danach wird der
Marmor sinken. Und laut
dem Sensor , der ausgelöst wird
und
die Punkte auf
meinen Knoten zurückbekommen die Punkte auf wird, ist auch der rote Burma
MQTT-Broker verbunden. Jetzt, länger gelebt
und es ist fertig.
37. OOP IRSensors neu erstellen: Herzlichen Glückwunsch am
Ende dieses Videokapitels. Und ich hoffe, du hattest
genauso viel Spaß
, wie ich den Quellcode für
dieses Objekt orientiert machen musste . Also lasst uns nutzen, hier sind ein paar Sekunden, um
alle Erkenntnisse zu wiederholen , die
wir hier hatten. Zunächst haben wir
Ihre verschiedenen
Objekte erstellt, damit wir prüfen
können, ob einige der Infrarotsensoren ausgelöst
werden. Danach haben wir
ein Gebiet geschaffen, so dass es
unbequemer ist , die Jahreszählung und
auch
die objektorientierte
Art und Weise zu kontrollieren Jahreszählung und
auch
die objektorientierte
Art und , wie sie hierher kommt. Einmal zeigt uns die Vorteile, die wir geschaffen haben
und die Kalibrierungsfunktion. Und diese Kalibrierungsfunktion vermittelt uns das Gefühl von Pin, die Anzahl der Integrationen, Eingabe von Punkten und das
Nachdenken darüber. Wie konntest du
das mit einer Funktion leicht entwickeln? Es wird nicht so einfach sein
, weil du es hier brauchst. Verschiedene Arten von
Iterationen, Variablen und wie man die
verschiedenen Arten von Sensoren steuert. In gewisser Weise wird es nicht so einfach sein. Es wäre erreichbar, aber nicht so bequem wie
ein objektorientierter Weg. Wir machen eine Blaupause
für einen Fall. Und danach
kann jedes Objekt diesen Blueprint verwenden und denke ich, dass es so
wertvoll ist , wenn es um Quellcode
geht. Wann immer Sie verschiedene
Arten von Sensoren haben, viele davon, mehrere davon, verwenden
Sie Ihr Objekt,
schreiben Sie Ihre eigene Klasse. Es wird schneller und viel
flexibler sein, so sehr zur Zusammenfassung. Und jetzt gehen wir
zur nächsten Übung und
zum nächsten Video.
38. Verdrahtung: Dann ist Virion Teil dieses
Projekts sehr, sehr einfach. Also haben wir hier und USB 32. Wir haben zwei LEDs, zwei Widerstände und
einen Druckknopf. Der Druckknopf
wird vom
Boden bis
zum Druckknopf mit dem Brotbrett verbunden . Und auf der anderen Seite verbinden
wir hier den Druckknopf mit
dem GPIO2 und 13. In meinem Fall
verbinden wir auch Boden vom ESP, also T2 mit dem Breadboard. Das wird also das
gleiche Potenzial für LEDs haben. Und wie ich in der
ersten praktischen Übung erwähnt habe, hängt
es von der
Farbe der LED ab,
die widerstandsfähig gegen Einheit ist. Und es kommt auch darauf an, ob Sie einen Arduino oder ESP 32
verwenden. Der ESP 32 unterstützt hier 3,3 Volt und es gibt das Enol kann
fünf Wörter von GPIO liefern. Und in diesem Zusammenhang
müssen Sie den Widerstand berechnen. Werfen Sie einen genaueren
Blick auf eines der ersten Videos
der LED-Klasse. Es gibt. Ich habe es ein
bisschen ausführlicher erwähnt. Hier war mein Fall der ESP 32, ich benutze nur einen 100-Ohm-Widerstand für beide, weil es
nur zum Trainingszweck dient. Also habe ich den Boden
mit der Kathode der LED verbunden. Dies ist der winzige Stift und dann der Lavastin, den wir an ihren Widerstand
anschließen. Und vom Widerstand über
die GPIO-Nummer 25
bis zum roten. Grüner, der
hier mit einem blauen angezeigt wird. Ich habe mich damit verbunden,
genauso wie das rote. Verbinden Sie also das
Gelände mit der Kathode, dann der längere Stift, der durch den Widerstand
und vom Widerstand
an die GPIO-Nummer 12.
geht . Und das war's für dieses Beispiel, der Rest wird das Programm sein, das im Quellcode
codiert ist.
39. Die Kurskonzept hinzufügen: Fangen wir mit einem
neuen Projekt an. Ich fühle mich als Scheinwerfer eingeschlossen
und im Haupt-CPP bearbeite
ich es einfach hier
und Sarah beginne. Das ist alles, was ich bisher getan habe. Nun möchte ich das ganze
Klassenkonstrukt einrichten. Deshalb klicken wir mit der rechten Maustaste
auf die neue Quelldatei. Und wir sagen Hier, button dot h, und wir rufen neue Datei auf, Button Point CPP,
klicken Sie mit der rechten Maustaste auf Combatant, diese Kante teilt sich nach rechts. Dann sehen wir, dass der Entdecker verschwinden
sollte. Und jetzt haben wir hier
unsere Entwicklungs-IDE. Und ich möchte damit beginnen, den Knopfpunkt h zu
definieren ,
zuerst die Klasse,
sie heißt button. Geschweifte Klammern öffnen,
schließen, Semikolon. Dann besteht der nächste darin
, Wachen einzubeziehen. Wenn N def Button Edge, dann könnten wir sagen, definiere Taste H und das
Ende mit dem Hören. Und wenn ich einschließe, ist
Gott fertig. Was ist dann die
dritte, die Schlange? Es ist jedes Mal das Gleiche. Wir sollten
den Arduino-Head Up einbeziehen. So weiter. Die Header-Datei ist, also ist dieser Status beendet. Dann springen wir
zum Button Dot cpp, ich würde vorschlagen, dass
wir hier hinzufügen. Das erste ist ein
Knopf an dieser Kante. Und wir schließen
den Arduino ein. Bisher so gut. Und was wir auch
hier brauchen, wird da sein. Ich sehe richtig aus, Punkt h. also würden wir später
für die LEDs brauchen , damit
wir sie mit PBM,
ihrer Schriftart, füttern können, um
den Explorer zu besitzen, der
auf die Plattform in ihm klickt. Wir müssen hier die externe
Bibliothek hinzufügen und nach rechts schauen. Und ich würde auch
vorschlagen, dass wir hören den Monitorport von meinem
hinzufügen, in meinem Fall ist es
die dritte Spalte. Wir haben die Geschwindigkeit
auf 115200 oder in
einem Framework und der
ausdrucksstarken Plattform eingestellt und verwenden
entsprechend PIM
auch den Port einzurichten. Sparen Sie in der Nähe von Blut vor. Und wir haben hier alles
was wir für
den Button cpp brauchen. Dann würde ich auch vorschlagen, dass wir
in die Haupt-CPP springen und
die Referenz DOD Edge enthalten lassen die Referenz DOD Edge enthalten ,
damit wir hier
alle Dateien haben , auf die
in unseren drei Dateien verwiesen wird. Im nächsten Schritt definieren
Rekruten die
gesamte Header-Datei. Das heißt, wir könnten hier sagen, dass
es sich um eine gebrachte technische Schulden und als kurze Erinnerung und geschützte Handlungen hier im
Klassenknopfpunkt HHS, privat. Wenn wir später
die ganze Klasse erben, wird es als
öffentliches, öffentliches Mitglied sein. So geschütztes Verantwortliches,
Button, Pin ,
Ganzzahlen, Datumsangaben und ganzzahliges Ergebnis, das wir und ganzzahliges Ergebnis, das wir später
und in der Öffentlichkeit benötigen, haben
wir hier den Konstruktor
, der uns und Pin nimmt. Wir haben
Startfunktion und wir haben Jack Button mit
Return-Parameter da eine Ganzzahl mit der rechten Maustaste auf Dokument
formatieren klicken. Und wir haben auch
unseren Button Dot h. formatiert. Ich springe zum Button CPP. Und ich will, ich möchte dir den Konstruktor
implementieren. Deshalb sage ich button, das heißt die Klasse
dann Double Point,
Double Points, Button
im Drop-In, geschweifte Klammern offen, geschlossen und es ist Button Pin. Dies ist unser geschütztes Mitglied, ist der Pin, den wir
durch den Konstruktor führen. Dann gehen wir
zum Haupt-CPP. Und dann das Haupt-CPP, oder
wir machen hier ein Objekt. Wir initiieren einen
Objekt-Button, Button edit dort. Und in meinem Fall
wird die Schaltfläche in einem Gruppenrichtlinienobjekt platziert, in diesem Beispiel geben
wir den Wert nur an unsere Klasse weiter und
richten den PinMode nicht ein. Dies ist eine andere Art von Ansatz, den ich Ihnen zeigen
möchte. Natürlich könntest du auch den PinMode
machen. Aber bis jetzt so gut. Wir haben es noch eingerichtet, unsere Klasse, unser Hauptknopf, CPP
und das Haupt-CPP. Jetzt sind wir bereit, den Rest
zu zitieren.
40. Debounce mit Millisekunden: In diesem Video
wollen wir nun den
Button ausbalancieren und auch den Code so
vorbereiten, dass wir im nächsten
Schritt l verwenden können,
kann erkennen, wie lange
wir den Knopf gedrückt haben. Aber bevor wir das tun konnten, müssen
wir
hier unseren Button einrichten und deshalb CPP M drücken, wir deklarieren
eine andere Funktion. Es heißt Weiß, Button, Double Point, Double
Point, Start. Hier stellen
wir die Pin-Modi ein. Es ist der Button Pin. Und ich benutze hier
und Eingänge ziehen hoch, damit wir ein gutes Signal haben. Und ich denke, in der
Arduino-Umgebung muss
man auch Pull-Up eingeben. Und ansonsten benutzt man
nur den Wert der Eingabe. Und auch ich sitze hier bei
der Staatsvariablen hoch. Wir kommen später. Warum machen wir das. Wenn wir also
zurück zur Haupt-CPP-Datei wechseln, im Setup-Teil, sehen
wir
im Setup-Teil, dass wir
den Button nach oben verwenden.
Es gibt einen Button, den wir nicht initiiert
haben, aber das Objekt mit Taste, Button LED, das ist unser Objekt, das
wir jetzt initiiert haben. Und jetzt können wir
Button sagen, LED-Punktstart. Und jetzt haben wir
den PinMode bereit. Der nächste Schritt wird sein, dass wir hier den Check-Button machen. Und noch einmal
ändere ich das in Weiß, weil
wir danach die ganze Zahl,
den Rückgabeparameter, verwenden , aber
im ersten Schritt brauchen wir sie nicht. Also sagen wir welche Taste,
doppelte Bindung, doppelte
Bindung, Check Button. Und diese Schaltfläche „Prüfen“ wird in jeder Schleife
aufgerufen. Also sind wir zum
Haupt-CPP gewechselt und sagen Taste, LED und Check-Taste. Also würde ich vorschlagen , dass wir
jetzt nur ein paar Codezeilen schreiben. Und danach haben wir
auf den ESP hochgeladen und gehen noch
einmal
den gesamten Code durch. Zuallererst
definieren wir eine Variable. Die Variable wird ganzzahlig sein. frühere Staat ist Staat, und der Staat ist digital. Pin, Knopf, Pin, Knopf, Pin. Was Sie also hier machen, durchlaufen
wir
diese Funktion. Jede Schleife, der letzte Status von der Schaltfläche, ist Sicherheit
und der vorherige Status, und der tatsächliche Status
wird hier im Bundesstaat gespeichert. Warum machen wir das? Der Grund ist, dass wir jetzt
erkennen können , wann jemand den Knopf
gedrückt hat. Und das ist sehr einfach. Wir können sagen, wenn der vorherige
Zustand höher ist, ist der
Zustand niedrig, weil ich
hier das Eingabe-Pull-Up verwende und die
Taste mit dem Boden verbunden
bin. Mein Zustand niedrig bedeutet, wenn
ich den Knopf drücke, hoch, gebe
ich uns kein Signal? Das ist der Grund, warum ich dir bleib Design
gebe. Das bedeutet, dass
wir am ersten
Anfang nicht
den Knopf drücken und mit dem hohen Signal
initiiert werden . In diesem Pilz befinden sich
in diesem If-Zustand. Wir machen
hier immer wieder ein Remeshing. Deshalb brauche ich noch eine
oder zwei weitere Variablen. Also sehe ich hier einen
unsignierten langen Button, geklickt auf Millisekunden und unsignierte lange Button
nach unten Millisekunden. Was ist unsigned? Unsigned ist, wenn wir Variable
deklarieren, haben
wir minus part
und dann plus Teil. Jedes Ding hat
die gleiche Größe. Aber wenn wir unsigned sehen, wollen
wir nur die Plusseite und wir nehmen
alle Werte sind der gesamte Speicherplatz und
weisen ihn nur der Plusseite zu. Also haben wir
nur die Größe verdoppelt und die Plusseite, das bedeutet es
mit unsigned long. Weil wir die Millisekunden sind. aktuelle Lebensdauer konnte kein Minus-Teil
sein. Dies ist der Grund,
warum wir es benutzen. Mit dieser
ButtonClicked-Millisekunden können
wir jetzt eine Schaltfläche zuweisen. Klicken Sie auf. Millisekunden sind Millis
was du jetzt machst? Wenn jemand die Taste drückt, die Millisekunden,
werden hier
aktuelle Millisekunden dem ButtonClicked zugewiesen. Und warum machen wir das? Denn jetzt können wir
weitermachen und sagen können else-if, wenn der vorherige Staat ist
und ich denke du weißt was, Es kommt, niedriger,
Endzustand ist hoch. Dann haben wir den Knopf losgelassen. Denn wenn ich den
Knopf drücke, läuft
die Schleife. Also drücke ich die Taste
und die Taste, auf die
Millisekunden geklickt wird ihrer
aktuellen Lebensdauer
bis zu den Millisekunden
zugewiesen . Und danach, wenn
ich es loslasse, kann ich
jetzt etwas mit dem
anderen machen, war
der anderen machen, war Millis-Editor-Button auf Millisekunden
geklickt. Also, aber hier ist, hier kommt der Logik-Teil. Aber eine Sache ist, dass Ihnen eine Währung
fehlt weil wir nicht
bereits besprochen werden , was einen Button
debounciert? Das Auswuchten bedeutet, wenn
wir einen Knopf drücken, einige mechanische
Dinge los. Diese mechanische Funktion
ist nicht sehr genau, wenn es um Millisekunden geht, da die Taste
in einer Millisekunden als nah bezeichnet wird, die starke oder die
Stromschaltung. Und deshalb haben wir gemischte Signale
bekommen. Dieser Prozess benötigt also ein paar
Sekunden, ein paar Millisekunden, und die Arena kann
diese Millisekunden erkennen und gibt uns ein Signal ein, aus, ein und aus. Und das wird
auch in unserer Skizze geschehen. Das bedeutet, dass der Betrachter ein paar Signale mehr
erhält ,
als wir es gewohnt sind. Machen Sie Ihre praktische serielle Drucklinie für
Showcase. Und wir sehen hier
ButtonClicked Millisekunden. Normalerweise sollten wir also den Knopf
drücken, bei der 0 Taste sollte
nichts
ausgedruckt werden. Und wenn ich es veröffentliche, dann bekommen wir, ich denke, mehr als ein Ergebnis. Und das ist der Grund für das
Springen von der Schaltfläche. Laden wir die
Skizze also auf unseren ESP hoch. Dann schalte die Kamera aus. Und Sie können hier
die 0 Monitore sehen, einfach die alten löschen. Und jetzt halte ich den
Knopf gedrückt und lasse ihn los. Und Sie können sehen, dass Sie
hier ein paar Codezeilen bekommen, und
dies springt von der Schaltfläche ab. Bedeutet, dass es nicht
schnell genug schließen kann, um
ein wirklich klares Signal zu erhalten. Was wir jetzt tun können, haben
wir gemessen, als
wir auf den Button geklickt haben. Und das könnte für
uns nützlich sein , denn jetzt können wir
weitermachen und sagen können, wenn wir zum Beispiel den aktuellen I'm
Lifecycle minus
buttonClicked Millisekunden
auflisten . Dies ist der Zeitpunkt, an dem wir den Knopf unter
50 Millisekunden
gedrückt haben, weil wir das nicht interessant sind. Hier ist der Bounds-Bereich, nichts nur
für Trainingszwecke zu tun. Dann sagen wir sonst. Wenn das Signal mehr als
50 Millisekunden beträgt, sollten wir hier nur noch einmal
eine gerade Linie
hochladen lassen . Und dann besprechen wir
den ganzen Code. Wieder einmal wird Code hochgeladen. Dann werde ich neu gestartet. Klicken Sie auf den Button
und lassen Sie ihn los. So wird der lange Klick immer die
meiste Zeit funktionieren. Aber wenn ich auf
kurzen, kurzen Clip klicke, dann kannst du auch hier sehen,
dass er D ausgeglichen ist, weil ich nur eine gerade Linie
davon bekomme und das ist es, was wir wollen. Nein, kein Aufprallen der
Schaltfläche, klicken Sie einfach. Und jetzt haben wir wirklich präzises Signal und wir erzielen ein gutes
Ergebnis daraus. Also noch einmal, was
haben wir bis
hier mit Meteor- und
früheren Staaten gemacht ? Und dann geben Sie an, der
Staat gibt uns ein Signal von der Schaltfläche, und der vorherige Status wird den Status von vorher
speichern. Dann sitzen wir hier
mit dem ersten wenn,
wenn der vorherige Zustand
hoch ist und das bedeutet, dass
nichts gedrängt wird, und jetzt wird es gedrängt. Bitte speichern Sie mich in
den Millisekunden in den variablen
ButtonClicked Millisekunden. Und ich halte den Knopf gedrückt und die Schleife geht weiter und
geht weiter und geht weiter. Jetzt lasse ich den Knopf los. Jetzt in der nächsten Schleife sind wir hier , weil der vorherige
Status jetzt niedrig ist. Und der Staat ist hoch. Hoch bedeutet, dass ich den Knopf
losgelassen habe. Der Unterschied zwischen den Millis endet, der ButtonClicked. Wenn es kurz oder weniger
als 50 Millisekunden ist, dann tu nichts anderes. Bitte gib mir hier in diesem Teil etwas
Logik. In den nächsten Videos können
wir
hier definieren, ob es größer als 5200 ist. Dies ist also der Bereich, in dem wir die verschiedenen
Arten von Klickdrücken
definieren können . Und so haben wir zwei Dinge. In einer Logik sind wir
tief auf den Knopf geprallt und können auch identifizieren, wie
lange jemand gedrückt hat.
41. Dauer von Klicks erkennen: Und jetzt wollen wir
zwei verschiedene Arten
erkennen wie lange wir den Knopf drücken. Und das wird jetzt sehr, sehr einfach für uns sein, denn jetzt wir nur noch ein anderes wenn hinzu. Und wir sehen hier, Milli ist minus buttonClicked. Das Ganze ist also größer als 50 und ich brauche ein
bisschen mehr Platz. Alle Dinge hier oben
sollten weniger als 200 Millisekunden betragen. Das heißt, wenn es
größer oder weniger als ist, passiert etwas. Es ist also nicht versichert. Klicke dann auf das ganze Ding. Kopiere es erneut. Else-if-Schaltfläche größer als 200 und weniger
als 900 Millisekunden ist
beispielsweise ein OnClick. Also hier ist der
Debouncing-Bereich. Es wird nichts passieren. Und nach den Millisekunden von 50 bis 200 oder kurzer
Clip sollte
identifiziert werden und danach
und lange klicken. Laden Sie also das
Ganze noch einmal hoch und schauen wir uns das genauer an. Wenn Sie jetzt die
verschiedenen Arten von Klicks identifizieren können. Skizziert nach oben. Dann klicke ich auf
kurz, kurz, kurz, kurz, lang, lang, lang, kurz. Und wie Sie sehen können, ein
normales No Bouncing. Alles sind tiefe
Anleihen in Bezug auf
klare, klare Klicks, nur
eine Zeile auf einen Klick, und das wollen wir. Nett. Wie Sie sehen können, haben wir einfacher mit
einer Logik und einem D-Pfund. Und wir könnten hier
verschiedene Arten erkennen wie lange wir den Knopf drücken. Es liegt also an deiner Kreativität wenn du
mehr Funktionen hinzufügen willst, aber ich denke, zwei oder
drei sollten ausreichen. Denn sonst wird
es schwierig sein zu erkennen, wie lange unsere
drei Sekunden es sind, aber es hängt von Ihrem Projekt ab und jetzt kann sich
Ihr Bereich
fühlen, können
Sie Ihre eigenen Patentlängen vornehmen Sie Ihre eigenen Patentlängen und identifizieren Sie die verschiedenen
Arten von Messungen.
42. Saubere Benutzeroberfläche: Dieses Video wollen wir jetzt
die Klasse ein
bisschen allgemeiner halten und Chiller bedeutet, dass wir
einige bestimmte Dinge
loswerden , weil wir
später
in einem anderen Projekt werden, zum Beispiel, wenn wir möchte das Patent CPP und button dot h, unsere Klasse, auch im Projekt verwenden. Und es besteht keine Notwendigkeit für
bestimmte Implementierungen, daher brauchen wir den ganzen Raum. Der gesamte logische
Teil sollte
im Haupt-CPP und nicht
im Muster CPP sein. Also zeig ich dir was ich meine. Wir wechseln zur Checkout-Schaltfläche und
geben
den Wert in eine ganze Zahl zurück. Auch in den Schaltflächen, dem BPM
ändern wir hier unter Rückgabewert in eine Ganzzahl. Und was wir jetzt tun, ist, dass wir hier drei Staaten
definieren. So zum Beispiel der Satz des
Rückgabewerts. Es gibt nichts zu tun. Es gibt nichts zu tun. Wenn wir eine Rückgabe erhalten, ist
es in einem kurzen Klick und
ansonsten ist es ein langer Klick. Deshalb haben wir
bereits eine Variable, die als Ergebnis bezeichnet wird. Und ich würde vorschlagen
, dass wir hier
Ergebnis von 0 machen , bedeutet, dass wir nichts zu tun
haben. Während er das Ergebnis 0 konnte. Sagt, fügt das Erste ein
, weil ich auch nichts zu tun habe. Und auch im
Debouncing-Fehler gibt es nichts zu tun. Ganz am Ende geben wir das Ergebnis und den kurzen Klick zurück. Wir heben den Seriendruck aus. Wir sagen nur, dass Ergebnis eins ist. Und in der Else-ob
ist Ergebnis zwei. Das ist mein Flex
und ich bin zu
Flex zurückgekehrt und ich habe jeden Fall hier. Es ist kein Ergebnis zugewiesen, daher sollte es in jeder Schleife
zurückgegeben werden. Und 0 oder ein oder zwei. Das ist es, was ich meine, wurde im nächsten Projekt
generiert. Sie könnten es verwenden und können
auch
die verschiedenen Arten
von Zuständen nach
Ergebnissen identifizieren die verschiedenen Arten
von Zuständen nach und
im Hauptteil etwas tun. Und das machen wir jetzt wechseln zum Hauptteil. Und jetzt wird uns diese Funktion
liefern und Wert zurückgeben. Und dieser zurückgegebene
Wert wird
beispielsweise in und Switch-Fall abgefangen . Also sagen wir Switch und
wir sagen Fall eins, Bremsgehäuse zu
Blasenpunktbruch. Dies sind also die wichtigsten
Strukturfonds, in welchem Fall? rechten Maustaste auf Dokument formatieren
und fügt den Fall ein, wir könnten sagen, seriell, Druck, Zeile, Betrugsklick aus Haupt-CPP. Und im Fall zwei sollten
wir
hier einen langen Klick haben. Lädt dann
noch einmal auf unseren USBE 32 hoch. Das meine ich damit, es allgemein
zu halten, denn jetzt gibt uns
das ganze Muster CPP einen Rückgabewert. Und dennoch, was
wir jetzt tun, fangen
wir hier die
Rückgabewerte in etwas und dies ist ein guter Weg, wie wir sie sauber
halten Schnittstelle. Schalten Sie dann die Kamera ein und
öffnen Sie die Zeremoniezeit. Und jetzt sollten wir das gleiche Ergebnis
sehen. Kurzer Clip, kurzer Klick,
onclick, onclick wahrscheinlich. Das gleiche Ergebnis. Sauberere Schnittstelle. Und jetzt können wir
unsere eigene Bibliothek auch in
anderen Projekten verwenden .
43. LEDs steuern: Jetzt ist es an der Zeit, dass wir unsere LEDs auch
mit der Taste
steuern können . Und deshalb
definieren wir zwei Variablen. Wir können sagen, es ist LED gelesen. Ich habe das GPO 25 und LED grün ist auf
GPO 12. In meinem Fall. Im Setup
müssen wir einen PinMode erstellen. Pinmode LED rot ist Ausgänge. Kopieren Sie Einfügen. Led grün ist auch ein Ausgang. Also haben wir uns schon vorbereitet und
jetzt können wir unsere LEDs steuern. Das ist auch einfach. Man könnte hier sagen, und
digitale Rechte LED. Aber ein kurzer Clip, den ich benutzt habe, ist ein
grauer Clip hoch. Und wir könnten jetzt sagen, dass wir
zum Beispiel mit Flaggen
arbeiten , wenn es aktiviert ist,
dann setzen wir es auf niedrig. Werden wir oft höher gesetzt? Aber ich bin mir sicher, dass Sie den LED-Kurs bereits
gesehen haben und auch auf vorheriges Beispiel und Übung in
diesem Online-Kurs. Und da haben wir eine LED umgeschaltet. So könnten
wir zum Beispiel digitale Rechte hier verwenden, LET green, und hier im
hohen oder niedrigen Teil sagen
wir, dass digital LED grün
liest. Und was ich jetzt mache,
ist, dass ich mich hier setze. Wenn der Pin ist, ist die LED eingeschaltet, dann komme ich
zurück und hoch, aber ich will kein High weil ich es dann umschalten
möchte. Und deshalb
invertiere ich das Signal. Und ich sehe, wenn ich höher
komme, ist
es zu niedrig invertiert. Wenn die LED ausgeschaltet ist, komme
ich hier rein und niedrig und Fragezeichen, Ausrufezeichen. Wir setzen das Tief auf hoch. Das ist also alles
, was wir hier brauchen. Mit Toggle die LED, den 0 Druck, behalte ich es, behalte es, denn dann kann ich sehen, was wir in der Schleife bekommen. Und wenn du liest, sollte
das in Ordnung sein.
Stimmt's? Projekt. Lädt dann das Ganze hoch. Und jetzt sollten
wir mit einem kurzen Klick sehen oder einschalten. Die grüne LED ist bei langem Klick, die rote LED sollte eingeschaltet sein. Schalten Sie also die Serie ein, überwachen Sie sie und
klicken Sie auf den Schuss. Klicken Sie lang. Und was
wir jetzt tun können, sind Verknüpfungen zu fehlen und
kurz und lang zu klicken. Und wie Sie sehen können, funktionieren
beide gleichzeitig,
weil wir
die GPIOs nur mit der Pin-Taste
steuern. Und das ist es, was ich
denke, dass es so mächtig ist, denn
jetzt haben
wir, wie Sie sehen können , nur mehrere
Codezeilen. Die ganze allgemeine Logik
befindet sich im Button. Und jetzt haben wir hier ein gutes Beispiel, was wir mit einem Knopf
und mehreren Staaten
machen können .
44. ButtonHeadlamp vererbt von Button: In dieser Phase eines Projekts haben
wir jetzt, ich würde
sagen, dass wir unsere
allgemeine Musterklasse abgeschlossen haben. Natürlich können Sie noch
ein paar Punkte hinzufügen. Was Sie
regelmäßig verwenden, damit Sie
diese Klasse nutzen können und Sie immer wieder
individuell projizieren. Deshalb machen wir diesen
objektorientierten Weg. Aber es könnte auch
jetzt vorkommen, da wir jetzt und Umstände und Anforderungen
haben, die wir unsere Klasse versiert haben.
Diese Annahme ist nicht
nützlich, wenn wir in der
allgemeinen Basisklasse
implementiert werden , in unserem Fall die Button-Klasse. Deshalb
erstellen wir eine neue Klasse. Was wir jetzt tun werden, heißt das
Knopfscheinwerfergewehr. Das bedeutet, dass die Basis die Basisklasse ist
unser Button Dot h. Wir haben geerbt und dann können wir einige Code-Snippets
anpassen. Und das ist nützlicher, auf sauberere Weise, da die einzelnen Teile
in einer separaten Klasse befinden. Die Basisklasse ist allgemein oder wir haben
sie auf sanfte Weise beibehalten. Das machen wir jetzt also. Wir schaffen eine neue Klasse. Klicken Sie mit der rechten Maustaste auf Quelle,
Wir klicken auf Neue Datei und wir können sagen, dass die
Schaltfläche einen Lampenpunkt CPP hatte. Und klicken Sie auch mit der rechten Maustaste auf New File, button, lamp dot h. Und wir beginnen
mit dem Standard io.h mit der Header-Datei. Und jetzt denke ich, dass
das nichts Neues für dich ist. Wir könnten sagen,
Klassen-Knopf-Scheinwerfer. Und jetzt wollen wir es
von der anderen Basisklasse ableiten. Ein doppelblinder öffentlicher Knopf, geschweifte Klammern öffnen,
schließen, Semikolon. Dass dies richtig funktionieren
wird. Wir müssen jetzt
diesen Musterpunkt h einbeziehen. Und wie Sie sehen können,
das dritte Mal, dass wir die
Header-Datei aus der Schaltfläche
einschließen. Und deshalb brauchen wir auch einige
Include-Wachen. Aber bevor sie Wachen
einschließen, sind wir hier und schreiben, dass H.
Und jetzt der
Include Guard F und der Gehörlose Knopf zugrunde liegende Lamm
hatten. Und dann haben wir
das Jahresende, wenn es gut ist. Und ganz am Ende sehen
wir uns hier. Und wenn das
so aussieht, wie ich sagen würde, ist
das bisher gut. Teilt sich nach rechts. Schließ das hier. Jetzt springen wir in
den Headland Dot cpp. Deshalb müssen wir
die Stirnlampe dot h einbeziehen die Stirnlampe dot h und wir müssen
den Arduino Dot h einbeziehen. Ich würde vorschlagen, dass
wir auch hier sind, damit wir unsere
Umgebung auch in der Klasse haben. Und jetzt könnten wir
hier das Erste definieren. Zum Beispiel könnten wir in der Header-Datei „
Public Double Point“ als nächstes
sagen , indem ein
Knopf-Doppelbindung, doppeltes Bondmuster verwendet wird. Also was ist das? Wir verwenden den Konstruktor von der
Schaltfläche „Basisklasse“. Lasst es uns noch einmal öffnen. Und wie Sie sehen können,
ist dies unser Hauptkonstruktor
, den wir
in der Hauptdatei hier aufgerufen werden. Und dies wird jetzt
auch in unserer entwicklungsbezogenen
Klassenscheinwerfer verwendet. Und wir machen hier
und zweite Funktion, es heißt White Check Schicksal. Dies könnten wir auch
hier in unserem Button
in unserer CPP-Datei erstellen . Und ich glaube, das kennst du
auch. Knopf, Stirnlampe,
Doppelpunkt, Doppelpunkt, Check Schicksal kommt
von meinen ausgefallenen Codes. Bisher so gut. Eine winzige Anpassung
, die wir in unserer Hauptdatei vornehmen müssen. Denn jetzt
wollen wir die Button-Klasse nicht mehr verwenden, weil
sie in
unserer Tastenscheinwerfer verwandt sind. Deshalb ändern wir uns hier. Button hatte Scheinwerfer. Wir können den Namen als denselben verwenden. Und wir können
hier auch den Konstruktor sehen, aber warum bekommen wir einen Fehler? Wir müssen
die Header-Datei ändern. Und das ist Scheinwerfer. Und jetzt
sollte alles wie zuvor funktionieren. Gib es einfach einen Scheck. Und ich denke, dann sind
wir bereit zu gehen. Als Nächstes. Schauen wir uns ja
im nächsten Video an. Jetzt werden wir
die Funktion für sie implementieren. Check fade, und auch ich bin ein bisschen
mehr pleite mit der Klasse.
45. Die Schaltfläche Keep gedrückt halten: Jetzt möchten wir
hier eine Funktion in unserer datenbezogenen Klasse hinzufügen . Und wir möchten sehen, ob der Knopf beispielsweise länger
als x Sekunden gedrückt wird. Das Gute ist jetzt
, dass wir über
alle Dinge in unserer
Basisklasse hinaus haben , wie zum Beispiel
die Variablen und auch
all die Dinge, die in unserem
Haupt-CPP in der Schleife aufgerufen
werden, überprüfen
wir hier, -Knopf leuchtet, Taste prüfen. Das bedeutet, dass hier
im Check-Button steht. Ich bin hier und ein
Check-Button Ich überprüfe das Jahr das digitale Lesen bereits und es wird nicht im Zustand gespeichert
. Und ich habe x ist auch in der
Milchklasse des Staates. Deshalb kann ich
hier überprüfen, ob der Zustand niedrig ist, das heißt der ButtonPressed und
auch Millis Minus Button. Millisekunden. Mehr als 2000er Jahre. Ich meine, zwei Sekunden,
zweitausend Millisekunden. Dann möchte
ich auf einer
seriellen Druckzeile ausdrucken , die
länger als zwei Sekunden gedrückt wird, und ich werde vererbt. Also lasst uns sehen. Das
sieht bisher gut aus. Und wir müssen den Check Glaube
auch in unsere Haupt-CPP
umsetzen. Haupt-CPP, oder es ist schon da. Also bedeutet es Button, das ist das Objekt Dot Jag Schicksal. Und jetzt wird die Funktion in jeder Schleife
aufgerufen, wir erhalten die notwendigen
Zustände und auch die Schaltfläche, die von der
Basisklasse
geklickt wird, die wir
hier bekommen , weil die
ButtonClicked Millisekunden. Und auch hier
sehen wir, dass hier die
Variablen zugewiesen werden und wir verwenden sie in unserer
Milchklasse, um zu überprüfen ob der Knopf
länger als zwei Sekunden gedrückt wird. Deshalb laden wir
jetzt
die Skizze hoch, um zu sehen, ob wir die alten Funktionen
haben, den kurzen und den langen Klick. Und jetzt mit zusätzlichem in unserer spezifischen Klasse
, wo wir
hier sehr detailliert
im Musterscheinwerfer programmieren . Also Kimara, die Zeremonie ist fertig. Und nicht kurz klicken Sie auf
Launch, klicken Sie auf. Halten Sie die Taste
nach zwei Sekunden gedrückt. Hier siehst du, dass ich
länger als zwei Sekunden gedrückt werde, 12. Los geht's. Noch einmal, dass wir das auch sehen
können. Und ich bin
Brustklumpen in Sekunden. Ja. Da machen wir weiter. Und im nächsten Video implementieren
wir
die Fading-Komponente.
46. Funktion hinzufügen: Jetzt wollen wir die Logik
umsetzen. Dann drücken
und halten wir die Taste gedrückt, die LED sollte erhöht werden. Und normalerweise machen wir
das mit einer for-Schleife, dem Rückgang der
Inkrementierung und Variable, und wir übergeben
die Stufe der Inkremente zum Beispiel an ein analoges Schreiben. Und so sollte es automatisch jede Schleife
vergrößert werden. Aber so
soll es nicht sein, weil wir wollen, nicht automatisch. Wir wollen den Schlüssel gedrückt halten. Und wenn wir
es loslassen, sollte die zunehmende Helligkeit gestoppt werden. Und deshalb müssen wir hier
einen etwas anderen
Ansatz verfolgen. Also haben wir hier auch einige Anforderungen und Herausforderungen
, die wir meistern sollten. Also würde
ich beim allerersten Analog sagen, oder? Led grün. Und wir könnten zum
Beispiel sagen, dass wir es einschalten sollen. Dies ist ein Schritt, den
wir umsetzen möchten. Wir möchten
es von 0 auf 255 erhöhen, zum Beispiel ist dies die
maximale Helligkeitsstufe. Die erste Herausforderung wird sein, dass
wir nicht die
richtige LED oder unsere Variable bekommen. Natürlich könnten wir nur einen PIN-Wert
sagen. Aber das Gruppenrichtlinienobjekt ist,
es könnte getan werden. Aber was ich
Ihnen zeigen möchte, ist, dass wir auch
außerhalb dieser Datei auf
Ihre Variablen zugreifen können , die ich zurück zum
Haupt-CPP gehe und hier
unsere zwei Variablen sehen kann . Und was wäre, wenn wir sie
über die Include-Erklärung stellen ? Denn hier ist es Include. Der Compiler geht von
oben nach unten und vielleicht kann er
darauf zugreifen. Es ist da. Led grün springt zurück zur Musterscheinwerfer, nur um die Firma schreiben zu
sehen. Stimmt das? Geschrieben, ja, aber ich kann sehen, dass es nicht definiert ist. Als nächstes könnten wir
die LED-Anweisungen
in den Scheinwerfer kopieren , aber dann haben wir eine
doppelte Deklaration. Das ist auch nicht das, was wir wollen. Aber wir könnten hier sagen, externe Kompilierung weiß
jetzt, okay, irgendwo außerhalb dieser Datei sollte
die in LED grün gelesene
LED
definiert werden und ich greife darauf zu. Und wie Sie
jetzt sehen können, wird das funktionieren. nächste Schritt ist, wie könnten wir den Pegel
des Analogs
erhöhen, die Helligkeitsstufe
schreiben. Und deshalb
möchte ich hier und statische Ganzzahl verwenden, zum Beispiel count genannt wird. Und wir erhöhen es in jeder Schleife, den Wert der Variablen, damit wir die
Count-Variable hinzufügen können. Und soweit wir auf dem
Laufenden sind, brechen Sie die Domäne sanft ab. Sie können also sehen, dass wir hier sind. Die Funktion wird
in die Hauptschleife aufgerufen. Und dies wird
unser Level in jeder Schleife erhöhen. Aber was wäre, wenn wir
zu zweihundertfünfzig,
zweihundertfünfundfünfzig bis 70 Jahren kommen , dies kein guter Weg ist, denn
dann haben wir einen Überlauf. Daher werden wir
unsere Zählvariable zurückgesetzt , wenn sie
größer als 255 erreicht. Und dann können wir sagen, dass Count 0 ist, also setzen wir
das Ganze zurück. Und wir können auch AnalogWrite
Serum sagen, also schalten wir es aus. Und für eine ordnungsgemäße Visualisierung setzen
wir auf die Verzögerung der Betten. Aber dann das nur zu
Trainingszwecken und auch das können
wir hier und mehr sehen. Der Effekt, den ich auch in kurzer Verzögerung von
20 Millisekunden implementieren möchte in kurzer Verzögerung von
20 Millisekunden implementieren , damit er
nicht nur die 255 trifft, etwas langsamer
bis zu unserem gewünschten Wert geht. Okay, bisher so gut. Was brauchen wir sonst noch? Ich glaube, das ist alles. Statisch, okay? Statisch bedeutet, dass es im ersten Mal
gesetzt wird, wenn wir es aufrufen, es wird das erste Mal hier definiert. Dann hat es jetzt den Wert eins mit dem Wert
einer Next-Schleife. Dies wird nicht
mehr aufgerufen, da es nur zum ersten Mal die
Standardzeile aufruft. Jetzt
hat dieses Konto den Wert 1234. Dies ist eine sehr bequeme
Möglichkeit, mit nur
innerhalb dieses Bereichs von
der weißen Taste, dem
Headland Check Schicksal zu arbeiten innerhalb dieses Bereichs von . Und wir müssen nicht auf globale
Weise statische Int-Anzahl
deklarieren. Mal sehen, ob wir Fehler und Fleisch
kompilieren. Unser ESP. Sieht gut aus, aber
wir spülen es nicht aus. Weil wir noch
eine serielle Druckzeile hinzufügen möchten. Und ich möchte eine Zählvariable
posten, damit wir sehen, was hier vor sich geht. Und für das Lesegeschenk,
im Gegenteil, mehr Platz
hier, klicken Sie mit der rechten Maustaste auf Dokument
formatieren. Bisher so gut. Springen Sie jetzt zur
Hauptdatei zurück, weil wir auch
etwas
anpassen müssen , weil wir
hier
mit digitalen Rechten arbeiten. Aber das Fading
wird mit
AnalogWrite und Mixing,
analog und digital, implementiert , oder? Es ist nie eine gute Idee. Daher würde ich vorschlagen, dass
wir auch
eine Funktion angepasst haben, damit wir auch verblassen, aber auch wieder auf „Ausschalten“ und
auf die grüne LED klicken können. Deshalb müssen
wir auch
auf wenig Funktion
mit und Flag implementieren . Also in der Hauptdatei
setzen wir hier in dem Fall man LED grün schreibt,
ist zum Beispiel Sarah. Und wir wollen
es mit 255 einschalten. Und wir könnten hier sagen, wir brauchen N statisch polar. Ist es an oder ist es ausgeschaltet? Und wenn eins, dann könnten wir sagen, wir schalten es aus. Und wir sagen, es läuft. Diese LED leuchtet an, wenn sie wieder ausgeschaltet
ist. Also ist LED eingeschaltet
für die nächste falsch. Sonst. Wenn es falsch ist, schalten wir es
einfach ein, da es 255 ist. Und es stimmt. Und ich möchte auch
diesen seriellen Druck haben , mit dem Sie
sehen können, was wir hier machen. Kurzer Clip aus Haupt-CPP,
klicken Sie mit der rechten Maustaste auf Dokument formatieren Wieder einmal, was
wir hier machen, sind
wir Angst und statischer Pool. Es ist, der allererste
Anfang wird als
falsch definiert , wenn der Klick kommt. Denn dies ist unsere
Check Button-Funktion , die auch eine liefert. Wenn wir hier reinkommen, einer zurück, Der erste Schritt
ist, dass wir ihn eingeschaltet haben. Led ist wahr. Mit einem nächsten Klick, LED. Led on ist wahr. Dann schalten wir es aus
und so weiter und so weiter. Und das ist eine bequeme
Art, wie wir mit Flex arbeiten. Also
überprüfen wir es noch einmal und dann können
wir unsere Datei hochladen. Hier haben wir unsere Hauptakte. Klicken Sie darauf, es ist versichert, klicken Sie mit einem kurzen Klick. Wenn ich es dann
auch ein wenig halten kann und länger
als zwei Sekunden
anklicke, wird das Verblassen erhöht. Ich klicke auf die Schulter, klicke und klicke noch einmal. Und ich kann sehen, dass
es eine doppelte Nachricht , weil ich zweimal
implementiert habe. Dies ist der Grund,
warum es sich verdoppelt hat. Aber jetzt, wenn
ich wieder verblasse, sollte
es von 141 gestartet werden zwei Sekunden
gedrückt halten. Und wie Sie sehen können, wird
es jetzt bis 141 fortlaufend sein, ich klicke noch einmal. Es ist auf voller Helligkeit. Wieder einmal ist es aus. Klicken Sie unter zwei Sekunden. Dieser ist dran. Kurz, eins, kurz. Dann behalten wir die Brüste so
, dass wir einmal Platz
bis 2552 Sekunden Verzögerung gefahren sind, und es ist weg und es ist weg. Sehr gut. Das ist es, was wir bisher wollen. Das bedeutet, dass unsere volle Funktion einwandfrei ein- und
ausgeschaltet ist . Und im nächsten Video habe ich ein paar zusätzliche
Aufgaben für dich.
47. Zusätzlicher Kurs für die task: Jetzt habe ich eine besondere
Aufgabe für dich. Wir möchten die LED-Klasse
implementieren
, in der wir auch in
diesem Online-Kurs erstellt und in dieses Projekt
umgesetzt wurden. Und es wäre schön, wenn wir zum Beispiel mit dem kurzen Klick die
Pulsfunktion einrichten. Ein Klick posiert also an und
ein weiterer Klick pulsiert ab. Und mit dem langen Klick möchte
ich die rote LED
einschalten. Und nach zum Beispiel fünf Sekunden sollte die
LED ausgehen. Dies könnte zum Beispiel für ein
Garagentor ein guter
Fall sein. Wenn wir es also öffnen wollen, wird
das Schild oder die LED flecken. Das heißt also Vorsicht. Da öffnet sich die Tür
und wenn wir gehen, klicken
wir noch einmal auf
die Tür und das Licht geht aus oder
wird nach sechs Sekunden
ausgeschaltet. Dies könnte also
mit der LED-Klasse geschehen, aber wir müssen hier
die Haupt-CPP-Datei anpassen ,
dies wird die Aufgabe sein. Es gibt viele verschiedene Arten von Ansätzen und Lösungen. Im nächsten Video können
wir zusammenfassen, wie Sie vorgehen und
wie ich es implementiert habe.
48. Mögliche Lösung: Beginnen wir also mit
der Implementierung oder einer möglichen Lösung,
indem wir die beiden LEDs
zu unserem Workspace hinzufügen. Ziehen Sie die
Klassendateien einfach per Drag & Drop von der LED, die in
den vorherigen Klassen erstellt wurden. Und einer der ersten
Schritte war, es ist Punkt h. und dann könnten wir im nächsten
Schritt sagen, dass wir das Objekt
implementieren oder
initiieren sollen . Geben wir das also in
Großbuchstaben ein. Lasst das lesen. Sie können sehen, dass es hier einen
Unterschied gibt mit 25 und wir haben LED grün mit 12. also auch zu
Visualisierungszwecken sehen, Sie können also auch zu
Visualisierungszwecken sehen, dass wir die Variablen
hier behalten, da die Variablen
mit der Fading-Funktion verwendet werden. Und diese Funktion ist zu
kurz und mit dem langen Klick verwenden
wir das Objekt. So können wir Objekte
und die Variablen oder die GPIO-Pins gleichzeitig verwenden. Aber natürlich würden
Sie in der
Warenarchitektur nur
eine Art von Ansatz verwenden. Aber ich möchte Ihnen zeigen , dass beide möglich sind. Also gehen wir ein bisschen
zu unserer Hauptdatei, dem Datei-Explorer, schließen
wir und los geht's. In der Hauptdatei können
wir jetzt Adepten hören,
diese, weil
wir diese Funktion hier hinzufügen
wollen . Wir wollen die Funktion des
schlechten Zustands implementieren. Und Sie werden machen und denken Sie daran, wir können LED grüne
Punkte sagen, Kreuzzug. Und wir brauchen und Zeit, zum Beispiel 20 Millisekunden. Diese Funktion
sollte jedoch in jeder Schleife aufgerufen werden. Und hier prüfen wir nur,
ob der Knopf gedrückt wird, damit das nicht funktioniert. Deshalb müssen wir
mit einigen Flaggen arbeiten, damit wir
auch auf Funktionen außerhalb
dieser Schalterkonstruktion zugreifen können . Und deshalb möchte ich, wie
ich es zuvor getan habe, diesen verwenden. Wie gesagt, ist die statische
Ganzzahlzahl 0. Was mache ich mit ihnen? Wenn Count Modulo zwei zum Beispiel
Sarah ist, würde
ich sagen, fahren Sie fort mit false. Und weiter ist noch
nicht definiert. Also gehe ich ein bisschen hoch
und sage, dass Pulsieren weiter falsch ist. Der allererste Anfang habe ich es auf „false“ gesetzt. Dann werde ich ein bisschen dunkel. Sonst, zum Beispiel,
setzt es an, ist wahr. Und wir könnten auch hier sagen, sagen wir wahr und LED, grüner Punkt ausschalten. Und das
stimmt natürlich, weil wir Analog Aus- und Einschalten
für den Fading-Effekt
beim Erlös
verwendet haben Analog Aus- und Einschalten
für den Fading-Effekt
beim Erlös
verwendet . Das ist der Grund, warum die
Reduzierung hier wahr wird, aber ich vermisse gemischte Zerreißen. Dies sollte wahr sein und
das sollte falsch sein. Was habe ich hier implementiert? Diese Variable wird
in der allerersten Schleife zugewiesen. Dann teilt Modeller immer auf, gibt uns den Rest
von der Division. So geteilt durch zwei hat sich keine Ruhe. Und das stimmt, also wird es weitergehen. Dann eins geteilt durch zwei. Es gibt jetzt einige
Register, null, was die Division ist, und
springt daher zum Anderen. Jedes Mal, wenn ich
hier drücke, sind sie Button. Ich muss auch
den Wert der Variablen erhöhen. Dies ist nur eine gesicherte
Funktion, bei der wir umschalten können. Und ich würde es in Fleck sagen. Wenn Sie also einmal klicken, um zu markieren, wird
es als wahr. Zum zweiten Mal
wird es auf „false“ umgewandelt. Und jetzt außerhalb der
Host-Switch-Struktur könnte
ich sagen, wenn fortfährt, wenn das Flag es auf seinen True setzt, dann würde ich es gerne sagen, weil der Vorgang dann in jedem
ist, in jeder Schleife durch und auch diese Funktion
wird aufgerufen. Und so könnte
sich die LED ein- und ausschalten. Das wollen wir
jetzt testen , weil wir viele Änderungen
vorgenommen haben. Und so können wir sicher sein
, dass diese Änderungen der Fall sind. Richten Sie daher die
Kamera richtig ein. Jetzt lasst uns sehen. Wenn wir einmal klicken. Sie pulsieren Funktion
wird eingeschaltet, da hier in der ersten
Spalte 0 Variable,
diese Variable als
eins und die Schleife, die if-Anweisung immer wahr
ist und die voreingestellte Funktion ordnungsgemäß funktionieren
kann . Noch einmal klicke ich auf Aus. Die statische Zählvariable
wird also auf Eins gehalten, Ein oder zwei Modal ist nicht 0 und
daher wird sie ausgeschaltet und Einzahlung wird wieder aktiviert
oder wieder falsch. Und ich kann klicken,
klicken, klicken, klicken, die zwei Sekunden
beibehalten
und ich kann es verblassen. Verblassen. Und zu verblassen ist los. Einmal klicken. Und das Vorgehen, wir arbeiten. Aber das ist nicht die
ganze Funktion. Der zweite Teil war, dass
wir
Yum implementieren und automatisch ein- und
ausschalten wollten . Deshalb könnten wir LED rot
sagen, schalten Sie ein. Und das schaffen wir mit digitalen
Rechten. Das ist okay. Und Sie wissen vielleicht, dass wir Angst und
Funktion in LET CPP haben, und es heißt „Nach Verzögerung
abschalten“. Aber hier müssen wir uns
ein wenig anpassen , denn
in dieser Funktion bin
ich, lass mich sehen, wo es ist. Also sind wir in dieser Funktion wird nur einmal arbeiten. Deshalb müssen wir
sagen, dass die vorherige Mitte ausgeschaltet
ist, ist Millis. Dann wird es richtig funktionieren
. Jedes Mal wird es aufgerufen. Kehren Sie zurück zum Haupt-CPP. Und auch diese Funktion
sollte außerhalb
der Schalterkonstruktion zugänglich sein. Und deshalb sagen wir, dass
LED-Ratte nach Verzögerung ausgeschaltet ist, zum Beispiel fünftausend Kraft, oder sagen wir 2500 und falsch, weil wir LED digital
verwenden, oder? Wieder einmal
laden wir die ganze Skizze hoch. Jetzt können wir sehen, dass wir den Fortfahren
ausschalten können. Natürlich können wir auch die Verzögerung
einschalten und ausschalten. Machen Sie noch einmal ein- und ausschalten. Und auch das Verblassen sollte
richtig funktionieren , wie wir es zuvor gesehen haben. Klicken Sie erneut und
es wird pulsieren. Dies ist es, was wir
geschaffen haben, um Aufgaben zu erfüllen. Und jetzt sind wir am
Ende dieses Projekts und haben erfolgreich eine Klasse
implementiert. Sie sind mit der Klasse verwandt
und haben auch
eine andere Klasse implementiert , um sie
in unserem Hauptprojekt zu verwenden.
49. Verdrahtung: Beginnen wir mit der Übersicht über die Hardware und
den Lagerteil. Wie Sie sehen können, ist es
sehr, sehr einfach. Mit ESP 325 LEDs Die LED ist mit dem
Boden an ein Brotbrett angeschlossen. Und auf der Anode
und der Plusseite haben
wir einen Widerstand. Und dann gehen wir zum
GPI oder vom ESP 32, in meinem Fall fünf LEDs und ich
fange an, billiger zu werden oder zu sinken. Es ist 19, wird es mir 1918 zeigen. Dann haben wir GPL 51615 auf der Oberseite eines für mehrere Modelle
als Hund- und G9-Team. Und du kannst auch
nur drei von ihnen benutzen. Zum Beispiel, plus und minus, verbinden
wir uns mit
dem Breadboard. Und jede der Zellen
hat einen Daten-Pin. Und wir verbinden den
Daten-Pin mit GPIO zum Beispiel
14, siebenundzwanzig,
sechsundzwanzig, fünfundzwanzig. Wenn Sie sich im Entwicklungsmodus befinden, würde
ich empfehlen
, den V5-Teil
auf das Breadboard zu überspringen , da der
USP über das USP mit Strom versorgt wird. Und Sie möchten nicht
zwei verschiedene Möglichkeiten haben . Es ist jedoch wichtig
, dass Sie
den Boden mit dem
Steckbrett verbinden , da das Potenzial gleich sein
sollte. Danach, wenn Sie
losgehen möchten, dass das ganze Spiel oben
nicht mit Ihrem PC verbunden ist. Dann müssen Sie natürlich eine
Verbindung herstellen, damit die
ESPs auch mit Strom versorgt werden. Aber ich versorge
die Zellwände danach mit einem externen USB mit einem externen
Stromquellenstecker. Und ich will, ich bin mit ihnen
verbunden. 12. Welt-Netzteil unterscheiden sich hier und
Spannungsregler, fünf Volt eingestellt ist mit diesem Potentiometer
innerhalb eines digitalen Messgeräts auf fünf Volt eingestellt ist, kann
ich hier auf fünf Welt messen wenn ich nach unten scrolle oder nach oben. Dann verbinde ich mich Plus, minus mit dem Breadboard. Und jetzt habe ich fünf
Volt auf dem Breadboard. Der Service wird erbracht. Wir sind eine externe Stromquelle. Das sind all die Dinge
, die brauchten. Die LEDs haben einen Widerstand, wie wir zuvor
in der LED-Klasse besprochen haben, und sind mit den
Minus-Teilen des Breadboards verbunden. Wie Sie sehen können, sehr,
sehr grundlegende Dinge. Es ist eher auf der Softwareseite. Und jetzt können wir mit
dem Quellcode fortfahren.
50. Kursdateien erstellen: Wir beginnen mit
diesem Projekt, indem eine neue Projektdatei
erstellen. Das habe ich schon
auf der Plattform gemacht. Alle Daten, die wir
hier hinzufügen, unsere grundlegenden Vorlagen, zum Beispiel die Ports zum Hochladen der
Monitorgeschwindigkeit , der
Monitorport. Und ich schließe immer
die AnalogWrite Library ein. Rette das hier. Und auch im Haupt-CPP beginnt
das Umschreiben der 0. Und es heißt Rock Paper Scissor und hat
vielleicht eine vierte Variante. Ich nehme den Brunnen, und so nenne ich
jetzt meine Klassifizierungen. Es ist ein Akronym, Es ist RPS. Wir, WE New File, R dot h. dann auch hier erstellen
und CPP File und New File, CPP als rechts. Und wir fangen
mit der Header-Datei an. Die Header-Datei hat immer
dieselbe Struktur. Es heißt also Klasse , weil wir dann Semikolon
machen. Der nächste Teil wird den Arduino Dot h einschließen.
Und sie beinhalten Wachen,
darunter Wachen I, f und f r p w, die h i zugrunde liegen. Dann heißt es define RP SW. Und ganz am
Ende sehen wir, und wenn es bisher gut aussieht, dann wechseln wir
zur CPP-Datei und hier
auch den
Arduino Today Edge. Und wir schließen
auch das RPS W ein, H. Ich kopiere diesen wechsele zwei Haupt-CPP. Und ich schließe auch
hier Header-Datei ein. Also haben wir jetzt
das Basisprogramm eingerichtet und auch die Klassendateien
erstellt.
51. Headerfile: Jetzt wollen wir
alle Dinge definieren , die
in die Header-Datei kommen. Obwohl wir es gerade nicht
brauchen, möchte
ich Ihnen einen
Überblick darüber geben, was wir brauchen. Zuallererst bin ich Euro. Meine Klasse ist
gegangen als Klasse, Klasse LPS W und Privates. Im privaten Bereich haben
wir keine Zeichenfolge. Es nennt sich Lösung. Und wir haben hier und
zweidimensionales Array. In der Lösungsdatei haben
wir jetzt vier Reihen und diese Furchen sollten mit geschweiften Klammern
initialisiert werden. Und wir setzen
hier in Verzug. Der erste Eintrag ist zum Beispiel
Schere, Stein, Papier. Dann habe ich in jeder Zeile 43 Einträge bedeutet Komma für Stein. Also kann ich jetzt sagen, der allererste Eintrag jeder der Zeilen überprüft
wird, ob ich, o von mir gewählt werde. Das heißt, wenn ich eine Schere
wähle, dann kommt der nächste Eintrag Papier, denn Schere schlägt Papier. Aber sonst nichts. Stein und wenn ich Steine
wähle, wird
Stein Schere sein, Schere
schlägt, Papier wird Stein sein und hat die Schere und
dieser Spender beschleunigt. Also welche Regeln? Weil die
Bürger der Welt sich nicht synchronisieren. Das Papier wird
auf dem Wasser schwimmen. Und das Papier wird den Stein
bedecken. Stein wird die Schere zerkleinern. Schere schneidet Papier. Dies sind die Regeln
im Basisformat. Natürlich können Sie
sich an viele,
viele Variationen für den E-Commerce anpassen viele Variationen für den E-Commerce , zum Beispiel mit Affen usw., dann können Sie weitere Zeilen hinzufügen. Und meine Spiellogik ist jetzt das, was wir später
implementieren. Ich wähle das erste aus, zum Beispiel Papier, das
ich durchlaufen habe. Und Papier kann
Stein schlagen und Schlimmeres. Und dann sehe ich den
unteren Stein oder Reichtum, dann gewinne ich, weil ich mich für Papier entschieden
habe. Wenn der Bot keinen
Stein und keine Brunnen hat, dann habe ich verloren, weil ich
nur mit Papier gewinnen kann. Und das ist bisher die
Spiellogik. Der erste ist das, was ich wähle, und dann sehe ich, was
im zweiten Teil ist. Und dann kann ich sagen, ob ich einen habe oder nicht, dann machen wir
mit der Struktur weiter. Struct zum Beispiel Punkte. Und in dieser Struktur werde
ich n String
Match und einen ganzzahligen Wert eingeben. Wir werden das später benutzen. Und es wird auch
hier auf der vorherigen Punktzahl haben. Rechtsklick Dokument formatieren. Dann öffentlicher Doppelpunkt. Hier definieren wir
eine Aufzählung, die Zustände nicht tun werden. Warum machen wir das in der Öffentlichkeit? Weil wir die
Staaten im Haupt-CPP verwenden wollen. Wir möchten prüfen, ob wir
jetzt States spielen,
ob wir auf Benutzereingaben
warten, zum Beispiel eine Website, oder wir sind am Ende und dann
sollten ihre Ergebnisse ausgedruckt werden. Dann sage ich auch String
ausgewählter Input zum Beispiel. Und ich tippe ein
Array ein und dann
haben wir Schere, Stein, Papier. Nun, und natürlich könnten wir
auch hier gebrauchen und runter gehen. Aber ich
möchte es einfach halten. Ich bin, ich bin, ich habe mich für Input entschieden. Und danach können wir hier und die
Zufallszahl
ausfüllen, und es ist fertig. Dann bin ich Punkte, erziele drei Punkte. Was sind Kurswerte, ist jetzt unsere Struktur und
wir initiieren dies. Und jetzt haben wir hier eine
Reihe von drei Punkten. Diese drei Punkte stellen
wir
zum Beispiel ein. Also eins. Und der Punktestand ist 0. Und dann, okay, dann benutze
ich es nicht, seinen Kern, würde ich
sagen Spielstand, eins. Kopieren. Dann der
zweite, den wir sagen können, verloren. Und der Chirurg sollte
zum Beispiel eng
gezogen sein, wie er es mochte. Augen fest. Bisher so gut. Wie du siehst. Die erste ist die Zeichenfolge, die zweite ist die ganze Zahl. Dies ist ein Array, und am Ende
brauchen wir hier Semikolon. Dann
wird das Nächste weiß sein. Alle LEDs aus. Weiß. Angeführt. Oder wir könnten sagen, dreh alle LEDs. Hier sehen wir einen Kamelfall, weiß. Check, Gameplay und Check Use. Bei zwei Eingabeparametern verwendet
String eine Zeichenfolge, aber ein Wide Reset-Spiel. Das ist alles, was wir für dieses Projekt
brauchen. Und jetzt haben wir
bereits
alle Header-Dinge implementiert alle Header-Dinge , die wir
in der Spiellogik benötigen.
52. Erster Spielmodus: In diesem Video beginnen wir jetzt mit der Definition unseres
ersten Spielalgorithmus. Und deshalb wechseln wir
zum RP als w dot cpp, wir deklarieren breite p.sit, W Doppelbindung, Doppelbindung,
Check, Use a Wind. Dies wird unsere
Hauptfunktion sein, die
uns unseren verlorenen Spielabschnitt
oder Draw überprüfen wird . Es ist also eine Benutzerzeichenfolge. Und diese Funktion wird in unserer main.cpp
aufgerufen, jede Übergabe hier, unsere
Auswahl und die Bot-Auswahl. Dann können wir sagen, ob die Eingabe des Benutzers dem Bot
entspricht, dann haben wir es entworfen. Es ist in engem Silberdruck. Eins. Sonst. Wir könnten sagen. Dann, jetzt die Logik, was wir definiert
haben, bevor sie jetzt ins
Spiel
kommt, das heißt vier. Wir sagen hier, dass Integer gleich 0 ist, Ganzzahl kleiner als Forum, da unser Lösungsbereich die Parameterform
hat. Und jetzt sehen wir hier, ob Lösungen, das sind Lösungen. Ich definiere das mit S , weil es
Lösungen gibt Plural Arm, Jahr 0. Das ist ein Benutzer. Wenn ich also eine Schere wähle, wird sie durchlaufen und prüfen, ob die ersten vier, ob das erste Element hier ist, Schere, wenn es ist, dann geht es weiter. Dann sagen wir, wenn Lösungen E, aber nicht die erste, die zweite
gekauft oder Lösungen ist. Wir brauchen ein bisschen mehr Platz. Eins zu diesem Ort, was wird
dann getan? Wir haben einen. Sonst. Wir haben verloren. Können wir das ausdrucken? Dann prüfen wir noch einmal
, was wir hier gemacht haben. Und wir könnten sagen, dass der Euro verloren gegangen ist. Also noch einmal die Logik, zu der
wir durch
das Spiel
durchlaufen, durch die Lösungen.
Hier sind wir. Wenn
ich zum Beispiel Papier wähle,
den ersten Bereich, werden wir es nicht tun. Der erste wenn wird nicht passieren,
weil das Lösungsserum, Serum eine Schere ist, 10 ist Stein bis 0
Papier, dann größer. Die nächste Lösung wird überprüft. Wenn der Bot hier hat, Stein, diesen, alle Knöpfe Brunnen, dann habe ich einen Elseif verloren. Und das ist der einfache
Algorithmus für unser Gameplay. Probieren wir es also aus. Wir werden
unsere Hauptdatei und TR hinzufügen, wir initiieren unser neues Objekt. Und das Objekt ist der
Klassenname ist RPS w und ich würde sagen, dass Spiel RP ist wie wir, aber nicht mit einem solchen w2-Namen. Und dann konnte ich im
Setup den
Game-Point-Check Benutzer sehen , wann. Und ich werde für x erstes
Beispiel Papier, Papier sagen. Und der Bot wird Stein haben. Dann habe ich eins, weil
Papier Stein bedecken wird. Probieren wir es also aus. Überprüfe einfach hier den Compiler. In der Zwischenzeit verbinde ich meinen USB an den
Computer und lade ihn hoch. Dann werden wir sehen, ob wir Recht haben. Also starte neu. Und wie Sie mit einem sehen können, denn Papier werden wir hier diese Kuppel
abdecken. Dann nächstes Beispiel, wenn
wir zum Beispiel verlieren, nehmen
wir eine Schere und der Bot nimmt
Welles noch einmal, lade das Ganze hoch. Und jetzt schießt die Schere gegen die Schweißnähte
verloren. Lassen Sie uns im
Hintergrund also minus
mehrere Motoren sehen , denn am Anfang
nehmen sie die Position ein, also haben sie ihre Wahrheit verloren. Und das letzte Spiel, was wir gerne überprüfen
möchten, ob wir
Papier und auch Papier haben als das ganze Spiel sollte mit
serieller Druckknappe aufhören ,
da die Eingabe gleich und dauerhaft
ist,
sollte sein geprüft. Mal sehen, ob diese
Funktion stimmt. Dann haben wir
unsere Spielalgorithmen bisher erfolgreich eingerichtet . Ja. Geht es uns gut? Im nächsten Teil werden
wir also ein
bisschen ausführlicher behandeln. Der Algorithmus.
53. Spielmodus in Loop: Jetzt verwenden wir das Objekt
ein bisschen mehr. Und deshalb wollen wir den 0-Print hier
loswerden. Und wir möchten den Kernspielstand des
Spiels verwenden. Aber ich möchte es am Anfang
mit Kleinbuchstaben verwenden . Also Spielstand. Und jetzt
wollen wir einen Index haben. Zum Beispiel
haben wir Ihren Tight ist dieser zweite Index 01 Sekunden. Und jetzt mit irgendeinem Punkt, es ist mir schon eine Truhe. Wir müssen
hier Punkte oder Match identifizieren. Und ich würde
gerne punkten müssen. Und jetzt ist Plus gleich eins, weil wir einen Zusatz haben
wollen. Um hier hinzuzufügen, um die Funktion
zusammenzufassen,
summieren Sie mit eins,
gleich, aber anders. Wir müssen hier 0 indizieren
und wir sind im letzten, wir haben den Index eins. Etwas
objektorientierter, weil wir jetzt punkten, sind wir diesen Kurs
in unserem Spielstand sicher? Mal sehen, wechseln Sie zum Haupt-CPP, um hier das
volle Potenzial auszuschöpfen. Was wir haben. Jetzt wollen wir hier auf
die Schleife gehen und wir machen hier und Bads verzögert sich nur zu
Trainingszwecken ,
weil
wir sie danach loswerden. Okay? Drucken Sie also einmal die Details
aus, damit wir einen seriellen Druck
verwenden können.
Und wirklich bequeme Art und Weise, wie wir Text und Variablen hinzufügen
können. So könnten wir zum Beispiel eins
sagen, verloren und eng. Und was wir jetzt tun können, ist, dass wir hier mit einem Komma,
der ersten Variablen, dem zweiten,
dritten Raum, einrichten
können der ersten Variablen, dem zweiten,
dritten Raum, , der einen
Zeilenumbruch macht, damit wir hier
ein bisschen mehr
Merrill-Modellraum haben . Und wie könnten wir jetzt
auf den Spielstand
mit RPS W auf einen starken Spielstand zugreifen . Kein Whisking. Spiel ist unser
Objektname, Spiel, Spiele Doppelpunkt. Und dann könnten wir sagen, wir wollen den ersten 1 Index,
den
Punktwert, den Klassennamen, dann den öffentlichen
Mitgliedsnamen und den Index haben. Das verwenden wir also
auch für den letzten, war aber der erste Index. Und der letzte ist
der zweite Index, aber am Ende kein Komma. Doppeltes Komma auch. Der Platzhalter dafür wird der und auch der letzte sein. Sieht sehr gut aus. Für die
allerersten paar Print f muss
es nicht gedruckt werden. Und jetzt lasst uns prüfen, ob
wir in Ordnung sind. Und es sieht gut aus, aber wir wollen ein
bisschen flexibler und
ein bisschen zufälliger hören . Daher würde ich sagen, dass
Ihre Benutzereingabe ist ich bin Benutzereingaben. Wir möchten auf
unsere ausgewählten Eingaben zugreifen. Also sagen wir hier wieder, Punkte gewählt, Eingabe gewählt. Und ich könnte
zum Beispiel zwei sagen. Und es wird mich zurückgeben, oder 10 oder 1012
werden wieder ausgedruckt. Ich möchte auch diese
Zeilenkunst-Benutzereingabe drucken,
am Ende der Zeichenfolge möchte
ich auch einen Zeilenumbruch hinzufügen. Also schrägst n für Zeilenumbruch. Aber hier gibt es keine
Zufallsfunktion im Inneren. Deshalb würde ich vorschlagen, dass
wir zufällig tippen. Und es braucht
zwei Dinge, um zu beginnen, Ausgangspunkt und
den letzten Punkt. Aber die letzte Zahl
sollte exklusiv sein. Wir haben also immer noch 123
sind was wir brauchen. Deshalb haben wir eine
Zufallsfunktion, die uns gibt, sollten wir
hier auch Benutzereingaben einbeziehen? Und diese Zufallsfunktion bringt Hilfe nicht
Papier oder Reichtum. Und zum Papier für das, denn der Bot wird fixiert
, damit wir ihn danach überprüfen können. Verbinden Sie dann den USB
mit Ihrem Computer. Kann meine Schrittmotoren
im Hintergrund hören , weil
sie bereits angeschlossen sind, dann werden Sie sehen, ob
wir Recht haben oder nicht. Also starte neu und gut, Scott verlor gegen Papier. Also wo sind wir? Meinst du hier? Paper Stone war wieder
einmal, ich muss neu starten. Stein, Stein, Stein, Menschen
verloren Stein, Papier, verloren. Verloren. Papier. Papier ist Gezeiten. Stein hält, Stein verloren. Schere, eine gegen die Rohrbombe. Ich bin gegen Papier verloren
, weil Papier schwebt. Stein gegen Lohn. War, und wie Sie es
sehen können, fangen
wir wieder von vorne an, damit ich sehen kann,
dass ein einziges,
Papier, eins gegen Papier steht . Unsere Zeitung sollte müde sein. Css, Stein hat Reichtum verloren. Ja, also funktioniert es. Sie können sehen, dass der Spielstand im Objekt gespeichert
wird. Und wir haben hier einen
etwas flexibleren Weg. Und auch wir haben hier
und zufällige Funktion implementiert, damit es da drin etwas
würziger ist. Erstens im ersten Feld.
54. Gestalte eine Website: Es ist Zeit, die Website zu erstellen. Deshalb gehen wir zu unserem Quellordner und
klicken mit der rechten Maustaste darauf. Neuer Ordner und ich erstelle
hier und Datenordner, es müssen die
Namensdaten sein, damit wir später die gesamte
Phase
auf unser System hochladen können . Dann kopiere ich
die Dateien von der Plattform und füge hier ein. Da wir hier
zum Beispiel jQuery benötigen, geben Sie Stil CSS ein und
klicken Sie mit der rechten Maustaste auf die neue Datei, und wir erstellen
einen Index-HTML. Jetzt kopiere und füge ich
ein bisschen ein, weil es allgemeinere Dinge zu tun ist. Aber wir gehen jede Zeile
durch. Das erste, was wir sind, beginnen
wir mit HTML. Dann hatten wir oft ein Jahr. Hier. Wir könnten zum Beispiel
Stein, Papier, Schere sagen. Schlimmer noch. Hier sind ein paar Dinge, die wir auch die Website öffnen
können. Für mobile Geräte. Wir haben auf einen
Stil- und
Jake-Zeilendaten verwiesen , die kurz zuvor
enthalten waren. Dann fangen wir mit
dem Körperteil an, Körper. Und wir können den
HTML-Code schließen. In der Leiche. Wir fügen hier die Überschrift könnte mit
dem Titel übereinstimmen. Dann haben wir hier
und Klasseninhalte. Also schließen wir es. In diesem Inhalt. Die Hauptwebsite wird visualisiert und wir haben
hier und andere Diff. Wir brauchen also alle Divs ,
damit alles sehr gut
ausgerichtet ist. Sie können dies
in der style.css verfolgen. Sie können sehen, was die
Klassenboxen tun werden. Dann der nächste, damit wir wirklich
alles ausgerichtet
haben . Es ist großartig div. Und in der Box kein Schatten. Ich habe hier und
wähle die Auswahl aus. Ich würde sagen, wir machen all die Dinge
sicher. Dann gehen wir in
unseren Projektordner. Das sind also alles Quelldaten für
Scherenordner aus Steinpapier. Doppelklicken Sie auf den Index HTML. Und wo ist es? Hier ist es. Hier ist die bisherige Website. Rock-Papier, Schere, Spiel. Und hier habe ich meine Auswahl. Und dann werde ich Schere, Stein, Papier, Reichtum. Und auch die ID sollte gleich
benannt werden. Schere, Steinpapier. Schlimmer noch. Okay, aktualisiere die Seite. Jetzt haben wir Neues. Bisher so gut. Als nächstes könnten
wir zum Beispiel Zeilenumbruch, Zeilenumbruch sagen. Dass wir hier in der Nähe der Todesfälle nach
den Kisten etwas
mehr Platz haben. Lass es mich sehen. Nach den Boxen füllen
wir hier ein neues
Notizbuch aus und es heißt
zum Beispiel Eintrag einreichen. Und das ist notwendig , dass wir hier eine
Onclick-Funktion haben. Ich komme später
dazu, spiele oder spiele. Das ist also ein Patent. Was haben wir jetzt gemacht? Wir haben und Knöpfe gemacht. Wenn wir also danach
hier wählen und auswählen, können wir
hier aufrufen UND Funktion, die wir an unseren ESP 32 weitergeben. Das sieht also aus, sieht sehr gut aus. Nach dem Hauptdef werde
ich
nach dem Inhalt Hertz hinzufügen und
unterstreichen Sprays. Und ich füge hier
ein neues div hinzu und es heißt zum Beispiel
Def-Statistik. Dann diese Statistik, die
wir hier veröffentlichen, die Ergebnisklassenstatistik muss
die Ergebnisklassenstatistik der Name sein, da sie im Stil CSS definiert ist, damit ich den Namen hier ändern kann. Ansonsten muss ich
es auch die CSS-Dateien ändern. Und hier habe ich keinen Tisch. Diese Tabelle wird
anschließend mit dem
serverseitigen Ereignis gefüllt . Die Tabelle hatte jemanden
mit Zeilen und Zeilen. Und die Idee ist
zum Beispiel dieser Kurs,
dass ich Änderungen überprüfen könnte. Und das sind nicht
Durans Ergebnis in H3. Erneuern Sie sich noch einmal,
und das ist jetzt unsere bisher perfekt reagierte
Website, so gut. Ganz am Ende würde ich
vorschlagen, dass wir Ihr JavaScript auch nicht in eine neue Datei
aufnehmen. Ich würde sagen, es ist gut genug , wenn wir alle in
ein Drehbuch schreiben. Dann sagen wir function,
wie heißt es? Es heißt „Submit get“. In dieser Funktion werden wir Daten
an unseren ESP 32 weitergeben. Bisher haben wir eine Website
erstellt. Im nächsten Schritt werden wir
besprechen, wie wir
eine WiFi-Verbindung aufbauen können und wie wir Daten zu unserem ESP 32
erhalten können .
55. Zugriff auf die Website über ESP32 Webserver: Jetzt ist es an der Zeit,
dass der USB 32 es mit unserem
Wireframe verbinden und dass wir auch
vom oder zum APS 32 auf die Website
zugreifen können . Zunächst einmal kleiner Fehler
im Video, bevor
wir die Daten in
der Haupthierarchie
im
Hauptordnerbereich herausnehmen Daten in
der Haupthierarchie
im
Hauptordnerbereich herausnehmen müssen als die Quellen,
Daten und Quellen
in derselben Hierarchie das ist
für einen späteren Zweck notwendig. In unserer Quelle kopiere
ich hier
meine Anmeldeinformationen in. So können Sie mir folgen und
mit der rechten Maustaste auf neue Datei klicken. Ihre Anmeldeinformationen, zum Beispiel Craig Zahnersatz Punkt h. Und wir können
hier sagen, dass
es zum Beispiel eine konstante
Lebensdauer ist und SSID sehen. Und wir könnten sagen, das Passwort
ist const char nicht 2442. Das war's. Das ist es, was wir identifizieren und definieren müssen
. Ich lösche diesen, weil
ich es schon hier habe. Im Haupt-cpp. Ich füge hinzu, dass es Zahnersatz
Dot h als nächsten enthält. Wir könnten sagen, dass wir hier ein bisschen
mehr externe Bibliotheken
brauchen . Daher füge ich
die folgenden hinzu. Du fragst dich vielleicht, wo bekommst du sie? Sie können sie auf die Plattform bringen. Ich öffne keine Bibliotheken. Und ich weiß nicht, ob
wir das vorher gemacht haben, aber hier können Sie zum Beispiel
ESP selbst
wählen und
Sie können den Namen
beispielsweise von
Kevin Harrington hören . Und Sie beginnen mit der
Beispielinstallation. Und du wirst den Namen
der Bibliothek hören. Kann es kopieren. Und wie ich es hier
habe, füge es ein. Das ist alles, was
wir jetzt tun müssen. Speichern Sie es und wechseln Sie
zum Haupt-CPP TO vor oder
nach dem Arduino-Punkt h. Wir schließen jetzt alle
Bibliotheken ein, die wir brauchen, das ist der Y fit und H. Warum haben wir nicht gemacht und referenziert
und ein Blut von irgendeinem? Das ist der Grund, weil
ein Feed bei H nicht der Kern des ESP 30 zum Kern ist, bedeutet, dass es
referenziert wird , dass die Bibliotheken
eine integrierte Bibliotheken sind, würde
ich sagen und alle anderen. Wir müssen es
so einbeziehen wie zuvor. Zum Beispiel auch der
benötigte TCP und der ESP-Arsen-Webserver für die Kommunikation mit
dem Webserver. Spucke sind ebenfalls
im Kern enthalten und Spucke
werden abgeschrieben. Das bedeutet, dass sie in den nächsten Releases
möglicherweise nicht mehr unterstützt werden. Stattdessen wird
wenig EFS verwendet. Warum verwende ich Spoofs, weil ich hier die
schwarze Version USB 32,
3.5, die Blutfilmversion verwende , und ich brauche sie aus anderen Gründen. Aber später, wenn Sie zwei kleine EFS wechseln
möchten, gibt es nur ein
paar kleinere Änderungen und alles
funktioniert auf die gleiche Weise. Ich zeige dir danach,
wie du das machen kannst. Dann müssen wir
diesen Servopunkt h hören. Das sind alle Bibliotheken
, die wir bisher brauchen. Dann unsere Truhe, dass wir Änderungen an
der Explorer-Quelle
vornehmen, neue Datei, meine Frau, V dot h. Jetzt
verbinden wir uns oder sagen hier
alle notwendigen
Funktionen, die wir brauchen. Zum Beispiel stellen sie eine Verbindung zu Access Points her, bei denen
wir über eine Wi-Fi-Verbindung verfügen. Hier können wir sagen, dass
Verbindungen zu Wi-Fi hergestellt werden. Wi-Fi zwischen SSID und Passwort. Und das ist von den
Anmeldeinformationen dot h, Unsere wichtigsten globalen Variablen. Dann ist dies auf
Standardverfahren. Sie können einfach kopieren und mit der
rechten Maustaste auf Dokument formatieren klicken. Hier bekommst du die
Wi-Fi-Verbindung. Wenn es sich in einer While-Schleife
befindet, wird es jede Sekunde ausgedruckt und zeigt und es ist erfolgreich. Wir können hier
und lokale IP-Adresse ausdrucken. Wenn es mehr als 20 Schleifen sind, bricht es aus
der While-Schleife aus. Weil
es dann oft so ist, dass es zum Beispiel
etwas mit dem
Router gibt. Dann würde ich auch vorschlagen , dass Sie hier
die Prozessorfunktion einschließen. Es wird für das Internet benötigt. Wenn wir zum Beispiel Lichter aus- und einschalten möchten , so dass wir, wenn wir Parameter
übertragen und erhalten, in diesem Fall nicht verwenden, aber Sie sollten
sie implementieren, weil es erforderlich ist. Erstellen Sie das Objekt auch später. Was brauchen wir für die
serverseitigen Ereignisse? Und wir erstellen hier auch das Webserver-Objekt
sollte Port 80 sein. Und dann sollten wir auch
hier den Arduino Dot h. einbeziehen und auch diese seriellen
Fehler sollten verschwunden sein. Bisher so gut, eine Menge Kopie
von Pasten. Das sind einige allgemeine Dinge. Wir wechseln zurück zum
Haupt-CPP auf den Setup-Teil. Denn was wir jetzt tun wollen, ist, dass wir Smiths anfangen wollen. Es gibt auch ein
Standardverfahren. Könnte es auch kopieren und einfügen. Dann rufen wir unsere Funktion auf, oder wir rufen unsere Funktion connect to
Access
Point auf , den wir bereits definiert haben. Aber wie Sie sehen können, wo
wenn Sie ein Fehler sind, weil wir noch nicht enthalten sind, enthält
es meine Frau dot h. Der nächste Punkt müssen wir hier Summenfunktionen
für den Webserver
hinzufügen. Also poste ich einfach in all die Dinge und dann
gehen wir es Zeile für Zeile durch. Dieser heißt Server auf. Server auf, wenn wir auf die Website
zugreifen, wird er von
unserem Dateisystem,
der
Seite index.html von Smiths, weitergeleitet . Der nächste. Wir haben hier unsere CSS-Akte. Eine CSS-Datei wird von
Smiths Website und
auch von Chaco bereitgestellt , es ist Text-Script-Text,
und sie wird durch Spirituosen
mit diesem Dateinamen
bereitgestellt. Dateiname. Beginnen Sie also, wie Sie sehen können, den mittleren Index. Und das ist notwendig
, weil wir
die Daten vor Verschüttungen im
Dateisystem speichern . Und so können wir automatisch vom
Programmstil CSS und
auch vom Index oder morgen darauf
zugreifen . Bisher so gut. Und was wir auch
hier auf dem Server brauchen, beginnt. Eine Randnotiz, wenn Sie später auf kleine f s
wechseln möchten , ändern Sie
einfach die
Include-Anweisung S begin. Und hier war das
respektiert, dass Sie
zwei kleine EFS wechseln und
alles sollte gut funktionieren. Wie bei Spirituosen. Nachdem das Silber beginnt. Bisher fügen wir nichts hinzu. Und ich würde auch
empfehlen, dass wir die Schleife kommentieren , da
wir darauf vertrauen
möchten , ob wir eine
stabile WLAN-Verbindung haben und
ob wir auf die Website zugreifen können, deshalb machen wir
hier und zuerst kompilieren, prüfen Sie, ob alles stimmt, und dann laden wir diesen Catch überhaupt
hoch. Also mal sehen, ob
alles gut aussieht. Ja. Sie dann die Skizze hochladen, wie wir sehen können, wird die
Datei hochgeladen. Wenn der Upload erfolgreich
ist, wechseln
wir zum
Serummonoton, denn jetzt sollten wir sehen, ob Gas, ob es sich anschließt oder nicht. Ja, und wir haben eine
Unstable-Funktion, aber wir können jetzt nicht auf
unsere Website zugreifen , weil wir sie bisher nicht hochgeladen
haben. Also sind wir nahe bei 0. Mana ist notwendig, weil wir
sonst den Weg blockieren. Jetzt haben wir einen
anderen Ansatz. Wenn Sie nicht Arduino EDM sind, würde
ich Ihnen empfehlen, nicht Terroristen
zufällig zu sein. Suchen Sie zum Beispiel nach dem Hochladen des ESP
32-Dateisystems. Weil es
ganz anders ist. Sie haben hier eine Einheit auf
Drittanbieter-Anwendung durchgeführt, die
Ihnen in dem Artikel zur Verfügung gestellt wird. Aber es ist nicht mit der
Arduino-IDE gekommen, um O. Also habe ich auch mit
den alten Medien
erlebt und mit diesem
speziellen hochgeladenen funktioniert sehr, sehr gut mit der
neuen Arduino IDE. Ich kann nichts sehen
, weil ich es nicht benutze. Gehen Sie also einfach Schritt für Schritt
durch den gesamten Prozess, laden Sie Ihre Datendateien und dann können Sie mir
mit den anderen Schritten folgen. Mit dem Visual Studio-Code. Es ist bequemer. Wir wechseln zur Plattform IO, gehen zu unserem Gehörlosen-Kit. Zuallererst könnten wir zum Beispiel alle
bereinigen, oder wir sagen Build
Dateisystemabbild. Wieder einmal ist es notwendig, dass alle
Serummonitore geschlossen sind. Sonst würden wir es blockieren. Dann könnten wir sagen Dateisystem
hochladen. Und jetzt werden alle Daten in die Melodie ESP 30
hochgeladen. Es ist noch nicht fertig. Warten Sie, bis hier die erfolgreiche
Meldung auf
dem seriellen Monitor angezeigt wird , wenn die
Schichtdaten überprüft wurden und verlassen. Das sieht sehr gut aus. Jetzt können wir
den seriellen Monitor so einschalten ,
dass er wieder eine Verbindung zu
WiFi verbindet und die Schauspielerin eintippt. Noch einmal. In meinem Fall muss
ich es oft melden
, damit eine Verbindung hergestellt
werden kann. Wieder einmal
wurde es erfolgreich etabliert. Und wenn ich
die IP-Adresse in sie eintippe, in meine Webs, sollte
mein Browser auf der Website geöffnet werden. Und das war's für den
ersten Ansatz, wir werden die spezifischen
Daten zum USB 32 erfolgreich
erstellt und Wi-Fi-Verbindung bearbeiten, und wir haben Zugriff auf unsere
Website auf ESP 32. Viel, sehr, sehr guter Ansatz. Vieles haben wir alles
getan. Und im nächsten Schritt implementieren
wir den Spielalgorithmus
auf ihre Website.
56. Daten von der Website auf ESP32 übertragen: Jetzt wollen wir
die Kommunikation
zwischen dem ESPN
und der Website herstellen . Unser Ziel in diesem Video, wir werden dann sein, wenn wir hier einige
unserer Optionen
auswählen. Wöchentliche Beschwerde, dass dieser Wert an unseren ESP 32 weitergegeben
wird. Zuallererst haben wir das
Öffnen unseres Index-HTML, und es befindet sich in unserem Datenordner. Und ganz am Ende, nach dem erneuten Öffnen, ist
es das Ende, dass wir
hier eine leere Funktion haben, senden erhält dieses Submit get wird aufgerufen, wenn wir auf diesen Button
klicken. Diese Schaltfläche
überträgt oder greift auf die Funktion
zu, die uns einen Teil
der gewählten Option liefern
soll. Das ist also die ID SSP Oswald. Und wir greifen auf diese Idee zu und wir sollten eine dieser Optionen
zurückholen. Wie können wir das machen? Ich bin ein jQuery-Fan,
weil er für mich einfacher zu bedienen ist. Sie können aber auch Ihre
Standard-JavaScript-Sprache verwenden . Also würde ich sagen, dass die
Benutzereingabe weit ist. Jetzt greifen wir auf die Idee zu. Und die Idee ist mit dem
Hashtag SSP sei Oswald. Es heißt Punkt gut, für wohlhabendere und
amerikanische Kleinbuchstaben. Falls wir
furchterregende andere Zeichen haben, dann habe ich die Benutzereingaben
der Konsolensperre
für später zum Debuggen gedruckt Benutzereingaben
der Konsolensperre . Und jetzt besteht die Aufgabe darin
, dass wir
diesen Wert auch auf den ESP übertragen diesen Wert auch auf den ESP und das können wir
mit ihnen machen GET-Anfrage, was ist nicht GET-Anfrage? Zum Beispiel meine Website. Und wenn ich hier
zum Beispiel auf einer Website namens
Arduino Dot PHP habe. Und dann mit einem
Fragezeichen, lautet
der Variablenname William. Und das ist nicht, ähm, ja, und wie wir
über den USB mit
den GET-Variablen kommunizieren können . Das bedeutet, dass
ich später diesen Variablennamen
hierher kriegen
und die Daten abrufen kann. Und das machen wir
hier mit diesem Ansatz. Deshalb verwende ich
auch jQuery. Also benutze ich hier, du bist unsere Funktion
, die nicht richtig war. Das sollte nicht sein. Es sollte Code,
Funktion und Daten sein. Da sind wir los. Und das ist die Struktur davon. Und hier ist nichts. Hier gibt es nichts für uns zu
tun, da wir nur
die Datenanomalie senden wollen. Der USB kann Daten
zurück an die Website senden und
wir können hier etwas tun. Aber wir verwenden
einen anderen Ansatz da dies nicht nur
im Synchronprozess ist, sondern wir wollen einen asynchronen
Prozess, da später der ESPN
das ganze Spiel machen und danach zurücksenden
sollte die Daten. Dies dient nur zum Senden von
Echtzeitdaten an unseren ESPN. Die URL sollte jedoch definiert sein. Und ich würde sagen, Get
Variablenname heißt SSP BM. Und ich sehe gleich, und wir sitzen im
Variablennamen ist Benutzereingabe. Der GET-Parameter
sollte also
so aussehen, ist zum Beispiel Stein
oder gestohlen in diesem Fall. Und legen Sie sich hin, wir holen diesen Variablennamen ab und
erhalten die Benutzereingaben zurück. Also speichern wir die Daten. Und ich würde empfehlen
, dass wir
jetzt nur auf die Website hochladen , damit wir sehen können, ob wir hier ein paar Pfeile
haben. Dann werden wir aus
Iowa geblutet, das Dateibild hochladen. Und hör auf. Ich sehe hier habe ich hier verpasst. Ich muss natürlich hier reinlegen
, um es noch einmal zu bekommen, lade es hoch. Hat eine Zeremonie eröffnet. Also bin ich bereits verbunden, als ich die
Website noch einmal öffne, aktualisiere sie und klicke mit der
rechten Maustaste hier. Dann können Sie weiter inspizieren. Wir klicken auf Abbrechen. Und jetzt, wenn wir
hier
etwas auswählen und auf das Flugzeug klicken, bekommen
wir hier die ID. Das wollen wir. Perfekt. Was wir bisher
getan haben, ist, dass
wir durch Klicken
auf den Play-Button, diesen Wert der ID, nicht auf den Inhalt, die ID, klicken. Diese Idee sollte die
gleiche sein wie wir in der,
oh, wo haben wir
sie in der Header-Datei definiert ? Weil wir es dann erreichen können. Dies ist also ein
Steinpapier-Reichtum sollte
die gleiche ID haben wie hier definiert. Dann können wir später
weitermachen, wenn die Verwendung von in die Werte
in diese Funktion einsetzen
und unsere gesamte Spiellogik haben könnte die Werte
in diese Funktion einsetzen . Also, aber wir sind noch nicht
fertig, weil wir hier
das Haupt-CPP
und die Funktion einsetzen das Haupt-CPP
und die müssen, die
auch das Get erfassen wird. Und ich habe es schon hier
erklärt. Also machen wir hier eine
individuelle Funktion und wir wollen hierher kommen, sie antworten könnte eine Webserveranfrage
sein weil diese Konstruktion alles
hat, was wir brauchen. Zuallererst gehen wir ein
bisschen an den Anfang
unserer Datei und wir erstellen
hier einige Variablen. Zuallererst möchte ich eine globale
variable Benutzereingabe
vornehmen. Und wir definieren hier
und Funktionsprototyp. Was ist der Funktionsprototyp? Weil ich hier
die Check Pattern-Funktion machen
möchte , aber nicht über dem Setup, wenn ich nicht
kommentiert deklariere, um
Ihnen zu zeigen , was
ich damit meine. Kopiere es einfach. Ich gehe zum Ende der Akte. Ich hätte gerne
hier die Funktion weil sie mir
einen besseren Überblick gibt. Aber hier kannst du ihn sehen. Die Prüf-Pfunde hätten einen Kompilierfehler haben können,
da wir
die Funktion an erster Stelle
definieren müssen die Funktion an erster Stelle
definieren , damit der Compiler von
oben nach unten geht, weiß, okay, der Funktion
wird definiert, hat keine Logik, geht,
geht runter, runter, und
hier kommt zur Logik. Dies ist es, was ein Prototyp daher
unkommentiert
macht, damit der
Compiler die Funktion kennt. Und jetzt gehen wir direkt zum
Button und jetzt sind sie, die Details kommen
als Eingabeparlament ein , dass wir diese Anfrage verwenden , die wir
vom Webserver erhalten. Und jetzt könnten wir sagen, ob die Anfragen, und
das ist ein Zeiger, also greifen wir
mit dem Fehler zu. Und hier sind alle
implementierten Funktionen , die es gibt. Und es sollte keine
Funktion mit Hessen geben, kein Keuchen S, S PBM oder wie nennen wir
es? Wir nennen es. Lass es mich sehen. Spb zum Beispiel. Wie auch immer Sie es Haupt-CPP
nennen möchten. Ich möchte das festhalten. Und wenn es einen solchen Parameter gibt, dann sage ich Benutzereingaben, die wir in
einem allgemeinen globalen Bereich deklariert werden. Dann sagen wir Anfrage
, die Parameter hat. Jetzt kriegen wir Eltern
Param, SSP, PM. Und wir sagen, nun, du bist bisher sehr gut. Jetzt
möchte ich es ausdrucken 0, Benutzereingaben
drucken, damit
wir überprüfen können, ob unser Recht ist, mal sehen, was der
Compiler sagt. Alle
geöffneten Hello Dinge schließen. Und wenn der Compiler uns grünes Licht
gibt, laden
wir die Skizze hoch, die Website ist bereits hochgeladen. Dann können wir sehen, ob wir noch nicht eingerichtet haben und
Kommunikationszeremonien geöffnet
sind oder
die Website neu geladen werden. Und jetzt möchte ich steinigen müssen. Stone ist hier. Ich wollte Papier machen. Okay, ich habe
einen Zeilenumbruch verpasst. Eine Schere. Schere war wieder sehr gut. Und hier haben wir eine erfolgreich
die Kommunikation zwischen
der Website etablieren und uns
den Wert an den ESP 32 weitergeben.
57. Spielmodus für zwei gewonnene Spiele: Jetzt kommen wir zur
geheimen Sauce
unseres Spiels, weil wir
den Spielmodus ändern
wollten , damit wir automatisch erkennen können ob wir auf einen Input warten, ob wir bluten oder ob das Spiel ist am n-ten
und wir haben zu eins gespielt. Das bedeutet also, dass ich zwei Siege oder
zwei Verluste brauche , damit wir das Spiel
beenden. Und deshalb
kommen unsere Staaten hierher ins Spiel. Und zuerst müssen
wir überlegen, was
ist der erste Staat? Der erste Status wird sein, dass wir auf Benutzereingaben warten,
nachdem der USP 32 gestartet wurde. Nachdem wir hier
eingestellt sind und die
Eingabe über die Website verwendet
haben, wechseln wir
zum Spielen des Spiels. Wenn du das Spiel spielst, muss
es
im Hintergrund sein. Prüfen Sie, ob wir am Ende sind
oder wir
wieder gegen den Bot spielen. Denn wenn jemand, wenn
ich einen oder den
BOD-Test zweimal einmal habe, dann sind wir am Ende. Wir setzen alles die Ergebnisse
auf der Konsole
veröffentlichen, oder wir warten auf die Eingabe. Das
wollen wir jetzt umsetzen. dann zuerst Gehen
wir dann zuerst zum Setup-Teil. Und im Setup müssen
wir hier erklären, wir wollen warten. Die erste Aussage
unserer Staaten geht
daher
zum Ende des Aufbaus. Dann geben wir unseren Cloud-Objektnamen von
Triclinium heißt Spiel ein. Spiel dot. Status ist gleich Spielpunkt. Warten Sie auf Benutzereingaben. Hier haben wir einen Fehler, weil wir
hier unsere Bundesstaaten haben, aber die Staaten
nicht initialisiert werden. Und natürlich ist es nicht
ungewöhnlich, dass
wir Dinge
in der Header-Datei initialisieren, aber ich möchte nur ein
Objekt der Zustände. Ich möchte nicht
viele verschiedene Arten von
Objekten haben , nur einen Staat. Und das ist der Grund,
warum wir
es hier in die Header-Datei einleiten können , und dann können wir
es verwenden und darauf zugreifen. Jetzt können wir in der Schleife hören, unser Objekt, unser Spielobjekt,
fragen, in welchem Zustand wir uns gerade
befinden. Und dann können wir uns hier zum Beispiel auf den
Radiergummi
konzentrieren. Was können wir jetzt tun? Wechseln Sie den Spielpunktstatus. Und im Switch-Fall sind wir, frage
ich den nächsten Fall. Also das
Fallspiel, Double Point, Break Case Game, warten Sie auf
Benutzereingabe-Datenpunkte. Und wir haben Großbritanniens Spiel
und ohne Pause. Und bisher haben wir
die verschiedenen Arten von
Staaten im Inneren und Bruch identifiziert . Springe zurück. Es muss obere F geben. Jetzt sollte es gut sein. Ja. Also legen Sie sich hin, wir überprüfen hier den Inhalt
für den Switch-Fall, aber wir befinden uns derzeit
im Bundesstaat. Es ist das Setup. Wir warten auf Benutzereingaben. Jetzt
tritt jemand auf der Website über Eingaben ein und wir
erhalten hier die Eingabe, löschen den seriellen
Druck und ändern den Status in „Abspielen“. Daher spielt das Spiel dot
States ein Spiel. Nachdem wir den
Status in der nächsten Schleife hier geändert haben, wird
die Funktion
in das Fallspiel gesprungen. Und jetzt können wir uns überlegen,
was ist der nächste Schritt? Jetzt müssen wir
unsere Hauptfunktion nutzen. Es heißt Game Check, Verwendung von wenn Benutzereingaben verwendet werden. Dies ist unsere globale Variable
von tschechischen Params. Und hier möchte ich die
Eingänge in der Schleife haben, aber außerhalb des Switches würde
ich hier String Pot definieren. Und der Pot kommt her. Spielpunkt ausgewählte Eingaben. Hier ist dies unser gewünschter RAM. Es hat vier Einträge und wir
wollen mit einer Zufallszahl, x ist hier, einer von ihnen. Und wie wir bereits besprochen haben, ist
dies eine private Sache. Das ist der Grund,
warum wir es hier hinzufügen. Die gewählte Eingabe als
öffentlich gewählter Input. Dann machen wir
in Zufallszahlen
zum Beispiel zufällig bis
vier und S, die wir
auch früher besprochen haben. Diese erste Zahl ist inklusive inklusive und dies ist
exklusiv. Also brauchen wir hier. 0 bis drei,
deshalb müssen wir dich betreten. Und für unsere Nummer, runde Nummer
identifizieren wir auch. Weil wir auch
später unter dieser Nummer brauchten. Und wir können hier im
URL-Feld die Zufallszahl festlegen. Okay, bisher so gut. Jetzt werden die Benutzereingaben
von der Website aus den
tschechischen Mustern
überprüft. Und wir sind mit zufälligen
Eingaben hierher gekommen. Bisher so gut. Was brauchen wir? Jetzt? Wir haben gerade die Staaten überprüft. Lassen Sie uns den
Benutzer des Spielprüfens sehen , wenn wir diesen Kurs nur
speichern, aber wir ändern hier keine
Zustände und halten ihn allgemein. Das heißt, wir müssen
mich hören Kann zweite Funktion und das Gameplay überprüfen. Gameplay. Wir haben uns
noch nicht definiert, daher wechseln
wir zu unserer Datei. Ich drücke W und wir
sagen, was RPS,
WOW, Point, Check Gameplay. Und hier müssen
wir unter
tschechischer Spielschuld darüber nachdenken, was passieren sollte. Also betritt jemand
etwas und eine Teekanne. Und jetzt haben wir
hier in Staaten, in denen jemand gewonnen oder verloren hat. Und jetzt sollten wir uns identifizieren, ist das Spiel am Ende oder sollten wir auf einen weiteren Input
warten? Denn wenn ich zum Beispiel eine
Schere habe und der Stein bin, hat
der Bot das erste
Mal gewonnen. Jetzt müssen wir warten. Aber was wir zeichnen sollen,
was ist, wenn wir nur eins zu eins
haben. Deshalb prüfen wir
jetzt, ob unsere Spielspalte Wenn
also der Spielstand punktet, müssen
wir hier zugreifen,
um den Spielstand zu erzielen. Punktestand für den ersten Einstieg. Das ist das, was wir wollen, ist größer als Werkzeug. Oder wenn das Spiel mit der ersten Punktzahl größer als zwei Punkte ist, dann hat jemand verloren
oder jemand hat einen. Weil der erste ist, dass ich 12 Mal habe oder der
Bot 12 Mal hat. Also auch nach Ereignissen, dann ist das Spiel beendet. Dann können wir hier sagen, der Staat ist wenn nein, wow, niemand hat einen. Dann lautet der Status, warte auf Benutzereingaben. Und wir sind hier
in der Klasse. Das ist der Grund,
warum wir keinen Objektnamen benötigen und ihn mit einem Gleichheitszeichen
identifizieren können. Bisher so gut. Und dieses Check Gameplay wird aufgerufen und jede Schleife
, wenn wir spielen. Und aus diesem Grund möchte
ich
ein paar Silberabzüge hinzufügen , damit
wir eine schönere Ausgabe haben. Ergebnisse. Serieller Druck. Wir können eins sagen. Dann sehen wir verloren. Und wir könnten Gezeiten sagen. Und wir tippen
den Spielstand ein, nicht 0. Ergebnis. Habe das verloren. Und Schemata CO2 ist gebunden, also kommen wir an die ganze Sache. Und da die letzte, serielle Druckzeile, Okey-Dokey, bisher gut
aussieht. Dann müssen wir
zu unserer Hauptschleife zurückkehren , weil
wir noch nicht fertig sind. Weil wir jetzt noch einmal die Schuld
überprüft haben. Es ist also feuchter, auf
einen Input zu warten oder es ist das Ende. Aber was er zum Nten sagte und etwas
nach unten
geht, haben wir hier eine weitere Funktion, die
wir implementieren müssen. Also könnten wir sagen, Spiel
Dot Reset Spiel. Und lass mich ein bisschen sehen. Also setze das Spiel
zurück und wechsle zurück zu unserer Klassendatei, weißem RP SW, neuestes Spiel. Und was sollte hier passieren? Es ist sehr einfach, weil ich das Objekt nicht auf
initiiertes oder neues Objekt löschen
möchte , weil Sie
hier
vielleicht einige Runden zählen würden usw. also möchte ich nur die Sticking School löschen oder
überschreiben. Deshalb
verwende ich eine for-Schleife. Ganzzahl zählt also bis drei. Und Tia, ich sage Game Score. I, der Punktestand ist gleich 0. Und jetzt überschreibe ich
diesen Kurs am Ende und ändere den Status, um
auf Benutzereingaben zu warten. Jetzt denke ich, dass wir
alle Staaten allgemein verwaltet haben ,
weil er in der Schleife zum Beispiel auf die
verschiedenen Modelle zugreifen kann, aber nichts
in der Hauptkernklasse implementieren kann. Und auch hier
warten wir auf Benutzereingaben, hier
gibt es nichts zu tun. Aber auch hier
würde ich zu
Trainingszwecken und
auch zur Validierung vorschlagen . Ich möchte hier dann
die Eingänge
ausdrucken , also serieller Druck. Und hier sind wir. Ich gebe ihm den Grund, aber ich wechsle hier, nicht den Pot am ersten. Ich hätte gerne
hier die Benutzereingaben, denn dann ist es die gleiche
Reihenfolge wie hier, Benutzereingaben. Dann haben wir den Pot als das letzte Zeichen, das
wir hier machen, Druckzeile und
Semikolon am Ende. Vergiss das Semikolon nicht. Prüfen wir, ob wir
hier ein paar Pfeile haben. Bekommen wir grünes
Licht von unserem Compiler? Und dann
laden wir die Skizze auf ihren USP 32 hoch.
Ja, es sieht gut aus. Dann lädt es hoch. Das Programm wird also
geflasht und wir sind mit dem WLAN verbunden und laden die Website
erneut . Jetzt möchte ich mich
für Stein entscheiden. Stone ist mein Input, Papier ist der Bot, also habe ich verloren. Das stimmt. Wieder Stein, Steinpapier. Okay. Wieder einmal möchte ich
Papier, Papier gegen Scissors haben . Ich habe verloren als Reichtum war. Wieder Schwester, ich gewinne, weil
Scheren gezogen werden. Dann war Wells wieder
Papier- und Papierschwimmer. Ich hab schon wieder verloren. Neues Spiel. Wir fangen beim nächsten Mal an. Eine Schere. Schere war einfach
nicht mein Glückstag. Gestohlene Schere. Eins, noch einmal das Stein
- und Steinpapier, das ich verloren habe. Noch ein Spiel. Ich hätte gerne Angst
und eine enge Papierschere. Ich habe den Zweck verloren, als ich verloren habe. Wie Sie sehen können,
haben wir hier Papier, Papier fest. Das wollte ich überprüfen. Das Gameplay, würde ich
sagen, funktioniert also sehr gut. Und im nächsten Video zeigen
wir
unseren Versuch, den Rest davon zu machen.
58. Serverseitige Ereignisse senden: Jetzt möchten wir zu den Ergebnissen des ESP auf
die Website
zurücksenden , damit
wir später
auch die
Ergebnisse dort visualisieren können . Daher können wir hier
die serverseitigen Ereignisse verwenden und die Seller Side Events sind
ziemlich gut für uns vorbereitet. Wir müssen nur Dinge
kopieren. Und das ist von
ausdrucksstark selbst. Sie haben uns die Code-Snippets gegeben
und Sie können es ausfüllen. Deshalb
öffnen wir den
Index-HTML und außerhalb der Funktion
Submit get deklarieren
wir hier. Und wenn Fensterereignisquelle, kopieren und fügen wir die erste Funktion ein,
klicken Sie mit der rechten Maustaste auf Dokument formatieren. So wird ein EventListener geöffnet. Und dann sind wir
auch auf Nachricht gekommen, wenn es getrennt
ist und der
ESP die Verbindung verloren hat. Auch die Nachricht, die
erste, wird hier implementiert. Aber jetzt bist du unsere Quelle. Unsere Veranstaltungen können kommen. Bevor wir das tun, wechseln
wir zurück zu unserer Haupt-CPP-Datei. Und wir, mal sehen, gehen in den Staat. Und wir müssen
hier die serverseitigen Ereignisse initialisieren. Der Server hat hier begonnen, behandelt
aber jetzt die
Webserver-Ereignisse. Und wie konnten wir das machen? Es ist auch hier zum Kopieren und Einfügen von festen
Mustern hier und auch für ausdrucksstarkes
Self-Event bei connected. Dann haben wir hier eine
Idee bekommen, wann wir uns wieder verbinden, und dies ist das erste Spiel. Die Nachricht war,
die
hier innerhalb von Halo und
Server bei Handles gesendet wird. Dies ist also das Basisskript, das die Ereignisse sind. Aber was ist unser Job? Unsere Aufgabe ist es, die
Ergebnisse an die Website zu senden. Daher könnten wir zum Beispiel hier
unter dem Gameplay gehen zum Beispiel hier
unter dem Gameplay und Ergebnisse an die Website senden. Und das
können wir jetzt tun, Events, Punksend-Events sind unser Objekt
, das wir hier erstellt haben. Lass es mich hier sehen. Sollte auf einem
Wi-Fi sein, glaube ich hier. Dies ist dieses Ereignis,
Ereignisquelle. Und jetzt, in der Schleife, geschickt, müssen wir
zum Beispiel eine Zeichenfolge senden . Und String. Kopieren Sie einfach
den ersten und fügen Sie ihn ein. Einige Zeichenfolge, weil dies
nur eine Ganzzahl ist , die in eine Zeichenfolge
umgewandelt wurde. Und dann zwei unaufgeladene,
weil wir das brauchen. Dann gebe ich auch den zweiten Wert an und er
heißt zum Beispiel eins. Und wir
posten auch hier Millis. Also hier müssen wir nicht reduziert
hinzufügen, und es heißt Spiel. Und wie man
den Spielstand aufzeichnet. Punkt-Spielstand, 0 und Punktwert. Jetzt haben wir zwei Punkte. nächsten Zeile wollen
wir das Verlorene haben. Und der dritte
wird der Tight sein. Okay. Lasst uns fertig werden. Lädt zunächst
die Websites hoch. Nein, wir sind
auf der Website noch nicht fertig. Wir haben nur die grundlegenden Ereignisse, aber jetzt müssen wir unsere Ereignisse
festhalten. Deshalb habe ich hier auch etwas
vorbereitet. Lass es uns durchgehen. Bezogen addEventListener,
und es heißt 11. Wir teilen uns dann hier auf
das Haupt-CPP, dieses. Dieser wird also hier auf einmal
initialisiert. Und dann
drucken wir die Werte auf der Konsole nur
zum ersten Zweck aus. Dann kopiere Paste zweimal
, weil wir verloren haben und eng. letzte. Speichern und hochladen Sie nun die Datei hoch ,
damit wir die Website neu
aktualisiert haben. Wieder einmal, was ist das Problem? Ja. Jetzt funktioniert es, weil der
serielle Monitor geöffnet war. Und danach
lade diesen Fang auch hoch. Usp hat eine Verbindung. Dann machen wir Reese
Refresh Inspect Console, während der Rat
etwas größer ist. Hier sind wir. Und wie Sie sehen können, bekommen
wir hier die Nachrichten. Wenn wir also aktualisieren, verbindet Sie mit P auch
mit den serverseitigen Ereignissen. Warum werden sie hier nicht angezeigt? Dann schicke ich eine Schere. Und hier ist das Ergebnis
des 0-Eingangs das gleiche, aber wir
hören auch das Feedback. Also hat man eng verloren. Wieder einmal würde ich PayPal mit 110
wählen. Dann schneiden wir
hier, ich habe 111 bekommen. Dies sind die letzten 31. Sehr gut. Dies ist aus dem Konsolenprotokoll
auf der Website, damit wir sehen
können, was wir
Schere zu 11 eingegeben haben. Wenn ich einmal die nächste,
die nächste Option, drücke das Spiel wieder von vorne. Und wie Sie sehen können, haben wir
auch diese serverseitigen Ereignisse hier bekommen . Perfekt. Wir senden Werte
an den ESP-Header und das Spiel, das
Glenn-Motoren spielt, und senden
dann die
Werte an unsere Websites zurück. Und im nächsten Schritt, aber wir könnten es ein bisschen mehr schaffen. Ich bin ziemlich dieses JavaScript
und auch mit CSS.
59. Ereignisse vorantreiben: In diesem Stand dieses Projekts können
wir erfolgreich
serverseitige Ereignisse
auf der Website abrufen , aber es befindet sich nur in der Konsole. Und jetzt wollen wir uns bei der ganzen
Sache gut machen. Deshalb
kehren wir zu unserem Haupt-CPP zurück und die Events
schneiden die Ereignisse vom
Hauptspiel bis zum Ende ab. Und bevor wir das Spiel zurücksetzen, schicken
wir
die Events nur
einmal nach dem Spiel hierher . Dann speichern wir
hier das Haupt-CPP und wechseln zu unserem Index-HTML, denn hier
müssen wir ein bisschen hinzufügen. Zunächst einmal schauen
wir uns diese Struktur an. Wir haben hier eine Statistik. Und es heißt Results ist der Klassenname von Archaea
muss es die Nieren nennen. Und weil es ein Klassenname ist. Und wir möchten
hier in einigen Reihen hinzufügen. Und ein Tisch stammt aus einer
Struktur mit einem Rho. Rho ist und t sind Tech. Und wir haben auch einige Spalten, und die Spalten sind mit td
gekennzeichnet. Ich möchte deine
vier Kolumnen haben. Eine Reihe. Die erste Spalte ist
die runde Zahl. Dann wie viele, wie
oft habe ich einen, verloren und eng usw. Deshalb verwenden wir jQuery. Zuallererst
möchte ich hier und Variable haben,
und es heißt TR
Counter, weil ich wissen
möchte, wie viele Stunden wie viele Zeilen ich hinzufüge. Wir werden sehen, warum wir sie brauchen. Zuallererst müssen wir nicht nur
für die Runden erklären, ich möchte eine verloren haben. Dies ist der Header
und auch eng. Okay? Jetzt können wir zu unseren Events
gehen. Und jetzt müssen wir nachdenken. Wir möchten hier am 1. hinzufügen. Zuerst müssen wir das n ausgehend von
einer neuen Zeile
erstellen und dann den
Spaltenkommentar und das Ende, wir haben die Struktur
des Endes der Spalte und der
Zeile noch einmal, zuerst die Zeile beginnt, dann haben wir vier Spalten und dann
müssen wir dort fertig werden. Reihe. Gehen Sie daher noch einmal zu unserer einzigen Veranstaltung. Also zuerst, var row ist, dass
wir mit einem
TR-Ereignis beginnen, und dann kommt es unsere Spalte. Und das wird jetzt per
Chromium an unseren Tisch geschickt. Und der Tisch heißt. Es ist eine Klasse, in der wir
einen Punkt verwenden, zum Beispiel Mr.. Und wir verwenden das
append, weil wir nachträglich
jede Zeile hinzufügen
möchten. Wir analysieren den
Zeilenwertraum, aber wir sind hier noch nicht fertig. Was ist unser TR? Ich möchte mich
mit einer speziellen ID identifizieren und die Idee ist der t, unser Zähler. Also zuerst nur
ein normales Zitat, dann doppelte Anführungszeichen,
damit ich hier
den Raum und die Einblicke hinzufügen kann . Das T D hätte ich gerne
auch. Plus plus. Okay? Ich bin nicht genau hier
, weil hier
die Zeilennummer
plus der Zähler kommt . Das ist also das Gleiche. Die ID ist nur die Kennung für
uns, für die Programmierung. Und hier würde ich
das gerne haben. Hier steht 123 usw. aber ich füge auch hier und Klasse hinzu. Es sind kleine Zahlen und Sie
können es in diesem Stil sehen CSS. Bisher so gut. Dann überschreiben wir unsere
Zeilenvariable und wir senden diese
auch an die TR, die wir hier erstellt haben. Daher Hashtag
plus t, unser Zähler. Also wollen wir
jetzt auf die
ID des neu erstellten
Linienpunkts zugreifen , der eine Zeile anhängt. In der Reihe. Wir erstellen eine neue Kolumne. Und das ist auch bei unklassigen kleineren
Zahlen und Erkenntnissen. Diesen können wir hier
e Daten hinzufügen. Was sind Daten? Daten sind das, was wir in der Konsole
ausgedruckt werden, die wir
durch den ESPN weitergeleitet werden. Und das ist alles was wir brauchen. Ich glaube, dann würde ich das
kopieren. Das Konsolenprotokoll wir sind überschreibt und ich füge hier und
var vor der Zeile hinzu. Und auch hier, der letzte, aber wir sind noch nicht fertig. Das Letzte, weil
wir die Linie schließen müssen. Nah am Licht. Wir haben es hier am
ersten Anfang geöffnet, aber wir wollen es jetzt schließen. Deshalb sage ich die ID
vom TR-Zähler
, den wir zuvor initialisiert haben. Dot anhängen und ein schließendes
Tag für die Zeile. Am Ende muss ich unseren Zähler
für die nächste Zeile
erhöhen. Das sollte alles sein. Ich glaube bisher. Dann schlage ich vor, dass
wir die
Website und die Skizze hochladen. Und mal sehen, was
der Compiler sagt. Usp hat eine Verbindung hergestellt, als wir die Website neu starten oder
aktualisieren. Wie wir sehen können, sind unsere vier
Zeilen oder Spalten hier. Jetzt schicke ich eine Schere. Ich habe einmal verloren, eine zweite Schere, und ich habe das Spiel bereits
verloren, wie Sie hier sehen können. Ich bin verloren. Dann wieder einmal verlor er einmal, eng,
einmalig, eins. Wir haben also nur eine Reihe, weil
wir noch im Spiel sind. Und jetzt haben wir einen. Und so haben wir hier,
dann die nächste Zeile. Also ein kleiner Fehler. Wir müssen unseren
Zähler mit einem und nicht mit 0 initialisieren. Aber hier verlor dann ein anderes Spiel mit Stein einmal, verlor die Zeit. Nächste Reihe. Hat das erste Mal verloren. Eng, eng. Das zweite Mal habe ich einmal verloren als jetzt wechselte ich
zu Papier und habe gewonnen. Das Spiel oder das vierte Spiel, 12 Mal, verlor zweimal einmal
knapp. Also haben wir
hier die serverseitigen
Ereignisse erfolgreich
implementiert und
haben auch eine gute Ergebnisseite
, auf der wir visualisieren können,
wie unsere Ergebnisse sind.
60. LED implementieren: Eine unserer letzten Aufgaben wird es
nun sein , die LED-Klasse zu implementieren. Deshalb gehe ich in
den Hauptordner des vorherigen
Kurskapitels, auf dem die wir die LEDs definiert haben. Und da sind wir los. Wir kopieren und fügen es in unseren
Quellordner ein und öffnen es. Hier sehen Sie, was
wir hier definiert haben. Dann würde ich vorschlagen, dass wir
hier das RPS öffnen, w ist TPP und auch hier in die neuen LEDs dot h.
Und als Exponent würde
ich sagen, dass wir die Header-Datei
überprüfen weil ich in der
Header-Datei bereits am ersten
Anfang umgesetzt. Alle LEDs schalten aus und
schalten alle LEDs ein. Ich würde keine Terminologie sagen. Es ist ein bisschen falscher Name. Es sollten zum Beispiel
Display-LEDs sein. Also dann los geht's, Wide, alle LEDs aus. Und unser Thema von BSW und
MSW lohnt sich Punkt-zu-Punkt. Dieser Deckel. Was stimmt also nicht mit dem? Tut mir leid, nein, es ist okay. Jetzt müssen wir also überlegen, wie könnten wir
hier eine LED-Funktion implementieren , die bei jedem Spiel
aufgerufen wird. Und daher ist es
relativ einfach, weil wir die Funktion
nach jedem Check Player aufrufen. Denn nach jedem Scheck muss
es
im Diskurs unverändert bleiben. Und dann wollen wir auch hier die
Änderung der Punktzahl
anzeigen. Zeigen Sie LEDs an. Und hier machen wir eine einfachere
Funktion, bei der wir sehen können, ob der Spielstand für den Gewinn für 0-Punkte-Score gleich eins ist. Dann zuerst LED auf LLC,
wenn das Spiel eins erzielt. Das heißt also, dass wir verloren haben. Dotcom ist eins zu meiner Schuld. Ich bin derjenige, weil ich zwei
LEDs habe, um zu gewinnen und zu verlieren ,
dann sind LEDs
dasselbe mit Lastschriften. Wenn wir also verlieren, dann wird zuerst LED eingeschaltet und
auch hier die zweite. Wir haben also
keine neuen Objekte initiiert. Der Klassenname lautet „Deckel“. Dann leuchtet
es zum Beispiel, gelb, einer leuchtet und
es ist im Pin 55. Wir haben fünf LEDs. Lassen Sie rote LED lesen, und wir haben blaue. Wir haben zwei Pins. Ich habe den zweiten
gelben unpin 18, den ersten roten auf 17, auf 16, am 19. Und jetzt können wir es einschalten. Also sagen wir spät, gelb, eine Einschaltung. Wenn wir den Spielstand 12 haben, dann hätte ich gerne hier
den gelben zum Einschalten. Spiele wurden abgefangen. Ich möchte, dass die LED
rot die LED 12 einschaltet. Wenn der
Spielstand gleich eins ist, dann wird die große, LED blau oder eingeschaltet. Wenn wir wollen. Bitte nicht nochmal. Oh wow, wir sollten alle
LEDs auf LED zurücksetzen ist aus. Das ist einfach. Wir rufen nur jede
der LEDs an und schalten sie aus. Und wie könnten wir
das mit dem Ausschalten machen? Und SEM erinnert sich vielleicht daran, dass wir hier ein Analog haben. Wir prüfen, ob wir die LEDs
eingeschaltet haben, welche AnalogWrite
immer digital
ist, was wir
mit Digital eingeschaltet haben, oder? Das ist der Grund, warum wir hier
reingehen und falsch sind. Danach
gehe ich zum Spiel zurücksetzen und rufe an, dass alle LED ausgeschaltet ist. Das sollte
alles sein, was wir für unsere
Anzeige der LED
brauchten. Mal sehen, was
der Compiler sagt. So wird der ESP geblitzt schaltet die Kamera ein,
damit wir
hier unser ganzes Bahrain sehen können . Und nur die Berichte, dass mein Router meinen ESP
mit dem
Ehefrau-Team verbinden ließ . Jetzt sind wir bereit. Jetzt kann ich hier
zum Beispiel Stein wählen. Und die rote LED geht weiter
, weil ich verloren habe. Dann
habe ich wieder zweimal verloren n, es wird sofort verschwinden. Dies ist der Grund dafür, weil wir nicht
unter seinem Haupt-CPP stehen. Wenn wir
hier alles in
der Schleife zurücksetzen , könnten wir
hier und kurze Verzögerung definieren. Zögern Sie beispielsweise
drei Sekunden. Es ist okay, dass wir
hier benutzen und verzögert haben, weil das Spiel, wenn es fertig ist, nichts tun
sollte. So könnten Sie zum Beispiel die Skizze
hier noch einmal aktualisieren . Aber ich behalte es hier und teste hier
nur die LEDs. Jetzt haben wir fest, also funktioniert die blaue LED auch. Dann habe
ich beim zweiten Mal noch einmal verloren. Ich habe 111, habe zu eng verloren
und wir sind fertig. John, auch unsere LEDs funktionieren
sehr gut auf schnelle Weise. Wir haben hier
solche Klassen implementiert und Sie können hier auf
verschiedene Arten
von Funktionen zugreifen , wenn
Sie möchten. Und das gibt uns jetzt
einen guten Überblick über das Potenzial des
objektorientierten Weges.
61. Deine eigene Bibliothek erstellen und veröffentlichen: Wenn wir also
unsere eigenen Klassen erstellt haben, möchten Sie
vielleicht auch Unterricht mit anderen teilen und bieten . Dies könnte mit einer
fertigen Bibliothek geschehen. In diesem Video möchte
ich Ihnen zeigen, wie wir uns von einer
Bibliothek aus einrichten können und wie
Sie sie teilen
und arduino, EDA implementieren können . Und Stefan. Ich bin hier auf meinem Windows-Computer. Ich bin in den Ordnerdokumenten,
Arduino und Bibliotheken. Dies ist der Standardordner, und es ist auch für
die Arduino-IDE auf 0 und auch für die späteren
Versionen geeignet. In dieser
Ordnerstruktur erstelle
ich einen neuen
Ordner und nenne ihn zum Beispiel Pixel-LEDs. Und jetzt kopiere
ich in diesem Ordner und füge ein. Hier. Lass mich sehen wo ich bin. Bilden Sie unsere fertige
Skizze aus den LEDs. Lass mich die LED-Quelle sehen. Ich komme hier zurecht. Alles trotzt Erkenntnissen. Dieser Hauptordner
und das Haupt-CPP, ich füge es hinzu, der Name oder
zum Beispiel, jagen LEDs sind nicht cpp. Ich ändere zu ignorieren
, weil wir
die Bibliothek zum Arduino-EDM hinzufügen möchten . Dann erstellen wir einen Ordner für die Beispiele, die als Beispiele bezeichnet werden müssen
. Und dann ziehen wir diese Datei per Drag &
Drop in diesen Ordner, den wir
im Unterordner erstellt haben. Es sollte denselben
Namen wie die Datei haben. Zum Beispiel. In dieser Datei öffne
ich in diesem Ordner die Inode-Daten und wir müssen uns anpassen, etwas
hören. Zuallererst müssen wir
hier einige Knoten hinzufügen ,
die lizenzieren usw. Wofür dient diese Bibliothek? Wofür ist dieses Beispiel? Das erste, was
wir tun, ist hier, dass
wir die Zitate
in diese Wissenschaft ändern, denn jetzt müssen wir die Bibliothek in
den Bibliotheken noch nicht
abgeschlossen haben. Das größer und weniger als Zeichen. Das ist alles, was wir tun müssen. Dann räumen wir unseren Code ein
wenig auf. Vielleicht fügen wir hier
ein paar Kommentare hinzu. Werden Sie einfach all
diese Beispiele los. Lass jagen. Und wir könnten hier
zum Beispiel die Beispiele sagen . Sparen Sie es. Und das ist bisher gut für uns. Springen wir zurück zum Ordner. Hier sind meine CPP und LEDs dot h. Das möchte ich hier haben. Nichts mehr was ich hinzufügen möchte. Aber eine einzige Sache
sollte getan werden. Und das ist unter Eigenschaften von
Bibliothekspunkten. Lass es uns öffnen. Hier. Sie können beispielsweise Ihren
Namen definieren, oder der Name der Klasse
sollte den gleichen Namen wie
die Photonenumleitung oder
die Outdoor-Wartung haben. Ein paar Beiträge sind
Dinge welche Kategorie und auch welche Abhängigkeiten in deiner Klasse enthalten
sind. Dies gibt Ihnen einen guten Überblick. Es gibt
noch viel mehr Dinge zu tun. Zum Beispiel Schlüsselwörter
, die beim
Bibliotheksmanager
gefunden werden usw. Aber ich möchte es
hier sehr einfach halten, damit Sie sehen
können, was wir hier tun möchten. Die äußere EDA braucht meine
Maschine immer ein wenig Zeit. Jetzt werden wir skizzieren, Bibliothek
einschließen und
zu Contributed Libraries gehen. Und es sollte
hier Darstellungen geben Lady Lids. Perfekt. Dann sage ich ja, denn jetzt nach einem vollen
Zugriff nach dem Unterricht, lass uns meine LED Deckel sind. Zum Beispiel verwende ich
hier die Bar Fünf Kopie. Dieses Leck könnte beispielsweise
zum Beispiel 18 sein. Dann schalte ich
meine Leads ein, um einzuschalten. Und in der Schleife sage ich
meine LED-Kreuzzüge, 20. Meine LED zu. Gibt es dann einen vollständigen
Vorschlag? Lass mich sehen. Wenn es auch auf
Yeah funktioniert, los geht's. Ich hätte gerne nach Verzögerung
ausgeschaltet. Wir haben zwei Millisekunden. Ich möchte die
zweite LED und fünf Sekunden ausschalten. Und es ist falsch, weil wir
kein Analog haben, oder? Sehr gut. Jetzt möchte ich dieses hochladen. Ich habe deine Nodes
23 benutzt und lass uns
das Ganze hochladen. Los geht's, schalten
die Kamera ein, haben wieder neu gestartet. Also haben wir hier
die LED pulsiert. Dieser sollte nach
fünf Sekunden losgehen. Sehr gut. Und wir haben erfolgreich
unsere eigene Bibliothek in
der Arduino-IDE
implementiert . Jetzt können wir auf sehr
bequeme
Weise darauf zugreifen und Sie können Ihre Bibliothek an andere
weitergeben. Aber wir sind noch nicht fertig. Wir haben hier auch
ein Dateibeispiel. Dann gehen wir runter. Und es sollte auch das
Beispiel zwischen eingeschlossen geben. Los geht's, weil
Lydia LEDs jagt. Lasst uns das öffnen. Hier. Wir sollten das
Beispiel von früher mit all unseren Akten und mit
dem Beispiel perfekt haben. Und diese Geschenke auch andere Entwickler und
gute Insidersicht, was sie
mit Ihrer Bibliothek machen können. Mal sehen, wo sind, wo wir hier
unter Bibliotheken sind. Du könntest also auch auf diese
heilige Mappe gehen und ihn eine SIP-Datei schlürfen. Und dann können Sie es
zum Beispiel auf GitHub teilen ,
oder Sie können sie senden, um sie auf diesem Entwickler
zu
entwickeln, kann zu Sketch,
Include Library
in einer SIP-Bibliothek gehen Include Library
in einer SIP-Bibliothek und dann das Ganze -Bibliothek wird auf dem Medium installiert. Dies ist auch eine bequeme
Möglichkeit für andere, Ihre gesamte Einstellung, z. B.
für die Bibliothek, zu implementieren . Und das war's bisher. So können Sie auf einfache Weise Ihre eigene Bibliothek erstellen einfache Weise Ihre eigene Bibliothek und diese anderen zur Verfügung stellen.
62. Zusammenfassung der Erkenntnisse: Wir befinden uns jetzt am Ende
dieses Online-Kurses und ich möchte mir ein paar Minuten
Zeit nehmen um alle Erkenntnisse zusammenzufassen , die wir in
diesem Online-Kurs gemacht haben. Zunächst einmal werden
wir
ein wenig über die Grundlagen diskutiert . Was ist eine Aufzählung,
was ist Instruct? Was sind die verschiedenen
Arten von IDEs? Was wir haben die Arduino IDE, Visual Studio Code,
diese Plattformion. Wie können wir den
Code vom Arduino bis zum Visuals Code
und umgekehrt verwenden. Dann haben wir eine
kurze Einführung in die objektorientierten Grundlagen gemacht. Wir werden
darüber diskutiert, wie wir ein leeres Projekt
einrichten können . Was ist die Hauptklasse? Was ist das Konstrukt? Was ist ein Konstruktor
und die Initiation
eines Objekts, das wir auch Konstruktoren
überladen können,
Konstruktoren die Hauptfunktionen,
die erste Funktion, wenn wir ein Projektobjekt
initiieren. Und wir können
verschiedene
Arten von Konstruktoren zur Verfügung stellen können. Dann haben wir auch über
grundlegende Funktionen als
Getter und Setter diskutiert . Mit öffentlicher Funktion können
wir also auf private Mitglieder zugreifen. Das ist die Datenkapselung. Und wir haben auch über
Vererbung gesprochen, damit es uns
leicht ist , zu bearbeiten
und die öffentliche Bibliothek zu bearbeiten. Dann haben wir mit der
ersten einzelnen LED-Klasse angefangen. Das heißt, wir hatten viele LEDs
und zur gleichen Laufzeit oder demselben Lebenszyklus
konnten wir hier auf
verschiedenen Arten von LEDs
gleichzeitig steuern . Dies ist nur objektorientiert möglich. Wenn Sie das in einer
funktionsorientierten Arbeit tun würden, Sie viel mehr Barrieren benötigen
, ist dies möglich. Wir sind auf LEDs umgeschaltet, die wir gemacht haben, und verzögern
nach acht Sekunden. Wir sind im Pulsieren verblasst. Und wir greifen auch mit einem Array
darauf zu. Das sind also vier wie möglich,
um viele,
viele LEDs gleichzeitig zu steuern und aufzurufen . Eins vom nächsten Projekt sind
wir beim Galton-Vorstand. Wir hatten auch viele verschiedene Arten von Sensoren
in dieses Projekt einbezogen. Und es war einfach für uns, ein Array zu
erstellen und es zu initialisieren, zu
steuern,
die ER-Sensoren zu initialisieren. Und dies gibt uns auch
die Möglichkeit, schnell
und flexibel mit verschiedenen
Arten von Eingängen von Sensoren zu arbeiten . Ein Hauptprojekt war
auch der Scheinwerfer. Wegen der Reduzierung
unserer Eingänge werden
mit nur einer Taste gesteuert. Es war die Herausforderung, drei verschiedene
Arten von Lichtmodellen implementiert zu
haben. Also sagten wir einen kurzen Atemzug, wir umgesetzt haben,
schalten Sie es einfach ein und aus. Die erste LED. Als wir einen Knopf
für den Kreisverkehr 1 Sekunde gedrückt haben. Dann
geht das zweite LET an oder aus. Und wenn wir den Knopf
gedrückt halten ,
um Licht in die Technik zu erhalten, ernähren
wir uns von den ersten LET all Sweet Lite-Modellen, die gleichzeitig über einen
Knopf
zugänglich sind. Das ist nicht wirklich praktisch. Beispiel, weil wir
oft nur
einen Input haben , aber
mehr als einen Mody benötigen. Und das könnte ein
Beispiel aus dem realen Leben sein. Letztes Projekt haben wir
das
Rockpaper-Scherenspiel implementiert , neu erstellt und wieder
Modi in der objektorientierten
Art und Weise, die wir hier anrufen, und Webserver hat
die
Kommunikation vom Webserver zum
Webserver gemacht mit dem ESP. Und Sie könnten auch in
diesem Beispiel sehen, wie einfach es ist, mehrere
Zellen mit einem Array zu steuern. Und dies gibt Ihnen noch
einmal die
Möglichkeit , die
elektrischen Komponenten und
mechanischen Komponenten
dieses Smiths auf einfache Weise zu interagieren . Also haben wir uns auf die
Hardwareseite konzentriert, auf die Softwareseite. Und ich hoffe, ich kann Ihnen
das volle Potenzial des
objektorientierten Objektes zeigen .