Changeset 222

Show
Ignore:
Timestamp:
03/30/09 21:38:53 (15 years ago)
Author:
trnewman
Message:

Added libvtcross functionality. Made socketcomm a little more robust. Added libvtcross demo application to illustrate how to use the lib.

Location:
vtcross/trunk/src
Files:
1 added
9 modified

Legend:

Unmodified
Added
Removed

  • vtcross/trunk/src/cognitive_engines/CognitiveEngine.cpp

    r218 r222  
    8888{ 
    8989    char buffer[256]; 
     90    uint16_t i; 
    9091 
    9192    while(true) { 
    … …  
    102103        // switch on the integer value... 
    103104        if(strcmp(buffer, "get_solution") == 0) { 
    104          
    105  
     105             
     106            /* Receive Set of Observables */ 
     107                        LOG("Cognitive Engine:: Receiving observables.\n"); 
     108 
     109            memset(buffer, 0, 256); 
     110            ReadMessage(commandSocketFD,buffer); 
     111            uint32_t numObservables = atoi(buffer); 
     112    
     113            Observable * o = new Observable[numObservables]; 
     114  
     115            for (i = 0; i < numObservables; i++){ 
     116                memset(buffer, 0, 256); 
     117                ReadMessage(commandSocketFD,buffer); 
     118                o[i].name = std::string(buffer); 
     119     
     120                memset(buffer, 0, 256); 
     121                ReadMessage(commandSocketFD,buffer); 
     122                o[i].value = atof(buffer); 
     123            }   
     124 
     125                        LOG("Cognitive Engine:: Sending Optimal Parameters.\n"); 
     126            SendMessage(commandSocketFD,"1"); 
     127            SendMessage(commandSocketFD,"txPower"); 
     128            SendMessage(commandSocketFD,"10"); 
    106129        } 
    107130        else if(strcmp(buffer, "query_component_type") == 0) { 
    … …  
    266289        memset(buffer, 0, 256); 
    267290        ReadMessage(commandSocketFD,buffer); 
    268         LOG("socket_comm::Get Utility - Name: %s\n", buffer); 
    269291        uList[i].name = std::string(buffer); 
    270292     
    … …  
    286308    ReadMessage(commandSocketFD, buffer); 
    287309    radioInfo->numParameters = atoi(buffer); 
    288     LOG("socket_comm::GetParameter - Number of parameters: %d\n", \ 
    289             radioInfo->numParameters); 
    290310     
    291311    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    292312        memset(buffer, 0, 256); 
    293313        ReadMessage(commandSocketFD, buffer); 
    294         LOG("socket_comm::GetParameter - Name: %s\n", buffer); 
    295314        pList[i].name = std::string(buffer); 
    296315     
    297316        memset(buffer, 0, 256); 
    298317        ReadMessage(commandSocketFD, buffer); 
    299         LOG("socket_comm::GetParameter - Units: %s\n", buffer); 
    300318        pList[i].units = std::string(buffer); 
    301319 
    302320        memset(buffer, 0, 256); 
    303321        ReadMessage(commandSocketFD, buffer); 
    304         LOG("socket_comm::GetParameter - Min: %s\n", buffer); 
    305322        pList[i].min = atof(buffer); 
    306323     
    307324        memset(buffer, 0, 256); 
    308325        ReadMessage(commandSocketFD, buffer); 
    309         LOG("socket_comm::GetParameter - Max: %s\n", buffer); 
    310326        pList[i].max = atof(buffer); 
    311327     
    312328        memset(buffer, 0, 256); 
    313329        ReadMessage(commandSocketFD, buffer); 
    314         LOG("socket_comm::GetParameter - Step: %s\n", buffer); 
    315330        pList[i].step = atof(buffer); 
    316331     
    317332        memset(buffer, 0, 256); 
    318333        ReadMessage(commandSocketFD,buffer); 
    319         LOG("socket_comm::GetParameter - Number of Affects: %s\n", buffer); 
    320334        pList[i].numAffects = atoi(buffer); 
    321335     
    … …  
    323337            memset(buffer, 0, 256); 
    324338            ReadMessage(commandSocketFD,buffer); 
    325             LOG("socket_comm::GetParameter - Affect Name: %s\n", buffer); 
    326339            for (k = 0; k < radioInfo->numUtilities; k++){ 
    327340                if(uList[k].name == std::string(buffer)){     
    … …  
    333346            memset(buffer, 0, 256); 
    334347            ReadMessage(commandSocketFD,buffer); 
    335             LOG("socket_comm::GetParameter - Affect Relation: %s\n", buffer); 
    336348            pList[i].affection_list[j].relation = std::string(buffer);    
    337349        } 
    … …  
    346358        memset(buffer, 0, 256); 
    347359        ReadMessage(commandSocketFD,buffer); 
    348         LOG("socket_comm::Get Observable - Name: %s\n", buffer); 
    349360        oList[i].name = std::string(buffer); 
    350361     
    351362        memset(buffer, 0, 256); 
    352363        ReadMessage(commandSocketFD,buffer); 
    353         LOG("socket_comm::Get Observable - Number Affects: %s\n", buffer); 
    354364        oList[i].numAffects = atoi(buffer); 
    355365     
    … …  
    357367            memset(buffer, 0, 256); 
    358368            ReadMessage(commandSocketFD,buffer); 
    359             LOG("socket_comm::Get Observable - Affect Name: %s\n", buffer); 
    360369            for (k = 0; k < radioInfo->numUtilities; k++){ 
    361370                if(uList[k].name == std::string(buffer)){     
    … …  
    367376            memset(buffer, 0, 256); 
    368377            ReadMessage(commandSocketFD,buffer); 
    369             LOG("socket_comm::Get Observable - Affect Relation: %s\n", buffer); 
    370378            oList[i].affection_list[j].relation = std::string(buffer);    
    371379        } 

  • vtcross/trunk/src/cognitive_engines/cbr_demo.cpp

    r218 r222  
    3535    LOG("Waiting for signal...\n"); 
    3636    while(1) { 
    37 //        cognitiveEngine.WaitForSignal(); 
     37        cognitiveEngine.WaitForSignal(); 
    3838    } 
    3939 

  • vtcross/trunk/src/include/vtcross/components.h

    r217 r222  
    353353        int16_t commandPort; 
    354354 
     355        int32_t ceSocketFD; 
     356        int32_t commandSocketFD; 
     357        int32_t policySocketFD; 
     358 
    355359        Utility *utils; 
    356360        Parameter *params; 

  • vtcross/trunk/src/include/vtcross/containers.h

    r221 r222  
    8181 * 
    8282 */ 
     83struct Service { 
     84    std::string name; 
     85    uint16_t socketFD; 
     86};  
     87 
     88 
     89/* TODO 
     90 * 
     91 */ 
    8392struct Mission { 
    8493    std::string name; 
    … …  
    8897}; 
    8998 
    90  
    91 /* TODO 
    92  * 
    93  */ 
    94 struct Service { 
    95     std::string name; 
    96     uint16_t socketFD; 
    97 };  
    98  
    9999#endif 

  • vtcross/trunk/src/include/vtcross/libvtcross.h

    r196 r222  
    4646 * functions will still be valid by the time the client code receives them. 
    4747 */ 
    48 Observables* GetRadioObservables(); 
    49 Parameters* GetRadioParameters(); 
    50 Utilities* GetRadioUtilities(); 
     48Observable* GetRadioObservables(); 
     49Parameter* GetRadioParameters(); 
     50Utility* GetRadioUtilities(); 
    5151 
    5252 
    … …  
    7676 * use this?  Shouldn't this be internal to the radio operation?  
    7777 */ 
    78 Parameters* GetOptimalParameters(Observables *radioObservables); 
     78Parameter* GetOptimalParameters(Observable *radioObservables, uint32_t numObservables); 
    7979 
    8080 
    … …  
    8585 * radio's performance? 
    8686 */ 
    87 bool UpdateParameterPerformance(Parameters *radioParameters, \ 
    88         Observables *radioObservables, Utilies *radioUtilies); 
     87bool UpdateParameterPerformance(Parameter *radioParameters, \ 
     88        Observable *radioObservables, Utility *radioUtilies); 
    8989 
    9090 

  • vtcross/trunk/src/lib/socketcomm/socketcomm.cpp

    r219 r222  
    4141    // Messages are termination with a "\0" to denote EOM. 
    4242    ssize_t msgLength = recv(socketFD, msgBuffer, 256, MSG_PEEK); 
     43    if (msgLength < 0) 
     44        ERROR(1, "Error reading from socket.\n"); 
     45    if (msgLength == 0) 
     46        ERROR(1, "Remote component closed connection.\n"); 
    4347 
    4448    size_t i; 
    … …  
    5155    msgLength = recv(socketFD, msgBuffer, i + 1, 0); 
    5256    if (msgLength < 0) 
    53         ERROR(1, "Error reading from socket"); 
     57        ERROR(1, "Error reading from socket.\n"); 
     58    if (msgLength == 0) 
     59        ERROR(1, "Remote component closed connection.\n"); 
    5460} 
    5561 
    … …  
    6672    server = gethostbyname(serverName); 
    6773    if(server == NULL) 
    68         ERROR(1, "No server found by that hostname."); 
     74        ERROR(1, "No server found by that hostname.\n"); 
    6975 
    7076    portNumber = atoi(serverPort); 
    … …  
    7278    socketFD = socket(AF_INET, SOCK_STREAM, 0); 
    7379    if(socketFD < 0)  
    74         ERROR(1, "Error opening socket"); 
     80        ERROR(1, "Error opening socket\n"); 
    7581 
    7682    memset((void *) &serv_addr, 0, sizeof(serv_addr)); 
    … …  
    8187 
    8288    if(connect(socketFD, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)  
    83         ERROR(1, "Error connecting to remote socket."); 
     89        ERROR(1, "Error connecting to remote socket.\n"); 
    8490 
    8591    return socketFD; 
    … …  
    117123{ 
    118124    ssize_t numSentBytes = send(socketFD, message, (strlen(message) + 1), 0); 
    119     if(numSentBytes < 0) { 
    120         ERROR(1, "Error sending to server."); 
     125        if(numSentBytes < 0) { 
     126        ERROR(1, "Error sending to server.\n"); 
    121127    } 
    122128    else if(numSentBytes == 0) { 
    … …  
    210216    int32_t clientSocket = accept(serverSock, NULL, NULL); 
    211217    if(clientSocket < 0) {  
    212         WARNING("ALERT: Could not establish connection with client socket.\n"); 
     218        //WARNING("ALERT: Could not establish connection with client socket.\n"); 
    213219        return -1; 
    214220    } 

  • vtcross/trunk/src/libvtcross/Makefile.am

    r161 r222  
     1INCLUDES = -I$(top_srcdir)/src/include 
     2 
     3lib_LTLIBRARIES = libvtcross.la 
     4bin_PROGRAMS = libvtcross_demo 
     5 
     6libvtcross_la_SOURCES = libvtcross.cpp 
     7libvtcross_la_LDFLAGS = -version-info 1:0:0 
     8libvtcross_la_LIBADD = ../lib/socketcomm/libsocketcomm.a 
     9 
     10libvtcross_demo_SOURCES = libvtcross_demo.cpp 
     11libvtcross_demo_LDADD = libvtcross.la 

  • vtcross/trunk/src/libvtcross/libvtcross.cpp

    r161 r222  
    1313#include "vtcross/libvtcross.h" 
    1414#include "vtcross/common.h" 
     15#include "vtcross/debug.h" 
    1516 
     17uint32_t 
     18ConnectToRemoteComponent() 
     19{ 
     20        uint32_t socket;  
     21    socket = ClientSocket("localhost", "40000"); 
     22     
     23    return socket; 
     24} 
     25 
     26/* Given a certain set of observables, ask the radio to find the optimum radio 
     27 * parameters and return them.  
     28 * 
     29 * TODO I'm a little confused about this function... why would anyone need to 
     30 * use this?  Shouldn't this be internal to the radio operation?  
     31 */ 
     32Parameter* GetOptimalParameters(Observable *radioObservables, uint32_t numObservables) { 
     33    uint32_t i,socketfd,numParameters; 
     34    char var[50]; 
     35    char counter[55]; 
     36        char buffer[256]; 
     37 
     38    socketfd = ConnectToRemoteComponent(); 
     39    SendMessage(socketfd,"request_optimization"); 
     40 
     41    /* Get number of observables to send.  This information needs to be  
     42     * sent to the Cognitive Radio Shell also.    
     43     */ 
     44 
     45    // Send Observables 
     46    sprintf(counter,"%i",numObservables); 
     47    SendMessage(socketfd,counter); 
     48    for(i = 0; i < numObservables; i++) { 
     49        SendMessage(socketfd,radioObservables[i].name.c_str()); 
     50        sprintf(var,"%f",radioObservables[i].value); 
     51        SendMessage(socketfd,var);       
     52    } 
     53 
     54    /* Receive Set of Parameters */ 
     55    memset(buffer, 0, 256); 
     56    ReadMessage(socketfd, buffer); 
     57    numParameters = atoi(buffer); 
     58    Parameter * pList = new Parameter[numParameters]; 
     59     
     60    for(size_t i = 0; i < numParameters; i++) { 
     61        memset(buffer, 0, 256); 
     62        ReadMessage(socketfd, buffer); 
     63        pList[i].name = std::string(buffer); 
     64         
     65                memset(buffer, 0, 256); 
     66        ReadMessage(socketfd, buffer); 
     67        pList[i].value = atof(buffer); 
     68    }    
     69 
     70    return pList; 
     71} 

  • vtcross/trunk/src/shell/CognitiveRadioShell.cpp

    r218 r222  
    125125    // send utility      
    126126    for(i = 0; i < radio_info->numUtilities; i++) { 
    127         SendMessage(socketfd, u[i].name.c_str()); 
    128         SendMessage(socketfd, u[i].units.c_str()); 
    129         SendMessage(socketfd, u[i].goal.c_str()); 
    130         sprintf(var,"%f", u[i].target); 
     127        SendMessage(socketfd, utils[i].name.c_str()); 
     128        SendMessage(socketfd, utils[i].units.c_str()); 
     129        SendMessage(socketfd, utils[i].goal.c_str()); 
     130        sprintf(var,"%f", utils[i].target); 
    131131        SendMessage(socketfd,var); 
    132132    } 
    … …  
    136136    SendMessage(socketfd,counter); 
    137137    for(i = 0; i < radio_info->numParameters; i++) { 
    138         SendMessage(socketfd,p[i].name.c_str()); 
    139         SendMessage(socketfd,p[i].units.c_str()); 
    140         sprintf(var,"%f",p[i].min); 
     138        SendMessage(socketfd,params[i].name.c_str()); 
     139        SendMessage(socketfd,params[i].units.c_str()); 
     140        sprintf(var,"%f",params[i].min); 
    141141        SendMessage(socketfd,var); 
    142         sprintf(var,"%f",p[i].max); 
     142        sprintf(var,"%f",params[i].max); 
    143143        SendMessage(socketfd,var); 
    144         sprintf(var,"%f",p[i].step); 
     144        sprintf(var,"%f",params[i].step); 
    145145        SendMessage(socketfd,var); 
    146146 
    147         sprintf(counter,"%i",p[i].numAffects);  
     147        sprintf(counter,"%i",params[i].numAffects);  
    148148        SendMessage(socketfd,counter); 
    149         for(j = 0; j < p[i].numAffects; j++) { 
    150             SendMessage(socketfd,p[i].affection_list[j].u->name.c_str()); 
    151             SendMessage(socketfd,p[i].affection_list[j].relation.c_str()); 
     149        for(j = 0; j < params[i].numAffects; j++) { 
     150            SendMessage(socketfd,params[i].affection_list[j].u->name.c_str()); 
     151            SendMessage(socketfd,params[i].affection_list[j].relation.c_str()); 
    152152        } 
    153153    } 
    … …  
    157157    SendMessage(socketfd,counter); 
    158158    for(i = 0; i < radio_info->numObservables; i++) { 
    159         SendMessage(socketfd,o[i].name.c_str()); 
     159        SendMessage(socketfd,observables[i].name.c_str()); 
    160160                 
    161         sprintf(counter,"%i",o[i].numAffects);  
     161        sprintf(counter,"%i",observables[i].numAffects);  
    162162        SendMessage(socketfd,counter); 
    163         for(j = 0; j < o[i].numAffects; j++) { 
    164             SendMessage(socketfd,o[i].affection_list[j].u->name.c_str()); 
    165             SendMessage(socketfd,o[i].affection_list[j].relation.c_str()); 
     163        for(j = 0; j < observables[i].numAffects; j++) { 
     164            SendMessage(socketfd,observables[i].affection_list[j].u->name.c_str()); 
     165            SendMessage(socketfd,observables[i].affection_list[j].relation.c_str()); 
    166166        } 
    167167    } 
    … …  
    186186    LOG("Cognitive Radio Shell:: Sending radio experience to Cognitive Engine.\n"); 
    187187    int32_t numberExp = 4; 
    188      
    189     std::string numberExpString = numberExp; 
    190     SendMessage(socketFD, numberExp);  
     188        char numberExpString[50]; 
     189 
     190    sprintf(numberExpString,"%i",numberExp); 
     191    SendMessage(socketFD, numberExpString);  
    191192 
    192193    char buffer[256]; 
    … …  
    451452CognitiveRadioShell::GetOptimalParameters(int32_t socketFD) 
    452453{ 
     454    char buffer[256]; 
     455    uint32_t numObservables,numParameters; 
     456    char counter[55]; 
     457    uint16_t i; 
     458    char var[50]; 
     459 
     460    /* Receive Set of Observables */ 
     461    LOG("Cognitive Radio Shell:: Got request for optimization.\n"); 
     462    memset(buffer, 0, 256); 
     463    ReadMessage(commandSocketFD,buffer); 
     464    numObservables = atoi(buffer); 
     465   
     466        LOG("Cognitive Radio Shell:: Attempting to get %i observables.\n",numObservables); 
     467    Observable * o = new Observable[numObservables]; 
     468  
     469    for (i = 0; i < numObservables; i++){ 
     470        memset(buffer, 0, 256); 
     471        ReadMessage(commandSocketFD,buffer); 
     472        o[i].name = std::string(buffer); 
     473     
     474        memset(buffer, 0, 256); 
     475        ReadMessage(commandSocketFD,buffer); 
     476        o[i].value = atof(buffer); 
     477    } 
     478 
     479    /* Send to Cognitive Engine  
     480         * TODO: With multiple CEs we need to make a decision about where 
     481         * to send this information 
     482         */ 
     483 
     484        LOG("Cognitive Radio Shell:: Passing on observables to Cognitive Engine\n"); 
     485    SendMessage(ceSocketFD,"get_solution"); 
     486    sprintf(counter,"%i",numObservables); 
     487    SendMessage(ceSocketFD,counter); 
     488    for(i = 0; i < numObservables; i++) { 
     489        SendMessage(ceSocketFD,o[i].name.c_str()); 
     490        sprintf(var,"%f",o[i].value); 
     491            SendMessage(ceSocketFD,var); 
     492    } 
     493 
     494 
     495        LOG("Cognitive Radio Shell:: Receiving optimized parameters from Cognitive Engine.\n"); 
     496    /* Receive Set of Parameters */ 
     497    memset(buffer, 0, 256); 
     498    ReadMessage(ceSocketFD,buffer); 
     499    numParameters = atoi(buffer); 
     500    
     501    Parameter * p = new Parameter[numParameters]; 
     502  
     503    for (i = 0; i < numParameters; i++){ 
     504        memset(buffer, 0, 256); 
     505        ReadMessage(ceSocketFD,buffer); 
     506        LOG("socket_comm::Get Parameter - Name: %s\n", buffer); 
     507        p[i].name = std::string(buffer); 
     508     
     509        memset(buffer, 0, 256); 
     510        ReadMessage(ceSocketFD,buffer); 
     511        LOG("socket_comm::Get Parameter - Value: %s\n", buffer); 
     512        p[i].value = atof(buffer); 
     513    } 
     514 
     515    /* Send to Application  
     516         */ 
     517        LOG("Cognitive Radio Shell:: Sending optimized parameters to Application.\n"); 
     518    memset(counter, 0, 55); 
     519    sprintf(counter,"%i",numParameters); 
     520    SendMessage(commandSocketFD,counter); 
     521    for(i = 0; i < numParameters; i++) { 
     522        SendMessage(commandSocketFD,p[i].name.c_str()); 
     523        sprintf(var,"%f",p[i].value); 
     524            SendMessage(commandSocketFD,var); 
     525    } 
    453526} 
    454527 
    … …  
    473546    } else if(strcmp(buffer,"deregister_sml") == 0) { 
    474547        DeregisterSML(socketFD); 
    475     } else if(strcmp(buffer,"optimize") == 0) { 
     548    } else if(strcmp(buffer,"request_optimization") == 0) { 
    476549        /* Receive optimization request and current environment */ 
    477550        GetOptimalParameters(socketFD);   
    … …  
    499572    servSock[command] = CreateTCPServerSocket(commandPort); 
    500573 
    501     int32_t maxDescriptor = servSock[command]; 
     574    int32_t maxDescriptor;  
     575 
     576        if(servSock[primary] > servSock[policy]) 
     577                maxDescriptor = servSock[primary]; 
     578    else  
     579                maxDescriptor = servSock[policy]; 
     580 
     581        if(servSock[command] > maxDescriptor) 
     582                maxDescriptor = servSock[command]; 
    502583 
    503584    if(InitializeTCPServerPort(servSock[primary]) == -1) 
    … …  
    540621                            if(new_sd < 0)  
    541622                                break; 
    542                              
     623                            
     624                            if(port == servSock[primary]) 
     625                                ceSocketFD = new_sd; 
     626                            if(port == servSock[command]) 
     627                                commandSocketFD = new_sd; 
     628                            if(port == servSock[policy]) 
     629                                policySocketFD = new_sd; 
     630 
    543631                            HandleMessage(new_sd); 
    544632                            FD_SET(new_sd,&sockSet);