Changeset 580


Ignore:
Timestamp:
10/22/2010 05:23:37 PM (9 years ago)
Author:
michael.kriegel
Message:

changing cmion to work with Samgar v2, work in progress, might already work but not tested yet, will complete asap

Location:
libs/cmion
Files:
1 added
3 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • libs/cmion/cmionAddOns/src/cmion/addOns/samgar/CmionPort.java

    r296 r580  
    1414         
    1515        /** create a new main Cmion port */ 
    16         public CmionPort(SamgarCompetency parent) 
     16        public CmionPort(SamgarCompetency parent,String portName) 
    1717        { 
    1818                this.parent = parent; 
    19                 open("/Port_"+SamgarConnector.MODULE_NAME+"_"+parent.getCompetencyName()); // open the port 
     19                open("/"+SamgarConnector.MODULE_NAME+"_"+portName); // open the port 
    2020                useCallback(myBottleCallback); // set the callback for reading data on this port 
    2121        } 
  • libs/cmion/cmionAddOns/src/cmion/addOns/samgar/MainCmionPort.java

    r296 r580  
    33import java.util.ArrayList; 
    44 
    5 import cmion.level2.SamgarModuleInfo; 
     5import cmion.level2.SamgarCompetencyInfo; 
    66 
    77import yarp.Bottle; 
     
    2424                while (Network.getNameServerName().toString().equals("/global")) 
    2525                {}   // a loop to wait until the network is on the local and not global server 
    26                 open("/Main_"+SamgarConnector.MODULE_NAME); // open the port, this will be the main module port you'll get updates on 
    27                 while(getInputCount()<1){Thread.yield();} // you might want a line like this to know that the samgar gui  
    28                                                                    // has actually connected to the maim module port 
     26                open(SamgarConnector.MODULE_NAME); 
     27                this.addOutput("/CONTROL"); 
     28                //open("/Main_"+SamgarConnector.MODULE_NAME); // open the port, this will be the main module port you'll get updates on 
     29                while(this.isWriting()){Thread.yield();} // you might want a line like this to know that the samgar gui  
     30                // has actually connected to the maim module port        
    2931        } 
     32         
    3033         
    3134        /** the call back for receiving bottles on this port */ 
     
    3740                public void onRead(Bottle datum)  
    3841                { 
    39                         // every bottle starts with an int to identify whats inside (samgar convention) 
    40                         int msgType = datum.get(0).asInt(); 
    41                         // 105 signifies information about connected modules 
    42                         if (msgType == 105) 
    43                         { 
    44                                 // modules are list by name , category and subcategory behind each other  
    45                                 // in the bottle 
    46                                 ArrayList<SamgarModuleInfo> modules = new ArrayList<SamgarModuleInfo>(); 
    47                                 int counter = 1; 
    48                                 while (counter < datum.size()) 
    49                                 { 
    50                                         String name = datum.get(counter).asString().toString(); 
    51                                         counter++; 
    52                                         String category = datum.get(counter).asString().toString(); 
    53                                         counter++; 
    54                                         String subcategory = datum.get(counter).asString().toString(); 
    55                                         counter++; 
    56                                          
    57                                         if (!name.equals(SamgarConnector.MODULE_NAME))  
    58                                                 modules.add(new SamgarModuleInfo(name,category,subcategory)); 
    59                                 } 
    60                                 // now that we have read the whole bottle update the Samgar connector, 
    61                                 // about what we have found 
    62                                 parent.updateModules(modules);                   
    63                         } 
    6442                }        
    6543        }; 
     
    7048        { 
    7149                Bottle b = prepare(); 
    72                 b.addInt(10); 
     50                b.addString("Add_Module"); 
    7351                b.addString(SamgarConnector.MODULE_NAME); 
    74                 b.addString("Control"); 
    75                 b.addString("Control"); 
     52                ArrayList<SamgarCompetencyInfo> scis = parent.getArchitecture().getCompetencyLibrary().getSamgarCompetencyInfos(); 
     53                for (SamgarCompetencyInfo sci: scis) 
     54                { 
     55                        b.addString(sci.getPortName()); 
     56                } 
    7657                write(); 
    7758        } 
  • libs/cmion/cmionAddOns/src/cmion/addOns/samgar/SamgarCompetency.java

    r296 r580  
    1515        private CmionPort port; 
    1616         
     17        private String portName; 
     18         
    1719        public SamgarCompetency(IArchitecture architecture)  
    1820        { 
    1921                super(architecture); 
     22                portName = null; 
    2023        } 
    2124 
     25        @Override 
     26        public void setAdditionalData(Object data) 
     27        { 
     28                if (data instanceof String) 
     29                        portName = (String) data; 
     30        } 
     31         
    2232        /** in here we initialize the yarp port */ 
    2333        @Override 
    2434        public final void initialize()  
    2535        { 
     36                if (portName==null) portName = this.getCompetencyName(); 
    2637                Network.init(); 
    27                 port = new CmionPort(this);              
     38                port = new CmionPort(this,portName);             
    2839                // after the ports have been created we are ready 
    2940                this.available = true; 
  • libs/cmion/cmionAddOns/src/cmion/addOns/samgar/SamgarConnector.java

    r287 r580  
    11package cmion.addOns.samgar; 
    2  
    3 import java.util.ArrayList; 
    42 
    53import ion.Meta.EventHandler; 
     
    1210import cmion.architecture.EventCmionReady; 
    1311import cmion.architecture.IArchitecture; 
    14 import cmion.level2.EventSamgarModuleAdded; 
    15 import cmion.level2.EventSamgarModuleRemoved; 
    16 import cmion.level2.SamgarModuleInfo; 
     12import cmion.level2.EventSamgarModuleReady; 
     13 
    1714 
    1815/** this class provides a connector to SAMGAR. It handles the dynamic 
     
    2522        /** the main yarp port needed in order to represent Cmion as a Samgar module */ 
    2623        private MainCmionPort mainPort; 
    27          
    28         /** storing the list of avilable Samgar modules*/ 
    29         ArrayList<SamgarModuleInfo> availableModules; 
    30          
     24 
    3125         
    3226        public SamgarConnector(IArchitecture architecture)  
    3327        { 
    3428                super(architecture); 
    35                 availableModules = new ArrayList<SamgarModuleInfo>(); 
    3629        } 
    3730 
     
    7568                // now the main port should identify itself 
    7669                mainPort.sendId(); 
    77                  
    78                  
     70                // raise an event that the cmion Samgar module is ready 
     71                this.raise(new EventSamgarModuleReady());        
    7972        } 
    8073 
    81         /** update the list of available Samgar modules*/ 
    82         public synchronized void updateModules(ArrayList<SamgarModuleInfo> modules)  
    83         { 
    84                 // the modules that were found but are not yet in available modules are new 
    85                 // (we ignore already existing ones) 
    86                 for (SamgarModuleInfo modInfo:modules) 
    87                         if (!availableModules.contains(modInfo)) 
    88                                 this.raise(new EventSamgarModuleAdded(modInfo));                                 
    89                                  
    90                 // the modules that are in available modules that were not found anymore  
    91                 // have to be removed  
    92                 for (SamgarModuleInfo modInfo:availableModules) 
    93                         if (!modules.contains(modInfo)) 
    94                                 this.raise(new EventSamgarModuleRemoved(modInfo));                               
    95  
    96                 // now that we have raised the events, update the list for next call of this 
    97                 // method 
    98                 availableModules = modules; 
    99                  
    100         } 
    10174} 
    10275 
  • libs/cmion/cmionLauncher/CompetencyLibrary.dtd

    r283 r580  
    1515<!ATTLIST Competency ConstructorParameters CDATA #IMPLIED> 
    1616 
    17 <!--A competency that can communicate with a Samgar Module. It will only be built and used if 
    18 a) Samgar is used (by using the samgarConnector component (cmion.addOns.level2.samgar.samgarConnector))  
    19 b) The Samgar connector at runtime finds a running Samgar module with identical category and sub category 
     17<!--A competency that can communicate with a Samgar Module. It will only be built and used if Samgar  
     18is used (by using the samgarConnector component (cmion.addOns.level2.samgar.samgarConnector))  
    2019--> 
    2120<!ELEMENT SamgarCompetency EMPTY> 
     
    3130<!ATTLIST SamgarCompetency ConstructorParameters CDATA #IMPLIED> 
    3231 
    33 <!--The category for this competency. Has to match the category of a SAMGAR module in order 
    34 to talk to it --> 
    35 <!ATTLIST SamgarCompetency Category CDATA #REQUIRED> 
    36  
    37 <!--The sub category for this competency. Has to match the sub category of a SAMGAR module in order 
    38 to talk to it --> 
    39 <!ATTLIST SamgarCompetency SubCategory CDATA #REQUIRED> 
     32<!--The name of the port of the cmion module that is used in SAMGAR to communicate 
     33 with this competency --> 
     34<!ATTLIST SamgarCompetency Port CDATA #REQUIRED> 
  • libs/cmion/cmionLauncher/CompetencyLibraryTeamBuddy.xml

    r316 r580  
    1515<Competency ClassName="cmion.TeamBuddy.competencies.MoveToUser" /> 
    1616                                   
    17 <SamgarCompetency ClassName="cmion.TeamBuddy.competencies.FaceDetect" 
    18                                   Category="FaceDetect" SubCategory="FaceDetect" /> 
     17<SamgarCompetency ClassName="cmion.TeamBuddy.competencies.FaceDetect" Port="FaceDetect"/> 
    1918                                   
    20 <SamgarCompetency ClassName="cmion.TeamBuddy.competencies.Motion" 
    21                                   Category="MoveRobot" SubCategory="Motion" /> 
     19<SamgarCompetency ClassName="cmion.TeamBuddy.competencies.Motion" Port="Motion"/> 
    2220                 
    2321</CompetencyLibrary> 
  • libs/cmion/cmionLauncher/CompetencyLibraryTest.xml

    r296 r580  
    1919                        ConstructorParameters="Pizza,Pasta" />  
    2020<Competency ClassName="cmion.level2.competencies.test.TestCompetency6" /> 
    21 <SamgarCompetency ClassName="cmion.addOns.samgar.competencies.test.TestSamgarCompetency" 
    22                                   Category="EmergencyStop" SubCategory="Wheels" /> 
    23 <SamgarCompetency ClassName="cmion.addOns.samgar.competencies.test.TestSamgarCompetency2" 
    24                                   Category="EmergencyStop2" SubCategory="Wheels2" /> 
     21<SamgarCompetency ClassName="cmion.addOns.samgar.competencies.test.TestSamgarCompetency" Port="test1"/> 
     22<SamgarCompetency ClassName="cmion.addOns.samgar.competencies.test.TestSamgarCompetency2" Port="test2" /> 
    2523                         
    2624</CompetencyLibrary> 
  • libs/cmion/cmionMain/src/cmion/level2/Competency.java

    r423 r580  
    195195        } 
    196196         
     197        /** a convenience function (i.e. dirty hack) to allow samgar competency construction 
     198         *  Please ignore this and don't call it :) */  
     199        public void setAdditionalData(Object data) 
     200        {} 
     201         
    197202} 
  • libs/cmion/cmionMain/src/cmion/level2/CompetencyLibrary.java

    r423 r580  
    170170                                        throw new Exception("No class name specified for a competency in competency library configuration file."); 
    171171                                 
     172                                // read attribute Port 
     173                                String portName; 
     174                                Node atrPortName = attribs.getNamedItem("Port"); 
     175                                if (atrPortName!=null)  
     176                                        portName = atrPortName.getNodeValue(); 
     177                                else 
     178                                        throw new Exception("No port specified for a samgar competency in competency library configuration file."); 
     179 
     180                                 
    172181                                // read attribute ConstructorParameters: default none 
    173182                                String constructorParametersStr = ""; 
     
    204213                                // the respective array list 
    205214                                if (samgarCompetency) 
    206                                 { 
    207                                         String catName; 
    208                                         Node atrCatName = attribs.getNamedItem("Category"); 
    209                                         if (atrCatName!=null)  
    210                                                 catName = atrCatName.getNodeValue(); 
    211                                         else 
    212                                                 throw new Exception("No category specified for a Samgar competency in competency library configuration file."); 
    213  
    214                                         String subCatName; 
    215                                         Node atrSubCatName = attribs.getNamedItem("SubCategory"); 
    216                                         if (atrSubCatName!=null)  
    217                                                 subCatName = atrSubCatName.getNodeValue(); 
    218                                         else 
    219                                                 throw new Exception("No sub-category specified for a Samgar competency in competency library configuration file."); 
    220                                          
    221                                         samgarCompetencyInfos.add(new SamgarCompetencyInfo(className,constructorParameters, 
    222                                                                                                 constructorClasses,catName,subCatName)); 
    223                                          
    224                                          
    225                                          
     215                                {                                        
     216                                        samgarCompetencyInfos.add(new SamgarCompetencyInfo(className,portName,constructorParameters,constructorClasses)); 
    226217                                } 
    227218                                else // otherwise directly construct the competency and add it to the library 
     
    256247        public final void registerHandlers()  
    257248        { 
    258                 Simulation.instance.getEventHandlers().add(new HandleSamgarModuleAdded()); 
    259                 Simulation.instance.getEventHandlers().add(new HandleSamgarModuleRemoved()); 
     249                Simulation.instance.getEventHandlers().add(new HandleSamgarModuleReady()); 
    260250                Simulation.instance.getEventHandlers().add(new HandleAddedElement()); 
    261251        } 
     
    332322        } 
    333323         
    334         /** retrieves a matching samgar competency info for a samgar module*/ 
    335         private SamgarCompetencyInfo findCompetencyForModule(SamgarModuleInfo modInfo) 
    336         { 
    337                 /** pick the first samgar competency info that matches that we encounter, 
    338                  *  there should be never more than one */ 
    339         for (SamgarCompetencyInfo samgarCompInfo:samgarCompetencyInfos) 
    340                 if (samgarCompInfo.canConnectToModule(modInfo)) 
    341                         return samgarCompInfo; 
    342         return null; 
    343         } 
    344          
    345         /** internal event handler class for listening to samgar module added events */ 
    346         private class HandleSamgarModuleAdded extends EventHandler { 
    347  
    348             public HandleSamgarModuleAdded() { 
    349                 super(EventSamgarModuleAdded.class); 
     324        /** internal event handler class for listening to samgar module ready events */ 
     325        private class HandleSamgarModuleReady extends EventHandler { 
     326 
     327            public HandleSamgarModuleReady() { 
     328                super(EventSamgarModuleReady.class); 
    350329            } 
    351330 
    352331            @Override 
    353332            public void invoke(IEvent evt) { 
    354                 // since this is an event handler only for type EventSamgarModuleAdded, 
    355                 // the following casts always work 
    356                 SamgarModuleInfo modInfo = ((EventSamgarModuleAdded)evt).getModuleInfo(); 
    357                 SamgarCompetencyInfo samgarCompInfo = findCompetencyForModule(modInfo); 
    358                 if (samgarCompInfo!=null)  
    359                 {   // we have information about a competency suitable for this module 
     333                // cycle through all registered samgar competency infos, and construct the competency  
     334                for (SamgarCompetencyInfo samgarCompInfo : samgarCompetencyInfos)  
     335                {    
    360336                        // check if the competency was already constructed before at some point 
    361337                        Competency comp = samgarCompetencies.get(samgarCompInfo); 
     
    404380        } 
    405381         
    406         /** internal event handler class for listening to samgar module added events */ 
    407         private class HandleSamgarModuleRemoved extends EventHandler { 
    408  
    409             public HandleSamgarModuleRemoved() { 
    410                 super(EventSamgarModuleRemoved.class); 
    411             } 
    412  
    413             @Override 
    414             public void invoke(IEvent evt) { 
    415                 // since this is an event handler only for type EventSamgarModuleRemoved, 
    416                 // the following casts always work 
    417                 SamgarModuleInfo modInfo = ((EventSamgarModuleRemoved)evt).getModuleInfo(); 
    418                 SamgarCompetencyInfo samgarCompInfo = findCompetencyForModule(modInfo); 
    419                 if (samgarCompInfo !=null) 
    420                 { 
    421                         // check if the competency was already constructed before at some point 
    422                         Competency comp = samgarCompetencies.get(samgarCompInfo); 
    423                         if (comp!=null) // if yes, disable it by setting available false 
    424                                 comp.available = false; 
    425                 } 
    426             } 
    427         }        
    428382 
    429383        /** internal event handler class for listening to ion element added events, 
     
    452406                } 
    453407            } 
     408        } 
     409 
     410        /** returns a list of information items regarding the samgar competencies 
     411         *  to be loaded by the architecture. Do not modify the returned list or its 
     412         *  contents outside this method*/ 
     413        public synchronized ArrayList<SamgarCompetencyInfo> getSamgarCompetencyInfos()  
     414        { 
     415                return samgarCompetencyInfos;    
    454416        }        
    455417 
  • libs/cmion/cmionMain/src/cmion/level2/SamgarCompetencyInfo.java

    r287 r580  
    1212        /** the full name of the class */ 
    1313        private String className; 
     14 
     15        /** the name of the port that will be linked to this class */ 
     16        private String port;     
    1417         
    1518        /** the parameters for the constructor */ 
     
    1922        private ArrayList<Class<?>> constructorParameterClasses; 
    2023         
    21         /** the category of the Samgar module */ 
    22         private String category; 
    23          
    24         /** the sub-category of the Samgar module */ 
    25         private String subCategory; 
    26          
    27          
     24 
    2825 
    2926        public SamgarCompetencyInfo(String className,  
     27                                                                String port, 
    3028                                                                ArrayList<Object> constructorParameters, 
    31                                                                 ArrayList<Class<?>> constructorParameterClasses, 
    32                                                                 String category, String subCategory) 
     29                                                                ArrayList<Class<?>> constructorParameterClasses) 
    3330        { 
     31                this.port = port; 
    3432                this.className = className; 
    3533                this.constructorParameters = constructorParameters; 
    3634                this.constructorParameterClasses = constructorParameterClasses; 
    37                 this.category = category; 
    38                 this.subCategory = subCategory; 
    39         } 
    40          
    41          
    42         /** return whether the samgar competency represented by this info can be used to connect 
    43          *  to the module passed */ 
    44         public boolean canConnectToModule(SamgarModuleInfo modInfo) 
    45         { 
    46                 if (category.equals(modInfo.getCategory()) 
    47                         && subCategory.equals(modInfo.getSubCategory())) 
    48                         return true; 
    49                 else  
    50                         return false; 
    5135        } 
    5236         
     
    6852                if (!(instance instanceof Competency)) throw new Exception("Competency could not be constructed because "+ className+ " is not a subclass of Competency"); 
    6953                Competency competency = (Competency) instance; 
    70  
     54                 
     55                // tell the competency the name of the port 
     56                competency.setAdditionalData(port); 
     57                 
    7158                return competency; 
    7259        } 
     
    7865        } 
    7966 
     67        /** returns the port name of the competency this info represents*/ 
     68        public String getPortName() { 
     69                return port; 
     70        } 
     71         
    8072} 
Note: See TracChangeset for help on using the changeset viewer.