char SSerial::serialGetchar()
{
if (!connected) {
printf( "Getchar() not connected\n"); //return -1;
return 0;
}
//printf( "Getchar() "); fflush(stdout);
char buff[3];
const long int LOOPS = 600000;
int c;
long int count=0;
if (available()) {
// do {
c = ::read( fd, (void*)&buff, 1 );
if (c==0) printf("0");
else if (c==-1) printf("?");
else printf("%c", buff[0]);
return buff[0];
}
else {
printf("no data\n");
return 0;
}
// count++;
// } while ((c==0) || ((c==-1) && (count<LOOPS)));
//printf( "c=%d; count=%d; ", c, count); fflush(stdout);
if (count>=LOOPS) {
buff[0] = -1;
printf("timeout!\n");
return 0;
}
// else
// printf(" %x_%c ", buff[0], buff[0]);
}
void QNativeWifiEngine::disconnectFromId(const QString &id)
{
QMutexLocker locker(&mutex);
if (!available()) {
locker.unlock();
emit connectionError(id, InterfaceLookupError);
return;
}
QString interface = getInterfaceFromId(id);
if (interface.isEmpty()) {
locker.unlock();
emit connectionError(id, InterfaceLookupError);
return;
}
QStringList split = interface.mid(1, interface.length() - 2).split('-');
GUID guid;
guid.Data1 = split.at(0).toUInt(0, 16);
guid.Data2 = split.at(1).toUShort(0, 16);
guid.Data3 = split.at(2).toUShort(0, 16);
guid.Data4[0] = split.at(3).left(2).toUShort(0, 16);
guid.Data4[1] = split.at(3).right(2).toUShort(0, 16);
for (int i = 0; i < 6; ++i)
guid.Data4[i + 2] = split.at(4).mid(i*2, 2).toUShort(0, 16);
DWORD result = local_WlanDisconnect(handle, &guid, 0);
if (result != ERROR_SUCCESS) {
#ifdef BEARER_MANAGEMENT_DEBUG
qDebug("%s: WlanDisconnect failed with error %ld\n", __FUNCTION__, result);
#endif
locker.unlock();
emit connectionError(id, DisconnectionError);
return;
}
}
uint8_t REDFLY::socketClosed(uint8_t socket)
{
if(available()) //check for new data, if socket closed?
{
uint8_t sock=INVALID_SOCKET;
uint16_t len=0;
socketRead(&sock, &len, 0, 0, 0, 0);
}
if(socket != INVALID_SOCKET)
{
for(uint8_t i=0; i<MAX_SOCKETS; i++)
{
if(socket_state[i].handle == socket) //socket found
{
return 0;
}
}
}
return 1;
}
bool recvfromAck(uint8_t* buf, uint8_t* len, uint8_t* from, uint8_t* to, uint8_t* id, uint8_t* flags)
{
uint8_t _from;
uint8_t _to;
uint8_t _id;
uint8_t _flags;
// Get the message before its clobbered by the ACK (shared rx and tx buffer in some drivers
if (available() && recvfrom(buf, len, &_from, &_to, &_id, &_flags))
{
// Never ACK an ACK
if (!(_flags & RH_FLAGS_ACK))
{
// Its a normal message for this node, not an ACK
if (_to != RH_BROADCAST_ADDRESS)
{
// Its not a broadcast, so ACK it
// Acknowledge message with ACK set in flags and ID set to received ID
acknowledge(_id, _from);
}
// If we have not seen this message before, then we are interested in it
if (_id != _seenIds[_from])
{
if (from)
*from = _from;
if (to)
*to = _to;
if (id)
*id = _id;
if (flags)
*flags = _flags;
_seenIds[_from] = _id;
return true;
}
// Else just re-ack it and wait for a new one
}
}
// No message for us available
return false;
}
void pr_ivec_block(FILE *fp,int indent,const char *title,int vec[],int n, bool bShowNumbers)
{
int i,j;
if (available(fp,vec,indent,title))
{
indent=pr_title_n(fp,indent,title,n);
i = 0;
while (i < n)
{
j = i+1;
while (j < n && vec[j] == vec[j-1]+1)
{
j++;
}
/* Print consecutive groups of 3 or more as blocks */
if (j - i < 3)
{
while(i < j)
{
(void) pr_indent(fp,indent);
(void) fprintf(fp,"%s[%d]=%d\n",
title,bShowNumbers?i:-1,vec[i]);
i++;
}
}
else
{
(void) pr_indent(fp,indent);
(void) fprintf(fp,"%s[%d,...,%d] = {%d,...,%d}\n",
title,
bShowNumbers?i:-1,
bShowNumbers?j-1:-1,
vec[i],vec[j-1]);
i = j;
}
}
}
}
void RF24Mesh::handlePacket()
{
int count=0;
// Is there anything ready for us?
while ( available() )
{
IF_SERIAL_DEBUG(printf_P(PSTR("There are available received message %d \n\r"),count++));
// If so, take a look at it
RF24NetworkHeader header;
peek(header);
// Dispatch the message to the correct handler.
switch (header.type)
{
case 'J':
handle_JoinMessage(header);
break;
case 'W':
handle_WelcomeMessage(header);
break;
case 'D':
handle_DataMessage(header);
break;
case 'F':
handle_ForwardData(header);
break;
case 'U':
handle_UpdateWeightMessage(header);
break;
default:
printf_P(PSTR("*** WARNING *** Unknown message type %s\n\r"),header.toString());
read(header,0,0);
break;
};
}
}
static void pr_cmap(FILE *fp, int indent, const char *title,
gmx_cmap_t *cmap_grid, gmx_bool bShowNumbers)
{
int i,j,nelem;
real dx,idx;
dx = 360.0 / cmap_grid->grid_spacing;
nelem = cmap_grid->grid_spacing*cmap_grid->grid_spacing;
if(available(fp,cmap_grid,indent,title))
{
fprintf(fp,"%s\n",title);
for(i=0;i<cmap_grid->ngrid;i++)
{
idx = -180.0;
fprintf(fp,"%8s %8s %8s %8s\n","V","dVdx","dVdy","d2dV");
fprintf(fp,"grid[%3d]={\n",bShowNumbers?i:-1);
for(j=0;j<nelem;j++)
{
if( (j%cmap_grid->grid_spacing)==0)
{
fprintf(fp,"%8.1f\n",idx);
idx+=dx;
}
fprintf(fp,"%8.3f ",cmap_grid->cmapdata[i].cmap[j*4]);
fprintf(fp,"%8.3f ",cmap_grid->cmapdata[i].cmap[j*4+1]);
fprintf(fp,"%8.3f ",cmap_grid->cmapdata[i].cmap[j*4+2]);
fprintf(fp,"%8.3f\n",cmap_grid->cmapdata[i].cmap[j*4+3]);
}
fprintf(fp,"\n");
}
}
}
//
// skip()
//
size_t InputStream::skip(size_t n)
throw(IOException)
{
/* [email protected] 14/7/2004
ignore((int) n);
return (size_t) gcount();
*/
unsigned char skip_buffer[SKIP_BUFFER_SIZE];
if (n == 0)
{
return n;
}
size_t buff_available = available();
size_t to_skip = min(n, buff_available);
size_t to_read = to_skip;
size_t to_read_in_this_loop = 0;
while (to_read > 0)
{
to_read_in_this_loop = min((unsigned int)to_read, SKIP_BUFFER_SIZE);
size_t n_read = 0;
while (n_read < to_read_in_this_loop)
{
size_t read_res = read(skip_buffer, SKIP_BUFFER_SIZE, 0,
to_read_in_this_loop - n_read);
n_read += read_res;
}
to_read -= to_read_in_this_loop;
}
return to_skip;
}
int WiFiUDP::read(unsigned char* buf, size_t size)
{
// sizeof(size_t) is architecture dependent
// but we need a 16 bit data type here
uint16_t size_tmp = available();
if (size_tmp == 0) {
return -1;
}
if (size < size_tmp) {
size_tmp = size;
}
for (uint32_t i = 0; i < size_tmp; ++i) {
buf[i] = _buffer[_tail++];
_rcvSize--;
if (_tail == _head) {
// the full buffered data has been read, reset head and tail for next transfer
_tail = _head = 0;
// clear the buffer full flag
_flag &= ~SOCKET_BUFFER_FLAG_FULL;
// setup buffer and buffer size to transfer the remainder of the current packet
// or next received packet
if (hif_small_xfer) {
recvfrom(_socket, _buffer, SOCKET_BUFFER_MTU, 0);
} else {
recvfrom(_socket, _buffer + SOCKET_BUFFER_UDP_HEADER_SIZE, SOCKET_BUFFER_MTU, 0);
}
m2m_wifi_handle_events(NULL);
}
}
return size_tmp;
}
void Client_connection::send(Request_ptr req, Response_handler on_res, const size_t bufsize, timeout_duration timeout)
{
Expects(available());
req_ = std::move(req);
on_response_ = std::move(on_res);
Expects(on_response_ != nullptr);
timeout_dur_ = timeout;
if(timeout_dur_ > timeout_duration::zero())
timer_.restart(timeout_dur_);
// if the stream is not established, send the request when connected
if(not stream_->is_connected())
{
stream_->on_connect([this, bufsize](auto&)
{
this->send_request(bufsize);
});
}
else {
send_request(bufsize);
}
}
void CachedImage::download()
{
if (_url.isEmpty() || isDownloading())
return;
if (_available)
{
emit available();
return;
}
if (_headReply)
_headReply->abort();
_reply = _man->web()->get(QNetworkRequest(_url));
Q_TEST(connect(_reply, SIGNAL(finished()), this, SLOT(_saveData())));
Q_TEST(connect(_reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(_changeBytes(qint64,qint64))));
Q_TEST(connect(_reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(_printError(QNetworkReply::NetworkError))));
Q_TEST(connect(_reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(_printErrors(QList<QSslError>))));
emit downloadingChanged();
}
// -------------------------------------------------------------
int FlexCAN::read(CAN_message_t &msg)
{
unsigned long int startMillis;
startMillis = msg.timeout? millis() : 0;
while( !available() ) {
if ( !msg.timeout || (msg.timeout<=(millis()-startMillis)) ) {
// early EXIT nothing here
return 0;
}
yield();
}
// get identifier and dlc
msg.len = FLEXCAN_get_length(FLEXCAN0_MBn_CS(rxb));
msg.req = (FLEXCAN0_MBn_CS(rxb) & FLEXCAN_MB_CS_RTR)? 1:0;
msg.ext = (FLEXCAN0_MBn_CS(rxb) & FLEXCAN_MB_CS_IDE)? 1:0;
msg.id = (FLEXCAN0_MBn_ID(rxb) & FLEXCAN_MB_ID_EXT_MASK);
if(!msg.ext) {
msg.id >>= FLEXCAN_MB_ID_STD_BIT_NO;
}
//0 for non-blocking (returns immediately), -1 for infinite blocking
/*virtual*/ int USBSerialStream::read(uint8_t* buf, size_t* pLength, size_t maxLength, uint32_t timeout/*=osWaitForever*/)
{
DBG("Trying to read at most %d chars", maxLength);
int ret = waitAvailable(timeout);
if(ret)
{
WARN("Error %d while waiting for incoming data", ret);
return ret;
}
int a = available(); //Prevent macro issues
int readLen = MIN( a, maxLength );
*pLength = readLen;
setupReadableISR(false);
while(readLen--)
{
m_inBuf.dequeue(buf);
buf++;
}
setupReadableISR(true);
DBG("Read %d chars successfully", *pLength);
return OK;
}
/**
* Push Method: push the input value into the queue.\n
* If fixedsize has been set to \p true, this method may
* return false. This means EWOULDBLOCK
* and the call should be retried.
*
* \param data Data to be pushed in the buffer
* \return \p false if \p fixedsize is set to \p true OR if \p data is NULL
* OR if there is not a buffer to write to.
*
* \return \p true if the push succedes.
*/
inline bool push(void * const data) {
/* NULL values cannot be pushed in the queue */
if (!data || !buf_w) return false;
// If fixedsize has been set to \p true, this method may
// return false. This means EWOULDBLOCK
if (!available()) {
if (fixedsize) return false;
// try to get a new buffer
INTERNAL_BUFFER_T * t = pool.next_w(size);
assert(t); //if (!t) return false; // EWOULDBLOCK
buf_w = t;
in_use_buffers++;
#if defined(UBUFFER_STATS)
atomic_long_inc(&numBuffers);
#endif
}
//DBG(assert(buf_w->push(data)); return true;);
buf_w->push(data);
return true;
}
void pr_mtop(FILE *fp,int indent,const char *title,gmx_mtop_t *mtop,
gmx_bool bShowNumbers)
{
int mt,mb;
if (available(fp,mtop,indent,title)) {
indent=pr_title(fp,indent,title);
(void) pr_indent(fp,indent);
(void) fprintf(fp,"name=\"%s\"\n",*(mtop->name));
pr_int(fp,indent,"#atoms",mtop->natoms);
for(mb=0; mb<mtop->nmolblock; mb++) {
pr_molblock(fp,indent,"molblock",&mtop->molblock[mb],mb,
mtop->moltype,bShowNumbers);
}
pr_ffparams(fp,indent,"ffparams",&(mtop->ffparams),bShowNumbers);
pr_atomtypes(fp,indent,"atomtypes",&(mtop->atomtypes),bShowNumbers);
for(mt=0; mt<mtop->nmoltype; mt++) {
pr_moltype(fp,indent,"moltype",&mtop->moltype[mt],mt,
&mtop->ffparams,bShowNumbers);
}
pr_groups(fp,indent,"groups",&mtop->groups,bShowNumbers);
}
}
uint8_t EthernetClient::connected()
{
int rc;
uint8_t val;
if (available() > 0)
return 1;
if (sws == NULL) return 0;
if (sws->_sock == SWS_INVALID_SOCKET)
return 0;
rc = SWS_recv(sws->_sock, &val, 1, 0);
if (rc == 0)
return 0;
if (rc > 0) {
_RegBuf = val;
_RegLen = 1;
}
return 1;
}
/**
* Read one byte from the ring buffer with a timeout (~ in ms)
*
*/
static inline uint8_t read_char(unsigned char &byte, uint16_t timeout = 0) {
uint16_t i = 0;
uint8_t j = 0;
// Hack for timeout
if (timeout > 0)
timeout *= 26;
while (!available()) {
if (timeout > 0) {
if (i > timeout)
return READ_TIMEOUT;
if (j == 0)
i++;
j++;
}
}
byte = rx_buffer_.buffer[rx_buffer_.tail];
rx_buffer_.tail = (rx_buffer_.tail + 1) % RX_BUFFER_SIZE;
return READ_SUCCESS;
}
void pr_ivecs(FILE *fp, int indent, const char *title, const ivec vec[], int n, gmx_bool bShowNumbers)
{
int i, j;
if (available(fp, vec, indent, title))
{
indent = pr_title_nxn(fp, indent, title, n, DIM);
for (i = 0; i < n; i++)
{
pr_indent(fp, indent);
fprintf(fp, "%s[%d]={", title, bShowNumbers ? i : -1);
for (j = 0; j < DIM; j++)
{
if (j != 0)
{
fprintf(fp, ", ");
}
fprintf(fp, "%d", vec[i][j]);
}
fprintf(fp, "}\n");
}
}
}
void pr_rvecs_len(FILE *fp, int indent, const char *title, const rvec vec[], int n)
{
int i, j;
if (available(fp, vec, indent, title))
{
indent = pr_title_nxn(fp, indent, title, n, DIM);
for (i = 0; i < n; i++)
{
pr_indent(fp, indent);
fprintf(fp, "%s[%5d]={", title, i);
for (j = 0; j < DIM; j++)
{
if (j != 0)
{
fprintf(fp, ", ");
}
fprintf(fp, "%12.5e", vec[i][j]);
}
fprintf(fp, "} len=%12.5e\n", norm(vec[i]));
}
}
}
void pr_mtop(FILE *fp, int indent, const char *title, const gmx_mtop_t *mtop,
gmx_bool bShowNumbers)
{
int mt, mb, j;
if (available(fp, mtop, indent, title))
{
indent = pr_title(fp, indent, title);
pr_indent(fp, indent);
fprintf(fp, "name=\"%s\"\n", *(mtop->name));
pr_int(fp, indent, "#atoms", mtop->natoms);
pr_int(fp, indent, "#molblock", mtop->nmolblock);
for (mb = 0; mb < mtop->nmolblock; mb++)
{
pr_molblock(fp, indent, "molblock", &mtop->molblock[mb], mb, mtop->moltype);
}
pr_str(fp, indent, "bIntermolecularInteractions",
gmx::boolToString(mtop->bIntermolecularInteractions));
if (mtop->bIntermolecularInteractions)
{
for (j = 0; (j < F_NRE); j++)
{
pr_ilist(fp, indent, interaction_function[j].longname,
mtop->ffparams.functype,
&mtop->intermolecular_ilist[j], bShowNumbers);
}
}
pr_ffparams(fp, indent, "ffparams", &(mtop->ffparams), bShowNumbers);
pr_atomtypes(fp, indent, "atomtypes", &(mtop->atomtypes), bShowNumbers);
for (mt = 0; mt < mtop->nmoltype; mt++)
{
pr_moltype(fp, indent, "moltype", &mtop->moltype[mt], mt,
&mtop->ffparams, bShowNumbers);
}
pr_groups(fp, indent, &mtop->groups, bShowNumbers);
}
}
/*!
* This method reads and empties the input buffer of `_dataStream`.
* It continues until it finds the specified prompt or until
* the specified amount of time has elapsed.
* It attempts to output the data it reads to `_diagStream`.
* @param prompt The prompt to read until.
* @param timeMS The time limit in milliseconds.
* @return `true` if it found the specified prompt within the time
* limit, otherwise `false`.
*/
bool Sodaq_WifiBee::skipTillPrompt(const char* prompt, const uint32_t timeMS)
{
if (!_dataStream) {
return false;
}
bool result = false;
uint32_t startTS = millis();
size_t index = 0;
size_t promptLen = strlen(prompt);
while (!timedOut32(startTS, timeMS)) {
if (available()) {
char c = read();
diagPrint(c);
if (c == prompt[index]) {
index++;
if (index == promptLen) {
result = true;
break;
}
}
else {
index = 0;
}
}
else {
_delay(10);
}
}
return result;
}
void pr_ilist(FILE *fp,int indent,const char *title,
t_functype *functype,t_ilist *ilist, gmx_bool bShowNumbers)
{
int i,j,k,type,ftype;
t_iatom *iatoms;
if (available(fp,ilist,indent,title) && ilist->nr > 0)
{
indent=pr_title(fp,indent,title);
(void) pr_indent(fp,indent);
fprintf(fp,"nr: %d\n",ilist->nr);
if (ilist->nr > 0) {
(void) pr_indent(fp,indent);
fprintf(fp,"iatoms:\n");
iatoms=ilist->iatoms;
for (i=j=0; i<ilist->nr;) {
#ifndef DEBUG
(void) pr_indent(fp,indent+INDENT);
type=*(iatoms++);
ftype=functype[type];
(void) fprintf(fp,"%d type=%d (%s)",
bShowNumbers?j:-1,bShowNumbers?type:-1,
interaction_function[ftype].name);
j++;
for (k=0; k<interaction_function[ftype].nratoms; k++)
(void) fprintf(fp," %u",*(iatoms++));
(void) fprintf(fp,"\n");
i+=1+interaction_function[ftype].nratoms;
#else
fprintf(fp,"%5d%5d\n",i,iatoms[i]);
i++;
#endif
}
}
}
}
void pr_idef(FILE *fp,int indent,const char *title,t_idef *idef, gmx_bool bShowNumbers)
{
int i,j;
if (available(fp,idef,indent,title)) {
indent=pr_title(fp,indent,title);
(void) pr_indent(fp,indent);
(void) fprintf(fp,"atnr=%d\n",idef->atnr);
(void) pr_indent(fp,indent);
(void) fprintf(fp,"ntypes=%d\n",idef->ntypes);
for (i=0; i<idef->ntypes; i++) {
(void) pr_indent(fp,indent+INDENT);
(void) fprintf(fp,"functype[%d]=%s, ",
bShowNumbers?i:-1,
interaction_function[idef->functype[i]].name);
pr_iparams(fp,idef->functype[i],&idef->iparams[i]);
}
(void) pr_real(fp,indent,"fudgeQQ",idef->fudgeQQ);
for(j=0; (j<F_NRE); j++)
pr_ilist(fp,indent,interaction_function[j].longname,
idef->functype,&idef->il[j],bShowNumbers);
}
}
VavailabilityType OptSchedule::optScheduleToVavail()
{
VavailabilityType::components_type components;
ArrayOfVavailabilityContainedComponents::available_sequence asequence;
vector<tavailable>::iterator itr;
for (itr = m_vavailability.begin(); itr != m_vavailability.end(); itr++)
{
AvailableType::properties_type properties((*itr).get_dtstart(), (*itr).get_duration());
ArrayOfVavailabilityContainedComponents::available_type available(properties);
asequence.push_back(available);
}
components.available(asequence);
VavailabilityType vavail(components);
return vavail;
}
void TwoWire::onService(void)
{
if ( sercom->isSlaveWIRE() )
{
//Received data
if(sercom->isDataReadyWIRE())
{
//Store data
rxBuffer.store_char(sercom->readDataWIRE());
//Stop or Restart detected
if(sercom->isStopDetectedWIRE() || sercom->isRestartDetectedWIRE())
{
//Calling onReceiveCallback, if exists
if(onReceiveCallback)
{
onReceiveCallback(available());
}
}
}
//Address Match
if(sercom->isAddressMatch())
{
//Is a request ?
if(sercom->isMasterReadOperationWIRE())
{
//Calling onRequestCallback, if exists
if(onRequestCallback)
{
onRequestCallback();
}
}
}
}
}
int HttpClient::skipResponseHeaders()
{
isChunk = 0;
header_line = "";
// Just keep reading until we finish reading the headers or time out
unsigned long timeoutStart = millis();
// Whilst we haven't timed out & haven't reached the end of the headers
while ((!endOfHeadersReached()) &&
( (millis() - timeoutStart) < iHttpResponseTimeout ))
{
if (available())
{
(void)readHeader();
// We read something, reset the timeout counter
timeoutStart = millis();
}
else
{
// We haven't got any data, so let's pause to allow some to
// arrive
delay(kHttpWaitForDataDelay);
}
}
if (endOfHeadersReached())
{
// Success
return HTTP_SUCCESS;
}
else
{
// We must've timed out
return HTTP_ERROR_TIMED_OUT;
}
}
int MiLightRadio::begin()
{
int retval = _pl1167.open();
if (retval < 0) {
return retval;
}
retval = _pl1167.setCRC(true);
if (retval < 0) {
return retval;
}
retval = _pl1167.setPreambleLength(3);
if (retval < 0) {
return retval;
}
retval = _pl1167.setTrailerLength(4);
if (retval < 0) {
return retval;
}
retval = _pl1167.setSyncword(0x147A, 0x258B);
if (retval < 0) {
return retval;
}
retval = _pl1167.setMaxPacketLength(8);
if (retval < 0) {
return retval;
}
available();
return 0;
}
int Me_Bluetooth::setName(String name)
{
int isSuccess = 0;
String recvBuf;
char recvChar;
String cmd("AT+NAME");
cmd += name;
cmd += '\r';
cmd += '\n';
int cmdLen = cmd.length();
for(int i = 0; i < cmdLen; i++)
{
swSerial.write(cmd[i]);
}
delay(100);
int len = 0;
if(len = available())
{
for(int i = 0; i < len; i++)
{
recvChar = read();
//Serial.print(recvChar);
recvBuf += recvChar;
}
if(recvBuf.indexOf("OK") != -1)
{
isSuccess= 1;
}
}
return isSuccess;
}
void BlueTooth::receiveCommand()
{
uint8_t buf[10];
if(!m_lastConnectStatus || !available())
return;
size_t amt = read(buf, 10);
#ifdef DEBUG_BT
printf("BT: got %u byte(s): ", amt);
#endif
for(size_t i = 0; i < amt; i++)
{
uint8_t b = buf[i];
#ifdef DEBUG_BT
printf("%x ", b);
#endif
if(!m_inPacket) {
if(buf[i] == '\e') {
#ifdef DEBUG_BT
printf("Entering packet\n");
#endif
m_inPacket = true;
m_pktPtr = 0;
}
else
{
#ifdef DEBUG_BT
printf("[stray %02x]", b);
#endif
}
continue;
}
// Blocks until a valid message is received
void RHGenericDriver::waitAvailable()
{
while (!available())
YIELD;
}
