const Point2DArray &PointGraph::getProcessedData() const {
if(m_dataProcessed) {
return m_processedData;
}
if(getParam().m_rollAvgSize <= 1) {
m_processedData = m_pointArray;
} else {
m_processedData.clear();
QueueList<double> queue;
double sum = 0;
const size_t maxQueueSize = getParam().m_rollAvgSize;
const size_t n = m_pointArray.size();
for(size_t i = 0; i < n; i++) {
if(queue.size() == maxQueueSize) {
sum -= queue.get();
}
queue.put(m_pointArray[i].y);
sum += m_pointArray[i].y;
m_processedData.add(Point2D(m_pointArray[i].x,sum / queue.size()));
}
}
m_dataProcessed = true;
return m_processedData;
}
void initMenuItems()
{
menuItem changeHour = {1, "Change hour"};
menuItems.push(changeHour);
menuItem test = {2, "Start LED time"};
menuItems.push(test);
menuItem test2 = {3, "Stop LED time"};
menuItems.push(test2);
// Complete the queue with NULL element to get a modulo
// of the line number
menuItem nullItem = {0, NULL};
for (int i = 0; i < menuItems.count()%NUMBER_OF_MENU_LINES; i++) {
menuItems.push(nullItem);
}
}
void bfs()
{
QueueList<Node*> mQ;
mQ.enQueue(root);
Node* r;
while (!mQ.isEmpty()) //breadth-first traversal,while the queue is not empty,travel the queue's head node;
{
r = mQ.deQueue();
cout << r->data << " ";
for (Node* p = r -> child; p; p = p -> bro)
{
mQ.enQueue(p);
}
}
cout << endl;
}
void Normalize::normalizeQueueGetConfigReplyV1() {
Header *hdr = header();
size_t length = hdr->length();
if (length < sizeof(QueueGetConfigReply)) {
markInputInvalid("QueueGetConfigReply is too short");
return;
}
if (hdr->version() == OFP_VERSION_1) {
// Convert port number to 32-bits -- only for OpenFlow 1.0.
UInt8 *ptr = buf_.mutableData() + sizeof(Header);
PortNumber port = PortNumber::fromV1(*Big16_cast(ptr));
std::memcpy(ptr, &port, sizeof(port));
}
// Convert QueueV1 to Queue.
ByteRange data = SafeByteRange(buf_.mutableData(), buf_.size(),
sizeof(QueueGetConfigReply));
deprecated::QueueV1Range queues{data};
Validation context;
if (!queues.validateInput(&context)) {
markInputInvalid("QueueGetConfigReply has invalid queues");
return;
}
QueueList newQueues;
for (auto &queue : queues) {
QueueBuilder newQueue{queue};
newQueues.add(newQueue);
}
// When converting to the regular `Queue` structure, we may exceed the max
// message size of 65535.
if (newQueues.size() > 65535 - sizeof(QueueGetConfigReply)) {
markInputTooBig("QueueGetConfigReply is too big");
return;
}
buf_.replace(data.begin(), data.end(), newQueues.data(), newQueues.size());
}
bool isCompBinTree()
{
QueueList<BinTree*> mQ;
BinTree* root = this;
mQ.enQueue(root);
bool flag = false;
while (!mQ.isEmpty()) //breadth-first traversal,while the queue is not empty,travel the queue's head node;
{
root = mQ.deQueue();
if (!flag && !(root -> ls && root -> rs))
{
if (!root -> ls && root -> rs)
{
return false;
}
flag = true;
}
if (flag && (root -> ls || root -> rs))
{
return false;
}
if (root -> ls)
{
mQ.enQueue(root -> ls);
}
if (root -> rs)
{
mQ.enQueue(root -> rs);
}
}
}
void menuState()
{
menuItem tempItem;
for (int i = 0; i < NUMBER_OF_MENU_LINES; i++) {
tempItem = menuItems.pop();
if (tempItem.message != NULL) {
lcd.setCursor(0,i);
lcd.print(i+1);
lcd.print(tempItem.message);
}
menuItems.push(tempItem);
}
lcd.setCursor(0,3);
if (menuItems.count() > NUMBER_OF_MENU_LINES) {
lcd.print("Next : * Back : 0");
}
else{
lcd.print("Back : #");
}
}
int TaskManager::executeTasksQueue()
{
int executedTasksCount = 0;
QueueList<TaskManagerRecord*>* fromQueue;
QueueList<TaskManagerRecord*>* toQueue;
if( !tasksQueueA->isEmpty() )
{
fromQueue = tasksQueueA;
toQueue = tasksQueueB;
}
else
{
fromQueue = tasksQueueB;
toQueue = tasksQueueA;
}
while( !fromQueue->isEmpty() )
{
TaskManagerRecord* taskManagerTaskRecord = fromQueue->pop();
if( taskManagerTaskRecord->taskManagerScheduler->canExecute() )
{
taskManagerTaskRecord->runnable->run();
executedTasksCount++;
}
if( taskManagerTaskRecord->taskManagerScheduler->canRemoveFromTaskManager() )
delete( taskManagerTaskRecord );
else
toQueue->push( taskManagerTaskRecord );
}
return executedTasksCount;
}
void setup2( Print& p , OneWire* oneWire )
{
// ---------------
analogReference( DEFAULT );
// ---------------
//TaskManagerSchedulerOneExecution* taskSchedulerOneExecution = new TaskManagerSchedulerOneExecution();
//TaskManagerMemoryConfigurator* taskMemoryConfFreeRunnable = new TaskManagerMemoryConfigurator( false , true , false );
//TaskManagerMemoryConfigurator* taskMemoryConfFreeSchedulerAndRunnable = new TaskManagerMemoryConfigurator( false , true , false );
//TaskManagerSchedulerOneExecution taskSchedulerOneExecution();
//TaskManagerMemoryConfigurator taskMemoryConfOnlyFreeRunnable( false , true , false );
// ---------------
/*{
QueueList<unsigned long>* queue = new QueueList<unsigned long>();
queue->push( 200 );
TaskManagerSchedulerTimeIntervals* taskScheduler = new TaskManagerSchedulerTimeIntervals( queue , true , true );
uint8_t alarmInputPin = 22;//0;
uint8_t sabotageInputPin = 23;//1;
uint8_t ledDigitalPin = 7;
uint8_t buzzerDigitalPin = 8;
unsigned long alarmOffTimeFromLastMotionDetection = 5 * 1000;
OptexMX40PTCheckRunnable* runnable = new OptexMX40PTCheckRunnable( p , taskManager , alarmInputPin , sabotageInputPin , ledDigitalPin , buzzerDigitalPin , alarmOffTimeFromLastMotionDetection );
taskManager->addTask( taskMemoryConfFreeSchedulerAndRunnable , taskScheduler , runnable );
}*/
// ---------------
/*{
QueueList<unsigned long>* queue = new QueueList<unsigned long>();
queue->push( 1000 );
queue->push( 10 );
TaskManagerSchedulerTimeIntervals* taskScheduler = new TaskManagerSchedulerTimeIntervals( queue , true , true );
uint8_t ledDigitalPin = 13;
PinHighLowRunnable* runnable = new PinHighLowRunnable( ledDigitalPin , false );
taskManager->addTask( true , true , taskScheduler , runnable );
}*/
// ---------------
/*
{
char prefix1[] = "setupSDcard:";
p << prefix1 << "Initializing SD card..." << endl;
uint8_t chipSelect = SS_PIN;
SdFat sd;
char name[] = "APPEND.TXT";
if (!sd.init(SPI_HALF_SPEED, chipSelect))
{
p << prefix1 << "Problem while initializing SD :(" << endl;
}
else
{
p << prefix1 << "SD initialized :)" << endl;
ofstream sdout(name, ios::out | ios::app);
if (!sdout)
{
p << prefix1 << "Problem while oppening file on SD card :(" << endl;
}
else
{
p << prefix1 << "File on SD card oppened :)" << endl;
sdout.close();
}
}
}*/
// ---------------
{
char prefix1[] = "setupSDcard:";
p << prefix1 << "Initializing SD card BEGIN..." << endl;
uint8_t chipSelect = 10;
pinMode( chipSelect , OUTPUT );
if (!SD.begin(chipSelect))
{
p << prefix1 << "Problem while initializing SD :(" << endl;
}
else
{
p << prefix1 << "SD initialized :)" << endl;
}
p << prefix1 << "Initializing SD card END..." << endl;
}
// ---------------
{
QueueList<unsigned long>* queue = new QueueList<unsigned long>();
queue->push( 1000 );
TaskManagerSchedulerTimeIntervals* taskScheduler = new TaskManagerSchedulerTimeIntervals( queue , true , true );
CheckDallasDS18B20TemperatureRunnable* runnable = new CheckDallasDS18B20TemperatureRunnable( oneWire , p );
taskManager->addTask( true , true , taskScheduler , runnable );
}
// ---------------
}
