bool ESP8266::eATCWQAP(void)
{
String data;
rx_empty();
sendAT("CWQAP");
return recvFind("OK");
}
s8 at_ate1(void) //打开回显
{
sendAT("ATE1\r\n", strlen("ATE1\r\n"));
recvAT();
if(check_string(gprs_databuf.recvdata, "OK", gprs_databuf.recvlen)) return 0;
else return -1;
}
bool ESP8266::eATCWLAP(String &list)
{
String data;
rx_empty();
sendAT("CWLAP");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list, 10000);
}
//! Send MO SBD message.
//! @param[in] data data to send.
//! @param[in] alert_reply true if a ring alert was received,
//! false otherwise.
void
sendSBD(const std::vector<uint8_t>& data, bool alert_reply = false)
{
getTask()->debug("sending SBD with size %u", static_cast<unsigned>(data.size()));
if (data.size() == 0)
writeBufferMO(NULL, 0);
else
writeBufferMO(&data[0], data.size());
if (alert_reply)
sendAT("+SBDIXA");
else
sendAT("+SBDIX");
setBusy(true);
}
//at
s8 at_at(void) //测试串口
{
sendAT("AT\r\n", sizeof("AT\r\n"));
recvAT();
if(check_string(gprs_databuf.recvdata, "OK", gprs_databuf.recvlen)) return 0;
else return -1;
}
bool ESP8266::eATCIPSTATUS(String &list)
{
String data;
delay(100);
rx_empty();
sendAT("CIPSTATUS");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", list);
}
s8 at_tsim(void) //sim 检测到sim卡返回0
{
sendAT("AT%TSIM\r\n", strlen("AT%TSIM\r\n"));
recvAT();
if(check_string(gprs_databuf.recvdata, "%TSIM 1", gprs_databuf.recvlen)){
recvAT();
return 0;
}
recvAT() ;
return -1;
}
bool aru(ardrone* dr)
{
/// Commence par sortir du mode de vol.
dr->fly = false;
/// Ensuite envoie un paquet d'arrêt d'urgence.
strcpy(dr->bufferLeft, "AT*REF=");
strcpy(dr->bufferRight, ",290717952\r");
fprintf(stdout, "#%5d - Arrêt d'urgence - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
return sendAT(dr);
}
bool initDrone(ardrone* dr)
{
/// Commence par configurer la hauteur maximale du drone en fonction de la configuration réalisée à l'aide d'un #define
/// Si le drone vol en intérieur limite l'altitude à ALTITUDEMAX (défini avec #define), sinon c'est 100 fois cette altitude
strcpy(dr->bufferLeft, "AT*CONFIG=");
#ifdef VOL_INTERIEUR
strcat(dr->bufferRight, ALTITUDEMAX);
#else
strcat(dr->bufferRight, 100*ALTITUDEMAX);
#endif
strcat(dr->bufferRight, "\"\r");
fprintf(stdout, "#%5d - Config alt max - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
if(!sendAT(dr))
return false;
/// Puis indique au drone qu'il est à plat : le drone se calibre.
strcpy(dr->bufferLeft, "AT*FTRIM=");
strcpy(dr->bufferRight, ",\r");
fprintf(stdout, "#%5d - Ftrim - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
if(!sendAT(dr))
return false;
/// Enfin, suivant la configuration réalisée avec un #define, indique au drone qu'il vole en extérieur, ou en intérieur, avec la carène correspondante.
/// N.B. : Cette configuration est réalisée à l'aide d'un bouton sur la télécommande.
strcpy(dr->bufferLeft, "AT*CONFIG=");
#ifdef VOL_INTERIEUR
strcpy(dr->bufferRight, ",\"control:outdoor\", \"FALSE\"\r");
if(!sendAT(dr))
return false;
strcpy(dr->bufferRight, ",\"control:flight_without_shell\", \"FALSE\"\r");
#else
strcpy(dr->bufferRight, ",\"control:outdoor\", \"TRUE\"\r");
if(!sendAT(dr))
return false;
strcpy(dr->bufferRight, ",\"control:flight_without_shell\", \"TRUE\"\r");
#endif
return sendAT(dr);
}
bool land(ardrone* dr)
{
/// On commence par sortir du mode vol.
dr->fly = false;
/// Puis demande l'atterrissage.
strcpy(dr->bufferLeft, "AT*REF=");
strcpy(dr->bufferRight, ",290717696\r");
fprintf(stdout, "#%5d - Land - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
return sendAT(dr);
}
bool ESP8266::qCWAUTOCONN()
{
String str_mode;
rx_empty();
sendAT("CWAUTOCONN?");
bool ret = recvFindAndFilter("OK", "+CWAUTOCONN:", "\r\n\r\nOK", str_mode);
if (ret) {
return (uint8_t) str_mode.toInt();
} else {
return false;
}
}
bool volCommand(ardrone* dr, joystick tiltLeftRight_, joystick tiltFrontBack_, joystick goUpDown_, joystick turnLeftRight_)
{
char strBuff[50];
/// Commence par préparer la trame à envoyer en écrivant dans un buffer les valeurs flottantes, récupérées en paramètres, sous forme de int. Cela revient à écrire un int dont l'empreinte binaire est celle du flottant correspondant passé en paramètre.
sprintf(strBuff, ",1,%d,%d,%d,%d\r", tiltLeftRight_.i,
tiltFrontBack_.i,
goUpDown_.i,
turnLeftRight_.i);
/// Envoie le datagramme.
strcpy(dr->bufferLeft, "AT*PCMD=");
strcpy(dr->bufferRight, strBuff);
fprintf(stdout, "#%5d - PCMD - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
return sendAT(dr);
}
bool ESP8266::connected()
{
String data;
rx_empty();
sendAT("CWJAP?");
data = recvString("OK", "FAIL", 1000);
if (data.indexOf("+CWJAP:") != -1) {
return true;
}
return false;
}
/*****************************************
测试信号强度
入口参数：无
返回参数：信号强度值 0 ~ 31
*******************************************/
s8 at_csq(void)
{
u8 *p, csq;
sendAT("AT+CSQ\r\n", strlen("AT+CSQ\r\n"));
recvAT() ;
// if(check_string(gprs_databuf.recvdata, "OK", 18) == NULL) return -1;
p = check_string(gprs_databuf.recvdata, ",", gprs_databuf.recvlen);
if(p) {
csq = (*(p-2)*10 + *(p-1));
recvAT();
return csq;
}
recvAT();
return -1;
}
//! Read the contents of the MT SBD message buffer.
//! @param[in] data buffer to hold binary data.
//! @param[in] data_size size of binary data buffer.
//! @return number of bytes read.
unsigned
readBufferMT(uint8_t* data, unsigned data_size)
{
ReadMode saved_read_mode = getReadMode();
Counter<double> timer(getTimeout());
uint8_t bfr[2] = {0};
uint8_t ccsum[2] = {0};
unsigned length = 0;
try
{
// Prepare to read raw data.
setReadMode(READ_MODE_RAW);
// Send command.
sendAT("+SBDRB");
// Read incoming data length.
length = getBufferSizeMT(timer);
getTask()->spew("reading %u bytes of SBD binary data", length);
// Read data.
if (length > data_size)
throw BufferTooSmall(data_size, length);
if (length > 0)
{
readRaw(timer, data, length);
computeChecksum(data, length, ccsum);
}
// Read and validate.
readRaw(timer, bfr, 2);
if ((bfr[0] != ccsum[0]) || (bfr[1] != ccsum[1]))
throw Hardware::InvalidChecksum(bfr, ccsum);
setReadMode(saved_read_mode);
expectOK();
}
catch (...)
{
setReadMode(saved_read_mode);
throw;
}
return length;
}
bool ESP8266::qATCWMODE(uint8_t *mode)
{
String str_mode;
bool ret;
if (!mode) {
return false;
}
rx_empty();
sendAT("CWMODE?");
ret = recvFindAndFilter("OK", "+CWMODE:", "\r\n\r\nOK", str_mode);
if (ret) {
*mode = (uint8_t)str_mode.toInt();
return true;
} else {
return false;
}
}
bool ESP8266::sATCIPSERVER(uint8_t mode, uint32_t port)
{
String data;
if (mode) {
rx_empty();
printAT("CIPSERVER=1,");
m_puart->println(port);
data = recvString("OK", "no change");
if (data.indexOf("OK") != -1 || data.indexOf("no change") != -1) {
return true;
}
return false;
} else {
rx_empty();
sendAT("CIPSERVER=0");
return recvFind("\r\r\n");
}
}
bool takeoff(ardrone* dr)
{
/// Demande le décollage du drone.
strcpy(dr->bufferLeft, "AT*REF=");
strcpy(dr->bufferRight, ",290718208\r");
fprintf(stdout, "#%5d - Take off - %s%d%s", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
if(!sendAT(dr))
return false;
/// Si la demande a réussi passe en mode vol.
strcpy(dr->bufferLeft, "AT*PCMD=");
strcpy(dr->bufferRight, ",1,0,0,0,0\r");
setGoUpDown(dr, 0);
setTurnLeftRight(dr, 0);
setTiltFrontBack(dr, 0);
setTiltLeftRight(dr, 0);
dr->fly = true;
return true;
}
int receiveNavData(ardrone* dr, struct sockaddr_in* sender, socklen_t* senderLen, char* buffer, int bufferLenght)
{
int ret = 0;
/// Commence par "réveiller" le drone en envoyant un paquet pour redémarrer le WatchDog.
strcpy(dr->bufferLeft, "AT*COMWDG=");
strcpy(dr->bufferRight, ",\r");
//fprintf(stdout, "#%5d - Restart the watchdog for Navdata flow - %s%d%s\n", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
if(!sendAT(dr))
{
fprintf(stderr, "## - Unable to reset the watchdog.\n");
return -1;
}
/// Puis attend de récupérer les données de navigation.
//fprintf(stdout, "Wait for data ...\n");
ret = recvfrom(dr->udpSocket_navData, buffer, bufferLenght, 0, (struct sockaddr*)sender, senderLen);
/// Une fois que les données sont reçues, vérifie que la fonction a bien écrit des caractères dans le buffer.
if(ret <= 0)
fprintf(stderr, "Impossible de réceptionner des données : %d\n", ret);
/// Enfin retourne le nombre de caractères écris dans le buffer.
return ret;
}
bool initNavData(ardrone* dr)
{
static char atCtrl[] = "AT*CTRL=0\r", un[14] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0};
/// Commence par envoyer un paquet sur le port des données de navigation, pour que le drone commence à écouter.
fprintf(stdout, "# - Send some bytes on navdata port\n");
if(!sendNavData(dr, "Hello World !"))
return false;
/// Puis demande l'envoi de donnée de navigation.
strcpy(dr->bufferLeft, "AT*CONFIG=");
strcpy(dr->bufferRight, ",\"general:navdata_demo\",\"TRUE\"\r");
fprintf(stdout, "#%5d - Start navdata flow %s%d%s\n", dr->ident+1, dr->bufferLeft, dr->ident+1, dr->bufferRight);
if(!sendAT(dr))
return false;
/// Ensuite envoie une trame de contrôle pour indiquer au drone qu'il peut envoyer des données.
if (sendto(dr->udpSocket_at, atCtrl, strlen(atCtrl), 0,
(struct sockaddr *) &(dr->addrDroneAT),
sizeof(dr->addrDroneAT)) < 0)
{
fprintf(stderr, "## Error : Impossible d'émettre la trame AT*CTRL=0\n", dr->ident);
return false;
}
else
fprintf(stdout, "# - AT*CTRL=0 emitted.\n");
/// Puis envoie une configuration pour demander au drone d'envoyer les données de navigation en multicast.
if(!sendNavData(dr, un))
{
fprintf(stderr, "## Error : Impossible d'émettre un 1\n");
return false;
}
else
fprintf(stdout, "# - 1 envoyé.\n");
return true;
}
bool ESP8266::eATGMR(String &version)
{
rx_empty();
sendAT("GMR");
return recvFindAndFilter("OK", "\r\r\n", "\r\n\r\nOK", version);
}
bool ESP8266::eATRST(void)
{
rx_empty();
sendAT("RST");
return recvFind("OK");
}
void XBeeRemote::init()
{
std::string hex = HexData(_interface->macAddress()).toHexStr();
sendAT(std::string("DH"+hex.substr(0,8)));
sendAT(std::string("DL"+hex.substr(8,8)));
}
bool ESP8266::eATCIPCLOSESingle(void)
{
rx_empty();
sendAT("CIPCLOSE");
return recvFind("OK", 5000);
}
