INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Problem Arduino Mega und Nextion Touch Display
26.10.2020, 17:30
Beitrag #1
Problem Arduino Mega und Nextion Touch Display
Guten Tag,
Ich betreibe ein Nextion Touch Display mit einem Arduino Mega und benütze die nextion-master Library. Im Quellcode habe ich den Nextion wie folgt initialisiert:

#define nextion Serial3 // soll seriell am Port Serial3 betrieben werden
Nextion myNextion(nextion, 9600); // erzeugen eines Nextion Objekts mit dem Namen
// myNextion bei Benützung des Nextion seriell
//Ports @ 9600bps

und habe beim Kompilieren folgendes Problem: Ich erhalte den Fehler
no matching function for call to 'Nextion::Nextion(HardwareSerial&, int)'

Ich betreibe dieses Projekt auf 2 unterschiedlichen Rechnern. Das Problem ist , das ein Rechner in Spanien (wo man im Moment leider nicht hinfahren kann) und der andere hier in Deutschland steht. Es ist jeweils die gleiche Arduino Oberfläche und der exakt gleiche Quellcode. Ich vermute deshalb, das es womöglich an der Library liegen kann. Ich habe auch schon die Standard-Library mit allen 7 Betreibssystemständen und den Nextion-Master probiert. Letzterer läuft ansonsten bie auf obigen Fehler gut. Was kann ich tun? Ich bin für jeden Tipp dankbar.
Mit den besten Grüßen und wünschen für die Gesundheit
pds14 Peter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 17:40
Beitrag #2
RE: Problem Arduino Mega und Nextion Touch Display
Das dein Problem an der Library liegt ist ziemlich unwahrscheinlich, es sei denn, du hast eigene Änderungen vorgenommen. Oder anders installiert.

Um da genauer zu helfen, ist es wichtig, deinen Sketch zu kennen.
Den solltest du mindestens hier posten.

Wobei eine Hilfe hier schon sehr selten wird, da kaum einer die von dir eingesetzte Library verwendet.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 17:44
Beitrag #3
RE: Problem Arduino Mega und Nextion Touch Display
Da es mittlerweile mehrere Nextion-Libs geben soll, solltest Du uns einen Link zur Lib geben.
Hier arbeitet kaum einer mit der Lib, deshalb ist da auch nicht viel Erfahrung vorhanden. Ich glaube mich aber schwach zu erinnern, dass dem Konstruktor nur die Schnittstelle mitgegeben wird. Die Geschwindigkeit wird ja an der Schnittstelle eingestellt.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 18:28 (Dieser Beitrag wurde zuletzt bearbeitet: 26.10.2020 18:32 von Klaus Dieter.)
Beitrag #4
RE: Problem Arduino Mega und Nextion Touch Display
Guten Tag,
ich habe ein sehr ähnliches Problem :
no matching function for call to 'Nextion::Nextion(SoftwareSerial&)'
Arduino IDE 1.8.13 ist instaliert, weder mit dem Uno noch dem Nano V3 ist ein kompilieren möglich.
Sämtliche Sketches bei "Nextion" , "NeoNextion" oder auch bei "ITEADLIB_Arduino_Nextion-master"
werden mit einem Fehler beim Kompilieren angezeigt.
Ich hatte sogar die Online Version der IDE versucht, leider ohne Erfolg.
Liegt es eventuell an der Windows Version 7 ??

Sonst laufen alle Sketches, nur beim Nextion geht es nicht.
Ich wollte das "car-sensor-monitoring-alarm-709b9c" (MR2 Arduino code for Nextion display ver2)
aus dem arduino.cc/projecthub zum Laufen bringen, ein sehr schönes Projekt, leider ohne Erfolg.
Ich wäre für eine zielführende Idee sehr dankbar !
Gruß Klaus Dieter
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 18:35 (Dieser Beitrag wurde zuletzt bearbeitet: 26.10.2020 18:36 von hotsystems.)
Beitrag #5
RE: Problem Arduino Mega und Nextion Touch Display
Hallo,
also am Windows liegt es sicher nicht.
Ich habe mein Arduino auch noch auf einem Win7 Rechner und das geht ohne Probleme.

Dennoch solltest du einen eigenen Thread aufmachen, damit sich das nicht vermischt.
Und da deinen Sketch in Code-Tags posten.

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 18:43
Beitrag #6
RE: Problem Arduino Mega und Nextion Touch Display
(26.10.2020 17:40)hotsystems schrieb:  Das dein Problem an der Library liegt ist ziemlich unwahrscheinlich, es sei denn, du hast eigene Änderungen vorgenommen. Oder anders installiert.

Um da genauer zu helfen, ist es wichtig, deinen Sketch zu kennen.
Den solltest du mindestens hier posten.

Wobei eine Hilfe hier schon sehr selten wird, da kaum einer die von dir eingesetzte Library verwendet.

Hier ist nochmal die entscheidende Stelle:
// Display-Vorbereitung ********************************************************************************​*
// Nextion TX
// 15 <----------- TX blau
// 14 -----------> RX gelb

#define nextion Serial3

Nextion myNextion(nextion, 9600); //erzeugen eines Nextion Objekts mit dem Namen myNextion
// bei Benützung des Nextion seriell Ports @ 9600bps
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2020, 20:10
Beitrag #7
RE: Problem Arduino Mega und Nextion Touch Display
(26.10.2020 18:43)pds14 schrieb:  Hier ist nochmal die entscheidende Stelle:
// Display-Vorbereitung ********************************************************************************​*
// Nextion TX
// 15 <----------- TX blau
// 14 -----------> RX gelb

#define nextion Serial3

Nextion myNextion(nextion, 9600); //erzeugen eines Nextion Objekts mit dem Namen myNextion
// bei Benützung des Nextion seriell Ports @ 9600bps

Ok.....und damit sollen wir dein Problem lösen ?
K.A. wie du dir das vorstellst.

Warum beantwortest du nicht die Fragen bzw. lieferst uns das gewünschte ?

Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2020, 09:19
Beitrag #8
RE: Problem Arduino Mega und Nextion Touch Display
Hier ist nun der erste Teile des sketches bis zum Ende von void setup. void loop und die anderen unterprogramme bekomme ich hier wegen der Größe nicht mehr rein. Der Fehler bereich ist hier ab schon ehthalten.
Enutschuldigung, dass ich es nicht gleich am Anfang mitgeschickt habe.
Gruß
pds14 Peter

[code]


// Sketch Arduino I2C Master
// Programm für das sogenannte Großhirn (Arduino Mega2560). Dieses steuert mit Kommandos
// über I2C das Arm-Kleinhirn (Armbewegung, Geräuscherkennung, Objekterkennung)(Mega2560),
// das Fahrzeug-Kleinhirn (Fahrzeugbewegung, Hinderniserkennung, Neigungsausgleich, GPS-Daten
// lesen/schreiben), das I2C-LCD-Display.
// Software entwickelt und teilweise aus Beispielen in den Libraries entnommen und angepasst
// von Peter Dambrowsky in 2016, 2017, 2018, 2019.
//
// Aufbau des Robot:
//
// Master
// Arduino Mega2560 steuert per I2C alle Slaves und das LCD-Display zur Anzeige. Miitels eines
// VoiceRecognitionShields zur Erkennung von Sprachkommandos, eines Display-Shields mit
// Touchscreen-Funktion, welches parallel zur VoiceRecognition fukntioniert, werden die
// Kommandos für die Slaves erzeugt.
// Die Eingaben per Hand oder Sprachkommando werden im LCD-Display angezeigt.
//
// Slave22
// Fahrzeug-Modul Arduino Mega2560 mit einem Shield für die Motorsteuerung
// (zur Steuerung des Antriebs (4 DC-Motoren, vorwärts, rückwärts, rechts, links und
// anhalten)). 1 Ultraschallsensor als Entfernungsmesser nach vorne, libks und rechts (drehbar mittels
// Servo). 1 Infrarot shield zur Entfernungsmessung nach hinten beim rückwärts fahren.
// Rückwärts und Vorwärtskontrolle erledigt das Kleinhirn selbstständig. Alles andere wird vom Großhirn
// (Master), dem Arduino Mega2560, per Kommando über I2C gesteuert
//
// Slave21
// Arm-Kamera-Geräusch-LCD-Modul Arduino Mega2560 mit aufgesetztem Shield mit Uhr und SD-Card und
// darauf einem Shield speziell zur Steuerung von bis zu 16 Servos (wird zur Steuerung von 6 Servos mit
// separater Spannung von 5V des Robotarmes benützt) und einer kleinen Fläche für Applikationen
// (Hier werden die 5V vom Arduino für die Shields abgenommen).
// Gesteuert werden eine Kamera VC0706 für die Bildaufnahme und abspeicherung auf der SD-Card, eine
// JeVois A33 cam zur visuellen Objekterkennung, ein Sprachausgabe-Shield (EMIC), ein
// VoiceRecognitionShield zur Erkennung von Sprachkommandos, ein Display-Shield mit Touchscreen-Finktion,
// welches parallel zur VoiceRecognition fukntioniert.
//
//
// Verbindung I2C zum Arduino_1_Arm_Kamera_Geräusch_Kleinhirn_Slave21 (I2C Slave)
// zur Arm- und Kamera-steuerung
// ---------------------------------------------------------------------------
// SDA <-----------> SDA
// SCL <-----------> SCL
//
// Verbindung I2C zum Arduino_2_Tank_Fahrgestell_Kleinhirn_Slave22 (I2C Slave)
// zur Fahrzeugsteuerung
// ---------------------------------------------------------------------------
// SDA <-----------> SDA
// SCL <-----------> SCL
//
// Verbindung I2C um LCD-Display (Slave 63 / Hex 3F) (I2C Slave)
// ---------------------------------------------------------------------------
// SDA <-----------> SDA
// SCL <-----------> SCL
//
// Verbindung Serial3
// Arduino Mega Nextion Display mit Touchscreen Baudrate 9600
// ---------------------------------------------------------------------------
// 2 <--- 15 <----------- TX blau
// 3 ---> 14 -----------> RX gelb
//
// Verbindung Softserial
// Arduino Mega VoiceRecognitionModule
// ---------------------------------------------------------------------------
// 2 <--- 67 <----------- TX
// 3 ---> 45 -----------> RX
//
// * Verbindung Softserial
// * Arduino Mega EMIC 2 Sprachausgabe-Modul
// ---------------------------------------------------------------------------
// * 2 <--- 68(A14) <----------- Sout
// * 3 ---> 46 -----------> Sin
// ---------------------------------------------------------------------------
//
// * Verbindung
// * Arduino Mega Arduino SD-Card
// ---------------------------------------------------------------------------
// * 4 <----------- CS
// * 52 -----------> SCK
// * 50 -----------> MISO
// * 51 -----------> MOSI
// * 5V -----------> VCC
// * GND -----------> GND
// ---------------------------------------------------------------------------
//
// * Interrupt-Verbindung Master ----> Salves
// * Arduino Mega Master Arduino Mega Slave Pin
// ---------------------------------------------------------------------------
// * 2 <----------------> Slave21 xx
// * 3 <----------------> Slave22 34
// ---------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------
//Nachfolgend erläutern wir die Hauptfunktionen der SD-Bibliothek. Dies ist eine
//Zusammenfassung der auf der offiziellen Arduino-Website bereitgestellten Referenz:
//https://www.arduino.cc/en/Reference/SD
//-----------------------------------------------------------------------------------------
//-------------------------
//SD.begin (cspin)
//Initialisiert die SD-Bibliothek und die Karte. Als Parameter wird der Pin CS angegeben,
//an den das Modul angeschlossen ist. Wenn cspin nicht angegeben ist, wird der Standardwert
//des CS von der Hardware verwendet. Die anderen Pins müssen über Arduino-Hardware mit dem
//SPI verbunden sein.
//-------------------------
//SD.exists (Dateiname)
//Überprüfen Sie, ob die angegebene Datei vorhanden ist. Dateiname ist der Name der Datei
//und / oder des Verzeichnisses auf der SD-Karte. Wenn dies vorhanden ist, gibt die
//Funktion "true" zurück, andernfalls "false".
//-------------------------
//SD.mkdir (Verzeichnis)
//Erstellen Sie das angegebene Verzeichnis. Wenn die Unterverzeichnisse nicht vorhanden
//sind, werden sie ebenfalls erstellt. Beispiel: SD.mkdir ("Arduino / project1 / files"),
//erstellen Sie den Ordner "files". Wenn die Ordner "Arduino" und "project1" nicht
//vorhanden sind, werden sie ebenfalls erstellt. Die Funktion gibt true zurück, wenn die
//Erstellung des Verzeichnisses erfolgreich war, andernfalls wird false zurückgegeben
//-------------------------
//SD.remove (Dateiname)
//Löschen Sie die Datei (Dateiname) von der SD-Karte, das Verzeichnis muss enthalten sein.
//Löschen Sie einfach die Datei, aber nicht das Verzeichnis. Return true kann die Datei
//löschen, andernfalls wird false zurückgegeben.
//-------------------------
//SD.rmdir (dirname)
//Entfernen Sie das Verzeichnis (dirname) von der SD-Karte. Das Verzeichnis muss leer sein.
//Gibt TRUE zurück, wenn das Entfernen des Verzeichnisses erfolgreich war, oder FALSE, wenn
//dies nicht der Fall ist.
//-------------------------
//SD.open (Dateipfad, Modus)
//Öffnen Sie die angegebene Datei und das Verzeichnis sollte enthalten sein, wenn sich die
//Datei in Ordnern befindet. Wenn die Datei nicht vorhanden ist, wird eine Datei mit dem
//angegebenen Namen erstellt, das Verzeichnis kann jedoch nicht erstellt werden, wenn es
//nicht vorhanden ist. Eine Datei kann schreibgeschützt (wenn der Modus FILE_READ ist) oder
//schreibgeschützt (wenn der Modus FILE_WRITE ist) geöffnet werden. Der Standardmodus ist
//FILE_READ, wenn er nicht angegeben ist
//Diese Funktion gibt ein FILE-Objekt zurück, das zuvor als Variable deklariert werden muss. Zum Beispiel:
//
// File myFile;
// myFile = SD.open ("file.txt", FILE_WRITE);
//-------------------------
//Funktionen der File-Klasse:
//-------------------------
//myFile.available ()
//Überprüfen Sie, ob in der Datei verfügbare Bytes zum Lesen vorhanden sind, und geben Sie
//die Anzahl der verfügbaren Bytes zurück
//-------------------------
//file.read ()
//Liest ein Byte der Variablen File (Datei, die zuvor mit SD.open () geöffnet wurde)
//-------------------------
//file.write (Daten)
//Schreiben Sie ein Byte in die Datei, die Datei muss im Lese- und Schreibmodus geöffnet
//sein. Mit file.write (buf, len) können Sie ein Byte-Array (buf) schreiben, aber Sie
//müssen die Größe (len) angeben.
//-------------------------
//file.print (Daten)
//Diese Funktion hat die gleichen Eigenschaften wie eine Serial.print (); Daten können
//eine Variable oder ein Text sein, der als Zeichen gesendet wird. Wenn wir am Ende einen
//Sprung oder eine neue Zeile einfügen möchten, wird file.println (data) verwendet
//-------------------------
//file.size ()
//Gibt die Größe der Datei in Byte zurück
//-------------------------
//file.position ()
//Gibt die aktuelle Position zurück, an der das nächste Byte gelesen oder geschrieben wird.
//-------------------------
//file.seek (pos)
//Wir befinden uns an einer bestimmten Stelle im Archiv. Pos muss eine Zahl zwischen 0 und
//der Größe der Datei in Byte sein
//-------------------------
//file.close ()
//Wir schließen die Datei und gerade werden die Daten auf der SD gespeichert, um unsere
//SD sicher extrahieren zu können.
//


//Alle benötigten Libraries
//-------------------------
#include <SD.h>
#include <HMC5883L.h>
#include <Wire.h>
#include <EMIC2.h>
#include <Nextion.h>
#include <LiquidCrystal_I2C.h>
#include "VoiceRecognitionV3.h"
#include <SoftwareSerial.h>
#include <virtuabotixRTC.h>
#include <IRremote.h>

// CLK -> 6, DAT -> 7, RST -> 8 Verkabelung der Uhr DS1302

int val = 0; // Variable für Nextion

byte error; // I2C endTransmit-Fehler
String HaltUrsache; // Grund, warum das Fahren gestoppt wurde (z.B. KH101)
int HaltCode; // Grund, warum das Fahren gestoppt wurde (z.B. 101)

char Endevariable[16]; // Array für die Wandlung String to CharArray

char empfangeneDaten[23]; // Array für Antwort vom slave
String SlaveDaten; // Variable für das empfangene Kommando

int i; // Zähler für array
int k; // Zähler für array

int Suchen_Flag = 0; // dieses Flag steuert die Such-Routine in void loop
int AblegeWinkel; // Gradzahl-Üebrgabe beim rechts oder links ablegen
int Cam_Flag; // Flag fuer JeVois CAM ein/aus fuer Display

// Arduino Interrupt-Vorbereitung ***********************************************************************
// Slave löst Interrupt beim Master aus, wenn Daten ohne Anorderung geholt werden sollen (fahren vor oder
// rueck anhalten, wenn ein Hindernis erkannt wurde beim Slave22). (Beim Slave21 verschiedenes).
const byte interruptPinSlave21 = 2; // Interrupt Pin für Slave21
const byte interruptPinSlave22 = 3; // Interrupt Pin für Slave22
int DatenHolFlag = 0; // Wird in der Interruptroutine auf 1 gesetzt
String Objekt; // Vom Slave 21 erkanntes Objekt
int xWert; // Vom Slave 21 erkannte Armdrehstellung in Grad
String DatenCode; // Satzart vom Slave 21
String Zustand; // Objekt-Zustands-Definition

// Arduino SD-Card-Vorbereitung *************************************************************************
File myFile;

// Uhr DS1302-Vorbereitung ******************************************************************************
virtuabotixRTC myRTC(6, 7, 8);

// Kompass-Vorbereitung ********************************************************************************​*
HMC5883L Kompass;
String command;
String EErgebnis;
float heading;
float headingDegrees;
// Vorbereitung Kalibrierung
int minX = 0;
int maxX = 0;
int minY = 0;
int maxY = 0;
int offX = 0;
int offY = 0;
String xOffset;
String xxOffset;
String yOffset;
String yyOffset;
String xxVorzeichen = "+";
String yyVorzeichen = "+";
char str[6];
String KalibrierOffset = "EIN";

// InfraRot-Empfänger-Vorbereitung********************************************************************​***
int RECV_PIN = 24;
IRrecv irrecv(RECV_PIN);
decode_results results;

// Hier werden Variable für die Motoren 1 bis 4 definiert************************************************
// In diesen Variablen werdem folgende Werte definiert: 0 = Motor steht, 1 = Motor läuft vorwärts
// 2 = Motor läuft rückwärts
String M1 = "0"; // Variable Motor1
String M2 = "0"; // Variable Motor2
String M3 = "0"; // Variable Motor3
String M4 = "0"; // Variable Motor4

String OK; // richtige Empfangsbestötigung

//Variable für den aktuellen Motorzustand 0 = Motoren stehen, 1 = Motoren laufen ************************
String MotorZustand = "0";

//Variable für die Entfernungsmessung
int ELinks90DistanzAkt= 0; //90 Grad links vom Fahrzeug gemessene Distanz
int ERechts90DistanzAkt = 0; //90 Grad rechts vom Fahrzeug gemessene Distanz
int ERechts60DistanzAkt = 0; //60 Grad rechts vom Fahrzeug gemessene Distanz
int ERechts30DistanzAkt = 0; //30 Grad rechts vom Fahrzeug gemessene Distanz
int ELinks60DistanzAkt = 0; //60 Grad links vom Fahrzeug gemessene Distanz
int ELinks30DistanzAkt = 0; //30 Grad links vom Fahrzeug gemessene Distanz
int EVorausDistanzAkt = 0; // in Fahrtrichtung gemessene Distanz
int ENachHintenDistanzAkt = 0; // nach hinten gemessene Distanz

int EGueltigerWinkel = 0; // Variable fuer Winkel zum Objekt
int EGueltigeDrehrichtung = 0; // Variable fuer Drehrichtung zu 0 Grad

// Allgemeine I2C-Informatinen********************************************************************​*******
// Beim automatischen Scan der LCD Addressenweren folgende Salves gefunden
// I2C slave mit Adresse: 21 0x15 gefunden ! Basisadresse Kleinhirn Salve 21
// I2C slave mit Adresse: 22 0x16 gefunden ! Basisadresse Kleinhirn Salve 22
// I2C slave mit Adresse: 30 0x1E gefunden ! HMC5883L Kompass shield Grosshirn
// I2C slave mit Adresse: 63 0x3F gefunden ! Display 16 x 4 Grosshirn
// I2C slave mit Adresse: 64 0x40 gefunden ! PWM Sensorshield Kleinhirn Slave21
// I2C slave mit Adresse: 104 0x68 gefunden ! Uhr shield Kleinhirn Slave21
// I2C slave mit Adresse: 112 0x70 gefunden ! ??? Kleinhirn Slave21

// Vorbereitung I2C-Display*************************************************************************​*****
// Setzen der LCD Addresse auf hex 0x27 für ein Display mit 2 Zeilen a 16 Zeichen
// Einige Geräte benützen die Addresse 0x3F WIRD HIER BENÜTZT !!!
// Setzen der Pins des I2C-Platine für die Verbindung mit dem Display:
// addr, en,rw,rs,d4,d5,d6,d7,bl,blpol
// Anschluss Display per I2C
// ---------------------------
// SDA <-----------> SDA
// SCL <-----------> SCL
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);// Setzen der LCD I2C Addresse

// VR-Vorbereitung********************************************************************​*******************
// Verbindung
// Arduino Mega VoiceRecognitionModule
// 67 <----------- TX gruen
// 47 -----------> RX gelb war auf 45

VR myVR(67, 47); // 67:RX 47:TX, Pin 2 beim Uno ist Pin 67 beim Mega


uint8_t records[7]; // save record
uint8_t buf[64];

// Sprachkommandos
// Gruppe 1 Basis-Gruppe. Von hier werden die anderen Gruppen aufgerufen. Werden diese mit ENDE
// verlassen, kommt man hierher zurück
#define NICHTS0 (0)
#define SPRACHE (1)
#define EINSARM (2)
#define ZWEIARM (3)
#define AWAGEN (4)
#define BWAGEN (5)
#define SERVICE (6)
// Gruppe 2 AWAGEN
#define ENDE (7)
#define VOR (8)
#define RUECK (9)
#define HALT (10)
#define RECHTS (11)
#define LINKS (12)
#define STATUS (13)
// Gruppe 3 SPRACHE
#define ENDE (14)
#define NAME (15)
#define ENGLISCH (16)
#define SPANISCH (17)
#define DEUTSCH (18)
#define EIN (19)
#define AUS (20)
// Gruppe 4 EINSARM
#define ENDE (21)
#define STOP (22)
#define BASIS (23)
#define BILD (24)
#define START (25)
#define NICHTS26 (26)
#define RUHE (27)
// Gruppe 5 ZWEIARM
#define ENDE (28)
#define GREIFEN (29)
#define ABLINKS (30)
#define ABRECHTS (31)
#define ABVORN (32)
#define SUCHEN (33)
#define GERERK (34)
// Gruppe 6 BWAGEN
#define ENDE (35)
#define VORNMESS (36)
#define HINTMESS (37)
#define NICHTS38 (38)
#define AUSGPS (39)
#define SHOWGPS (40)
#define MEMGPS (41)
// Gruppe 7 SERVICE
#define ENDE (42)
#define KURS (43)
#define KAL (44)
#define AUTOKAL (45)
#define UHR (46)
#define LOGBUCH (47)
#define SLAVETEST (48)

// weitere 4 Gruppen sind moeglich

int Autark_Flag = 0; // 1 = Autarklauf gestartet
int Flag_Autark_Anfang = 0; // 1 = Autark_Anfang_Routine wird durchlaufen
int Flag_RaumEntfernungMessenBewegungEntscheiden = 0; // Abstaende im Raum Messen und ueber weitere
// Bewegung entscheiden

// EMIC2-Vorbereitung********************************************************************​****************
// Erklärungen

// Einige der Texte benuetzen spezielle Steuersymbole fuer den dynamischen Wechsel
// Tonhoehe (/\ - hoeher, \/ - niedriger),
// Sprachgeschwindigkeit (>> - erhoehen, << - erniedrigen),
// Betonung (Hervorheben) (__ - betont das nächste Wort),
// fluestern (## - fluestert das nächste Wort),
// Stimme :-)x, x = 0 bis 8

// Folgende Kommandos koennen benuetzt werden:
// emic.setVoice zum einstellen der Stimme (0 - 8)
// emic.setVolume zum Einstellen der Lautstärke Bereich -48 bis +18
// emic.resetVolume zum Zuruecksetzen der Lautstärke auf 0 dB
// emic.setRate zum Einstellen der Sprechgeschwindigkeit 75 bis 600 Worte/Minute
// emic.resetRate zum Zuruecksetzen der Sprechgeschwindigkeit auf 200 Worte/Minute
// emic.setLanguage zum Einstellen der Sprache (0 (US English), 1 (Castilian Spanish), 2 (Latin Spanish)

// Beim Mega2560 koennen folgende Pins fuer RX benuetzt werden: 10, 11, 12, 13, 14, 15,
// 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68),
// A15 (69)
// Hier nachlesen: http://arduino.cc/en/Reference/SoftwareSerial


#define rx_Pin 68 // Connect SOUT pin of the Emic 2 module to the RX pin (Mega PIN 68)
#define tx_Pin 46 // Connect SIN pin of the Emic 2 module to the TX pin (Mega PIN 46)


// Variable
int Sprach_Flag;
int Sprache;
String SatzEnglisch;
String SatzSpanisch;
String SatzDeutsch;

#include <avr/pgmspace.h>

// Diese strings werden im Flash-RAM gespeichert (nicht im SRAM)
const char Text_Englisch_0[] PROGMEM = "Basic commands loaded. ";
const char Text_Englisch_1[] PROGMEM = "A-Car commands loaded. ";
const char Text_Englisch_2[] PROGMEM = "B-Car commands loaded. ";
const char Text_Englisch_3[] PROGMEM = "Speach commands loaded. ";
const char Text_Englisch_4[] PROGMEM = "Arm one commands loaded. ";
const char Text_Englisch_5[] PROGMEM = "Arm two commands loaded. ";
const char Text_Englisch_6[] PROGMEM = "Service commands loaded. ";
const char Text_Englisch_7[] PROGMEM = "Image created and saved. ";
const char Text_Englisch_8[] PROGMEM = "Object searched. ";
const char Text_Englisch_9[] PROGMEM = "Noise detection. ";
const char Text_Englisch_10[] PROGMEM = "Arm is in basic position. ";
const char Text_Englisch_11[] PROGMEM = "Object matter. ";
const char Text_Englisch_12[] PROGMEM = "Image created and saved. ";
const char Text_Englisch_13[] PROGMEM = "Arm is in rest position. ";
const char Text_Englisch_14[] PROGMEM = "My Name ist Robot. ";
const char Text_Englisch_15[] PROGMEM = "I speak english. ";
const char Text_Englisch_16[] PROGMEM = "drive forward. ";
const char Text_Englisch_17[] PROGMEM = "drive backwards. ";
const char Text_Englisch_18[] PROGMEM = "drive to the right. ";
const char Text_Englisch_19[] PROGMEM = "drive to the left. ";
const char Text_Englisch_20[] PROGMEM = "Stop. ";
const char Text_Englisch_21[] PROGMEM = "Object discarded. ";
const char Text_Englisch_22[] PROGMEM = "No Face detected. ";
const char Text_Englisch_23[] PROGMEM = "Face detected. ";
const char Text_Englisch_24[] PROGMEM = "I do not know you. ";
const char Text_Englisch_25[] PROGMEM = "please tell me your first name. ";
const char Text_Englisch_26[] PROGMEM = "How are you. ";
const char Text_Englisch_27[] PROGMEM = "wow wow wow wow wow wow. ";
const char Text_Englisch_28[] PROGMEM = "Maastr ready. ";
const char Text_Englisch_29[] PROGMEM = "Aircraft detected. ";
const char Text_Englisch_30[] PROGMEM = "Bicycle detected. ";
const char Text_Englisch_31[] PROGMEM = "Bird recognized. ";
const char Text_Englisch_32[] PROGMEM = "Boat detected. ";
const char Text_Englisch_33[] PROGMEM = "Bottle detected. ";
const char Text_Englisch_34[] PROGMEM = "Bus detected. ";
const char Text_Englisch_35[] PROGMEM = "Car detected. ";
const char Text_Englisch_36[] PROGMEM = "Cat recognized. ";
const char Text_Englisch_37[] PROGMEM = "Chair recognized. ";
const char Text_Englisch_38[] PROGMEM = "Cow recognized. ";
const char Text_Englisch_39[] PROGMEM = "Dining table recognized. ";
const char Text_Englisch_40[] PROGMEM = "Dog recognized. ";
const char Text_Englisch_41[] PROGMEM = "Horse recognized. ";
const char Text_Englisch_42[] PROGMEM = "Motorcycle detected. ";
const char Text_Englisch_43[] PROGMEM = "Person recognized. ";
const char Text_Englisch_44[] PROGMEM = "Pot plant recognized. ";
const char Text_Englisch_45[] PROGMEM = "Sheep detected. ";
const char Text_Englisch_46[] PROGMEM = "Sofa recognized. ";
const char Text_Englisch_47[] PROGMEM = "Train detected. ";
const char Text_Englisch_48[] PROGMEM = "Screen detected. ";
const char Text_Englisch_49[] PROGMEM = "No Object detected. ";

const char Text_Spanisch_0[] PROGMEM = "Comandos basicos, cargados. ";
const char Text_Spanisch_1[] PROGMEM = "Comandos del A-coche, cargados. ";
const char Text_Spanisch_2[] PROGMEM = "Comandos del Be-coche, cargados. ";
const char Text_Spanisch_3[] PROGMEM = "Comandos de voz, cargados. ";
const char Text_Spanisch_4[] PROGMEM = "Comandos del brazo uno, cargados. ";
const char Text_Spanisch_5[] PROGMEM = "Comandos del brazo dos, cargados. ";
const char Text_Spanisch_6[] PROGMEM = "Comandos del Servicio, cargados. ";
const char Text_Spanisch_7[] PROGMEM = "Imagen creado y guardado. ";
const char Text_Spanisch_8[] PROGMEM = "objeto buscado. ";
const char Text_Spanisch_9[] PROGMEM = "detección de ruido. ";
const char Text_Spanisch_10[] PROGMEM = "Brazo esta en la posi-cion de la base. ";
const char Text_Spanisch_11[] PROGMEM = "Objeto que, se ag__arra. ";
const char Text_Spanisch_12[] PROGMEM = "Imagen creado y guardado. ";
const char Text_Spanisch_13[] PROGMEM = "Brazo esta en la posi-cion de rep__oso. ";
const char Text_Spanisch_14[] PROGMEM = "Me llamo Robot. ";
const char Text_Spanisch_15[] PROGMEM = "Hablo espaniol. ";
const char Text_Spanisch_16[] PROGMEM = "avanzar. ";
const char Text_Spanisch_17[] PROGMEM = "martcha atr__as. ";
const char Text_Spanisch_18[] PROGMEM = "gire a la derecha. ";
const char Text_Spanisch_19[] PROGMEM = "gire a la izquierda. ";
const char Text_Spanisch_20[] PROGMEM = "detener. ";
const char Text_Spanisch_21[] PROGMEM = "objeto depositado. ";
const char Text_Spanisch_22[] PROGMEM = "ninguna cara detectada. ";
const char Text_Spanisch_23[] PROGMEM = "cara detectada. ";
const char Text_Spanisch_24[] PROGMEM = "No te conozco. ";
const char Text_Spanisch_25[] PROGMEM = "Por favor dime tu nombre. ";
const char Text_Spanisch_26[] PROGMEM = "como estas. ";
const char Text_Spanisch_27[] PROGMEM = "vau vau vau vau vau vau. ";
const char Text_Spanisch_28[] PROGMEM = "Maastr listo. ";
const char Text_Spanisch_29[] PROGMEM = "Avion detectado. ";
const char Text_Spanisch_30[] PROGMEM = "Bicicleta detectada. ";
const char Text_Spanisch_31[] PROGMEM = "Pájaro detectado. ";
const char Text_Spanisch_32[] PROGMEM = "Barco detectado. ";
const char Text_Spanisch_33[] PROGMEM = "Botella detectada. ";
const char Text_Spanisch_34[] PROGMEM = "Bus detectado. ";
const char Text_Spanisch_35[] PROGMEM = "Coche detectado. ";
const char Text_Spanisch_36[] PROGMEM = "Gato detectado. ";
const char Text_Spanisch_37[] PROGMEM = "Sillón detectado. ";
const char Text_Spanisch_38[] PROGMEM = "Vaca detectado. ";
const char Text_Spanisch_39[] PROGMEM = "Mesa de comedor detectada. ";
const char Text_Spanisch_40[] PROGMEM = "Perro detectado. ";
const char Text_Spanisch_41[] PROGMEM = "Caballo detectado. ";
const char Text_Spanisch_42[] PROGMEM = "Motocicleta detectada. ";
const char Text_Spanisch_43[] PROGMEM = "Persona detectada. ";
const char Text_Spanisch_44[] PROGMEM = "Planta de maceta detectada. ";
const char Text_Spanisch_45[] PROGMEM = "Oveja detectada. ";
const char Text_Spanisch_46[] PROGMEM = "Sofá detectada. ";
const char Text_Spanisch_47[] PROGMEM = "Tren detectado. ";
const char Text_Spanisch_48[] PROGMEM = "Pantalla detectada. ";
const char Text_Spanisch_49[] PROGMEM = "ninguna objeto detectado. ";

const char Text_Deutsch_0[] PROGMEM = "Basis-Kommandos, keladen. ";
const char Text_Deutsch_1[] PROGMEM = "A-Waagen-Kommandos, keladen. ";
const char Text_Deutsch_2[] PROGMEM = "Be-Waagen-Kommandos, keladen. ";
const char Text_Deutsch_3[] PROGMEM = "Sprach-Kommandos, keladen. ";
const char Text_Deutsch_4[] PROGMEM = "Arm-Ains-Kommandos, keladen. ";
const char Text_Deutsch_5[] PROGMEM = "Arm-Zwai-Kommandos, keladen. ";
const char Text_Deutsch_6[] PROGMEM = "Service-Kommandos, keladen. ";
const char Text_Deutsch_7[] PROGMEM = "Bild erstelt und kespaichert. ";
const char Text_Deutsch_8[] PROGMEM = "Gegenstand kesucht. ";
const char Text_Deutsch_9[] PROGMEM = "Keroysch Erkennung. ";
const char Text_Deutsch_10[] PROGMEM = "Arm ist in Grund-Stelung. ";
const char Text_Deutsch_11[] PROGMEM = "Gegenstand kegriffen. ";
const char Text_Deutsch_12[] PROGMEM = "Bild erstelt und kespaichert. ";
const char Text_Deutsch_13[] PROGMEM = "Arm ist in Rue-Stelung. ";
const char Text_Deutsch_14[] PROGMEM = "Main Name ist Robot. ";
const char Text_Deutsch_15[] PROGMEM = "Ij, spreje, doytsch. ";
const char Text_Deutsch_16[] PROGMEM = "naj vorne faahren. ";
const char Text_Deutsch_17[] PROGMEM = "haj hinten faahren. ";
const char Text_Deutsch_18[] PROGMEM = "haj rejts faahren. ";
const char Text_Deutsch_19[] PROGMEM = "haj links faahren. ";
const char Text_Deutsch_20[] PROGMEM = "Anhalten. ";
const char Text_Deutsch_21[] PROGMEM = "Gegenstand abkelegt. ";
const char Text_Deutsch_22[] PROGMEM = "Kain Kesicht erkanndt. ";
const char Text_Deutsch_23[] PROGMEM = "Kesicht erkanndt. ";
const char Text_Deutsch_24[] PROGMEM = "Ij kenne dij nijt. ";
const char Text_Deutsch_25[] PROGMEM = "Bitte sake, mir, dainen, Fornamen. ";
const char Text_Deutsch_26[] PROGMEM = "Wi keht, es, dir. ";
const char Text_Deutsch_27[] PROGMEM = "vau vau vau vau vau vau. ";
const char Text_Deutsch_28[] PROGMEM = "Maastr berait. ";
const char Text_Deutsch_29[] PROGMEM = "Flugzeuk erkanndt. ";
const char Text_Deutsch_30[] PROGMEM = "Fahrrad erkanndt. ";
const char Text_Deutsch_31[] PROGMEM = "Vogel erkanndt. ";
const char Text_Deutsch_32[] PROGMEM = "Boht erkanndt. ";
const char Text_Deutsch_33[] PROGMEM = "Flasche erkanndt. ";
const char Text_Deutsch_34[] PROGMEM = "Bouss erkanndt. ";
const char Text_Deutsch_35[] PROGMEM = "Auto erkanndt. ";
const char Text_Deutsch_36[] PROGMEM = "Katse erkanndt. ";
const char Text_Deutsch_37[] PROGMEM = "Sessel erkanndt. ";
const char Text_Deutsch_38[] PROGMEM = "Kou erkanndt. ";
const char Text_Deutsch_39[] PROGMEM = "Estisch erkanndt. ";
const char Text_Deutsch_40[] PROGMEM = "Hunt erkanndt. ";
const char Text_Deutsch_41[] PROGMEM = "Pferd erkanndt. ";
const char Text_Deutsch_42[] PROGMEM = "Motorrad erkanndt. ";
const char Text_Deutsch_43[] PROGMEM = "Person erkanndt. ";
const char Text_Deutsch_44[] PROGMEM = "Topfpflanze erkanndt. ";
const char Text_Deutsch_45[] PROGMEM = "Schaaf erkanndt. ";
const char Text_Deutsch_46[] PROGMEM = "Sofa erkanndt. ";
const char Text_Deutsch_47[] PROGMEM = "Zuk erkanndt. ";
const char Text_Deutsch_48[] PROGMEM = "Bildchirm erkanndt. ";
const char Text_Deutsch_49[] PROGMEM = "Kain Objekt erkanndt. ";

const char* const Englisch_string_table[] PROGMEM = {Text_Englisch_0, Text_Englisch_1, Text_Englisch_2,
Text_Englisch_3, Text_Englisch_4, Text_Englisch_5,
Text_Englisch_6, Text_Englisch_7, Text_Englisch_8,
Text_Englisch_9, Text_Englisch_10, Text_Englisch_11,
Text_Englisch_12, Text_Englisch_13, Text_Englisch_14,
Text_Englisch_15, Text_Englisch_16, Text_Englisch_17,
Text_Englisch_18, Text_Englisch_19, Text_Englisch_20,
Text_Englisch_21, Text_Englisch_22, Text_Englisch_23,
Text_Englisch_24, Text_Englisch_25, Text_Englisch_26,
Text_Englisch_27, Text_Englisch_28, Text_Englisch_29,
Text_Englisch_30, Text_Englisch_31, Text_Englisch_32,
Text_Englisch_33, Text_Englisch_34, Text_Englisch_35,
Text_Englisch_36, Text_Englisch_37, Text_Englisch_38,
Text_Englisch_39, Text_Englisch_40, Text_Englisch_41,
Text_Englisch_42, Text_Englisch_43, Text_Englisch_44,
Text_Englisch_45, Text_Englisch_46, Text_Englisch_47,
Text_Englisch_48, Text_Englisch_49
};

const char* const Spanisch_string_table[] PROGMEM = {Text_Spanisch_0, Text_Spanisch_1, Text_Spanisch_2,
Text_Spanisch_3, Text_Spanisch_4, Text_Spanisch_5,
Text_Spanisch_6, Text_Spanisch_7, Text_Spanisch_8,
Text_Spanisch_9, Text_Spanisch_10, Text_Spanisch_11,
Text_Spanisch_12, Text_Spanisch_13, Text_Spanisch_14,
Text_Spanisch_15, Text_Spanisch_16, Text_Spanisch_17,
Text_Spanisch_18, Text_Spanisch_19, Text_Spanisch_20,
Text_Spanisch_21, Text_Spanisch_22, Text_Spanisch_23,
Text_Spanisch_24, Text_Spanisch_25, Text_Spanisch_26,
Text_Spanisch_27, Text_Spanisch_28, Text_Spanisch_29,
Text_Spanisch_30, Text_Spanisch_31, Text_Spanisch_32,
Text_Spanisch_33, Text_Spanisch_34, Text_Spanisch_35,
Text_Spanisch_36, Text_Spanisch_37, Text_Spanisch_38,
Text_Spanisch_39, Text_Spanisch_40, Text_Spanisch_41,
Text_Spanisch_42, Text_Spanisch_43, Text_Spanisch_44,
Text_Spanisch_45, Text_Spanisch_46, Text_Spanisch_47,
Text_Spanisch_48, Text_Spanisch_49
};

const char* const Deutsch_string_table[] PROGMEM = {Text_Deutsch_0, Text_Deutsch_1, Text_Deutsch_2,
Text_Deutsch_3, Text_Deutsch_4, Text_Deutsch_5,
Text_Deutsch_6, Text_Deutsch_7, Text_Deutsch_8,
Text_Deutsch_9, Text_Deutsch_10, Text_Deutsch_11,
Text_Deutsch_12, Text_Deutsch_13, Text_Deutsch_14,
Text_Deutsch_15, Text_Deutsch_16, Text_Deutsch_17,
Text_Deutsch_18, Text_Deutsch_19, Text_Deutsch_20,
Text_Deutsch_21, Text_Deutsch_22, Text_Deutsch_23,
Text_Deutsch_24, Text_Deutsch_25, Text_Deutsch_26,
Text_Deutsch_27, Text_Deutsch_28, Text_Deutsch_29,
Text_Deutsch_30, Text_Deutsch_31, Text_Deutsch_32,
Text_Deutsch_33, Text_Deutsch_34, Text_Deutsch_35,
Text_Deutsch_36, Text_Deutsch_37, Text_Deutsch_38,
Text_Deutsch_39, Text_Deutsch_40, Text_Deutsch_41,
Text_Deutsch_42, Text_Deutsch_43, Text_Deutsch_44,
Text_Deutsch_45, Text_Deutsch_46, Text_Deutsch_47,
Text_Deutsch_48, Text_Deutsch_49
};

String NameBekannt;
char buffer[50]; // buffer muss grösser sein als der längste vorhandene String
int tabNum; // Wert zwischen 0 und 49 je nach Textstandort

EMIC2 emic; // Erzeugt eine Instanz der EMIC2 library

// Display/Touchscreen-Vorbereitung *********************************************************************
// 15 RX <----------- TX blau
// 14 TX -----------> RX gelb

//SoftwareSerial nextion(14, 15);
#define nextion Serial3
//#define nextion (14, 15)
Nextion myNextion(nextion, 9600); // erzeugen eines Nextion Objekts mit dem Namen myNextion
// bei Benützung des Nextion seriell Ports @ 9600bps

// Variable für automatische Winkelberechnung zum Hindernis plus Drehrichtung****************************
int DrehWinkel = 0;
String DrehRichtung = " ";

// Vorbereitung Kommunikation mit Kleinhirn (Arduino Mega), hier Rueckantwort vom Kleinhirn lesen********
//#define SERIAL_RX_BUFFER_SIZE 64
//#define SERIAL_TX_BUFFER_SIZE 64

String antwortKleinhirn;
String datenVomKleinhirn;
boolean stringComplete = false;
String inputString = ""; // String für die empfangenen Daten

String command010 = "<010N000000083->\n"; //Fahrzeug nach vorne anhalten
String command011 = "<011N000000083->\n"; //Fahrzeug nach vorne anfahren
String command012 = "<012N000000083->\n"; //Fahrzeug nach vorne anfahren (1cm bis 250cm)
String command020 = "<020N000000083->\n"; //Fahrzeug nach hinten anhalten
String command021 = "<021N000000083->\n"; //Fahrzeug nach hinten anfahren
String command022 = "<022N000000083->\n"; //Fahrzeug nach hinten anfahren (1cm bis 250cm)
String command030 = "<030N000000083->\n"; //Arm in Basisstellung
String command031 = "<031N000000083->\n"; //Arm in Ruhestellung
String command032 = "<032N000000083->\n"; //Arm Objekt suchen
String command033 = "<033N000000083->\n"; //Arm Objekt vorne greifen
String command034 = "<034N000000083->\n"; //Arm Objekt links ablegen
String command035 = "<035N000000083->\n"; //Arm Objekt rechts ablegen
String command036 = "<036N000000083->\n"; //Arm Objekt vorne ablegen
String command040 = "<040N000000083->\n"; //Bild Einzelbild speichern
String command041 = "<041N000000083->\n"; //Bild Bewegungsmeldung
String command042 = "<042N000000000->\n"; //Geräusch orten
String command050 = "<050N000000083->\n"; //Fahrzeug nach links anhalten
String command051 = "<051N000000083->\n"; //Fahrzeug nach links anfahren
String command052 = "<052N000000083->\n"; //Fahrzeug nach links anfahren (1Grad bis 180Grad)
String command060 = "<060N000000083->\n"; //Fahrzeug rechts anhalten
String command061 = "<061N000000083->\n"; //Fahrzeug nach rechts anfahren
String command062 = "<062N000000083->\n"; //Fahrzeug nach rechts anfahren (1Grad bis 180Grad)
String command070 = "<070N000000083->\n"; //Fahrzeug Variable für Zeit,Laenge und Winkel loeschen
String command080 = "<080N000000000->\n"; //Fahrzeug GPS_Flag im Kleinhirn auf 0 setzen
String command081 = "<081N000000000->\n"; //Fahrzeug GPS_Flag im Kleinhirn auf 1 setzen
String command082 = "<082N000000000->\n"; //Fahrzeug GPS_Flag im Kleinhirn auf 2 setzen
String command090 = "<090N000000000->\n"; //Fahrzeug Statusabfrage
String command091 = "<091N000000000->\n"; //Fahrzeug Hindernisabfrage links 90 Grad, rechts 90 Grad
String command092 = "<092N000000000->\n"; //Fahrzeug Winkel zum Hindernis und Drehrichtung abfragen
String command094 = "<094N000000000->\n"; //Fahrzeug Hindernisabfrage links 90 Grad, links 60 Grad,
//links 30 Grad, nach vorne, rechts 30 Grad, rechts 60 Grad
//und rechts 90 Grad
String command095 = "<095N000000000->\n"; //Fahrzeug Hindernisabfrage hinten

String lastCommand = "00"; // Variable zum Merken des letzten Kommandos

int NachHintenDistanzAkt = 0; // in Fahrtrichtung nach hinten gemessene Distanz

int DiffLinks; // für Berechnung der Hindernisentfernung nach links
int DiffRechts; // für Berechnung der Hindernisentfernung nach rechts

int zwischenSumme; // Zwischenvariable für die Umstellung der Entfernungen
String Ergebnis; // Zwischenvariable für die Umstellung der Entfernungen

byte PC_Eingabe = 0; // Steuerung über Serial-Data vom PC

String buttonName = " ";

// Allgemeine Serielle Ausgabe einstellen (Monitor) *****************************************************
// Wenn 1, dann alle Serial.print und println ausgeben.
// Bei 0 wird nichts an den PC gesendet
int AnzeigeFlag = 1;

//********************************************************************************​***********************
//***********Beginn der Hauptschleife void setup()*******************************************************
//********************************************************************************​***********************
void setup() {
Serial.begin(115200); // Verbindung zum Monitor einstellen

// Einstellung der Uhr DS1302**************************************************************************​
// Um Datum und Uhrzeit einzustellen, muss das folgende Format verwendet werden:
// Sekunden, Minuten, Stunden, Wochentag, Tag, Monat und Jahr

//myRTC.setDS1302Time(00, 19, 10, 3, 25, 9, 2019); // SS, MM, HH, DW, DD, MM, YYYY

// Nach dem Einstellen der Zeit muss die obige Zeile kommentiert werden, damit
// ie eingestellten Werte nicht mehr verändert werden.

Serial.println("Die Datums- und Uhrzeiteinstellung wurde angepasst");

// Diese Funktion aktualisiert die Variablen, um aktuelle Ergebnisse zu erhalten
myRTC.updateTime ();
// Das Ergebnis wird auf dem seriellen Monitor gedruckt Serial.print("Datum und Uhrzeit aktuell: ");
Serial.print(myRTC.dayofmonth); // Sie kann zwischen Tag und Monat geändert werden, wenn das
// amerikanische System verwendet wird
Serial.print("/");
Serial.print(myRTC.month);
Serial.print("/");
Serial.print(myRTC.year);
Serial.print(" ");
Serial.print(myRTC.hours);
Serial.print(":");
Serial.print(myRTC.minutes);
Serial.print(":");
Serial.println(myRTC.seconds);

// SD-Card-Vorbereitung *******************************************************************************
Serial.println(F("Initialisierung der SD-Card"));
if (!SD.begin(4)) {
Serial.println(F("Keine initialisierung moeglich. Bitte folgendes pruefen:"));
Serial.println(F("* Ist eine SD-Card vorgesteckt?"));
Serial.println(F("* Ist die Verdrahtung richtig?"));
Serial.println(F("* Ist der PIN fuer CS wegen Pruefung des Shield oder Modules geaendert?"));
//return;
} else {
Serial.println(F("Initialisierung erfolgreich"));
Serial.println(F("Verdrahtung in Ordnung und Karte vorhanden."));
}

Serial.println(F(" "));
Serial.println(F("Root der SD-Card auflisten"));
File root = (SD.open("/"));
printDirectory(root, 0);
Serial.println(F("Alle Dateien in der Root aufgelistet"));
Serial.println(F(" "));

if (SD.exists("Logbuch.dat")) {
Serial.println("Logbuch.dat existiert.");
}else{
myFile = SD.open("Logbuch.dat", FILE_WRITE); // Datei erstellem
myFile.close(); // und sofort wieder schließen
}

LogbuchAnzeigen();

// Vorbereitung den I2C-Bus****************************************************************************
Wire.begin(); // einstellen des i2c bus
// (Adresse optional als Master)

// InfraRot-Empfänger-Vorbereitung********************************************************************​*
pinMode(RECV_PIN, INPUT);
irrecv.enableIRIn(); // Startet den InfraRot-Empfänger
Serial.println(F("Infrarot-Empfänger vorbereitet."));

// Vorbereitung für die LCD-Anzeige********************************************************************
lcd.begin(16,4); // Anzeige für 4 Zeilen mit je 16 Zeichen initialisieren
// Hintergrundbeleuchung eingeschaltet

// Hinweis: Cursor Position: (Zeichen, Zeile) beginnt bei 0
lcd.backlight(); // Hintergrundbeleuchtung ein ?
lcd.setCursor(0,0); // Cursor setzen ganz links 0 in Zeile 0
lcd.print("Robot--Grosshirn");
lcd.setCursor(0,1); // Cursor setzen ganz links 0 in Zeile 1
lcd.print(">--I2C-Master--<");
lcd.setCursor(0,2); // Cursor setzen ganz links 0 in Zeile 2
lcd.print("----------------");
lcd.setCursor(0,3); // Cursor setzen ganz links 0 in Zeile 3
lcd.print(" betriebsbereit ");
Serial.println(F("LCD-Anzeige vorbereitet."));
delay(1000);
/*
// EMIC2-Vorbereitung********************************************************************​**************
// Initialisierung der EMIC2 Instanz
// Die Library setzt den SoftwareSerial Port
// fuer die Kommunikation mit dem Emic 2 Modul
Serial.println(F("Beginn EMIC2 Vorbereitung."));
emic.begin(rx_Pin, tx_Pin);
Serial.println(F("emic.begin"));
delay(100);
emic.setVoice(4); // Setzt die Stimme (9 Stimmen: 0 - 8)
Serial.println(F("emic.setVoice"));
delay(100);
emic.setVolume(18); // Lautstärke auf laut stellen
Serial.println(F("emic.setVolume"));
delay(100);
emic.setRate(180); // Sprachgeschwindigkeit langsamer stellen
Serial.println(F("emic.setRate"));
delay(100);

Sprache = 3; // Sprache setzen (0 = keine,1 = Englisch, 2 = Spanisch, 3 = Deutsch)
Text_Sprechen_Routine(28); // Texttabelle Nr. 28
Sprache = 0; // Sprache wieder abschalten
Serial.println(F("Sprachausgabe EMIC2 vorbereitet."));
*/
// Display/Touchscreen-Vorbereitung********************************************************************​**
myNextion.init(); // die Initialierungs-Kommandos für Page 0 senden

myNextion.setComponentText("t0", "<-ROBOT->"); // Text ins Display Feld t0 laden
myNextion.setComponentText("t1", " "); // Text ins Display Feld t1 laden
myNextion.setComponentText("t2", "- Gruppe -"); // Text ins Display Feld t1 laden
myNextion.setComponentText("b0", " "); // Text ins Display Feld b0 laden
myNextion.setComponentText("b1", " "); // Text ins Display Feld b1 laden
myNextion.setComponentText("b2", " "); // Text ins Display Feld b2 laden
myNextion.setComponentText("b3", " "); // Text ins Display Feld b3 laden
myNextion.setComponentText("b4", " "); // Text ins Display Feld b4 laden
myNextion.setComponentText("b5", " "); // Text ins Display Feld b5 laden
myNextion.setComponentText("b6", " "); // Text ins Display Feld b6 laden

myNextion.sendCommand("n0.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n1.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n2.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n3.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n4.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n5.val=0"); // Number-Feld wird gesetzt
myNextion.sendCommand("n6.val=0"); // Number-Feld wird gesetzt

Serial.println(F("Display/Touchscreen vorbereitet."));

// Voice Recognition ********************************************************************************​**
myVR.begin(9600);
//Gespeicherte Kommandos im Voice Recognizer loeschen
if (myVR.clear() == 0) {
Serial.println(F("Spracherkennungsmodul bereit."));
} else {
Serial.println(myVR.clear());
Serial.println(F("Sprachmodul nicht vorhanden."));
Serial.println(F("Verbindung pruefen und Arduino erneut starten."));
//while (1); //???????????????
}
// Jetzt die ersten 7 Kommandos der Basis-Gruppe laden.
// Später wird mit den Kommandos AWAGEN , BWAGEN, SPRACHE, EINSARM, ZWEIARM und SERVICE
// zu den 6 Kommandogruppen umgeschaltet.

myNextion.setComponentText("t2", "- Haupt-Gruppe -"); // Text ins Display Feld t1 laden

/* if (myVR.load((uint8_t)FREI) >= 0) {
//Serial.println("FREI geladen");
} */
myNextion.setComponentText("b0", "n.b."); // Text ins Display Feld b0 laden
myNextion.sendCommand("n0.val=0"); // Number-Feld wird gesetzt


if (myVR.load((uint8_t)SPRACHE) >= 0) {
Serial.println("SPRACHE geladen");
myNextion.setComponentText("b1", "SPRACHE"); // Text ins Display Feld b1 laden
myNextion.sendCommand("n1.val=1"); // Number-Feld wird gesetzt
}

if (myVR.load((uint8_t)EINSARM) >= 0) {
Serial.println("EINSARM geladen");
myNextion.setComponentText("b2", "EINSARM"); // Text ins Display Feld b2 laden
myNextion.sendCommand("n2.val=2"); // Number-Feld wird gesetzt
}

if (myVR.load((uint8_t)ZWEIARM) >= 0) {
//Serial.println("ZWEIARM geladen");
myNextion.setComponentText("b3", "ZWEIARM"); // Text ins Display Feld b3 laden
myNextion.sendCommand("n3.val=3"); // Number-Feld wird gesetzt
}

if (myVR.load((uint8_t)AWAGEN) >= 0){
//Serial.println("AWAGEN geladen");
myNextion.setComponentText("b4", "AWAGEN"); // Text ins Display Feld b4 laden
myNextion.sendCommand("n4.val=4"); // Number-Feld wird gesetzt
}

if (myVR.load((uint8_t)BWAGEN) >= 0){
//Serial.println("BWAGEN geladen");
myNextion.setComponentText("b5", "BWAGEN"); // Text ins Display Feld b5 laden
myNextion.sendCommand("n5.val=5"); // Number-Feld wird gesetzt
}

if (myVR.load((uint8_t)SERVICE) >= 0){
//Serial.println("SERVICE geladen");
myNextion.setComponentText("b6", "SERVICE"); // Text ins Display Feld b6 laden
myNextion.sendCommand("n6.val=6"); // Number-Feld wird gesetzt
}

// Kompass-Einstellungen ******************************************************************************
// Initialisierung HMC5883L
Serial.println(F("Initialisierung HMC5883L"));
while (!Kompass.begin())
{
Serial.println(F("HMC5883L nicht gefunden, überprüfen Sie die Verbindung!"));
delay(500);
}

if (AnzeigeFlag == 1) {
Serial.println(F("Messungsbereich setzen"));
}
// Messungsbereich setzen
Kompass.setRange(HMC5883L_RANGE_1_3GA);

if (AnzeigeFlag == 1) {
Serial.println(F("Messungsmode setzen"));
}
// Messungsmode setzen
Kompass.setMeasurementMode(HMC5883L_CONTINOUS);

if (AnzeigeFlag == 1) {
Serial.println(F("Datenrate setzen"));
}
// Datenrate setzen
Kompass.setDataRate(HMC5883L_DATARATE_30HZ);

if (AnzeigeFlag == 1) {
Serial.println(F("Anzahl der gemittelten Beispiele festlegen"));
}
// Anzahl der gemittelten Beispiele festlegen
Kompass.setSamples(HMC5883L_SAMPLES_8);

if (AnzeigeFlag == 1) {
Serial.println(F("Kalibrierversatz einstellen"));
}
// Kalibrierversatz einstellen. Siehe HMC5883L_calibration.ino
//Kompass.setOffset(0, 0); //ohne Kalibrierversatz (X, Y)
Kompass.setOffset(+202, -514); //mit Kalibrierversatz laut Kalibrier-Sketch (X, Y)


delay(2000); // 2 weitere Sekunden anzeigen
lcd.clear(); // Display löschen
lcd.noBacklight(); // Hintergrundbeleuchtung ausschalten

// Vorbereitung Interrupt Slave --> Master ************************************************************
Serial.println(F("Interrupts vorbereitet"));
// LOW Interrupt startet, wann immer der Interrupt Pin auf low ist,
// CHANGE Interrupt startet, wann immer der Interrupt Pin seinen Wert ändert (high > low oder umgekehrt),
// RISING Interrupt startet, wenn der Interrupt Pin auf low auf high geht,
// FALLING Interrupt startet, wenn der Interrupt Pin auf high auf low geht.
pinMode(interruptPinSlave21, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(interruptPinSlave21), Interrupt_Routine_21, FALLING);
// Wird nur dort gestartet, wo es benötigt wird.
pinMode(interruptPinSlave22, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(interruptPinSlave22), Interrupt_Routine_22, FALLING);
// Wird nur dort gestartet, wo es benötigt wird.

}
//********************************************************************************​***********************
//***********Ende der Hauptschleife void setup()*********************************************************
//********************************************************************************​***********************
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Problem mit "pow" awillib 9 383 27.02.2021 19:22
Letzter Beitrag: Tommy56
  Pwm Problem safitom 4 289 20.02.2021 12:14
Letzter Beitrag: safitom
  Touch Button am TFT mit Libary „MCUFRIEND_kbv“ Heiko67 2 195 18.02.2021 21:56
Letzter Beitrag: Tommy56
  3,5" TFT-Touch mit microSD am MEGA Heiko67 9 513 17.02.2021 20:45
Letzter Beitrag: Heiko67
  SH1107 Oled Display und Multiplexer Feuchtigkeitssteuerung Kanka 35 1.658 06.02.2021 22:38
Letzter Beitrag: Kanka
  Problem mit "Keyboard" und "Mouse" LK2567 4 287 03.02.2021 16:11
Letzter Beitrag: MicroBahner
  const char zu int Konvertierung Problem Lumplux 1 209 02.02.2021 10:26
Letzter Beitrag: Lumplux
  Arduino Uno+ Ethernetshield W5100 Website Problem Justus S. 9 518 31.01.2021 17:37
Letzter Beitrag: Tommy56
Sad MAX7221 mit gemeinsamer Anode und Problem Dezimalpunkt daja64 11 528 30.01.2021 11:07
Letzter Beitrag: daja64
  Werte im Display per Taster wechseln bmxruler 8 490 27.01.2021 11:22
Letzter Beitrag: bmxruler

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste