La mia prima libreria per Arduino.
La libreria ATCommand_1.0 .
Libreria per collegare diversi moduli, con funzionalità UART (SIM800L, HC-12, ...), interagendo con essi tramite comandi AT. L'interazione con i moduli avviene tramite l'interfaccia UART (Serial). Per un lavoro completo con i moduli, avrai bisogno di un riferimento di comando AT ufficiale, che puoi trovare nelle istruzioni per lavorare con i moduli.
Considera la libreria ATCommnd_1.0:
File ATCommand.h
#pragma once //indica al compilatore che il file specificato deve essere incluso solo una volta.
#include <Arduino.h> //per utilizzare le funzioni di Arduino nel codice.
#define ATC_RX_PIN 10 //costante - indicare il pin RX.
#define ATC_RX_PIN 10 //costante - indicare il pin RX.
#define ATC_TX_PIN 11 //costante - indicare il pin TX.
#define ATC_RESET_PIN 9 //costante - indicare il pin reset.
#define ATC_SPEED 9600 //costante - la velocità di scambio dati con il modulo.
#define ATC_TIMEOUT 10000 //costante - il periodo di timeout.
class Command //nome della classe.
class Command //nome della classe.
{
public:
//dichiarazione di funzione.
void begin(); //per la velocità di scambio dati con il modulo.
void resetModule(); //per resettare il modulo.
.
String sendCommand(String command, bool waiting); //per invio di un comando AT.
String waitResponse(); //per l'attesa di una risposta e restituzione del risultato.
bool sentModule(); //per attendere se il modulo ha inviato qualcosa
.
void sendModule(); //per ricevere i comandi via Serial e inviare il comando ricevuto al modulo.
private:
String _response; //variabile per memorizzare la risposta.
String _waiting; // variabile per la memorizzazione delle risposte dal modulo.
uint32_t _timeout; //variabile per il timeout.
bool _flag; //variabile se il modulo ha inviato qualcosa.
};
extern Command ATCommand; //creare oggetto all'interno della libreria.
extern Command ATCommand; //creare oggetto all'interno della libreria.
File ATCommand.cpp
#include <ATCommand.h> // include i file di intestazione.
#include <SoftwareSerial.h> //libreria per implementazione software di scambio tramite protocollo UART.
SoftwareSerial Module(ATC_RX_PIN, ATC_TX_PIN); /*creare un oggetto per SoftwareSerial e dichiarare i pin RX e TX.*/
void Command::begin() //Funzione per la velocità di comunicazione del modulo.
{
Module.begin(ATC_SPEED); //impostazione della velocità.
}
void Command::resetModule() //Funzione per resettare il modulo.
{
digitalWrite(ATC_RESET_PIN, HIGH);
delay(500);
digitalWrite(ATC_RESET_PIN, LOW);
delay(500);
digitalWrite(ATC_RESET_PIN, HIGH);
delay(1000);
}
String Command::sendCommand(String command, bool waiting) //Funzione per invio di un comando AT.
{
_response = ""; // inizializzazione della variabile _response.
Serial.println(command); // duplica il comando sul monitor.
Module.println(command); // invia comando al modulo.
if (waiting) // se devi aspettare una risposta...
{
_response = waitResponse(); // ... attendi l'invio della risposta.
if (_response.startsWith(command)) // rimuove il comando duplicato dalla risposta.
{
_response = _response.substring(_response.indexOf("\r", command.length()) + 2);
}
Serial.println(_response); //duplica la risposta sul monitor..
}
return _response; // restituisce il risultato.
}
String Command::waitResponse() // funzione per attendere una risposta e restituire il risultato.
{
_timeout = 0; //inizializzazione della variabile _timeout.
_waiting = ""; //inizializzazione della variabile _waiting.
_timeout = millis() + ATC_TIMEOUT; //tempo di attesa (10 secondi).
while (!Module.available() && millis() < _timeout) {}; /*stiamo aspettando una risposta per 10 secondi, se c'è una risposta o un timeout, allora...*/
if (Module.available()) //...se c'è qualcosa da leggere...
{
_waiting = Module.readString(); //... leggi e memorizza.
}
else //se c'è un timeout, allora...
{
Serial.println("Timeout..."); //...segnalalo e...
}
return _waiting; //... restituisci il risultato.
}
bool Command::sentModule() //funzione per attendere se il modulo ha inviato qualcosa.
{
_flag = false;
if (Module.available()) //se il modulo ha inviato qualcosa
{
_flag = true; //true - se il modulo ha inviato.
}
else
{
_flag = false; //false - se il modulo non ha inviato.
}
return _flag; //restituisci il risultato.
}
void Command::sendModule() //funzione
per ricevere i comandi via Serial e inviare il comando ricevuto.
{
if (Serial.available()) //In attesa di comandi via Serial...
{
Module.write(Serial.read()); //...e invia il comando ricevuto al modulo.
};
}
Command ATCommand = Command(); //creare oggetto all'interno della libreria
.
File keywords
#################################
#Syntax ATCommand
#################################
#File name and Class (KEYWORD1)
#################################
ATCommand KEYWORD1
#################################
#Methods and Functions (KEYWORD2)
#################################
begin KEYWORD2
resetModule KEYWORD2
sendCommand KEYWORD2
waitResponse KEYWORD2
sentModule KEYWORD2
sendModule KEYWORD2
Esempio basato su modulo SIM800L File Seting_Module.ino
#include <ATCommand.h> /*libreria per l'implementazione dello scambio software tramite protocollo UART che interagisce con i comandi AT.*/
String response = ""; //variabile per memorizzare la risposta del modulo.
String response = ""; //variabile per memorizzare la risposta del modulo.
void setup()
{
Serial.begin(9600); //velocità di scambio dati con il computer.
Serial.println("Start");
ATCommand.resetModule(); //resettare il modulo.
ATCommand.begin(); //velocità di scambio dati con il modulo.
ATCommand.sendCommand("AT", true); //invia AT per impostare la velocità di scambio dati.
}
void loop()
{
if (ATCommand.sentModule()) //se il modulo ha inviato qualcosa.
{
response = ATCommand.waitResponse(); //ottiene una risposta dal modulo per l'analisi.
response.trim(); //rimuovi gli spazi bianchi all'inizio e alla fine.
Serial.println(response); //duplica la risposta sul monitor.
// ... qui puoi analizzare i dati ricevuti dal modulo.
}
ATCommand.sendModule(); //attendi un comando via Serial e invia il comando ricevuto al modulo.
}
Libreria ATCommand_1.0