Changeset 247

Timestamp:

09/03/08 15:32:38 (5 years ago)

Author:

telle

Message:

merge r230:237 of /branches/behrens/mfiles (libusb support for windows)

Location:

branches/telle/RWTHMindstormsNXT

Files:

• COM_CloseNXT.m (modified) (6 diffs)
• COM_CollectPacket.m (modified) (3 diffs)
• COM_OpenNXTEx.m (modified) (18 diffs)
• COM_SendPacket.m (modified) (4 diffs)
• ChooseLibrary.m (copied) (copied from branches/behrens/mfiles/ChooseLibrary.m)
• ResetMotorAngle.m (modified) (1 diff)
• private/checkHandleStruct.m (modified) (1 diff)
• private/createHandleStruct.m (modified) (1 diff)
• private/getLibusbErrorString.m (modified) (3 diffs)
• private/libusb_win_proto.m (copied) (copied from branches/behrens/mfiles/private/libusb_win_proto.m)

branches/telle/RWTHMindstormsNXT/COM_CloseNXT.m

@@ -63 +63 @@
 %
 % Signature
-%   Author: Linus Atorf (see AUTHORS)
-%   Date: 2008/07/09
+%   Author: Linus Atorf, Alexander Behrens (see AUTHORS)
+%   Date: 2008/08/15
 %   Copyright: 2007-2008, RWTH Aachen University
 %
@@ -137 +137 @@
             textOut(sprintf('Closing handle (USB) with MAC = %s (handle was %.1f minutes old)\n', h.NXTMAC, etime(clock, h.CreationTime) / 60));
             if h.OSValue == 1 % win
-                USB_CloseHandle_Windows(h);
+                switch (h.ConnectionLibraryValue)
+                    case 1 % fantom library
+                        USB_CloseHandle_Windows(h);
+                    case 2 % libusb library
+                        USB_CloseHandle_libusb(h);
+                    otherwise
+                end
             else % linux
-                USB_CloseHandle_Linux(h);
+                USB_CloseHandle_libusb(h);
             end%if
         else % BT
@@ -360 +366 @@
 
 
+%% --- FUNCTION USB_CloseHandle_libusb
+function USB_CloseHandle_libusb(h)
+
+    LIBUSB_Interface = 0;
+
+    
+    if h.ConnectionLibraryValue == 1  % fantom library
+        %   // Send EOF marker, a zero length packet
+        %   usb_bulk_write(nxt->hdl, 0x1, buf, 0, 1000);
+        buffer = uint8(zeros(64,1));
+        textOut(sprintf('  - Sending a zero length packet... '));    
+        ret = calllib(h.ConnectionLibraryName, 'usb_bulk_read', h.Handle, 1, buffer, LIBUSB_Interface, 1000);
+        displayLibusbStatus(ret, h);
+
+        %   // Turn off stream mode
+        %   usb_control_msg(nxt->hdl, 0x41, 0x1, 0, 0, NULL, 0, 5000);
+        buffer = blanks(64);
+        textOut(sprintf('  - Turn off the stream mode... '));        
+        ret = calllib(h.ConnectionLibraryName, 'usb_control_msg', h.Handle, 65, 1, 0, 0, buffer, LIBUSB_Interface, 5000);
+        displayLibusbStatus(ret, h);
+
+        %   // Discard any data that is left in the buffer
+        %   while (usb_bulk_read(nxt->hdl, 0x82, buf, sizeof(buf), 1) > 0)
+        %     ;
+        textOut(sprintf('  - Discard any data that is left in the buffer... '));        
+        ret = 1;
+        while ret > 0
+          buffer = uint8(zeros(64,1));       
+          ret = calllib(h.ConnectionLibraryName, 'usb_bulk_read', h.Handle, 130, buffer, 64, 1);
+        end
+    end % end if fantom
+    
+    
+    % interface number is hardcoded, should it be that way?
+    textOut(sprintf('  - Releasing interface... '));
+    ret = calllib(h.ConnectionLibraryName, 'usb_release_interface', h.Handle, LIBUSB_Interface);
+    displayLibusbStatus(ret, h);
+
+
+    textOut(sprintf('  - Closing device... '));
+    ret = calllib(h.ConnectionLibraryName, 'usb_close', h.Handle);
+    displayLibusbStatus(ret, h);
+
+end%function
+
+
+%% --- FUNCTION USB_CloseHandle_Windows_libusb
+function USB_CloseHandle_Windows_libusb(h)
+
+    LIBUSB_Interface = 0;
+
+    
+    %   // Send EOF marker, a zero length packet
+    %   usb_bulk_write(nxt->hdl, 0x1, buf, 0, 1000);
+    buffer = uint8(zeros(64,1));
+    textOut(sprintf('  - Sending a zero length packet... '));    
+    ret = calllib('libusb0', 'usb_bulk_read', h.Handle, 1, buffer, LIBUSB_Interface, 1000);
+    displayLibusbStatus(ret, h);
+    
+    %   // Turn off stream mode
+    %   usb_control_msg(nxt->hdl, 0x41, 0x1, 0, 0, NULL, 0, 5000);
+    buffer = blanks(64);
+    textOut(sprintf('  - Turn off the stream mode... '));        
+    ret = calllib('libusb0', 'usb_control_msg', h.Handle, 65, 1, 0, 0, buffer, LIBUSB_Interface, 5000);
+    displayLibusbStatus(ret, h);
+    
+    %   // Discard any data that is left in the buffer
+    %   while (usb_bulk_read(nxt->hdl, 0x82, buf, sizeof(buf), 1) > 0)
+    %     ;
+    ret = 1;
+    while ret > 0
+      buffer = uint8(zeros(64,1));       
+      ret = calllib('libusb0', 'usb_bulk_read', h.Handle, 130, buffer, 64, 1);
+    end
+    
+    
+    % interface number is hardcoded, should it be that way?
+    textOut(sprintf('  - Releasing interface... '));
+    ret = calllib('libusb0', 'usb_release_interface', h.Handle, LIBUSB_Interface);
+    displayLibusbStatus(ret, h);
+
+
+    textOut(sprintf('  - Closing device... '));
+    ret = calllib('libusb0', 'usb_close', h.Handle);
+    displayLibusbStatus(ret, h);
+
+end%function
+
 
 %% --- FUNCTION USB_CloseHandle_Linux
@@ -369 +463 @@
     textOut(sprintf('  - Releasing interface... '));
     ret = calllib('libusb', 'usb_release_interface', h.Handle, LIBUSB_Interface);
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, h);
 
 
     textOut(sprintf('  - Closing device... '));
     ret = calllib('libusb', 'usb_close', h.Handle);
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, h);
 
     % we don't unload libusb now, but if we did:
@@ -386 +480 @@
 
 
-%% --- FUNCTION displayUSBWinStatus(status)
+%% --- FUNCTION displayUSBWinStatus
 function displayUSBWinStatus(status)
     if status
@@ -397 +491 @@
 
 
-%% --- FUNCTION displayLibusbStatus(status)
-function displayLibusbStatus(status)
+%% --- FUNCTION displayLibusbStatus
+function displayLibusbStatus(status, h)
     if isnumeric(status) && (status < 0)
         textOut(sprintf('failed.\n'));
-        textOut(sprintf(['Libusb error ' num2str(status) ': ' getLibusbErrorString(status) '\n']))
+        textOut(sprintf(['Libusb error ' num2str(status) ': ' getLibusbErrorString(status, h) '\n']))
     else
         textOut(sprintf('done.\n'));

branches/telle/RWTHMindstormsNXT/COM_CollectPacket.m

@@ -92 +92 @@
     if handle.ConnectionTypeValue == 1 % USB
         if handle.OSValue == 1 % Windows
-            [type cmd statusbyte content] = USB_CollectPacket_Windows(handle);
+            switch (handle.ConnectionLibraryValue)
+                case 1 % fantom library
+                    [type cmd statusbyte content] = USB_CollectPacket_Windows(handle);
+                case 2 % libusb library
+                    [type cmd statusbyte content] = USB_CollectPacket_libusb(handle);
+                otherwise
+            end
         else % Linux
-            [type cmd statusbyte content] = USB_CollectPacket_Linux(handle);
+            [type cmd statusbyte content] = USB_CollectPacket_libusb(handle);
         end%if
     else % BT
@@ -395 +401 @@
 
 
-%% --- FUNCTION USB_CollectPacket_Linux
-function [type cmd statusbyte content] = USB_CollectPacket_Linux(h)
+%% --- FUNCTION USB_CollectPacket_libusb
+function [type cmd statusbyte content] = USB_CollectPacket_libusb(h)
 
 %% Libusb params
@@ -427 +433 @@
       
     %[ret something reply] = calllib('libusb', 'usb_bulk_read', hNXT, receivingEndpoint, char(buffer'), length(buffer), timeout);    
+    [status something reply] = calllib(h.ConnectionLibraryName, 'usb_bulk_read', h.Handle, receivingEndpoint, buffer, length(buffer), timeout);    
+    if status < 0
+        msg = ['Libusb error ' num2str(status) ' while receiving data: ' getLibusbErrorString(status, h)];
+        warning('MATLAB:RWTHMindstormsNXT:USB:libusbErrorWhileReceivingData', msg);
+    end%if
+
+        
+%% Interpret content
+
+    if length(reply) < 2
+        % basically we've lost, nothing we can do anymore...
+        warning('MATLAB:RWTHMindstormsNXT:USB:receivedPacketIncomplete', 'The received packet does not contain enough data. Current packet seems incomplete...')
+        return
+    end%if
+
+    cmd = reply(2);
+    len = getReplyLengthFromCmdByte(cmd) + 1;
+        
+    if length(reply) < len
+        % this won't end good, but let's try to continue
+        len = length(reply);        
+        warning('MATLAB:RWTHMindstormsNXT:USB:receivedPacketIncomplete', 'The received packet does not contain enough data. Current packet seems incomplete...')
+    end%if
+    
+    % extract packet from reply (which might be padded)
+    packet = reply(1:len);
+    
+    % statistics
+    h.PacketsReceived(1);
+    h.BytesReceived(len);
+    
+    
+%% Interpret content
+
+    % note that we return uint8, NOT double!
+    % this is what the other functions (BT, fantom) do as well!
+
+    type = packet(1);
+    cmd = packet(2);
+    statusbyte = packet(3);
+
+    content = packet(4:end);
+
+end%function
+
+
+%% --- FUNCTION USB_CollectPacket_Linux
+function [type cmd statusbyte content] = USB_CollectPacket_Linux(h)
+
+%% Libusb params
+    %sendingEndpoint     = 1;
+    receivingEndpoint   = 130;  % hex2dec('82')
+    timeout             = 1000; % ms
+    maxPacketSize       = 64;
+
+
+%% Initalize Variables
+    type = 0; cmd = 0; statusbyte = 1; content = [];
+
+%% Retrieve data
+    % Various tests were necessary to find out how exactly data retrieval works
+    % with usb_bulk_read from libusb in MATLAB. The problem is that this libusb
+    % function uses a zero-terminated "string" (char-array) as data type for real
+    % binary data. Now MATLAB is very nice and converts this for us, back to a
+    % real string data type in MATLAB. But, only until the first 0 gets
+    % discovered, after all it's a zero-terminated string. So, after the first 0
+    % inside the packet, we don't get any data. I've worked around this at the
+    % moment by changing the datatype in the original .h header file, which is the
+    % template / master for the prototype m-file. 
+    
+    %buffer = blanks(maxPacketSize);
+    %buffer = uint8(zeros(getReplyLengthFromCmdByte(packet(2)), 1));
+    %buffer = [blanks(maxPacketSize - 1) 0];
+    %buffer = uint8(zeros(maxPacketSize, 1));
+    buffer = uint8(zeros(maxPacketSize, 1));
+    
+      
+    %[ret something reply] = calllib('libusb', 'usb_bulk_read', hNXT, receivingEndpoint, char(buffer'), length(buffer), timeout);    
     [status something reply] = calllib('libusb', 'usb_bulk_read', h.Handle, receivingEndpoint, buffer, length(buffer), timeout);    
     if status < 0
-        msg = ['Libusb error ' num2str(status) ' while receiving data: ' getLibusbErrorString(status)];
+        msg = ['Libusb error ' num2str(status) ' while receiving data: ' getLibusbErrorString(status, h)];
         warning('MATLAB:RWTHMindstormsNXT:USB:Windows:libusbErrorWhileReceivingData', msg);
     end%if

branches/telle/RWTHMindstormsNXT/COM_OpenNXTEx.m

@@ -3 +3 @@
 %
 % Syntax
-%   handle = COM_OpenNXTEx('USB', UseThisNXTMAC)
-%
-%   handle = COM_OpenNXTEx('Bluetooth', UseThisNXTMAC, inifilename, 'check')
-%
-%   handle = COM_OpenNXTEx('Any', UseThisNXTMAC, inifilename, 'check')
+%   |handle = COM_OpenNXTEx('USB', UseThisNXTMAC)|
+%
+%   |handle = COM_OpenNXTEx('Bluetooth', UseThisNXTMAC, inifilename, 'check')|
+%
+%   |handle = COM_OpenNXTEx('Any', UseThisNXTMAC, inifilename, 'check')|
 %
 % Description
 %   This function establishes a connection to an NXT brick and returns the
 %   handle structure that has to be used with NXT-functions (you can call
-%   COM_SetDefaultNXT(handle) afterwards for easier use).
+%   |COM_SetDefaultNXT(handle)| afterwards for easier use).
 %
 %   For a more convenient way to open an NXT handle with less parameters, the
-%   function COM_OpenNXT is provided.
+%   function |COM_OpenNXT| is provided.
 %
 %   Different types of connection modes are supported. In all modes, you can
-%   set UseThisNXTMAC to a string with the NXT's MAC address (serial number).
+%   set |UseThisNXTMAC| to a string with the NXT's MAC address (serial number).
 %   A connection will then only be estabslished to a matching NXT brick. This can be
 %   useful for programs with multiple NXT devices. Set it to an empty string
-%   '' to use any NXT available (usually the first one found).
+%   |''| to use any NXT available (usually the first one found).
 %   
 %
-%   handle = COM_OpenNXTEx('USB', UseThisNXTMAC)
+%   |handle = COM_OpenNXTEx('USB', UseThisNXTMAC)|
 %   This will try to open a connection via USB. Device drivers (Fantom on
 %   Windows, libusb on Linux) have to be installed.
 %
 %
-%   handle = COM_OpenNXTEx('Bluetooth', UseThisNXTMAC, inifilename, 'check')
+%   |handle = COM_OpenNXTEx('Bluetooth', UseThisNXTMAC, inifilename, 'check')|
 %   Uses Bluetooth as communication method. A valid inifile containing
-%   parameters like the COM-Port has to be specified in inifilename. The
-%   optional paramter 'check' can be omitted (it will nake sure that the
+%   parameters like the COM-Port has to be specified in |inifilename|. The
+%   optional paramter |'check'| can be omitted (it will nake sure that the
 %   new Bluetooth connection is working bi-directional). Leave it out if
 %   your hardware does only support sending data (depends on the Bluetooth
@@ -39 +39 @@
 %   motor control).
 %   To create an inifile with Bluetooth settings, the function
-%   COM_MakeBTConfigFile is available.
+%   |COM_MakeBTConfigFile| is available.
 %    
-%   Note that as of right now, the parameter UseThisNXTMAC will be
+%   Note that as of right now, the parameter |UseThisNXTMAC| will be
 %   ignored for Bluetooth connections until implemented in a future version.
 %
 %
-%   handle = COM_OpenNXTEx('Any', UseThisNXTMAC, inifilename, 'check')
+%   |handle = COM_OpenNXTEx('Any', UseThisNXTMAC, inifilename, 'check')|
 %   This syntax combines the two parameter settings from above.
-%   inifilename has to be given, the optional 'check' can be omitted.
+%   |inifilename| has to be given, the optional |'check'| can be omitted.
 %   The function will try to locate an NXT device on the USB bus first. If
 %   this fails for some reason (no USB connection to the NXT available, no
@@ -58 +58 @@
 %   
 %
-% Limitations of COM_CloseNXT
-%   If you call COM_CloseNXT('all') after a clear all command has been
+% Limitations of |COM_CloseNXT|
+%   If you call |COM_CloseNXT('all')| after a |clear all| command has been
 %   issued, the function will not be able to close all remaining open USB
 %   handles, since they have been cleared out of memory. This is a problem
 %   on Linux systems. You will not be able to use the NXT device without
 %   rebooting it.
-%   Solution: Either use only clear in your programs, or you use the
-%   COM_CloseNXT('all') statement before clear all.
+%   Solution: Either use only |clear| in your programs, or you use the
+%   |COM_CloseNXT('all')| statement before |clear all|.
 %   The best way however is to track your handles carefully and close them
-%   manually (COM_CloseNXT(handle)) before exiting whenever possible!%
+%   manually (|COM_CloseNXT(handle)|) before exiting whenever possible!%
 %
 %
 % Example
-%   myNXT = COM_OpenNXTEx('Any', '001612345678', 'bluetooth.ini', 'check');
-%   % This will connect to an NXT device with the MAC/serial number 001612345678,
-%   % first trying via USB. If this fails (no drivers installed or no matching USB
-%   % device found), a connection via Bluetooth will be established, using
-%   % the paramters found in the given config file.
+%+   myNXT = COM_OpenNXTEx('Any', '001612345678', 'bluetooth.ini', 'check');
+%+   % This will connect to an NXT device with the MAC/serial number 001612345678,
+%+   % first trying via USB. If this fails (no drivers installed or no matching USB
+%+   % device found), a connection via Bluetooth will be established, using
+%+   % the paramters found in the given config file.
 % 
 %
@@ -85 +85 @@
 %   Copyright: 2007-2008, RWTH Aachen University
 %
+; %#ok<NOSEM>
 %
 % ***********************************************************************************************
@@ -244 +245 @@
 %     handle.IniFilename           = h.IniFilename;
 %     handle.ComPort               = h.ComPort;
-%     handle.BaudRate                    = h.BaudRate;
-%     handle.DataBits                    = h.DataBits;
-%     handle.Timeout                     = h.Timeout;
+%     handle.BaudRate              = h.BaudRate;
+%     handle.DataBits              = h.DataBits;
+%     handle.Timeout               = h.Timeout;
 % 
-%     handle.SendSendPause               = h.SendSendPause;
+%     handle.SendSendPause         = h.SendSendPause;
 %     handle.SendReceivePause      = h.SendReceivePause;
 % 
 %     handle.NXTMAC                = h.NXTMAC;
-%     handle.CreationTime                = h.CreationTime;  
+%     handle.CreationTime          = h.CreationTime;  
 %     handle.Index                 = h.Index;
     
@@ -390 +391 @@
     
     if hIn.OSValue == 1
-        hOut = USB_OpenHandle_Windows(hIn, SuppressErrors);
+        
+        hIn = ChooseLibrary(hIn);
+        
+        switch (hIn.ConnectionLibraryValue)
+            case 1 % fantom library
+                hOut = USB_OpenHandle_Windows(hIn, SuppressErrors);
+            case 2 % libusb library
+                hOut = USB_OpenHandle_libusb(hIn, SuppressErrors);
+            otherwise
+                % use libusb0 as default
+                unknownLibrary = hIn.ConnectionLibraryValue;
+                if isnan(unknownLibrary)
+                    unknownLibrary = num2str(unknownLibrary);
+                end
+                hIn.ConnectionLibraryName  = 'libusb0';
+                hIn.ConnectionLibraryValue = 2;
+                msg = ['Unkown library ' unknownLibrary '. Use as default: ' hIn.ConnectionLibraryName];
+                warning('MATLAB:RWTHMindstormsNXT:USB:UnknownNXTDriverLibrary', msg);
+                hOut = USB_OpenHandle_libusb(hIn, SuppressErrors);
+        end
+%         hOut = USB_OpenHandle_Windows(hIn, SuppressErrors);
+%         hOut = USB_OpenHandle_libusb(hIn, false);        
     elseif hIn.OSValue == 2
-        hOut = USB_OpenHandle_Linux(hIn, SuppressErrors);
+        hOut = USB_OpenHandle_libusb(hIn, SuppressErrors);
     end%if
     
@@ -427 +449 @@
     hOut.ConnectionTypeValue    = 1;
     hOut.ConnectionTypeName     = 'USB';
+
     
     
@@ -447 +470 @@
         textOut(sprintf('  - Library "fantom" already loaded.\n'));
     end%if
-        
+
+    hOut.ConnectionLibraryName = 'fantom';  % String, 'fantom' or 'libusb' / 'libusb0'
+    hOut.ConnectionLibraryValue = 1; % fantom = 1, libusb = 2
     
     
@@ -567 +592 @@
 
 
-%% --- FUNCTION displayLibusbStatus(status)
+%% --- FUNCTION displayLibusbStatus
 % little convenient helper to save some lines of code with textOut
-function displayLibusbStatus(status)
+function displayLibusbStatus(status, h)
 % little convenient helper to save some lines of code with textOut
     if isnumeric(status) && (status < 0)
         textOut(sprintf('failed.\n'));
-        textOut(sprintf(['Libusb error ' num2str(status) ': ' getLibusbErrorString(status) '\n']))
+        textOut(sprintf(['Libusb error ' num2str(status) ': ' getLibusbErrorString(status, h) '\n']))
     else
         textOut(sprintf('done.\n'));
@@ -657 +682 @@
     textOut(sprintf('    . finding busses... '))
     ret = calllib('libusb', 'usb_find_busses');
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, hIn);
     
     textOut(sprintf('    . finding devices... '))
     ret = calllib('libusb', 'usb_find_devices');
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, hIn);
 
 %% Get main root bus
@@ -668 +693 @@
     p = calllib('libusb', 'usb_get_busses');
     bus = libstruct('usb_bus', p);
-    displayLibusbStatus(p);
+    displayLibusbStatus(p, hIn);
     
 
@@ -747 +772 @@
                 textOut(sprintf('    . opening device... '));
                 DevHandle = calllib('libusb', 'usb_open', dev);
-                displayLibusbStatus(DevHandle);
+                displayLibusbStatus(DevHandle, hIn);
 
                 textOut(sprintf('    . reading serial number... '));
@@ -754 +779 @@
                 buffer = blanks(255);
                 [bytesRead newHandleOrWhat SerialNo] = calllib('libusb', 'usb_get_string_simple', DevHandle, dev.descriptor.iSerialNumber,  buffer, length(buffer));
-                displayLibusbStatus(bytesRead);
+                displayLibusbStatus(bytesRead, hIn);
                                 
                 SerialNo = strtrim(SerialNo); % just to be safe
@@ -770 +795 @@
                     textOut(sprintf('    . closing device... '));
                     status = calllib('libusb', 'usb_close', DevHandle);
-                    displayLibusbStatus(status);
+                    displayLibusbStatus(status, hIn);
                 end%if
                 
@@ -837 +862 @@
     %calllib('libusb', 'usb_set_configuration', DevHandle, dev.config.bConfigurationValue);
     ret = calllib('libusb', 'usb_set_configuration', DevHandle, LIBUSB_Configuration);
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, hIn);
     if (ret < 0)
         ErrorWhileOpening = true;
@@ -847 +872 @@
     %calllib('libusb', 'usb_claim_interface', DevHandle, dev.config.interface.altsetting.bInterfaceNumber);
     ret = calllib('libusb', 'usb_claim_interface', DevHandle, LIBUSB_Interface);
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, hIn);
     if (ret < 0)
         ErrorWhileOpening = true;
@@ -866 +891 @@
     textOut(sprintf('    . resetting device... '));
     ret = calllib('libusb', 'usb_reset', DevHandle);
-    displayLibusbStatus(ret);
+    displayLibusbStatus(ret, hIn);
     if (ret < 0)
         ErrorWhileOpening = true;
@@ -899 +924 @@
 end%function
 
+
+%% --- FUNCTION USB_OpenHandle_libusb
+function hOut = USB_OpenHandle_libusb(hIn, SuppressErrors)
+% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
+% Temporary USB construction site for the RWTH - Mindstorms NXT Toolbox
+%           http://www.mindstorms.rwth-aachen.de
+%
+% Linus Atorf, Alexander Behrens, 15.08.2008
+% % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % % %
+
+% Basic structure of this function:
+% Load library libusb, initialize it, get root bus object, loop through all
+% busses, for each bus loop through all devices, see if vendor and product id
+% match with lego NXT, try to open device, read serial no (which is = MAC), if it
+% matches, keep it open. then do basic USB device initialization (set config,
+% claim interface, reset device). dev should be ready then.
+
+%TODO There is still one big problem with Multi-NXT: If the first one that is
+%connected is also the first that was opened (and is now in use), the usb_open_dev
+%might fail when looping through all devs (since the dev is busy). Careful testing
+%is necessary to see wether opening an "NXT in use" fails, or if it is possible
+%and only fails when claiming its interface (I think that's the case actually, so
+%this would not be an issue after all).
+
+
+
+%% initialize etc...
+    ID_VENDOR_LEGO = 1684; % hex2dec('0694');
+    ID_PRODUCT_NXT = 2;    % hex2dec('0002');
+
+    LIBUSB_Configuration = 1;
+    LIBUSB_Interface = 0;
+    
+    
+    hOut = hIn;
+    hOut.Connected(false);
+
+    hOut.ConnectionTypeValue    = 1;
+    hOut.ConnectionTypeName     = 'USB';
+
+    
+%% Load libusb library (only if necessary)
+    if ~libisloaded(hIn.ConnectionLibraryName)
+        textOut(sprintf('  - Loading library "%s"... ', hIn.ConnectionLibraryName));
+        try
+            % use "our" wrapper file...
+            loadlibrary(hIn.ConnectionLibraryName, @libusb_win_proto)
+            textOut(sprintf('done.\n'));
+        catch 
+            textOut(sprintf('failed.\n'));
+            if ~SuppressErrors
+                error('MATLAB:RWTHMindstormsNXT:USB:couldNotLoadLibraryLibusb', 'The "libusb" library could not be loaded. Make sure it is installed and paths are set correctly!')
+            else
+                return
+            end%if
+        end%try
+    else
+        textOut(sprintf('  - Library "%s" already loaded.\n',hIn.ConnectionLibraryName));
+    end%if
+
+    textOut(sprintf('  - Initializing and browsing USB busses\n'));
+
+%% Init libusb
+    textOut(sprintf('    . initializing %s.\n',hIn.ConnectionLibraryName))
+    calllib(hIn.ConnectionLibraryName, 'usb_init');
+    
+    % > - insert usb_set_debug(255) in pyusb.c right behind usb_init()
+    % > - recompile and reinstall the module
+    % > - hook up DebugView from www.sysinternals.com
+    % > - rerun your application
+    % so if we want debug mode, this needs to be uncommented!
+    %calllib('libusb', 'usb_set_debug', 255);
+
+
+    % these functions return the number of changes made to the busses and
+    % devices since last call, don't neet it...
+    textOut(sprintf('    . finding busses... '))
+    ret = calllib(hIn.ConnectionLibraryName, 'usb_find_busses');
+    displayLibusbStatus(ret, hIn);
+    
+    textOut(sprintf('    . finding devices... '))
+    ret = calllib(hIn.ConnectionLibraryName, 'usb_find_devices');
+    displayLibusbStatus(ret, hIn);
+
+%% Get main root bus
+    
+    textOut(sprintf('    . getting root bus object... '))
+    p = calllib(hIn.ConnectionLibraryName, 'usb_get_busses');
+    bus = libstruct('usb_bus', p);
+    displayLibusbStatus(p, hIn);
+    
+
+    textOut(sprintf('  - Enumerating busses and devices\n'));
+
+%% Cycle through all busses and devices: enumerate...
+    foundNXT = false;
+    while ~foundNXT % for all busses
+        
+        % we want to save some debug-lines (already got too many), so we don't
+        % care what USB devices the user has. remove comment for advanced debug
+        % mode
+        %textOut(sprintf('    . current bus: %s\n', strtrim(char(bus.dirname))))
+
+        dev = libstruct('usb_device', bus.devices);
+
+        % -------------------------------------
+        while true % for all devices! sorry for endless-loop, but we break later down
+
+            % if no devs at all
+            if isempty(dev)
+                break
+            end%if
+
+
+            % we want to save some debug-lines (already got too many), so we don't
+            % care what USB devices the user has. remove comment for advanced debug
+            % mode
+            %textOut(sprintf('    . current device: %s\n', strtrim(char(dev.filename))))
+
+
+            % try a little string reading....
+
+            % THIS DOESN'T WORK UNDER LINUX MOST OF THE TIME
+            % APPARENTLY, WE CANNOT OPEN ALL PRESENT DEVICES
+            % Since we don't want to try to open a device now, we keep this
+            % working code (at least for public devices on Linux and for
+            % alle devices on Windows) commented, maybe someone else can
+            % use it to improve this function later on...
+            % It's debug-info only anyway
+
+            
+            if hIn.OSValue == 1 % windows
+                % open device to get a handle
+                DevHandle = calllib(hIn.ConnectionLibraryName, 'usb_open', dev);
+
+                % now the string stuff
+                buffer = blanks(255);
+                % we don't need a real buffer or pointer, matlab seems to do this
+                % for us, so we pass that buffer variable, without really needing
+                % it. it seems like matlab "knows" how strings get written by
+                % reference and returns the new value from the function. if you
+                % compare the matlab-returnvalues of usb_get_string_simple using
+                % libfunctionsview libusb, you'll find that they don't match whats
+                % written inside usb.h. very nice and handy, thank you matlab :-)
+                %pBuffer = libpointer('cstring', buffer); not needed, see above
+
+                % now the actual call:
+                [bytesRead newHandleOrWhat ManufacturerName] = calllib(hIn.ConnectionLibraryName, 'usb_get_string_simple', ...
+                           DevHandle, dev.descriptor.iManufacturer,  buffer, length(buffer));
+                % again:
+                [bytesRead newHandleOrWhat ProductName] = calllib(hIn.ConnectionLibraryName, 'usb_get_string_simple', ...
+                           DevHandle, dev.descriptor.iProduct,  buffer, length(buffer));
+
+                disp(sprintf('        Manufacturer: %s', ManufacturerName))
+                disp(sprintf('        Product: %s', ProductName))
+
+                % close device again
+                ret = calllib(hIn.ConnectionLibraryName, 'usb_close', DevHandle);
+                displayLibusbStatus(ret, hIn);
+                clear DevHandle %better doing it now than forgetting it later
+            end % end if windows
+
+
+            % note at this point that we only try to open a device if it's one
+            % from LEGO!
+    
+            % check if it's LEGO and NXT
+            if (dev.descriptor.idVendor == ID_VENDOR_LEGO) && (dev.descriptor.idProduct == ID_PRODUCT_NXT)
+                textOut(sprintf('    . found NXT device\n'));
+
+                textOut(sprintf('    . opening device... '));
+                DevHandle = calllib(hIn.ConnectionLibraryName, 'usb_open', dev);
+                displayLibusbStatus(DevHandle, hIn);
+
+                textOut(sprintf('    . reading serial number... '));
+                % c-syntax from documentation so we know whats going on:
+                % int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, size_t buflen);
+                buffer = blanks(255);
+                [bytesRead newHandleOrWhat SerialNo] = calllib(hIn.ConnectionLibraryName, 'usb_get_string_simple', DevHandle, dev.descriptor.iSerialNumber,  buffer, length(buffer));
+                displayLibusbStatus(bytesRead, hIn);
+                                
+                SerialNo = strtrim(SerialNo); % just to be safe
+                textOut(sprintf('    . MAC = %s ', SerialNo))
+                
+                % is it the right one?
+                if isempty(hIn.NXTMAC) || strcmpi(hIn.NXTMAC, SerialNo)
+                    foundNXT = true;
+                    textOut(sprintf('(MAC matches, this is our desired NXT)\n'));
+                    break % search came to an end
+                else
+                    foundNXT = false;
+                    textOut(sprintf('(no match, not using this NXT)\n'));
+                    % don't forget to close the opened NXT that didnt match...
+                    textOut(sprintf('    . closing device... '));
+                    status = calllib(hIn.ConnectionLibraryName, 'usb_close', DevHandle);
+                    displayLibusbStatus(status, hIn);
+                end%if
+                
+            end%if
+
+
+            % we are at the end of our "pointer-queue"
+            if isempty(dev.next)
+                break
+            else
+                % get next device, not that easy, but it works now \o/
+                ptr = dev.next;
+                ptr.setdatatype('usb_device');
+                dev = ptr.Value; 
+                clear ptr % to be sure, don't want to risk memory leaks
+            end%if
+            
+        end%while (for all devices)
+        % -------------------------------------
+
+        
+        % no need to scan other busses if already found
+        if foundNXT
+            break
+        end%if
+
+        % jump to next bus - same procedure as for devices, see above
+        if isempty(bus.next)
+            break
+        else
+            ptr = bus.next;
+            ptr.setdatatype('usb_bus');
+            bus = ptr.Value;
+            clear ptr
+        end%if
+        
+    end%while (for all busses)
+
+
+%% check if NXT present
+    if ~foundNXT
+        if ~SuppressErrors
+            errordlg('No NXT found on USB bus! Make sure the NXT is turned on and access rights in /dev/ are properly set. Rebooting your NXT might help!')
+            error('MATLAB:RWTHMindstormsNXT:USB:noNXTfound', 'No NXT found on USB bus! Make sure the NXT is turned on and access rights in /dev/ are properly set. Rebooting your NXT might help!')
+        else
+            % well, no NXT, exit silently
+            return
+        end%if
+    end%if
+
+
+%% NXT found, open connection
+
+    % DevHandle is now the NXT we want
+    
+    % the following commands are standard procedure for USB devices, similar usage
+    % can be found in the open source packages Python_NXT and LEGO::NXT (Perl)
+
+    % flag to remember
+    ErrorWhileOpening = false;
+    
+    % if the following fails with error -16, the NXT is probably already in
+    % use (opened in another handle!)
+    textOut(sprintf('    . setting active configuration... '));
+    % somehow this doesn't work, so we use the hardcoded configuration 1!
+    %calllib('libusb', 'usb_set_configuration', DevHandle, dev.config.bConfigurationValue);
+    ret = calllib(hIn.ConnectionLibraryName, 'usb_set_configuration', DevHandle, LIBUSB_Configuration);
+    displayLibusbStatus(ret, hIn);
+    if (ret < 0)
+        ErrorWhileOpening = true;
+    end%if
+
+    textOut(sprintf('    . claiming interface... '));
+    % again, interface is hardcoded (compare implementations in python and
+    % perl, they do it the same way)
+    %calllib('libusb', 'usb_claim_interface', DevHandle, dev.config.interface.altsetting.bInterfaceNumber);
+    ret = calllib(hIn.ConnectionLibraryName, 'usb_claim_interface', DevHandle, LIBUSB_Interface);
+    displayLibusbStatus(ret, hIn);
+    if (ret < 0)
+        ErrorWhileOpening = true;
+    end%if
+    
+    
+    % we don't need an alternative interface, whatever that is.
+    % but from debugging experience (also with Windows), you never know
+    % when you might need this, so we keep it in here!
+    
+    % disp('    . set altinterface')
+    % %  %[int32, usb_dev_handlePtr] usb_set_altinterface(usb_dev_handlePtr, int32)
+    % ret = calllib('libusb', 'usb_set_altinterface', DevHandle, dev.config.interface.altsetting.bInterfaceNumber);
+    % disp(sprintf('usb_strerror: %s', calllib('libusb', 'usb_strerror')))
+
+    if hIn.OSValue == 2 % linux
+        % is this necessary? but found it in perl and python versions...
+        % the main point: never touch a running system
+        textOut(sprintf('    . resetting device... '));
+        ret = calllib(hIn.ConnectionLibraryName, 'usb_reset', DevHandle);
+        displayLibusbStatus(ret, hIn);
+        if (ret < 0)
+            ErrorWhileOpening = true;
+        end%if
+    end % end if linux
+    
+
+    if hIn.OSValue == 1 % windows
+%         NOTE: really necessary?
+%         %   // Discard any data that is left in the buffer
+%         %   while (usb_bulk_read(nxt->hdl, 0x82, buf, sizeof(buf), 1) > 0);
+%         textOut(sprintf('    . discarding any data... '));
+%         buffer = uint8(zeros(64,1));
+%         ret = 1;
+%         while ret > 0
+%            ret = calllib(hIn.ConnectionLibraryName, 'usb_bulk_read', DevHandle, uint8(130), buffer, 5, 1);
+%            displayLibusbStatus(ret, hIn);
+%         end
+% %         displayLibusbStatus(ret, hIn);
+
+        %   // try to set the stream I/O feature
+        %   ret = usb_control_msg(nxt->hdl, 0x41, 0x3, 0, 0, NULL, 0, 1000);
+        %   if (ret >= 0)
+        %   {
+        %     nxt->stream_mode = 1;
+        %   }
+        textOut(sprintf('    . open stream modus... '));
+        buffer = char(uint8(blanks(64)));
+        ret = calllib(hIn.ConnectionLibraryName, 'usb_control_msg', DevHandle, 65, 3, 0, 0, buffer, 0, 1000);
+        displayLibusbStatus(ret, hIn);
+        if (ret < 0)
+            ErrorWhileOpening = true;
+        end%if
+%         if ret < 0
+%           msg = ['Libusb error ' num2str(ret) ' while open stream mode: ' getLibusbErrorString(ret, hIn)];
+%           warning('MATLAB:RWTHMindstormsNXT:USB:libusbErrorWhileOpenStreamMode', msg);
+%         end%if
+    end % end if windows
+    
+    
+    % now it's time to decide:
+    if ErrorWhileOpening || isnumeric(DevHandle)
+        if ~SuppressErrors
+            errordlg('Something went wrong while opening the NXT device via USB (is it already open in another handle?). Please try to reboot the NXT or call COM_CloseNXT(''all'')!')
+            error('MATLAB:RWTHMindstormsNXT:USB:couldNotOpenNXT', 'Something went wrong while opening the NXT device via USB (is it already open in another handle?). Please try to reboot the NXT or call COM_CloseNXT(''all'')!')
+        else
+            % again, exit silently when no success
+            return
+        end%if
+    end%if
+    
+    % finally, we're good to go!
+    hOut.Handle = DevHandle;
+    hOut.NXTMAC = SerialNo;
+
+    % and, important:
+    hOut.Connected(true);
+    
+    
+%% clean up
+
+    % is this needed? or will matlab destroy this private vars anyway after
+    % finishing this function? just to be sure with pointers...
+    clear p v bus dev newHandleOrWhat DevHandle
+
+
+end%function
+

branches/telle/RWTHMindstormsNXT/COM_SendPacket.m

@@ -32 +32 @@
 %
 % Signature
-%   Author: Linus Atorf (see AUTHORS)
-%   Date: 2008/07/09
+%   Author: Linus Atorf, Alexander Behrens (see AUTHORS)
+%   Date: 2008/08/15
 %   Copyright: 2007-2008, RWTH Aachen University
 %
@@ -73 +73 @@
         
         if handle.OSValue == 1 % Windows
-            USB_SendAndCollectPacket_Windows(Packet(3:end), handle);
+            switch (handle.ConnectionLibraryValue)
+                case 1 % fantom library
+                    USB_SendAndCollectPacket_Windows(Packet(3:end), handle);                    
+                case 2 % libusb library
+                    USB_SendPacket_libusb(Packet(3:end), handle);
+                otherwise
+            end
         else % Linux
-            USB_SendPacket_Linux(Packet(3:end), handle);
+            USB_SendPacket_libusb(Packet(3:end), handle);
         end%if
         
@@ -197 +203 @@
 
 
-%% --- FUNCTION USB_SendPacket_Linux
-function USB_SendPacket_Linux(packet, h)
+%% --- FUNCTION USB_SendPacket_libusb
+function USB_SendPacket_libusb(packet, h)
 
 
@@ -207 +213 @@
 
     % be very careful to send uint8(packet) !!!!!!
+    ret = calllib(h.ConnectionLibraryName, 'usb_bulk_write', h.Handle, sendingEndpoint, uint8(packet), length(packet), timeout);
+    
+    if ret < 0
+        msg = ['Libusb error ' num2str(ret) ' while sending data: ' getLibusbErrorString(ret, h)];
+        warning('MATLAB:RWTHMindstormsNXT:USB:libusbErrorWhileSendingData', msg);
+    else % success
+        h.PacketsSent(1);
+        h.BytesSent(length(packet));
+    end%if
+
+
+
+end%function
+
+
+%% --- FUNCTION USB_SendPacket_Linux
+function USB_SendPacket_Linux(packet, h)
+
+
+    sendingEndpoint     = 1;
+    %receivingEndpoint   = 130;  % hex2dec('82')
+    timeout             = 1000; % ms
+    %maxPacketSize       = 64;
+
+    % be very careful to send uint8(packet) !!!!!!
     ret = calllib('libusb', 'usb_bulk_write', h.Handle, sendingEndpoint, uint8(packet), length(packet), timeout);
     
     if ret < 0
-        msg = ['Libusb error ' num2str(ret) ' while sending data: ' getLibusbErrorString(ret)];
+        msg = ['Libusb error ' num2str(ret) ' while sending data: ' getLibusbErrorString(ret, h)];
         warning('MATLAB:RWTHMindstormsNXT:USB:Linux:libusbErrorWhileSendingData', msg);
     else % success

branches/telle/RWTHMindstormsNXT/ResetMotorAngle.m

@@ -47 +47 @@
 % ***********************************************************************************************
 
+%% Parameter check
+% check if NXT handle is given; if not use default one
+if nargin > 2
+        handle = varargin{1};
+else
+    handle = COM_GetDefaultNXT;
+end%if
+
 % as we can see, just a little wrapper that maps the following NXT function and
 % parameter combination to a more obvious name

branches/telle/RWTHMindstormsNXT/private/checkHandleStruct.m

@@ -52 +52 @@
             if h.OSValue == 1 % Windows
                 if h.ConnectionTypeValue == 1 % USB
-                    if isfloat(h.Handle)
+                    if isfloat(h.Handle) || ~isnumeric(h.Handle) % libusb0
                         valid = true;
                     end%if

branches/telle/RWTHMindstormsNXT/private/createHandleStruct.m

@@ -82 +82 @@
     h.ConnectionTypeName    = '';  % String, 'USB' or 'Bluetooth'
     h.ConnectionTypeValue       = NaN; % USB = 1, Bluetooth = 2
+    h.ConnectionLibraryName = '';  % String, 'fantom' or 'libusb' / 'libusb0'
+    h.ConnectionLibraryValue = NaN; % fantom = 1, libusb = 2
 
     h.Handle                = [];  % actual handle to driver / serial ...

branches/telle/RWTHMindstormsNXT/private/getLibusbErrorString.m

@@ -1 @@
-function msg = getLibusbErrorString(errNo)
+function msg = getLibusbErrorString(errNo, h)
 % Returns description to the last error from libusb
 %
 % Syntax
-%   msg = getLibusbErrorString(errNo)
+%   |msg = getLibusbErrorString(errNo, h)|
 %
 % Description
@@ -13 +13 @@
 %   Copyright: 2007-2008, RWTH Aachen University
 %
+;
 %
 % ***********************************************************************************************
@@ -36 +37 @@
     if  errNo < 0
         %msg = sprintf('Error %d in libusb: %s', errNo, calllib('libusb', 'usb_strerror'));
-        msg =  calllib('libusb', 'usb_strerror');
+        msg =  calllib(h.ConnectionLibraryName, 'usb_strerror');
 
     % basically taht was it, leave the other strings below just in case...