uint32_t cmdLeftMFw(int speed) {
uint8_t data = (speed > 127) ? 127 : speed;
sig = M1_FORWARD;
ret = serialSend(&sig,1);
ret = serialSend(&data,1);
return ret;
}
uint32_t cmdRightMBw(int speed) {
uint8_t data = (speed > 127) ? 127 : speed;
sig = M2_BACKWARD;
ret = serialSend(&sig,1);
ret = serialSend(&data,1);
return ret;
}
void Server::waitForClient()
{
printf("Waiting for client.\n");
serialReceive(msgBuffer); // Recieve filename from client.
FILE* stream;
if(stream = fopen(msgBuffer, "r")) // If opening a file with the name recieved is succesfull continue
{
long lengthOfFile = getFileLength(stream); // Get file length of opened file in bytes.
printf("User requested: %s with a size of %ld bytes\n", msgBuffer, lengthOfFile); // Print out filename and lenght of file.
sprintf(msgBuffer, "%ld", lengthOfFile); // Convert lenght of file to string.
serialSend(msgBuffer, strlen(msgBuffer)+1); // Send lenght of file
sendFile(stream, lengthOfFile); // Use function to send file, giving pointer and lenght of the file to send.
fclose(stream); // Close file.
}
else // If file couldnt be found, print out message and send to client 0 filelenght (its not found).
{
printf("Client tried to get: %s\n", msgBuffer);
serialSend("0", 2);
}
printf("Client connection closed\n");
}
uint32_t cmdDoPlay(char *seq) {
sig = DO_PLAY;
//First byte must be length of sequence to read
uint8_t len = strlen(seq);
//Songs longer than 100 (1 for reset) are invalid input
if (len > 99) {return 0;}
ret = serialSend(&sig, 1);
ret = serialSend(&len, 1);
ret = serialSend((uint8_t*)seq, (uint32_t)len);
return ret;
}
uint32_t cmdLcdPrint(char *buf) {
uint8_t length = strlen(buf);
if (length > 8) {
buf[9] = '\0';
length = 8;
}
sig = DO_PRINT;
ret = serialSend(&sig,1);
ret = serialSend(&length,1);
ret = serialSend((unsigned char*)buf,length);
return ret;
}
QByteArray &FalconBoard::comandoNvar(int tipo, QByteArray var)
{
QByteArray comando;
comando.resize(8);
qComando1var_t *qcmd = (qComando1var_t *)comando.data();
qcmd->header = header;
qcmd->tipo = tipo;
comando += var;
int sum = tipo;
int *varptr = (int *)var.data();
for (int i = var.size()/4; i != 0; i--){
sum += *(varptr++);
}
QByteArray CRC;
CRC.resize(4);
varptr = (int *)CRC.data();
*varptr = -sum;
comando += CRC;
comando.append("\r\n\r\n");
emit serialSend(comando);
if (tipo != qComandoxplanInfo2board_t){
qDebug() << "[" << comando.size() << "] <- Comando N var tipo: " << tipo;
}
//QString state = "[" + QString::number(comando.size()) + "] <- Comando N var tipo: " + QString::number(tipo);
//emit estadoDebug(state);
return comando;
}
uint32_t cmdLinePos(uint8_t *linePos) {
sig = SEND_LINE_POSITION;
ret = serialSend(&sig, 1);
ret = serialRecv(linePos, 2);
return ret;
}
/*****************************************************************************************************************************
*
* Read specified metric's value of the Winsen MH-Zxx CO2 sensor via UART, put it to output buffer on success.
*
* Returns:
* - RESULT_IS_BUFFERED on success
* - DEVICE_ERROR_TIMEOUT if device stop talking
*
*****************************************************************************************************************************/
int8_t getMHZxxMetricUART(const uint8_t _rxPin, const uint8_t _txPin, uint8_t* _dst, int32_t* _value, const uint8_t _wantsNumber) {
uint8_t len, rc = DEVICE_ERROR_TIMEOUT;
SoftwareSerial swSerial(_rxPin, _txPin);
// Send query only if sensor heated
if (millis() > MH_ZXX_PREHEAT_TIMEOUT) {
swSerial.begin(MH_ZXX_UART_SPEED);
_dst[MH_ZXX_STARTING_BYTE] = 0xFF; // Starting byte
_dst[MH_ZXX_SENSOR_NUMBER] = 0x01; // Sensor No.
_dst[MH_ZXX_CMD] = MH_ZXX_CMD_GAS_CONCENTRATION; // Command
_dst[3] = _dst[4] = _dst[5] = _dst[6] = _dst[7] = 0x00; // Stub bytes
_dst[MH_ZXX_CRC] = 0x79; // Check value
// Flush all device's transmitted data to avoid get excess data in recieve buffer
//serialRXFlush(&swSerial, !UART_SLOW_MODE);
flushStreamRXBuffer(&swSerial, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_SLOW_MODE);
// The serial stream can get out of sync. The response starts with 0xff, try to resync : https://github.com/jehy/arduino-esp8266-mh-z19-serial/blob/master/arduino-esp8266-mhz-19-serial.ino
// Send command to MH-Zxx
serialSend(&swSerial, _dst, MH_ZXX_PACKET_SIZE, !UART_SLOW_MODE);
// Recieve from MH-Zxx
// It actually do not use '\r', '\n', '\0' to terminate string
len = serialRecive(&swSerial, _dst, MH_ZXX_PACKET_SIZE, MH_ZXX_DEFAULT_READ_TIMEOUT, !UART_STOP_ON_CHAR, '\r', !UART_SLOW_MODE);
// Connection timeout occurs
if (len < MH_ZXX_PACKET_SIZE) { rc = DEVICE_ERROR_TIMEOUT; goto finish; }
// Wrong answer. buffer[0] must contain 0xFF
if (0xFF != _dst[MH_ZXX_STARTING_BYTE]) { rc = DEVICE_ERROR_WRONG_ANSWER; goto finish; }
// Bad CRC
// CRC calculate for bytes #1..#9 (byte #0 excluded)
if (_dst[MH_ZXX_CRC] != crcMHZxx(_dst)) { rc = DEVICE_ERROR_CHECKSUM; goto finish; }
*_value = 256 * _dst[MH_ZXX_GAS_CONCENTRATION_HIGH_BYTE];
*_value += _dst[MH_ZXX_GAS_CONCENTRATION_LOW_BYTE];
} else { // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)
// Return 'good concentracion' while sensor heated
*_value = MH_ZXX_PREHEAT_GAS_CONCENTRATION;
} // if (millis() > MH_ZXX_PREHEAT_TIMEOUT)
if (!_wantsNumber) {
ultoa(*_value, (char*) _dst, 10);
}
rc = RESULT_IS_BUFFERED;
finish:
gatherSystemMetrics(); // Measure memory consumption
swSerial.~SoftwareSerial();
return rc;
}
uint32_t cmdAutoCal() {
sig = AUTO_CALIBRATE;
uint8_t check;
ret = serialSend(&sig,1);
ret = serialRecv(&check,1);
if (check != (uint8_t)'c')
return 1;
else
return ret;
}
void Server::sendFile(FILE* file, long fileSize)
{
puts("Sending file");
size_t readFromFile = 0;
// Start reading
while(1)
{
readFromFile = fread(msgBuffer, 1, BUFFERSIZE, file);
// serialSend info
serialSend(msgBuffer, readFromFile);
if(feof(file)) // If everything has been read, break out of while loop.
break;
}
}
QByteArray &FalconBoard::comando1var(int tipo, int var)
{
QByteArray comando;
comando.resize(sizeof(qComando1var_t));
qComando1var_t *qcmd = (qComando1var_t *)comando.data();
qcmd->header = header;
qcmd->tipo = tipo;
qcmd->variable1 = var;
qcmd->CRC = -(tipo + var);
comando.append("\r\n\r\n");
emit serialSend(comando);
qDebug() << "[" << comando.size() << "bytes] <- Comando 1 var tipo: " << tipo;
QString state = "[" + QString::number(comando.size()) + "] <- Comando 1 var tipo: " + QString::number(tipo);
emit estadoDebug(state);
return comando;
}
cell pawn_serialSend( AMX * amx, const cell * params )
{
int i = 0;
int cnt = 0;
cell * data = amx_Address( amx, params[1] );
while ( i < params[2] )
{
int j;
for ( j=0; j<SERIAL_BUF_SZ; j++, i++ )
{
if ( i >= params[2] )
break;
serialBuffer[j] = (uint8_t)data[i];
}
cnt += serialSend( serialBuffer, j );
}
return cnt;
}
uint32_t cmdRstCal() {
sig = LINE_SENSORS_RESET_CALIBRATION;
ret = serialSend(&sig, 1);
return ret;
}
uint32_t cmdPIDstart(uint8_t *data) {
sig = SET_PID;
ret = serialSend(&sig, 1);
ret = serialSend(data, 5);
return ret;
}
uint32_t cmdLcdClear() {
sig = DO_CLEAR;
ret = serialSend(&sig,1);
return ret;
}
uint32_t cmdCalSens(uint16_t *sens) {
sig = SEND_CAL_SENSOR_VALUES;
ret = serialSend(&sig,1);
ret = serialRecv((uint8_t*)sens,10);
return ret;
}
uint32_t cmdSig(unsigned char *buf) {
sig = SEND_SIGNATURE;
ret = serialSend(&sig,1);
ret = serialRecv(buf,6);
return ret;
}
uint32_t cmdPIDstop() {
sig = STOP_PID;
ret = serialSend(&sig, 1);
return ret;
}
