Earth_Analyzer

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Lötdraht, bleifrei
	Lötflussmittel, Löten
	Multitool, Schraubendreher

Apps und Onlinedienste

	Arduino-IDE
	Bolt IoT Bolt Cloud
	integromat
	Twilio SMS Messaging API
	Mailgun
	Bolt IoT Android App
	Bolt IoT iOS App

Über dieses Projekt

HALLO, HALLO JEDER

Bei diesem Projekt geht es hauptsächlich um den Rover für die Erde, der Landwirten helfen kann. Dieses Projekt enthält hauptsächlich drei Module.

MODUL 1:

Hardwareverbindungen für das komplette Setup berücksichtigen jetzt die Gleichstrommotoren.

Dies erfordert die beiden Gleichstrommotoren und einen Motortreiber. Motortreiber enthält

Hier müssen Sie die v +, en1, en2, mit dem einzelnen Punkt in der Brotplatine verbinden und die vier Drähte des Motors mit den vier Eingängen in den 1 ma 2 Pins verbinden. Als nächstes werden die Ausgangspins des Motortreibers mit dem Arduino verbunden und Batterie sollte wie folgt angeschlossen werden.

Als nächstes müssen wir sie mit dem Bolzen verbinden. Die gleichen vier Pins sollten mit den digitalen Pins des Bolzens (0, 1, 2, 3) verbunden werden.

Jetzt sollte der Bodensensor mit dem Bolzen verbunden sein, aber den digitalen Stift auf den Bolzen setzen (4-polig). Jetzt ist es endlich an der Zeit, den Temperatursensor mit dem analogen Bolzen des Bolzens (A0) zu verbinden.

Jetzt dieses Mal die gesamte Masse und die v + (Temperatursensor, Feuchtigkeitssensor), en1, en2 auf die 5 V des Arduino und schließlich sollte dieser alle Pin mit den erforderlichen Spannungsbatterien versorgt werden.

MODUL 2:

NRF-VERBINDUNGEN:

Das obige Diagramm wird als nrf-Modul bezeichnet, das für die Funkkommunikation verwendet wird. Das obige Diagramm sollte auch in unsere Schaltung aufgenommen werden, um das Auto in den nahen Bereichen zu steuern.

ENDGÜLTIGE VERBINDUNG DES NRF MIT DEM ARDUINO

JETZT IST ES ZEIT, JOY STICKS ZU VERBINDEN:

Es werden zwei Joysticks verwendet:

1) um die Autorichtung zu steuern.

2) um das Servo zu steuern.

MODUL 3:

ENDGÜLTIGE CODIERUNG

1)ARDUINO-KODIERUNG:

Sender:

#include 
#include 
#include 
#include 
 #include 

RF24-Funk (7, 8); // CSN, CE
const byte address[6] ="00001";

int x_key =A1; 
int y_key =A0; 
int p_key =A3; 
int q_key =A2; 
int x_pos;
int y_pos;
int p_pos;
int q_pos;

void setup() {
 radio.begin();
 radio.openWritingPipe(Adresse)
;
 radio.setPALevel(RF24_PA_MIN);
 radio.setChannel(87);
 radio.setDataRate(RF24_
250KBPS);
 radio.stopListening();
 
 Serial.begin(9600);
 pinMode (x_key, INPUT); 
 pinMode (y_key, INPUT);
 pinMode (p_key, INPUT); 
 pinMode (q_key, INPUT); 
}
int pos;
void loop() {
 x_pos =analogRead (x_key); 
 y_pos =analogRead (y_key); 
 p_pos =analogRead (p_key); 
 q_pos =analogRead (q_key); 
 Serial.println(x_pos);
 Serial.println(y_pos);
 Serial.println(p_pos);
 Serial.println(q_pos);
 if ( p_pos>400 &&p_pos<600 &&q_pos>400 &&q_pos<600)
 {
 if(x_pos>400 &&x_pos<600 &&y_pos>400 &&y_pos<600)
 {
 pos=100;
 radio.write(&pos, sizeof(pos));
 }
 if(x_pos>400 &&x_pos<600 &&y_pos<400)
 { 
 pos=200;
 radio.write(&pos, sizeof(pos));
 }
 if(x_pos>400 &&x_pos<600 &&y_pos>600)
 {
 pos=300;
 radio.write(&pos, sizeof(pos));
 }
 if(y_pos>400 &&y_pos<600 &&x_pos<400)
 {
 pos=400;
 radio.write(&pos, sizeof(pos));
 }
 if(y_pos>400 &&y_pos<600 &&x_pos>600 )
 {
 pos=500;
 radio.write(&pos, sizeof(pos));
 }
 Serial.println(pos);
 Verzögerung(100);
}
else if(p_pos<400 || p_pos>600)
{
 if(p_pos<400)
 {
 pos=600;
 radio.write(&pos, sizeof(pos));
 }
 if(p_pos>600)
 {
 pos=700; 
 radio.write(&pos, sizeof(pos));
 }
 delay(100);
}
} 

Empfänger:

#include 
#include 
#include 
#include 
 #include 
#include 
Servo-Servo;

RF24-Funk (7, 8); // CSN, CE
const byte address[6] ="00001";
int servo_pin =9;
int sensor_pin=A0;
int output_value;

void setup() {
 Serial.begin(9600);
 radio.begin();
 servo.attach (servo_pin );
 radio.openReadingPipe(0, Adresse);
 radio.setPALevel(RF24_PA_MIN);
 radio.setChannel(87);
 radio.setDataRate(RF24_250KBPS);
 radio.startListening();
 }
int pos;
void loop() {
 if (radio.available()) {
 radio.read(&pos, sizeof(pos));
 Serial.println(pos);
 if(pos==100)
 {
 digitalWrite(6,LOW);
 digitalWrite(5,LOW);
 digitalWrite (4,LOW);
 digitalWrite(3,LOW);
 // Serial.println("gk0");
}
 else if (pos==200){ 
 digitalWrite(6,HIGH);
 digitalWrite(5,LOW);
 digitalWrite(4,HIGH);
 digitalWrite(3,LOW);
 delay( 10);
 // Serial.println("gk1");
 }
 else if (pos==300){
 digitalWrite(6,LOW);
 digitalWrite(5,HIGH);
 digital Write(4,LOW);
 digitalWrite(3,HIGH);
 delay(10);
 // Serial.println("gk2");
 }
 else if (pos==400){
 digitalWrite(6,LOW);
 digitalWrite(5,HIGH);
 digitalWrite(4,HIGH);
 digitalWrite(3 ,LOW);
 delay(10);
 // Serial.println("gk3");
 }
 else if (pos==500){
 digitalWrite(6,HIGH);
 digitalWrite(5,LOW );
 digitalWrite(4,LOW);
 digitalWrite(3,HIGH);
 delay(10);
 // Serial.println("gk5");
}
 else if (pos==600){
 servo.write (90);
 delay (10 .) ); 
 // Serial.println("gk6");
 }
 else if (pos==700){
 servo.write(180);
 delay( 10);
 // Serial.println("gk7");
 
 }
 }
 else
 {
 Serial.println( "Verbindung unterbrochen"); 
 }
}
} 

jetzt Telegrammnachricht empfangen :(Servercode)

Melden Sie sich bei einem der Server wie ripl.it an und laden Sie dann die Codes hoch

main.py

Import-Anfragen # zum Erstellen von HTTP-Anfragen
importieren Sie json # Bibliothek zum Verarbeiten von JSON-Daten
Importieren Sie das Zeitmodul # für den Ruhebetrieb
from Bolt Import Bolt # Importieren Sie Bolt aus dem Bolt-Modul 
import conf # config file
mybolt =Bolt(conf.bolt_api_key, conf.device_id)
def get_sensor_value_from_pin(pin):
try:
response =mybolt.digitalRead (pin)
data =json.loads(response)
if data["success"] !=1:
print("Request nicht erfolgreich")
print("This is the response->", data)
return -999
sensor_value =int(data["value"])
return sensor_value
außer Ausnahme wie e:
 print("Bei der Rückgabe des Sensorwertes ist etwas schief gelaufen")
print(e)
return -999
def send_telegram_message(message):
"""Sendet Nachricht per Telegramm" ""
url ="https://api.telegram.org/" + conf.telegram_bot_id + "/sendMessage"
data ={
"chat_id":conf.telegram_chat_id,
"text":Nachricht
}
versuchen:
re sponse =request.request(
"GET",
url,
params=data
)
print("Dies ist die Telegrammantwort")
 print(response.text)
telegram_data =json.loads(response.text)
return telegram_data["ok"]
außer Ausnahme als e:
print("Ein Fehler ist aufgetreten beim Senden der Warnmeldung per Telegramm")
print(e)
return False
während True:
# Schritt 1
sensor_value =get_sensor_value_from_pin("4")
print("Der aktuelle Sensorwert ist:", sensor_value)
# Schritt 2
if sensor_value ==-999:
print("Anfrage war nicht erfolgreich. Überspringen.")
time.sleep(10)
weiter
# Schritt 3
if sensor_value>=conf.threshold:
print("Der aktuelle Temperaturwert ist ")
message ="Der Feuchtigkeitswert ist knapp über dem Schwellenwert "
telegram_status =send_telegram_message(message)
print("Dies ist der Telegrammstatus:", telegram_status)
# Schritt 4
time.sleep(100) 

conf.py:

"""Konfigurationen für telegram_alert.py"""
bolt_api_key ="XXXX" # Dies ist Ihr Bolt Cloud API-Schlüssel
device_id ="XXXX" # Dies ist die Geräte-ID und wird ähnlich wie BOLTXXXX sein, wobei XXXX einige Zahlen ist
telegram_chat_id ="@XXXX" # Dies ist die Kanal-ID des erstellten Telegrammkanals. Einfügen nach @
telegram_bot_id ="botXXXX" # Dies ist die Bot-ID des erstellten Telegram-Bots. Einfügen nach bot
threshold =0 # Schwellenwert, ab dem die Warnung gesendet werden soll 

Geben Sie Ihre Bot- und API-Werte ein

VERFAHREN:

Benachrichtigungen per Telegram

Was ist Telegramm?

Telegram ist eine WhatsApp-ähnliche Messaging-App. Sie können auch Nachrichten zusammen mit Dateien senden und empfangen. Es ist KOSTENLOS zu verwenden. Sie können über Ihr Android-/iOS-/Windows-Telefon und auch über Ihren PC oder Mac auf die Plattform zugreifen.

Einige Telegrammterminologien -

Was ist ein Telegram-Kanal?

Ein Kanal ist zum Telegram, was Gruppen zu Whatsapp sind. Kanäle sind ein Werkzeug, um Ihre Nachrichten an ein großes Publikum zu senden. Sie können eine unbegrenzte Anzahl von Abonnenten haben, sie können mit einer permanenten URL öffentlich sein und jeder Beitrag in einem Kanal hat seinen eigenen Aufrufzähler.

Was ist ein Bot?

Bots sind Anwendungen von Drittanbietern, die in Telegram ausgeführt werden. Benutzer können mit Bots interagieren, indem sie ihnen Nachrichten, Befehle und Anfragen senden.

Wir werden Bots verwenden, um Warnungen auf unserem Kanal zu senden.

Was werden wir in diesem Projekt lernen?

In diesem Projekt können Sie Benachrichtigungen per Telegram an Ihr Telefon senden, wenn der Sensorwert Ihren eingestellten Schwellenwert überschreitet.

Was benötige ich für dieses Projekt?

Um Benachrichtigungen und Nachrichten per Telegram zu senden, benötigen Sie:

• Ein Android-/iOS-/Windows-Telefon mit Internetverbindung.
• Ein Telegram-Konto. Dafür benötigst du eine Handynummer.
• Zugriff auf Ihr Ubuntu-Betriebssystem über puTTY oder Virtual Machine.

Setup-Telegramm

Schritte zur Anmeldung/Anmeldung bei Telegram

• Gehe auf deinem Telefon zum Playstore oder App Store und suche nach Telegram.
• Laden Sie die neueste Version der Telegram-App herunter und installieren Sie sie.
• Melden Sie sich für ein neues Konto an oder melden Sie sich bei Telegram an, indem Sie Ihre Handynummer angeben.
• Telegram ruft dich an ODER schickt dir eine SMS, um deine Handynummer zu bestätigen.
• Lass dein Konto verifizieren und genehmige bei Bedarf alle Berechtigungen.
• Sie werden bei Telegram angemeldet und es wird ein Bildschirm ähnlich dem folgenden angezeigt. (Es ist in Ordnung, wenn es vom Screenshot unten abweicht)

Sie haben Telegram erfolgreich installiert und Ihr Konto eingerichtet. In den nächsten Lektionen werden wir mehr über Kanäle und Bots erfahren.

Einen Kanal erstellen

Was ist ein Telegram-Kanal?

Ein Kanal ist zum Telegram, was Gruppen zu Whatsapp sind. Kanäle sind ein Werkzeug, um Ihre Nachrichten an ein großes Publikum zu senden. Sie können eine unbegrenzte Anzahl von Abonnenten haben, sie können mit einer permanenten URL öffentlich sein und jeder Beitrag in einem Kanal hat seinen eigenen Aufrufzähler.

Schritte zum Erstellen eines Kanals

• Gehe zum Startbildschirm der Telegram-App.
• Wischen Sie von der linken Seite, um das Menü anzuzeigen.
• Klicke auf "Neuer Kanal".

• Sie werden nach einem Namen und einer Beschreibung für Ihren Kanal gefragt. Geben Sie einen passenden Namen und eine Beschreibung an. Das Hinzufügen eines Fotos ist optional.

• Lege im nächsten Bildschirm den Kanal als Öffentlich fest.
• Auf demselben Bildschirm werden Sie aufgefordert, einen permanenten Link für Ihren Kanal einzugeben. Du kannst Kleinbuchstaben und Zahlen von 0-9 verwenden, um den Kanallink zu erstellen.
• Bitte beachte, dass der Kanallinkname global ist und du nur dann einen Kanallink erstellen kannst, wenn der Linkname verfügbar ist. Der Name des Kanallinks ähnelt einer E-Mail-Adresse, d. h. es kann immer nur eine eindeutige E-Mail-ID existieren.
• Du kannst den Linknamen des Kanals als temperature_alert_ belassen, gefolgt von deiner E-Mail-ID. Wenn meine E-Mail-ID beispielsweise [email protected] ist, kann ich den Kanallinknamen als temperature_alert_developer_boltiot_com beibehalten (Ich habe das @ und. Symbol entfernt, da es nicht erlaubt war und es durch einen Unterstrich _ ersetzt). Dies ist nur ein Vorschlag. Du kannst den Linknamen des Kanals beliebig lange beibehalten, solange er gültig ist.
• Notieren Sie sich den Namen des permanenten Links dieses Kanals. Es wird später erforderlich sein, Nachrichten an diesen Kanal zu senden. Der Name des Kanallinks im Screenshot unten lautet beispielsweise " temperature_alert".

• Herzlichen Glückwunsch! Sie haben einen neuen Kanal erstellt. Du kannst diesen Kanal auch auf deinem App-Startbildschirm anzeigen.

• Du kannst oben auf den Kanalnamen klicken, um weitere Details dazu anzuzeigen.

• Als Nächstes müssen wir einen Bot erstellen und dem Kanal hinzufügen, damit er Benachrichtigungen für uns in diesem Kanal posten kann.

Erstelle ein Beides

Was ist ein Bot?

Bots sind Anwendungen von Drittanbietern, die in Telegram ausgeführt werden. Benutzer können mit Bots interagieren, indem sie ihnen Nachrichten, Befehle und Anfragen senden.

Wir werden Bots verwenden, um Warnungen auf unserem Kanal zu senden.

Erstelle ein neues Beides

Telegram ermöglicht es uns, mit Hilfe eines Bots namens "BotFather" einen neuen Bot zu erstellen. Es ist ein einzelner Bot, um andere Bots zu erstellen und zu verwalten.

• Klicke auf dem Startbildschirm der App oben rechts auf das Suchsymbol und gib "botfather" ein.

• Klicken Sie in den Suchergebnissen auf das richtige Ergebnis für "BotFather", wie unten gezeigt. Der richtige "BotFather" hat neben seinem Namen ein blaues Häkchen. Dadurch gelangen Sie zu einem Chat-Fenster mit dem "BotFather".

• Der Chat enthält bereits einige Elemente und zeigt Ihnen eine Liste mit Befehlen an, um loszulegen.

• Da wir einen neuen Bot erstellen müssen, geben Sie "/newbot" in das Fenster ein.
• Sie werden aufgefordert, einige weitere Details wie den Bot-Namen und den Bot-Benutzernamen einzugeben.
• Wenn Ihr Bot erfolgreich erstellt wurde, wird Ihnen ein Bildschirm ähnlich dem folgenden angezeigt, der das Bot-Token enthält. Dieses Token wird verwendet, um Ihren Bot zu steuern und Nachrichten in seinem Namen zu senden. Bitte bewahren Sie dieses Token sicher auf, damit jeder auf Ihren Bot zugreifen kann.

• Im obigen Screenshot ist das Bot-Token "894346529:AAhuJ2XJQy5dlEtLYF0sc0Z_qu0fSqihSSc". Bitte speichern Sie es als telegram_bot_id. Die telegram_bot_id wird als "bot" gespeichert, gefolgt vom Bot-Token. In diesem Beispiel lautet die telegram_bot_id also "bot894346529:AAhuJ2XJQy5dlEtLYF0sc0Z_qu0fSqihSSc".
• Die telegram_bot_id wird im Python-Code zum Senden von Nachrichten verwendet. Der Python-Code wird in den späteren Lektionen gelehrt.
• Außerdem seien Sie bitte vorsichtig, wenn Sie die Bot-ID speichern. Sie können zwischen 0 und O, I und 1 usw. verwechseln, da sie ähnlich aussehen.
• Herzlichen Glückwunsch, Sie haben einen neuen Bot erstellt. Jetzt müssen wir es zu dem zuvor erstellten Kanal hinzufügen, damit wir Benachrichtigungen senden können.

Bot dem Kanal hinzufügen

• Öffne auf dem App-Startbildschirm den Kanal, den wir zuvor erstellt haben.
• Klicke oben auf dem Bildschirm auf den Kanalnamen, um die Informationen zum Kanal zu öffnen.

• Klicke auf die Schaltfläche Administratoren, damit wir den neu erstellten Bot zum Kanal hinzufügen können.

• Suchen Sie mit dem Benutzernamen des Bots nach dem Bot, den wir erstellt haben. Sobald Sie den richtigen Bot gefunden haben, klicken Sie darauf, um ihn dem Kanal hinzuzufügen. Bitte vergewissern Sie sich, dass Sie im vorherigen Schritt auf die Schaltfläche Administratoren geklickt haben, da dies unserem Bot ermöglicht, im Kanal zu posten.

• Sie werden aufgefordert, die Rechte für den Bot zu bestätigen. Drücken Sie auf das Häkchen oben rechts, um den Bot weiter zum Kanal hinzuzufügen. Stellen Sie sicher, dass der Bot die Rechte zum Posten von Nachrichten hat.

• Du siehst nun den neu erstellten Bot in der Liste der Administratoren für den Kanal.

• Jetzt werden wir codieren, um Nachrichten über den Bot an den Kanal zu senden.

JETZT DAS NETZWERK FÜR TWILLO UND MAIL PISTOLE EINSTELLEN

Erhalten Sie die Werte des LM35-Temperatursensors per SMS und E-Mail jederzeit auf Ihrem Mobiltelefon mit Google Assistant.

Was tun Sie, wenn Sie die Sensorwerte Ihres Iot-Projekts jederzeit überprüfen müssen? Sie melden sich einfach bei Ihrer Cloud an, um sie zu überprüfen. Scheint einfach, nicht wahr? Aber was wäre, wenn Sie die Werte einmal in jeder Stunde oder alle paar Minuten und das zu oft am Tag überprüfen müssten. Das wäre etwas (sehr) umständlich, oder? Stellen Sie sich nun eine Welt vor, in der Sie die Sensorwerte per SMS und E-Mail abrufen könnten, indem Sie einfach "Senden Sie mir die Sensorwerte" zu Ihrem Google Assistant sagen. Warte warte warte. Diese Situation ist nicht mehr imaginär, weil Sie das selbst in wenigen Schritten tun könnten. Lesen Sie weiter, um es herauszufinden.

In diesem Projekt erhalten wir die Temperatursensorwerte vom LM35-Sensor per SMS und E-Mail über einen Befehl an Google Assistant.

Schritt 1:Hardware-Setup

Halten Sie den LM35-Sensor so in der Hand, dass der Name für Sie sichtbar ist. Die drei Pins von links nach rechts sind VCC, Ausgang und GND. Verbinden Sie die drei Stifte mit den Buchse-zu-Stecker-Drähten. Verbinden Sie die drei Drähte, die den drei Pins von links nach rechts entsprechen, mit den 5 V-, A0- und GND-Pins des Bolt WiFi-Moduls. Verbinden Sie das WiFi-Modul mit einer 5-V-Stromquelle. Stellen Sie sicher, dass es mit einer aktiven Internetverbindung verbunden ist.

Schritt 2:Erstellen eines IFTTT-Moduls in Integromat

Melden Sie sich bei Ihrem Integromat-Konto an. Wenn Sie sich nicht bei Integromat angemeldet haben, können Sie hier ein Konto erstellen. Klicken Sie nach der Anmeldung oben rechts im Bildschirm auf "Neues Szenario erstellen". Wählen Sie auf dem Bildschirm IFTTT, HTTP, Mailgun und Twilio aus, um die erforderlichen Tools auszuwählen, und klicken Sie dann auf "Weiter". Klicken Sie dann auf den weißen Kreis und wählen Sie IFTTT aus der Liste aus und wählen Sie dann "Daten empfangen" aus dem Menü. Dieses Modul ist unerlässlich, um es mit dem Applet auf IFTTT zu verbinden, auf das später eingegangen wird. Klicken Sie auf „Hinzufügen“, um einen neuen Webhook hinzuzufügen, geben Sie ihm einen passenden Namen und klicken Sie auf „Speichern“. Jetzt erhalten Sie eine URL oder einen Link. Speichern Sie es für weitere Zwecke.

Schritt 3:Erstellen eines HTTP-Moduls in Integromat

Klicken Sie anschließend auf das am Modul angebrachte "+"-Symbol, um ein neues Modul hinzuzufügen. Wählen Sie "HTTP" gefolgt von "Anfrage stellen". Dies ist erforderlich, um die Sensorwerte von der Bolt Iot Cloud zu erhalten. Fügen Sie in der URL den Link https://cloud.boltiot.com/remote/your-bolt-iot-api-key/analogRead?pin=A0&deviceName=BOLTXXXXXXX ein. Ersetzen Sie "your-bolt-iot-api-key" und "BOLTXXXXXXX" durch Ihre jeweiligen Zugangsdaten, die Sie ganz einfach in Ihrer Bolt Iot Cloud finden können. Lassen Sie die Methode "GET" sein und klicken Sie auf "OK".

Der obige Link wird verwendet, um die Sensorwerte aus der Bolt Iot Cloud abzurufen. Die Ausgabe des obigen Links erfolgt in Form von {"value":"XXX", "success":"1"} wobei XXX die Sensorwerte sind.

Schritt 4:Erstellen eines Mailgun-Moduls in Integromat

Klicken Sie nun erneut auf "+" und geben Sie "Flow Control" in das Suchfeld ein und wählen Sie es gefolgt von "Router" aus. Es müssen zwei weiße Kreise gemacht werden. Klicken Sie auf den ersten weißen Kreis und wählen Sie "Mailgun" gefolgt von "E-Mail senden". Hier wird Mailgun verwendet, um die E-Mail mit der Temperatur zu erhalten. Wenn Sie bereits ein Konto bei Mailgun haben, müssen Sie den API-Schlüssel und den Domänennamen haben, die leicht in Ihrem Mailgun-Konto zu finden sind. Wenn Sie kein Konto bei Mailgun haben, können Sie den unten angegebenen alternativen Schritt ausführen. Füllen Sie die erforderlichen Angaben wie verlangt aus. Geben Sie die E-Mail des Empfängers ein (das ist Ihre E-Mail-Adresse). Geben Sie in das Feld "Absender" "test@yourdomainname" ein. Im Abschnitt "Inhalt" müssen wir den Temperaturwert und nicht den Sensorwert schreiben. Um den Temperaturwert in den Sensorwert umzurechnen, müssen wir die Zahl durch 10,24 teilen. Um den Sensorwert in der Form XXX zu erhalten, müssen wir alle anderen Zeichen eliminieren, für die wir die Funktion "substring" verwenden. Klicken Sie im nebenstehenden Dialogfeld auf das Symbol "A" und wählen Sie "Teilzeichenfolge".

Klicken Sie im ersten Leerzeichen innerhalb der Klammern auf die Option "Daten" unter dem Sternsymbol, gefolgt von "11" und "14" im zweiten Leerzeichen und dritten Leerzeichen. Streng genommen ist dies nicht die richtige Methode, um den Sensorwert abzurufen, daher verwende ich einen Hack, um ihn zu erhalten. Wenn jemand den richtigen Weg kennt, kann er die Methode im Kommentarbereich unten erwähnen.

Letzteres geschieht, um nur das "XXX" aus der Ausgabe zu erfassen. Diese Zahl wird dann durch 10,24 geteilt

Vergessen Sie vor dem Speichern des Szenarios nicht, die "Planung" am unteren Bildschirmrand einzuschalten und "Szenario ausführen" als "Sofort" auszuwählen. Ihr endgültiges Szenario sollte so aussehen.

Schritt 6:Erstellen eines neuen Applets in IFTTT

Melden Sie sich bei Ihrem IFTTT-Konto an. Wenn Sie sich nicht bei IFTTT angemeldet haben, können Sie hier ein Konto erstellen. Klicken Sie nach der Anmeldung im Abschnitt "Meine Applets" auf "Neues Applet". Klicken Sie auf "+dies" gefolgt von "Google Assistant", nachdem Sie im Suchfeld danach gesucht haben. Click on "Say a simple phrase" in the following screen. Type the command for which you want to trigger the required action.

Click on "Trigger" followed by "+that". Search for "Webhooks" in the search box and select it followed by selecting "Make a web request" in the following screen. In the URL field, paste the link which we got in Step 2 after creating an IFTTT module in Integromat. This step is very essential to run the scenario in Integromat when you say the command to Google Assistant. Afterwards, select "POST" in method and click on "Create Action". Write a suitable name for the applet and select "Finish".

Das ist es. Now see the magic when you take out your mobile phone and say "Ok Google, send the temperature sensor value."

Schematics

Connecting female-to-male wires to LM35 sensor

Connecting female-to-male wires to the Bolt WiFi module

Final connection

THAT'S IT NOW UPLOAD EVERY THING AND THEN CHECK.

IF ANY DOUBTS CONTACT ME BY COMMENT SECTION.

THANK YOU....................................

Code

• FINAL RECEIVER
• FINAL TRANSMITER

FINAL RECEIVERArduino

#include #include #include #include #include #include Servo servo;RF24 radio(7, 8); // CSN, CEconst byte address[6] ="00001";int servo_pin =9;int sensor_pin=A0;int output_value;void setup() { Serial.begin(9600); radio.begin(); servo.attach (servo_pin ); radio.openReadingPipe(0, address); radio.setPALevel(RF24_PA_MIN); radio.setChannel(87); radio.setDataRate(RF24_250KBPS); radio.startListening();}int pos;void loop() { if (radio.available()) { radio.read(&pos, sizeof(pos)); Serial.println(pos); if(pos==100) { digitalWrite(6,LOW); digitalWrite(5,LOW); digitalWrite(4,LOW); digitalWrite (3, NIEDRIG); // Serial.println("gk0"); } else if (pos==200){ digitalWrite(6,HIGH); digitalWrite(5,LOW); digitalWrite (4, HOCH); digitalWrite (3, NIEDRIG); Verzögerung(10); // Serial.println("gk1"); } else if (pos==300){ digitalWrite(6,LOW); digitalWrite(5,HIGH ); digitalWrite(4,LOW); digitalWrite (3, HOCH); Verzögerung(10); // Serial.println("gk2"); } else if (pos==400){ digitalWrite(6,LOW); digitalWrite(5,HIGH ); digitalWrite (4, HOCH); digitalWrite (3, NIEDRIG); Verzögerung(10); // Serial.println("gk3"); } else if (pos==500){ digitalWrite(6,HIGH); digitalWrite(5,LOW ); digitalWrite(4,LOW); digitalWrite (3, HOCH); Verzögerung(10); // Serial.println("gk5"); } else if (pos==600){ servo.write(90); Verzögerung(10); // Serial.println("gk6"); } else if (pos==700){ servo.write(180); Verzögerung(10); // Serial.println("gk7"); } } else { Serial.println("connection lost"); } }

FINAL TRANSMITERArduino

#include #include #include #include #include RF24 radio(7, 8); // CSN, CEconst byte address[6] ="00001";int x_key =A1; int y_key =A0; int p_key =A3; int q_key =A2; int x_pos;int y_pos;int p_pos;int q_pos;void setup() { radio.begin(); radio.openWritingPipe(address); radio.setPALevel(RF24_PA_MIN); radio.setChannel(87); radio.setDataRate(RF24_250KBPS); radio.stopListening(); Serial.begin (9600); pinMode (x_key, INPUT); pinMode (y_key, INPUT); pinMode (p_key, INPUT); pinMode (q_key, INPUT); }int pos;void loop() { x_pos =analogRead (x_key); y_pos =analogRead (y_key); p_pos =analogRead (p_key); q_pos =analogRead (q_key); Serial.println(x_pos); Serial.println(y_pos); Serial.println(p_pos); Serial.println(q_pos); if (p_pos>400 &&p_pos<600 &&q_pos>400 &&q_pos<600) { if(x_pos>400 &&x_pos<600 &&y_pos>400 &&y_pos<600) { pos=100; radio.write(&pos, sizeof(pos)); } if(x_pos>400 &&x_pos<600 &&y_pos<400) { pos=200; radio.write(&pos, sizeof(pos)); } if(x_pos>400 &&x_pos<600 &&y_pos>600) { pos=300; radio.write(&pos, sizeof(pos)); } if(y_pos>400 &&y_pos<600 &&x_pos<400) { pos=400; radio.write(&pos, sizeof(pos)); } if(y_pos>400 &&y_pos<600 &&x_pos>600) { pos=500; radio.write(&pos, sizeof(pos)); } Serial.println(pos); delay(100);}else if(p_pos<400 || p_pos>600){ if(p_pos<400) { pos=600; radio.write(&pos, sizeof(pos)); } if(p_pos>600) { pos=700; radio.write(&pos, sizeof(pos)); } delay(100);}}

Schaltpläne