void Publication::processPublishQueue()
{
V_SerializedMessage queue;
{
boost::mutex::scoped_lock lock(publish_queue_mutex_);
if (dropped_)
{
return;
}
queue.insert(queue.end(), publish_queue_.begin(), publish_queue_.end());
publish_queue_.clear();
}
if (queue.empty())
{
return;
}
V_SerializedMessage::iterator it = queue.begin();
V_SerializedMessage::iterator end = queue.end();
for (; it != end; ++it)
{
enqueueMessage(*it);
}
}
/*
* See header file
*/
void store_impact(void)
{
uint16_t i;
pcSerial.printf("\nImpact complete:\nStarttime: %d\n", impact->starttime);
pcSerial.printf("Samples: %d\nPeaks: %d\nMaximum: %d\n***********\n", impact->sample_count, impact->peak_count, impact->max_amplitude);
// samples
for(i = 0; i < impact->sample_count; i++){
pcSerial.printf("%10u, %5hd; ", impact->starttime + i, impact->samples[i]);
}
pcSerial.printf("\n\n");
// peaks
for(i = 0; i < impact->peak_count + 3; i++){
pcSerial.printf("%3hu: %10u %5hd\n", i, impact->peaks[i].timestamp, impact->peaks[i].value);
}
pcSerial.printf("\n");
ImpStd_t std;
std.numberOfPkgs = 1;
std.maxPeaks = impact->max_amplitude;
//printf("amplitude %x\n",impact->max_amplitude);
std.timestamp = impact->starttime;
//printf("starttime %x\n",impact->starttime);
std.nrOfPeaks = impact->peak_count;
//printf("peak_count %x\n",impact->peak_count);
std.duration = impact->sample_count;
//printf("sample_count %x\n",impact->sample_count);
enqueueMessage(7,std,0x01,canId,IMPACT_STD_SINGLE);
}
/**
* Public function which makes sure buffered messages are still being read into
* the internal buffer. A compromise between forcing a thread-based implementation
* and blocking on results. This could be placed into a separate thread, but will
* need to be wrapped for thread safety
*/
void Transport::poll()
{
CHECK_THROW_CONFIGURED();
Message* msg = NULL;
while( (msg=rxMessage()) ) {
/* We're not waiting for acks, so drop them */
if( ! msg->isData() ) {
++counters[IGNORED_ACK];
delete msg;
continue;
}
// Message is good, queue it.
enqueueMessage(msg);
}
}
/**
* Read data until an ack message is found.
* Any data messages received by this function will be queued.
* @return The next ack message, if one is read.
* Null if no ack message has been read yet.
*/
Message * Transport::getAck()
{
Message * msg = NULL;
while( (msg=rxMessage()) ) {
/* Queue any data messages that turn up */
if( msg->isData() ) {
enqueueMessage(msg);
continue;
}
/* Drop invalid messages */
if( ! msg->isValid() ) {
++counters[INVALID_MSG];
delete msg;
continue;
}
return msg;
}
return NULL;
}
