Changeset 246

Show
Ignore:
Timestamp:
08/29/08 16:28:25 (5 years ago)
Author:
telle
Message:

Create version without the use of function closures. This is necessary to make
copying motor objects more intuitive. With function closures a motor object was
like a handle, so that 'set' worked like it works with, e.g., matlab figure
handles. As a result, copying a motor object makes no independent copy. If a
property was set on the copy it was also set on the original. I think this is not
very intuitive as it does not act like a struct.

In this version also synchronization of the properties of synced motors is forced

Location:
branches/telle/RWTHMindstormsNXT
Files:
1 added
22 modified

Legend:

Unmodified
Added
Removed
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/NXTmotor.m

    r221 r246  
    3131% Author: Aulis Telle, IND, RWTH Aachen 
    3232 
    33 data = []; 
    3433 
    3534if nargin > 0 && isa(varargin{1}, 'NXTmotor') 
    36     tmp = varargin{1}; 
    37     data = tmp.data(); 
     35    obj = varargin{1}; 
    3836else 
    3937    port = 0; 
     
    6058    end 
    6159 
    62     data.port           = port; 
    63     data.power          = 0; 
    64     data.mode.motorOn   = 1; 
    65     data.mode.brake     = 1; 
    66     data.regulationMode = 'IDLE'; 
    67     data.turnRatio      = 0; 
    68     data.runState       = 'RUNNING'; 
    69     data.tachoLimit     = 0; 
     60    obj.port           = port; 
     61    obj.power          = 0; 
     62    obj.motorOn        = 1; 
     63    obj.brake          = 1; 
     64    obj.regulationMode = 'IDLE'; 
     65    obj.turnRatio      = 0; 
     66    obj.runState       = 'RUNNING'; 
     67    obj.tachoLimit     = 0; 
    7068end 
    7169 
    72  
    73 obj.data = @dataClosure; 
    7470 
    7571obj = class(obj, 'NXTmotor'); 
    7672 
    7773if nargin > 1 
    78     set(obj, varargin{2:end}); 
     74    obj = set(obj, varargin{2:end}); 
    7975end 
    80  
    81 % This is the nested function for the function closure. The variable 
    82 % "data", which is in the scope of the outer function, can be accessed from 
    83 % within the nested function. A handel to this function is returned to the 
    84 % caller of the outer function. This makes the variable "data" persistent 
    85 % and from now on it can be accessed from within the nested function, even 
    86 % when it is called from another scope. 
    87 function val = dataClosure(varargin) 
    88  
    89     % if there are two arguments, this indicates, that a property field 
    90     % shall be set. varargin{1} is the field name and varargin{2} the  
    91     % value, to which it should be set. 
    92     if nargin == 2 
    93         switch varargin{1} 
    94             case {'port'} 
    95                 data.port = varargin{2}; 
    96                  
    97             case {'power'} 
    98                 data.power = varargin{2}; 
    99                  
    100             case {'motorOn'} 
    101                 data.mode.motorOn = varargin{2}; 
    102      
    103             case {'brake'} 
    104                 data.mode.brake = varargin{2}; 
    105      
    106             case {'regulationMode'} 
    107                 data.regulationMode = varargin{2}; 
    108      
    109             case {'turnRatio'} 
    110                 data.turnRatio = varargin{2}; 
    111      
    112             case {'runState'} 
    113                 data.runState = varargin{2}; 
    114      
    115             case {'tachoLimit'} 
    116                 data.tachoLimit = varargin{2}; 
    117         end 
    118     end 
    119     val = data; 
    120 end 
    121 % END OF NESTED FUNCTION dataClosure() 
    12276 
    12377end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/get.m

    r218 r246  
    2323end 
    2424 
    25 data = obj.data(); 
     25 
    2626if nargin > 1  
    2727    switch prop 
    2828        case 'Port' 
    29             val = data.port; 
     29            val = obj.port; 
    3030        case 'Power' 
    31             val = data.power; 
     31            val = obj.power; 
    3232        case 'MotorOn' 
    33             if data.mode.motorOn == 1 
     33            if obj.motorOn == 1 
    3434                val = 'on'; 
    3535            else 
     
    3737            end 
    3838        case 'Brake' 
    39             if data.mode.brake == 1 
     39            if obj.brake == 1 
    4040                val = 'on'; 
    4141            else 
    4242                val = 'off'; 
    4343            end 
    44             %         case 'Regulated' 
    45             %             if ischar(val) 
    46             %                 if strcmpi(val,'on') 
    47             %                     data.mode.regulated = 1; 
    48             %                 elseif strcmpi(val,'off') 
    49             %                     data.mode.regulated = 0; 
    50             %                 else 
    51             %                     error('MototSettingError:InvalidRegulated', ... 
    52             %                         'MotorOn may be ''on'' or ''off''.'); 
    53             %                 end 
    54             %             end 
    5544        case 'RegulationMode' 
    56             switch data.regulationMode 
     45            switch obj.regulationMode 
    5746                case 'IDLE' 
    5847                    val = 'idle'; 
     
    6554            end 
    6655        case 'TurnRatio' 
    67             val = data.turnRatio; 
     56            val = obj.turnRatio; 
    6857        case 'RunState' 
    69             switch data.runState 
     58            switch obj.runState 
    7059                case 'IDLE'; 
    7160                    val = 'idle'; 
     
    7867            end 
    7968        case 'TachoLimit' 
    80             val = data.tachoLimit; 
     69            val = obj.tachoLimit; 
    8170        otherwise 
    8271            error('RWTHMINDSTORMS:NXTmotor:unsupportedProperty',... 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/read.m

    r218 r246  
    1313        'No NXTmotor object.'); 
    1414end 
    15 data = obj.data(); 
    16 data = NXT_GetOutputState(data.port); 
    1715 
     16data = NXT_GetOutputState(obj.port); 
     17 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/reset.m

    r218 r246  
    2828end 
    2929 
    30 data = obj.data(); 
    31  
    3230switch lower(type) 
    3331    case 'absolute' 
    34         NXT_ResetMotorPosition(data.port, 0); 
     32        NXT_ResetMotorPosition(obj.port, 0); 
    3533    case 'relative' 
    36         NXT_ResetMotorPosition(data.port, 1); 
     34        NXT_ResetMotorPosition(obj.port, 1); 
    3735    case 'full' 
    3836        NXT_StartProgram('ResetCounter'); 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/send.m

    r218 r246  
    1717end 
    1818 
    19 data = obj.data(); 
    2019if nargout == 1 
    2120 
    2221    out = NXT_SetOutputState(... 
    23         data.port, ... 
    24         data.power, ... 
    25         data.mode.motorOn, ... 
    26         data.mode.brake, ... 
    27         data.regulationMode, ... 
    28         data.turnRatio, ... 
    29         data.runState, ... 
    30         data.tachoLimit, ... 
     22        obj.port, ... 
     23        obj.power, ... 
     24        obj.motorOn, ... 
     25        obj.brake, ... 
     26        obj.regulationMode, ... 
     27        obj.turnRatio, ... 
     28        obj.runState, ... 
     29        obj.tachoLimit, ... 
    3130        'reply'... 
    3231        ); 
    3332else 
    3433    NXT_SetOutputState(... 
    35         data.port, ... 
    36         data.power, ... 
    37         data.mode.motorOn, ... 
    38         data.mode.brake, ... 
    39         data.regulationMode, ... 
    40         data.turnRatio, ... 
    41         data.runState, ... 
    42         data.tachoLimit, ... 
     34        obj.port, ... 
     35        obj.power, ... 
     36        obj.motorOn, ... 
     37        obj.brake, ... 
     38        obj.regulationMode, ... 
     39        obj.turnRatio, ... 
     40        obj.runState, ... 
     41        obj.tachoLimit, ... 
    4342        'dontreply'... 
    4443        ); 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/set.m

    r243 r246  
    1 function set( obj, varargin ) 
     1function obj = set( obj, varargin ) 
    22% SET Configure or display NXTmotor object properties. 
    33%  
     
    3030end 
    3131 
     32if nargout == 0 
     33    error('RWTHMINDSTORMS:NXTmotor:InvalidUseOfSet',... 
     34        'No output argument supplied to set.'); 
     35end 
     36 
    3237if numel(obj) > 1 
    33     error('RWTHMINDSTORMS:NXTmotor:inputNotScalar',... 
     38    error('RWTHMINDSTORMS:NXTmotor:InputNotScalar',... 
    3439        'Set method supports only scalar objects.'); 
    3540end 
     
    5762            case 'Port' 
    5863                if isscalar(val) && isnumeric(val) && val >= 0 && val <= 2 
    59                     obj.data('port', val); 
     64                    obj.port = val; 
    6065                elseif ischar(val) 
    6166                    val = lower(val); 
    6267                    switch val 
    6368                        case 'a' 
    64                             obj.data('port', 0); 
     69                            obj.port = 0; 
    6570                        case 'b' 
    66                             obj.data('port', 1); 
     71                            obj.port = 1; 
    6772                        case 'c' 
    68                             obj.data('port', 2); 
     73                            obj.port = 2; 
    6974                        otherwise 
    7075                            error('MotorSettingError:InvalidPort',... 
     
    7883            case 'Power' 
    7984                if isscalar(val) && isnumeric(val) && val >= -100 && val <= 100 
    80                     obj.data('power',val); 
     85                    obj.power = val; 
    8186                else 
    8287                    error('MotorSettingError:InvalidPower',... 
     
    8691            case 'MotorOn' 
    8792                if isscalar(val) && isnumeric(val) && (val == 0 || val == 1) 
    88                     obj.data('motorOn', val); 
     93                    obj.motorOn = val; 
    8994                elseif islogical(val) 
    9095                    if val 
    91                         obj.data('motorOn', 1); 
    92                     else 
    93                         obj.data('motorOn', 0); 
     96                        obj.motorOn = 1; 
     97                    else 
     98                        obj.motorOn = 0; 
    9499                    end 
    95100                elseif ischar(val) 
    96101                    if strcmpi(val,'on') 
    97                         obj.data('motorOn', 1); 
     102                        obj.motorOn = 1; 
    98103                    elseif strcmpi(val,'off') 
    99                         obj.data('motorOn', 0); 
     104                        obj.motorOn = 0; 
    100105                    else 
    101106                        error('MototSettingError:InvalidMotorOn',... 
     
    109114            case 'Brake' 
    110115                if isscalar(val) && isnumeric(val) && (val == 0 || val == 1) 
    111                     obj.data('brake', val); 
     116                    obj.brake = val; 
    112117                elseif islogical(val) 
    113118                    if val 
    114                         obj.data('brake', 1); 
    115                     else 
    116                         obj.data('brake', 0); 
     119                        obj.brake = 1; 
     120                    else 
     121                        obj.brake = 0; 
    117122                    end 
    118123                elseif ischar(val) 
    119124                    if strcmpi(val,'on') 
    120                         obj.data('brake', 1); 
     125                        obj.brake = 1; 
    121126                    elseif strcmpi(val,'off') 
    122                         obj.data('brake', 0); 
     127                        obj.brake = 0; 
    123128                    else 
    124129                        error('MototSettingError:InvalidBreak',... 
     
    144149                    switch lower(val) 
    145150                        case 'idle' 
    146                             obj.data('regulationMode', 'IDLE'); 
     151                            obj.regulationMode = 'IDLE'; 
    147152                        case 'speed' 
    148                             obj.data('regulationMode', 'SPEED'); 
     153                            obj.regulationMode = 'SPEED'; 
    149154                        case 'sync' 
    150                             obj.data('regulationMode', 'SYNC'); 
     155                            obj.regulationMode = 'SYNC'; 
    151156                        case 'speedsync' 
    152                             obj.data('regulationMode', 'SPEEDSYNC'); 
     157                            obj.regulationMode = 'SPEEDSYNC'; 
    153158                        otherwise 
    154159                            error('MototSettingError:InvalidRegulationMode', ... 
    155160                                'RegulationMode may be ''idle'', ''speed'', or ''sync''.'); 
    156161                    end 
     162                else 
     163                    error('MototSettingError:InvalidRegulationMode', ... 
     164                          'RegulationMode may be ''idle'', ''speed'', or ''sync''.'); 
    157165                end 
    158166 
    159167            case 'TurnRatio' 
    160168                if isscalar(val) && isnumeric(val) && val >= -100 && val <= 100 
    161                     obj.data('turnRatio', val); 
     169                    obj.turnRatio = val; 
    162170                else 
    163171                    error('MotorSettingError:InvalidTurnRatio',... 
     
    169177                    switch lower(val) 
    170178                        case 'idle' 
    171                             obj.data('runState', 'IDLE'); 
     179                            obj.runState = 'IDLE'; 
    172180                        case 'rampup' 
    173                             obj.data('runState', 'RAMPUP'); 
     181                            obj.runState = 'RAMPUP'; 
    174182                        case 'running' 
    175                             obj.data('runState', 'RUNNING'); 
     183                            obj.runState = 'RUNNING'; 
    176184                        case 'rampdown' 
    177                             obj.data('runState', 'RAMPDOWN'); 
     185                            obj.runState = 'RAMPDOWN'; 
    178186                        otherwise 
    179187                            error('MototSettingError:InvalidRunState', ... 
    180188                                'RunState may be ''idle'', ''rampup'', ''running'', or ''rampdown''.'); 
    181189                    end 
     190                else 
     191                    error('MototSettingError:InvalidRunState', ... 
     192                          'RunState may be ''idle'', ''rampup'', ''running'', or ''rampdown''.'); 
    182193                end 
    183194 
    184195            case 'TachoLimit' 
    185196                if isscalar(val) && isnumeric(val) 
    186                     obj.data('tachoLimit', val); 
     197                    obj.tachoLimit = val; 
    187198                else 
    188199                    error('MotorSettingError:InvalidTachoLimit',... 
     
    195206end 
    196207 
     208if (nargout == 0) 
     209    clear obj; 
     210end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/stop.m

    r218 r246  
    2525    withBrake = 1; 
    2626end 
    27 data = obj.data();     
     27 
    2828NXT_SetOutputState(... 
    29     data.port, ... % Port 
     29    obj.port, ... % Port 
    3030    0, ...           % Power 
    3131    withBrake, ...   % IsMotorOn 
  • branches/telle/RWTHMindstormsNXT/@NXTmotor/subsasgn.m

    r218 r246  
    5050 
    5151    Index = Struct(1).subs{:}; 
    52     set(obj(Index), Struct(2).subs,Value); 
     52    obj(Index) = set(obj(Index), Struct(2).subs,Value); 
    5353else 
    5454    if strcmp(Struct(1).type,'.') 
    55         set(obj, Struct(1).subs, Value); 
     55        obj = set(obj, Struct(1).subs, Value); 
    5656    elseif strcmp(Struct(1).type,'()') 
    5757        obj(Struct(1).subs{:}) = Value; 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/NXTmotorsettings.m

    r222 r246  
    2929 
    3030if nargin > 0 && isa(varargin{1}, 'NXTmotorsettings') 
    31     tmp = varargin{1}; 
    32     data = tmp.data(); 
    33     for k = 1:length(data.motors) 
    34         data.motors(k) = NXTmotor(data.motors(k)); 
    35     end 
     31    obj = varargin{1}; 
    3632else 
    3733    useMotors = []; 
    38     data = []; 
    3934 
    4035    if nargin > 0 
     
    8176 
    8277        for k = 1:length(useMotors) 
    83             data.motors(k) = NXTmotor(useMotors(k)); 
     78            obj.motors(k) = NXTmotor(useMotors(k)); 
    8479        end 
    8580    else 
    8681        for k = 1:3 
    87             data.motors(k) = NXTmotor(k-1); 
     82            obj.motors(k) = NXTmotor(k-1); 
    8883        end 
    8984    end 
    9085end 
    9186 
    92 obj.data = @dataClosure; 
    93  
    9487obj = class(obj, 'NXTmotorsettings'); 
    9588 
    9689if nargin > 1 
    97     applyProperties(obj, varargin(2:end)); 
     90    obj = applyProperties(obj, varargin(2:end)); 
    9891end 
    99  
    100 % Nested functions 
    101     function val = dataClosure() 
    102         val = data; 
    103     end 
    10492 
    10593end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/display.m

    r222 r246  
    1616 
    1717if isscalar(obj) 
    18     data = obj.data(); 
    19     for k = 1:length(data.motors) 
    20         display(data.motors(k)); 
     18    for k = 1:length(obj.motors) 
     19        display(obj.motors(k)); 
    2120    end 
    2221else 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/get.m

    r222 r246  
    2424    return; 
    2525end 
    26 data = obj.data(); 
    2726 
    28 val = cell(length(data.motors), 1); 
    29 for k = 1:length(data.motors) 
    30     val{k} = get(data.motors(k), prop); 
     27val = cell(length(obj.motors), 1); 
     28for k = 1:length(obj.motors) 
     29    val{k} = get(obj.motors(k), prop); 
    3130end 
    3231 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/length.m

    r222 r246  
    1212        'No NXTmotorsettings object.'); 
    1313end 
    14 data = obj.data(); 
    15 l = length(data.motors); 
    1614 
     15l = length(obj.motors); 
     16 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/private/applyProperties.m

    r243 r246  
    1 function applyProperties(obj, settings) 
     1function obj = applyProperties(obj, settings) 
    22 
    33propertyArgIn = settings; 
    4 data = obj.data(); 
     4 
    55while length(propertyArgIn) >= 2 
    66    prop = propertyArgIn{1}; 
     
    1212    end 
    1313 
     14    % if character string is provided, stuff it into a cell.  
     15    % Only for the Port property this is allowed 
    1416    if ischar(val) && (strcmp(prop,'Port') == 0) 
    1517        val = {val}; 
     
    1820    switch prop 
    1921        case 'Port' 
    20             setProperty(data.motors, 'Port', val); 
     22            setProperty('Port', val); 
    2123        case 'Power' 
    22             setProperty(data.motors, 'Power', val); 
     24            setProperty('Power', val); 
    2325        case 'Brake' 
    24             setProperty(data.motors, 'Brake', val); 
     26            setProperty('Brake', val); 
    2527        case 'TachoLimit' 
    26             setProperty(data.motors, 'TachoLimit', val); 
     28            setProperty('TachoLimit', val); 
    2729        case 'RegulationMode' 
    28             setProperty(data.motors, 'RegulationMode', val); 
     30            setProperty('RegulationMode', val); 
    2931        case 'TurnRatio' 
    30             setProperty(data.motors, 'TurnRatio', val); 
     32            setProperty('TurnRatio', val); 
    3133        case 'RunState' 
     34            % DO WE WANT THIS ??? 
    3235            for k = 1:numel(val) 
    3336                if strcmpi(val{k},'idle') 
     
    3740                end 
    3841            end 
    39             setProperty(data.motors, 'RunState', val); 
    40             setProperty(data.motors, 'MotorOn', motorOn); 
     42            setProperty('RunState', val); 
     43            setProperty('MotorOn', motorOn); 
    4144        case 'MotorOn' 
    42             setProperty(data.motors, 'MotorOn', val); 
     45            setProperty('MotorOn', val); 
    4346        otherwise 
    4447            error('Unsupported property %s', prop); 
     
    4649end 
    4750 
    48 end 
     51obj = checkForSyncedMotors(obj); 
     52return 
    4953 
    50 %-------------------------------------------------------------------------- 
    51 function setProperty(motors, prop, val) 
     54    % NESTED FUNCTION HAS ACCESS TO obj ---------------------------------- 
     55    function setProperty(prop, val) 
     56         
     57        if numel(val) == 1 
     58            val = repmat(val, size(obj.motors)); 
     59        elseif numel(val) ~= numel(obj.motors) 
     60            error('MotorSettingsError:InvalidParameterSize',... 
     61                'Number of elements must be 1 or the number of motors.'); 
     62        end 
    5263 
    53 if numel(val) == 1 
    54     val = repmat(val, size(motors)); 
    55 elseif numel(val) ~= numel(motors) 
    56     error('MotorSettingsError:InvalidParameterSize',... 
    57         'Number of elements must be 1 or the number of motors.'); 
    58 end 
     64        if strcmp(prop,'RegulationMode') == 1 
     65            % if one cell, there have to be exactly two motors in this 
     66            %   settings object. if this is the case, sync with the settings 
     67            %   of the latter 
     68            % if array with more cells, check, whether 
     69             
     70            motorsToSync = []; 
     71            for index = 1:length(val) 
     72                if strcmp(val{index}, 'sync') 
     73                    motorsToSync = [motorsToSync index]; 
     74                end 
     75            end 
     76             
     77            % Check, that there are exactly two motors to sync 
     78            if ~isempty(motorsToSync) && length(motorsToSync) ~= 2 
     79                error('RWTHMINDSTORMS:NXTmotorsettings:InvalidSyncCount',... 
     80                    'The number of motors to sync is not 2.'); 
     81            end 
     82        end 
    5983 
    60 if iscell(val) 
    61     for k = 1:length(motors) 
    62         set(motors(k), prop, val{k}); 
    63     end 
    64 else 
    65     for k = 1:length(motors) 
    66         set(motors(k), prop, val(k)); 
     84        if iscell(val) 
     85            for m = 1:length(obj.motors) 
     86                obj.motors(m) = set(obj.motors(m), prop, val{m}); 
     87            end 
     88        else 
     89            for m = 1:length(obj.motors) 
     90                obj.motors(m) = set(obj.motors(m), prop, val(m)); 
     91            end 
     92        end 
    6793    end 
    6894end 
    6995 
    70 end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/read.m

    r222 r246  
    1616end 
    1717 
    18 data = obj.data(); 
    1918for k = 1:length(data.motors) 
    20     settings(k) = read(data.motors(k)); 
     19    settings(k) = read(obj.motors(k)); 
    2120end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/reset.m

    r222 r246  
    3030end 
    3131 
    32 data = obj.data(); 
    3332if numel(type) == 1 
    34     type = repmat(type, size(data.motors)); 
    35 elseif numel(type) ~= numel(data.motors) 
     33    type = repmat(type, size(obj.motors)); 
     34elseif numel(type) ~= numel(obj.motors) 
    3635    error('MotorSettingsError:InvalidParameterSize',... 
    3736        'Number of elements must be 1 or the number of motors.'); 
    3837end 
    3938 
    40 for k = 1:length(data.motors) 
    41     reset(data.motors(k), type{k}); 
     39for k = 1:length(obj.motors) 
     40    reset(obj.motors(k), type{k}); 
    4241end 
    4342 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/send.m

    r222 r246  
    1616end 
    1717 
    18 data = obj.data(); 
    1918 
    20 out = zeros(size(data.motors)); 
    21 for k = 1:length(data.motors) 
    22     out(k) = send(data.motors(k)); 
     19out = zeros(size(obj.motors)); 
     20for k = 1:length(obj.motors) 
     21    out(k) = send(obj.motors(k)); 
    2322end 
    2423 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/set.m

    r222 r246  
    1 function set( obj, varargin ) 
     1function obj = set( obj, varargin ) 
    22% SET Configure or display properties of the unterlying NXTmotor objects. 
    33% 
     
    2121%     Examples: 
    2222%         ms = NXTmotorsettings('AB'); 
    23 %         set(ms) % Display all configurable properties and their possible  
    24 %                 % values 
    25 %         set(ms, 'Power', [80, 20]); % Set Power of A to 80 and Power 
     23%         ms = set(ms, 'Power', [80, 20]); % Set Power of A to 80 and Power 
    2624%                                          % of B to 20 
    2725%         ms.RegulationMode = 'speed';     % Set Regulation mode for A and 
     
    3432 
    3533if ~isa(obj,'NXTmotorsettings') 
    36     error('RWTHMINDSTORMS:NXTmotor:InvalidObject',... 
     34    error('RWTHMINDSTORMS:NXTmotorsettings:InvalidObject',... 
    3735        'No NXTmotorsettings object.'); 
    3836end 
    3937 
    40 applyProperties(obj, varargin); 
     38if nargout == 0 
     39    error('RWTHMINDSTORMS:NXTmotorsettings:InvalidUseOfSet',... 
     40        'No output argument supplied to set.'); 
     41end 
     42 
     43obj = applyProperties(obj, varargin); 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/stop.m

    r222 r246  
    2727end 
    2828 
    29 data = obj.data(); 
    30  
    3129if numel(withBrake) == 1 
    32     withBrake = repmat(withBrake, size(data.motors)); 
    33 elseif numel(withBrake) ~= numel(data.motors) 
     30    withBrake = repmat(withBrake, size(obj.motors)); 
     31elseif numel(withBrake) ~= numel(obj.motors) 
    3432    error('MotorSettingsError:InvalidParameterSize',... 
    3533        'Number of elements must be 1 or the number of motors.'); 
    3634end 
    3735 
    38 for k = 1:length(data.motors) 
    39     stop(data.motors(k), withBrake{k}); 
     36for k = 1:length(obj.motors) 
     37    stop(obj.motors(k), withBrake{k}); 
    4038end 
    4139 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/subsasgn.m

    r222 r246  
    3232end 
    3333 
    34 data = obj.data(); 
    35  
    3634if StructLength == 2  
    3735    if (strcmp(Struct(1).type,'()') == 0) || (strcmp(Struct(2).type,'.') == 0) 
     
    4038 
    4139    Index = Struct(1).subs{:}; 
    42     set(data.motors(Index), Struct(2).subs, Value); 
     40    obj.motors(Index) = set(obj.motors(Index), Struct(2).subs, Value); 
    4341else 
    4442    if strcmp(Struct(1).type,'.') 
    45         set(obj, Struct(1).subs, Value); 
     43        obj = set(obj, Struct(1).subs, Value); 
    4644    elseif strcmp(Struct(1).type,'()') 
    47         data.motors(Struct(1).subs{:}) = Value; 
     45        obj.motors(Struct(1).subs{:}) = Value; 
    4846    else 
    4947        error('RWTHMINDSTORMS:motor:unsupportedSubscript','Unsupported subscription');         
    5048    end 
    5149end 
     50obj = checkForSyncedMotors(obj); 
    5251 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/subsref.m

    r222 r246  
    2929end 
    3030 
    31 data = obj.data(); 
    32  
    3331if StructLength == 2  
    3432    if (strcmp(Struct(1).type,'()') == 0) || (strcmp(Struct(2).type,'.') == 0) 
     
    3735 
    3836    Index = Struct(1).subs{:}; 
    39     result = get(data.motors(Index), Struct(2).subs); 
     37    result = get(obj.motors(Index), Struct(2).subs); 
    4038else 
    4139    if strcmp(Struct(1).type,'.') 
    4240        result = get(obj, Struct(1).subs); 
    4341    elseif strcmp(Struct(1).type,'()') 
    44         result = data.motors(Struct(1).subs{:}); 
     42        result = obj.motors(Struct(1).subs{:}); 
    4543    else 
    4644        error('RWTHMINDSTORMS:NXTmotorsettings:unsupportedSubscript','Unsupported subscription');         
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/sync.m

    r222 r246  
    1 function sync(obj, motorsToSync) 
     1function obj = sync(obj, motorsToSync) 
    22% SYNC Synchronize two motors 
    33%    
     
    3232end 
    3333 
    34 data = obj.data(); 
    3534motorIndex = []; 
     35syncMotorPorts =[]; 
    3636 
    3737if (exist('motorsToSync', 'var')) 
    38     if (length(data.motors) >= 2) 
     38    if (length(obj.motors) >= 2) 
    3939        if length(motorsToSync) == 2 
    4040            if motorsToSync(1) ~= motorsToSync(2) 
     
    4343                        switch lower(motorsToSync(k)) 
    4444                            case 'a' 
    45                                 motorIndex(end+1) = 0; 
     45                                syncMotorPorts(end+1) = 0; 
    4646                            case 'b' 
    47                                 motorIndex(end+1) = 1; 
     47                                syncMotorPorts(end+1) = 1; 
    4848                            case 'c' 
    49                                 motorIndex(end+1) = 2; 
     49                                syncMotorPorts(end+1) = 2; 
    5050                            otherwise 
    5151                                error('Unsupported motor identifier %s', motorsToSync(k)); 
     
    5454                elseif isnumeric(motorsToSync) 
    5555                    for k = 1:length(motorsToSync) 
    56                         if (motorsToSync(k) >= 0 && motorsToSync <= 2) 
    57                             motorIndex(end+1) = motorsToSync(k); 
     56                        if (motorsToSync(k) >= 0 && motorsToSync(k) <= 2) 
     57                            syncMotorPorts(end+1) = motorsToSync(k); 
    5858                        else 
    5959                            error('Unsupported motor port number %d', motorsToSync(k)); 
     
    7373         
    7474        % check, whether the selected motors are present 
    75         for k = motorIndex 
    76             for m = 1:length(data.motors) 
    77                 port = get(data.motors(m), 'Port'); 
     75        for k = syncMotorPorts 
     76            for m = 1:length(obj.motors) 
     77                port = get(obj.motors(m), 'Port'); 
    7878                if port == k 
    7979                    motorIndex(end+1) = m; 
     
    8989            'The number of motors in the NXTmotorsettings object must be at least 2.'); 
    9090    end 
     91elseif (length(obj.motors) == 2) 
     92    syncMotors([1,2]); 
    9193else 
    92     if (length(data.motors) == 2) 
    93         syncMotors([1,2]); 
    94     else 
    95         error('RWTHMINDSTORMS:NXTmotorsettings:InvalidSyncCount',... 
    96             'The number of motors to sync is not 2.'); 
     94    error('RWTHMINDSTORMS:NXTmotorsettings:InvalidSyncCount',... 
     95        'The number of motors to sync is not 2.'); 
     96end 
     97 
     98return 
     99 
     100     
     101    function syncMotors(index) 
     102        val = {}; 
     103        for m = 1:length(obj.motors) 
     104            if valueInArray(m,index) 
     105                val(m) = {'sync'}; 
     106            else 
     107                v = get(obj.motors(m), 'RegulationMode'); 
     108                if strcmp(v,'sync') 
     109                    v = 'idle'; 
     110                end 
     111                val(m) = {v}; 
     112            end 
     113        end 
     114        obj = set(obj, 'RegulationMode', val); 
     115    end 
     116 
     117end 
     118 
     119function isInArray = valueInArray(val, arr) 
     120for m = 1:length(arr) 
     121    if val == arr(m) 
     122        isInArray = 1; 
     123        return; 
    97124    end 
    98125end 
    99  
    100     function syncMotors(index) 
    101         set(data.motors(index(1)), 'RegulationMode', 'sync'); 
    102         set(data.motors(index(2)), 'RegulationMode', 'sync'); 
    103  
    104         set(data.motors(index(1)), 'Power', get(data.motors(index(2)), 'Power')); 
    105         set(data.motors(index(1)), 'MotorOn', get(data.motors(index(2)), 'MotorOn')); 
    106         set(data.motors(index(1)), 'Brake', get(data.motors(index(2)), 'Brake')); 
    107         set(data.motors(index(1)), 'TurnRatio', get(data.motors(index(2)), 'TurnRatio')); 
    108         set(data.motors(index(1)), 'RunState', get(data.motors(index(2)), 'RunState')); 
    109         set(data.motors(index(1)), 'TachoLimit', get(data.motors(index(2)), 'TachoLimit'));         
    110     end 
     126isInArray = 0; 
    111127end 
  • branches/telle/RWTHMindstormsNXT/@NXTmotorsettings/wait.m

    r222 r246  
    3636timedOut = zeros(size(obj.motors)); 
    3737 
    38 data = obj.data(); 
    39  
    4038if ~exist('timeout','var') 
    41     timeout = zeros(size(data.motors)); 
     39    timeout = zeros(size(obj.motors)); 
    4240elseif numel(timeout) == 1 
    43     timeout = repmat(timeout, size(data.motors)); 
    44 elseif numel(timeout) ~= numel(data.motors) 
     41    timeout = repmat(timeout, size(obj.motors)); 
     42elseif numel(timeout) ~= numel(obj.motors) 
    4543    error('MotorSettingsError:InvalidParameterSize',... 
    4644        'Number of elements must be 1 or the number of motors.');     
     
    4846 
    4947for k = 1:length(obj.motors) 
    50     timedOut(k) = wait(data.motors(k), timeout(k)); 
     48    timedOut(k) = wait(obj.motors(k), timeout(k)); 
    5149end