To convert uppercase to lowercase:

tr [A-Z] [a-z]

To convert lowercase to uppercase:

tr [a-z] [A-Z]

And in a shell script:

VALUE="A Mixed Case String"
UPPER=`echo $VALUE | tr [a-z] [A-Z]`
LOWER=`echo $VALUE | tr [A-Z] [a-z]`

I am using the compiler available at Next Byte Codes & Not eXactly C site. This is a simple package package to “install” (simply copying the executable from the tar/gzip to /usr/local/bin did it for me), and is wonderfully documented.

I am using a modified version of a script provided by Jan-Klaas Kollhof:

#!/bin/sh
set -e

_nbcpath=/PATH/TO/NBC/EXECUTABLE/DIRECTORY

_dirname=`dirname $1`
if [ "${_dirname}" == "." ]; then
	_dirname=$(pwd)
fi
_basename=`basename $1 .nxc`

echo "compiling ${_basename}.rxe from ${_basename}.nxc..."
${_nbcpath}/nbc \
	-O="${_dirname}/${_basename}.rxe" \
	-nbc="${_dirname}/${_basename}.nbc" \
		"${_dirname}/${_basename}.nxc"

echo "sending ${_basename}.rxe to brick..."
cd "${_dirname}"
nxt_push "${_basename}.rxe"

as should be apparent, /PATH/TO/NBC/EXECUTABLE/DIRECTORY will need to be altered to suit your environment.

the “-nbc” switch will save the generated “Next Byte Code” to YOUR_CODE_FILE_NAME.nbc. the resulting file is not only interesting to poke around in, but may help when optimizing for size.

currently, I am having some issues with nxt_python, documented here.

example usage:

[gary@motoko]# nxt_pull log.txt

code:

#!/usr/bin/env python
#
# nxt_pull:
#   Pull a file to a LEGO Mindstorms NXT brick,
#   based on Douglas P Lau's nxt_filer and nxt_push
#   Copyright (C) 2008 Gary French
#   Version: 0.1
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

import sys
import nxt.locator
from nxt.brick import FileFinder, FileReader, FileWriter

def read_file( b, fname ):
	r = FileReader(b, fname)
	r.__enter__()
	try:
		f = open(fname, 'wb')
		print 'Pulling %s ...' % (fname),
		try:
			size = 0
			for data in r:
				f.write(data)
				size += len(data)
		finally:
			f.close()
			print 'read %d bytes' % size
	finally:
		r.__exit__(None, None, None)

if __name__ == '__main__':
	sock = nxt.locator.find_one_brick()
	#sock = nxt.locator.find_one_brick(host='00:16:53:XX:XX:XX')
	if sock:
		b = sock.connect()
		read_file( b, sys.argv[1] )
		sock.close()

1. turn the Brick’s Bluetooth off
2. turn off the Brick
3. restart Bluetooth services
4. turn on the Brick
5. turn the Brick’s Bluetooth on

it acts as if something is not cleaning up after itself properly.
I’m sure I’ll figure that one out, but I have more pressing concerns at the moment. if anyone has some insight on this issue I’d appreciate the comment.

current workaround:

• use “hcitool scan” to find the MAC
• modify nxt_push line 49 from:

  sock = nxt.locator.find_one_brick()

  to:

  sock = nxt.locator.find_one_brick(host='00:16:53:XX:XX:XX')

as one might suspect, this workaround is applicable in any other similar situation.

• NXT Python
• PyBlueZ for Bluetooth communication

to test PyBlueZ, the following can be used (code by Albert Huang <albert@csail.mit.edu>)

#!/usr/bin/env python
import bluetooth
print "performing inquiry..."
nearby_devices = bluetooth.discover_devices(lookup_names = True)
print "found %d devices" % len(nearby_devices)
for name, addr in nearby_devices:
    print "  %s - %s" % (addr, name)

as I do not care for gnome, my default desktop is KDE,
what follows is my procedure for pairing with a NXT Brick.

[root@motoko]# /usr/bin/bluetooth-applet &

a Bluetooth icon will appear in your system tray,

right-click the Bluetooth icon and click “Preferences” from the popup.

• set the radio button under “Mode of operation” to be “Visible and connectable for other devices”
  (even if it ought to be “connectible”)
• click “Close”

on the NXT Brick, from the root menu,

• select “Bluetooth” and press the square button.
• select “Search” and press the square button.
• after it has finished searching, select the name that matches your computer and press the square button.
• select “[1]” and press the square button.
• wait for it to connect.
• enter passkey, or press the square button for the “1234″ default.
• Bluetooth icon will begin to blink, click it and enter the passkey in the resulting dialog.
• right-click the Bluetooth icon and click “Preferences” from the popup.
  • select the NXT Brick in the “Bonded devices” box.
  • Click “Set Trusted”
  • click “Close”

the connection can now be tested with the following python code:

#!/usr/bin/env python
import nxt.locator
sock = nxt.locator.find_one_brick()
if sock:
	brick = sock.connect()
	name, host, signal_strength, user_flash = brick.get_device_info()
	print 'NXT brick name: %s' % name
	print 'Host address: %s' % host
	print 'Bluetooth signal strength: %s' % signal_strength
	print 'Free user flash: %s' % user_flash
	sock.close()

put the following in a class

private final static SimpleDateFormat dateFormat;
static {
    //as per ISO 8601
    dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
    //make sure the formatter requires an exact string
    dateFormat.setLenient(false);
    //set "timezone" to Universal Time Coordinates (GMT adjusted by leap seconds)
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
}

and the following elsewhere in the class:

//to create a string
String nowString = dateFormat.format(new Date());
//to parse a proper string to a date
Date nowDate = dateFormat.parse(nowString);

an ActionListener can be registered with any object capable of it, typically this is an instance of an AbstactButton class like a JButton or JMenuItem.

 
 
this can be done by implementing the ActionListener on the parent of the AbstractButton object:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class ActionListenerTest
        extends JFrame
        implements ActionListener {

    //define the ActionListener subject object
    private JButton button;
    //define the example target value
    private int numberOfClicks;

    public ActionListenerTest() {
        //set the example target value
        this.numberOfClicks = 0;

        //create the ActionListener subject object
        this.button = new JButton("OK");
        //register the ActionListener with the ActionListener subject object
        this.button.addActionListener(this);
        //add the ActionListener subject object to the content pane
        this.getContentPane().add(this.button);
        //"pack the frame for visual appeal
        this.pack();
    }

    //this is the method that the implementation of ActionListener forces us to have,
    //  this will be called by the component when an "Action" is performed
    public void actionPerformed(ActionEvent e) {
        //adjust the example target value
        this.numberOfClicks++;
        //echo the example target value
        System.out.println( "The button has been pressed "+this.numberOfClicks+" times.");
    }

    public static void main(String args[]){
       ActionListenerTest frame = new ActionListenerTest();
       frame.setVisible(true);
    }

}

 
 
this can also be done by implementing the ActionListener on an inner class of the parent of the AbstractButton object:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class ActionListenerTest
        extends JFrame {

    private JButton button;

    public ActionListenerTest() {
        //create the ActionListener subject object
        this.button = new JButton("OK");
        //register the ActionListener with the ActionListener subject object
        this.button.addActionListener(new ActionListenerInnerTest());
        //add the ActionListener subject object to the content pane
        this.getContentPane().add(this.button);
        //"pack the frame for visual appeal
        this.pack();
    }

    private class ActionListenerInnerTest
            implements ActionListener {
        //define the example target value
        private int numberOfClicks = 0;
        public void actionPerformed(ActionEvent e) {
            //adjust the example target value
            this.numberOfClicks++;
            //echo the example target value
            System.out.println( "The button has been pressed "+this.numberOfClicks+" times.");
        }
    }

    public static void main(String args[]){
       ActionListenerTest frame = new ActionListenerTest();
       frame.setVisible(true);
    }

}

 
 
an advantage to the inner class method is that ic can be reused for similar situations:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;

public class ActionListenerTest
        extends JFrame {

    private JButton button1;
    private JButton button2;
    private JButton button3;

    public ActionListenerTest() {
        //define and set a layout for the content
        BoxLayout layout = new BoxLayout(this.getContentPane(),BoxLayout.Y_AXIS);
        this.getContentPane().setLayout(layout);
        //create the ActionListener subject objects
        this.button1 = new JButton("Button 1");
        this.button2 = new JButton("Button 2");
        this.button3 = new JButton("Button 3");
        //register the ActionListener with the ActionListener subject object
        this.button1.addActionListener(new ActionListenerInnerTest());
        this.button2.addActionListener(new ActionListenerInnerTest());
        this.button3.addActionListener(new ActionListenerInnerTest());
        //add the ActionListener subject objects to the content pane
        this.getContentPane().add(this.button1);
        this.getContentPane().add(this.button2);
        this.getContentPane().add(this.button3);
        //"pack the frame for visual appeal
        this.pack();
    }

    private class ActionListenerInnerTest
            implements ActionListener {
        //define the example target value
        private int numberOfClicks = 0;
        private String sourceText = null;
        public void actionPerformed(ActionEvent e) {
            //adjust the example target value
            this.numberOfClicks++;
            //set the source text if needed by casting event source to a JButton
            if( this.sourceText == null ) {
                this.sourceText = ((JButton )e.getSource()).getText();
            }
            //echo the example target value
            System.out.println( "The button: "+this.sourceText+" has been pressed "+this.numberOfClicks+" times.");
        }
    }

    public static void main(String args[]){
       ActionListenerTest frame = new ActionListenerTest();
       frame.setVisible(true);
    }

}