168 | | static ossieCBR *myCBR; |
169 | | |
170 | | |
171 | | CognitiveEngine::CognitiveEngine() |
172 | | { |
173 | | LOG("Creating Cognitive Engine.\n"); |
174 | | SML_present = false; |
175 | | commandSocketFD = -1; |
176 | | } |
177 | | |
178 | | |
179 | | CognitiveEngine::~CognitiveEngine() |
| 168 | class OSSIE_CE : public CognitiveEngine |
| 169 | { |
| 170 | public: |
| 171 | /*! Default constructor. */ |
| 172 | OSSIE_CE() : CognitiveEngine(){}; |
| 173 | |
| 174 | /*! Default destructor. */ |
| 175 | ~OSSIE_CE(); |
| 176 | |
| 177 | /*! \brief Preferred constructor. |
| 178 | * |
| 179 | * Overloaded constructor that creates a cognitive engine object and |
| 180 | * connects it to either the shell or an SML, depening on the SML bool. |
| 181 | * |
| 182 | * The 'numFields' parameter sets how large the parameter, observable, |
| 183 | * and utility arrays should be upon instantiation. |
| 184 | */ |
| 185 | OSSIE_CE(const char* serverName, const char* serverPort, \ |
| 186 | const int32_t numFields, const bool SML) \ |
| 187 | : CognitiveEngine(serverName, serverPort, numFields, SML){} |
| 188 | |
| 189 | |
| 190 | void RegisterServices(); |
| 191 | void DeregisterServices(); |
| 192 | |
| 193 | /*! \brief Request that the CE optimize a set of parameters. |
| 194 | * |
| 195 | * Find the most optimal set of transmission parameters given certain |
| 196 | * observables and possibly a service if the SML component is present |
| 197 | * and active. */ |
| 198 | Parameter *GetSolution(Observable *observables, \ |
| 199 | Parameter *currentParameters); |
| 200 | Parameter *GetSolution(Observable *observables, \ |
| 201 | Parameter *currentParameters, std::string service); |
| 202 | |
| 203 | /*! \brief Receive feedback from the radio |
| 204 | * |
| 205 | * Receive a feedback from the radio regarding the performance of a |
| 206 | * certain set of parameters, possibly associated with a service. |
| 207 | * |
| 208 | * Feedback is a single set of performance statistics that is achieved |
| 209 | * corresponding to a specific set of transmission parameters. Feedback |
| 210 | * helps a Cognitive Engine make better future decisions based upon |
| 211 | * more accurate performance statistics. |
| 212 | */ |
| 213 | void ReceiveFeedback(Observable *observables,Parameter *parameters); |
| 214 | void ReceiveFeedback(Observable *observables, Parameter *parameters, \ |
| 215 | std::string service); |
| 216 | |
| 217 | |
| 218 | /*! \brief Initialize the CE and prepare it for operation. |
| 219 | * |
| 220 | * BuildCognitiveEngine performs the CE implementation specific work |
| 221 | * that defines the internals of a CE. For example, a CBR CE engine |
| 222 | * would build the case-base reasoner or create the database, a neural |
| 223 | * network based CE may perform the initial training, a GA based CE |
| 224 | * may build the chromosome structure. |
| 225 | */ |
| 226 | void BuildCognitiveEngine(); |
| 227 | |
| 228 | /*! \brief Each of these functions responds to a specific command. |
| 229 | * |
| 230 | * These functions are left principally un-implemented. It is the duty |
| 231 | * of child classes to implement these functions, as they define the |
| 232 | * cognitive engine's functionality. |
| 233 | */ |
| 234 | void PerformUpdatePerformance(); |
| 235 | void PerformRequestOptimizationService(); |
| 236 | void PerformRequestOptimization(); |
| 237 | void PerformQueryComponentType(); |
| 238 | void PerformConnectSML(); |
| 239 | void PerformDisconnectSML(); |
| 240 | void PerformResetEngineCognitive(); |
| 241 | void PerformShutdownEngineCognitive(); |
| 242 | |
| 243 | ossieCBR *myCBR; |
| 244 | }; |
| 245 | |
| 246 | |
| 247 | OSSIE_CE::~OSSIE_CE() |
294 | | CognitiveEngine::WaitForSignal() |
295 | | { |
296 | | char buffer[256]; |
297 | | |
298 | | while(true) { |
299 | | memset(buffer, 0, 256); |
300 | | |
301 | | ReadMessage(commandSocketFD, buffer); |
302 | | |
303 | | // TODO this is ugly... is there a better way? Doesn't strcmp compare the |
304 | | // whole string? We only need to compare until we find a single different |
305 | | // byte... |
306 | | // |
307 | | // If we send integer op codes rather than strings, this process will be |
308 | | // MUCH faster since instead of donig string compares we can simply |
309 | | // switch on the integer value... |
310 | | if(strcmp(buffer, "update_performance") == 0) { |
311 | | |
312 | | /* Receive Set of current Parameters */ |
313 | | memset(buffer, 0, 256); |
314 | | ReadMessage(commandSocketFD, buffer); |
315 | | uint32_t numParameters = atoi(buffer); |
316 | | |
317 | | Parameter *p = new Parameter[numParameters]; |
318 | | |
319 | | for(size_t i = 0; i < numParameters; i++) { |
320 | | memset(buffer, 0, 256); |
321 | | ReadMessage(commandSocketFD, buffer); |
322 | | p[i].name = std::string(buffer); |
323 | | |
324 | | memset(buffer, 0, 256); |
325 | | ReadMessage(commandSocketFD, buffer); |
326 | | p[i].value = atof(buffer); |
327 | | } |
328 | | |
329 | | /* Receive Set of Observables */ |
330 | | memset(buffer, 0, 256); |
331 | | ReadMessage(commandSocketFD, buffer); |
332 | | uint32_t numObservables = atoi(buffer); |
333 | | |
334 | | Observable *o = new Observable[numObservables]; |
335 | | |
336 | | for(size_t i = 0; i < numObservables; i++) { |
337 | | memset(buffer, 0, 256); |
338 | | ReadMessage(commandSocketFD, buffer); |
339 | | o[i].name = std::string(buffer); |
340 | | |
341 | | memset(buffer, 0, 256); |
342 | | ReadMessage(commandSocketFD, buffer); |
343 | | o[i].value = atof(buffer); |
344 | | } |
345 | | |
346 | | ReceiveFeedback(o,p); |
347 | | |
348 | | delete [] o; |
349 | | delete [] p; |
350 | | } |
351 | | else if(strcmp(buffer, "request_optimization_service") == 0) { |
352 | | // THIS IS CURRENTLY IN DEMO MODE |
353 | | |
354 | | |
355 | | /* Receive Set of Observables */ |
356 | | LOG("\nCognitive Engine:: Receiving service name\n"); |
357 | | |
358 | | memset(buffer, 0, 256); |
359 | | ReadMessage(commandSocketFD,buffer); |
360 | | LOG("\nCognitive Engine:: Got service name, %s\n", buffer); |
361 | | |
362 | | /* Receive Set of Observables */ |
363 | | LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); |
364 | | |
365 | | memset(buffer, 0, 256); |
366 | | ReadMessage(commandSocketFD,buffer); |
367 | | uint32_t numObservables = atoi(buffer); |
368 | | |
369 | | Observable *o = new Observable[numObservables]; |
370 | | |
371 | | for(size_t i = 0; i < numObservables; i++) { |
372 | | memset(buffer, 0, 256); |
373 | | ReadMessage(commandSocketFD, buffer); |
374 | | o[i].name = std::string(buffer); |
375 | | |
376 | | memset(buffer, 0, 256); |
377 | | ReadMessage(commandSocketFD, buffer); |
378 | | o[i].value = atof(buffer); |
379 | | } |
380 | | |
381 | | /* Receive Set of current Parameters */ |
382 | | LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); |
383 | | |
384 | | memset(buffer, 0, 256); |
385 | | ReadMessage(commandSocketFD, buffer); |
386 | | uint32_t numCurrentParameters = atoi(buffer); |
387 | | |
388 | | Parameter *cp = new Parameter[numCurrentParameters]; |
389 | | |
390 | | for(size_t i = 0; i < numCurrentParameters; i++) { |
391 | | memset(buffer, 0, 256); |
392 | | ReadMessage(commandSocketFD, buffer); |
393 | | cp[i].name = std::string(buffer); |
394 | | |
395 | | memset(buffer, 0, 256); |
396 | | ReadMessage(commandSocketFD, buffer); |
397 | | cp[i].value = atof(buffer); |
398 | | } |
399 | | LOG("Cognitive Engine:: Processing parameters....\n"); |
400 | | |
401 | | //Parameter *solutionSet; |
402 | | |
403 | | //solutionSet = GetSolution(o,cp); |
404 | | |
405 | | // TODO need to actually do something with the observables here |
406 | | |
407 | | LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); |
408 | | char numParametersChar[10]; |
409 | | //char solutionValue[50]; |
410 | | sprintf(numParametersChar, "%i", radioInfo->numParameters); |
411 | | SendMessage(commandSocketFD, numParametersChar); |
412 | | for(size_t i = 0; i < radioInfo->numParameters; i++) { |
413 | | //SendMessage(commandSocketFD, solutionSet[i].name.c_str()); |
414 | | SendMessage(commandSocketFD, "test"); |
415 | | //memset(solutionValue, 0, 50); |
416 | | //sprintf(solutionValue, "%f", solutionSet[i].value); |
417 | | //SendMessage(commandSocketFD, solutionValue); |
418 | | SendMessage(commandSocketFD, "00"); |
419 | | } |
420 | | |
421 | | delete [] o; |
422 | | delete [] cp; |
423 | | } |
424 | | else if(strcmp(buffer, "request_optimization") == 0) { |
425 | | |
426 | | /* Receive Set of Observables */ |
427 | | LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); |
428 | | |
429 | | memset(buffer, 0, 256); |
430 | | ReadMessage(commandSocketFD,buffer); |
431 | | uint32_t numObservables = atoi(buffer); |
432 | | |
433 | | Observable *o = new Observable[numObservables]; |
434 | | |
435 | | for(size_t i = 0; i < numObservables; i++) { |
436 | | memset(buffer, 0, 256); |
437 | | ReadMessage(commandSocketFD, buffer); |
438 | | o[i].name = std::string(buffer); |
439 | | |
440 | | memset(buffer, 0, 256); |
441 | | ReadMessage(commandSocketFD, buffer); |
442 | | o[i].value = atof(buffer); |
443 | | } |
444 | | |
445 | | /* Receive Set of current Parameters */ |
446 | | LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); |
447 | | |
448 | | memset(buffer, 0, 256); |
449 | | ReadMessage(commandSocketFD, buffer); |
450 | | uint32_t numCurrentParameters = atoi(buffer); |
451 | | |
452 | | Parameter *cp = new Parameter[numCurrentParameters]; |
453 | | |
454 | | for(size_t i = 0; i < numCurrentParameters; i++) { |
455 | | memset(buffer, 0, 256); |
456 | | ReadMessage(commandSocketFD, buffer); |
457 | | cp[i].name = std::string(buffer); |
458 | | |
459 | | memset(buffer, 0, 256); |
460 | | ReadMessage(commandSocketFD, buffer); |
461 | | cp[i].value = atof(buffer); |
462 | | } |
463 | | LOG("Cognitive Engine:: Processing parameters....\n"); |
464 | | |
465 | | Parameter *solutionSet; |
466 | | |
467 | | solutionSet = GetSolution(o,cp); |
468 | | |
469 | | // TODO need to actually do something with the observables here |
470 | | |
471 | | LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); |
472 | | char numParametersChar[10]; |
473 | | char solutionValue[50]; |
474 | | sprintf(numParametersChar, "%i", radioInfo->numParameters); |
475 | | SendMessage(commandSocketFD, numParametersChar); |
476 | | for(size_t i = 0; i < radioInfo->numParameters; i++) { |
477 | | SendMessage(commandSocketFD, solutionSet[i].name.c_str()); |
478 | | memset(solutionValue, 0, 50); |
479 | | sprintf(solutionValue, "%f", solutionSet[i].value); |
480 | | SendMessage(commandSocketFD, solutionValue); |
481 | | } |
482 | | |
483 | | delete [] o; |
484 | | delete [] cp; |
485 | | } |
486 | | else if(strcmp(buffer, "query_component_type") == 0) { |
487 | | SendComponentType(); |
488 | | } |
489 | | else if(strcmp(buffer, "connect_sml") == 0) { |
490 | | /* This command implies that we are disconnecting from the shell and |
491 | | * connecting to a SML component. */ |
492 | | char serverName[256]; |
493 | | char serverPort[256]; |
494 | | // TODO is this going to end up being too slow? |
495 | | memset(serverName, 0, 256); |
496 | | memset(serverPort, 0, 256); |
497 | | |
498 | | ReadMessage(commandSocketFD, serverName); |
499 | | ReadMessage(commandSocketFD, serverPort); |
500 | | |
501 | | /* Only continue if we are currently connected to a shell. */ |
502 | | if(!SML_present) { |
503 | | DeregisterComponent(); |
504 | | |
505 | | shutdown(commandSocketFD, 2); |
506 | | close(commandSocketFD); |
507 | | |
508 | | ConnectToRemoteComponent(serverName, serverPort, true); |
509 | | } |
510 | | } |
511 | | else if(strcmp(buffer, "disconnect_sml") == 0) { |
512 | | /* This command implies that we are disconnecting from the SML and |
513 | | * connecting to a shell component. */ |
514 | | char serverName[256]; |
515 | | char serverPort[256]; |
516 | | // TODO is this going to end up being too slow? |
517 | | memset(serverName, 0, 256); |
518 | | memset(serverPort, 0, 256); |
519 | | |
520 | | ReadMessage(commandSocketFD, serverName); |
521 | | ReadMessage(commandSocketFD, serverPort); |
522 | | |
523 | | /* We only want to do this if we are actually connected to an SML |
524 | | * currently. */ |
525 | | if(SML_present) { |
526 | | DeregisterServices(); |
527 | | |
528 | | shutdown(commandSocketFD, 2); |
529 | | close(commandSocketFD); |
530 | | |
531 | | ConnectToRemoteComponent(serverName, serverPort, false); |
532 | | } |
533 | | } |
534 | | else if(strcmp(buffer, "reset_engine_cognitive") == 0) { |
535 | | Reset(); |
536 | | } |
537 | | else if(strcmp(buffer, "shutdown_engine_cognitive") == 0) { |
538 | | Shutdown(); |
539 | | } |
540 | | } |
| 313 | OSSIE_CE::ReceiveFeedback(Observable *observables, Parameter *parameters, \ |
| 314 | std::string service) |
| 315 | { |
| 316 | LOG("Cognitive Engine:: Receiving feedback.\n"); |
636 | | void |
637 | | CognitiveEngine::ReceiveRadioConfiguration() |
638 | | { |
639 | | LOG("Cognitive Engine:: Receiving Radio Configuration.\n"); |
640 | | |
641 | | char buffer[256]; |
642 | | |
643 | | /* Receive Set of Utilities */ |
644 | | memset(buffer, 0, 256); |
645 | | ReadMessage(commandSocketFD, buffer); |
646 | | radioInfo->numUtilities = atoi(buffer); |
647 | | |
648 | | for(size_t i = 0; i < radioInfo->numUtilities; i++) { |
649 | | memset(buffer, 0, 256); |
650 | | ReadMessage(commandSocketFD, buffer); |
651 | | uList[i].name = std::string(buffer); |
652 | | |
653 | | memset(buffer, 0, 256); |
654 | | ReadMessage(commandSocketFD, buffer); |
655 | | uList[i].units = std::string(buffer); |
656 | | |
657 | | memset(buffer, 0, 256); |
658 | | ReadMessage(commandSocketFD, buffer); |
659 | | uList[i].goal = std::string(buffer); |
660 | | |
661 | | memset(buffer, 0, 256); |
662 | | ReadMessage(commandSocketFD, buffer); |
663 | | uList[i].target = atof(buffer); |
664 | | } |
665 | | |
666 | | /* Receive Set of Parameters */ |
667 | | memset(buffer, 0, 256); |
668 | | ReadMessage(commandSocketFD, buffer); |
669 | | radioInfo->numParameters = atoi(buffer); |
670 | | |
671 | | for(size_t i = 0; i < radioInfo->numParameters; i++) { |
672 | | memset(buffer, 0, 256); |
673 | | ReadMessage(commandSocketFD, buffer); |
674 | | pList[i].name = std::string(buffer); |
675 | | |
676 | | memset(buffer, 0, 256); |
677 | | ReadMessage(commandSocketFD, buffer); |
678 | | pList[i].units = std::string(buffer); |
679 | | |
680 | | memset(buffer, 0, 256); |
681 | | ReadMessage(commandSocketFD, buffer); |
682 | | pList[i].min = atof(buffer); |
683 | | |
684 | | memset(buffer, 0, 256); |
685 | | ReadMessage(commandSocketFD, buffer); |
686 | | pList[i].max = atof(buffer); |
687 | | |
688 | | memset(buffer, 0, 256); |
689 | | ReadMessage(commandSocketFD, buffer); |
690 | | pList[i].step = atof(buffer); |
691 | | |
692 | | memset(buffer, 0, 256); |
693 | | ReadMessage(commandSocketFD,buffer); |
694 | | pList[i].numAffects = atoi(buffer); |
695 | | |
696 | | for(size_t j = 0; j < pList[i].numAffects; j++) { |
697 | | memset(buffer, 0, 256); |
698 | | ReadMessage(commandSocketFD,buffer); |
699 | | // TODO for + if{break} = while? |
700 | | for(size_t k = 0; k < radioInfo->numUtilities; k++) { |
701 | | if(uList[k].name == std::string(buffer)) { |
702 | | pList[i].affection_list[j].u = &uList[k]; |
703 | | break; |
704 | | } |
705 | | } |
706 | | |
707 | | memset(buffer, 0, 256); |
708 | | ReadMessage(commandSocketFD, buffer); |
709 | | pList[i].affection_list[j].relation = std::string(buffer); |
710 | | } |
711 | | } |
712 | | |
713 | | /* Receive Set of Observables */ |
714 | | memset(buffer, 0, 256); |
715 | | ReadMessage(commandSocketFD, buffer); |
716 | | radioInfo->numObservables = atoi(buffer); |
717 | | |
718 | | for(size_t i = 0; i < radioInfo->numObservables; i++) { |
719 | | memset(buffer, 0, 256); |
720 | | ReadMessage(commandSocketFD, buffer); |
721 | | oList[i].name = std::string(buffer); |
722 | | |
723 | | memset(buffer, 0, 256); |
724 | | ReadMessage(commandSocketFD, buffer); |
725 | | oList[i].numAffects = atoi(buffer); |
726 | | |
727 | | for(size_t j = 0; j < oList[i].numAffects; j++) { |
728 | | memset(buffer, 0, 256); |
729 | | ReadMessage(commandSocketFD, buffer); |
730 | | // TODO for + if{break} = while? |
731 | | for(size_t k = 0; k < radioInfo->numUtilities; k++) { |
732 | | if(uList[k].name == std::string(buffer)){ |
733 | | oList[i].affection_list[j].u = &uList[k]; |
734 | | break; |
735 | | } |
736 | | } |
737 | | |
738 | | memset(buffer, 0, 256); |
739 | | ReadMessage(commandSocketFD, buffer); |
740 | | oList[i].affection_list[j].relation = std::string(buffer); |
741 | | } |
742 | | } |
743 | | |
744 | | SendMessage(commandSocketFD, "receive_config_ack"); |
745 | | |
746 | | BuildCognitiveEngine(); |
747 | | } |
748 | | |
749 | | void |
750 | | CognitiveEngine::ReceiveExperience() |
751 | | { |
752 | | LOG("Cognitive Engine:: Receiving Experience Report.\n"); |
753 | | char buffer[256]; |
754 | | uint32_t numberExp; |
755 | | |
756 | | /* Receive number of experience entries */ |
757 | | memset(buffer, 0, 256); |
758 | | ReadMessage(commandSocketFD, buffer); |
759 | | numberExp = atoi(buffer); |
760 | | |
761 | | LOG("Cognitive Engine:: Waiting for %i number of entries.\n", numberExp); |
762 | | |
763 | | SendMessage(commandSocketFD, "receive_exp_ack"); |
764 | | } |
| 507 | void |
| 508 | OSSIE_CE::PerformUpdatePerformance() |
| 509 | { |
| 510 | /* Receive Set of current Parameters */ |
| 511 | char buffer[256]; |
| 512 | memset(buffer, 0, 256); |
| 513 | ReadMessage(commandSocketFD, buffer); |
| 514 | uint32_t numParameters = atoi(buffer); |
| 515 | |
| 516 | Parameter *p = new Parameter[numParameters]; |
| 517 | |
| 518 | for(size_t i = 0; i < numParameters; i++) { |
| 519 | memset(buffer, 0, 256); |
| 520 | ReadMessage(commandSocketFD, buffer); |
| 521 | p[i].name = std::string(buffer); |
| 522 | |
| 523 | memset(buffer, 0, 256); |
| 524 | ReadMessage(commandSocketFD, buffer); |
| 525 | p[i].value = atof(buffer); |
| 526 | } |
| 527 | |
| 528 | /* Receive Set of Observables */ |
| 529 | memset(buffer, 0, 256); |
| 530 | ReadMessage(commandSocketFD, buffer); |
| 531 | uint32_t numObservables = atoi(buffer); |
| 532 | |
| 533 | Observable *o = new Observable[numObservables]; |
| 534 | |
| 535 | for(size_t i = 0; i < numObservables; i++) { |
| 536 | memset(buffer, 0, 256); |
| 537 | ReadMessage(commandSocketFD, buffer); |
| 538 | o[i].name = std::string(buffer); |
| 539 | |
| 540 | memset(buffer, 0, 256); |
| 541 | ReadMessage(commandSocketFD, buffer); |
| 542 | o[i].value = atof(buffer); |
| 543 | } |
| 544 | |
| 545 | ReceiveFeedback(o,p); |
| 546 | |
| 547 | delete [] o; |
| 548 | delete [] p; |
| 549 | } |
| 550 | |
| 551 | |
| 552 | void |
| 553 | OSSIE_CE::PerformRequestOptimizationService() |
| 554 | { |
| 555 | /* Receive Set of Observables */ |
| 556 | LOG("\nCognitive Engine:: Receiving service name\n"); |
| 557 | |
| 558 | char buffer[256]; |
| 559 | memset(buffer, 0, 256); |
| 560 | ReadMessage(commandSocketFD,buffer); |
| 561 | LOG("\nCognitive Engine:: Got service name, %s\n", buffer); |
| 562 | |
| 563 | /* Receive Set of Observables */ |
| 564 | LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); |
| 565 | |
| 566 | memset(buffer, 0, 256); |
| 567 | ReadMessage(commandSocketFD,buffer); |
| 568 | uint32_t numObservables = atoi(buffer); |
| 569 | |
| 570 | Observable *o = new Observable[numObservables]; |
| 571 | |
| 572 | for(size_t i = 0; i < numObservables; i++) { |
| 573 | memset(buffer, 0, 256); |
| 574 | ReadMessage(commandSocketFD, buffer); |
| 575 | o[i].name = std::string(buffer); |
| 576 | |
| 577 | memset(buffer, 0, 256); |
| 578 | ReadMessage(commandSocketFD, buffer); |
| 579 | o[i].value = atof(buffer); |
| 580 | } |
| 581 | |
| 582 | /* Receive Set of current Parameters */ |
| 583 | LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); |
| 584 | |
| 585 | memset(buffer, 0, 256); |
| 586 | ReadMessage(commandSocketFD, buffer); |
| 587 | uint32_t numCurrentParameters = atoi(buffer); |
| 588 | |
| 589 | Parameter *cp = new Parameter[numCurrentParameters]; |
| 590 | |
| 591 | for(size_t i = 0; i < numCurrentParameters; i++) { |
| 592 | memset(buffer, 0, 256); |
| 593 | ReadMessage(commandSocketFD, buffer); |
| 594 | cp[i].name = std::string(buffer); |
| 595 | |
| 596 | memset(buffer, 0, 256); |
| 597 | ReadMessage(commandSocketFD, buffer); |
| 598 | cp[i].value = atof(buffer); |
| 599 | } |
| 600 | LOG("Cognitive Engine:: Processing parameters....\n"); |
| 601 | |
| 602 | //Parameter *solutionSet; |
| 603 | |
| 604 | //solutionSet = GetSolution(o,cp); |
| 605 | |
| 606 | // TODO need to actually do something with the observables here |
| 607 | |
| 608 | LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); |
| 609 | char numParametersChar[10]; |
| 610 | //char solutionValue[50]; |
| 611 | sprintf(numParametersChar, "%i", radioInfo->numParameters); |
| 612 | SendMessage(commandSocketFD, numParametersChar); |
| 613 | for(size_t i = 0; i < radioInfo->numParameters; i++) { |
| 614 | //SendMessage(commandSocketFD, solutionSet[i].name.c_str()); |
| 615 | SendMessage(commandSocketFD, "test"); |
| 616 | //memset(solutionValue, 0, 50); |
| 617 | //sprintf(solutionValue, "%f", solutionSet[i].value); |
| 618 | //SendMessage(commandSocketFD, solutionValue); |
| 619 | SendMessage(commandSocketFD, "00"); |
| 620 | } |
| 621 | |
| 622 | delete [] o; |
| 623 | delete [] cp; |
| 624 | } |
| 625 | |
| 626 | |
| 627 | void |
| 628 | OSSIE_CE::PerformRequestOptimization() |
| 629 | { |
| 630 | /* Receive Set of Observables */ |
| 631 | LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); |
| 632 | |
| 633 | char buffer[256]; |
| 634 | memset(buffer, 0, 256); |
| 635 | ReadMessage(commandSocketFD,buffer); |
| 636 | uint32_t numObservables = atoi(buffer); |
| 637 | |
| 638 | Observable *o = new Observable[numObservables]; |
| 639 | |
| 640 | for(size_t i = 0; i < numObservables; i++) { |
| 641 | memset(buffer, 0, 256); |
| 642 | ReadMessage(commandSocketFD, buffer); |
| 643 | o[i].name = std::string(buffer); |
| 644 | |
| 645 | memset(buffer, 0, 256); |
| 646 | ReadMessage(commandSocketFD, buffer); |
| 647 | o[i].value = atof(buffer); |
| 648 | } |
| 649 | |
| 650 | /* Receive Set of current Parameters */ |
| 651 | LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); |
| 652 | |
| 653 | memset(buffer, 0, 256); |
| 654 | ReadMessage(commandSocketFD, buffer); |
| 655 | uint32_t numCurrentParameters = atoi(buffer); |
| 656 | |
| 657 | Parameter *cp = new Parameter[numCurrentParameters]; |
| 658 | |
| 659 | for(size_t i = 0; i < numCurrentParameters; i++) { |
| 660 | memset(buffer, 0, 256); |
| 661 | ReadMessage(commandSocketFD, buffer); |
| 662 | cp[i].name = std::string(buffer); |
| 663 | |
| 664 | memset(buffer, 0, 256); |
| 665 | ReadMessage(commandSocketFD, buffer); |
| 666 | cp[i].value = atof(buffer); |
| 667 | } |
| 668 | LOG("Cognitive Engine:: Processing parameters....\n"); |
| 669 | |
| 670 | Parameter *solutionSet; |
| 671 | |
| 672 | solutionSet = GetSolution(o,cp); |
| 673 | |
| 674 | // TODO need to actually do something with the observables here |
| 675 | |
| 676 | LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); |
| 677 | char numParametersChar[10]; |
| 678 | char solutionValue[50]; |
| 679 | sprintf(numParametersChar, "%i", radioInfo->numParameters); |
| 680 | SendMessage(commandSocketFD, numParametersChar); |
| 681 | for(size_t i = 0; i < radioInfo->numParameters; i++) { |
| 682 | SendMessage(commandSocketFD, solutionSet[i].name.c_str()); |
| 683 | memset(solutionValue, 0, 50); |
| 684 | sprintf(solutionValue, "%f", solutionSet[i].value); |
| 685 | SendMessage(commandSocketFD, solutionValue); |
| 686 | } |
| 687 | |
| 688 | delete [] o; |
| 689 | delete [] cp; |
| 690 | } |
| 691 | |
| 692 | |
| 693 | void |
| 694 | OSSIE_CE::PerformQueryComponentType() |
| 695 | { |
| 696 | SendComponentType(); |
| 697 | } |
| 698 | |
| 699 | |
| 700 | void |
| 701 | OSSIE_CE::PerformConnectSML() |
| 702 | { |
| 703 | /* This command implies that we are disconnecting from the shell and |
| 704 | * connecting to a SML component. */ |
| 705 | char serverName[256]; |
| 706 | char serverPort[256]; |
| 707 | // TODO is this going to end up being too slow? |
| 708 | memset(serverName, 0, 256); |
| 709 | memset(serverPort, 0, 256); |
| 710 | |
| 711 | ReadMessage(commandSocketFD, serverName); |
| 712 | ReadMessage(commandSocketFD, serverPort); |
| 713 | |
| 714 | /* Only continue if we are currently connected to a shell. */ |
| 715 | if(!SML_present) { |
| 716 | DeregisterComponent(); |
| 717 | |
| 718 | shutdown(commandSocketFD, 2); |
| 719 | close(commandSocketFD); |
| 720 | |
| 721 | ConnectToRemoteComponent(serverName, serverPort, true); |
| 722 | } |
| 723 | } |
| 724 | |
| 725 | |
| 726 | void |
| 727 | OSSIE_CE::PerformDisconnectSML() |
| 728 | { |
| 729 | /* This command implies that we are disconnecting from the SML and |
| 730 | * connecting to a shell component. */ |
| 731 | char serverName[256]; |
| 732 | char serverPort[256]; |
| 733 | // TODO is this going to end up being too slow? |
| 734 | memset(serverName, 0, 256); |
| 735 | memset(serverPort, 0, 256); |
| 736 | |
| 737 | ReadMessage(commandSocketFD, serverName); |
| 738 | ReadMessage(commandSocketFD, serverPort); |
| 739 | |
| 740 | /* We only want to do this if we are actually connected to an SML |
| 741 | * currently. */ |
| 742 | if(SML_present) { |
| 743 | DeregisterServices(); |
| 744 | |
| 745 | shutdown(commandSocketFD, 2); |
| 746 | close(commandSocketFD); |
| 747 | |
| 748 | ConnectToRemoteComponent(serverName, serverPort, false); |
| 749 | } |
| 750 | } |
| 751 | |
| 752 | |
| 753 | void |
| 754 | OSSIE_CE::PerformResetEngineCognitive() |
| 755 | { |
| 756 | Reset(); |
| 757 | } |
| 758 | |
| 759 | |
| 760 | void |
| 761 | OSSIE_CE::PerformShutdownEngineCognitive() |
| 762 | { |
| 763 | Shutdown(); |
| 764 | } |
| 765 | |