Transcription
1. Introduction à ce cours: Introductions et approche
orientée objet avec Arduino et ESP. Bonjour et bienvenue dans
ce cours en ligne. Je suis sorti parce qu'il sait que je suis un développeur senior dans
l'environnement de laboratoire, mais aussi dans les systèmes embarqués. Dans ce cours en ligne,
je suis en train de suivre l'approche
pratique que nous construisons ensemble certains projets. Tout d'abord, nous parcourons
la théorie au minimum, mais nous mettons également en œuvre
dans le premier chapitre, les premières classes
et
imprimons code sur le moniteur série. Dans l'exemple suivant, nous contrôlons les LED à l'exécution à différents
types d'états. Et c'est
l'un des principaux avantages de l'
approche orientée objet que nous pouvons éditer et ajuster
ici beaucoup de choses avec différents
composants en temps réel. Ce que je veux dire avec différents
états en même temps. Nous avons également affaire
à d'autres composants, par
exemple les capteurs infrarouges. Alors, lorsque nous disposons de dix capteurs
ou plus, comment pouvons-nous les évaluer ? ce que nous lançons. Vous faites cela avec
un tableau, par exemple. Et je vais vous montrer comment
nous pouvons les contrôler et les évaluer de manière
facile et pratique. Dans l'
environnement Arduino lorsque nous
développons des systèmes embarqués
avec microcontrôleurs. Nous devons également faire face à
une utilisation limitée dans les livres. Et c'est l'un de nos deux
prochains exemples. Nous sommes en train de créer une lampe frontale. Cette lampe frontale n'a qu'une seule pression. Ce bouton-poussoir. Nous contrôlons trois types
différents de voix de lumière. Le premier est un raccourci car le bouton
s'allume. Le deuxième. Nous appuyons sur
le bouton pendant une seconde, seconde, LET continue. Si vous appuyez sur le bouton et le
maintenez enfoncé pendant
plus de deux secondes, la première LED s'adaptera
à notre dernier exemple. Nous fabriquons les ciseaux de papier rock classique avec plusieurs moteurs et recréons
nous-mêmes la logique du jeu d'une manière orientée
objet. Lorsque vous souhaitez amener votre
propre code source
au niveau supérieur pour écrire et
nettoyer le code et aussi de manière
plus structurée. N'hésitez pas et
attendez plus longtemps et
obtiens cette classe et ce code avec moi
de manière orientée objet. J'ai hâte de
vous accueillir dans ce cours en ligne.
2. Expérience pratique ou théorie: Avant de commencer par
la partie programmation, j'aimerais me concentrer
sur un sujet majeur. Cela signifie
une expérience pratique par rapport à la théorie. Je suis conscient et je suis sûr
que beaucoup d'entre vous possèdent nombreuses années d'expérience dans codage et dans le
développement de programmes. Mais ici, dans ce contexte, j'aimerais être un
peu plus ouvert d'esprit. Cela signifie que vous avez, bien
sûr, votre propre
approche de certaines choses. Et peut-être que vous vous
demandez pourquoi
compliquez-vous cela ? Il y a sûrement une autre
façon de mettre en œuvre des pièces de codes aussi petites, par
exemple, c'est correct. C'est tout à fait correct. Vous pouvez vous adapter à
toutes mes versions à votre approche et également
implémenter individuellement pour vous. Il y a toujours des
discussions en cours en ce qui concerne les langages de
programmation, lorsqu'il s'agit de mettre en œuvre des données codées à la
source. Et ne prenez pas trop au sérieux, soyez ouvert d'esprit et
adaptez-le à votre approche.
3. Prérequis pour ce cours: Conditions préalables. Que puis-je supposer que
vous apportez à ce cours en ligne que j'ai recueilli ici
quatre points majeurs ? J'aimerais être
ici très transparent. Ce que vous pouvez attendre, cela annule cours
en ligne et
ce qui n'est pas couvert. Le premier sera, bien sûr, que vous devez apporter quelques connaissances
de base en programmation. Cela signifie que vous devez connaître les différents types
de données. Vous devriez savoir ce qui est un
si c'est au niveau des connaissances fondamentales et de
base de la programmation, connaissances fondamentales et de
base de la programmation car cela n'est pas
vraiment couvert ici. Bien sûr, j'ai expliqué ce que je fais dans tout décodage,
puis dans le code source, mais il n'y a pas de
connaissances approfondies derrière cela. La deuxième partie est également que je couvre tous les schémas de
câblage, etc., sur l'ESP 32. Bien sûr, tous ces
objets sont endettés. Le code source est applicable
à l'environnement Arduino. Néanmoins, si vous utilisez une unité
externe, normale n, nano, etc., c'est toujours
le même concept, le même code source. Mais sachez que j'utilise l'ESP 3200 car il dispose d'
une connexion Wi-Fi. C'est très bon marché et vous pouvez l'utiliser pour les appareils Internet
des objets. Mais il s'applique également à
l'environnement Arduino. J'utilise Visual Studio Code avec le sang pour le blocage
masculin. Et c'est un
peu différent de
l' EDI de l'union originale, mais vous pouvez l'utiliser. Ce n'est pas grave parce que le code
source est C plus et fonctionne dans presque
toutes les
programmation, programmation, laquelle utiliser. Je vous ai également montré
comment utiliser mon code source et implémenté
dans l'EDI Arduino. La dernière, je pense également que
l'un des points majeurs est que vous
devriez vous intéresser à une programmation orientée objet car au tout
premier début, elle vous
ressemble un
peu plus sur le code source,
plus de lignes de code. Mais quand vous
parcourez les exemples comme ici sont les
LED qu'il peut voir les principaux avantages lorsque nous codons avec une
manière orientée objet parce que nous sommes
plus flexibles, nous pouvons nous adapter à
certaines situations et nous pouvons créer des programmes
vraiment très sympas
avec différents types de composants de manière
simple et rapide. Et c'est pourquoi j'aborde ce point parce qu'
au tout premier
début, nous écrivons, on dirait que nous
écrivons plus de code, mais c'est
plus pratique, plus réalisable, plus adaptable.
4. Avis de non-responsabilité: Quelques réflexions sur
la clause de non-responsabilité. J'ai essayé d'être aussi prudent que possible en
matière de cinématique. Et la source
va être précise et la regarder encore et encore. Mais je ne suis pas libre
de toute erreur. Cela signifie peut-être que
j'ai fait une erreur sur les parties de Bahreïn et que vous
rassemblez tout. Et puis l'USP fait par exemple, une compétence automobile sera
endommagée ou pire encore, elle pourrait être brûlée. Parce que souvent, lorsque vous
assemblez les
composants de manière forestière, ils sont devenus
vraiment, vraiment chauds. Et cela
pourrait aussi se produire
à la pierre brûlée. Cela peut aussi se produire si vous grandissez en
circuit ouvert. Il y a un danger de vie. Il pourrait être assuré
de plusieurs façons. Soyez toujours actif sur le
pod Byron et la partie de codage. B aussi très, très réfléchissant lorsqu'il
s'agit de différents types
de composants. Par exemple, je n'ai pas l'USP 32, qui a des pinouts légèrement
différents. Peut-être que votre ESP a commencé E2F. Ainsi, lorsque nous connectons
le virus ensemble, vérifiez
toujours les GPIO, les données relatives à la peine de mort. Soyez conscient de ce que nous faisons
implémenté et adapté
à vos propres versions. Je ne peux pas vous garantir que
tout ce que je vous montre
fonctionnera sur votre système car il y a
trop de composants
et d'approches différents ici à l'extérieur. Mais dans mes vidéos précédentes, il est très simple de suivre ou d'être conscient des risques, et nous
obtenons alors un bon résultat.
5. ESP32 Pinout: Quelques mots sur le
thème de la cacahuète. Comme vous le savez peut-être,
un objet de stratégie de groupe ou représente entrée et une sortie à usage
général. Cela signifie que nous pouvons utiliser, par
exemple ici, le GPIO
numéro 27 comme entrée. Nous avons donc ici dans le
capteur pur détecte les mouvements. Et lorsque le mouvement est détecté, nous pouvons envoyer et signaler
ici la broche 27. Mais dans un autre exemple,
il y avait l'outil d'étude I-SPY. Nous pouvons également utiliser la broche GPO, broche 27 comme sortie. Cela signifie qu'il
allume une LED, par
exemple, que la LED
sera charnue ou clignote. Par conséquent, nous devrions
également savoir qu'il n'
y a pas de brochage et de GPO P, et cela dépend de quelle entreprise, fabricant et utilisez-vous ? Je l'utilise à partir de la livraison AC. Et comme vous pouvez le voir ici, c'est le brochage pour ESP
32 à partir d'une livraison définie. Et c'est un peu
différent des autres fabricants. Par exemple, ici, je
n'ai pas de connexion au sol. Cela signifie toujours
vérifier votre P-Naught. Néanmoins, s'il s'agit
d'une certitude ESP, ils ne sont pas toujours les mêmes. Vérifiez que l'objet de stratégie de groupe référencera
la référence de brochage afin
que vous puissiez être sûr que cette épingle sera nécessaire pour ce dont vous avez besoin. Par exemple, ici, je n'ai
pas de broche de terre ou la broche 3534
ne sont que des entrées. Nsc est d'autres 32 qui n'ont également 3232
que comme entrée déclarée. Nous avons des jeunes utilisés
pour le flash interne, jamais recommandé pour d'autres
utilisations, les jaunes. Soyez donc conscient des
différents types. Nous avons également utilisé
des épingles tactiles. Nous avons également des convertisseurs
AD, AD et DCM pour que nous puissions transférer des
signaux de ces données. Cela est également toujours
nécessaire lorsqu'il
s'agit s' câblage de parties de différents GPO
prenant en charge la tuberculose, différents types d'ESP ont
différents GPIO et broches. Et puis,
espérons-le, nous pourrons avoir un bon schéma de câblage et
pouvoir également l'implémenter.
6. Code VS vs Arduino IDE: Pourquoi devriez-vous changer l'Arduino EDA en
Visual Studio Code ? Et il y a une réponse plus simple
que vous n'avez pas à faire. Je voudrais vous montrer
ici mon opinion,
comment vous, quel est le flux de travail ? Pourquoi ? Je pense que Visual Studio Code est un peu plus
pratique lorsqu' il s'agit de décoder la routine
quotidienne. Sur le côté gauche, je l'
ai vu dans votre ED50, Python 2 en dessous, j'avais dit que ce sont des coordonnées Visual
Studio. Vous pouvez voir qu'il est très
similaire dans la superposition visuelle, mais il se trouve dans le noyau et le compilateur était dans
une courbe de vitesse. Et lorsque nous le compilons, il y a beaucoup de différences. Je ressens le premier exemple que nous traitons ici
dans ce cours en ligne, c'est faire ici les LED
avec des objets datées et je vais
vous montrer 1 première chose. Par exemple, si je clique ici sur compilation et que je clique sur le côté
gauche du compilateur, peux voir que la littérature, le code nécessite 1,7 seconde.
Je n'ai pas bien cliqué dessus. Encore une fois, ajouter un nouvel EDA. Cela prend deux fois plus de temps, peut-être troisième plus de temps. Et ce n'est pas tellement nécessairement quand nous n'avons pas vraiment implémenté
des bibliothèques tierces, mais quand nous le faisons plus tard, elle craint 678 bibliothèques externes, alors vous reconnaissez vraiment
et différence significative dans les vitesses de compilation entre le
rond-point de 20 secondes et
plus d'une minute dans l'ARN. Et c'est vraiment ennuyeux
quand on fait juste courte erreur d'orthographe. Et aussi, la vitesse lorsque nous
sommes pris est différente. Par exemple, je crée
l'objet rouge dans le constructeur et nous
transmettons la valeur. Ensuite, nous nous lançons
dans la configuration juste pour vous montrer la différence. Ensuite, je tape ici
deux points rouges et je vois toute la fonction que j'ai implémentée dans la classe
que nous traitons plus tard. Par exemple, je clique
sur des crochets de chair ,
puis je vois que je
dois entrer un entier. Même exemple ici,
le même flux de travail, mais un peu différent. Deux points rouges. Rien ne se passe. Je vais attendre. Et j'espère que quelque chose s'
ouvrira avec le contrôle et l'espace. L'Arduino il y est chargé. Toutes les
fonctions nécessaires. Maintenant, je l'ai. J'aimerais définir la chair et T
m'a collé en retard entier,
ok, est déjà sélectionné pour que je puisse la remplacer
par 500 par exemple. Et c'est fini. dirais pas vraiment vite. Mais bien sûr, vous pouvez le
faire à un autre exemple. Ainsi, lorsque nous avons ouvert l'année la
fonction de sagesse de l'objet, nous pouvions appuyer sur la touche Ctrl
et la souris gauche. Et puis il devrait sauter
à la classe elle-même. Ici. Étiquette très facile ici. Et ici, il n'a pas été chargé. ne sais pas si je suis maladroit ou
s'il n'a pas déjà été chargé. Je ne l'ai pas remarqué. contrôle. Je ne sais pas. Cela devrait fonctionner, mais pas aussi vite que dans Visual Studio
Code. Maintenant, c'est fini. Comme vous pouvez le constater,
Sandberg circule
un peu différemment
dans les vitesses de réservation. Aussi sur leur
histoire visuelle, courtisane, mon opinion et
mon grand porteur dois-je sauter la distorsion
que voici mon espace de travail. Du sang indien, très
bon gestionnaire de dépendances. Là, vous devez
dire, par exemple, que je voudrais mettre à jour
AnalogWrite. Je voulais avoir deux
versions 1.2 et toutes les versions précédentes. Quand il y a une nouvelle version d'art, j'arrive à la mise à jour. Tout de suite. Je pourrais définir le framework à la partie de téléchargement et
aussi au port du moniteur. C'est-à-dire que lorsque je
télécharge le code, il sera ouvert sur un certain moniteur sur la même plate-forme de données de port. Tout doit également détecter
automatiquement le rapport. Mais ici, je l'ai
configuré parce que souvent j'
ai plus de deux Arduinos
connectés à mon PC. J'aimerais donc qu'
il soit codé en dur ici. Aussi parce que j'utilise beaucoup
d' espace et peu de gestion
FS. Et donc également dans
leur plateforme i o, nous pouvons créer l'image du
système de fichiers et télécharger des fichiers de la recherche du fonds vers
le code, vers nos ESP. Et c'est nécessaire
lorsque nous voulons interagir. Par exemple, l'ESP 32 peut comporter la moitié et
un serveur Web. Lorsque nous construisons un site Web, nous pouvons mettre
en place pour étalonner quelque chose
ou ajouter
certaines, certaines valeurs, par exemple, comment devrait-on
le définir pour nos autres exemples ? Sans nouvelle EDA, nous devons installer
des composants tiers. C'est un peu, oui, pas,
pas intuitif et facile à utiliser. Code Visual Studio.
Il y a beaucoup de choses intégrées. Et encore une fois, la vitesse est vraiment une autre dimension. Quelques
vues d'informations seulement lorsque vous souhaitez passer à
Visual Studio Code. Il y a beaucoup de
bonnes vidéos
YouTube où vous pouvez faire
vos premiers exemples. Je vais décrire et montrer comment j'ai mis en place les projets de
ce cours. Mais je ne vais pas approfondir toute la mécanique
de Visual Studio Code. Justin réclame d'abord le dédié pour que
vous ayez un aperçu.
7. Code source de VS Code dans Arduino IDE: Dans cette vidéo, nous
expliquons comment transférer les codes, le code source
du Visual Studio Code vers l'Union Arduino EDA. J'ai certainement un exemple. C'est l'exemple
de la LED dès notre premier saut vers le bas et en supposant que nous en ayons
déjà fini. Et vous voulez maintenant
transférer ce genre de codes. Sur le côté gauche se trouve l'
Arduino IDE version 2. Et sur le côté droit
après Visual Studio Code avec la plateforme blogging. Et comme vous pouvez le constater,
ils se ressemblent beaucoup, mais ils sont dans le noyau et le compilateur
est un peu différent. De plus, le Visual Studio Code est beaucoup plus rapide lorsqu'
il s'agit de combiner. Vous pouvez donc voir ici
la structure
du projet et vous pouvez voir
qu'il y a quelques photos supplémentaires, ces deux éditées IF, mais comme les autres photos
sont toujours dans l'Oresteia, même lorsque vous
créez une nouvelle projet. Deux proviennent de Visual Studio Code. Ce qui est intéressant pour nous, c'est le dossier source et nous avons trois fichiers Sui majeurs, c'est
LEDs dot CPP et LEDs dot H. Ce sont la classe
et la classe est également 100% compatible
avec l'IDE Arduino. Et puis vous voyez le point principal CPP. Et son principal CPP lui
est notre dossier principal, et c'est notre dossier intérieur, que vous pouvez voir ici. Jusqu'à une brève introduction. Et maintenant, nous sommes en train de sauter
dans un explorateur et de sauter directement
dans ce dossier. Voici mon projet. Encore une fois, les différents types de projets, je clique sur les LED, comme vous pouvez le voir, la même
structure qu'auparavant. Cliquez sur la source. Maintenant, je copie les fichiers
dans un dossier. Supposons qu'il s'appelle
0.1 afin que nous puissions maintenant le copier, le coller ici. Nous pouvons donc avoir un sous-dossier. Et maintenant, nous avons renommé le fichier main.cpp. Cliquez avec le bouton droit de la souris dessus, changez
le nom pour exécuter le point. Débarrassez-vous du RPC. Et oui, maintenant, nous avons changé ici. L'extension maintenant dans
notre copie multimédia, le chemin. Va les voir. Fichier ouvert. Allez dans le dossier que
nous venons de créer et nous ouvrons le fichier
que nous avons renommé. Une nouvelle instance sera ouverte, basculant vers la gauche. Et ce que j'aimerais vous
montrer maintenant, c'est que c'est pourquoi j'ai choisi cet exemple car ils ont différents
types de compilateurs. Compilons-le dans
Visual Studio Code. C'est exactement ce code. Et ici aussi, j'ai dit
que ça doit être 32. S'agit-il d'anciennes bibliothèques
chargées ici. Si une
bibliothèque tierce est incluse, vous pouvez la télécharger depuis
la bibliothèque ou le gestionnaire, mais dans ce cas, nous
n'en avons plus besoin. Ensuite, nous allons ici
pour le compiler. Et comme vous pouvez le voir ici, le code Visual Studio
a réussi à compiler le code. Mais ici, l'IDE Arduino est un peu plus strict, et vous pouvez
le voir, le message d'erreur est
appelé tableau doit être initialisé avec l'initialiseur d'
enclose accolade. Et c'est que je ne l'ai pas
fait dans le code Visual Studio. Par conséquent, nous n'
avons qu'à décommenter ces lignes et
, bien sûr, nous allons traiter le
contenu qui s'y trouve plus tard, mais nous devons initialiser tous
les objets, par exemple. Une fois de plus, recompilez-le. Et comme vous pouvez le constater maintenant, prend un peu
plus de temps que Visual Studio Code. Il l'a
toujours combiné. Maintenant, vous pouvez télécharger l'esquisse sur
USBE, par exemple, et vous avez le même code avec la remise
à neuf créée sur la cour, mais l'a adapté à
l'Arduino EDA. Encore une fois. s'agit là d' un peu de différences
dans la compilation, mais en général, 99 %
seraient mis en œuvre. Vous pouvez l'implémenter dans
votre edi déjà en cours, qui provient de
Visual Studio Codes. Et encore une fois,
essayez simplement d'
utiliser Visual Studio Code. C'est beaucoup, beaucoup plus rapide
dans la compilation. De plus, je pense qu'il est un
peu plus pratique de
coder car il y a beaucoup de bonnes fonctionnalités clés au lieu
de Visual Studio Code, que vous pouvez l'utiliser dans votre vie
quotidienne de programmation.
8. Simulateur en ligne: Lorsque vous le faites, au cours de
votre processus de codage, c'
est souvent le cas où vous
souhaitez tester certaines parties logiques, juste quelques lignes de
code ne pas avoir à compiler le code
entier encore et encore. Par conséquent, certains simulateurs
en ligne sont vraiment pratiques car alors vous prenez le Dakota
collé dans le concours. Que peut We.com ? projets informatiques similaires dans votre
navigateur sont à mon avis, ne sont
vraiment pas un bon moyen
et une bonne simulation est faite. Parce que vous avez ici, pouvez utiliser la certitude ESP
pour cliquer dessus. Et puis vous avez ici
le simulateur en ligne. Et la bonne chose
ici, c'est que vous pouvez également ajouter certains composants, certains composants, une partie
électrique, mais aussi des bibliothèques
externes. Et vous pouvez également coller ici vos classificateurs
afin de tester votre projet entier
dans un simulateur. Donc, premier exemple, je
vais créer ici, la LED, connectée à une commande
avec, par exemple, 25 à GPIO sur la
cétotique va au sol. Ensuite, la broche LED est de 25. Il s'agit du même mode PinMode. Eux, PinMode. Goupille LED. Faux. Sortie. Dans la boucle. Nous sommes en train de retarder. Non, ce n'est pas le meilleur moyen, mais c'est juste à des fins de
test. Ensuite, nous allons cliquer sur assimiler. Et la bonne chose ici, c'est aussi lorsque nous commençons
à le voir commencer, nous devrions également voir ici la console, la communication
sérique. Et comme vous pouvez le voir, nous
pouvons parfaitement vous entendre. Testez également les composants et comment contrôler
les composants ainsi notre code si nous avons
un code propre ou non. Walkway.com, un bon simulateur
pour tester votre code.
9. Enum: Dans les chapitres suivants, nous fabriquons des codes
et du code source et
du personnel un
peu plus complexes que nous
voulons également vérifier dans quels états nous
traitons actuellement. Par exemple, lorsque nous
développons et nous
jouons, alors nous voulions savoir si nous
attendons la participation des utilisateurs, avons-nous fini de jouer ou jouons actuellement,
calculons quelque chose. Et souvent, cela se
fera avec flex. Par exemple, vous
pouvez définir ou déclarer,
dans ce cas, une
variable de pool, par exemple, l'attente d'état est
fausse ou la salle de bal. Commencez. Le jeu est vrai. Ensuite, dans la boucle, vous
pouvez le vérifier avec un IF. Et en ce qui concerne les états, vous pouvez calculer quelque chose,
oh, attendez, pour les données d'entrée de l'utilisateur. À mon avis, il existe un
autre moyen plus pratique lorsqu'il s'agit de vérifier
les états dans C plus plus. Et donc j'utilise
vraiment souvent enum. Enum l'est, à quelques égards. Je pense que c'est la meilleure
façon de choisir. Non. Cela se reflète parce qu'
avec les énumérations, vous avez une variable. Dans ce cas, un statut. Environ trois états sont combinés. Cela vous donne donc une bonne vue d'ensemble du nombre d'
états que vous avez définis dans votre programme que vous
pouviez traiter.
L'état est un modèle par exemple. Et vous pouvez également l'imprimer,
imprimer l'état de la ligne. Mais maintenant, vous n'obtenez plus ici et une chaîne parce que ce n'
est que le nom de la variable, cela signifie
que nous obtenons
ici
0 car c'est 0 index lorsque nous sommes
en pause, puis nous obtenons et un, cela signifie que le compilateur choisit le bon type de données dans l'énumération, car vous pouvez également déclarer
ici d'autres choses. Mais je ne leur donne pas de valeur, ne fais que définir l'état. Et c'est ce
que je pense que c'est vraiment pratique
dans la programmation. Prenons un exemple un peu plus pour voir ce que je veux dire ici. Tout d'abord, j'ai dit
l'état normal et nous
imprimons l'état. Ensuite, au tout premier arrêt, j'aimerais définir le prototype de
fonction car il est vraiment trouvé plus tard sur le bouton de vérification de la fonction
ET. Nous simulons donc
quelque chose comme si notre programme attend un clic de Pattern ,
puis nous
changeons les états. Des millions gratuits parce que
j'aimerais
changer au bout de deux secondes pour y
rester automatiquement. C'est pourquoi j'ai implémenté sans délai
la logique Blink. Je suis sûr que tout le monde s'en est
déjà pris. Et si ce n'est pas le cas sur Google
Blink sans retarder. Par conséquent, nous sommes assis
ici au milieu des années. Et après deux secondes, j'aimerais changer l'
état en fatigue de statut, par
exemple, nous venons de
terminer le bouton de vérification. La toute fin. Par exemple, je rends
l'état normal. Voyons donc voir. Nous démarrons le programme Debra Thompson pour
configurer les C de configuration. Nous sommes en train de changer l'état
pour commencer normalement. Je dirais que le conjoint pour l'épouser nous
imprimons le premier état, puis on saute
dans le bouton Check. L'état sera modifié
pour commencer normalement. Au bout de deux secondes, l'état
sera remplacé par Status Fabrics. Nous avons donc ici trois états
différents. Et maintenant, nous voulons également le
visualiser dans
les différents états imprimés. Par conséquent, je recommanderais
les villes et l'étui de commutation. Boîtier d'interrupteur. Nous voulons vérifier l'état. Nous n'avons pas affaire
ici à une ficelle. Par conséquent, nous pourrions utiliser ici, l'affaire commence comme d'habitude. Nous écrivons simplement
ici le nom de la variable, puis nous écrivons ici. Allons-y par exemple. Ensuite, le second cas a commencé
en passant ou en pause. En lançant. Maintenant, c'est l'heure de la pause. La dernière, c'est que c'est fini. Mon cas, c'est la fac qui commence à se stationner et
on peut se doper. Nous sommes finis.
Un peu plus d'avis. Et ensuite, on pourrait juste le vérifier. Si vous en avez le droit ou non. Quel est le problème ? Nous retardons souvent ici. La suppression, c'est bien. Nous sommes à T of 500 et
celui-ci trop. Encore une fois. Alors, qu'
est-ce que nous avons ici ? Je clique sur
le mettre en pause au tout premier début, il sera imprimé en un car l'état n'est pas en pause. Indice Sera. Ensuite, nous
sautons dans le bouton Check, vérifiez les changements de bouton pour
démarrer cette normale, normale. Et après, oui, nous en avons
fini avec la configuration. Et puis dans la boucle, ce n'est pas le fait
que nous sautons , auquel cas, et maintenant
il sera imprimé. Allons-y parce qu'ils
pensaient que ce n'était pas un kilomètre. Au bout de deux secondes,
l'état
sera modifié car ici, sur
le clignotement, logique saute et nous
réglons l'état
sur la fatigue du statut. Et donc le statut, oh, nous sommes finis
là où nous l'imprimons. s'agit simplement d'un petit cas, d'un cas rapide où
vous
pouvez voir comment changer l'état, ou nous pourrions également vérifier
l'état d'un projet. Et comme vous pouvez le voir, vous
donne un bon aperçu. Quels sont
les différents États que nous avons et comment pourrions-nous le changer ?
10. Structure: J'ai également utilisé
régulièrement des structures. Les structures sont vraiment
un moyen
pratique résumer différents types de variables qui sont différents
types de données. J'appellerais aussi ça et une classe légère
plus petite. Alors, comment pouvons-nous utiliser une stratégie C plus plus
dans l'environnement Arduino ? Par exemple, nous pouvons
taper une structure, puis nous leur attribuons un nom de
structure, par
exemple, personne en bas et nous pouvons définir certaines variables. Je n'ai pas de chaîne,
nommez un âge entier. Boolean est le quota
personnel ou non. Et juste par exemple, si des raisons longues comptent le
solde en cents de dollars. Et c'est toujours une bonne
pratique lorsque vous
traitez des soldes de comptes, de l'argent, etc. Ne calculez pas avec des flotteurs
car c'est toujours l'œil. Cela peut être difficile lorsque
nous calculons avec des flotteurs concernant la
décimale ou que ce n'est pas facile. Par conséquent, je
recommande également de
calculer avec, par
exemple, un sens et le visualiser en dollars
normaux. Mais ici, nous avons
affaire au dollar, aux structures. Par exemple. Maintenant, nous pouvions la voir
personne, lourde, mais ce
point-virgule entre crochets le nom de celle-ci. Par exemple, la virgule y, la commande age 25 ans, est codée par une virgule. Et ensuite, nous pouvons nous asseoir sur le solde de
leur compte, par
exemple, le but. suite, nous pourrions également modifier leurs différents
types de variables. Par conséquent, je tape un point d'oiseau
lourd, et maintenant je peux aborder la variable à l'intérieur, par
exemple, un nom. Mon nouveau nom. Également à propos du point, le
quart est faux. Je suis en train d'imprimer ici. N'importe qui par son nom et si
je ne suis pas mal orthographié, quelque chose devrait imprimer mon nouveau nom parce que nous l'avons écrasé de Harry Boats. Et comme vous pouvez le voir, maintenant nous
avons discuté de la façon dont nous
pourrions définir une structure, comment nous pourrions l'initialiser, et aussi comment nous pourrions changer dans des
frappes soudaines certaines choses.
11. Réglage de base d'un projet vide: Dans cette vidéo, j'
aimerais vous montrer mes paramètres de base et
comment créer un nouveau projet vide
dans Visual Studio Code. Tout d'abord, si l' espace de travail et moi cliquons
sur la plateforme, je possède le menu, cliquez sur Ouvrir, puis cela me montrera quelle est ma plateforme principale
ou ainsi de suite. Ce que j'aimerais me
concentrer avec vous c'est que je suis allé sur des plateformes. Et ici l'épisode, vous voyez que ma
version expressive est 3.5. Et bien sûr, lorsque vous
montrez, regardez cette vidéo, peut-être que dans un ou deux ans plus tard, bien
sûr, sera
une autre version. Et cela peut également arriver
que certains de mes extraits de code ne fonctionnent pas immédiatement
parce que vous avez apporté des modifications. Par conséquent, il est nécessaire
de toujours garder à l'esprit que vous devez
adapter certains types de codes lorsqu'il s'agit
de mises à jour depuis la plateforme. Juste que vous le savez,
quand vous avez eu erreur de
compilation pour voir
où cela pouvait se produire. De plus, nous avons discuté dans une vidéo
précédente, les conseils d'État, que j'utilise le
tableau de livraison de l'AEC, les enfants sourds C4. Et ici, vous pouvez également
parcourir vos tableaux. Et quand vous avez un ESP 32 normal
, je pense que vous pouvez également prendre celui-ci ou vous pouvez
rechercher un ESP 32. Vous trouvez un autre type de cadres et
aussi un fabricant. Maintenant, nous passons aux projets
et je laisserais sortir sur Accueil, cliquez sur Nouveau projet. Et par exemple, j'ai tapé
, OOP. À Toronto. Je sélectionne les tableaux. Livraison Ac. J'utilise l'ID ou
le framework interne, et je choisis
ici mon emplacement. Et c'est tout ce dont
nous avons besoin pour les faire, je clique sur Terminer et mon
projet sera créé. Et j'ai laissé le côté ici
sur l'espace de travail. Vous pouvez voir ici
mon 51, mon projet. Et la première chose que nous
faisons est ici sur la plateforme. Nous sommes ouverts ici les
paramètres généraux du projet. Et je vous recommande d'
apporter les modifications suivantes. Nous ajoutions la vitesse du
moniteur cachée, par
exemple, à 1152
sérums, au framework sera et au port de
téléchargement et de surveillance. Le port moniteur
ou le port de votre appareil que vous pouvez obtenir
depuis la plateforme que vous tous, vous connectez votre appareil
et cliquez ici sur les appareils. Donc, en vous connectant, cliquez sur Actualiser. Et comme vous pouvez le voir ici, c'est mon port trois, c'est la raison pour laquelle je suis édité
ici et la plateforme. J'ajoute également ici et une bibliothèque
tierce. C'est ce qu'on appelle AnalogWrite. Néanmoins, si nous l'utilisons, mais ici, c'est l'
une de mes choses fondamentales. Je mets toujours en œuvre. Le gestionnaire de bibliothèque de sang de IO est très, très bon. Vous pouvez donc cliquer sur vos
bibliothèques et, par exemple, Adafruit, Neil Pixel, juste à
des fins de formation. Vous pouvez cliquer dessus. Et ici, vous pouvez
voir les exemples, comment y remédier dans le code source et
dans l'installation. Par exemple,
si vous avez toujours la version mise à jour
sur une version spécifique, il
vous suffit de copier cette ligne
ici, parcourir les tendances du laboratoire
Deborah, puis de l'inclure
dans votre programme en tant que normal. Et ces marchandises à emporter, pour commencer par ça. Coffre-fort. Sur le côté gauche,
nous avons maintenant notre menu que nous allons
explorer, et tout cela est un projet
puis une source. Nous avons un dossier vérifié. Et je
travaillerai aussi depuis l'Inde pour mettre tout
en avant. Justin en-tête de
vos informations d'identification, peut-être votre
licence, etc. Introduction répétée à
une date réelle. Et puis, tu es bon d'y aller. Il est également très pratique
lorsque vous tapez ici
les versions de votre plateforme. Donc aussi des personnes
de l'extérieur ? Non. Quels étaient vos paramètres de base et comment avez-vous
évolué dans quelles circonstances ? Ce ne sont que quelques
paramètres que je fais lorsque je commence
un nouveau projet.
12. Structure d'un cours et encapsulation de données: Commençons par les bases
de la structure de classe et aussi par l'encapsulation de données
et le moteur pratique. Je voudrais donc commencer
par ouvrir le principal RPC. Et ce que je suggère de faire, c'est ici que nous écrivons tout dans un seul dossier uniquement à des fins de
formation. Et la première chose lorsque nous
déclarons des classes, c'est que
nous saisissons en classe. Ensuite, le nom de la classe, crochets
bouclés s'ouvrent, le crochet
bouclé est fermé. Et à la fin, il faut qu'il
s'agisse d'un point-virgule. Et c'est la structure
de base de la classe qui limite. Un élément de classe est également
que nous définissons ici si leur fonction ou la variable est visible
de l'extérieur ou non. Et ça pourrait, c'est, hum, pouvons-nous faire avec l'identificateur public
et aussi privé ? Donc, tout ce qui vient
après le privé est juste, par
exemple, nous avons ici
une chaîne appelée name, et ces éléments
ne sont visibles et accessibles qu'
à l'intérieur de la classe. Dans cet exemple suivant, nous pouvons avoir votre nom de famille. Et bien sûr,
à l'intérieur de la classe et à l'intérieur de toutes les fonctions que
nous définissons ultérieurement, nous avons un excès de noms de variables
et aussi
du contenu de la variable lorsque nous utilisons voici
quelques choses publiques. Et bien sûr, je pourrais aussi
taper un nom de fichier de chaîne. Ensuite, nous avons des x sur ces variables également
en dehors de cette classe, et en dehors de cette classe signifie en dehors de cette structure. Lorsque nous instancions
l'objet plus tard, il n'est pas possible
d'accéder à vos objets
en privé. Nous n'avons
accès qu'à des choses que nous définissons
dans l'espace public. C'est que nous sommes
toujours conscients de ce
type de mécanisme. Et comme il s'agit d'une encapsulation de
données, cela signifie
que nous n'
affichons
que des données au public, accessibles
depuis l'extérieur de la classe. Et cela nous donne également une fonction
de sécurité car nous pouvons ajouter ici des éléments très
confidentiels, mais c'est aussi que vous ne
modifiez pas inconsciemment certaines données ici. Par conséquent, il ne s'agit pas
seulement de sécurité des données, mais aussi de sécurité lorsque nous utilisons ici
privé et public. Et le public, par exemple, nous pourrions utiliser votre chaîne GetName et voir ici
renvoyer un nom. Et comme vous pouvez le constater, la fonction elle-même est publique de l'extérieur. Et cette fonction peut
nous rendre ici quelques variables
privées. C'est ce que nous
apprendrons plus tard, les getters et les setters
afin que nous puissions utiliser vos fonctions publiques pour
obtenir des éléments privés. Il y a aussi d'autres identifiants dont j'
aimerais discuter avec vous et qui
s'appelle protégée. Protected n'est pas une façon que
nous utiliserons plus tard lorsque nous avons
hérité de certaines classes. Cela signifie que dans
la zone protégée, nous pouvons ici les variables, par
exemple chaîne, mon deuxième nom
n'est visible que dans la classe étudiante en tant que
privé, traite comme privé. Mais plus tard, lorsque vous donnez quelqu'un la bibliothèque et que
la bibliothèque est héritée
, la protégée
agit comme un public. Cela signifie que votre
classe principale sera
traitée comme privée, tout ce qui
n'est pas protégé. Mais plus tard, c'est quand
quelqu'un a hérité qu'il est utilisé comme public. Et c'est une bonne chose
quand on se développe. Et la bibliothèque, qui sera ensuite
distribuée à d'autres développeurs afin qu'ils
puissent en faire leur propre
chose. Mais vous aimeriez avoir
protégé votre propre classe. C'est ce que
signifie protégé et cela
pourrait être très utile. Nous avons donc parlé un peu des différents types
de personnes privées et
publiques et protégées qui nous
identifient, mais plus tard, nous
le verrons un peu plus en
pratique lorsque nous lancerons les objets. et aussi programmer plus fonctionnel pour s'adapter juste en brève introduction, c'est ainsi que nous configurons une
classe avec le nom, crochets de
colonne et le
point-virgule à la fin. Et pour les secteurs privé et public, c'est la
façon la plus habituelle de programmer. Nous définissons nos
fonctions et nos variables.
13. Instance et constructeur: Concentrons-nous maintenant sur ce qu'est une instance et ce qui
n'est pas un constructeur. Tout d'abord, le bord Arduino, nous
mettons tout en avant. Et puis aussi dans le temps de configuration, je recommanderais de taper
0
start car après, nous
n'y pensons peut-être pas. Alors, nous sommes prêts à partir. Nous avons donc terminé la
première étape de notre classe. Voilà donc nos
plans jusqu'à présent. Et maintenant, nous voulons mettre en place notre classe dans le monde réel du codage. C'est pourquoi nous
initions un objet. Et cela pourrait être fait
avec le nom de la classe, puis le nom de la variable de l'
objet dans mon cas, l'idiome, puis les étudiants, crochet, le crochet ouvert
fermé et le point-virgule. Et on y va. Nous avons initié notre premier
objet sous le nom d'Eddie. Ensuite, je saute ici
à l'intérieur de la configuration. Et en tapant 80, j'ai accès à tous les membres du
public de ma classe. Et comme vous pouvez le voir,
je ne peux pas accéder au nom ou au nom de famille
car c'est en privé. Je peux donc utiliser celle-ci, la fonction que
j'ai définie ici, et f x est au-dessus de la fonction
pour mes membres privés. C'est un moyen gênant, comment programmer et comment
pourrions-nous accéder à tous les éléments ici. Ensuite, comme deuxième exemple, nous pouvons initier ici
et le deuxième objet, qui s'appelle Julia. Et comme vous pouvez le voir ici aussi, Julia dots a son nom. Nous pouvons également accéder ici à la
même chose depuis Trulia, mais nous n'avons pas de stockage de
données jusqu'à présent. Ce serait donc la prochaine
étape de remplir ici
quelques chaînes pour que
vous puissiez également
connaître les noms de nos objets. Et bien sûr, on pourrait dire
qu'il fixerait toutes mes données. Et je pourrais dire
chaîne, nommer une, dernier pour chaîne, et
ainsi de suite. Et je pourrais invoquer cette
fonction par la suite, mais ce n'est pas
comme ça que je veux le faire. Parce que pour la première configuration, il existe une construction comme
on l'appelle constructeur. Ce constructeur nous prend nos premières entrées lorsque nous
sommes initiés à l'objet. Comment définir
un constructeur en ajoutant
simplement le nom de
la classe au public ? y a donc pas de valeur de retour. Dans ce cas, il s'appelle
étudiant et insert. On pourrait dire chaîne,
FirstName par exemple. Et puis, comme nous l'avons fait ici, nous pouvons dire que les
noms sont privés. Le membre sera un,
obtient le prénom. C'est donc maintenant notre constructeur. Le constructeur sera appelé lorsque nous lancerons l'objet. Et l'objet est initié ici et, comme vous pouvez le constater
, nous avons une erreur car celui-ci a
maintenant besoin d'un paramètre d'entrée. Par conséquent, je pourrais
dire les habitants et Julia. Donc, pour voir, il
s'agit d'un autre type de fait c'est juste la déclaration
du nom et c'est
le paramètre d'entrée. Maintenant, nous voulons obtenir le nom. Il s'agit d'un
retour, d'une valeur. Nous devons donc le couvrir ici en ligne d'impression en série, en ligne d'impression. Et nous pourrions également entrer en
première ligne d'impression en série. Mon premier cours. Ensuite, connectez-vous ici. Utilisez pm, donc T2
sur votre projet. Pour voir ici sur le bon objet c'est que le bon projet
est ici sélectionné. Nous cliquons sur Check
et avons
construit le projet, puis nous
allons le télécharger. Ainsi, et aussi le moniteur de sérum
commencerait tout de suite. Et nous devrions maintenant obtenir
trois lignes de sortie et notre moniteur série de première classe que le nom de Marco
devrait être affiché. Et ici aussi, le Trulia
devrait être affiché. Ça a l'air tellement bien. Jusqu'à présent, c'est tellement bien. Oui, mes
marqueurs de première classe et Trulia. Nous avons donc maintenant discuté de
ce qui est
souvent une instance de classe et aussi de
ce qui n'est pas un constructeur.
14. Constructeur de surchargement: Il est également souvent
vrai qu'il n'est pas que nous ayons non
seulement besoin d'un seul constructeur, mais cela serait très pratique lorsque nous en
avons un deuxième ou un troisième, ce qui nous donne plus d'occasions d' avoir plus
valeurs d'entrée, par exemple. C'est aussi ce que nous
pouvons mettre en œuvre pour que nous puissions surcharger le constructeur sont également fonctionnels dans ce qu'on
appelle le polymorphisme. Et comment pourrions-nous le faire ? Nous saisissons simplement le
nom du constructeur et définissons ici. Deuxièmement, il porte
le même nom, mais d'autres valeurs d'entrée. Par exemple, pinwheel
votre corde. Prénom. Par exemple, on peut dire ici que le
nom est FirstName. Et ici, nous pourrions aussi faire quelque chose avec le moule d'épingle. Mais ce n'est qu'à des fins
d'entraînement. faisant défiler un peu vers le bas
et j'aimerais vous montrer, je peux maintenant entrer un entier. Et comme vous pouvez le
voir, les deux objets, les deux constructeurs fonctionneront
parce que celui-ci
invoquera le premier est le
compilateur vérifie également,
ok, il n'y a qu'une seule pyramide, une pyramide de chaîne
sombre
que je Je prendrai celui-là. Et le second a deux entrées du Parlement, que
notre premier est un entier. Le compilateur
prendra le second. Ce n'est pas un moyen pratique. Comment pourrait-on approfondir notre programme ? Parce que c'est souvent
le cas que nous avons besoin plus de valeurs
d'entrée en même temps. Mais je voudrais citer
ici un autre exemple. Par exemple, nous pourrions
prendre votre chaîne FirstName,
String, LastName , Last Name, Last Name. Et c'est ce qu'on appelle beaucoup. Ce nom de famille est le dernier. Donc, en bas, bien
sûr, j'ai une erreur
car nous n'avons construit qu'avec deux paramètres
d'entrée. Et maintenant, comme vous pouvez le constater, nous avons ici un
objet initié avec un seul constructeur, et c'est le constructeur
surchargé. String, LastName,
retour, nom de famille. C'est donc notre
membre privé et nous pouvons accéder
au membre privé avec notre fonction publique,
obtenir le nom de famille. Et nous changeons ici
GetName pour obtenir LastName. Et nous sommes en train de le compiler et
de le télécharger sur notre USBE 32. Et lorsque tout fonctionne bien, nous avons trois lignes
dans notre cérémonie. Ma première classe, le Prénom d' Eddie n'entre que le
nom de famille de Julia. Voyons donc ce que notre
programme va imprimer. Terminé, téléchargez-le. Ensuite,
nous sommes ouverts à la cérémonie terminée. Ma première classe, et c'est ce qu'on appelle
des marqueurs comme nous l'avons ici. Et nous n'
imprimons que le nom
de famille de
Julie et Julia. Comme vous pouvez le constater, c'est ce qu' reste à
surcharger le constructeur ou le canal de
fonction, et aussi comment nous pouvons l'utiliser de manière orientée objet.
15. Exemple d'interaction des fichiers d'en-tête et de CPP: Dans cette vidéo, nous allons
explorer un peu
plus la manière
orientée objet et couvrir tous les
aspects de l'environnement Arduino à partir de la manière orientée objet. Par conséquent, je
suggère que nous supprimions la classe et tous
les objets définis
dans le CPP principal. Parce que nous voulons maintenant définir
vos en-têtes et vos fichiers CPP. Et c'est le moyen standard de programmer et de coder de manière orientée
objet. Mais tout d'abord, débarrassez-vous de toutes les
choses que
nous avons définies et déclarées
ici dans le dossier principal du RPC. Néanmoins, si vous
êtes sous ED ou dans Visual Studio Code
maintenant dans le dossier principal, dans mon cas, c'est
le dossier source. Nous avons créé deux nouveaux fichiers, s'appellent personne point
h pour le fichier d'en-tête. Et aussi un nouveau fichier
avec personne point cpp. Si vous n'êtes pas seulement
dans le coin supérieur droit où vous pouvez créer un nouveau fichier dans
l'explorateur de fichiers. Et vous pouvez également modifier
ici l'extension. Et l'une des premières étapes que je suggérerais de faire un clic droit
sur la personne point h, divisée à droite jusqu'à ce que
nous ayons les deux feux. Dans l'environnement ou dans un environnement
C Plus Plus, il est très courant que nous
n'ayons pas de fichier
dans le fichier d'en-tête. Il y a la définition de ma classe les membres privés et publics et les prototypes de fonctions. Un prototype de fonction
n'est que la déclaration
du paramètre de retour et le nom de la fonction.
Juste un aperçu. Dans le dossier du RPC. Il y a toute la logique à l'intérieur de l'ensemble
des parties performantes. Dans le CPP principal, nous définissons l'objet et le travail
qui est l'objet. Mais tout d'abord, j'aimerais commencer par
le fichier d'en-tête. Dans le fichier d'en-tête,
nous pouvions maintenant définir notre classe comme auparavant
dans le fichier CPP principal. Par conséquent, nous
fabriquons ici en classe, personne, crochets bouclés, point-virgule
ouvert. Et comme nous l'avons fait auparavant, pouvait voir le nom de
l'âge entier privé à Detroit. Ils venaient du public, un constructeur vide par
exemple. Et puis nous avons une fonction, ça s'appelle tout imprimer. Et comme vous pouvez le voir, pas de crochets bouclés,
juste un point-virgule. Et c'est le prototype de
fonction. Depuis le compilateur, il n'y
aura pas de fonction imprimer tout dans , mais avec le nom imprimer tout
et pas de retour parlement. Et la fonction elle-même
sera déclarée un
peu plus tard. Mais nous n'avons pas encore fini. Parce que nous avons besoin ici aussi de l' arduino dot h pour
que nous ayons un excès de tout. Il y a les paramètres
de l'environnement, vous le savez. Je vais vous en montrer un
petit parce que si je prends une chaîne
comme phonème, j'obtiendrai une erreur car le C Plus Plus ne connaît pas seulement les caractères
sans épargne. Par conséquent, nous incluons ici
point h et l'erreur a disparu. Une chose que nous devons
également savoir est que vos données incluent des gardes, le
nom Inclure Guard est, nous pourrions dire que si n
définit et un nom, je
vous suggère de l'appeler comme le fichier juste avec l'âge sous-jacent défini de la
personne. Et dans l'affirmative, qu'est-ce que c'était ? Que ne fait pas l'Inclure
Guard ? Ils incluent des gardes
montre le compilateur. Il y a un fichier
appelé personne point h. Et si
un code est déjà inclus,
ne l'incluez pas. Et si nous devrions l'inclure, il n'
y a personne défini par point
h, alors incluez-le. Nous devons donc inclure
la personne point h. Bien sûr, dans le
fichier
du domaine dot cpp, inclure le point personnel h. C'est
donc la première fois que j'
inclue l'année toute la cour. Mais j'ai aussi inclus dans
le RPC ou dans le
RPC d'une personne inclut le point
h de personne et, comme vous pouvez le constater, je l'ai inclus deux fois. Et cela va aussi, le compilateur l'
utilisera et dira deux fois, mais nous incluons toujours des gardes. Il ne sera utilisé qu'une seule
fois à la toute première fois. Il sera peut-être inclus ici. Et puis à ce stade, le compilateur voit peut-être un dur, il y a une définition de la personne, l'âge existant déjà
et il le sauterait. Et ce sera code
plus rapide et
aussi dans un cours plus propre. Il s'agit donc d'inclure les gardes et l'urée de la définition de
classe. Et c'est jusqu'ici notre fichier d'en-tête
fini. Nous remuons les paramètres de fonction et leur déclaration
des variables. Mais quelle était la logique. Ainsi, dans la personne point cpp, nous pouvons définir votre
empreinte blanche, ou par exemple, Sarah imprimer la ligne H. Et nous pouvons voir que nous avons ici une erreur
car h n'est pas défini. Pourquoi est-ce que c'
est juste une fonction ? Il n'y a aucune référence
selon laquelle nous voulons agir avec la classe
de la personne. Par conséquent, nous devons
respecter le nom de la classe. C'est ce qu'on appelle les
points doubles de la personne, le double point. Et maintenant, nous avons un excès de tous
les membres de la classe. Et comme vous pouvez le constater,
l'erreur a disparu. Et maintenant, nous avons également
agi à l'intérieur de la classe. C'est la
raison pour laquelle nous avons également accès
aux membres privés. Et c'est ça. Jusqu'à présent, nous avons implémenté
notre première classe dans l'environnement
Arduino d'une manière avec l'en-tête et le fichier cpp.
16. Getter: Dans cette vidéo, nous voulons maintenant
discuter des getters et des setters et de ce que nous pouvons faire maintenant chaque fois que nous voulons
accéder à des membres privés, utiliser une fonction publique fonctionnelle
qui a accès à notre, notre membres publics ou privés. Par exemple, lorsque nous voudrions modifier, graver le cycle de vie, certaines variables ou
aussi quand nous
voulons obtenir certains membres
privés. Mais avant de commencer, nous voulons ajouter
d'autres variables privées afin de pouvoir les
utiliser dans nos exemples. Par exemple, une
hauteur entière uniquement pour tourner Barber's String
LastName, string sex. Et également l'adresse String à des
fins ultérieures. Pays SIP de chaîne, code et pays de chaîne. Jusqu'à présent, c'est bon. Et comme
fonction ultérieurement, nous voulons utiliser la personne
d'impression, imprimer les détails de la
personne. Et bien sûr, nous
ne devrions pas imprimer quelque chose directement
depuis la classe. Nous devrions passer par
une valeur de retour. Ensuite, dans
le programme principal, nous devrions imprimer quelque chose
à des fins de débogage. Mais ici, c'est juste
un objectif d'entraînement. Et je dirais que
ça irait bien. Nous n'avons maintenant aucun objet. Nous voulons attribuer certains
objets via un constructeur. Par conséquent, nous
ajoutons ici quelques
chaînes d'entrée soulignées afin
que je ne mélange pas les membres privés normaux
et les mentors empruntés en entrée, je dirais pour nom chaîne de
virgules,
LastName sous-jacent, chaîne . Maintenant, de quoi avons-nous besoin d'autre ? Oui, hauteur, je
dirais la hauteur entière. Ça a l'air bien. Je copie l'ensemble du
constructeur. OK ? L'ensemble du constructeur passe
au CPP de la personne, collez-le. Ensuite, je supprime les
crochets bouclés du point-virgule ouverts et fermés. Et maintenant, comme vous pouvez le constater, nous avons une erreur parce que
nous voulons, nous voulons, ou nous devrions
identifier ici le nom de classe
double aveugle, double point. Et maintenant, nous avons accès
à tous nos membres. Signe pour le nom. C'est ma variable privée, nous
transmettrons nos entrées. Mais pour la partition, pour le nom, puis le nom, le nom de famille, il suffit d'utiliser l'auto-complet, sexe et sexe à une extrémité où
la hauteur est la hauteur. Voyons donc toutes les erreurs. Oui, quelque chose
mal orthographié, par exemple, qu'
est-ce que vous
n'aimez pas ici ? Aha, aha, aha, aucun trait de soulignement. Ce que nous faisons ici, nous transmettons les paramètres d'entrée
à nos variables privées. Et cela sera invoqué
lorsque nous lancerons un objet. Donc, en passant à notre CPP principal, nous voulons
maintenant
ajouter de nouveaux objets. Par conséquent, nous
écrivons personne, c'est le nom de classe
et le nom de variable l'objet s'appelle personne AT. Et à l'intérieur du
constructeur Person , nous
devons remplir le nom, nom, le sexe et la hauteur. Donc Eddie, nom de famille,
téléphone et molécules. Eddie, par exemple. Mâle, 180 centimètres. Bien sûr, nous pourrions également changer le nom de la hauteur
en centimètres. Il serait un peu
plus clair et plus net accord avec la deuxième personne. C'est la personne du pot. C'est ce qu'on appelle, mais pas de genre. Et c'est seulement 25
centimètres plus haut. Personne non servie. Nous avons Julia Julia, une femme. Et nous devons cacher 175 femmes elle et lui dire,
oui, une femme. Nous avons donc lancé
trois objets. Et maintenant, vous pouvez voir aussi les principaux avantages de
la manière orientée objet, car si vous
le faites de manière normale, vous avez déclaré
ici 1234 variables. Bien sûr, nous avons
aussi ici détourné, déclaré ici pour le virus, mais pour la deuxième personne. Nécessaire également pour les variables huit en
résumé, puis ici aussi, nous avons
maintenant 12 types
de variables différentes lorsque vous souhaitez traiter
ce type d'informations dans le code. Le principal avantage de la manière dont nous
avons ici
orienté l'objet , notre plan directeur. Et nous attribuons ces
informations à notre plan directeur. Et en arrière-plan,
ils traiteront de la gestion de la mémoire des
détenteurs et
de la déclaration. C'est là que nous venons les
créer un Blueprint
et de l'utiliser encore et encore autant de
fois que nous avons la
mémoire et l'utilisation
du processeur pour que nous puissions l'utiliser. Nous venons donc de l'initialiser. Mais nous avons également eu des informations sur les personnes
imprimées. Cette fonction que je voudrais
invoquer null, donc points
Abby, et comme vous pouvez le voir, j'ai deux options
car nous n'
avons ici que deux fonctions publiques. Le constructeur ne
sera appelé automatiquement que lorsque nous
créons l'objet. Par conséquent, j'utilise
les détails de la personne, pas de paramètres d'entrée. Et nous sommes prêts à y aller. Mais la même chose
apporte des détails. Et Julia
veut imprimer ici quelques données. Une chose qui m'a manquée de
retourner en
personne, car nous n'avons déclaré aucune de ces
fonctions jusqu'à présent. Par conséquent, quelle
personne, Double point, double liaison, imprimer les détails de
la personne. Nous voulons maintenant utiliser cette fonction d'impression
série f. La fonction Print F est
très pratique. Nous pouvons utiliser ici et ficeler. Et après que la virgule arrive aux
noms de variables, par exemple, j'aimerais utiliser ici le nom complet et je
peux mélanger vos textes. Par exemple, nom. Et c'est un espace réservé. Répondait à cet espace réservé. Le nom très apte
sera automatiquement mis ici. L'espace réservé. Maintenant, vous pouvez également ajouter ici
à l'intérieur de la chaîne. Et la deuxième variable, par
exemple LastName, comme dans la chaîne. Et ici, la deuxième
variable sera utilisée ici pour le
deuxième espace réservé. Et comme vous pouvez le voir, je peux seulement utiliser
votre variable incertaine. Ce n'est pas vraiment de la science des fusées. Mais que faisons-nous
maintenant lorsque nous
mélangeons vos chaînes
et vos entiers ? De plus, ce n'est pas un problème pour nous. Nous pouvons utiliser ici et d pour un
entier, ajouter un espace réservé. Une information mineure pour vous. Mon compilateur et le code
Visual Studio convertiront automatiquement
la chaîne en caractères caractères. Et comme nous le savons dans l'Arduino, il y a quelque chose que je peux enfiler, mais dans un C plus, en plus, il n'y a pas de chaîne,
il n'y a que des caractères. Et par conséquent, certains
compilateurs ont également besoin ici sur Come converti
conversation en un char. Je n'en ai pas besoin, mais si vous
êtes en 3D, par exemple, vous
donne ici une erreur de compilation qui
vient d' ajouter aux chaînes ici,
voir la chaîne de
soulignement sous-jacente STR. Et alors tout
devrait bien se passer. Nous avons donc maintenant implémenté des accessoires et des détails d'
impression. Voyons si nous avons raison. Je vais écrire un
projet comme vous pouvez le voir ici.
Voici l'avertissement. Vous devez modifier
votre chaîne I-System, mais elle n'est pas chargée. Mais c'est une conversation implicite. C'est dans mon cas,
tout le loyer. Eh bien. Donc, Succès. Montrez-moi le moniteur série. Redémarrez. Nous avons tout en une ligne
et nous pourrions changer cela. Eh bien, comme nous sommes juste à la fin du texte
et du saut de ligne, sorte que nous avons ici
un peu plus résultats que de se connecter. Restez juste à l'écoute. Nous sommes près du résultat. Maintenant, je dois imprimer
le bouton de démarrage. C'est un comportement étrange. Parfois, je dois le vider à travers
le
bouton de démarrage, parfois pas. Une fois de plus, la nouvelle ligne a redémarré. Ici, nous avons des molécules, nom de famille 86 m, hauteur
100, 80. Et comme vous pouvez le constater,
ce sont les informations de
notre constructeur. Et aussi ici, et aussi ici. Félicitations, vous avez
implémenté ici constructeur et vous avez également implémenté encore et la fonction
getter.
17. Setter: Mais que se passe-t-il si nous voulons modifier la durée de vie
actuelle du cycle de vie de notre programme,
quelques informations. Et nous n'avons toujours pas accès à nos membres ici
car, comme vous pouvez le voir, je ne peux pas
accéder ici, par
exemple, car le nom est nouveau nom. Lorsque j'ai essayé de compiler cela, j'obtiendrai une erreur
car il s'agit d'un membre privé privé. Alors, que puis-je faire maintenant ? Je peux également utiliser ici quelques fonctions
publiques pour y accéder. Alors, permettez-moi de voir ce que
nous pouvons faire maintenant. Par exemple, nous
définissons ici et nom de famille
blanc. Et nous sommes une chaîne de
soulignement LastName. Et aussi l'ensemble blanc H, entier h semble bon jusqu'à présent. Ensuite, nous
revenons à notre personne , je n'ai personne
que H plus est RPC. Et maintenant, nous
définissons ici le blanc, vide, l'ensemble, l'âge, l'âge entier. Et nous pouvions voir le bord
est souligné H. Nous pourrions le faire aussi avec quoi ? Définir le nom de famille
prendra une entrée parlement
de la chaîne LastName. Et nous définissons dans le LastName
est soulignée LastName. Quel est le problème ? Une fois de plus, nous devons lui attribuer une personne
lâche, un double aveugle, des points
doubles. Et maintenant, nous avons la
bonne référence. Nous revenons au RPC principal. Et maintenant, je peux dire, par
exemple, 80. Je dirais ce qui l'
a mis en place jusqu'à 55 ans. Et on pourrait dire que Julia a fixé
LastName, peut-être qu'elle se marie. Et ensuite, nous voyons ici. Alors, permettez-moi de voir ce qu'il y a ici. Cordes de certains âges. Quel est le problème ici ? Dans ces contextes ? Essayons ça. S'il y a une erreur. Non, ça me paraît bien. Ensuite, nous l'avons téléchargé une fois de plus. Et laissez-moi voir si nous avons ici un changement repris
à partir d'un saut de ligne clair. Ce que j'ai changé jusqu'à présent,
c'est que Julia a un nouveau nom de famille, mais
nous n'avons pas attribué ici le RPC de la personne H. So. J'aimerais
imprimer que vous êtes aussi le h. Ensuite, nous allons ici, H à ce stade, par exemple, c'est un entier 123 h. Et ce que j'
aimerais souligner ici un peu plus
pourquoi nous le faisons ceci avec le setter and getter, c'est que non seulement pour récupérer les données
de nos membres privés, il y a aussi une bonne
façon d'entendre une certaine
logique avant d'y entrer. Par exemple, nous pourrions dire que
si l'âge est supérieur à 100 ans, nous avons dit que le h
est 299, par exemple, ce qui concerne la
limitation de la base de données ou autre. Nous attribuons la variable
à nos membres privés. Une fois de plus, nous avons téléchargé. Et comme vous pouvez le constater, c'est également un bon moyen de voir QRA et de maintenir le niveau de qualité supérieur de
notre programmation et gestion des
données pour utiliser PM. Maintenant, encore une fois, nous avons changé ici au plan de vie
actuel, 155, nous avons fixé l'âge, alors que mon bot, et dans la configuration, nous avons
ajouté de la logique et il y a ici le 99 Julia
LastName MANOVA. Nous sommes affectés à votre
horreur en premier lieu. Et puis les secondes de
la configuration, nous avons ajouté le
nom de famille aux logiciels malveillants. C'est le principe des setters et des getters dans la programmation orientée
objet.
18. Héritage: L'un des
concepts principaux est également que nous pouvons hériter d'une classe d'
une autre classe. Cela signifie que nous avons un plan,
des dossiers généraux. Ensuite, nous pouvons utiliser
toutes ces fonctions, toutes ces variables
de notre classe. Ainsi, lorsque vous effectuez des
recherches sur Google et faites des recherches
sur la manière orientée objet, l'
un des principaux
exemples est toujours en général et généralement chauffant. Et ce véhicule n'est qu'une classe. Et ensuite, vous pouvez hériter et utiliser toutes les fonctions et
adapter à une voiture de sport à un VUS et deux
voitures, voitures, voitures,
etc. Pour avoir une vue d'ensemble. C'est en code général. Ensuite, vous pouvez également spécifier d'autres classes avec
des codes individuels. Mais c'est aussi mon
cas que ce que nous
utilisons beaucoup, c'est qu'il nous
donne une API. C'est ce qu'on appelle une interface
où nous pouvons utiliser en classe pour notre propre objectif et
adaptée à notre propre objectif. Alors, comment pourrions-nous
le faire dans notre exemple ? Nous avons ici nos
objets, notre projet et nous créons
ici de nouveaux fichiers car nous voulons maintenant ajouter
à la personne et au client. Et cela pourrions-nous faire avec le
nouveau client de fichier que H et le nouveau client de fichier point cpp. Je change le client
qui se trouve à droite. Et maintenant, nous pouvons déclarer ici toutes les choses
que nous avons faites auparavant. Tout d'abord, nous commençons
par le point-virgule du client de
classe, classe. Ensuite, nous avons besoin ici sur l'
Arduino comme avant. Et nous devons inclure des gardes car je vous montrerai plus tard. C'est nécessaire. Mais comment pouvons-nous faire maintenant ? Ils ont hérité pour la
personne de la classe pour le client. Par conséquent, une personne publique à double
point. Nous avons maintenant une erreur car personne n'est pas incluse ici. Inclure la personne point
h. Et maintenant, nous avons hérité
avec succès de la
personne dans la classe client. Et comme vous pouvez le voir ici, nous avons une
personne incluse que H pour inclure la
personne point h, la troisième. Et c'est pourquoi il est nécessaire que nous incluions
des gardes qui
n'étaient pas inclus encore et
encore, tout le code. Ainsi, dans cette classe de clients, nous pourrions également définir
ses propres choses privées. Par exemple,
ID client entier, entier, vente, public, par
exemple,
ID client, entier, nombre. Et ce qui est vraiment nécessaire lorsque nous
héritons de quelque chose, nous devons utiliser le constructeur
de notre classe de base. Et comment pouvons-nous faire cela ? Nous passons au client et nous disons utiliser une personne à
double liaison personnelle, ce qui signifie que nous avons hérité et que nous utilisons le même constructeur
dans notre classe héritée. Parfait. Jusqu'à présent, tellement bien. Ce que nous faisons maintenant, c'est que
nous revenons au RPC client. Inclure le point client h, inclure arduino dot h. Et nous
pouvons définir votre
client blanc double obligation, double obligation, définir l'
idée du client, le nombre entier. Et on pourrait dire que l'ID
client est un numéro. Jusqu'à présent, rien, surtout
ce que nous ne voyons pas ici, mais ce que nous avons chez
notre client CBP est plus ancien. Ou ce que nous pouvons utiliser, c'est toute la fonction que
nous avions déjà ici. Cela signifie que nous pouvons définir l'âge, définir le nom de famille, mais aussi
imprimer les détails. Nous examinons donc de plus près
le dossier principal du RPC. Sous Julia, je dirais que nous
créons un nouvel objet
qui s'appelle
client, car il s'agit notre nouveau
robot de classe hérité et d'un client. Alors nous l'avons déclaré ici, nous opposons. Nous utilisons le
même constructeur. Cela signifie que nous avons ici
un robot ou un ami utilise une aiguille et il en est un. Les cinq. Salut. Examinez
de plus près pourquoi est-ce cassé ? Parce que nous n'avons pas
inclus ce point client h. Et maintenant nous devrions arriver ici
sur le client, le client. Maintenant, il est en train de se compiler. Nous avons donc initié ici et un nouvel objet,
il s'appelle Robert. Et nous avons également hérité
du constructeur. Maintenant, j'aimerais entendre Robert imprimer les détails de la personne et les télécharger à
nouveau sur notre ESPN. En attendant,
je voudrais souligner une fois
de plus que nous n'avons pas déclaré ici détails de
la personne imprimée. Cela sera
automatiquement utilisé à partir de la personne point h car nous avons hérité de
toutes les fonctions. Ainsi, lorsque tout
va bien, nous devrions également vous toutes les informations
de notre robot. cérémonie d'ouverture est terminée. On voit Robert nom de famille casinos, âge, sexe et taille, 195. Et nous avons
hérité avec succès d'une classe complète, l'avons
adaptée et
utilisons également la fonction
de notre classe de base. Et bien sûr, nous
pouvons utiliser ici notre propre identifiant client d'
acceptation fonctionnel. Ainsi, nous pouvons également définir ici le
robot set client le dysfonctionnement n'
est disponible que dans la classe client. Je pourrais donc
dire, par exemple, 255. Et cela fonctionnera
comme nous l'avons fait auparavant. Le concept est donc que nous utilisons une classe de base
et héritons d' une nouvelle classe et que nous utilisons toutes
les fonctions accessibles
publiquement
à notre nouvelle classe. C'est ce qu'est
hérité et pourquoi nous l'utilisons régulièrement pour
orienter l'objet.
19. La fonction Inherited surchargée: Que se passe-t-il si, lorsque nous
voulons utiliser les
données personnelles imprimées également
dans notre classe de clients, car dans la personne pour vous, il est tout à fait logique que
nous imprimions l'âge, sexe et la taille, mais
pas en tant que vue client. Par conséquent, nous pouvons surcharger
un ovale juste là, imprimer les détails de la personne dans
notre classe héritée, et c'est ce que nous faisons maintenant. Par conséquent, nous
entrons dans le client à
cet avantage et nous disons que nous voulons ajouter un numéro de vente et nous débarrasser
de l'âge, du sexe et du type. Par conséquent, notre
fonction d'assistance
appellerait ensemble, résumerait les ventes. Et nous définissons les ventes entières avec un imprimé sous-jacent
et blanc. Toutes les ventes. Comment appelons-nous cela
imprimer toutes les impressions. Costume. C'est ce qu'on appelle imprimer des
données personnelles. Oui, c'est ce que nous
voulons écraser maintenant. C'est donc maintenant une nouvelle déclaration
au client que H, nous pouvons passer au client CPP. La première chose sera le client double aveugle, en
double aveugle certaines cellules. Et nous avons des ventes entières. Et nous voyons les ventes, c'est la variable privée, sur ces ventes. Mais nous n'
ajoutons pas ici un avantage, donc il sera résumé dans le principal RPC
que nous pourrions utiliser ici. Par exemple, Robert, quelques ventes. 1505200. J'aimerais ajouter 150
ici encore une fois. Nous avons donc trois
cent cinq cinquante, cinq cent
cinquante en résumé. Et cela doit être imprimé
dans les détails de la personne imprimée
et imprimer les détails de la personne. Nous avons déjà
déclaré chez la personne, mais nous voulons nous débarrasser
de l'âge, du sexe, etc. C'est pourquoi nous définissons
ici encore une fois cette fonction. Donc, soyez surchargé,
imprimez les détails de la personne. Et je reviens à la
personne du RPC et je copie toutes les choses
que nous avons faites ici, collez ça. Et j'aimerais me
débarrasser de celui-ci. Et ces ventes. Ventes. S'agit-il d'un entier ? D'accord ? Alors, que pouvons-nous voir ? Maintenant ? Nous voyons que nous
avons une erreur dans le nom et le nom de famille,
comment s'appelle-t-on ? C'est ce qu'on appelle. Nous ne pouvons pas accéder au nom
car il n'est pas déclaré. Les x ne sont pas interdits. Pourquoi est-ce que c'est ? Jetons donc un coup d'œil au point client h. Nous n'avons pas déclaré ici pour nom ou le nom de famille
car il est hérité. Nous ne sommes pas en train de nous rencontrer. Il n'est pas nécessaire de le déclarer à nouveau. Jetons un
coup d'œil en personne point h. C'est privé, et comme nous le savons, tout le privé est simplement
accessible à
partir d'une personne, d'un objet, de
la personne point h. Mais nous sommes maintenant dans un client. Nous avons donc hérité, mais
nous n'avons pas accès. Que pouvons-nous faire comme nous l'avons fait
au tout premier
début du discours ? Nous connaissons trois membres d' une classe et nous pourrions
changer cela pour la protéger. Qu'est-ce qui est protégé maintenant ? Protégé signifie qu'il est
privé dans la classe des personnes, mais qu'il est public pour toutes les classes
héritées. Et comme vous pouvez le constater,
nous n'avons plus d'erreur. C'est vraiment un bon
moyen car quelqu'un aimerait
peut-être enregistrer toute
cette encapsulation de données
pour sa propre classe. Mais n'est-il pas un développeur pour les projets
open source et dit, d'accord, vous pouvez utiliser toutes mes choses. Mais s'il vous plaît, héritées
et éditées à votre manière. Et avec l'état protégé. Maintenant, nous avons adopté et surchargé la fonction de
détails d'impression. Encore une fois,
téléchargeons toutes les choses
, revenons au CPP principal. Et maintenant, ce qui a changé c'
est qu'Eddie a acheté et devrait
vraiment l'
imprimer tous les détails de la classe,
bien sûr, de la personne. Nous devrions résumer ici, les ventes et
imprimer la nouvelle
fonction de vente, la nouvelle ligne. Et comme vous pouvez le constater, Robert a réussi pour le nom, nom de famille et les ventes
qui sont résumées ici. Il s'agit d'un concept principal selon lequel vous pouvez surcharger la fonction héritée. Soyez conscient des membres protégés
et publics. Et nous pourrions également ajouter ici
certaines de nos propres fonctions, mais nous pourrions aussi les surcharger. Et je pense que c'est très
pratique lorsqu'il s'agit de développement public et open
source. Nous avons donc
beaucoup de potentiel
là où nous pouvons l'utiliser. Imprimez donc les détails de la personne.
20. L'introduction du récapitulatif au OOP: Si vous m'avez suivi tout
au long des étapes de ces exercices
pratiques, je peux vous féliciter
car vous avez appris maintenant les concepts de base de l'approche orientée
objet, ce dont nous avons besoin ici dans ce cours en ligne pour
l'environnement Arduino. Ce sont vraiment
les bases fondamentales. J'aimerais
faire un bref récapitulatif afin que nous puissions résumer
tous les enseignements obtenus jusqu'à présent. Tout d'abord, nous avons étudié de
plus près la syntaxe, comment définir une classe, comment écrire une classe et qu'est-ce que l'encapsulation de
données ? Cela signifie pour les membres publics
et privés, mais aussi pour la protéger. Une fois. Par la suite, nous avons
initié un objet. Nous l'avons fait dans le dossier principal. Et nous
utilisons également constructeur. Ainsi, un premier paramètre d'entrée
pourrait utiliser et définir nos membres privés dans
le processus d'initiation. Ensuite, nous avons parlé
du « getter and setter ». Donc, comment utiliser fonction
publique pour
accéder à des membres privés, et comment modifier données à partir de la
durée de vie du cycle de vie pendant notre codage. Ensuite, nous
avons également étudié de plus près l'héritage
et
la façon dont nous pouvions hériter des
classes de deux autres classes. Comment utiliser la classe,
la fonction de classe héritée. Comment pourrions-nous surcharger la fonction, dont nous avons hérité le concept
principal. Ensuite, nous essayons également d'
entendre les différents types d'encapsulation de données, par
exemple
avec
ceux protégés, de sorte que nous ayons x dans la classe héritée, mais pas dans la classe de base. C'était pour trouver les bases. Et maintenant, nous sautons
directement dans nos exercices.
21. Calcul de la résistance au câblage et à la série: Commençons par
la partie câblage. Nous avons du
côté droit, l'ESP 32. La première chose que
nous faisons, c'est que nous relions le sol
à la planche à pain. Et maintenant, nous avons ici une LED. Et cette LED dispose de deux collecteurs. La première est qu'il y a un
ordre est le côté positif, et il est aussi là, la broche de connexion latérale. Ensuite, nous avons le cartilage. C'est la partie moins. Et comme vous pouvez le constater,
nous avons ici et la résistance avant de
connecter les LED. Et cela est nécessaire
car nous avons trop limité le courant de base de la LED. Et comment pouvons-nous faire cela ? Il existe de nombreux sites Web
différents où vous pouvez le calculer car
il est nécessaire pour chaque couleur
que vous implémentez. Vous devez choisir
une résistance appropriée. Et cela est calculé avec
un Arduino Uno à cinq fois. Soyez conscient que nous utilisons ici dans
cet exemple et utilisez be 32. Et avant, il était 32
a une tension de sortie, tension sur le GPA ou du
rond-point, 3,3 volts. Par conséquent, nous devons
adapter ici les valeurs afin d'obtenir la
résistance appropriée aux ohms appropriés. Par exemple,
allons-y un peu plus bas. C'est l'ensemble du calcul. Nous devons donc voir que la
tension globale est dans notre cas, 3,3 volts moins la
tension sur la LED, car nous voulons avoir juste une certaine
tension sur la LED afin que le courant
de base approprié du La LED se trouve sur la LED. Et c'est pourquoi nous devons
faire le calcul ici. Nous allons donc sauter directement dedans. Par exemple. Nous voulons calculer pour
la LED rouge cette résistance. Par conséquent, nous disons que
la tension principale est de 3,3 volts moins 1,6 mot pour
la LED et
le reste, la tension de 1,7
doit ou doit tomber pour la résistance. Ensuite, lorsque le
suivi de 1,7 volts de la résistance, la LED ne reçoit que 1,6 volt
et 0,02 ampère. Et c'est ce dont nous avons besoin. Nous n'en avons donc pas fini maintenant c'est notre calcul car nous n'avons ici la tension qui se
replie sur la résistance. Ensuite, nous avons 1,7 volts divisé
deux courants de base ou principaux. C'est 0,02 et passe. Et par conséquent, nous sommes en train d'obtenir,
regardons de plus près. 58 ohms. Comme vous pouvez le constater, il y a une petite différence. Mais dans les contextes principaux, je suggère que vous utilisiez, par
exemple,
l'air de 20 ohms. Il ne peut pas être endommagé ou ne devrait pas être
endommagé par les LED. Mais il ne brillera pas, ou
il est si lumineux parce qu'il ne
peut pas obtenir la pleine tension. Mais dans mon cas, j'ai aussi utilisé, je pense que 220 ou 110
ohms pour tous. Juste à des fins de formation, il est plus facile à utiliser lorsque vous êtes dans un environnement
productif. Je vous recommande de
calculer exactement la résistance exactement ohms car cela
concerne également la durabilité ou
la durée de vie de la LED
et des composants. Nous
connaissons donc maintenant la résistance. Voyons comment on peut tout
relier ensemble. Selon vous, comment
vérifier s'il s'agit d'une broche de sortie ? Ensuite, vous connectez
la broche de sortie de l'ESP 32 à la résistance, la résistance à la
liste non ordonnée, la partie la plus longue. Ensuite, vous connectez la
deuxième partie de la cathode aux
parties moins ou au sol. Et c'est tout. Prenez autant ou
autant de LED que vous le souhaitez. J'ai ici 3691215 LED. Il
vous montre donc un peu plus ce que nous pouvons faire avec l'approche orientée
objet. Et quand vous n'avez que
deux ou trois LED, ce n'est pas tellement. C'est bon. Et, mais vous constatez les principaux avantages lorsque vous ajoutez cinq
LED ou plus à votre projet.
22. Contrôlez la LED avec un objet: Ajoutons maintenant quelques
fonctionnalités à notre programme. Tout d'abord, cliquez avec le bouton droit
sur les couvercles point h et se divise pour écrire de
sorte que nous ayons sur le côté droit
le fichier d'en-tête. Et nous ouvrons sur le côté
gauche pour supprimer point CPP. Et comme c'est le
cas, nous voulons ajouter la
fonctionnalité. Tout d'abord, inclure la LED est point h afin que nous ayons accès
à nos éléments de classe. Comme point suivant,
je recommanderais d'inclure l'arduino dot h afin que nous ayons tous accès à l'
environnement Arduino ici. Tout d'abord, j'
aimerais définir le constructeur. Le constructeur est
la méthode principale qui sera
invoquée lorsque nous créerons l'objet plus tard dans
le point principal cpp. Ainsi, le constructeur a ici et un paramètre d'entrée et
il s'appelle la broche entière. Nous sommes donc des LED, des LED comment le
nom de la classe est appelé. Ensuite, nous appelons
le constructeur. C'est le même nom
que le nom de la classe. Ensuite, nous avons un parlement
d'apport. Il s'appelle l'épingle, les
crochets bouclés s'ouvrent, se ferment. Nous avons donc ici
nos fonctionnalités. Que faisons-nous maintenant
avec le constructeur ? Le constructeur prend le numéro de
broche, le bras GPO. Et donc nous sauvegardons le numéro de broche dans la broche variable privée, la
LED, la broche, il y a, la broche. Et puis il est enregistré
dans la classe. Et plus tard, nous
pourrons l'éteindre, l'allumer. Et c'était différents
types d'objets. Et la deuxième partie, je vous recommande
d'accéder ou de définir le PinMode
avec le cerf Pinellia. Et c'est une sortie parce que
nous avons des LED et
que nous voulons des
récompenses sur le GPIO cette semaine. Le mode PinMode pourrait donc
également être appelé en dehors la fonction de configuration, car je les ai ouverts
plus tard. Nous pouvons ici créer un objet, par
exemple, des couvercles , un
blanc, puis
les crochets bouclés, le constructeur sera
invoqué et un blanc, le premier est à GPO 12e, dans mon cas, fermant supports. Et maintenant, nous avons créé
notre premier objet. Il est appelé blanc des LED
de classe avec le
12e entier du constructeur. Nous avons donc ici les ensembles, la LED à broches variables privées, et nous avons défini le mode broche. Encore une fois, pourquoi nous
pouvons accéder ici, la variable privée, parce que nous avons affaire
ici à l'intérieur de la classe. Nous ne pouvons pas accéder à une
LED à broches avec cela très réel, ce n'est pas possible. Et ainsi de suite. Nous voulons maintenant ajouter
la fonctionnalité. Par exemple, nous pourrions continuer, activer et désactiver les
crochets bouclés. Et donc on pourrait dire que la broche
numérique LED haute. Et nous obtenons ici une flèche alors qu'
elle est propre parce que nous
définissons ici ET
la fonction dans les couvercles point CPP. Mais ce n'est pas notre tour
de classe. Par conséquent, nous devons identifier les personnes devant la fonction. C'est le nom de la classe,
double aveugle, double point. Et maintenant, la fiabilité est
reconnue et nous pouvons
allumer la LED
en tant que fonction x. Nous l'éteindrions. Il est éteint. Droits numériques, LED à broches et faible. J'ai eu une erreur supplémentaire. Pourquoi est-ce ainsi parce que
éteignez son oreille et son paramètre d'entrée. Et c'est également à des fins
de formation. Pourquoi est-ce si analogique de taureau, analogique du pauvre log de et
comme nous l'avons mentionné précédemment, ne mélangez pas analogique et numérique
blanc et donc, je passe ici et
bool variable que nous pouvons vérifier si
analogique de son vrai. Ensuite, nous devons éteindre
la LED avec analogique. À droite sur la broche inférieure
droite LED 0. Sinon, nous pourrions utiliser les droits
numériques. Par conséquent, la prochaine erreur survient ici car AnalogWrite
n'est pas défini. Pourquoi est-ce que c'est ? Donc, parce que je ne l'ai pas
inclus, nous devons inclure
un autre point droit h et maintenant nous sommes de la peur
et de la logique simple. Avec la fonction de désactivation, nous passons ici
et vrai ou faux. Si c'est vrai, nous éteignons la
LED avec de l'amiloride. Comme pour le DigitalWrite, l'AnalogWrite que
nous utilisons plus tard pour
le fondu ou quatre. Disons des détecteurs pour que nous puissions régler la lumière sous différents
types d'aspects. Si légèrement timide ou
s'est estompé et ne se contente pas de la
chair avec
toute la luminosité. C'est la raison pour laquelle je suis ici. Faire un petit détour pour vous
montrer comment nous pourrions également vous transmettre quelques paramètres
d'entrée,
etc. Nous avons maintenant la
fonctionnalité dans le constructeur. Nous avons activé la fonction
et la fonction de désactivation. Et maintenant, j'aimerais le
mettre en œuvre dans notre projet principal. Ici, le blanc
est déjà défini. Maintenant, je peux y aller en
tapant un point blanc. Et ici, vous pouvez voir
toutes
les fonctions définies
dans le fichier d'en-tête. Mais vous n'avez déjà
ajouté que de la logique à activer. Et dans la boucle, nous
sommes en train de faire ici et retarder juste pour l'entraînement
pendant cinq secondes. Et puis on peut dire blanc, éteindre, mettre les crochets. Et ici, nous avons
la suggestion. Veuillez nous donner ici
dans la variable taureau. Et je peux reconnaître, aha, de quoi est-ce que c'est un analogue bool ? Quand vous décrivez
très bien
vos riches, alors vous
n'avez pas à
réfléchir à ce que je voulais dire ici ? L'analogue de est faux parce que
nous n'avons pas le droit numérique. Et cela devrait fonctionner
pour le premier exemple. Je suggérerais donc que nous
cliquons sur le dessus de la table. J'ai connecté ma
planche à pain à mon PC. Il s'agit d'un vieux croquis
qui est en cours d'exécution. Ensuite, je l'ai fait chair. Tout d'abord, je
le vérifie auprès du compilateur. Si j'ai quelque chose
mal orthographié ne l'est pas. Il semble que la marchandise télécharge l'ensemble de l'esquisse et clique sur le bouton pour
vider le tout. Maintenant, il est en cours de téléchargement et
il ne devrait que réussir. J'ai le faux programme. Je dois passer aux LED
pour la partie anglaise, une fois de plus, télécharger
le bon projet. Vous voyez ici que vous pouvez modifier
le répertoire du projet. Et parce que j'ai ouvert ici beaucoup d'
options différentes pour nos projets. Connecter, encore une fois, mettre. Et maintenant, seule la première LED, la lumière blanche,
doit être
allumée, comme vous pouvez le voir, après cinq secondes, elle
devrait très bien s'éteindre. Alors maintenant, vous direz peut-être, d'accord, c'est logique, mais il y a beaucoup plus de codes
à écrire que je n'en ai l'habitude. J'ai aussi pu le
définir ici. C'est vrai, mais attendez. Nous pouvons maintenant continuer à dire, par
exemple, deux autres LED. Par exemple, vert un rouge, un an les épingles appropriées. On pourrait dire que le vert s'allume, le rouge est allumé,
ça a fonctionné. Et là aussi après
un retard, nous disons que le vert nous disons que le vert et le rouge
devraient s'éteindre. Cliquez avec le bouton droit sur Format des téléchargements de
documents. Et puis je suis désolé, LED devrait s'allumer et
après cinq secondes, elle devrait s'éteindre. Démarrez encore une fois. Et comme vous pouvez le voir ici, il semble que
certaines LED soient allumées. Considérons trois
LED et après cinq secondes qui s'éteignent. Parfait, notre croquis fonctionne, mais on dirait
qu'ils sont allumés, mais c'est parce que j'ai quelques projecteurs et
c'est le reflet de cela. Il est donc éteint. Encore une fois. Redémarrez l'ESPN. Comme vous pouvez le constater, les trois LED, que nous sommes déclarées ici allumées et après
cela, elles sont éteintes. C'est un moyen facile. J'aimerais vous
visualiser à quel point la manière orientée objet présente de nombreux avantages car nous avons
ici un modèle unique. Avec ce schéma,
nous pouvons traiter beaucoup, autant de LED que nous le voulons. Et lorsque nous
aimerions changer quelque chose
dans la partie « désactivation », il suffit de le faire ici et toutes les
LED sont affectées. Dans la vidéo suivante, nous aimerions ajouter d'
autres fonctions afin que
vous puissiez voir que nous
pouvons également utiliser différents types de
fonctions pour les LED.
23. Fichier d'écran: Je ressens un nouveau projet
dans Visual Studio Code. Et vous pouvez aussi me
suivre avec l'
autre intermédiaire, simplement créer un nouveau projet. Ensuite, j'ai inclus dans la bibliothèque principale de
droits analogiques de fichiers dont
nous avions besoin parce que nous voulons utiliser un GPIO PBM afin que nous puissions régler la tension de sortie dans différents types d'emplacements
afin que nous puissions nous estomper, par exemple, nos LED. Soyez conscient lorsque nous
utilisons des bibliothèques externes. Également la plateforme GoTo. Et faites la référence pour
la dépendance de la bibliothèque ici. De plus, lorsque vous êtes avec l'EDA, vous pouvez utiliser ici à gauche
le gestionnaire de bibliothèque et
inclut
l'analogique, n'est-ce pas ? Je ne suis pas sûr qu'il soit
déjà inclus dans le noyau de l'ASPE 30 pour simplement lui faire un
test lors de la compilation, alors vous devriez obtenir
du succès ou une erreur. Ensuite, vous devez ajouter
la bibliothèque. Et ainsi de suite. Ensuite, en tant qu'exposant, nous allons dans le répertoire
source et créons deux nouveaux fichiers. Nous commençons par
le fichier d'en-tête, et il s'appelle le point
h de LED et de la même
manière que nous ajoutons ensuite les couvercles de fichier CPP point CPP. D'accord ? Nous commençons par
Declaration ou définissons les éléments dans les
LED du fichier d'en-tête. Les fichiers d'en-tête
donnent une bonne vue
d'ensemble des variables que nous utilisons et des fonctions que
nous mettons en œuvre plus tard dans le CPP, mes approches que nous sommes, j'utilise le projet terminé et collez tout ce qui est en
richesse dans le fichier d'en-tête. Parce que vous leur
avez un bon aperçu ce que nous développons actuellement. C'est là que je pense que
c'est un très bon avantage dans la programmation. Lorsque vous êtes échangé avec d'
autres programmeurs, les encodeurs détectent, suppriment des données, donnent une bonne vue d'ensemble
du projet. Donc, tout d'abord, nous fabriquons les Inclure Guards. Si N def LED est nuisible mon approche est appelée est
la même que le fichier. Définissez ensuite les couvercles à la fin. Et s'il s'agit d'un petit rappel, Inclure Guard
nous aide à savoir que le code
n'est qu'une fois implémenté
à partir du compilateur. Donc, lorsque nous utilisons
beaucoup d'inclusions de la LED punk star,
le programme vérifie. Êtes-vous déjà implémenté ? Lorsque vous n'êtes pas implémenté ? Si oui, ils ne sont pas implémentés. Encore une fois, je vous
recommande également de
passer au fichier principal et de faire les LED d'inclusion point h afin que nous soyons préparés pour
les parties de programmation. Lorsque nous incluons
le fichier d'en-tête, le fichier CPP sera également
automatiquement inclus. Revenons aux LED point h. Et maintenant, nous commençons
par déclarer notre classe. Les crochets bouclés s'ouvrent, les crochets
bouclés fermés et un
point-virgule à la fin. Jusqu'à présent, c'est tellement bien. Ensuite, nous sommes en train de taper en
privé et en public. Et maintenant, nous pourrions
commencer par la déclaration. Il manque une chose
et nous devons inclure ce
point arduino h. Pourquoi est-ce ainsi,
afin que nous ayons accès à toutes les autres fonctions
de leur environnement. Nous commençons donc par
les variables privées, donc la LED épingle et ensuite
nous avons de la luminosité. Ensuite, nous avons un
nombre entier de fondu. Et nous avons des modes de croisade annuelle et
bool. J'ai ajouté ici
cinq poumons non signés. Et je suis sûr que vous connaissez déjà le Blink sans
retarder la fonctionnalité. Et bien sûr, je n'ai
eu qu'à en implémenter une, je pense qu'une version précédente, mais je veux être sûr et économiser. J'ai donc mis en œuvre cinq d'entre eux parce que plus tard, nous
avons un mécanisme
de contrôle différent pour les premiers jours et
nous sommes donc en sécurité. D'accord ? la partie publique, nous avons ici beaucoup de fonctions que nous
mettrons en œuvre ultérieurement. Je le colle
simplement en cliquant avec le bouton droit et on peut dire Format du document. Nous utilisons une fonction d'activation et
de désactivation du constructeur. Et la
fonction de désactivation a également un parlement d'entrée et analogue de
pool de parce que
nous ne devrions pas mélanger. Ce n'est qu'un rappel. Ne mélangez pas l'analogique
et le numérique, n'est-ce pas ? C'est la même LED qui
ne fonctionnera pas vraiment. Il suffit de décider si vous voulez l'
activer avec DigitalWrite. Tournez aussi le
numérique à droite, et c'est la même chose
que l'analogique, non ? Par conséquent, nous avons une
fonction et nous vérifions si vous
êtes activé avec
analogique ou non ? Nous pouvons donc vérifier ce
fondu en quelques millisecondes. Nous avons une
fonction cible, une fonction f. Nous utilisons notre fonction de désactivation
après un retard. Nous dirons que ce sont les LED
et que nous n'avons pas réglé le mode
pulsation afin de
pouvoir les régler en boucle. Et c'est tout ce que vous pouvez voir. Ici. Cela nous donne juste
un très bon aperçu fonction
que nous allons
mettre en œuvre plus tard. Jusqu'à présent, c'est bon. Et dans la vidéo suivante,
nous commençons par définir nos premières
fonctions à la fin, c'est le fichier point cpp.
24. Basculer la LED: Dans cette vidéo, nous voulons maintenant
ajouter et fonctionner, ce qui allume ou éteint notre LED. Et c'est plutôt
là que nous ne savons pas, c'
est allumé ou désactivé ? Il devrait donc être
automatique, automatiquement. Identifiez s'il est activé ou non. Donc la fonction cible, nous sommes ici dans les LEDs point
CPP et je tape en blanc. Il s'agit de
supports à bascule sur et hors tension. Donc maintenant, nous écrivons
votre
LED numérique à broches droite n niveau
par exemple, Hi ou Low. Mais maintenant, je veux avoir
l'état de la LED. Je veux que vous le sachiez.
Par conséquent, on pourrait dire numérique, l'épingler là. Et le voyant de la broche nous fait référence ou nous renvoie si le
GPA est allumé ou non. Donc, si le
voyant clignote et que R est allumé, et que nous écrivons
le voyant numérique ici. Nous sommes en train de réduire plus haut. Il nous livre donc, par
exemple, haut ou bas. Mais j'aimerais maintenant
avoir le contraire. Par conséquent, je pourrais faire
un point d'exclamation. Et ce sera
inverser mes signaux. Donc, si je rentre ici et plus haut avec deux points d'
exclamation, il sera bas. Et c'est extrêmement
pratique car nous pouvons maintenant ajouter le numérique
lu et inversé. Donc, si nous atteignons un haut, donc la LED est allumée, nous obtenons ici la partie
haute V qui l'a inversée. Nous sommes donc bas et la droite numérique
éteint la LED. D'autre part, s'il est faible, les lectures numériques nous
redonnent et sont faibles. Nous l'avons renversé. Et donc nous n'avons pas été défoncés. Fonction très pratique. Et pour que nous puissions
revenir ici aux LED, voir la partie principale. Et maintenant, nous nous
débarrassons du retard car les
retards sont toujours mauvais
lorsque vous codez. Par exemple, lorsque
nous selon le transfert
MQTT sur la transmission
ou que nous avons des moteurs pas à pas, il y a un besoin dans
la fonction de boucle. Autrement dit, les fonctions sont
toujours connectées. Et si nous
travaillons ici avec des retards, la connexion a eu du
mal à continuer. Par conséquent, le programme
ne fonctionnera pas très bien. Ou dans le cas où cela
ne fonctionnera pas d'une façon ou d'une autre. Par conséquent, il faut
nécessairement se débarrasser des retards. Et maintenant, nous voulons
implémenter ici la
fonction AND qui allume ou éteint nos LED toutes les deux secondes. Par conséquent, nous utilisons la logique
Blink sans délai. Et je suis sûr que vous avez déjà
entendu un dysfonctionnement, mais je l'ai encore expliqué
ici. Nous avons donc besoin ici la durée
de vie actuelle du programme. Le cycle de vie ici
est donc en millisecondes. Millis précédent
n'est pas défini ici. Nous allons donc passer à la partie
supérieure et définir un long
non signé, car les millions
précédents pourraient être un nombre très important, car nous
parlons en millisecondes. Il est donc recommandé d'utiliser un nombre long
et non un entier. Alors, comment cette logique fonctionne-t-elle
en quelques termes ? Par exemple, nous avons
ici une durée de vie d'une seconde. Si le code 1 seconde
est
mille, mille millisecondes avec vos 1000 millis précédents est 01 moins 0 est 1000. Mille ne
dépasse pas deux mille, deux mille n, par
exemple dix. Ensuite, 2010 est
supérieur aux années 2000. Et cette logique,
si la condition est vraie et que le code ici
sera invoqué, alors il manque une chose. Nous remettons le village
précédent au Millis actuel, car à
l'étape suivante, par exemple, 2050 moins 2010, car c'était la dernière fois que
la condition était vraie, nous avons
alors la nouvelle condition
n'est pas supérieur aux années 2000. Mais par exemple,
si une seconde plus tard, 3 050 moins 2010 ne
dépasse pas 2000. Mais par exemple, dans
les deux secondes suivantes, pour des milliers, 50 moins 2010
est supérieur à 2 000. C'est vrai. Et le précédent Millis
sera fixé à 44 050 et ainsi de suite. Nous avons donc une logique facile toutes
les deux secondes. Mais nous voulons basculer nos
LED. Comment pouvons-nous faire cela ? Par exemple, écrire un blanc, un tout-petit, un rouge allumé. Et qu'est-ce que c'était ? C'
était le rouge, le vert. Vous pouvez voir une
logique simple où nous pouvons allumer et
éteindre ici les LED. Et bien sûr, dans la fonction
bascule, je ne vérifie pas s'il s'agit d'un
analogique ou d'un numérique, n'est-ce pas ? C'est également à des
fins de formation de
vous visualiser ce qui est possible avec les paramètres
d'entrée, etc. Mais ici, il suffit de basculer les LED, basculer le projet
sur le bon projet. Voyons alors si
nous avons mal orthographié quelque chose
ou si le compilateur nous
donne un signe vert, oui. Téléchargez ensuite l'ensemble du programme. Selon la
caméra de table, où en sommes-nous ? On y va. Et comme vous pouvez le constater, le programme est en cours de téléchargement. Rien ne l'est. Nous l'avons déjà téléchargé
et nous sommes toutes les deux secondes, les voyants s'
allument et s'éteindront. Alors vous pourriez vous demander, OK, c'est
cool, mais je pourrais aussi gérer ça avec une
fonction à l'extérieur. Par exemple, basculez en blanc,
puis invoquez-le. Et pour le blanc, le rouge et le
vert, c'est vrai. Mais plus tard, lorsque vous utilisez différents types de
Millis précédents, par exemple, avec des durées de vie
et des cycles de vie différents, vous obtenez tout le potentiel de la manière orientée objet. Ce n'est qu'une première
étape la plus simple qui permet de voir ce qui est possible et dans quelle la manière orientée
objet est
flexible.
25. Désactivez la LED après x secondes: Dans cette vidéo,
nous voulons maintenant ajouter les fonctions virage après retard. Donc, les trois LED basculent ici. Depuis que nous avons commencé l'USP. Alors désyntonnez, c'est bon. Et maintenant, nous voulons ajouter trois autres LED aux entités
d'esquisse. Trois voyants doivent s'éteindre après un numéro de retard
spécifique. Et c'est ce que nous
voulons mettre en œuvre maintenant. Par conséquent, nous sautons dans
la LED élites dot cpp. Je copie toute la fonction
du fichier d'en-tête afin que nous ayons ici exactement
la copie de la déclaration. Faisons une double liaison, des doubles liaisons, des crochets
bouclés s'ouvrent et se ferment. Nous avons donc ici la fonction qui
s'éteint après un retard. Il dispose de deux puissances
d'entrée, dix millisecondes, afin que nous puissions
choisir chaque entité, combien de temps elle doit être allumée et aussi si elle est
allumée avec analogique ou non. Par conséquent, nous
devons
également mettre en œuvre le principe Blink sans
délai ou une logique, mais un peu différent. Maintenant, tout d'abord, nous voulons avoir le
Millis actuel, rien de nouveau ici. Mais si la condition que nous avons maintenant
ici, quelque chose a changé. Nous prenons les
Millis actuels et les Millis
précédents,
je vais raccourcir. C'est ici défini
en privé. Nous pouvons
également l'utiliser en anglais. Par exemple, désactivez. Et maintenant, nous disons que
différent du Millis actuel moins
l'arrêt Millis
précédent est inférieur
aux millisecondes, que nous passons
au paramètre d'entrée. Et il
y a aussi quelque chose de nouveau car nous ne
voulons pas réinitialiser le
ministre précédent. Comme nous l'avons fait auparavant, nous avons dit que cette réduction de
millions de dollars est en minutes actuelles, mais nous ne réinitialisons pas l'ancien
Middle-Eastern off. Pourquoi ? Parce que nous ne voulons qu'une fois que cette logique soit exécutée. Donc, mais nous voulons l'
autre partie de cela. Et dans l'autre
partie, nous disons
éteindre la LED avec l'analogique de. Désactiver est donc la fonction qui est
mentionnée ici
dans notre classe LED. Et la désactivation prend un vrai
ou un faux et met en place le voyant de broche, que nous avons défini précédemment. Et c'est tout. C'est ça. Ce que nous avons ici
inclus dans la logique. Allons au dossier principal du RPC. Et maintenant, j'aimerais
ajouter quelques LED supplémentaires. Par conséquent, je LED est bleue, l'une est sur mon GPO, 16. Ensuite, j'ai la LED rouge, l'une est sur 15. J'ai déjà ça. Je veux un jaune sur 19, et je veux que l'
outil blanc soit sur GPIO 14. Ensuite, j'allume les
voyants LED pour s'allumer. Le bleu s'est allumé. Et le jaune s'allume. Bien sûr, je pourrais également l'activer ici dans cette partie,
c' est-à-dire que
cela dépend de ce que
vous aimeriez mettre en œuvre. De plus, j'aime garder mon
code aussi général que possible. Et il s'appelle éteindre après retard lorsque nous avons changé le nom. Il est donc plus évident qu'il s'
allume et s'éteint après un retard. Ensuite, vous pouvez également
ajouter ici, par exemple, que vous n'avez pas besoin de l'
activer avec une ligne distincte. Ensuite, vous pouvez également appeler l'activation ou la désactivation après un
retard, par exemple. Mais j'aimerais que cela
soit plus général. Donc, je l'allume. Ensuite, cette partie est le basculement et l'arrêt,
ce que nous avons fait auparavant. Et maintenant, je peux dire blanc pour s'éteindre après le support d'ouverture de
retard. Maintenant, je vois deux paramètres,
l'entier millisecondes. Je veux éteindre la
première au bout de deux secondes, et ce n'est pas avec l'analogique. Regardez bien ? Oups. Ensuite, j'ai le bleu
et j'ai répondu à une. C'est ce qu'on appelle le jaune. Le bleu doit s'
éteindre au bout de quatre secondes et terminer le jaune
après dix secondes. Nous avons donc ici deux ou plusieurs processus
simultanément en
cours où la FEA, le clignotement et le
basculement toutes les deux secondes. Et aussi le blanc
au bleu et le jaune devraient
s'éteindre après un certain temps. Voyons ce que dit le
compilateur. Si vous avez une zone de
déversement quelque part, elle a l'air bien jusqu'à présent. Ensuite, nous avons le
croquis clignotant qui se déroule. Ensuite, nous cliquons sur les téléchargements. Cliquez sur le bouton pour
qu'il puisse être vidé. Bouton Nth Now. Laissez-moi le faire chair maintenant. Led à bluer s'éteint
après deux secondes. Au bout de quatre secondes. Au bout de dix secondes. Oui. Et ce sont ceux dans la
boucle, que nous avons ici, basculent jusqu'à ce que l'infini
soit boucle de l'infini. Une fois de plus, nous
redémarrons le programme. Le blanc est, le Y2 est après deux secondes du bleu
au bout de quatre secondes, et la LED sera jaune
après dix secondes. Et vous voyez que le processus parallèle avec le bascule est en cours. Et je pense que c'est juste un bon exemple que
vous pouvez voir comment la manière
orientée objet vous soutient lorsqu'il s'agit différents types de
processus en même temps. C'est vraiment en même temps. Mais vous pouvez voir qu'il
n'y a pas de différence, de différence
visuelle. Donc, si vous avez implémenté ce type de logique de manière
normale avec l'usine, vous deviez définir ici trois
Millis différents car vous avez besoin de différents types de logique. Clignez des yeux sans retard,
car ici nous
avons deux secondes,
quatre en dix secondes. Et comme vous pouvez le constater, vous
devez écrire trois fonctions avec presque la même logique
mais pas les mêmes variables. Et ce n'est pas bon lorsque nous reproduisons du code pour
la même chose. Ce n'est jamais une bonne idée,
car maintenant j'ai ici
un modèle que je pourrais le changer comme
je le voudrais. Et comme vous pouvez le constater,
avec une seule ligne, nous pouvons activer et
invoquer cette fonction. Nous avons donc ici le premier exemple de notre manière orientée
objet.
26. Se fondre: Maintenant, nous voulons mettre
en œuvre et s'estomper. Décoloration. La décoloration signifie
que nous allumons la LED étape par étape en petites valeurs afin de pouvoir
l'éteindre plus facilement. Et par conséquent, je
vais au Couvercle Dot CPP et nous mettons en œuvre le
fondu sur la fonction. J'ai copié celui-ci.
Ensuite, o taper dans les blancs conduit double aveugle,
double aveugle, collez-le. J'ai ici la fonction. Dans cette fonction,
nous mettons en œuvre sans délai
notre logique Blink. Par conséquent, j'ai ici
le Millis actuel. Et maintenant, nous entrons dans la
même voie que dans la boucle. Cela signifie que nous avons
votre Millis actuel, nous accédons à l'immobilier
précédent. Voyez-vous, c'est un
autre type de variable que nous obtenons
qui passe sur la fonction, le Moyen-Orient en quelques secondes. Cela signifie que, par exemple, toutes les deux secondes, trois secondes, cette
logique sera invoquée. Et dans cette fonction, maintenant, nous pouvons configurer la
milliseconde précédente sur la millis actuelle de
sorte que nous
entrons dans la condition
encore et encore. Maintenant, nous disons que si la luminosité
est de 25, donc moins de 255, alors nous pourrions
augmenter leur valeur. Et cela pourrait être fait, par
exemple, d'abord, que nous imprimons le
niveau de luminosité. Et puis on voit
un autre regard, n'est-ce pas ? Nous voyons la LED à broches et nous avons une valeur de profondeur, de
luminosité. La luminosité est réglée sur deux sérum au
début, non ? Ensuite,
nous augmentons la valeur de la luminosité par
le fondu Montant. Et la blessure mortelle est également en variable
privée
que nous avons ici. Et l'enquête est fixée à cinq. Cela signifie que chaque
ligne ou chaque boucle. Nous augmentons la
luminosité de cinq. Ainsi, la LED devrait augmenter le
niveau de luminosité étape par étape. Jusqu'à présent, c'est bon. Cliquez avec le bouton droit sur Format du document Et nous avons mis en place
notre fonction pieds sur place ici. écriture analogique peut également
avoir une valeur d'assertion, d'assertion. Par exemple, la
valeur maximale dépend de bibliothèque
que vous utilisez, mais elle doit également fonctionner
avec deux paramètres. Ensuite, je retourne
à la boucle principale. Et je dois l'
initialiser à d'autres objets. Je dirais que nous
collectons. Laissez-moi voir. Je prends l'écran LED
deux est sur la broche, vert à 25, et nous
ajoutons l'outil bleu. Et c'est sur le GPIO 17. Ensuite, à la fin de la boucle, nous quittons
tout comme avant. Nous avons donc ici nos
trois bascules, heures trois LED qui s'éteignent
après les dernières secondes. Et maintenant, nous voyons le
vert s'estomper , par
exemple, en millisecondes. Et nous avons le bleu qui s'estompe
sur 600 millisecondes. Jusqu'à présent, si bien, en sécurité. Voyons ce que dit le
compilateur. Si nous avons mal orthographié
quelque chose ou non. Ensuite, nous allumons
la caméra. Ça a l'air bien. Ensuite, nous téléchargeons le croquis et rinçage est robuste pour eux. Maintenant, tous les processus
doivent être invoqués. Oui, et comme vous pouvez le voir, ces deux fonctions sont ici la verte
et la bleue. Le bleu augmente de
600 millisecondes, cinq pas, le vert
est un peu plus rapide. V3 basculent et les autres
sont déjà désactivés. Une fois de plus, je vais commencer le moniteur en série parce que nous avons collé quelque chose
lors d'une cérémonie, temps passe ici. Et maintenant, comme vous pouvez le constater, j'ai deux messages, ce n'
était pas vraiment clair. J'aurais dû ajouter ici également
la valeur du code PIN par exemple. Mais vous pouvez voir ici une
LED à 80 et l'autre à 255, déjà
finie de s'estomper. Et ici, nous
n'avons que le bleu. Comme vous pouvez le constater, chaque
600 millisecondes, elle est augmentée de cinq. Et je le répète encore une fois. Ici, vous pouvez voir
tout le potentiel de la manière orientée objet car ici nous
avons le culbutage. Nous devons désactiver les extrémités de la
fonction, la fonction de
décoloration. Et tout au sein d'un même programme, des processus
parallèles, des processus
simultanés. Et comme vous pouvez le constater, nous avons peur et nous avons
vraiment une bonne vue
d'ensemble de ce que nous faisons ici. n'y a pas vraiment
beaucoup de coordonnées. Parce que vous pouvez voir si
Aidan, ce qui est alimenté, nous pouvons revenir en arrière et voir
ici la logique d'un fondu. C'est un des principaux
avantages, outre ces processus parallèles
que nous pouvons voir ici, le code est très
propre et très clair. Et aussi, pour certains tiers, pourrait être, je dirais, travailler dans la logique un peu plus rapidement parce qu'elle a
une bonne structure.
27. Pulsate: Nous voulons maintenant ajouter une autre fonction
parallèle appelée fonction
pulsate. Nous aimerions allumer
légèrement et doucement la LED , puis l'éteindre doucement. Et je l'ai appelé pulsate, donc nous le copions sur nos
couvercles point cpp, blanc. Nous allons doubler les points doubles. Et nous ajoutons
encore la fonction. Et maintenant, nous pourrions
commencer par les codes seuls. Et comme nous l'avons fait auparavant, nous utilisons ici la logique Blink
sans délai. En même temps que chaque fois. Nous disons ici, si Millis actuel. Ainsi, la durée de vie,
le cycle de codes moins le
milieu précédent se poursuit. Nous l'avons défini
ici, nous le dirons. Et puis nous disons des
crochets bouclés. La première chose que nous faisons, nous passons les millis
précédents au millis actuel
afin que chaque cercle, la condition if
soit vérifiée. Ensuite, l'étape suivante, nous disons que la luminosité
plus est égale au fondu Montant. Et la quantité de fondu est fixée à
cinq comme nous l'avons fait auparavant dans le destin sur les points S et X, nous devons ajouter si luminosité est égale à 0 ou si
la luminosité est égale à deux, 55. Pourquoi en avons-nous besoin ? Nous avons besoin d'une logique qui nous ajoute le design ou le design à partir de la radio,
de la quantité d'alimentation. Parce que si nous sommes à des niveaux de
luminosité sérum, la quantité de
fondu devrait avoir le signe plus afin d'ajouter chaque cercle, 51015, etc. Si nous avons atteint le niveau de 255, la quantité de fondu devrait
changer le signe à moins. Nous comptons donc jusqu'
à 255250 itérateur. Et donc, dans
cette logique simple, nous pouvons en changer le signe, la quantité de
fondu. Cette quantité moins fondue. Parce que si nous diminuons la valeur et que
nous atteignons 0 moins, c'est moins c'est plus, et cela augmente. Si nous avons atteint le haut pour s'estomper montant sera un signe moins. Et nous descendons une
logique simple, mais efficace. Et comme le dernier,
nous devons ajouter un autre journal, n'est-ce pas ? LED à broches. Et nous voyons le niveau de
luminosité. C'est tout ce que nous devons faire. revenant
à la partie principale, nous commençons à entendre de nouvelles
variables, de nouveaux objets. Et je suggère d'
ajouter le tube jaune. C'est sur mon épingle 21
et je lis pour écrire. Je ne sais pas si c'est la
bonne épingle sur un formulaire. Et à la
fin de notre croquis. Donc, tous ces trois processus
comme le basculement, aiment s'éteindre et s'estomper. Nous le gardons dans le croquis. Et maintenant, nous disons rouge pour pulser. Dix par exemple, et très vite. Et jaune pour le dire. À 50 ans un peu plus longtemps. Il suffit de vérifier s'il y a des
flèches qui allument la caméra. Et comme vous pouvez le constater, il
s'agit de l'exemple d'
esquisse précédente. Je clique sur Upload. Ensuite, nous nous chargeons,
une fois de plus, utilisez les PM. Et les téléchargements devraient commencer. haut. Essayez ensuite de focaliser l'appareil photo. Alors maintenant, comme vous pouvez le voir
ici, où est mon alimentation ? W2 pulse
très, très lentement. Et ici, nous avons le
jaune qui est également assis et pas le
bleu ne
se nourrit que de
celui-ci. Et bien sûr,
le rouge est très
rapide. Ainsi, pour les processus, différents types de
processus sont en cours. Et comme vous pouvez le constater, je pense que sept ou huit LED ont différents types
de fonctionnalités. Encore une fois, nous
allumons et désactivons cette réalité. Ceux-ci, nous nous sommes
décolorés et nous avons l' entrée
totale pulsant
tout en même temps. Je pense que cela se fait par
quelques lignes de codes. Et comme vous pouvez le constater, c'est vraiment très bon aperçu et
a une bonne structure.
28. Instancier des objets dans le tableau: Cette vidéo, j'aimerais vous
montrer une fois de plus le potentiel de la manière orientée
objet. Par conséquent, j'aimerais créer une zone
et ensuite cette zone, nous stockons tous les
objets afin que nous puissions itérer et jouer
un peu autour. Par conséquent, j'ai créé et const
int variable parce que c'est, j'ai ici 15 LED. Et quand nous changeons ensuite ici quelque chose
dans une planche à pain, je n'en ai besoin que ici et le changement devrait avoir tout adapté. Nous sommes donc en
train de créer un nouveau tableau. List est le nom de la classe, c'est le nom du tableau que j'appelle. C'est. Toutes les pistes, par exemple. Et nous devons dire quelle est la
taille de la région. C'est cool, il y a 15 emplacements. Ensuite, nous faisons ici quelques crochets
bouclés, point-virgule. Et à l'intérieur des crochets bouclés, on pourrait dire, 12e. C'est la même chose
que nous l'avons fait auparavant. Alors, jetez un coup d'œil. Nous avons initié l'objet
blanc sous cette forme, disons, juste
le nom de la classe, c'est le nom de l'objet,
c'est le constructeur. Mais nous pourrions aussi faire
quelque chose comme ça. C'est la même procédure, c'est le même objet. Nous sommes en train de créer un objet. Et nous avons commencé avec des couvercles ceci, le nom de la classe et
le constructeur. Et cette méthode nous
utiliserons ici à l'intérieur de l'œil toutes les LED car ici le nom, nous n'avons pas de nom. Nous stockons uniquement l'
objet dans le tableau. Voyons donc comment
nous pourrions le faire. J'ai préparé,
déjà préparé cela signifie que nous avons
notre premier objet, deuxième objet, notre troisième, etc. Donc, dans l'ordre, comme je l'
ai sur la planche à pain. Et donc nous pourrons ensuite faire quelque chose comme si
je suis à la poursuite du détecteur de mensonges. Vous pouvez voir que 15 objets
sont stockés ici. Et c'est ce que nous devons
faire car
un à la fois nous devons l'initier avec
le numéro d'épingle. C'est donc obligatoire. Tous les couvercles ont 15
objets. Jusqu'à présent. Nous n'avons pas besoin de quelque chose dans la configuration car
il est déjà fait dans la classe que nous avons
depuis PinMode, c'est mieux. Maintenant, j'aimerais m'
estomper chaque année. Chacune des LED
sont-elles en même temps. Par conséquent, j'ai fait fonctionner
et fonctionner ici. Appelons ça se fondre et
ensuite faire votre boucle for. Et c'est la suggestion automatique. Ils peuvent dire entier. Et pour les leads num, cela signifie 0 à moins de 15. Nous devons donc nous permettre, il sera itéré. Et puis on peut
dire, par exemple, dates, ou
on appelle ça des allèles. Maintenant, nous appelons tout ça des pistes. Leads. Ensuite, nous parcourons la
première, la seconde, etc. Ensuite, nous pouvons faire valoir un point. Et on peut dire que
le fondu sur 150 millisecondes. C'est la même chose
que nous l'avons fait auparavant. Par exemple, si nous avons
ici le jaune à objecter, nous
pourrions aussi dire jaune
à pointer, fondu sur 150. Et on pourrait dire jaune, un destin sur bla, bla, bla. C'est la même
procédure que celle que nous avons faite ici, car tous les objets
sont stockés
dans notre tableau et nous pouvons
y accéder lorsque nous effectuons une itération. Voici donc l'objet
et nous pouvons
y accéder avec la classe. Jusqu'à présent, c'est bon. Ensuite, nous devons appeler la
fonction dans notre boucle. Voyons ce que dit le
compilateur. Si tout va
bien, ça a l'air bien. Connecter l'USP
certainement pour surveiller son
moniteur d'ordinateur, télécharger, puis changer
la caméra, le clignoter. Maintenant, tout était
le projet « Force up J ». Une fois de plus, téléchargez c' était la configuration pour nous dans
le mauvais répertoire. Maintenant, c'est le bon. Les projets doivent être compilés. Voyons voir. On y va. Chacun d'entre eux le sont, chacune des LED s'estompera
légèrement, une fois de plus, un redémarrage. Et comme vous pouvez le voir,
c'est simultanément. Mais en fait, ce n'est pas
vraiment simultané. Chaque LED est un peu
retardée, mais c'est ce que nous
voulons et maintenant il est facile pour nous de créer une autre fonction. Par exemple, nous voulons
aller de l'avant, tout va de l'avant. Et puis nous changeons
ici, pas les fondus. C'est ce qu'on appelle le produit à moins de 20 ans. Et dans la boucle, nous appelons
tout de suite sans commentaires. Cela vous permet de voir
tout ce qui n'est pas commenté auparavant, car nous voulons simplement
utiliser la fonction array. présent. Encore une fois,
télécharge l'ensemble du croquis. Chair, utilisez PM. Et maintenant, les anciennes LED devraient
s'allumer et s'éteindre en douceur. Parfait. Comme vous pouvez le constater, nous avons Kavya
et un moyen très pratique où nous pouvons contrôler
beaucoup de LED. Par exemple, nous pouvons contrôler
des centaines et des milliers de LED uniquement avec quatre
ou cinq lignes de code. Et c'est ce que je pense que
nous utilisons également plus tard. C'est ce qui est si puissant parce que M. objet est orienté vers l'objet, nous avons ici le moyen de
contrôler beaucoup de composants
en même temps. Et c'est très facile.
29. Effet de chasse à la LED: Ajoutons ici une fonction de
plus et c'est facile à mettre en œuvre et nous voulons créer une fonction de
poursuite LED. Cela signifie que les premiers jours devraient se dérouler de
gauche à droite. Et si elle atteint le haut, la LED doit s'
éteindre de gauche à droite, puis
recommencer. Par exemple,
nous l'appelons Jason. Dans cette fonction,
nous commençons par allumer toutes les LED. Nous utilisons donc ici sur for-loop et nous
voyons ici ne pas pulser. Nous sommes déchirés. Et nous utilisons le calque
incorporé, mais c'est juste à des
fins d'entraînement, de sorte que nous voyons, ok, Il y a votre sous-couche
et cela a un effet plus agréable. Dans ce cas, nous voulons
éteindre toutes les LED. Donc, dans la même fonction que vous
utilisez et au deuxième étage, car c'est la première itération. Et voici la deuxième boucle. Dans la deuxième boucle,
nous avons déjà cette fonction et elle s'
appelle tour après retard. Nous devons entrer des paramètres. Le premier est le délai de désactivation. Nous voyons 50 millisecondes
et est-ce un analogue de Non ? C'est la raison pour
laquelle nous disons faux. Par exemple, nous
sommes ici en retard. Et maintenant, nous pourrions dire ici, laissez-moi le voir. C'est ça. Il suffit de compiler, ça. Ça a l'air bien. Une chose que j'ai manquée, c'est
que je dois invoquer la fonction, bien
sûr dans la boucle. Chasing, télécharge
le tout. Voyons à quoi ça ressemble. Normalement, il devrait
commencer de gauche à droite. Si j'ai saisi correctement toutes
les épingles, selon l'ordre
ici, les breadboards ? Oui. De gauche à droite, il continue et s'
il atteint le sommet, il s'éteindra doucement. Et comme vous pouvez le voir ici, nous avons beaucoup de possibilités où nous
pouvons contrôler, éteindre, allumer les LED et
vraiment, très pratique
avec cette zone et la zone est ancienne ou
magasins d'objets plus anciens. Amusez-vous donc avec le codage orienté
objet
et aussi avec des tableaux.
30. Fil: Et la partie vibrante pour ce
projet est très, très simple. Nous avons notre ESP 32 et voici
les capteurs infrarouges HV 210
autant que nécessaire. Donc, dans mon projet d'artisanat, j'ai un citron des capteurs. Et dans cet exemple d'exercice ici pour ce
cours, j'en ai cinq. Et il est
recommandé d'utiliser ici convertisseur de tension pour
pouvoir brancher
vos colis externes, par
exemple 12 volts. Et ce
convertisseur de tension convertit
la tension en cinq volts, et ces cinq volts
vont au breadboard. Vous pouvez donc alimenter
ici vos capteurs, l'ESP. Donc, le double devrait également être
connecté alors à cinq. Mais je saute cette ligne
parce que je suis alimenté par USB parce que nous
la programmons et que nous
voulons un monotone 0. Donc je ne veux pas que tu sois
sur la fonction root. C'est la raison pour
laquelle j'ai sauté ici. Si une broche de cinq volts. Ensuite, sur le côté droit, nous avons ici notre écran LCD et
LED pour simuler le mortier. Et nous nous connectons ici
au cartilage, de
l'élite au sol. Ensuite, à partir de la
liste non ordonnée, les plus grosses broches, nous allons à la résistance
puis à la broche numéro 13. Le motif sera
relié au sol. Et de l'autre côté,
nous nous connectons à, sans aucune résistance
au GPR 12th, car nous utilisons ici la
résistance pull-up d'entrée de l'ESP 32. Examinons donc de plus près
et comment je l'ai mis en œuvre. Vous pouvez voir que c'
est ma configuration. Ici. Nous avons la LED, le
bouton-poussoir et les cinq capteurs. L'un d'eux
sera le cortège. Et comme vous pouvez le voir, votre
petit potentiomètre, il se peut que ces capteurs
interfèrent avec les autres. Ensuite, vous devez le mettre en
relation avec certaines tendances virales
telles que je l'ai ici. Et puis ça
devrait bien fonctionner. Donc, dans mon cas, cela fonctionne correctement. Je l'ai connecté avec des
fils ici sur la breadboard, ce qui signifie que la terre, le VCC et les broches de sortie sont connectés si
c'est le virus ici. C'est donc tout ce dont nous avons besoin.
31. Créer un projet et un cours: Nous commençons par
un nouveau projet que
j'ai déjà
créé ici à cette époque. Et mes textes jusqu'à présent, alors j'aimerais
ouvrir la plateforme, n'importe quelle fin ici, copier et coller des projets
précédents. L'argent est donc de l'argent. Ces vitesses de chargement des ports. Et j'inclut, comme toujours, l'AnalogWrite pour
que nous l'ayons ici. Sauvez, fermez-le. Encore une fois, ouvrez le CPP de domaine. Et maintenant, ce que nous voulons faire, c'est mettre en place une classe qui identifie lequel de ces capteurs sera déclenché. C'est pourquoi nous commençons par créer
nos classes. Mais avant cela, vous voyez comment j'ai implémenté toutes
les parties de virion. J'avais donc 32 ans sur
la planche à pain plus et je motive la planche à pain pour
que chacun d'eux
ait une alimentation électrique. Et la broche gauche de chacun d'entre eux connectée à
l'un des GPIO de l'ESP 32, et c'est tout jusqu'à présent, toute
la logique moderne sera mise en œuvre
plus tard, car maintenant nous ne voulons que nous concentrer On, je suis orienté objet,
comment on peut accéder ici au sous-marin
des capteurs infrarouges. Ensuite, nous commençons par
créer deux nouveaux fichiers. Cliquez avec le bouton droit sur source, nouveau fichier. Et nous l'appelons
IR notre capteur ou un nouveau fichier point h
ou sin point cpp M. Cliquez avec le bouton droit de la souris, divisez à
droite, fermez celui-ci. Nous avons donc notre
schéma d'avant, et je voudrais commencer par
le fichier d'en-tête. Tout d'abord, classe, capteur, crochets
bouclés, point-virgule,
puis privé, public. Ensuite, nous avons besoin d'une
journée, y compris Arduino. Et nous savions que nous avions également besoin
d'un Inclure Guard si le capteur N def souligne l'âge
et que nous avons la fin de l'année, définissez la toute fin. Et si c'est le cas, vous pouvez vous demander pourquoi je tape tout
ça encore et encore. Ça a été bien. Je dirais aussi faire de l'exercice
pour vous que vous savez, sont les
conditions
requises pour la classe. Et lorsque vous le faites
encore et encore, vous pouvez également copier et coller sur un modèle, par exemple. Mais au tout premier début, j'aime le
faire étape par étape. Vous pouvez donc également voir des
références voilées sur lesquelles il se trouve. Nous passons donc
au fichier CPP et
nous incluons ici le point h du capteur
ainsi que l'Arduino. Ensuite, dans le RPC principal, inclure les RE et l'âge personnel. Toutes les références
sont donc faites jusqu'à présent. Et maintenant, nous pouvons poursuivre
la définition de
la classe par elle-même. Et j'aimerais remplir l'ensemble du
fichier d'en-tête afin que vous ayez une bonne vue d'ensemble de ce dont nous avons besoin et de ce que
nous mettons en œuvre. Par conséquent, la broche
centrale sera le tenseur d'état GPO que nous reconnaissons s'
il n'y a pas de changement. De plus, dans l'état précédent, nous avons besoin de données pour identifier quel
capteur est déclenché. Intelligence le punk, ou
on peut appeler ça des points. Parce que nous voulions également
dire que, par exemple, le milieu
nous donne cinq points, dix points, 20 points, un match. Compter les itérations, les ER et sont déclenchés, est déclenché par le
moteur. Plus tard, nous pourrons
également avoir du plaisir et logique pour commencer et
mettre fin au mortier. Ensuite, nous pouvons implémenter
le constructeur. Nous prenons donc
ici le Terre-Soleil, donc c'est le GPI ouvert. Et nous disons également que nous
voulons connaître les points. Par exemple, j'ai nommé cela
un peu différent ce point, de sorte que nous n'avons pas
ici clair que je suis la distinction. Ensuite, nous avons besoin ici d'une autre, de
trois autres fonctions. Cliquez avec le bouton droit de la souris, Format,
document, vérification, ER, déclencheur. Et cela sera mis en œuvre
dans la boucle afin que nous sachions lequel du
recensement des urgences est déclenché. Et étalonner le rire de stoke, c'est ce qu'on appelle
par exemple l'étalonnage. Ce n'est pas nécessaire
que nous ayons répété et nous nous épargnions
aussi une
certaine inflammation. Ce n'est qu'à
des fins de débogage ,
puis arraché cette barrière moteur se met en douceur
et une nouvelle version de celle-ci. Nous écrasons donc cette fonction. Ce sera soigné. Je
remarque que je comprends ça. Ceci est nécessaire pour contrôler le moteur qui s'
éteint et se rallume. Jusqu'à présent, le
fichier d'en-tête est terminé. Le fichier CPP est
configuré comme référence et nom
du fichier CPP principal. Dans la vidéo suivante, nous pouvons
commencer par la partie logique.
32. Capteur d'adresse IR individuellement: Commençons par le code
source et la logique. Nous commençons donc par définir le nom de classe de constructeur
IR capteur ou une double liaison, double liaison I, le nôtre et ainsi de suite. Et nous avons des épingles
GPIO entières et des points de
soulignement entiers ,
des accolades. Et à l'intérieur, nous sommes X, dit le capteur, la broche est GPO ou pin. Ensuite, nous disons que les points sont sur les
points et que nous avons ici et broche du capteur de dettes
PinMode est une entrée car nous voulons la valeur ER et
nous ne les avons pas démarrées. Je commencerais le capteur en est un. Cela est nécessaire dans
la fonction suivante. C'est donc la première,
la première initiation. Nous passons
au fichier principal du CPP. Et maintenant, nous pourrions adresser les cinq objets à
nos cinq sens. Et comment pourrions-nous faire cela, notre sens ou c'est notre
sens des urgences ou c'est le nom de la classe. Ensuite, je dirais que notre
capteur est ER, sens. La première consiste à épingler. Ma première épingle est
14 et j'ai assigné des points tendent à son 2345. La deuxième phrase pour les tris et le deuxième
capteur n'est pas une broche sept. Vingt-sept, vingt
six, vingt-cinq. Et nous avons le dernier à r0. Ensuite, nous leur donnons les
points pour 2050 centièmes. Et le dernier obtient 0 point
car cela sera plus tard sur notre cortège Watergate pour identifier si nous
démarrons le moteur ou non. Ok, jusqu'à présent, tellement bien. Maintenant, nous pourrions également implémenter ici sur la fonction,
par exemple les points de contrôle. Les points de contrôle se trouvent sur
les points de contrôle. Dans cette fonction, nous pourrions
aborder ces objets. Par exemple, vous
êtes central. Et ici, on pourrait dire Check
Trigger, Check Trigger. Est-ce un cortège ? Non. Pourquoi dois-je
également implémenter le cortège dans cette fonction ? Parce que j'aimerais
décocher les fonctions de déclenchement. Alors, lequel de mes capteurs sera déclenché dans
l'ensemble du projet ? Maintenant, si c'
est un cortège, je dis le reste d'entre eux. Je suis le capteur de force 2345. C'est un
moyen vraiment pratique et pas très bon. Mais tout d'abord, je vais vous
montrer comment vous
pouvez le faire
dans le petit détour. Et ensuite, nous sommes
en train de faire ici un fils de réseau
, revenant aux ERS. Et donc parce que nous voulons maintenant
implémenter la fonction de
déclenchement de vérification. Par conséquent, la
fonction de déclenchement n'est pas blanche. pas indigne, c' est un capteur ERS entier ou une double liaison double contrôle
ER ou déclencher des motocades. Et maintenant, nous mettons en œuvre presque la même chose que nous l'avons fait
avec le bouton équilibré. Et maintenant, vous vous demandez pourquoi devrais-je faire fonctionner
les os pour un ER, un choix
sensé et une déclaration de lecture
analogique. Et pourquoi je fais cela,
c'est que je veux avoir votre fonction qui
commence simplement par
revenir au capteur. Tout d'abord, ce
sera normal
quand je serai déclenché. Le capteur comme
celui-ci sera
déclenché, déclenché, déclenché,
déclenché , déclenché,
déclenché, déclenché, non déclenché. Et je veux avoir une telle chose qu'elle soit déclenchée
dans la logique, mais maintenant ça
me renvoie les points. C'est ce que j'aimerais
avoir dans mon projet. Donc rien ne se passe et
quand le marbre disparaît, dois
m'en vouloir à leurs points et seulement une fois et
non cinq ou six fois. Par conséquent, nous
pouvions utiliser la même approche
qu'auparavant. Nous disons donc que
l'état précédent commence à censurer et capteur d'
état est une broche de capteur de
lecture numérique. Nous lisons donc le capteur et nous le passons
à l'état précédent. Et maintenant, nous disons que si l'état
précédent est plus élevé et que le capteur des portes de démarrage est faible, cela signifie
que sa cible, alors nous avons des erreurs E, envoie ou déclenché, n'est pas vrai, c'est Millis parce que
nous voulons le temps comme dénonçant. Sinon,
si nous pouvions voir si l'état précédent est maintenant faible et si le capteur d'état l'
est, qu'en pensez-vous ? Ensuite, nous avons ici la
logique dans laquelle nous pouvons identifier maintenant combien de temps
ces années ont été déclenchées. Et je voudrais dire ici que si des millions de personnes moins les urgences envoient
un bon sens, sont déclenchées en moins de
dix millisecondes. Rien ne devrait
se produire si et autrement. Je pourrais dire ici, si
quelque chose se produisait. Et je pourrais dire que si le moteur porte, c'est le paramètre d'entrée. Si cela est déclenché, alors je pourrais dire 0 print. Tout à fait. Nous l'
implémentons ultérieurement, mais je voudrais le couvrir
ici car il a un paramètre d'entrée et leur
chanson devrait tout augmenter, déclenchée lorsque le moteur
est également déclenché. Et néanmoins, si c'est
un moteur bon ou non, j'aimerais
imprimer la broche du capteur. Jusqu'à présent, c'est tellement bien. C'est ce que notre
principale logique de nez. Donc, si la censuration est détectée, comme si je le couvrais ici, le Millis
sera transmis à un capteur,
puis il sera
imprimé sur la broche du capteur. Voyons donc ce que dit
le compilateur. Et je suis en train
de relier le tout. Et téléchargés. Soudain, on
allume la caméra. Voici mes capteurs
et maintenant je couvre le premier et
maintenant je quitte le premier et
je supprime le point, je reçois
la broche du capteur également au second. Le troisième, le quatrième avait besoin de
descendre un peu. Et le cinquième. Et ici aussi, cela nous
donne des résultats très, très nets
à partir de chacune des épingles. Et c'est ce que je veux. Je veux un marbre qui passera à travers les LED et
me redonne le sentiment de douleur. Ou plus tard, il s'agit points
référencés qui
ont été déclarés ici. C'est la première chose que
nous avons mise en œuvre a maintenant un résultat clair et simple.
33. Objets dans un tableau: Jusqu'à présent, nous avons testé notre logique pour instant notre programme principal
et cela fonctionne très bien. Mais ce n'est pas très bon. Codez-le parce que nous avons
cinq lignes distinctes et chaque ligne nous devons identifier si notre capteur ER est
déclenché, elles sont formées. Nous adaptons maintenant notre code source à une
manière plus orientée objet afin que nous
puissions également utiliser certaines
zones. Comment pourrions-nous faire cela ? Nous disons notre capteur, le nom de la classe, puis
je l'appelle notre tableau. Voici l'espace réservé. Combien de domaines avons-nous besoin ? supports bouclés s'ouvrent et
se ferment. Avant de le faire ? Peu fréquent pour eux parce que le
dernier sera mon moteur obtenir ce capteur qui
nous indique le démarrage molto ou non. Donc et ici aussi, nous n'avons pas convaincu
la salle de vérifier les points. Notre réseau de capteurs IR
doit donc se rencontrer ici et
const int par exemple, num, ER, envoie ou capteurs est 44. Pour les capteurs, ce qui nous
donne les points. On nous identifie si
le moteur démarre. Je suis donc assis ici, les capteurs de num num num ER et ils sont pratiques, c'
est ici que je peux maintenant changer les chiffres pour 7810
en conséquence et toutes
les boucles qui ne
sont pas un flux de chaleur. Une prise de pour boucles
qui arrivera plus tard. Nous serons automatiquement adaptés. C'est ce qu'on appelle le
capteur de l'année, ce capteur allumé. Ici, nous avons maintenant un autre crochet bouclé
pour chaque objet. 40 est l'épingle, dix sont là. Je fais un point. Puis le deuxième objet,
épingle 2720 points, certains objets 2650,
objet photo 25100 points.
Le portail moteur. Nous allons le laisser
là, car cela devrait être séparé. Ensuite, vérifiez les points
dont nous avons besoin et le suivi. Donc pour tablette. Pour que nous obtenions ici
l'auto-complétion. J'utilise ici un
entier et deux pour le compte et la définition
ici des centres IRR numériques. Il itère donc jusqu'à 01234. Ensuite, oui, je
dirais notre tableau, puis identifiez les points
d'objet. Et je pourrais dire « Check Trigger ». Et c'est faux car
vous n'êtes qu'une fois les points et qu'un capteur
doit être adressé manuellement. Et ce sont les portes
modales parce que plus
la cible est séparée, le
Watergate est vrai. Oui. C'est tout ce que
nous devons changer. Donc téléchargé une
fois de plus, pas de compilation. Eran allume la caméra. J'ai ajouté une LED supplémentaire, qui est également implémentée
dans la partie violon, mais nous y arriverons
plus tard, ainsi de suite. cérémonie Dan devrait être le
même résultat qu'avant, mais avec un certain changement,
tout fonctionne bien. Nous avons donc adopté l'ensemble du programme de manière
plus pratique, manière plus simple. Donc, quand nous devons
changer quelque chose, c'est très, très simple. Et comme je l'ai mentionné
dans mon projet, j'ai ajouté ici 11 capteurs et je pense à savoir si vous
devez changer quelque chose, et je ne suis pas vraiment assez
flexible. Et c'était cette construction. Nous pouvons adapter notre code de
manière plus facile.
34. Simuler le moteur hors tension: Dans cette vidéo, nous
aimerions maintenant simuler le moteur. Le moteur est là, la LED, et utilisez
le bouton-poussoir. Nous pouvons démarrer le mortier. Et puis si le marbre
monte, monte,
monte, sur le dessus de notre
planche Galton, il y a le cortège. C'est le centre. Et lorsque le marbre frappe ou passe devant
ces ERS et ainsi de
suite, le moteur
s'éteint et cette fonctionnalité que nous
aimerions implémenter. Par conséquent, nous devons maintenant
passer au RPC principal. Et nous déclarons ici
deux autres variables. Ici. La LED Integer est un entier. Le bouton est, alors jetons un coup d'œil. Mon bouton est sur la broche 12e
et D fait partie d'une équipe CERT. Ensuite, dans la configuration, nous devons épingler les modes. Le bouton de mode broche est
un pull-up d'entrée, et la LED PinMode est une sortie. L'une ou l'autre fonction boucle. Nous voulons vérifier si
le bouton est cliqué. Par conséquent, nous disons si. Et comment pouvons-nous le faire
avec le bouton de lecture numérique ? Et il doit être bas car j'ai connecté le
bouton vers le bas, au sol et une fois
une broche au GPIO. Par conséquent, je dirais que si le bouton de lecture
numérique est inférieur à quelque chose
. Et dans ce cas,
DigitalWrite LED haute. Nous allons donc allumer le moteur, et ici nous allumons la LED. Donc, la prochaine partie sera lorsque le
cortège sera déclenché, notre capteur à la fin, il devrait s'éteindre. Par conséquent, nous le
repassons au capteur ER afin d'avoir accès à notre variable. Nous devons dire LED entier
externe. C'est ainsi que nous disons le programme. Veuillez regarder en dehors
de ce programme. Cette variable doit être identifiée sur l'
externe car terme
x est défini
en dehors de ce fichier. Le cortège est donc là. Si des motorcades une fois,
nous pouvons dire si c'est LED numérique
déclenchée et qu'elle est faible. Nous allons vérifier le compilateur. Et Lester, ESPN. Le camp. Sommes-nous sur ? Encore une fois, le
moniteur série est déjà ouvert. Sun maintenant, on
se connecte à la chasse d'eau. Voyons donc ce qui se passe. Les points normaux
devraient fonctionner comme avant. Et quand je change maintenant, je suis en marche, appuyez sur le bouton. Et c'est le cortège. Et le cortège sera
déclenché pour un M. Relieve it. Oui. Joli. Et les points
fonctionneront comme avant. Maintenant, dans notre cas, nous avons appuyé sur le bouton et c'est
ce que je n'ai pas non plus fait. Le premier concept, le
modèle sera affamé. Le modèle, le modèle,
le modèle amène le marbre au
sommet. Il y a un capteur. Le capteur sera déclenché
pour que le moteur se décolle. Pas trop. Trop de billes
arrivent au sommet en même temps. Et puis le marbre
prend le chemin vers le bas,
alors nous avons éteint. Ensuite, il déclenche l'un
des capteurs et cela nous donne maintenant
le capteur plus tard, les points qui
seront livrés.
35. Évaluation des capteurs de l'IR: Dans cette vidéo, je
voudrais maintenant implémenter,
implémenter la méthode
d'étalonnage. Parce que lorsque vous pensez
à l'ensemble du projet, j'aimerais savoir à quelle fréquence chaque capteur sera déclenché
et quels sont les points. Je vais revenir. Parce que comme vous pouvez le voir ici, nous avons ici et la valeur de retour, mais nous ne l'avons pas
implémenté ici aucun retour, et cela doit être implémenté. Je voudrais donc tout d'abord
vérifier si nous avons
attribué les points. Les points sont attribués. Et maintenant, j'aimerais
appeler ici à ce stade. Néanmoins, s'il s'agit
d'un cortège ou non, la méthode d'étalonnage, la
méthode d'étalonnage pourrait être : C'est un sens large de notre étalonnage à
double point à double liaison. Dans cette fonction, je ne
veux que revenir et envoyer textos car je ne m'
intéresse qu'aux points d'épingle. Et à quelle fréquence dois-je l'utiliser ? Et donc, j'ai des
variables membres, un membre privé
appelé dans les durées. Et nous réitérons celui-ci. Et maintenant je peux voir l'impression en
série f. et je veux avoir
trois variables. Le premier peut être un capteur, et il s'appelle la broche du capteur. Ensuite, je pourrais ajouter une
deuxième valeur. Et ce sont les points importants. Également un format entier. Et les points sont les points. Et en dernier lieu, nous pouvons également ajouter ici les
itérations, les durées. Et c'est aussi un entier, appelé itérations de
comptage. Nous revenons chaque fois
et le capteur est déclenché. Ce capteur de ligne
points d'épingle, itération. Ça a l'air bien. Un peu plus. Les crochets diraient
dans ce format. Et la fin que je
fais une fois le saut de ligne. Et ça a l'air bien jusqu'à présent. Alors, nous choisissons le bon projet,
téléchargez le tout. Et maintenant, nous devrions obtenir
ici quelques commentaires dans notre moniteur de sérum lorsque le
compilateur ne voit aucune erreur. Mais je pense que c'est
beau jusqu'à présent. Ensuite, nous téléchargeons
l'ensemble du croquis. Ouvrez le barrage de la cérémonie. Et comme avant, nous pourrions commencer
ici, le moteur moteur, et nous voyons ici le
capteur du moteur broche 0,30 point, l'itération un, l'itération 234, et les divergers qui commencent
nous avons ici dix points. Nous avons ici le deuxième, 20 points, 50 points, 100 points. Et les différentes
itérations
seraient en cours d'itération. Très, très bien. C'est ce que je veux. Et maintenant, vous pouvez imaginer que vous pouvez le faire dans
un processus automatique. Là. Merveilleux monte, descend. Il collectera les
points et les itérations. Et puis vous pouvez
également résumer ici, distribution
normale quand
tout s'est bien passé. Mais ce n'est pas ce que je veux dans un environnement
productif. Il s'agit uniquement d'un étalonnage. Nous pouvons désactiver cela. Et ici aussi la douleur centrale. Je ne veux pas, je ne
veux récupérer que les
points que je veux. Par conséquent, nous pourrions
dire,
par exemple , définir une nouvelle variable. C'est ce qu'on appelle la sortie entière. Et nous le retournons à la
toute fin pour que nous
puissions être sûrs qu'il
y a quelque chose. Retournez ici. On pourrait dire que la sortie est de
0 point, par exemple. Maintenant, vous devez imaginer
que lorsque vous avez peu d'autres logiques, par
exemple, vous pouvez
ajouter des points bonus, des leviers bonus, etc. C'est toujours une bonne
idée de placer cela dans une variable extérieure et
ne mettez pas seulement les points. Ensuite, nous revenons
au RPC principal car ici la
valeur de retour ne va nulle part. Par conséquent, j'
implémenterais ici également sur D2L dans une nouvelle variable, elle s'appelle des points obtenus. Et nous voyons ici ce qui me donne ces
points dans cette pièce. Et si Galton pointe
plus de 0, parce que 0 est notre portail moteur
, centimètre les
points via MQTT, par
exemple, ou envoyez-les
via des événements côté serveur. Des événements côté serveur ont également eu lieu
dans ce cours en ligne dans l'exercice de ciseaux en papier rock. Nous pourrions donc également commencer mortier via des sites Web sur l'ESP, ou nous pouvons gérer leurs points et les
renvoyer sur notre site Web. Mais ici, nous pourrions aussi, oui, envisager une impression
uniquement à des fins de débogage. Points D. Et nous revenons
ici, le deck a obtenu quelques points parce que ce n'est pas une bonne
approche lorsque nous
traitons ici à l'intérieur du principal. Et quand nous
reviendrons de toute notre classe, seuls les points et toute
la logique seront mis en œuvre
dans la partie principale. Une fois de plus,
nous téléchargeons notre fichier. Et voyons ce que dit
le compilateur. Normalement, c'est
toujours bon signe. Ensuite, téléchargez le
tout une fois de plus et maintenant la cérémonie devrait être un
peu plus claire. J'ai raté le saut de ligne. Donc 11010202050, Un 100. Et aussi les portails du moteur. Le cortège devrait être
en dehors de la boucle for, puis il se trouve dans les
marchandises vendues jusqu'à présent que nous avons mis en œuvre également sur les
points et le cortège.
36. Aperçu du projet d'artisanat: Voyons donc le projet
terminé. Tout d'abord, l'élévateur
en marbre sera alimenté par un si
petit motoneurone. Et le moteur est
fixé au bas. Donc, quand j'appuie
ici sur mon bouton, il est connecté via
MQTT, marbre lift one. Et voici le cortège
qui a déclenché le moteur. Une fois de plus, moteur va continuer jusqu'à ce que
le cortège
soit déclenché. Ensuite, le
marbre va tomber. Et selon le capteur qui sera déclenché
et récupérer points à
mon nœud rouge,
le courtier MQTT Birmanie est également connecté. Maintenant, j'ai vécu plus longtemps
et c'est fini.
37. Récapitulatif des IRSensors OOP: vous félicite à la
fin de ce chapitre vidéo. Et j'espère que vous avez eu
autant de plaisir que rendre le code source de
cet objet orienté de manière. Prenons donc quelques secondes pour récapituler toutes les leçons
que nous avons eues ici. Tout d'abord, nous avons créé vos différents
objets afin que nous
puissions vérifier si certains capteurs infrarouges
seront déclenchés. Ensuite, nous avons créé
une zone afin que puissions contrôler
le recensement annuel et la façon dont
il est orienté
objet ici est
plus
gênant le recensement annuel et la . Une fois, nous montre les avantages que nous avons créés
et la fonction d'étalonnage. Et cette fonction d'étalonnage nous
donne le sens de l'
épingle, le nombre d'intégrations, saisie de points et la
réflexion. Comment pourriez-vous facilement développer
cela avec une certaine fonction ? Ce ne sera pas si facile,
car vous en avez besoin ici. Différents types d'
itérations, de variables et de contrôle des
différents types de capteurs. D'une certaine façon, ce ne sera pas si facile. Il serait réalisable, mais pas aussi pratique qu'
une manière orientée objet. Nous créons un plan
pour un cas. Et ensuite, chaque objet peut utiliser ce Blueprint et
c'est là que je pense qu'il est si
précieux en ce c'est là que je pense qu'il est si qui concerne le code source. Chaque fois que vous avez différents
types de capteurs, beaucoup d'entre eux, plusieurs d'entre eux
, utilisent votre objet,
écrivez votre propre classe. Il sera plus rapide et beaucoup plus flexible, tant pour le récapitulatif. Et maintenant, nous allons passer
au prochain exercice et
à la vidéo suivante.
38. Fil: Alors virion partie de ce
projet est très, très simple. Nous avons donc ici et USB 32. Nous avons deux LED, deux résistances et
un bouton-poussoir. Le bouton-poussoir
sera connecté à la planche à pain du
sol au bouton-poussoir. Et de l'autre côté, nous connectons ici, le bouton-poussoir
aux GPIO2 et 13. Dans mon cas, nous
connectons également le sol de l'ESP, donc T2 à la planche à pain. Cela aura donc le
même potentiel pour les LED. Et comme je l'ai mentionné dans le
premier exercice pratique, cela dépend de la
couleur de la LED, résistante à l'unité. Et cela dépend aussi si vous
utilisez un Arduino ou un ESP 32. L'ESP 32 prend en charge ici 3,3 volts et l'énol peut délivrer
cinq mots de GPIO. Et à ce sujet, vous
devez calculer la résistance. Il suffit de
regarder de plus près l'une des premières vidéos
de la classe LED. Là. Je l'ai mentionné un
peu plus en détail. Ici, mon cas était l'ESP 32, j'utilise juste une résistance de 100 ohms
pour les deux parce que c'est
juste à des fins d'entraînement. J'ai donc connecté la terre
à la cathode de la LED. C'est la petite épingle
puis l'épingle de lave que nous
connectons à leur résistance. Et de la résistance
au GPIO numéro 25 en
passant par la résistance rouge. Un vert, qui est affiché
ici avec un bleu. Je me suis connecté,
comme le rouge. Ainsi, relier les
bases à la cathode, puis la broche la plus longue qui
traverse la résistance et de la résistance
au numéro GPIO 12e. Et c'est tout pour cet exemple, le reste sera le programme
codé dans le code source.
39. Ajouter un bouton de cours: Commençons par un
nouveau projet. Je me sens inclus dans la lampe frontale
et dans le CPP principal, je l'édite ici
et Sarah commence. C'est tout ce que j'ai fait jusqu'ici. Maintenant, ce que j'aimerais faire, c'est mettre en place toute la construction de la
classe. Par conséquent, nous cliquons avec le bouton droit
sur le nouveau fichier source. Et nous disons ici, bouton point h, et nous appelons un nouveau fichier, le point de bouton CPP,
le combattant de clic droit, ce bord se divise à droite. Ensuite, nous voyons que l'explorateur
devrait s'en aller. Et maintenant, nous avons ici
notre IDE de développement. Et je voudrais commencer par
définir le bouton point h. Tout d'abord, la classe,
elle s'appelle bouton. crochets bouclés s'ouvrent,
se ferment, point-virgule. Ensuite, la prochaine consiste
à inclure des gardes. Si N def bouton bord, alors nous pourrions dire définir le bouton H et la toute
fin avec l'ouïe. Et si j'incluais
Dieu, c'est fini. Alors, quel est le
troisième, le serpent ? C'est toujours la même chose. Nous devrions inclure
l'Arduino tête haute. Et ainsi de suite. Le fichier d'en-tête est, donc cet état est terminé. Ensuite, nous sautons sur
le bouton point cpp, je suggérerais que
nous ajoutions ici. La première chose inclut
le bouton de ce bord. Et nous incluons
l'Arduino. Jusqu'à présent, c'est tellement bien. Et ce dont nous avons également besoin
ici sera là. J'ai l'air droit point h. Donc nous aurions besoin plus tard pour
les LED afin que
nous puissions l'alimenter avec PBM,
leur police, pour posséder l'explorateur en cliquant
sur la plate-forme en Lui. Nous devons ajouter ici la
bibliothèque externe et regarder bien. Et je
suggère également que nous entendions ajouter le port du moniteur à partir de mon, dans mon cas, c'est
la troisième colonne. Nous avons réglé la vitesse
à 115200 ou dans un cadre et la plate-forme
expressive et selon vous, nous utilisons PIM
pour configurer le port. Sauvez près du sang. Et nous avons ici tout ce dont nous avons besoin pour
le bouton cpp. Ensuite, je
suggère également que nous sautions
dans le CPP principal et que la référence inclue la périphérie du DOD afin que nous ayons ici tous les fichiers référencés
dans nos trois fichiers. Ensuite, les recrues définissent l'
ensemble du fichier d'en-tête. Cela signifie que nous pourrions dire ici que
c'est une dette technologique apportée et comme un bref rappel et actes
protégés ici dans le bouton de
classe point HHS, privé. Lorsque nous héritons plus
tard dans toute la classe
, ce sera en tant que
membre public et public. Donc protégés en charge, bouton, pin, entiers, dates et résultats entiers dont
nous avons besoin plus tard
et sur le public, nous avons ici le constructeur, qui nous emmène et épingle. Nous avons la
fonction de démarrage et nous avons le bouton
Jack avec le paramètre de
retour en tant qu'entier, cliquez avec le bouton droit sur
Format du document. Et nous avons également formaté
notre bouton point h. Je saute sur le bouton CPP. Et je veux, je veux vous
implémenter le constructeur. Par conséquent, je dis bouton, c'est
ce qu'on appelle la classe,
puis double point, double point, bouton
dans le drop-in, crochets
bouclés ouverts, fermés, et c'est une broche de bouton. C'est notre membre protégé, c'est la goupille que nous passons
à travers le constructeur. Ensuite, nous allons
au RPC principal. Et puis le CPP principal, ou nous
faisons ici un objet. Nous lançons un bouton d'objet,
bouton d'édition ici. Et dans mon cas, le bouton
est placé dans un objet de stratégie de groupe certain, dans cet exemple, nous passons simplement la valeur à notre classe et nous ne
configurons pas le mode PinMode. C'est un autre type d' approche que j'
aimerais vous montrer. Bien sûr, vous pouvez également
créer le mode PinMode. Mais jusqu'à présent, c'est bon. Nous l'avons déjà mis en place, notre classe, notre bouton principal, le RPC
et le CPP principal. Nous sommes maintenant prêts à
citer le reste.
40. Bouton de déjeuner avec millis: Dans cette vidéo maintenant, nous voulons équilibrer le
bouton et préparer le code afin que nous soyons à l'
étape suivante puisse utiliser l, identifier combien de temps
nous avons appuyé sur le bouton. Mais avant de pouvoir le faire, nous devons configurer
ici notre bouton, et donc le bouton CPP M, nous déclarons
une autre fonction. C'est ce qu'on appelle blancs, bouton, double point, double
point, début. Ici, nous sommes
en train de définir les modes épingles. C'est la broche bouton. Et j'utilise ici
et les entrées
remontent pour que nous ayons un bon signal. Et je pense que dans l'environnement
Arduino, vous devez également entrer dans le pull-up. Sinon, vous
n'utilisez que la valeur de l'entrée. Et je suis aussi assis ici à
la variable d'état en haut. Nous arriverons plus tard. Pourquoi est-ce que nous faisons cela ? Donc en
revenant au fichier CPP principal, dans la partie configuration, nous voyons ici que nous utilisons
le bouton vers le haut, Il y a un bouton que nous
n'avons pas initié, mais l'objet avec bouton, bouton LED, c'est notre objet maintenant que
nous sommes initiés. Et maintenant, nous pouvons dire
bouton, point de départ LED. Et maintenant, nous avons
le mode PinMode prêt. La prochaine étape sera donc de
faire ici le bouton de vérification. Et encore une fois, je
change cela en blanc car
nous utilisons ensuite l'entier,
le paramètre de retour, mais dans la première étape, nous n'en avons pas besoin. Donc, nous disons quel bouton, double liaison, double
liaison, bouton Check. Et ce bouton Check sera
appelé dans chaque boucle. Nous sommes donc passés au CPP
principal et disons bouton, LED et bouton de contrôle. Je suggérerais donc que nous n'
écrivons que quelques lignes de code. Ensuite, nous avons téléchargé sur
l'ESP et nous allons, une fois de plus, passer en revue
l'ensemble du code. Tout d'abord, nous
définissons une variable. La variable sera un entier. L'état précédent est l'état et l'état est numérique. Broche, bouton, goupille, bouton, épingle. Donc ce que vous faites ici, nous parcourons
cette fonction en boucle. Chaque boucle, le dernier état du bouton sera la sécurité
et l'état précédent, et l'état réel
sera enregistré ici dans l'état. Pourquoi faisons-nous cela ? La raison en est que nous pouvons maintenant identifier quand quelqu'un a
appuyé sur le bouton. Et c'est très facile. Nous pouvons dire que si
l'état précédent est plus élevé, l'état est bas parce que j'utilise ici le pull-up d'entrée et je suis connecté au
bouton au sol. Mon état bas signifie que lorsque
j'appuie sur le bouton, haut, est-ce quand c'est le cas, je ne nous donne aucun signal ? C'est la raison pour laquelle je vous
donne un design de séjour. Cela signifie qu'au
tout premier début, nous n'appuyons pas sur
le bouton et que nous sommes
initiés avec le signal élevé. À l'intérieur de ce champignon se trouve
dans cet état si. Nous faisons du remaillage
ici à la fois. Par conséquent, j'ai besoin d'une
ou de deux variables supplémentaires. Je vois donc ici un bouton long
non signé, millisecondes
cliquées et bouton
long
non signé en millisecondes. Qu'est-ce qui n'est pas signé ? Non signé, c'est lorsque nous
déclarons une variable, nous avons moins une partie
puis une partie plus. Chaque chose a
la même taille. Mais lorsque nous voyons non signé, nous voulons juste le côté positif et nous prenons
toutes les valeurs sont tout l'espace mémoire et ne l'
affectons que sur le côté positif. Nous avons donc doublé
seulement la taille et le côté positif, est
ce que cela signifie
avec un long non signé. Parce que nous sommes les millisecondes. La durée de vie actuelle ne
peut pas être une partie négative. C'est la raison pour
laquelle nous l'utilisons. Donc, avec ce bouton cliqué en
millisecondes, nous pouvons maintenant attribuer le bouton. Cliquez sur. Millisecondes, c'est Millis
ce que vous faites maintenant ? Lorsque quelqu'un appuie sur
le bouton, les millisecondes et les millisecondes
actuelles seront affectées ici
au bouton cliqué. Et pourquoi faisons-nous cela ? Parce que maintenant nous pouvons
continuer et dire autrement si,
si l'état précédent est
et je pense que vous savez quoi, Il vient, bas,
l'état final est élevé. Ensuite, nous avons relâché le bouton. Parce que lorsque j'
appuie sur le bouton, la boucle se poursuit. J'appuie donc sur le bouton
et le bouton cliqué millisecondes sera affecté à leur durée
de vie
actuelle jusqu'aux millisecondes. Et par la suite, si
je le relâche, je peux
maintenant faire quelque chose avec le je peux
maintenant faire quelque chose avec le
bouton de
l'éditeur Millis
cliqué en millisecondes. Donc, mais voici, voici la partie logique. Mais une chose est que vous
manquez une monnaie parce que nous ne sommes pas
déjà discutés de ce qui
dénonce un bouton ? L'équilibrage signifie que lorsque
nous appuyons sur un bouton, il se passe
des choses mécaniques. Cette fonction mécanique
n'est pas très précise lorsqu' il s'agit de millisecondes, car le bouton appelé fermer
en une milliseconde, le circuit fort ou le
courant. Et c'est pourquoi nous avons
reçu des signaux mitigés. Ce processus nécessite donc quelques
secondes, quelques millisecondes, et l'arène peut reconnaître
ces millisecondes et
nous émet un signal allumé, éteint, allumé, éteint. Et cela se produira
également dans notre croquis. Cela signifie que nous
avons le spectateur
recevra quelques signaux de plus
que ce à quoi nous sommes habitués. Créez votre ligne
d'impression en série pratique. Et nous voyons ici
BoutonClicked millisecondes. Donc normalement, nous devrions
appuyer sur le bouton, rien ne devrait être imprimé
sur le bouton 0. Et quand je le publie,
alors nous obtenons, je pense que plus d'un résultat. Et c'est la raison du
rebondissement du bouton. Nous allons donc télécharger le
croquis sur notre ESP. Ensuite, éteignez l'appareil photo. Et vous pouvez voir ici
les moniteurs 0 activés, en supprimant
simplement les anciens. Et maintenant, je suis enfoncé
sur le bouton et je le relâche. Et vous pouvez voir que vous obtiendrez
ici quelques lignes de code et cela
rebondit sur le bouton. Cela signifie qu'il ne peut pas le fermer assez
rapidement pour obtenir
un signal vraiment clair. Ce que nous pouvons faire maintenant, nous avons mesuré lorsque
nous avons cliqué sur le bouton. Et cela pourrait
nous être utile car maintenant nous pouvons
continuer et dire,
si, par exemple, nous
listons le
cycle de vie actuel moins le
bouton cliqué en millisecondes. C'est alors que nous
appuyons sur le bouton en moins 50 millisecondes, car
c'est ce qui ne nous intéresse pas. Voici la zone des limites, rien à faire uniquement à
des fins d'entraînement. Ensuite, nous disons, sinon. Si le signal est supérieur à
50 millisecondes, nous ne devrions obtenir ici une ligne droite
téléchargée une fois de plus. Ensuite, nous discutons de
l'ensemble du code. Encore une fois, le code est téléchargé. Ensuite, je suis redémarré. Cliquez sur le bouton
et relâchez-le. Donc, le long clic toujours, plupart du temps fonctionnera. Mais si je
clique sur un clip court et court, alors vous pouvez voir ici qu'
il est en D équilibré parce que je n'en ai qu'une seule ligne
droite et c'est ce que nous voulons. Non, pas de rebondissement du
bouton, il suffit de cliquer. Et maintenant, nous avons un signal
très précis et nous en obtenons de bons
résultats. Alors encore une fois, qu'
avons-nous fait jusqu' ici avec les météores et les états
précédents ? Ensuite, l'
état
nous donnera un signal depuis le bouton, et l'état précédent
sauvegardera le statut d'avant. Ensuite, nous sommes assis ici
avec le premier si, si l'état précédent est élevé et cela signifie que
rien n'est poussé, et maintenant il est poussé. S'il vous plaît, enregistrez-moi
dans
les millisecondes dans le
bouton variable en millisecondes cliquées. Et je maintiens le bouton enfoncé et la boucle
continue et continue. Maintenant, je relâche le bouton. Maintenant, dans la boucle suivante, nous sommes ici car l'
état précédent est maintenant bas. Et l'état est élevé. Élevé signifie que j'ai
relâché le bouton. La différence entre les Millis se termine, le bouton cliqué. S'il est court ou
inférieur à 50 millisecondes, ne
faites rien d'autre. S'il vous plaît, donnez-moi une
logique ici dans cette partie. Dans les prochaines vidéos,
nous pouvons définir ici s'il est supérieur à 5200. C'est donc dans ce domaine que nous pouvons définir les différents
types de pressions de clic. Nous avons donc deux choses. Dans une logique, nous sommes
profondément rebondis sur le bouton et pouvons également identifier la
durée pendant laquelle quelqu'un a appuyé.
41. Détecter la durée des clics: Et maintenant, nous voulons identifier
deux types différents de la durée pendant laquelle nous appuyons sur le bouton. Et ce sera très,
très facile maintenant pour nous, car maintenant nous ne faisons qu'ajouter un autre si. Et nous voyons ici, milli est moins cliqué sur le bouton. Donc, le tout est
supérieur à 50 et j'ai besoin d'un
peu plus d'espace. Toutes les choses ici devraient être inférieures à 200 millisecondes. Cela signifie que s'il est
supérieur ou
inférieur à, il se passe quelque chose. Il n'est donc pas assuré. Cliquez ensuite sur tout le truc. Recopiez-le. bouton ELSE si supérieur à 200 et
moins de 900 millisecondes, par
exemple, est un bouton OnClick. Voici donc la
zone de dénonciation. Il ne se passera rien. Et après les millisecondes de 50 à 200 ou un
clip court doit être identifié
et après un long clic. Alors téléchargez le
tout une fois de plus, et regardons de plus près. Si vous pouvez maintenant identifier les
différents types de clics. Croquis vers le haut. Ensuite, je clique sur
court, court,
court, long, long, long, long, court. Et comme vous pouvez le constater, une
normale sans rebondissement. Tout est un
lien profond en ce qui concerne les clics
clairs et clairs, une
seule ligne à un clic, et c'est ce que nous voulons. Joli. Ainsi, comme vous pouvez le voir, nous avons plus simple avec
une logique et des livres D. Et nous pourrions identifier
différents types ici de la durée pendant laquelle nous appuyons sur le bouton. C'est donc sur votre créativité si vous voulez ajouter
plus de fonctions, mais je pense que deux ou
trois devraient suffire. Parce que sinon,
il sera difficile d'
identifier la durée de nos
trois secondes, mais cela dépend de votre projet et maintenant
votre domaine peut se
sentir, n' hésitez pas à créer vos propres longueurs de brevet et identifier les différents
types de mesures.
42. Interface propre: Cette vidéo maintenant, nous voulons garder la classe un
peu plus générale et refroidisseur signifie que nous nous
débarrassons de certaines choses spécifiques car plus tard, nous le ferons
dans d'autres projets, par
exemple, si nous Je veux utiliser le brevet CPP et le bouton point h, notre classe, également dans le projet. Et il n'y a pas besoin d'implémentations
spécifiques, nous avons
donc besoin de toute la salle. L'ensemble de la
partie logique doit se trouver dans le RPC principal et non
dans le schéma du RPC. Je vous montre ce que je veux dire. Nous passons
au bouton Checkout et nous
renvoyons la valeur en entier. Également dans les boutons, le BPM que nous
modifions ici sous valeur de
retour en entier. Et ce que nous faisons maintenant, c'est que nous
définissons ici trois États. Par exemple, le théorème de la valeur de
retour. n'y a rien à faire. Rien à faire. Si nous obtenons un retour, il s'agit d'un clic court et
sinon c'est long. Par conséquent, nous avons
déjà une variable, appelée résultat. Et je suggérerais
que nous faisons ici résultat de 0 signifie que nous n'
avons rien à faire. Alors qu'il pouvait le résultat 0. Mettez, insère la première chose parce que je n'ai rien à faire non plus. Et aussi dans l'
erreur de dénonciation, rien à faire. À la fin, nous retournons le résultat et le court clic. Nous décommentons l'impression en série. Nous disons simplement que le résultat est un. Et dans l'autre si
c'est le résultat est deux. C'est mon flex
et je suis revenu au flex et j'ai tous les cas ici. Aucun résultat n'est attribué, il doit
donc être
renvoyé dans chaque boucle. Et 0 ou un ou deux. C'est ce que je veux dire a été
généré dans le prochain projet. Vous pouvez l'utiliser et
également identifier
les différents types
d'états après les résultats et faire quelque chose
dans la partie principale. Et c'est ce que nous faisons maintenant, en
passant à la partie principale. Et maintenant, cette fonction va nous
fournir et nous rendre de la valeur. Et cette
valeur renvoyée sera capturée, par
exemple, dans le cas de changement. Nous disons donc interrupteur et
nous disons le cas 1, boîtier de
frein à la
bulle. Il s'agit donc des principaux fonds
structurels, quel cas ? Cliquez avec le bouton droit de la souris sur Format du document
et insère le cas, nous pourrions dire série, impression, ligne, fraude clique à partir du CPP principal. Et dans le cas deux, nous devrions avoir
ici un long clic. Puis les téléversements une
fois de plus sur notre USBE 32. C'est ce que je veux dire par «
Keep it General », car maintenant tout
le schéma du RPC nous
donne une valeur de retour. Et néanmoins, ce que
nous faisons maintenant, nous attrapons ici les valeurs de
retour dans quelque chose et c'est une bonne façon de les
garder une interface propre. Allumez ensuite la caméra et
ouvrez l'heure de la cérémonie. Et maintenant, nous devrions
voir le même résultat. Clip court, clic court,
onclick, onclick probable. Même résultat. Interface plus propre. Et maintenant, nous pouvons également utiliser notre propre bibliothèque dans
d'autres projets.
43. Contrôler les LED: Il est maintenant temps que nous puissions également contrôler nos LED à l'
aide du bouton. Par conséquent, nous
définissons deux variables. On peut dire que c'est une lecture LED. J'ai le GPO 25, et la LED verte est sur
GPO 12e. Dans mon cas. Dans la configuration, nous devons
créer un mode PIN. Le voyant rouge en mode Pinmode est des sorties. Copier le collage. LED verte est également une sortie. Nous nous sommes donc déjà préparés et
maintenant nous pouvons contrôler nos LED. C'est aussi facile. Vous pouvez dire ici, et les droits
numériques LED. Mais un court clip, j'ai utilisé, gris est haut. Et nous pourrions maintenant dire
travailler avec des drapeaux, par
exemple, s'il est allumé, alors nous le réglons à un niveau bas. Est-ce souvent que nous sommes plus élevés ? Mais je suis sûr que vous avez déjà
regardé la classe LED ainsi sur l'exemple précédent et l'exercice dans
ce cours en ligne. Et là, nous avons basculé une LED. Ainsi, les droits numériques, par exemple, nous pourrions utiliser ici, LET green, et ici dans la partie
haute ou basse, nous disons que le numérique
lit LED vert. Et ce que je fais maintenant,
c'est que je suis assis ici. Si la broche est allumée, alors je
reviens ici et haut, mais je ne veux pas un haut parce que je
veux le basculer. C'est pourquoi je suis
en train d'inverser le signal. Et je vois que lorsque je suis
plus haut, il est inversé trop bas. Si la LED est éteinte, j'arrive ici et bas et interrogation, point d'exclamation. Nous sommes en train de fixer le bas au plus haut. C'est donc tout
ce dont nous avons besoin ici. Avec basculer la LED, l'impression 0, je le garde, je le
garde, car alors je peux voir ce que nous obtenons dans la boucle. Et si vous lisez, ça devrait bien se passer.
C'est vrai ? projet. Puis il télécharge le tout. Et maintenant, en quelques clics, nous devrions voir ou devrions l'activer. Le voyant vert est sur un long clic, la LED rouge doit être allumée. Alors allumez la série, surveillez-les et
cliquez sur la prise de vue. Cliquer longuement. Et ce que
nous pouvons faire maintenant, c'est manquer des raccourcis et cliquer
court et long. Et comme vous pouvez le constater, les
deux fonctionneront même temps,
car nous
contrôlons simplement les GPIO à l'
aide du bouton PIN. Et c'est ce
que je pense que cela rend si puissant car
maintenant, comme vous pouvez le constater, nous n'avons que plusieurs
lignes de code. Toute la logique générale
se trouve dans le bouton. Et maintenant, nous avons ici un bon exemple de ce que nous pouvons faire avec un bouton
et plusieurs états.
44. ButtonHeadlamp frontale hérite du bouton: À ce stade d'un projet, nous avons maintenant terminé
notre cours de modèle
général. Bien sûr, vous pouvez
y ajouter d'autres points. Ce que vous utilisez
régulièrement pour pouvoir utiliser
cette classe et que vous projetiez individuellement encore et encore. C'est pourquoi nous faisons cet
objet de manière orientée vers l'objet. Mais cela peut aussi se produire
maintenant que nous avons, maintenant et les circonstances et exigences que nous
avons aptes à notre classe, cette adoption n'est pas
utile lorsque nous sommes mis en œuvre dans la classe de base
générale, dans notre cas, la classe des boutons. Par conséquent, nous
créons une nouvelle classe. Ce que nous allons faire maintenant, c'est ce qu'on appelle le fusil
frontal bouton. Cela signifie que la base est la classe de base est
notre bouton point h. Nous avons hérité et ensuite nous pouvons
adapter certains extraits de code. Et c'est de manière plus utile, plus propre car les pièces individuelles sont
dans une classe distincte. La classe de base
est générale ou nous l'avons
gardée en douceur. C'est donc ce que nous faisons maintenant. Nous sommes en train de créer une nouvelle classe. Cliquez avec le bouton droit sur la source,
Nous cliquons sur Nouveau fichier et nous pouvons dire que
le bouton avait un point de lampe CPP. Et également cliquez avec le bouton droit sur Nouveau fichier, bouton, point de lampe h. Et nous commençons par
io.h standard
avec le fichier d'en-tête. Et maintenant, je pense que ce n'
est rien de nouveau pour vous. On pourrait dire lampe frontale à
bouton de classe. Et maintenant, nous voulons le déduire
de l'autre classe de base. Un bouton public à double insu, crochets
bouclés s'ouvrent,
se ferment, point-virgule. Que cela fonctionnera
de la bonne façon. Nous devons maintenant inclure
ce point de motif h. Et comme vous pouvez le voir,
la troisième fois que nous
incluons le
fichier d'en-tête à partir du bouton. Et c'est pourquoi nous avons
également besoin d'inclure des gardes. Mais avant qu'ils n'
incluent les gardes, nous sommes ici et écrivons que H. Et maintenant le bouton Inclure la
garde F et le bouton sourd avaient un âge sous-jacent à l'agneau. Et puis nous avons la
fin de l'année, si c'est bien. Et à la toute fin,
nous voyons ici. Et si cela semble d'une
manière que je dirais, c'est bien jusqu'ici. Se divise vers la droite. Fermez celui-là. Maintenant, nous sommes en train de sauter dans
le ppc de promontoire. Par conséquent, nous devons inclure la lampe frontale point h et nous devons inclure
l'arduino dot h. Je suggérerais que
nous le faisons également ici,
afin que notre
environnement soit également dans la classe. Et maintenant, nous pourrions définir
ici la première chose. Par exemple, on pourrait
dire dans le fichier d'en-tête, point double
public, ensuite, l'aide d'un bouton double
liaison, double motif de liaison. Alors, qu'est-ce que c'est ? Nous utilisons le constructeur à partir du
bouton de la classe de base. Ouvrons-le encore une fois. Et comme vous pouvez le constater, c'
est notre constructeur principal, que nous sommes invoqués
dans le fichier principal ici. Et cela sera utilisé maintenant dans notre lampe frontale à bouton de
classe liée au développement. Et nous sommes en train de créer ici
et la deuxième fonction, c'est ce qu'on appelle White Check Fate. Nous pourrions également créer cela
ici dans notre bouton, dans notre fichier CPP. Et je pense que vous le connaissez
aussi. Bouton, lampe frontale, point double, double
point, vérifier le destin vient
de mes codes fantaisistes. Jusqu'à présent, c'est bon. Une petite adaptation que nous devons
faire dans notre dossier principal. Parce que maintenant, nous ne
voulons plus utiliser la classe des boutons car c'est le cas, ils sont liés à
notre lampe frontale bouton. Par conséquent, nous changeons ici. bouton avait une lampe frontale. Nous pouvons utiliser le même nom. Et nous pouvons également voir
ici le constructeur, mais pourquoi obtenons-nous une erreur ? Nous devons modifier
le fichier d'en-tête. Et c'est une lampe frontale. Et maintenant, tout
devrait fonctionner comme avant. Donnez-lui juste un chèque. Et je pense que
nous sommes prêts à y aller. Prochaine. Voyons oui,
dans la vidéo suivante. Nous allons maintenant leur mettre en œuvre
la fonction. Vérifiez le fondu, et aussi je suis un peu
plus fauché avec la classe.
45. Fonction Maintenir le bouton appuyé sur le bouton: Nous voulons maintenant ajouter une fonction ici dans notre classe liée aux données. Et nous voulons voir si le bouton est enfoncé pendant
plus de x secondes, par exemple. La bonne chose est maintenant
que nous avons un excès de toutes les choses de notre
classe de base, comme par exemple les variables et aussi
toutes les choses qui sont invoquées dans notre CPP
principal dans la boucle, nous vérifions ici, bouton allumé, bouton à cocher. Cela signifie qu'ici,
dans le bouton de contrôle. Je suis ici et un
bouton de contrôle que je vérifie l'année que le numérique a déjà lu et il ne sera pas sauvegardé
dans l'État. Et j'ai que x est également dans la
classe liée aux produits laitiers de l'État. Donc, je peux vérifier
ici si l'état est bas, cela signifie
que c'est le bouton pressé et
aussi le bouton Millis moins. Millisecondes. Plus de 2000. Je veux dire, deux secondes, 2
000 millisecondes. Ensuite, j'
aimerais imprimer sur ligne d'impression
série pressée
plus de deux secondes, et je suis hérité. Voyons donc voir. Ça
a l'air bien jusqu'à présent. Et nous devons
également mettre en œuvre la foi de contrôle dans notre principal RPC. RPC principal, ou il est déjà là. Donc ça veut dire bouton, c'est l'objet dot jag destin. Et maintenant, la fonction
sera appelée dans chaque boucle, nous obtenons les
états nécessaires et aussi le bouton cliqué dans la
classe de base que nous obtenons ici parce que le
bouton a cliqué en millisecondes. Et ici aussi, nous
constatons que les
variables sont attribuées et nous les
utilisons dans notre
classe de produits laitiers pour vérifier si le bouton est enfoncé pendant
plus de deux secondes. Par conséquent, nous
téléchargeons maintenant l'esquisse pour voir si nous
avons les anciennes fonctions, le clic court et le long clic. Et maintenant avec d'autres dans notre classe spécifique
où nous programmons ici très en détail dans
le modèle de lampe frontale. Kimara, la cérémonie est terminée. Et pas un court clic,
Lancer, cliquez sur. Maintenez le bouton enfoncé
après deux secondes. Ici, vous pouvez voir que je suis pressé
plus de deux secondes, 12. On y va. Encore une fois, nous
pouvons voir celui-là aussi. Et je suis en train de le mettre
au sein en quelques secondes. Oui. On y va. Et dans la vidéo suivante, nous mettons en œuvre
le composant de décoloration.
46. Ajouter une fonction Fade: Nous voulons donc maintenant mettre
en œuvre cette logique. C'est lorsque nous appuyons
et maintenons le bouton enfoncé, la LED doit être augmentée. Et normalement, nous le faisons
avec une boucle for, la chute de l'
incrémentation et de la variable, et nous passons
le niveau des incréments à une écriture analogique par exemple. Et donc, il devrait être automatiquement
augmenté chaque boucle. Mais ce n'est pas comme ça que c'est
censé être parce que nous le voulons, pas automatiquement. Nous voulons maintenir la clé enfoncée. Et lorsque nous le
relâchons, la luminosité augmente devrait être arrêtée. C'est pourquoi nous devons adopter une
approche légèrement différente ici. Nous avons donc ici également des exigences et des défis
que nous devrions surmonter. Donc, à la première chose, je dirais analogique, non ? Led vert. Et nous pourrions dire,
par exemple, de l'activer. C'est une étape que
nous voulons mettre en œuvre. Nous voulons l'incrémenter de 0 à 255, par
exemple,
il s'agit du niveau de luminosité
maximal. Le premier défi sera que
nous n'obtenons pas la
bonne LED ou notre variable. Bien sûr, nous pourrions
dire juste une valeur PIN. Mais l'objet de stratégie de groupe est
que cela pourrait être fait. Mais ce que j'aimerais
vous montrer, c'est que nous pouvons également accéder vos variables
en dehors de ce fichier, que je retourne au CPP
principal et que je peux voir ici nos deux variables. Et si, lorsque nous les plaçons au-dessus de la déclaration d'inclusion ? Parce que c'est le cas ici. Le compilateur va de
haut en bas et il peut peut-être y
accéder. Là. Led vert sautant à la lampe frontale à
motif juste pour
voir l'écriture ferme. Est-ce vrai ? Oui, mais je vois que ce n'est pas défini. Ensuite, nous pourrions copier les instructions LED
à l'intérieur du projecteur, mais nous avons ensuite une
double déclaration. Ce n'est pas non plus ce que nous voulons. Mais on pourrait dire ici, compilation
externe sait
maintenant, d'accord, quelque part en dehors de ce fichier, la LED lue en
vert devrait être définie et j'y accède. Et comme vous pouvez le constater
maintenant, cela fonctionnera. L'étape suivante est comment augmenter le niveau
de l'analogique, écrire le niveau de luminosité. Et par conséquent, j'aimerais utiliser ici et un entier statique, c'est ce que l'on appelle count par exemple. Et nous l'augmentons dans chaque boucle, la valeur de la variable, sorte que nous puissions ajouter la variable de
compte. Et pour autant que nous soyons dans la
boucle, brisez doucement le domaine. Vous pouvez donc voir ici que nous sommes ici. La fonction est appelée
dans la boucle principale. Et cela augmentera
notre niveau dans chaque boucle. Mais que se passe-t-il si lorsque nous arrivons
à deux cent cinquante, deux cent cinquante
cinq à 70 ans, ce n'est pas un bon moyen car nous avons
alors un débordement. Par conséquent, nous réinitialisons
notre variable de compte lorsqu'elle atteint
plus de 255. Et puis on peut dire que le nombre est 0, donc nous réinitialisons
le tout. Et nous pouvons aussi dire analogiqueWrite
sérum, donc nous l'éteignons. Et pour une visualisation correcte, nous
misons sur le retard des lits. Mais cela n'est qu'à fins de
formation et que
nous pouvons voir ici et plus encore. L'effet que je voudrais également implémenter dans un court délai de 20 millisecondes pour qu'il
ne se contente pas d'atteindre le 255, il va un peu plus lentement
jusqu'à la valeur souhaitée. Bon, jusqu'à présent, c'est bon. De quoi avons-nous besoin d'autre ? Je pense que c'est tout. Statique, d'accord ? Statique signifie qu'il sera
défini dans la toute première, lorsque nous l'invoquons,
c' est la toute première fois qu'elle sera définie ici. Ensuite, il a, maintenant la valeur 1 à la valeur
d'une boucle Next. Cela ne sera
plus invoqué car il suffit d'invoquer la ligne
par défaut la première fois. Maintenant, ce compte
a la valeur 1234. C'est une
façon très pratique de travailler avec juste à l'intérieur de cette lunette à partir du bouton blanc,
le
promontoire vérifie le destin. Et nous n'avons pas à déclarer globalement le nombre
d'entiers statiques. Voyons donc si nous avons
compilé l'erreur et la chair. Notre ESP. Ça a l'air bien, mais
on ne va pas le rincer. Parce que nous aimerions ajouter d'
autres lignes d'impression en série. Et j'aimerais
publier une variable de comptage afin que nous
voyions ce qui se passe ici. Et pour le cadeau de lecture, au contraire, plus d'espace ici, cliquez avec le bouton droit sur
Format du document. Jusqu'à présent, c'est bon. Revenons maintenant au fichier
principal parce que nous devons
adapter votre
quelque chose aussi parce que nous travaillons
ici
avec les droits numériques. Mais la décoloration
sera implémentée avec AnalogWrite et mixage,
analogique et numérique, n'est-ce pas ? Ce n'est jamais une bonne idée. Je suggère donc que
nous ayons également adapté une fonction pour que
nous puissions également s'estomper, mais aussi cliquer sur éteindre et
allumer à nouveau la LED verte. Par conséquent, nous devons également
mettre en œuvre sur peu de fonction
avec et marquer. Donc, dans le fichier principal que nous
définissons ici, dans le cas où l' on écrit la LED verte
est par exemple Sarah. Et nous voulons l'
activer avec 255. Et nous pourrions dire ici que nous avons besoin de N polaire statique. Est-ce qu'il est allumé ou éteint ? Et si c'est le cas, nous pourrions dire que nous l'éteignons. Et nous disons que c'est parti. Ce voyant s'allume lorsqu'il
est allumé. La LED est donc fausse
pour la suivante. Sinon. Quand c'est faux, on l'allume
simplement car c'est 255. Et c'est vrai. Et je veux également avoir cette impression en série qui vous permettra de
voir ce que nous faisons ici. Clip court du CPP principal,
cliquez avec le bouton droit de la souris sur Format du document. Encore une fois, ce que
nous faisons ici, c'est la peur et la piscine statique. En fait, le tout premier
début sera défini comme faux lorsque le clic arrive. Parce que c'est notre fonction bouton
Check qui en offre également une. Quand nous arrivons ici, un retour, la première étape
est que nous l'avons allumé. Led est vrai. Dans un clic suivant, LED. Led on est vrai. Ensuite, nous l'
éteindrons et ainsi de suite. Et c'est une
façon pratique de travailler avec flex. Une fois de plus, nous le
vérifions, puis nous pouvons télécharger notre fichier. Nous avons ici notre dossier principal. Cliquez dessus, c'est assuré, cliquez sur un court clic. Ensuite, quand je suis capable le tenir un peu et cliquer sur
plus de deux secondes, cela augmentera la décoloration. Je clique sur l'épaule, je
clique, je clique encore une fois. Et je vois qu'il
y a un double message parce que j'ai
mis en œuvre deux fois. C'est la raison pour
laquelle il a doublé. Mais quand même, maintenant
que je recommence à s'estomper, il devrait commencer par 141, maintenant deux secondes enfoncées. Et comme vous pouvez le constater, maintenant, il sera continu à 141, je clique encore une fois. Il est en pleine luminosité. Encore une fois, c'est éteint. Cliquez en moins de deux secondes. Celui-là est allumé. Courte, courte, courte. Ensuite, en gardant les seins pour
que nous ayons fait du vélo une fois la pièce jusqu'à 2552 secondes de retard, et c'est parti, et c'est parti. Très bien. C'est ce que nous voulons jusqu'ici. Cela signifie que notre fonction complète est parfaitement
mise en œuvre et
désactivée. Et dans la vidéo suivante, j'ai des
tâches supplémentaires pour vous.
47. Cours de mise en œuvre d'une tâche supplémentaire sur le LED: Maintenant, j'ai une
tâche spéciale pour vous. Nous aimerions
implémenter la classe LED, que nous avons également créée dans ce cours en ligne et
implémentée dans ce projet. Et ce serait bien quand nous, par
exemple, en un clic court, nous configurons la fonction d'
impulsion. Donc, un clic se pose et
un autre clic s'éteint. Et en un long clic, j'aimerais
allumer la LED rouge. Et après, par exemple, cinq secondes, la
LED devrait s'éteindre. Cela pourrait être un bon
cas, par exemple, pour certaines
portes de garage. Donc, lorsque nous voulons l'ouvrir, le panneau ou la LED vont s'épanouir. Cela signifie donc prudence. Il y a la porte qui s'ouvre
et lorsque nous partons, nous cliquons une fois de plus sur
la porte et la lumière s'
éteindra ou s'
éteindra au bout de six secondes. Cela pourrait donc être fait
avec la classe LED, mais il faut adapter ici le fichier CPP principal,
ce sera la tâche. Il existe de nombreux types d'approches et de solutions différentes. Dans la vidéo suivante,
nous pouvons résumer votre approche et
comment je l'ai mise en œuvre.
48. Solution possible: Commençons donc par
l'implémentation ou une solution possible en
ajoutant les deux LED
à notre espace de travail. Il suffit donc de faire glisser et de déposer les fichiers de
classes depuis la LED, qui ont été créés dans
les classes précédentes. Et l'une des premières
étapes consistait inclure, c'est point h. Et ensuite, à l'
étape suivante, nous pourrions dire d'
implémenter ou d'
initier l'objet. Alors, saisissons ceci en
majuscules. Laissez-vous lire ceci. Vous pouvez voir qu'il y a une
différence ici avec 25 et nous avons une LED verte avec 12e. Ainsi également à
des fins de visualisation, vous pouvez voir que nous conservons
ici les variables car elles seront utilisées
avec la fonction de fondu. Et cette fonction est trop
courte et le long clic, nous utilisons l'objet. Nous pouvons donc utiliser des objets
et des variables ou les broches
GPIO en même temps. Mais bien sûr, dans l'architecture des
biens, vous n'utiliseriez qu'
un seul type d'approche. Mais j'aimerais vous montrer que les deux sont possibles. Donc, en revenant un
peu à notre fichier principal, l'explorateur de fichiers,
nous fermons, et nous y allons. Donc, dans le fichier principal, nous pouvons maintenant entendre des adeptes, celui-ci parce que
nous ne
voulons pas ajouter ici cette fonction. Nous voulons mettre en œuvre la fonction d'état
pauvre. Et vous allez faire, et rappelez-vous, on peut dire
des points verts LED, croisade. Et nous avons besoin de temps, par
exemple, de 20 millisecondes. Mais cette fonction doit
être invoquée dans chaque boucle. Et ici, nous ne faisons que vérifier
si le bouton est enfoncé, ce qui ne fonctionnera pas. Par conséquent, nous devons travailler
avec certains drapeaux pour pouvoir également accéder au fonctionnement en dehors de
cette construction de commutateur. C'est pourquoi, comme je l'
ai fait auparavant, j'aimerais utiliser celui-ci. Ainsi, comme je l'ai dit, le nombre d'
entiers statiques est 0. Que dois-je faire avec eux ? Si le comte modulo deux est
Sarah, par exemple, je dirais continuer sur faux. Et continuer
n'est pas encore défini. Je vais donc monter un peu
et dire que le pulsat est faux. Donc, au tout premier début, je l'ai mis à faux. Ensuite, je suis un peu sombre. Sinon, par exemple, l'
enfile, c'est vrai. Et nous pourrions aussi dire ici, dire vrai et LED, point
vert s'éteint. Et c'est vrai, bien sûr
, parce que nous avons utilisé l'analogique désactivé et activé pour l'effet de décoloration
au produit. C'est la raison pour laquelle la
réduction ici devient vraie, mais je manque la déchirure mixte. Cela devrait être vrai et
cela devrait être faux. Qu'est-ce que j'ai mis en œuvre ici ? Cette variable sera affectée
à la toute première boucle. Ensuite, le modélisateur se divise toujours, nous
donne le reste
de la division. Donc divisé par deux n'a pas de repos. Et c'est vrai, donc ça va continuer. Puis un divisé par deux. Il y a maintenant quelques
registres, null, qui est la division, et donc il
saute à l'autre. Donc, chaque fois que j'appuie
ici, ils sont sur un bouton. Je dois également augmenter
la valeur de la variable. C'est juste une
fonction assurée où nous pouvons basculer. Et je dirais dans Fleck. Donc, en cliquant une fois pour marquer, cela deviendra vrai. La deuxième fois, elle
deviendra fausse. Et maintenant, en dehors de la structure du commutateur d'
hôte, je pourrais dire que
si le drapeau le met sur sa vraie, alors je voudrais dire parce que procéder
est alors dans chaque boucle, dans chaque boucle et cette fonction
sera également appelée. Ainsi, la LED peut s'
allumer et s'éteindre. C'est ce que nous voulons tester maintenant, car nous avons
apporté de nombreux changements. Nous pouvons donc être sûrs
que ces changements le sont. Configurez correctement, donc
éteignez l'appareil photo. Voyons maintenant. Si nous cliquons une fois. fonction pulsation
sera activée car ici, à la première
colonne 0 variable,
cette variable comme
une seule et la boucle, l'instruction if
est toujours vraie et la fonction prédéfinie
peut fonctionner correctement. . Encore une fois, je clique dessus. Ainsi, la variable de compte statique
sera maintenue sur
Un, Un modal ou deux n'est pas 0 et
donc elle s'éteint et le
dépôt sera activé
ou faux à nouveau. Et je peux cliquer,
cliquer, cliquer, cliquer, garder les deux secondes
et je peux l'estomper. Décoloration. Et il se passe de s'estomper. Cliquez à nouveau une fois. Et la procédure, nous travaillons. Mais ce n'est pas l'
ensemble de la fonction. La deuxième partie était que
nous voulions implémenter yum et activer et
désactiver automatiquement. Par conséquent, on pourrait
dire LED rouge, allumer. Et nous réalisons cela avec
des droits numériques. C'est bon. Et vous savez peut-être que nous avons peur et
fonctionnons dans LET CPP, et il est appelé «
désactiver » après retard. Mais ici, nous devons nous adapter un peu parce que
dans cette fonction, je suis, laissez-moi voir où elle se trouve. Nous sommes donc dans cette fonction
qui ne fonctionnera qu'une seule fois à la fois. Par conséquent, nous devons
dire que le milieu précédent est désactivé, c'est Millis. Ensuite, cela
fonctionnera correctement. Chaque fois, il sera invoqué. Retournez au CPP principal. Et cette fonction doit également être accessible en dehors de la construction
de l'interrupteur. Et donc nous disons que le
rat LED s'est éteint après un retard, par
exemple, 5 000 forces, ou disons 2500 et faux parce que nous
utilisons LED numérique, n'est-ce pas ? Encore une fois, nous
téléchargeons l'ensemble du croquis. Nous pouvons donc maintenant voir que nous pouvons
désactiver la procédure. Bien sûr, nous pouvons également
activer, désactiver le délai. Encore une fois, faites un allumage et un arrêt. Et aussi, la décoloration devrait fonctionner correctement comme nous l'avons vu auparavant. Une fois de plus, cliquez à nouveau et
il sera palpitant. C'est ce que nous avons été
créés pour accomplir des tâches. Et maintenant, nous sommes à la
fin de ce projet et avons
mis en œuvre une classe avec succès. Ils sont liés à la classe
et ont également implémenté une autre classe pour l'utiliser
dans notre projet principal.
49. Fil: Commençons par un aperçu de
la quincaillerie et de
la pièce de roulement. Comme vous pouvez le constater, c'est
très, très facile. Avec LED ESP 325. La LED est connectée au
sol, à une planche à pain. Et sur l'anode
et le côté positif, nous avons une résistance. Et puis nous allons au
GPI ou à partir de l'ESP 32, dans mon cas, cinq LED et je commence à moins cher ou à couler. Il est 19 ans, je vais me montrer en 1918. Ensuite, nous avons la GPL 51615 sur la partie supérieure d'un pour plusieurs modèles
en tant qu'équipe canine et G9. Et vous
ne pouvez en utiliser que trois. Par exemple, plus et moins, nous nous connectons
à la planche à pain. Et chacune des cellules
possède une épingle de données. Et nous connectons la
broche de données à GPIO, par exemple ,
14, vingt-sept,
vingt-six, vingt-cinq. Lorsque vous êtes en mode développement, je vous recommande d'
ignorer la pièce
V5 la breadboard car l'
USP est alimenté via l'USP. Et vous ne voulez pas avoir deux types de choix différents. Mais il est important
que vous connectiez le sol à la
planche à pain car les terrains, le potentiel
doit être le même. Ensuite, lorsque vous
partez, vous voulez avoir tout
le jeu à l'envers
ne sont pas connectés à votre PC. Ensuite, bien sûr, vous devez vous
connecter pour que les
ESP soient également alimentés. Mais j'alimente ensuite
les parois cellulaires avec un port USB externe avec un connecteur de
source d'alimentation externe. Et je le veux, je suis en
relation avec eux. adaptateur secteur 12e monde diffère ici et le régulateur de
tension, qui est configuré à cinq volts avec ce potentiomètre
dans un compteur numérique, je peux mesurer ici à cinq monde quand je fais défiler vers le bas ou en haut. Ensuite, je me connecte plus, moins à la planche à pain. Et maintenant, j'ai cinq
volts sur la planche à pain. Le service sera fourni. Nous sommes une source d'alimentation externe. C'est tout ce
dont nous avons besoin. Les LED ont une résistance, comme nous l'avons déjà mentionné
dans la classe LED, et sont connectées aux
parties moins de la planche à pain. Comme vous pouvez le constater, des choses très,
très basiques. C'est plutôt du côté logiciel. Et maintenant, nous pouvons
passer au code source.
50. Créer des fichiers de cours: Nous commençons dans
ce projet par création d'un nouveau fichier de projet. Je l'ai déjà fait sur
la plateforme. Toutes les données que nous ajoutons
ici nos modèles de base, par
exemple, les ports de téléchargement de
vitesse du
moniteur, le port de surveillance. Et je suis toujours inclus
dans la bibliothèque AnalogWrite. Sauvez celui-là. Et aussi dans le CPP principal, réécriture du 0 commence. Et c'est ce qu'on appelle des
ciseaux en papier roche et peut être
une quatrième variante. Je prends le puits, et c'est comme ça que j'appelle
maintenant mes classifications. C'est un acronyme, c'est RPS. Nous, WE New File, R dot h.
Donc aussi créer ici
et Fichier CPP et Nouveau Fichier, CPP que vers la droite. Et nous commençons
par le fichier d'en-tête. Le fichier d'en-tête a toujours
la même structure. C'est ce qu'on appelle la classe parce qu'on
fait ensuite un point-virgule. La prochaine partie inclura le point arduino h.
Et ils incluent les gardes,
y compris les gardes I, f et f r p w sous-jacents h i. Ensuite, elle s'appelle define RP SW. Et à la toute
fin, nous voyons, et si cela semble bon jusqu'à présent, nous passons
au fichier CPP et incluons ici l'
Arduino aujourd'hui Edge. Et nous
incluons également le RPS W, H. Je copie celui-ci, changeant deux CPP principaux. Et j'inclus
ici le fichier d'en-tête. Nous avons donc maintenant configuré le programme de base et
créé les fichiers de classe.
51. Fichier d'écran: Nous voulons maintenant définir toutes les choses qui entrent
dans le fichier d'en-tête. Même si nous n'en avons pas
besoin pour le moment, j'aimerais vous donner un
aperçu de ce dont nous avons besoin. Donc, tout d'abord, je suis euro. Ma classe est partie
vers la classe, classe LPS W et les privés. Dans la section privée,
nous n'avons pas de chaîne. C'est ce qu'on appelle la solution. Et nous avons ici un tableau
bidimensionnel. Ainsi, dans le fichier de solution, nous avons maintenant quatre rangées et ces sillons doivent être
initialisés avec des crochets bouclés. Et nous mettons
ici par défaut. La première entrée est par exemple des
ciseaux, de la pierre, du papier. Ensuite, j'ai dans chaque rangée, 43 entrées signifie virgule après pierre. Je peux donc dire maintenant que la toute première entrée de chacune des lignes
sera vérifiée si je suis choisi par moi. Donc, si je
choisis des ciseaux
, la prochaine entrée vient du papier, car les ciseaux battent le papier. Mais rien d'autre. La pierre et quand je
choisirai des pierres, pierre sera des ciseaux, des ciseaux
battant, papier sera de la pierre et des ciseaux en excès de vitesse et
ce donneur. Quelles sont donc les règles ? Parce que les
citoyens du monde ne se synchronisent pas. Le papier va
flotter sur l'eau. Et le papier
couvrira la pierre. La pierre écrasera les ciseaux. Les ciseaux vont couper le papier. Ce sont les règles
dans le format de base. Bien sûr, vous pouvez vous
adapter à nombreuses variantes pour le commerce électronique, par exemple avec le singe, etc., puis vous pouvez ajouter d'autres lignes. Et ma logique de jeu est maintenant celle que nous mettons
en œuvre plus tard. Je choisis le premier, par
exemple, le papier
que j'ai parcouru. Et le papier peut battre la
pierre et pire encore. Et puis je vois la pierre
inférieure ou la richesse, puis je gagne parce que j'
ai choisi le papier. Si le bot n'a pas de
pierre et pas de puits, alors j'ai perdu parce que je
ne peux gagner qu'avec du papier. Et c'est la logique du
jeu jusqu'à présent. Le premier est ce que je choisis, puis je vois ce qu'il y a
dans la deuxième partie. Et puis je peux dire que si j'en ai un ou non, alors nous allons continuer
avec la structure. Struct, par exemple, les scores. Et dans cette structure, je mettrai n
chaîne et un score entier. Nous utiliserons cela plus tard. Et il aura également
ici sur la note précédente. Cliquez avec le bouton droit sur Format du document Ensuite, le double point public. Ici, nous définissons
un état énuméré qui ne le fera pas. Pourquoi faisons-nous cela en public ? Parce que nous voulons utiliser les
États dans le principal RPC. Nous voulons vérifier si nous sommes
maintenant en jeu States, si nous attendons
la participation des utilisateurs, par
exemple un site Web, ou si nous sommes à la fin et leurs résultats
devraient être imprimés. Ensuite, je dis aussi que la chaîne
choisie entrée par exemple. Et je tape dans un
tableau, puis nous
avons des ciseaux, de la pierre, du papier. Bien sûr, nous pourrions
aussi utiliser ici et descendre. Mais j'
aimerais que ce soit simple. Je suis, je suis, j'ai choisi les commentaires. Ensuite, nous pourrons remplir ici un
numéro aléatoire, et c'est fait. Ensuite, je suis un score, je marque trois. Donc, ce que sont les scores de cours est maintenant notre structure et c'est ce
que nous lançons. Et maintenant, nous avons ici un
tableau de trois partitions. Ces trois scores
que nous sommes en train de mettre en place, par
exemple. Donc, un. Et le score est de 0. Et puis, d'accord,
je ne l'utilise pas, son noyau, je
dirais un score de jeu, un. Copier. Ensuite,
on peut dire que la seconde est perdue. Et le chirurgien devrait être, par
exemple, un serré
dessiné comme il l'a aimé. Les yeux sont serrés. Jusqu'à présent, c'est tellement bien. Comme vous pouvez le voir. La première est la chaîne, la seconde est l'entier. C'est un tableau, et à la fin, nous avons
besoin d'un point-virgule. Ensuite, la prochaine chose
sera blanche. Toutes les LED sont éteintes. blanc. J'ai allumé. Ou on pourrait dire qu'on allume toutes les LED. Ici, nous voyons un étui de chameau, blanc. Vérifiez, jouez et vérifiez l'utilisation. Lorsque deux paramètres d'entrée, chaîne utilise une chaîne, mais un jeu de réinitialisation large. C'est tout ce
dont nous avons besoin pour ce projet. Et maintenant, nous avons
déjà implémenté toutes les choses d'en-tête dont nous avons besoin
dans la logique du jeu.
52. Premier mode de jeu: Dans cette vidéo, nous commençons maintenant par définir notre
premier algorithme de jeu. Et par conséquent, nous passons
au RP en tant que point cpp, nous déclarons large p.sit, W double bond, double liaison, Check, utilisez un vent. Ce sera notre
fonction principale qui
nous vérifiera notre section de jeu perdu
ou de tirage au sort. C'est donc une chaîne utilisateur. Et cette fonction sera
appelée dans notre main.cpp, chaque fois que nous passons ici, notre
sélection et la sélection du bot. Ensuite, nous pouvons dire que si l'entrée de l'utilisateur
est égale au bot, c'est ce que nous avons conçu. Il est en imprimé argenté serré. Un. Sinon. On pourrait dire. Ensuite, maintenant la logique, ce que nous avons défini
juste avant
son entrée dans le
jeu, cela signifie quatre. Nous disons ici que l'entier est égal à 0, entier inférieur au forum, car notre zone de solution
a la forme de paramètre. Et maintenant, nous voyons ici si des solutions, c'est des solutions. Je le définit avec S parce qu'il existe
des solutions pluriel bras, année 0. Il s'agit d'un utilisateur. Donc, lorsque je choisis des ciseaux, il va parcourir et vérifiera si les quatre premiers, si le premier élément est là, des ciseaux, quand c'est le cas, puis ça continue. Ensuite, nous disons, si les solutions E, mais pas la première, la seconde est
achetée ou des solutions. Nous avons besoin d'un peu plus d'espace. Un à cet endroit, alors que fait-on ? Nous en avons un. Sinon. Nous avons perdu. Est-ce que nous pouvons imprimer ? Ensuite, nous vérifions encore une fois
ce que nous avons fait ici. Et on pourrait dire que l'euro a perdu. Une fois de plus, la logique que nous irons dans
le jeu, à travers les solutions.
Nous y voilà. Ensuite, par exemple, si
je choisis le papier, la première zone, nous ne le ferons pas. Le premier si ne passera pas
parce que la solution sérum, sérum est des ciseaux, 10 est pierre à 0 est
du papier, puis plus gros. Je vérifie la prochaine solution. Si le robot a ici, pierre,
celui-là , tous les boutons puits, alors j'en ai un autre si perdu. Et c'est l'
algorithme facile pour notre gameplay. Essayons donc. Nous allons ajouter
notre fichier principal et TR, nous lançons notre nouvel objet. Et l'objet est que le
nom de la classe est RPS w et je
dirais que le jeu est RP comme nous w, mais pas avec un tel nom w2. Et puis à l'intérieur de la
configuration, j'ai pu voir utilisateur de vérification des points de
jeu quand. Et je dirai pour x premier
exemple, papier, papier. Et le robot aura de la pierre. Ensuite, j'en ai un car le
papier couvrira la pierre. Essayons donc. Il suffit de vérifier ici le compilateur. Entre-temps, je connecte mon USB à l'
ordinateur et je le télécharge. Ensuite, nous verrons si nous avons raison. Redémarrez donc. Et comme vous pouvez le voir avec un, parce que du papier nous
couvrirons ici ce dôme. Ensuite, l'exemple suivant, lorsque
nous perdons, par exemple, nous prenons des ciseaux et le bot prendra
Welles une fois de plus, téléchargera le tout. Et maintenant, les ciseaux se sont
perdus contre les soudures. Voyons donc en
arrière-plan ici moins plusieurs moteurs car
au départ, ils
prennent la position, donc perdu son vrai. Et le dernier jeu, ce que nous aimerions
vérifier si nous avons papier et du papier que tout
le jeu devrait s'arrêter avec une impression en
série serrée
car l'entrée est la même et durable
devrait être vérifié. Voyons si cette
fonction sera correcte. Nous avons ensuite mis en place
nos algorithmes de jeu avec succès jusqu'à présent. Oui. Sommes-nous bons ? Dans la partie suivante, nous aborderons un
peu plus en détail. L'algorithme.
53. Mode de jeu en boucle: Nous allons maintenant utiliser l'objet
un peu plus. Et c'est pourquoi nous voulons nous
débarrasser de l'impression 0 ici. Et nous voulons utiliser le score de base du
jeu. Mais j'aimerais l'utiliser en minuscules au début. Donc, score de jeu. Et maintenant, nous
voulons avoir un indice. Par exemple, nous
avons votre serré est ce deuxième indice 01 secondes. Et maintenant, avec un certain point, c'est déjà un coffre pour moi. Nous devons identifier
ici le score ou le match. Et j'aimerais avoir
à marquer. Et maintenant plus est égal un parce que nous
voulons avoir un ajout. Pour ajouter ici pour
résumer la fonction, additionnez avec une, la même,
la même mais différente. Nous avons ici pour indexer 0
et nous sommes dans le dernier, nous avons l'indice un. Un peu plus
orienté objet parce que maintenant nous marquons,
sommes-nous sûrs ce cours
dans notre score de jeu ? Voyons donc, passons
au RPC principal pour obtenir le
plein potentiel ici. Ce que nous avons. Maintenant, nous voulons aller ici dans
la boucle et nous sommes en train de faire ici et des mauvais retards juste pour entraînement
parce que
nous nous en débarrassons par la suite . D'accord ? Donc, une fois maintenant, imprimez les détails afin que nous puissions
utiliser une impression en série f. et une façon vraiment pratique ajouter du texte et des variables. Par exemple, on pourrait
dire un, perdu et serré. Et ce que nous pouvons faire maintenant, c'est que nous
pouvons configurer ici avec une
virgule, la première variable, la deuxième, troisième pièce, faire un
saut de ligne pour que nous ayons ici un peu plus d'espace de modèle
Merrill. Et maintenant, comment pouvons-nous
accéder au score du jeu avec RPS W sur un score puissant. Je ne fouette pas. Le jeu est notre nom
d'objet, jeu, jeux deux-points. Ensuite, nous pourrions dire que nous voulons avoir
le premier index 1, le score de
point, le nom de classe, puis le
nom du membre public et l'index. C'est donc ce que nous utilisons
également pour le dernier indice, mais c'était le premier indice. Et le dernier est
le deuxième index, mais pas de virgule à la fin. Double virgule, également. L'espace réservé pour cela sera le dernier et le dernier. Ça a l'air très bien. Pour les
premières impressions f, il ne doit pas être imprimé. Et maintenant, vérifions si
nous avons le droit. Et ça a l'air bien, mais on veut entendre un
peu plus de souplesse, un peu plus aléatoire. Donc, je dirais que je
vais faire entrer
votre utilisateur je suis des entrées utilisateur. Nous voulons accéder aux intrants que
nous avons choisis. Nous disons donc ici encore, les points choisis, les entrées choisies. Et je pourrais dire, par
exemple, deux. Et ça va me rendre, ou 10, ou 1012
seront imprimés en arrière. Je veux également imprimer cette entrée utilisateur de dessin au
trait, à la fin de la chaîne ici, je veux également ajouter un saut de ligne. Donc, barre oblique n pour le saut de ligne. Mais ici, il n'y a pas de fonction
aléatoire à l'intérieur. Par conséquent, je suggérerais que
nous saisissons au hasard. Et il faudra
deux choses pour commencer, point de
départ et
le dernier point. Mais le dernier numéro
doit être exclusif. Il nous reste donc 123
sont ce dont nous avons besoin. Par conséquent, nous avons une
fonction aléatoire qui nous donne, devrions-nous également inclure
ici l'entrée de l'utilisateur ? Et cette fonction aléatoire met en aide, ne
papier ni sur la richesse. Et pour le papier pour le, pour le bot sera fixé afin
que nous puissions le vérifier par la suite. Connectez ensuite l'USB
à votre ordinateur. peux entendre mes moteurs pas à pas en arrière-plan parce
qu'ils sont déjà connectés, alors vous verrez si
nous avons raison ou non. Alors redémarrez et bien, Scott a perdu contre le papier. Alors, où en sommes-nous ? Je veux dire ici ? La pierre de papier était encore
une fois, je dois redémarrer. La pierre, la pierre, la pierre, les gens ont
perdu de la pierre, du papier, perdus. Perdu. papier. Le papier est une marée. La pierre dure, la pierre est perdue. Des ciseaux, un contre une bombe à pipe. Je suis perdu contre le papier
parce que le papier flotte. Stone contre salaire. C'était, et comme vous pouvez le
voir, une fois de plus, nous recommençons à zéro pour que je puisse voir cela dit un, un papier, un contre papier. Notre journal devrait être fatigué. Css, la pierre a perdu sa richesse. Oui, donc ça marche. Vous pouvez voir que le score du jeu
sera enregistré dans l'objet. Et nous avons ici un moyen un
peu plus flexible. Et nous avons également implémenté ici
une fonction aléatoire pour qu' elle soit un peu
plus épicée là-dedans. Tout d'abord, dans le premier domaine.
54. Créer un site Web: Il est temps de créer le site Web. Par conséquent, nous allons notre dossier source,
cliquez dessus avec le bouton droit de la souris. Nouveau dossier et je crée
ici et dossier de données, il faut que ce soit les
données de nom pour que nous puissions télécharger plus tard toute la
phase
sur notre système. Ensuite, je copie et colle ici
les fichiers de la plateforme. Parce que nous avons besoin ici
du jQuery, par exemple, entrez style CSS, et
cliquez avec le bouton droit sur ce nouveau fichier, et nous créons
un code HTML d'index. Maintenant, je suis en train de copier et coller
un peu parce que c'est plus général à faire. Mais nous passons
par chaque ligne. La première chose que nous sommes, c'est que
nous commençons par le HTML. Ensuite, nous avons souvent eu un an. Ici. On pourrait dire, par exemple,
roche, papier, ciseaux. Pire. Voici quelques éléments que nous
pouvons également ouvrir le site Web. Pour appareils mobiles. Nous avons référencé un
style et des
données de ligne Jake qui ont été
inclus juste avant. Ensuite, nous commençons par
la partie du corps, le corps. Et nous pouvons fermer le
code HTML. À l'intérieur du corps. Nous sommes en train de coller ici le titre pourrait être
le même que le titre. Ensuite, nous avons ici
et en classe du contenu. Nous allons donc le fermer. À l'intérieur de ce contenu. Le site principal sera visualisé et nous avons
ici et d'autres différences. Nous avons donc besoin de toutes les divs pour que tout soit très bien
aligné. Vous pouvez
suivre cela dans le fichier style.css. Vous pouvez voir ce que les boîtes de
classe vont faire. Ensuite, le suivant, pour que nous ayons vraiment tout aligné sur
. C'est génial div. Et à l'intérieur de la boîte, pas d'ombre. J'ai ici et je
sélectionne le Select. Je dirais que nous mettons toutes les choses en
sécurité. Ensuite, nous allons dans
notre dossier de projet. Il s'agit donc de toutes les données source de dossiers de
ciseaux en papier rocheux. Double-cliquez sur l'index HTML. Et où est-il ? Le voilà. Voici le site Web jusqu'à présent. Papier rock, ciseaux, gibier. Et ici, j'ai ma sélection. Et puis je vais ciseaux, pierre, papier, richesse. Et l'identifiant doit également être
nommé comme le même. Ciseaux, papier de pierre. Pire. Rafraîchissez la page. Maintenant, nous avons de nouvelles choses. Jusqu'à présent, c'est bon. La prochaine chose
sera, par exemple, nous pourrions dire saut de ligne,
saut de ligne. Que nous ayons un peu
plus d'espace ici près
des morts après les boîtes. Laissez-moi voir. Après les cases, nous remplissons ici un nouveau
cahier de notes et il s'appelle, par
exemple, soumettre une entrée. Et c'est nécessaire que nous ayons ici une fonction
onclick. J'y arrive plus tard
, je joue ou joue. Il s'agit donc d'un brevet. Qu'avons-nous fait maintenant ? Nous avons créé et des boutons. Ainsi, lorsque nous choisissons
ensuite
ici et la sélection, nous pouvons invoquer
ici la fonction AND, que nous transmettons les
données à notre ESP 32. Donc, ça a l'air très bien. Après le def principal,
après le contenu, j'ajouterai sur hertz et
soulignerai les sprays soulignés. Et j'ajoute ici une nouvelle div et elle s'appelle
def statistics par exemple. Ensuite, cette statistique que
nous publions ici, la statistique de classe de résultats doit être le nom car elle est définie dans le style CSS, donc je peux changer le nom ici. Sinon, je dois
changer aussi les fichiers CSS. Et ici, je n'ai pas de table. Ce tableau sera
ensuite rempli avec l'événement
côté serveur. La table a eu quelqu'un
avec des lignes et des lignes. Et l'idée est, par
exemple, de ce cours
que je pourrais vérifier le changement. Et ce n'est pas le résultat de
Duran en H3. Une fois de plus, rafraîchissez-vous,
et c'est maintenant notre
site Web parfaitement réagi jusqu'à présent, si bien. À la fin, je
suggère que nous
incluions également votre JavaScript
non dans un nouveau fichier. Je dirais que c'est assez bien quand nous mettons tous
ici dans un seul scénario. Ensuite, on dit « fonction »,
comment s'appelle-t-on ? Il s'appelle Submit get. Dans cette fonction, nous
transmettrons les données à notre ESP 32. Jusqu'à présent, nous avons
créé un site Web. Ensuite, dans l'étape suivante, nous
discuterons de la façon dont nous pouvons mettre en place une connexion Wi-Fi et comment obtenir les données de notre ESP 32.
55. Site web d'accès via ESP32 Webserver: Il est maintenant temps que l'USB 32, nous le connecterons à notre
filaire et que nous puissions également accéder au site Web
depuis ou vers le GSP 32. Tout d'abord, peu d'erreur dans la vidéo avant
d' extraire
les données dans
la hiérarchie principale, dans la
zone du dossier principal que dans les sources, données et les sources de
la même hiérarchie c'est nécessaire
à des fins ultérieures. Donc, dans notre source, je vais copier ici
mes informations d'identification. Vous pouvez donc me suivre
avec le bouton droit de la souris sur un nouveau fichier. Vos informations d'identification, par exemple, Craig prothèses dentaires point h. Et nous pouvons dire
ici, par exemple, c'est une
vie d'omble constante et voir SSID. Et on pourrait dire que le mot de passe
est const char pas 2442. C'est ça. C'est ce dont nous avons besoin
pour l'identifier et le définir. Je le supprime parce que
je l'ai déjà ici. Dans le rpc principal. Il inclut les prothèses dentaires
point h comme suivant. Nous pourrions dire que nous avons
besoin ici d'un peu plus de bibliothèques externes. Par conséquent, j'inclut
les éléments suivants. Vous pouvez vous demander où les trouver ? Vous pouvez les obtenir sur la plateforme. Je n'ouvre pas de bibliothèques. Et je ne sais pas si
nous l'avons fait auparavant, mais ici vous pouvez
choisir, par exemple, ESP lui-même et vous pouvez
entendre le nom, par
exemple, de
Kevin Harrington. Et vous commencez
l'installation par exemple. Et vous entendrez
le nom de la bibliothèque. Je peux le copier. Et comme je l'ai
fait ici, collez-le. C'est tout ce que nous
devons faire maintenant. Sauvegardez-le et passez
au RPC principal avant ou
après le point arduino h. Nous incluons maintenant toutes les
bibliothèques dont nous avons besoin, c'est le Y fit et H. Pourquoi
n'avons-nous pas fait de référence
et un sang de n'importe lequel ? C'est la
raison parce que le flux y chez H n'est pas le cœur de l'ESP 30
au cœur signifie qu'il y a référencé les bibliothèques
sont des bibliothèques intégrées, je dirais et tous les autres. Nous devons l'inclure de
cette façon comme nous l'avons fait auparavant. Par exemple, le TCP
qui était nécessaire et le serveur Web ESP arsenics pour la communication
avec le serveur Web. Les flèches sont également incluses dans le noyau et les
broches sont dépréciées. Cela signifie que dans les prochaines versions, ils risquent de ne plus
être pris en charge. Au lieu de cela, il y a
peu d'EFS utilisés. Pourquoi j'utilise des usurpateurs, parce que j'utilise ici la version USB 32 en mousse
noire,
3.5, la version film sanguin, et j'en ai besoin pour d'autres raisons. Mais plus tard, lorsque vous
voulez changer deux petits EFS, il n'y a que
quelques changements mineurs et tout
fonctionne de la même façon. Je vous montre ensuite
comment vous pouvez le faire. Ensuite, nous devons entendre
ce servo point h. C'est toutes les bibliothèques
dont nous avons besoin jusqu'à présent. Ensuite, notre coffre que nous
apportons des modifications à
la source de l'Explorateur, nouveau fichier, ma femme, V dot h. Maintenant, nous
connectons ou disons ici, toutes les
fonctions nécessaires dont nous avons besoin. Par exemple, ils se connectent à des points d'
accès dotés d'une connexion Wi-Fi. Ici, on peut dire qu'il
se connecte au Wi-Fi. Wi-Fi entre SSID et mot de passe. Et c'est à partir des
informations d'identification point h, Nos principales variables globales. Ensuite, il s'agit d'une procédure
standard. Vous pouvez simplement copier et coller un
clic droit sur Format du document. Ici, vous obtenez la connexion
Wi-Fi. S'il se trouve dans une boucle de temps, il
sera imprimé
et pointé à
chaque seconde et il réussira. Nous pouvons imprimer ici
et l'adresse IP locale. S'il s'agit de plus de 20 boucles, il sortira
de la boucle while. Parce que souvent,
il y a quelque chose avec le
routeur par exemple. Ensuite, je vous
suggère également d'inclure ici
la fonction processeur. Il sera nécessaire pour le Web. Par exemple, si nous voulons éteindre et allumer les lumières,
etc. Pour que lorsque nous
transférons et obtenons des paramètres, nous ne l'utilisons pas dans ce cas, mais vous devez l'implémenter car
c'est nécessaire. Créez également l'objet ultérieurement. De quoi avons-nous besoin pour les événements
côté serveur ? Et nous créons également ici l'objet serveur Web
était sur le port 80. Et ensuite, nous devrions inclure
ici le point arduino h. Et ces
erreurs de série devraient également disparaître. Jusqu'à présent, tellement bien, beaucoup
de copies de pâtes. Il s'agit de choses générales. Nous revenons au
CPP principal en passant à la partie configuration. Parce que maintenant, ce que nous voulons faire c'est que nous voulons commencer Smith. Il existe également une procédure
standard. Peut également le copier et le coller. Ensuite, nous invoquons notre fonction, ou nous appelons notre fonction
connectée au
point d'accès que nous avons déjà défini. Mais comme vous pouvez le voir où
si vous êtes une erreur, parce que nous ne sommes pas inclus,
il inclut encore ma femme point h. Le point suivant nous devons
ajouter ici des fonctions de somme
pour le serveur Web. Donc je ne fais que poster toutes les choses et ensuite nous le
parcourons ligne par ligne. Celui-ci s'appelle Server on. Serveur activé, lorsque nous
accédons au site Web, il passera à partir de
notre système
de fichiers, côté index.html de Smith. Le prochain. Nous avons ici notre fichier CSS. Un fichier CSS sera fourni à partir du site Web de Smith
ainsi que du Chaco, c'est du texte JavaScript,
et il sera fourni par des esprits
portant ce nom de fichier. Nom de fichier. Comme vous pouvez le constater, commencez l'index du milieu. Et cela est nécessaire
car nous stockons les données dans
le
système de fichiers à partir de déversements. Et c'est ainsi que nous pouvons y
accéder automatiquement à partir du style de programme CSS et
aussi de l'index ou de demain. Jusqu'à présent, c'est tellement bien. Et ce que nous avons également besoin
ici sur le serveur commence. Une note de côté, si vous souhaitez passer à petit f s plus tard, il suffit de changer l'
instruction d'inclusion S start. Et voici ce que vous
respectez, vous changez deux petits EFS et
tout devrait bien fonctionner. Comme pour les esprits. Après le début de l'argent. Nous n'ajoutons rien jusqu'ici. Et je
recommande également de
commenter la boucle parce que
nous voulons
faire confiance pour vérifier si nous disposons une connexion Wi-Fi
stable et
si nous pouvons accéder au site Web.
Par conséquent, nous sommes en train de faire
ici et d'abord compilant, vérifiez si tout va bien, puis nous téléchargeons cette capture en
premier lieu. Voyons donc si
tout va bien. Oui. Ensuite, en téléchargeant l'esquisse, comme nous pouvons le voir, le
fichier sera téléchargé. Maintenant, si le téléchargement
réussit, nous passons au
sérum monotone car maintenant nous devrions voir si du gaz, s'il se connecte ou non. Oui, et nous avons une fonction
instable, mais nous ne pouvons pas accéder maintenant à notre site Web car nous ne l'
avons pas téléchargé jusqu'à présent. Nous sommes donc proches de 0. mana est nécessaire car
sinon nous bloquons la voie. Nous avons donc maintenant une approche
différente. Si vous n'êtes pas Arduino EDM, je vous recommande de ne pas être au
hasard aux terroristes. Recherchez par exemple le téléchargement du système de fichiers ESP
32. Parce que c'est
complètement différent. Vous avez fait l'unité ici sur une application
tierce, qui
vous est fournie dans l'article. Mais ce n'est pas venu avec l'IDE
Arduino pour pointer O. J'ai
donc aussi
expérimenté les anciens médias et avec ce téléchargement
spécifique fonctionne très, très bien avec le
nouvel IDE Arduino. Je ne vois rien
parce que je ne l'utilise pas. Il suffit donc de
parcourir étape par étape tout ce processus, télécharger vos fichiers de données, puis de me suivre
avec les autres étapes. Avec Visual Studio Code. C'est plus pratique. Nous passons à la plateforme IO, passons à notre kit sourd. Tout d'abord, nous pourrions tout
nettoyer, par exemple, ou nous disons construire l'image
du système de fichiers. Encore une fois, il est nécessaire que tous les
moniteurs de sérum soient fermés. Sinon, nous le bloquerions. Ensuite, nous pourrions dire
Upload File System. Et maintenant, toutes les données seront téléchargées dans
l'air ESP 30. Ce n'est pas encore fini. Attendez que le
message réussi apparaisse dans le moniteur série lors de la vérification
des données de quart de travail, en partant. Ça a l'air très bien. Maintenant, nous pouvons allumer le moniteur série pour
qu'il se connecte, une fois de plus, se connecte au WiFi
je tape dans l'actrice. Encore une fois. Dans mon cas, je dois souvent le signaler pour que la connexion puisse
être établie. Encore une fois, il est maintenant établi
avec succès. Et lorsque je tape
l'adresse IP dans eux,
dans mes sites Web, dans mon navigateur sur le site Web
devrait être ouvert. Et c'est tout pour la
première approche que je suis, nous aurons
créé avec succès et la connexion Wi-Fi
modifiera les
données spécifiques à l'USB 32, et nous aurons accès à notre
site Web sur l'ESP 32. Très, très, très bonne approche. Nous avons beaucoup
fait tout. Et puis, la prochaine étape,
nous mettons en œuvre l'algorithme de jeu
sur leur site Web.
56. Transférer des données du site Web vers ESP32: Nous voulons maintenant établir
la communication entre ESPN
et le site Web. Donc, notre objectif dans cette vidéo, nous le serons lorsque nous choisirons ici certaines
de nos options. Une plainte hebdomadaire selon laquelle cette valeur sera transmise à notre ESP 32. Tout d'abord, nous avons l'
ouverture de notre index HTML, et il se trouve dans notre dossier de données. Et à la toute fin, après l'ouverture une fois de plus, c'est la toute fin que nous avons
ici une fonction vide, soumettre obtient cette soumission sera invoquée lorsque nous
cliquons sur ce bouton. Ce bouton va
transférer ou accéder à la fonction qui devrait nous fournir une partie
de l'option choisie. Il s'agit donc de l'ID SSP Oswald. Et nous accédons à cette idée et nous devrions
récupérer l'une de ces options. Alors, comment pouvons-nous faire cela ? Je suis fan de jQuery parce que
c'est pour moi plus facile à utiliser. Mais vous pouvez également utiliser votre langage JavaScript
standard. Je dirais donc que
l'entrée des utilisateurs est loin. Maintenant, nous accédons à l'idée. Et l'idée est avec le
hashtag, SSP soit Oswald. C'est ce qu'on appelle « dot well », pour les plus riches et les minuscules
américaines. Dans le cas où nous avons d'
autres caractères redoutés, j'ai imprimé sur le verrouillage de la console des entrées utilisateur pour plus tard pour le débogage proposé. Et maintenant, la tâche sera
de transférer cette valeur à l'ESP et que nous pouvons faire
avec cette demande GET, qu' est-ce qui n'est pas une demande GET ? Par exemple, mon site Web. Et si j'ai ici, par
exemple, sur un site Web appelé
arduino dot PHP. Et puis, en indiquant par un point
d'interrogation, le nom de la variable est William. Et ce n'est pas, euh, oui, et la façon dont nous pouvons communiquer via l'USB avec
les variables GET. Cela signifie que je
peux plus tard obtenir ce nom de variable
et récupérer les données. Et c'est ce que nous faisons
ici avec cette approche. Par conséquent, j'utilise
également jQuery. Donc j'utilise ici, vous êtes notre fonction
qui n'était pas juste. Ce n'était pas censé être le cas. C'est le code,
la fonction et les données. On y va. Et c'est la structure de tout ça. Et il n'y a rien ici. Il n'y a rien à
faire pour nous, car nous voulons
seulement envoyer
l'anomalie des données. L'USB peut renvoyer des données sur le site Web et
nous pouvons faire quelque chose ici. Mais nous utilisons
une autre approche car il ne s'agit pas seulement
d'un processus de synchronisation, mais nous voulons un
processus asynchrone, car plus tard ESPN devrait faire tout
le jeu et ensuite
renvoyer
les données. Il s'agit uniquement d'envoyer des données en temps
réel à notre ESPN. Mais l'URL doit être définie. Et je dirais que le
nom de la variable s'appelle SSP BM. Et je vois égal, et nous sommes assis dans le nom de la
variable est entrée par l'utilisateur. Le paramètre GET
doit donc ressembler à
ceci, par exemple Stein
ou volé dans ce cas. Et allongez-vous, nous récupérons ce nom de variable et
récupérons les entrées de l'utilisateur. Nous sauvegardons donc les données. Et je recommande
que nous ne puissions télécharger que sur le site Web afin que nous puissions voir si nous
avons ici quelques flèches. Ensuite, nous allons capturer de l'
Iowa, télécharger une image de fichier. Et arrêtez. Je vois ici que j'ai manqué ici. Bien sûr, je dois
mettre ici pour l' obtenir une fois de plus, le télécharger. ouvert une cérémonie terminée. Je suis donc déjà connecté que j'ouvre le
site Web une fois de plus,
rafraîchissez-le, cliquez avec le bouton droit de la souris
quelque part ici. Ensuite, vous pouvez continuer à inspecter. Nous cliquons sur Annuler. Et maintenant, lorsque nous
choisissons
quelque chose ici et que nous cliquons sur l'avion, nous obtenons ici la carte d'identité c'est ce
que nous voulons. Parfait. Ce que nous avons
fait jusqu'ici, c'est que nous obtenons en cliquant
sur le bouton de lecture, cette valeur de l'ID, non sur le contenu, sur l'ID. Cette idée devrait être la
même que celle que nous avons définie dans le fichier d'en-tête ? Parce qu'alors on peut le faire correspondre. Il s'agit donc d'une
richesse en papier de pierre qui doit avoir la même ID qu'ici, définie. Ensuite, nous pourrons continuer plus tard
en vérifiant que l'utilisation de in pourrait
insérer les valeurs dans cette fonction et avoir toute notre logique de jeu. Donc, mais nous n'avons pas encore
fini parce que nous devons mettre ici dans le CPP principal et la fonction qui capturera
également l'obtention. Et je l'ai déjà
déclaré ici. Nous faisons donc ici une fonction
individuelle et nous voulons arriver ici, ils répondent
peut-être à une demande de serveur Web parce que cette construction
a tout ce dont nous avons besoin. Tout d'abord, nous allons un
peu en haut de notre fichier et nous créons
ici quelques variables. Tout d'abord, j'aimerais
faire une entrée utilisateur
variable globale. Et nous définissons ici
et fonctionnons un prototype. Qu'est-ce que le prototype de fonction ? Parce que j'
aimerais faire ici la fonction de vérification des modèles, mais pas au-dessus de la configuration lorsque je déclare non commenté pour
vous montrer ce que
je veux dire par là. Il suffit de le copier. Je vais à la fin du dossier. J'aimerais avoir
ici la fonction car elle me donne
une meilleure vue d'ensemble. Mais ici, vous pouvez le voir. Les livres de contrôle auraient pu être erreur de
compilation
car nous devons définir en premier lieu la fonction pour que le compilateur passe de
haut en bas, sache, ok, le
sera définie, n'
a pas de logique,
va, descend, baisse, et
voici la logique. C'est donc ce qu'un prototype
fait sans commentaire pour que le
compilateur connaisse la fonction. Et maintenant, nous allons directement sur
le bouton et maintenant ils
le sont, les détails entrent dans
l'entrée du Parlement que nous utilisons cette demande que nous recevons
du serveur Web. Et maintenant, nous pourrions dire, si les demandes, et
c'est un pointeur, nous y accédons
avec l'erreur. Et voici toutes les fonctions
mises en œuvre qui sont là. Et il ne devrait pas y avoir de
fonction avec Hesse Param, pas de respiration sifflante S, S PBM, ou comment appelons-nous
cela ? C'est ce que nous appelons. Laissez-moi voir. Spb, par exemple. Cependant, vous voulez
l'appeler principal RPC. Je veux capturer ça. Et s'il existe un tel paramètre, alors je dis les entrées utilisateur, que nous sommes déclarées dans
une portée globale générale. Ensuite, nous disons une demande
qui a un paramètre. Maintenant, les parents
obtiennent Param, SSP, PM. Et nous disons que vous êtes très bon jusqu'ici. Maintenant, je
voudrais l'imprimer 0, imprimer les entrées de l'utilisateur, afin que
nous puissions vérifier si notre droit, voyons ce que dit le
compilateur. Fermer toutes les choses de Hello
ouvertes. Et lorsque le compilateur nous
donne un feu vert, nous téléchargeons le croquis, le site Web est déjà téléchargé. Ensuite, nous pouvons voir si nous n'avons pas été établis et si les cérémonies de
communication sont ouvertes ou si nous rechargeons
le site Web. Et maintenant, je veux devoir faire de la pierre. Stone est ici. Je voulais faire du papier. D'accord, j'ai raté
un saut de ligne. ciseaux. Les ciseaux étaient encore très bons. Et ici, nous avons réussi à établir
la communication entre le site Web et à nous transmettre
la valeur à l'ESP 32.
57. Mode de jeu sur deux jeux gagné: Nous arrivons maintenant à
la sauce secrète de notre jeu parce que nous
voulions changer le mode de jeu afin pouvoir détecter automatiquement si nous attendons une entrée, si nous sommes en train de saigner ou si le match est au nième
et nous avons joué à un seul. Cela signifie que j'ai besoin de deux victoires ou deux défaites pour
terminer le match. Et donc, nos états
entrent dans le jeu. Et avant tout, nous devons penser à quel
est le premier état ? Le premier état sera que nous attendons les entrées utilisateur
après le démarrage de l'USP 32. Ensuite, une fois que nous
sommes arrivés ici et que nous avons utilisé les
entrées via le site Web, nous
passons à jouer au jeu. Lorsque vous jouez au jeu, il doit y avoir
en arrière-plan. Vérifiez si nous sommes à la fin ou si nous
rejouons contre le bot. Parce que si quelqu'un, si j'
ai un
test de DBO deux fois un, alors nous sommes à la fin. Nous réinitialisons tout lors la
publication
des résultats sur la console, ou nous attendons l'entrée. C'est ce que nous
voulons mettre en œuvre maintenant. Ensuite, tout d'abord, passons à la partie configuration. Et dans la configuration, nous devons déclarer ici, nous voulons attendre. Donc, la première déclaration
de nos états, nous allons
à la fin de la configuration. Ensuite, nous saisissons dans notre objet Cloud le nom du
triclinium est appelé jeu. Point de jeu. L'état est égal au point de jeu. Attendez la saisie de l'utilisateur. Ici, nous avons eu une erreur parce que nous avons
ici nos états, mais les États
ne sont pas initialisés. Et bien sûr, ce n'est pas inhabituel que
nous initialisions des choses
dans le fichier d'en-tête, mais je ne veux qu'un seul
objet des états. Je ne veux pas avoir beaucoup d'
objets différents, juste un seul état. Et
c'est la
raison pour laquelle nous pouvons l'initier ici dans le fichier d'en-tête, puis nous pouvons l'
utiliser et y accéder. Nous pouvons donc maintenant entendre en boucle, demander à notre objet, à notre objet de jeu, dans quel état nous
sommes actuellement. Et puis nous pouvons ici, en nous concentrant sur la
gomme par exemple. Alors, que pouvons-nous faire maintenant ? Changer l'état des points du jeu. Et dans le cas de l'interrupteur que nous sommes, je demande la prochaine affaire. Donc le jeu de cas,
jouer à double point, casser le jeu, attendre les points de données
d'entrée de l'utilisateur. Et nous avons le jeu du Royaume-Uni
et sans aucune pause. Et jusqu'à présent, nous avons identifié les différents types d'
états à l'intérieur et à la rupture. Revenez ici. Il doit y avoir une partie supérieure. Maintenant, ça devrait être bon. Oui. Alors laissez-vous poser, nous vérifions ici le contenu
du boîtier de commutation, mais nous sommes actuellement
à l'état. C'est la configuration. Nous attendons les commentaires des utilisateurs. Donc maintenant, quelqu'un entre sur le site Web sur entrées et nous
obtenons l'entrée ici, supprimant l'
impression série et changeons l'état en lecture. Par conséquent, game dot
States est un jeu. Maintenant que nous avons changé l'
état dans la prochaine boucle ici, la fonction sera sautée
dans le jeu de cas. Et maintenant, nous pouvons
réfléchir à la prochaine étape ? Nous devons maintenant utiliser
notre fonction principale. C'est ce qu'on appelle la vérification du jeu, utilisation de quand les entrées de l'utilisateur. Il s'agit de notre variable globale
des params tchèques. Et ici, je veux avoir les
entrées à l'intérieur de la boucle, mais en dehors de l'interrupteur, je définirais ici le pot de cordes. Et le pot arrive ici. Entrées choisies par point de jeu. Ici, c'est notre RAM souhaitée. Il comporte quatre entrées et nous
voulons avec un nombre aléatoire, x est ici, l'une d'elles. Et comme nous l'avons déjà dit, c'est une chose privée. C'est la raison pour
laquelle nous l'ajoutons ici. L'entrée choisie en tant que contribution choisie par le
public. Ensuite, nous faisons
en nombre aléatoire, par
exemple, aléatoire à quatre et S que nous avons
également discuté plus tôt. Ce premier numéro est
inclus et il est
exclusif. Nous avons donc besoin d'ici. 0 à trois, c'est la raison pour
laquelle nous devons entrer en vous. Et pour notre numéro, numéro
rond, nous
identifions également. Parce que nous avions besoin de plus
tard sous ce numéro. Et nous pouvons définir ici dans le champ
URL un numéro aléatoire. Bon, jusqu'à présent, c'est bon. Maintenant, les commentaires de l'utilisateur
proviennent du site Web seront vérifiés ici à partir
des modèles tchèques. Et nous sommes arrivés ici sur des
entrées aléatoires. Jusqu'à présent, c'est tellement bien. De quoi avons-nous besoin ? Maintenant ? Nous venons de vérifier les états. Voyons
l'utilisateur de vérification du jeu lorsque nous
stockons simplement ce cours, mais nous ne changeons aucun
état ici et le gardons général. Cela signifie que nous devons
m'entendre Can second fonction et vérifier le gameplay. Gameplay. Nous n'avons pas
encore été définis, donc nous passons à notre fichier. Je vais appuyer sur W et nous
disons ce que RPS, WOW, pointez, vérifiez le gameplay. Et ici, sous le blâme du jeu
tchèque, nous devons réfléchir à
ce qui devrait se passer. Donc quelqu'un entre dans
quelque chose et dans une théière. Et c'est maintenant que nous avons
ici dans les États où quelqu'un a gagné ou perdu. Et maintenant, nous devrions identifier si le jeu
est à la fin ou devrions-nous
attendre une autre contribution ? Parce que, par exemple, si j'ai des ciseaux et que je suis la pierre, le bot a gagné la première
fois. Maintenant, il faut attendre. Mais ce que nous devons dessiner, quand nous n'
avons qu'un à un. Par conséquent, nous vérifions
maintenant si notre colonne de jeux, donc si le score du jeu fait des points, nous devons accéder ici
pour marquer le score du jeu. Score du premier point d'entrée. C'est l'outil, c'est ce que nous voulons, est plus grand que l'outil. Ou si le score
du jeu est supérieur à deux, alors quelqu'un a perdu
ou quelqu'un en a un. Parce que le premier est que j'ai 12 fois ou que le
bot en a 12 fois. Donc, même après les événements
, le jeu est terminé. On peut dire ici que l'état est quand non, ouah, personne n'en a. Ensuite, l'état est, attendez les entrées de l'utilisateur. Et nous sommes ici au
sein de la classe. C'est
pourquoi nous n'avons pas besoin d'un nom d'objet et nous pouvons l'
identifier avec un signe égal. Jusqu'à présent, c'est bon. Et ce jeu de vérification sera invoqué et chaque boucle
lorsque nous jouons. Et pour cette raison,
j'aimerais ajouter quelques tirages argentés pour que
nous ayons un résultat plus agréable. Résultats. Impression en série. On peut en dire un. Ensuite, nous voyons perdu. Et on pourrait dire des marées. Et nous saisissons
le score du jeu, pas 0. Score. J'ai perdu celui-là. Et les schémas de CO2 sont liés, donc on s'en prend à tout. Et comme la dernière, ligne d'impression en
série, Okey-Dokey, a fière allure jusqu'à présent. Ensuite, nous devons revenir
à notre boucle principale parce que
nous n'avons pas encore fini. Parce que maintenant, on
a encore vérifié le blâme. Il est donc plus humide en attendant
une entrée ou c'est la fin. Mais ce qu'il a dit au nième, descendant un peu, nous avons ici une fonction de plus que
nous devons mettre en œuvre. On pourrait donc dire jeu de réinitialisation des
points de jeu. Et laissez-moi voir un peu. Alors réinitialisez le jeu,
revenez à notre fichier de classe, blanc RP SW, jeu récent. Et que devrait-il se passer ici ? C'est très facile parce que je ne
veux pas supprimer l'objet sur un objet
initié ou nouveau car
peut-être que vous feriez ici quelques rondes de comptage, etc. Donc je veux seulement supprimer ou
écraser l'école de collage. Par conséquent, j'
utilise une boucle for. entiers comptent donc jusqu'à trois. Et Tia, je dis « score de jeu ». Je, le score est égal à 0. Et maintenant, je remplace
ce cours à la fin et change l'état pour
attendre les entrées de l'utilisateur. Maintenant, je pense que nous avons géré tous les états d'une manière générale
parce qu'il, dans la boucle, nous pouvons ensuite accéder aux
différents modèles, par exemple, mais pas implémenter quelque chose
dans la classe principale. Et ici aussi, nous
attendons les commentaires des utilisateurs, rien à faire ici. Mais ici aussi, je
suggérerais à des fins de formation et
aussi de validation. J'aimerais
imprimer ici puis les entrées, donc l'impression en série. Et nous y voilà. Je lui donne le fond, mais je change ici, pas le pot au premier. J'aimerais avoir
ici les entrées de l'utilisateur, car c'est le même
ordre que ici, l'entrée de l'utilisateur. Ensuite, nous avons le pot comme dernier signe que
nous fabriquons ici, la ligne
d'impression et le
point-virgule à la fin. N'oubliez pas le point-virgule. Voyons si nous avons des flèches
ici. Est-ce que nous obtenons le
feu vert de notre compilateur ? Ensuite, nous
téléchargeons le croquis sur leur USP 32.
Oui, ça a l'air bien. Puis les téléversements. Le programme est donc
clignoté et nous sommes connectés au Wi-Fi et nous
rechargeons le site Web. Maintenant, j'aimerais
choisir la pierre. Stone est ma contribution, papier est le robot, donc j'ai perdu. C'est vrai. Encore de la pierre, du papier de pierre. D'accord. Encore une fois, j'aimerais avoir du papier, du papier contre des ciseaux. J'ai perdu que la richesse ne l'était. Encore une fois ma sœur, je gagne parce que
les ciseaux sont tirés. Une fois de plus, Wells était un flotteur de
papier et de papier. J'ai encore perdu. Nouveau jeu. Nous commencerons la prochaine fois. ciseaux. Les ciseaux n'étaient tout simplement
pas mon jour de chance. Des ciseaux volés. Une fois de plus, la pierre
et le papier de pierre, j'ai perdu. Encore un jeu. J'aimerais avoir peur
et avoir des ciseaux en papier serrés. J'ai perdu des buts en perdant. Comme vous pouvez le voir, ici, nous avons du papier, du papier serré. C'est ce que je voulais vérifier. Le gameplay, je
dirais, fonctionne très bien. Et dans la prochaine vidéo,
nous allons montrer notre tentative de faire le reste.
58. Envoyer des événements côté serveur: Nous voulons maintenant renvoyer
les résultats de l'ESP sur
le site Web afin que
nous
puissions ensuite visualiser les
résultats. Par conséquent, nous pouvons utiliser ici
les événements côté serveur et les événements côté vendeur sont à
peu près préparés pour nous. Il suffit de copier et
coller les choses dans. Et cela vient de l'
expression elle-même. Ils nous ont donné les extraits de code
et vous pouvez le remplir. Par conséquent, nous
ouvrons l'index HTML et en dehors de la fonction
Soumettre obtenir, nous déclarons ici. Et si la source de l'événement de fenêtre, à l'intérieur, nous copions et collons la première fonction,
cliquez avec le bouton droit de la souris sur Format du document. Ainsi, un EventListener,
il sera ouvert. Et puis nous sommes arrivés ici
aussi par message quand il est déconnecté et que l'
ESP a perdu la connexion. De plus, le message, le
premier sera mis en œuvre ici. Mais maintenant, vous êtes notre source. Nos événements peuvent arriver. Avant cela,
nous
revenons à notre fichier CPP principal. Et, voyons voir, nous allons à l'État. Et nous devons initialiser
ici les événements côté serveur. Le serveur a commencé ici, mais il gère désormais les événements du serveur
Web. Et comment pourrions-nous le faire ? Il est également ici sur le
motif fixe copier et coller ici et aussi pour l'
auto-événement expressif sur connecté. Ensuite, nous avons eu une
idée quand nous nous reconnectons, et c'est le premier match. Le message était,
qui sera envoyé ici au sein de Halo et
du serveur aux poignées. Il s'agit donc du script de base, qui gère les événements. Mais quel est notre travail ? Notre travail consiste à envoyer les
résultats sur le site Web. Par conséquent, nous pourrions aller ici sous le gameplay, par exemple, et envoyer des résultats sur le site Web. Et c'est ce que nous
pouvons faire maintenant, les événements, événements
punk send sont notre objet
que nous sommes créés ici. Laissez-moi voir ici. Je pense que je devrais être sur un
wifi. Il s'agit de cet
événement, source d'événements. Et maintenant, dans la boucle qui descend, vous
a envoyé, nous
devons envoyer une chaîne, par
exemple. Et de la ficelle. Il suffit de copier et
de coller le premier. Une chaîne car il
ne s'agit que d'un entier
converti en chaîne. Et puis deux déchargées
parce que c'est ce dont nous avons besoin. Ensuite, je donne également la deuxième valeur et elle s'
appelle, par exemple une. Et nous
publions également ici Millis. Donc ici, nous devons
ajouter non réduit, et c'est ce que l'on appelle le jeu. Et comment enregistrer
le score du jeu. Score de jeu de points, 0 et points. Nous avons maintenant deux points. Prochaine ligne, nous
voulons avoir le perdu. Et le troisième
sera le serré. D'accord. Allons finir. Tout d'abord, télécharge
les sites Web. Non, nous n'avons pas fini
sur le site Web. Nous n'avons que les événements de base, mais maintenant nous devons
capturer nos événements. Par conséquent, j'ai également
préparé quelque chose ici. Allons-y. Sourced AddEventListener,
et il s'appelle 11. Nous divisons ensuite ici
le rpc principal, celui-ci. Celui-ci sera donc
initialisé ici à un seul moment. Ensuite, nous imprimons
les valeurs sur la console uniquement
dans le premier but. Ensuite, copiez le collage deux fois
parce que nous avons perdu et serré. Le dernier. Maintenant, enregistrez et téléchargez le fichier afin que nous ayons une nouvelle
mise à jour du site Web. Encore une fois, quel est le problème ? Oui. Maintenant, cela fonctionne car le moniteur
série était ouvert. Et ensuite,
téléchargez également cette capture. Usp a une connexion. Ensuite, nous faisons en sorte que Reese
rafraîchisse la console d'inspection, alors que le conseil est un
peu plus grand. Nous y voilà. Et comme vous pouvez le constater, nous recevons ici les messages. Ainsi, lorsque nous actualisons, utilisez P pour vous connecter également
aux événements côté serveur. Alors pourquoi ne pas apparaître ici ? Ensuite, j'envoie des ciseaux. Et ici, le résultat sur
l'entrée 0 est le même, mais nous pouvons également
entendre les commentaires. Donc, l'un a perdu serré. Encore une fois, je
choisirais PayPal avec 110. Puis on a coupé
ici, c'est que j'ai eu 111. Ce sont les 31 derniers. Très bien. Cela provient de la connexion
de la console sur le site Web afin que nous puissions voir ce que nous avons entré dans
les ciseaux à 11. Une fois que j'appuie sur l'option suivante, la prochaine option, le jeu
recommencera à zéro. Et comme vous pouvez le voir, nous avons
également eu ici ces événements côté serveur. Parfaitement. Nous envoyons des valeurs
à l'en-tête ESP et au jeu
Glenn Motors
, puis nous renvoyons les
valeurs à nos sites Web. Et à l'étape suivante, mais nous pourrions en faire un peu plus. Je suis assez ce JavaScript
et aussi avec CSS.
59. Prettify des événements: À cet état de ce projet, nous pouvons obtenir événements
côté serveur
sur le site Web, mais ce n'est que dans la console. Et maintenant, nous voulons nous
réjouir de tout ça. Par conséquent, nous
revenons à notre principal RPC et les événements
éliminent les événements du
jeu principal jusqu'à la fin. Et avant de réinitialiser le jeu, nous envoyons ici
les événements juste une fois après le jeu. Ensuite, nous sauvegardons
ici le CPP
principal et passons à notre index HTML, car ici nous
devons ajouter un peu. Tout d'abord, nous examinons
ici cette structure. Nous avons ici des statistiques. Et c'est ce que l'on appelle les résultats est le nom de classe des archaea
doit appeler ça les reins. Et parce que c'est un nom de classe. Et nous voulons ajouter
ici quelques rangées. Et une table provient d'une
structure avec un rho. Rho est et c'est la technologie. Et nous avons également quelques colonnes, et les colonnes sont
identifiées avec td. Je veux avoir vos
quatre colonnes. Une rangée. La première colonne est
le numéro rond. Alors combien,
combien de fois j'en ai un, perdu et serré, etc. Par conséquent, nous utilisons jQuery. Tout d'abord, j'aimerais
avoir ici et variable, et ça s'appelle TR
counter parce que je veux savoir combien d'heures, combien de lignes j'ajoute. Nous verrons pourquoi nous
en avons besoin. Tout d'abord, nous devons déclarer non seulement
pour les rondes, je veux en faire une perdue. C'est l'en-tête
et aussi serré. D'accord ? Nous pouvons maintenant
passer à nos événements. Et maintenant, nous devons réfléchir. Nous voulons ajouter ici au 1. Tout d'abord, nous devons
créer le n à partir d'une nouvelle ligne, puis le commentaire des
colonnes et la fin, nous avons la structure
de la fin de
la colonne et de la
ligne une fois de plus, tout d'
abord, la ligne commence, puis nous avons quatre colonnes ,
puis nous
devons finir là. Rangée. C'est pourquoi, une fois de plus, nous reprenons notre seul événement. Donc tout d'abord, var row est que
nous commençons par
un événement TR, puis il vient notre colonne. Et cela sera envoyé maintenant via
le chrome à notre table. Et la table s'appelle. C'est une classe que nous utilisons
un point, monsieur par exemple. Et nous utilisons l'
ajout car nous voulons ajouter
chaque ligne par la suite. Nous analysons la salle de valeur des
lignes, mais nous n'avons pas fini ici. Qu'est-ce que notre TR ? Je voudrais m'identifier
avec une pièce d'identité spéciale et l'idée est le t, notre compteur. Tout d'abord, juste
des citations normales, puis des guillemets doubles pour
que je puisse ajouter ici la salle et les idées. Le T D que j'aimerais aussi
avoir. Plus, plus. D'accord ? Je ne suis pas là
parce que voici le numéro de ligne
plus, plus le compteur. C'est donc la même chose. L'identifiant n'est que l'identifiant pour
nous, pour la programmation. Et ici, j'
aimerais avoir ça. Ici, 123, etc. Mais j'ajoute aussi ici et classe. Ce sont de petits nombres et vous
pouvez le voir dans ce style CSS. Jusqu'à présent, c'est bon. Ensuite, nous écrasons notre
variable de ligne et nous envoyons
également celle-ci au TR, que nous avons créé ici. Par conséquent, hashtag
plus t, notre compteur. Nous voulons donc
maintenant accéder à l' identifiant du nouveau point de
ligne créé, ajouter une ligne. À l'intérieur de la rangée. Nous sommes en train de créer une nouvelle colonne. Et c'est aussi avec
des chiffres et des informations plus petits. Celle-ci, nous pouvons ajouter ici
des données. Qu'est-ce que les données ? données sont celles que nous
imprimons dans la console, que nous passons
par l'ESPN. Et c'est tout ce dont nous avons besoin. Je pense que je
copierais celui-ci. Le journal de la console que nous sommes remplace et j'ajoute ici et
var en avant de la rangée. Et ici aussi, le dernier, mais nous n'en avons pas fini. La dernière chose parce que nous
devons fermer la ligne. Près de la lumière. Nous sommes ouverts ici au tout
premier début, mais nous voulons le fermer maintenant. Par conséquent, je dis l'ID
du compteur TR, que nous avons initialisé auparavant. Ajouter un point et une
balise de fermeture pour la ligne. À la fin, je dois augmenter notre compteur
pour la prochaine ligne. Ça devrait être tout. Je pense jusqu'à présent. Ensuite, je suggère que
nous téléchargions le
site Web et le croquis. Et voyons ce que dit
le compilateur. Usp s'est connecté que nous redémarrons ou
actualisons le site Web. Comme nous pouvons le constater, nos quatre
lignes ou colonnes sont ici. Maintenant, j'envoie des ciseaux. J'ai perdu une fois, deuxième ciseau, et j'ai déjà
perdu la partie, comme vous pouvez le voir ici. Je suis perdu. Puis encore une fois, j'ai perdu une fois, serré, une
fois, un. Nous n'avons donc qu'une seule rangée parce que
nous sommes toujours dans le jeu. Et maintenant, nous en avons un. Nous avons donc ici,
puis la prochaine ligne. Donc, une erreur mineure. Nous devons initialiser notre
compteur avec un et non 0. Mais ici, un autre jeu avec pierre a ensuite perdu une fois, perdu dans le temps. La prochaine rangée. ai perdu un la première fois. Serré, serré. La deuxième fois, j'ai perdu une fois que maintenant j'ai changé
de papier et j'ai gagné. Donc, le match ou le quatrième match, 12 fois, a perdu une fois
serré deux fois. Nous avons donc
implémenté avec succès ici les
événements côté serveur et
avons également une bonne page de résultats où nous pouvons
visualiser nos résultats.
60. Mettre en œuvre le cours LED: L'une de nos dernières tâches sera maintenant d'implémenter la classe LED. Par conséquent, je vais dans
le dossier principal du
chapitre précédent du cours sur lequel les, lesquels nous avons défini les LED. Et on y va. Nous le copions et le collons dans notre dossier
source et nous l'ouvrons. Vous pouvez voir ici ce que
nous avons défini ici. Ensuite, je suggérerais que
nous ouvrons ici le RPS, w est TPP et incluons ici dans les nouvelles LED point h.
Et en tant qu'exposant, je dirais que nous
vérifions le fichier d'en-tête
parce que dans le fichier d'en-tête
, j'ai déjà mis en œuvre
dès le premier début. Toutes les LED sont éteintes et
allumez toutes les LED. Je ne dirais pas de terminologie. C'est un peu faux nom. Il devrait s'agir de
LED d'affichage par exemple. Alors, voilà,
large, toutes les LED sont éteintes. Et cela vaut la peine d'être notre sujet
BSW et MSW point à point. Ces couvercles. Alors, qu'est-ce qui ne va pas avec celui-là ? Désolé, non, c'est bon. Nous devons donc maintenant réfléchir à façon d'implémenter
ici une fonction LED , qui sera
invoquée à chaque jeu. Par conséquent, c'est
relativement facile car nous appelons la fonction
après chaque joueur de contrôle. Parce qu'après chaque vérification, il doit y avoir inchangé
dans le discours. Et ensuite, nous voulons également afficher ici le
changement de partition. LED d'affichage. Et ici, nous créons une
fonction plus simple où nous pouvons voir si le score du jeu pour gagner pour score de
0 point est égal à un. Puis d'abord LED sur LLC
si le jeu marque un. Cela signifie donc que nous avons perdu. Dotcom est de ma faute. Je suis le seul parce que j'ai deux
LED sur gagner et perdre , puis les LED sont sur la
même chose avec les débits. Donc, si nous perdons, alors la première LED allumée et ici
aussi la seconde. Nous n'avons donc
pas initié de nouveaux objets. Le nom de la classe est couvercles. Puis, par exemple,
il est allumé, jaune, l'un est allumé et
il est dans la broche 55. Nous avons cinq LED. Laissez la LED rouge lire, et nous en avons un bleu. Nous avons deux épingles. J'ai le deuxième
décollage jaune 18, le premier rouge le 17, le 16, le 19. Et maintenant, nous pouvons l'activer. Donc on dit tard, jaune, on allume. Si nous avons le score de 12, alors j'aimerais avoir ici
le score jaune à activer. Les jeux ont été pris. J'aimerais que la LED
rouge allume le LED 12. Si le score du jeu est égal à un, alors le gros, LED bleue ou s'allume. Quand on le veut. Pas encore, s'il vous plaît. Oh ouah, nous devrions réinitialiser toutes les
LED sur la LED est éteinte. C'est simple. Nous appelons simplement chacune
des LED et nous les éteignons. Et comment pourrions-nous faire
cela avec la désactivation ? Et SEM se souviendra peut-être que nous avons ici un analogue. Nous vérifions si nous avons
allumé les LED, quel analogiqueWrite
toujours numérique, ce que nous avons allumé
avec le numérique, n'est-ce pas ? C'est la raison pour laquelle nous
passons ici et c'est faux. Ensuite, je
vais à Réinitialiser le jeu et j'appelle que toutes les LED sont éteintes. Ce devrait être
tout ce
dont nous avions besoin pour
afficher la LED. Voyons donc ce que dit
le compilateur. L'ESP est donc clignoté, allumant la caméra
pour que nous puissions voir ici tout notre Bahreïn. Et juste les rapports selon lesquels mon routeur permettait à mon ESP se connecter à l'
équipe épouse. Maintenant, nous sommes prêts. Je peux donc maintenant choisir ici, par
exemple, la pierre. Et la LED rouge s'allume
parce que j'ai perdu. Puis encore une fois, j'
ai perdu deux fois n, il disparaîtra immédiatement. C'est la raison pour laquelle, parce que nous n'avons pas de niveau
dans le cadre de son principal RPC. Lorsque nous réinitialisons
ici tout ce qui se passe dans la boucle, nous pourrions définir
ici et un court délai. Par exemple, retardez
trois secondes. C'est normal que nous utilisions
ici et retardé parce que le jeu une fois terminé
ne devrait rien faire. Par exemple, vous pouvez à nouveau mettre à jour l'esquisse
ici. Mais je le garde ici, je teste ici les LED. Maintenant, nous avons serré, donc la LED bleue fonctionne également. Puis, sur la deuxième, j'ai perdu encore une fois. J'ai 111, j'ai perdu trop serré,
et c'est fini. John, aussi, nos LED fonctionnent
très bien rapidement. Nous avons implémenté ici de
telles classes et vous
pouvez accéder ici à
différents types de fonctions quand
vous le souhaitez. Et cela nous donne maintenant
une bonne vue d'ensemble
du potentiel de la manière orientée
objet.
61. Créez et publiez votre propre bibliothèque: Ainsi, lorsque nous aurons créé
nos propres classes, vous voudrez
peut-être également
partager et
vous fournir des cours avec d'autres. Cela pourrait être fait avec
une bibliothèque terminée. Dans cette vidéo, j'
aimerais vous montrer comment nous avons pu configurer à partir d'une classe sur bibliothèque et comment
vous pouvez le partager et implémenter arduino, EDA. Et Stefan. Je suis ici sur mon ordinateur Windows. Je suis dans le dossier documents,
Arduino et les bibliothèques. s'agit du dossier standard, et c'est également pour
l'IDE Arduino à 0 et également pour les
versions ultérieures appropriées. Dans cette structure de
dossier, je crée un nouveau
dossier et je
l'appelle par exemple des LED pixel. Et dans ce dossier maintenant, je suis en train de copier-coller. Ici. Laissez-moi voir où je suis. Formez notre
croquis fini à partir des LED. Laissez-moi voir la source des LED. Je me débrouille ici. Tous défient les idées. Ce dossier principal
et le cpp principal, je l'ajoute, le nom
ou par exemple, poursuite des LED ne sont pas cpp. Je suis en train de changer pour ignorer
car nous voulons ajouter la bibliothèque dans
l'Arduino EDM. Ensuite, nous créons un dossier pour les exemples qui
doivent être appelés exemples. Ensuite, nous allons faire glisser
et déposer ce fichier dans ce dossier que nous avons
créé sur le sous-dossier. Il doit porter le même
nom que le fichier. Par exemple. Dans ce fichier, dans ce dossier, j'ouvre les données d'inode et nous devons nous adapter,
entendre quelque chose. Tout d'abord, nous devons ajouter ici quelques nœuds
sous licence, etc. quoi sert cette bibliothèque ? À quoi sert cet exemple ? La première chose que
nous faisons est ici, c'est que
nous changeons les citations
à cette science, car maintenant nous n'avons pas
terminé
la bibliothèque dans les bibliothèques
doit être incluse avec cela. Le signe le plus grand et le moins que le signe. C'est tout ce que nous devons faire. Ensuite, nous allons ranger un
peu notre code. Peut-être ajoutons-nous ici
quelques commentaires. Débarrassez-vous de tous
ces exemples. Laissez courir après. Et nous pourrions en dire ici, par
exemple, les exemples. Gardez-le. Et c'est bon pour nous jusqu'ici. Revenons au dossier. Voici mon RPC et mes LED point h c'est ce
que je veux avoir ici. Rien de plus ce que je veux ajouter. Mais une seule chose
doit être faite. Et c'est sous les propriétés des points de
bibliothèque. Ouvrons-le. Ici. Vous pouvez définir votre
nom, par exemple, ou le nom de la classe
doit être le même que le détournement des photons ou
la maintenance extérieure. Quelques articles sont
des choses dans quelle catégorie et quelles dépendances
se trouvent dans votre classe. Cela vous donne une bonne vue d'ensemble. Il y a beaucoup
d'autres choses à faire. Par exemple, des mots-clés
qui seront trouvés avec le gestionnaire de
bibliothèque, etc. Mais j'aimerais que cela
reste très simple pour que vous
puissiez voir ce que nous voulons faire ici. L'EDA externe prend toujours un peu de temps
à ma machine. Nous allons donc maintenant esquisser,
inclure une bibliothèque, passer
à Bibliothèques Contributed. Et il devrait y avoir
ici des couvercles Lady. Parfait. Ensuite, je dis, oui, parce que maintenant après un
accès complet après le cours, ma LED est des couvercles. Par exemple, j'utilise
ici la copie de la barre cinq. Celui-ci pourrait
fuir est, par exemple, 18. Ensuite, j'
allume mes pistes pour allumer. Et dans la boucle, je dis
mes croisades LED, 20e. Mon LED vers. Y a-t-il une
suggestion complète ? Laissez-moi voir. Si ça fonctionne aussi sur
Oui, on y va. J'aurais aimé m'
éteindre après un retard. Nous avons deux millisecondes. J'aimerais éteindre la
deuxième LED et cinq secondes. Et c'est faux parce que nous
n'avons pas d'analogue, non ? Très bien. Maintenant, je veux télécharger celui-ci. J'ai utilisé vos nœuds 23 et téléchargeons
le tout. , on allume
la caméra, on a redémarré. Nous avons donc ici
la LED qui pulse. Celui-ci devrait se déclencher au bout de
cinq secondes. Très bien. Et nous avons
implémenté avec succès notre propre bibliothèque dans
l'IDE Arduino. Nous pouvons maintenant y accéder de
manière très pratique et vous pouvez partager votre bibliothèque avec d'autres personnes. Mais nous n'avons pas encore fini. Nous avons également ici
quelques exemples de fichiers. Ensuite, on descend. Et il devrait y avoir aussi l'
exemple entre les deux. On y va, parce que
Lydia poursuit les LED. Ouvrons celui-là. Ici. Nous devrions avoir l'
exemple d'avant avec tous nos fichiers et avec
l'exemple parfait. Et ce cadeau aussi d'autres développeurs et
une bonne vue intérieure, ce qu'ils peuvent faire
avec votre bibliothèque. Voyons donc où nous sommes, où nous sommes ici
sous les bibliothèques. Vous pouvez donc aussi aller sur ce dossier
sacré et le
siroter, dans un fichier SIP. Et ensuite, vous pouvez le partager, par
exemple, sur GitHub, ou vous pouvez les envoyer développer sur ce développeur
peut aller dans Sketch, Inclure Library
dans une bibliothèque SIP, puis le tout sera installée sur le support. C'est également un
moyen pratique pour d'autres personnes d'
implémenter l'ensemble de votre paramètre, par exemple
pour la bibliothèque. Et c'est tout jusqu'ici. C'est ainsi que vous pouvez créer
une bibliothèque simple et la fournir à d'autres personnes.
62. Résumé des leçons: Nous sommes maintenant à la fin
de ce cours en ligne et j'aimerais
prendre quelques minutes pour résumer tous les enseignements que nous avons tirés dans
ce cours en ligne. Donc, tout d'abord,
nous discutons un peu des bases. Qu'est-ce qu'une énumération,
qu'est-ce qu'une instruction ? Quels sont les différents
types d'EDI ? Ce que nous avons l'IDE Arduino, Visual Studio Code,
cette plate-forme ion. Comment utiliser le
code de l'Arduino vers le code visuel
et inversement. Ensuite, nous avons fait une
brève introduction aux bases orientées objet. Nous
discutons de la façon dont nous pouvons mettre en place un projet vide. Quelle est la classe principale ? Quelle est la construction ? Qu'est-ce qu'un constructeur
et l'initiation d' un objet que nous pouvons également
surcharger les constructeurs, les constructeurs, les fonctions principales, la première fonction lorsque nous
lançons un objet de projet. Et nous avons pu fournir plusieurs
types de constructeurs différents. Ensuite, nous avons également discuté des fonctions de
base comme
getter et setter. Ainsi, avec la fonction publique, nous pouvons accéder à des membres privés. C'est l'encapsulation des données. Et nous avons également parlé de
l'héritage afin que nous puissions
facilement éditer
et bibliothèque publique. Ensuite, nous avons commencé avec la
première classe de LED individuelle. Cela signifie que nous avions beaucoup de LED
et que, au même temps ou au même cycle de vie, nous
pouvions contrôler ici sur différents types de LED
en même temps. Cela n'est possible que
de manière orientée objet. Si vous le faites dans une
fonction orientée là où vous avez besoin de beaucoup plus d'obstacles,
c'est possible. Nous sommes basculés sur les LED que nous avons fabriquées et nous retardons au
bout de huit secondes. Nous nous sommes évanouis en pulsant. Et nous y accédons
également avec un tableau. C'est donc quatre que possible
pour contrôler et appeler
plusieurs LED en même temps. Un des projets suivants,
nous sommes avec le conseil d'administration de Galton. Nous avions également inclus de nombreux types
de capteurs différents dans ce projet. Et il nous a été facile de
créer une matrice et d'initier, le
contrôler, d'initialiser
les capteurs ER. Cela nous donne également la
possibilité de travailler rapidement et de manière flexible avec différents
types d'entrées provenant de capteurs. L'un des principaux projets était
également la lampe frontale. En raison de la réduction de nos commandes d'entrée
avec un seul bouton. C'était le défi d' avoir mis en œuvre trois
types différents de modèles d'éclairage. Nous avons donc dit une courte respiration, nous avons mis en œuvre, il suffit de l'
allumer et de l'éteindre. La première LED. Lorsque nous avons appuyé sur un bouton
pendant un rond-point 1 seconde. Ensuite, le deuxième LET
s'allume ou s'éteint. Et lorsque nous continuons appuyer sur le bouton
pour éclairer la technologie, nous alimentons les premiers modèles LET All Sweet Lite accessibles par un seul
bouton en même temps. Ce n'est pas vraiment pratique. Exemple car
souvent, nous n'avons qu'
une seule entrée, mais nous avons besoin de
plus d'un mody. Et c'est ce que pourrait être l'
exemple réel. Dernier projet, nous avons mis en œuvre le
jeu de ciseaux de papier rock, recréé et encore, Modi de la
manière orientée objet que nous appelons ici et le
serveur Web a fait
la
communication du serveur Web au serveur
Web avec l'ESP. Vous pouvez également voir dans
cet exemple à quel point il
est facile de contrôler plusieurs
cellules avec un tableau. Et cela vous donne une
fois de plus l'occasion d'interagir facilement avec les composants
électriques de Smith, les composants
mécaniques. Nous nous sommes donc concentrés sur le
côté matériel, sur le côté logiciel. Et j'espère pouvoir vous montrer tout
le potentiel de
l'objet orienté vers l'objet.