521 lines
13 KiB
C++
521 lines
13 KiB
C++
/*
|
|
server_drv.cpp - Library for Arduino Wifi shield.
|
|
Copyright (c) 2018 Arduino SA. All rights reserved.
|
|
Copyright (c) 2011-2014 Arduino. All right reserved.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
//#define _DEBUG_
|
|
|
|
#include "utility/server_drv.h"
|
|
|
|
#include "Arduino.h"
|
|
#include "utility/spi_drv.h"
|
|
|
|
extern "C" {
|
|
#include "utility/wl_types.h"
|
|
#include "utility/debug.h"
|
|
}
|
|
|
|
|
|
// Start server TCP on port specified
|
|
void ServerDrv::startServer(uint16_t port, uint8_t sock, uint8_t protMode)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(START_SERVER_TCP_CMD, PARAM_NUMS_3);
|
|
SpiDrv::sendParam(port);
|
|
SpiDrv::sendParam(&sock, 1);
|
|
SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(START_SERVER_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
}
|
|
|
|
void ServerDrv::startServer(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(START_SERVER_TCP_CMD, PARAM_NUMS_4);
|
|
SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
|
|
SpiDrv::sendParam(port);
|
|
SpiDrv::sendParam(&sock, 1);
|
|
SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(START_SERVER_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
}
|
|
|
|
// Start server TCP on port specified
|
|
void ServerDrv::startClient(uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_4);
|
|
SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
|
|
SpiDrv::sendParam(port);
|
|
SpiDrv::sendParam(&sock, 1);
|
|
SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
}
|
|
|
|
void ServerDrv::startClient(const char* host, uint8_t host_len, uint32_t ipAddress, uint16_t port, uint8_t sock, uint8_t protMode)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_5);
|
|
SpiDrv::sendParam((uint8_t*)host, host_len);
|
|
SpiDrv::sendParam((uint8_t*)&ipAddress, sizeof(ipAddress));
|
|
SpiDrv::sendParam(port);
|
|
SpiDrv::sendParam(&sock, 1);
|
|
SpiDrv::sendParam(&protMode, 1, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
int commandSize = 17 + host_len;
|
|
while (commandSize % 4) {
|
|
SpiDrv::readChar();
|
|
commandSize++;
|
|
}
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady(/* feed_watchdog = */ (protMode == TLS_BEARSSL_MODE));
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(START_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
}
|
|
|
|
// Start server TCP on port specified
|
|
void ServerDrv::stopClient(uint8_t sock)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(STOP_CLIENT_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, 1, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(STOP_CLIENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
}
|
|
|
|
|
|
uint8_t ServerDrv::getServerState(uint8_t sock)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(GET_STATE_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(GET_STATE_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
return _data;
|
|
}
|
|
|
|
uint8_t ServerDrv::getClientState(uint8_t sock)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(GET_CLIENT_STATE_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseCmd(GET_CLIENT_STATE_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
return _data;
|
|
}
|
|
|
|
uint16_t ServerDrv::availData(uint8_t sock)
|
|
{
|
|
if (!SpiDrv::available()) {
|
|
return 0;
|
|
}
|
|
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _dataLen = 0;
|
|
uint16_t len = 0;
|
|
|
|
SpiDrv::waitResponseCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1, (uint8_t*)&len, &_dataLen);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
|
|
return len;
|
|
}
|
|
|
|
uint8_t ServerDrv::availServer(uint8_t sock)
|
|
{
|
|
if (!SpiDrv::available()) {
|
|
return 255;
|
|
}
|
|
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _dataLen = 0;
|
|
uint16_t socket = 0;
|
|
|
|
SpiDrv::waitResponseCmd(AVAIL_DATA_TCP_CMD, PARAM_NUMS_1, (uint8_t*)&socket, &_dataLen);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
|
|
return socket;
|
|
}
|
|
|
|
bool ServerDrv::getData(uint8_t sock, uint8_t *data, uint8_t peek)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(GET_DATA_TCP_CMD, PARAM_NUMS_2);
|
|
SpiDrv::sendParam(&sock, sizeof(sock));
|
|
SpiDrv::sendParam(peek, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseData8(GET_DATA_TCP_CMD, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
if (_dataLen!=0)
|
|
{
|
|
*data = _data;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ServerDrv::getDataBuf(uint8_t sock, uint8_t *_data, uint16_t *_dataLen)
|
|
{
|
|
if (!SpiDrv::available())
|
|
{
|
|
*_dataLen = 0;
|
|
return false;
|
|
}
|
|
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(GET_DATABUF_TCP_CMD, PARAM_NUMS_2);
|
|
SpiDrv::sendBuffer(&sock, sizeof(sock));
|
|
SpiDrv::sendBuffer((uint8_t *)_dataLen, sizeof(*_dataLen), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
if (!SpiDrv::waitResponseData16(GET_DATABUF_TCP_CMD, _data, _dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
if (*_dataLen!=0)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ServerDrv::insertDataBuf(uint8_t sock, const uint8_t *data, uint16_t _len)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(INSERT_DATABUF_CMD, PARAM_NUMS_2);
|
|
SpiDrv::sendBuffer(&sock, sizeof(sock));
|
|
SpiDrv::sendBuffer((uint8_t *)data, _len, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
int commandSize = 9 + _len;
|
|
while (commandSize % 4) {
|
|
SpiDrv::readChar();
|
|
commandSize++;
|
|
}
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseData8(INSERT_DATABUF_CMD, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
if (_dataLen!=0)
|
|
{
|
|
return (_data == 1);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool ServerDrv::sendUdpData(uint8_t sock)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(SEND_DATA_UDP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseData8(SEND_DATA_UDP_CMD, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
if (_dataLen!=0)
|
|
{
|
|
return (_data == 1);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
uint16_t ServerDrv::sendData(uint8_t sock, const uint8_t *data, uint16_t len)
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(SEND_DATA_TCP_CMD, PARAM_NUMS_2);
|
|
SpiDrv::sendBuffer(&sock, sizeof(sock));
|
|
SpiDrv::sendBuffer((uint8_t *)data, len, LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
int commandSize = 9 + len;
|
|
while (commandSize % 4) {
|
|
SpiDrv::readChar();
|
|
commandSize++;
|
|
}
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint16_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
if (!SpiDrv::waitResponseData8(SEND_DATA_TCP_CMD, (uint8_t*)&_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
|
|
return _data;
|
|
}
|
|
|
|
|
|
uint8_t ServerDrv::checkDataSent(uint8_t sock)
|
|
{
|
|
const uint16_t TIMEOUT_DATA_SENT = 25;
|
|
uint16_t timeout = 0;
|
|
uint8_t _data = 0;
|
|
uint8_t _dataLen = 0;
|
|
|
|
do {
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
// Send Command
|
|
SpiDrv::sendCmd(DATA_SENT_TCP_CMD, PARAM_NUMS_1);
|
|
SpiDrv::sendParam(&sock, sizeof(sock), LAST_PARAM);
|
|
|
|
// pad to multiple of 4
|
|
SpiDrv::readChar();
|
|
SpiDrv::readChar();
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
if (!SpiDrv::waitResponseCmd(DATA_SENT_TCP_CMD, PARAM_NUMS_1, &_data, &_dataLen))
|
|
{
|
|
WARN("error waitResponse isDataSent");
|
|
}
|
|
SpiDrv::spiSlaveDeselect();
|
|
|
|
if (_data) timeout = 0;
|
|
else{
|
|
++timeout;
|
|
delay(100);
|
|
}
|
|
|
|
}while((_data==0)&&(timeout<TIMEOUT_DATA_SENT));
|
|
return (timeout==TIMEOUT_DATA_SENT)?0:1;
|
|
}
|
|
|
|
uint8_t ServerDrv::getSocket()
|
|
{
|
|
WAIT_FOR_SLAVE_SELECT();
|
|
|
|
// Send Command
|
|
SpiDrv::sendCmd(GET_SOCKET_CMD, PARAM_NUMS_0);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
//Wait the reply elaboration
|
|
SpiDrv::waitForSlaveReady();
|
|
SpiDrv::spiSlaveSelect();
|
|
|
|
// Wait for reply
|
|
uint8_t _data = -1;
|
|
uint8_t _dataLen = 0;
|
|
SpiDrv::waitResponseCmd(GET_SOCKET_CMD, PARAM_NUMS_1, &_data, &_dataLen);
|
|
|
|
SpiDrv::spiSlaveDeselect();
|
|
|
|
return _data;
|
|
}
|
|
|
|
ServerDrv serverDrv;
|