Arduino & HC-05: Serial menyn guiden (6 / 6 steg)

Steg 6: kod:

Nedan är Arduino koden (du kan också hämta själva filen)

Var uppmärksam på den intensiva sträng användningen i detta program. Jag möter många problem eftersom om detta, och jag kunde matcha par av dem med följande kommentarer:

• Använd funktionen "String.reserve()" före reservera dynamisk minne för string-förekomst, detta gör bättre hantering på minne uppdrag i högen. Men det är fortfarande inte tillräckligt så det inte kan garantera något.
• Användning av 'F()' makrot: som tillåter lagring av strängar i flash-minnet i stället för RAM. Det fungerar bara med statiska strängar inom print/println verksamhet. Detta är mycket användbart men inte tillräckligt (inte hjälper med dynamiska strängar)
• minska antalet reserverade strängar: fråga inte att hitta upp till 10 enheter om detta inte är riktigt vad du vill,. 3 kan till exempel vara nog.

Problemet att programmet kommer att utföra och ladda upp i alla fall, men det kommer att fungera på oväntat sätt, svarar på olika frågor än det du skrev, och visar inte några strängar och saker sådär.

Ett sätt att lösa det är att använda char matriser (eller char *) i stället för strängar. Detta är mitt nästa steg men nu har jag inte tid att göra det ;)

/*
* AT_AT_mode.ino - en guide för HC-05 bluetooth-moduler
* Copyright (c) 2016 Rami Baddour. Alla rättigheter reserverade.
* http://ramibaddour.com/ https://ch.linkedin.com/in/ramibaddour
*
* Ett program för att visa, ange, ändra och använda HC-05 bluetooth med en interaktiv textural menyer
* över seriell monitore
*
* Du kan inkludera delar av koden som gör specifika funktioner (t.ex. sökning efter enheter)
* till dina egna program
*
* Observera att denna kod använder intensivt klassen String, som har vissa oförutsägbara beteende
* När virtuellt minne inte är möjligt att researve. DEN är testad för att fungera perfekt när begränsar
* antal inspelade sökte enheter till 3. över detta kan ha vissa problem med flytta strängar.
*
* Nyare version kommer att använda char matriser istället, förhoppningsvis med bättre stabilitet.
*
*
*/
#include
SoftwareSerial mySerial (5, 4); / / RX, TX var HC-05 är ansluten
#define pinRe 3 / / Återställ PIN-koden, ansluten till HC-05 stift nr 11
#define pinEn 6 / / aktivera pin, ansluten till HC-05 stift nr 34
#define INQ1 1 / / fråga om Acces läge: 0-standard 1-RSSI(default)
#define INQ2 100 / / maximalt antal enheter svar: 0-till-32000
#define INQ3 30 / / fråga om timeout: 1-till-48 SEK
#define MAXDEV 1 / / maximalt antal enheter för att spela in.
#define PAIRTO "25" / / ihopkoppling timout i sekunder
#define MAXSTRLEN 50 / / maximala buffert researved för string-variabler.
#define ATSTART "#start" / / token sträng för att starta vid kommandoindata
#define ATEND "#end" / / token sträng för att sluta på kommando eller operativa meny ingång
#define ovanpå "#op" / / token sträng till börja menyn åtgärd.
kolumnbredder i teckenantal för listan discovred BT enheter'
#define colW1 6
#define colW2 45
#define colW3 20
#define colW4 7
int8_t sin = -1; Den nuvarande ingången, registrerar val av användare och används inom programmet tillståndsdator
int8_t currSt = -1; det aktuella läget, definierar aktuell status i fråga om menyval
int8_t deviceCount = 0; Återställ PIN-koden, ansluten till HC-05 stift nr 13
int devCount = 0; Hur många enheter totalt har upptäckts i den senaste undersökningen som enheten
int devLoc = 0; platsen för den valda enheten i listan över upptäckta enheter.
Sträng serialStr, tmpName, tmpRes; några string variabler ska användas senare
definiera en datastruktur för varje descovered enhet. Det innehåller grundläggande information som namn, adress, RRSI och Service klass
TypeDef struct inqDevices {
String namn;
Sträng adress;
Sträng RSSI;
Klassen String;
inqDevices (int defSize = MAXSTRLEN) {
Name.Reserve(defSize);
Namn = "";
Address.Reserve(20);
Adress = "";
RSSI.reserve(20);
RSSI = "";
Class.Reserve(40);
Class = "";
}
} inqDevice;
inqDevice lstDevices [MAXDEV];

Denna funktion tar en sträng av någon längd "biltillverkar" och utgångar en samma sträng men med fast längd "strLen"
vilket är en delsträng om den ingående length(strIn) > strLen, är samma som "biltillverkar" med de återstående tecknen
fylld med "strFillChar" karaktär.
om "strFill" är satt till true, ingång strängen läggs till i slutet av strängen resultatet.
Sträng strFixed (String stringenta, int strLen, boolean strFill = false, String strFillChar = "") {
String tmpStr1 = strIn.substring(0,strLen);
int tmpLen = tmpStr1.length();
för (int jag = 0; jag < (strLen - tmpLen), i ++)
tmpStr1 = tmpStr1 + strFillChar;
om (strFill)
tmpStr1 = tmpStr1 + biltillverkar;
Return (tmpStr1);
}
En funktion för att radera innehållet i enhetslistan array strängarna.
void clearDeviceList() {
för (int jag = 0; jag

Använda inställningen "discardOK" om du vill att funktionen ska ignorera 'OK' resultatet på AT-kommandot RETUR.
Använd "charsToCutFrom" och "charsToCutTo" om du vill få endast en delsträng av AT-kommandot avkastning. t.ex. om du vill ignorera
den "+ INQ:" inledande del i svaret på kommandot "AT + INQ" och få direkt adress och signal information om enhetens descovered.
Sträng getFromMySerial (String strToWrite = "", bool discardOK = true, int charsToCutFrom = 0, int charsToCutTo = 150) {
om (strToWrite! = "")
{
mySerial.println(strToWrite);
Delay(50); Dessa förseningar kan inte vara nödvändigt, bara för att rymma långsamt reagerande HC-05 moduler.
}

String tmpStr = (mySerial.readStringUntil('\n'));
tmpStr.trim();
Delay(50);

om (discardOK)
mySerial.readStringUntil('\n');
återgå tmpStr.substring (charsToCutFrom, charsToCutTo);
}
Den här funktionen liknar den tidigare "getFromMySerial". Men här används när svaret
är inte garanterad efter en fast fördröjning. t.ex. om du väntar att få remote BT enhetsadress eller namn i
Discovery-processen. Det används också om du inte förväntar dig ett returvärde alls.
Sträng getFromMySerialSimple (String strToWrite = "", int charsToCutFrom = 0, int charsToCutTo = 150) {
om (strToWrite! = "")
{
mySerial.println(strToWrite);
Delay(100);
gå tillbaka "";
}
annat
{
medan (! mySerial.available()){delay(10);}
String tmpStr = (mySerial.readStringUntil('\n'));
återgå tmpStr.substring (charsToCutFrom, charsToCutTo);
}
}

void setup() {
Serial.BEGIN(57600);
mySerial.begin(38400); standard HC-05 överföringshastigheten på AT-läge
Serial.Print (F ("att gå in på läge vänligen typ" "));
Serial.Print(ATSTART);
Serial.Print (F ("", att det finns typ "));
Serial.Print(ATEND);
Serial.Print (F (", eller typ" "));
Serial.Print(ATOP);
Serial.println F ("för menyn").
pinMode (pinRe, produktionen);
pinMode (pinEn, produktionen);
serialStr = "";
serialStr.reserve(MAXSTRLEN);
tmpName.reserve(MAXSTRLEN);
tmpRes.reserve(MAXSTRLEN);
}

void loop() {
om (Serial.available()) {
serialStr = (Serial.readStringUntil('\n'));
serialStr.trim();
In på läge, du anger EN pin till hög, och generera en 100ms negativa puls på Återställ PIN-koden
om (serialStr.equalsIgnoreCase(ATSTART)) {
Serial.println(F(ATSTART));
Serial.println (F ("du är nu på läge, ange AT-kommandon:"));
Sin = -1;
currSt = -5;
digitalWrite(pinEn,HIGH); Aktivera PIN-koden (nr.34) inställd på hög och hålla den under AT-kommandot
digitalWrite(pinRe,LOW); Återställ PIN-koden (no.11) inställd på låg, detta skjuter upp modulen i förberedelse för att återställa
Delay(100); En kort fördröjning (bör vara mer som 10 ms) att simulera en negativ puls på Återställ PIN-koden
digitalWrite(pinRe,HIGH); Inställd på Återställ PIN-koden tillbaka hög och med aktivera pin hög, startar om modulen i kommandot AT läge.
serialStr = "";
}
Spännande på läge in data överföringsläge, du anger EN pin till låg och generera en 100ms negativa puls på Återställ PIN-koden
annat if (serialStr.equalsIgnoreCase(ATEND)) {
Sin = -1;
currSt = -1;
Serial.println(F(ATEND));
Serial.println F ("du har slutat på mode.").
digitalWrite(pinEn,LOW); Aktivera PIN-koden (nr.34) inställd på låg och hålla den under sändningsteknik data
digitalWrite(pinRe,LOW); Återställ PIN-koden (no.11) inställd på låg, detta skjuter upp modulen i förberedelse för att återställa
Delay(100); En kort fördröjning (bör vara mer som 10 ms) att simulera en negativ puls på Återställ PIN-koden
digitalWrite(pinRe,HIGH); Inställd på Återställ PIN-koden tillbaka hög och med aktivera pin låg, modulen startar om i Data överföringsläge.
}
För att komma till läget för operativa menyn, gör du samma som inleder på läge, men med det statlig variablle påstår till 0 så du aktivera menyn tillståndsdator
annat if (serialStr.equalsIgnoreCase(ATOP)) {
Sin = 0;
currSt = 0;
Serial.println(F(ATOP));
digitalWrite(pinEn,HIGH);
digitalWrite(pinRe,LOW);
Delay(100);
digitalWrite(pinRe,HIGH);
}
Efter några andra indata är detta i grunden ett urval av ett objekt i menyn, eller ett kommando i på-läge.
annat {
Serial.println(serialStr);
Sin = serialStr.toInt(); några icke-numeriska indata resultat i "0"
}
Detta är när vi starta AT läge, skickas alla ingångar till bluetooth-modulen.
om (currSt == -5) {
mySerial.println(serialStr);
}
}
Vid svar eller input från bluetooth-modulen själv
om (mySerial.available()) {
samtidigt (mySerial.available()) {
tmpName = (mySerial.readStringUntil('\n'));
tmpName.trim();
Serial.println(tmpName);
Delay(50);
}

}
om (sin > = 0) {/ / ange tillståndsdatorn bara om vi får en giltiga indata
växel (currSt) {/ / menyn Visa urval
fall 0: {/ / detta är huvudmenyn
Switch (sin) {/ / baserat på användaren ingång, väljer motsvarande operationen och därför nästa tillstånd
fall 0:
Serial.println(F("----------------------------------------------------------"));
Serial.println (F ("Vänligen välj en av följande verksamheter:"));
Serial.println (F ("1-Display modulinställningarna"));
Serial.println (F ("2 - ändra aktuella inställningar"));
Serial.println F ("3-återställning till ursprungliga inställningar").
Serial.println F ("4-ledar-bara operationer").
Serial.println F ("5-").
Serial.Print F ("(alternativet No.)").
Sin = -1; Vi inställd på -1 att undvika ingå statliga maskin på obestämd tid.
bryta;
fall 1:
currSt = 1;
bryta;
fall 2:
currSt = 2;
Sin = 0;
bryta;
fall 3:
currSt = 3;
bryta;
fall 4:
currSt = 4;
Sin = 0;
bryta;
standard:
Serial.println (F ("inte en giltig ingång, vänligen välj från listan"));
currSt = 0;
Sin = 0;
}
bryta;
}
fall 1: {/ / Visa den modul viktigaste inställningar. för varje, skicka kommandot och vänta på resultatet och Visa den
Serial.println(F("----------------------------------------------------------"));
Serial.println (F ("de aktuella modulinställningarna för är:"));
Serial.Print (F ("- namn:"));
Serial.println (getFromMySerial ("AT + namn", sant, 6));
Serial.Print (F ("--baudvärde:"));
Serial.println (getFromMySerial ("AT + UART", sant, 6));
Serial.Print (F ("--roll:"));
om (getFromMySerial ("AT + roll", sant, 6) == "1")
Serial.println(F("Master"));
annat
Serial.println(F("Slave"));
Serial.Print (F ("--Conn läge:"));
tmpRes = getFromMySerial ("AT + CMODE", sant, 6);
om (tmpRes == "0")
Serial.println F ("enda anslutning").
annat if (tmpRes == "1")
Serial.println F ("någon anslutning").
annat
Serial.println F ("Test mode").
Serial.Print (F ("--Passowrd:"));
Serial.println (getFromMySerial ("AT + PSWD", sant, 6));
currSt = 0;
Sin = 0;
bryta;
}
fall 2: {/ / menyn för att ändra inställningarna för BT modul
Växla (sin) {
fall 0:
Serial.println(F("----------------------------------------------------------"));
Serial.println (F ("Vänligen välj en av följande verksamheter:"));
Serial.println (F ("1 - ändra modulnamnet"));
Serial.println (F ("2 - ändra UART inställningar"));
Serial.println (F ("3 - ändra hopkoppling kod/PW"));
Serial.println F ("4-Switch roll (Master/Slave)").
Serial.println F ("5-ändra anslutningsläge").
Serial.println F ("6-Back...").
Serial.Print F ("(alternativet No.)").
Sin = -1;
bryta;
fall 1:
currSt = 21;
Sin = 0;
bryta;
fall 2:
currSt = 22.
Sin = 0;
bryta;
fall 3:
currSt = 23.
Sin = 0;
bryta;
fall 4:
currSt = 24.
Sin = 0;
bryta;
fall 5:
currSt = 25;
Sin = 0;
bryta;
fall 6:
currSt = 0;
Sin = 0;
bryta;
standard:
Serial.println (F ("inte en giltig ingång, vänligen välj från listan"));
currSt = 2; bo i samma meny om du fel ingång
Sin = 0;
bryta;
}
bryta;
}
i mål 21: {/ / ändra modulens namn
Serial.println(F("----------------------------------------------------------"));
Serial.Print (F ("curent Modulnamn:"));
Serial.println (getFromMySerial ("AT + namn", sant, 6));
Serial.println (F ("Ange ett nytt namn, eller lämna tomt för att hålla den aktuella inställningen."));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
Serial.println (F ("namn lämnas oförändrad"));
annat {
tmpName = "AT + namn =" + tmpName;
tmpRes = getFromMySerial (tmpName, true);
om (tmpRes == "OK")
Serial.println F ("namnändring framgångsrika").
annat
Serial.println F ("Faild att ändra namnet, kontrollera namn och försök igen").
}
currSt = 2;
Sin = 0;
bryta;
}
fall 22: {/ / Ändra portinställningarna seriell UART (Baudrate, stoppbit och paritetsbitar)
Serial.println(F("----------------------------------------------------------"));
Serial.Print (F ("curent UART (baudvärde) inställningarna är:"));
tmpName = getFromMySerial ("AT + UART", sant, 6);
String tmpBR = tmpName.substring(0,tmpName.indexOf(',')); Baud-hastighet
String tmpSB = tmpName.substring(tmpName.indexOf(',')+1,tmpName.indexOf(',')+2); / / Stop bitars
String tmpPB = tmpName.substring(tmpName.indexOf(',')+3,tmpName.indexOf(',')+4); / / paritet bitars

Serial.println(tmpName);
Serial.println (F ("Välj nya baudvärde, eller lämna det tomt för att hålla oförändrade. Möjliga alternativ: "));
Serial.println(F("(1) 4800 (2) 9600 (3) 19200 (4) 38400 (5) 57600"));
Serial.println(F("(6) 115200 (7) 234000 (8) 460800 (9) 921600 (10) 1382400"));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
{
Serial.Print (F ("baudvärde lämnas oförändrad:"));
Serial.println(tmpBR);
}
annat
{
int tmpInt = tmpName.toInt(); Baudvärde
om ((tmpInt > 0) & &(tmpInt < 11))
Serial.Print (F ("baudvärde channged framgångsrikt, den nya baudvärde är:"));
växel (tmpInt) {
fall 1: 2 i mål: mål 3: fall 4:
tmpBR = sträng (2400 * pow(2,tmpInt),0);
Serial.println(tmpBR);
bryta;
fall 5: 6 i mål: mål 7: fall 8: fall 9:
tmpBR = sträng (1800 * pow(2,tmpInt),0);
Serial.println(tmpBR);
bryta;
mål 10:
tmpBR = "1382400";
Serial.println(tmpBR);
bryta;
standard:
Serial.println (F ("felaktigt baudvärde för ingång, är lämnas oförändrade"));
}
}
Serial.println(); Stoppbitar
Serial.println (F ("Välj antalet stoppbitar, eller lämna det tomt för att hålla oförändrade. Möjliga alternativ: "));
Serial.println(F("(a) 0:1 bit (b) 1:2 bitar"));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
{
Serial.Print (F ("Stop bitars nummer lämnas oförändrad:"));
Serial.println(tmpSB);
}
annars om ((tmpName == "a") || (tmpName == "A"))
{
tmpSB = "0";
Serial.Print (F ("Stop bitarstal är channged framgångsrikt är den nya inställningen:"));
Serial.println(tmpSB);
}
annars om ((tmpName == "b") || (tmpName == "B"))
{
tmpSB = "1";
Serial.Print (F ("Stop bitarstal är channged framgångsrikt är den nya inställningen:"));
Serial.println(tmpSB);
}
annat
Serial.println (F ("fel ingång, Stop bitars nummer lämnas oförändrad"));
Serial.println(); Paritetsbitar
Serial.println (F ("Välj paritetsbitar inställning, eller lämna det tomt för att hålla oförändrade. Möjliga alternativ: "));
Serial.println(F("(1) ingen paritet (2) udda paritet (3) jämn paritet"));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
int tmpInt = tmpName.toInt();
om (tmpName == "")
{
Serial.Print (F ("paritetsbitar inställningen lämnas oförändrad:"));
Serial.println(tmpPB);
}
annars om ((tmpInt >0) & &(tmpInt <4))
{
tmpPB = tmpName;
Serial.Print (F ("paritetsbitar inställning är channged framgångsrikt är den nya inställningen:"));
Serial.println(tmpPB);
}
annat
Serial.println F ("fel ingång, paritetsbitar inställningen lämnas oförändrad").
tmpName = "AT + UART =" + tmpBR + "," + tmpSB + "," + tmpPB; Kommandot inställningar overal UART
String tmpRes = getFromMySerial (tmpName, true);
om (tmpRes == "OK")
Serial.println F ("UART inställningar ändra framgångsrika").
annat
Serial.println F ("Faild vill ändra de UART, försök igen").
currSt = 2;
Sin = 0;
bryta;
}
i mål 23: {/ / ändra lösenordet (Pairing kod)
Serial.println(F("----------------------------------------------------------"));
Serial.Print (F ("curent parbildningskod är:"));
Serial.println (getFromMySerial ("AT + PSWD", sant, 6));
Serial.println (F ("Ange en ny hopkoppling nyckel eller lämna tomt för att hålla aktuell kod."));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
Serial.println (F ("ihopkoppling nyckel är lämnas oförändrade"));
annat
{
tmpName = "AT + PSWD =" + tmpName;
String tmpRes = getFromMySerial (tmpName, true);
om (tmpRes == "OK")
Serial.println F ("Pairing nyckel ändra framgångsrika").
annat
Serial.println F ("Faild ändra Pairing nyckeln, vänligen kontrollera koden och försök igen").
}
currSt = 2;
Sin = 0;
bryta;
}
fall 24: {/ / modifiera roll (Master/Slave/slav-loop)
Serial.println(F("----------------------------------------------------------"));
Serial.Print (F ("inställningen curent roll är:"));
tmpName = getFromMySerial ("AT + roll", sant, 6);
tmpName.trim();
Serial.Print(tmpName);
om (tmpName == "0")
Serial.println F ("[slav]").
annat if (tmpName == "1")
Serial.println F ("[Master]").
annat if (tmpName == "2")
Serial.println F ("[slav-loop]").

Serial.println (F ("Välj en ny roll, eller lämna det tomt för att hålla oförändrade. Möjliga alternativ: "));
Serial.println(F("(0) 0:Slave (1) 1:Master (2) 2:Slave-loop"));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
{
Serial.Print (F ("roll lämnas oförändrad:"));
}
annat
{
int tmpInt = tmpName.toInt();
växel (tmpInt)
{
fall 0: mål 1: 2 i mål:
tmpName = "AT + roll =" + tmpName;
tmpRes = getFromMySerial (tmpName, true);
om (tmpRes == "OK")
Serial.println F ("rollen ändra framgångsrika").
annat
Serial.println F ("Faild att byta roll, försök igen").
bryta;
standard:
Serial.println (F ("felaktig input, roll är lämnas oförändrade"));
bryta;
}

}
currSt = 2;
Sin = 0;
bryta;
}
fall 25: {/ / ändra anslutningsläge
Serial.println(F("----------------------------------------------------------"));
Serial.Print (F ("aktuell anslutningstyp är:"));
tmpName = getFromMySerial ("AT + CMODE", sant, 6);
tmpName.trim();
Serial.Print(tmpName);
om (tmpName == "0")
Serial.println F ("[enda anslutning]").
annat if (tmpName == "1")
Serial.println F ("[någon anslutning]").
annat if (tmpName == "2")
Serial.println F ("[Test mode]").
Serial.println (F ("Välj en ny anslutningsläge, eller lämna det tomt för att hålla oförändrade. Möjliga alternativ: "));
Serial.println(F("(0) 0:Single anslutning (1) 1: någon anslutning (2) 2:Test läge"));
tag (!. Serial.available());
tmpName = (Serial.readStringUntil('\n'));
tmpName.trim();
om (tmpName == "")
{
Serial.Print (F ("anslutning läge lämnas oförändrad:"));
}
annat
{
int tmpInt = tmpName.toInt();
växel (tmpInt)
{
fall 0: mål 1: 2 i mål:
tmpName = "AT + CMODE =" + tmpName;
tmpRes = getFromMySerial (tmpName, true);
om (tmpRes == "OK")
Serial.println F ("anslutning lägesändring framgångsrika").
annat
Serial.println F ("Faild att ändra anslutningsläge, försök igen").
bryta;
standard:
Serial.println (F ("felaktig, anslutning ingångsläge är lämnas oförändrade"));
bryta;
}
}
currSt = 2;
Sin = 0;
bryta;
}
fall 3: {/ / Reset modul till de ursprungliga inställningarna
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("modulinställningarna återställs till original").
getFromMySerial ("AT + ORGL", falsk, 6);
Serial.Print (F ("- namn:"));
Serial.println (getFromMySerial ("AT + namn", sant, 6));
Serial.Print (F ("--baudvärde:"));
Serial.println (getFromMySerial ("AT + UART", sant, 6));
Serial.Print (F ("--roll:"));
om (getFromMySerial ("AT + roll", sant, 6) == "1")
Serial.println(F("Master"));
annat
Serial.println(F("Slave"));
Serial.Print (F ("--Passowrd:"));
Serial.println (getFromMySerial ("AT + PSWD", sant, 6));
currSt = 0;
Sin = 0;
bryta;
}
fall 4: {/ / menyn att utföra befälhavaren modul operationer.
om (getFromMySerial ("AT + roll", sant, 6)! = "1") {/ / kolla om rollen modul = 1 vilket betyder att modulen är master.
Serial.println F ("modulen bör i Master roll att utföra dessa operationer, vänligen ändra rollen.").
currSt = 2;
Sin = 0;
}
annat {
Växla (sin) {
fall 0:
Serial.println(F("----------------------------------------------------------"));
Serial.println (F ("Vänligen välj en av följande verksamheter:"));
Serial.println (F ("1 - Upptäck i närheten enheter"));
Serial.println F ("2-par med en enhet").
Serial.println (F ("3 - ansluta till en enhet"));
Serial.println F ("4-ta bort enheter från ihopkoppling lista").
Serial.println F ("5-röra med en enhet").
Serial.println F ("6-Back...").
Serial.Print F ("(alternativet No.)").
Sin = -1;
bryta;
fall 1:
currSt = 41; Sin = 0; bryta;
fall 2:
currSt = 42. Sin = 0; bryta;
fall 3:
currSt = 43; Sin = 0; bryta;
fall 4:
currSt = 44. Sin = 0; bryta;
fall 5:
currSt = 45; Sin = 0; bryta;
fall 6:
currSt = 0; Sin = 0; bryta;
standard:
Serial.println (F ("inte en giltig ingång, vänligen välj från listan"));
currSt = 4; Sin = 0; bryta;
}
}
bryta;
}
i mål 41: {/ / fråga om närliggande enheter (adresser + namn)
Serial.println(F("----------------------------------------------------------"));
Serial.println (F ("lista enheter i närheten:"));
getFromMySerial ("AT + INIT", true); Ignorera resultatet, det kan resultera i fel om SPP profilen är redan öppnat
tmpName = sträng ("AT + INQM =" + String(INQ1) + "," + String(INQ2) + "," + String(INQ3));
tmpRes = getFromMySerial (tmpName, true);
om (tmpRes! = "OK")
Serial.println F ("fråga läge ställa misslyckade").
annat
{
getFromMySerialSimple("AT+INQ"); Som flera enheter kan upptäckas, bara köra kommandot sedan vänta på följetong för varje ny rad tills "OK" tas emot
clearDeviceList();
tmpName = getFromMySerialSimple ("", 5); Vi har åtminstone, på resultat även om inga enheter upptäcktes, som är "OK" produktionen i slutet av processen fråga
medan ((tmpName! = "")) / / "OK" är mindre än 5 tecken, kommer att leda till tom sträng när OK tas emot.
{
int ind1st = tmpName.indexOf(','); index för första kommatecknet
int ind2nd = tmpName.indexOf (",", ind1st + 1); index för andra kommat
String devAddr = tmpName.substring(0,ind1st); Enhetens adress
String devClas = tmpName.substring(ind1st+1,ind2nd); Enhetens tjänsteklassen
String devRSSI = tmpName.substring(ind2nd+1); Enhetens RSSI
devLoc = searchDeviceList(devAddr); Kontrollera om enhetens adress är redan upptäckt, som i de flesta fall den samma deie kan upptäcka flera gånger med olika RSSI och/eller olika tjänsteklasser
om ((devLoc < 0) & & devCount < MAXDEV) / / en ny enhet, inte finns i listan, men det är fortfarande tom plats i listan (inte överstiger det maximala antalet lagrade enheter)
{
lstDevices [devCount]. Adress = devAddr; vi lagrar nya enhetsdata
lstDevices [devCount]. Class = devClas;
lstDevices [devCount]. RSSI = devRSSI;
devCount ++;
}
Delay(10);
tmpName = getFromMySerialSimple ("", 5); få nästa indata från MySerial (dvs. BT enhet)
}
Serial.println (strFixed ("+", colW1 + colW2 + colW3 + colW4 + 3, sant,"-")); Rita en tabell med resultat
Serial.println ("|" + strFixed("Ind.",colW1) + strFixed ("BT enhetens namn:", colW2) + strFixed ("BT enhetsadress", colW3) + strFixed("Paired",colW4) + "|");
Serial.println ("|"+ strFixed("---",colW1) + strFixed("---",colW2) + strFixed("---",colW3) + strFixed("---",colW4) +"|");
för (int jag = 0; jag devCount) {/ / om en numeriska indata överskrider antalet lagrade/upptäckt enheter
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("valda indexet är ut of bounds, Välj i listan över tillgängliga enheter").
Serial.Print F ("(alternativet No.)").
Sin = -3; bo i samma meny, tills en korrekt index anges eller "q" för exitting till föregående meny
}
annat {
devLoc = sin - 1. indexet börjar med 0
tmpName = lstDevices [devLoc]. Adress;
tmpName.replace(":",",");
tmpName = sträng ("AT + par ="+ tmpName +"," + PAIRTO);
tmpRes = getFromMySerialSimple(tmpName);
tmpRes = getFromMySerialSimple(""); Vi gör detta eftersom parkopplingen kan ta längre tid, så vi inte kan lita på timeout i readstringuntil()
tmpRes.trim();
om (tmpRes == "OK")
{
Serial.println (("Du är ihopkopplade med enheten" + lstDevices [devLoc]. Namn + "[" + lstDevices [devLoc]. Adress + "]"));
}
annat
{
Serial.println (tmpName);
Serial.println (tmpRes);
Serial.println (F ("kunde inte koppla ihop med enheten, försök igen eller Initiation en annan sökning efter enheter"));
}
currSt = 4;
Sin = 0;
}
bryta;
}
fall 43: {/ / Anslut med en av de upptäckta enheterna
om (sin == 0) {
om (serialStr.equalsIgnoreCase("q")) {/ / "q" till ganska till föregående meny
currSt = 4;
Sin = 0;
}
annat {
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("Välj enhetsindex som du vill ansluta till, q att avbryta").
Serial.Print F ("(alternativet No.)").
Sin = -3;
}
}
annars om (sin > devCount) {/ / om en numeriska indata överskrider antalet lagrade/upptäckt enheter
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("valda indexet är ut of bounds, Välj i listan över tillgängliga enheter").
Serial.Print F ("(alternativet No.)").
Sin = -3;
}
annat {
devLoc = sin - 1. indexet börjar med 0
tmpName = lstDevices [devLoc]. Adress;
tmpName.replace(":",",");
tmpName = sträng ("AT + LINK =" + tmpName);
tmpRes = getFromMySerialSimple(tmpName);
tmpRes = getFromMySerialSimple(""); Vi gör detta som förbinder/ansluta processen kan ta längre tid, så vi inte kan lita på timeout i readstringuntil()
tmpRes.trim();
om (tmpRes == "OK") {
Serial.println (("Du är nu ansluten till enheten" + lstDevices [devLoc]. Namn + "[" + lstDevices [devLoc]. Adress + "], typ #end koppla och återställa."));
currSt = 6;
Sin = 0;
}
annat {
Serial.println (tmpName);
Serial.println (tmpRes);
Serial.println (F ("kunde inte ansluta med enheten, försök igen eller Initiation en annan sökning efter enheter"));
}
currSt = 4;
Sin = 0;
}
bryta;
serialStr = "";
}
fall 44: {
om (sin == 0)
{
om (serialStr.equalsIgnoreCase("q"))
{
currSt = 4;
Sin = 0;
}
annars om (serialStr.equalsIgnoreCase("a"))
{
tmpRes = getFromMySerial(String("AT+ADCN"), sant, 6);
tmpRes.trim();
int tmpCount = tmpRes.toInt();
för (int jag = 0; jag devCount)
{
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("valda indexet är ut of bounds, Välj i listan över tillgängliga enheter").
Serial.Print F ("(alternativet No.)").
Sin = -4;
}
annat
{
devLoc = sin - 1.
tmpName = lstDevices [devLoc]. Adress;
tmpName.replace(":",",");

tmpRes = getFromMySerial(String("AT+FSAD=") + tmpName, true);
tmpRes.trim();
om (tmpRes == "OK")
{
tmpRes = getFromMySerial(String("AT+RMSAD=") + tmpName, true);
tmpRes.trim();
om (tmpRes == "OK")
{
Serial.println (("Enheten" + lstDevices [devLoc]. Namn + "[" + lstDevices [devLoc]. Adress + "] tas bort från listan med ihopkopplade enheter"));
}
}
annat
{
Serial.println F ("enheten inte är i listan Parade enheter.").
}
Sin = 0;
}

bryta;
}
mål 45: {
om (sin == 0)
{
om (serialStr.equalsIgnoreCase("q"))
{
currSt = 4;
Sin = 0;
}
annat
{
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("Välj enhetsindex som du vill binda med, q att avbryta").
Serial.Print F ("(alternativet No.)").
Sin = -3;
}
}
annars om (sin > devCount)
{
Serial.println(F("----------------------------------------------------------"));
Serial.println F ("valda indexet är ut of bounds, Välj i listan över tillgängliga enheter").
Serial.Print F ("(alternativet No.)").
Sin = -3;
}
annat
{
devLoc = sin - 1.
tmpName = lstDevices [devLoc]. Adress;
tmpName.replace(":",",");

tmpName = sträng ("AT + binda =" + tmpName);
tmpRes = getFromMySerialSimple(tmpName);
tmpRes = getFromMySerialSimple("");
tmpRes.trim();
om (tmpRes == "OK")
{
Serial.println (("Du är nu garanterad leverans med enheten" + lstDevices [devLoc]. Namn + "[" + lstDevices [devLoc]. Adress + "], typ #end koppla och återställa."));
}
annat
{
Serial.println (F ("kunde inte binda med enheten, försök igen eller Initiation en annan sökning efter enheter"));
}
currSt = 4;
Sin = 0;
}
bryta;
}
mål 6: {
för (int jag = 0; jag < serialStr.length(); i ++)
mySerial.write(serialStr[i]);
bryta;
}
}
}
serialStr = "";
}