NXT - Arduino - homebrew

Saving space with strings

2011-07-24T01:27:00.000-07:00

Also a diary entry:
How to save space on Strings using the FLASH memory of an ATmega
http://jeelabs.org/2011/05/23/saving-ram-space/

This is a usefull post, but for one thing: it does not explain the PSTR()

This turns out to be handled with a little care, so no


Serial.println(PSTR("hello");

will work, as explained here:

http://arduino.cc/forum/index.php?action=printpage;topic=50197.0

Ad you learn something about addresses and seperate parts of the Harvard architecture

ethernetshield arduino, jeenode

2011-07-24T00:36:00.000-07:00

This stuff is all known, and this post is just a diary, remembering how to do it all.

Arduino has its own ethernetshield.
http://arduino.cc/en/Tutorial/WebServer
We also have the ethercard from Jeelabs.com
http://jeelabs.org/2010/05/24/meet-the-ether-card/

We have a modem, so how to connect what with what and what about IP?

http://electronics.stackexchange.com/questions/15150/what-does-the-arduino-ethernet-shield-connect-to
this link has a nice setup explanation.

I don't have a crossover cable, so I connected to the modem.
Then with the Arduino Ethernetshield, what worked was the example of the reading of the analog PINS.

With the jeenode ethercard setup of jeelabs the DHCP did not work for me, (probably the settings of the modem)
http://jeelabs.org/2011/06/19/ethercard-library-api/

but using the static IP:

 // ethernet interface mac address
static byte mymac[] = { 0xDE,0xAD,0xBE,0xEF,0xFE,0x19 };
// ethernet interface ip address

static byte myip[] = { 192,168,2,77 };

and in the setup:


void setup(){
ether.begin(sizeof Ethernet::buffer, mymac);
//ether.dhcpSetup();
ether.staticSetup(myip, gwip);
}

we got the "backsoon page".

That is, we got it at http://192.168.2.77/ which is still local network.

The last hurdle is to connect to this "server" from the outside.

You can see which IP you have in ipconfig in the terminal, or using
http://www.whatismyip.com

Then in our case, you have to get to your modem using the browser, (IP number in ipconfig)
advanced settings
internet
Address translation
port forwarding
and add the port whcih is in the arduino script, and the local ip of the arduino server.

Then you can reach the arduino internet page, from outside, and the arduino becomes a real server.
(Strange enough, no problems with the firewall....)

Working on XP, so Windows.

Compass sensors

2010-06-07T06:49:00.001-07:00

Some students wanted to make a real catapult which throws virtual objects into a virtual world.

Some considerations were given to calibrating the direction of the catapult using a compass sensor.

We did some searching to find the cheapest way to get (I2C) information from a compass sensor:

http://www.magnetometer.org/mag-magnetoresistive.php

HMC1051, a Honeywell chip
KMZ10B/B MAGNETFELDSENSO, but then you have to go building
( only 4.56 euro at conrad.nl )

http://www.convict.lu/Jeunes/CompassSensor.htm
http://www.sparkfun.com/commerce/product_info.php?products_id=7892
http://www.antratek.nl/Compass-modules.html

so the cheapest ready made sensor seems to be around 23 euro's and then sending costs...

music pencil drawing: drawdio

2010-03-19T02:06:00.000-07:00

While looking for a way to imitate a bird sound with a 555 timer or a Atiny something, this funny thing came out:

http://www.ladyada.net/make/drawdio/user.html

making sounds while drawing, you have to stay in touch with the drawing too, because you are part of the electronic circuitry!

http://web.media.mit.edu/~silver/drawdio/

based on a 555 or 551 timer

looks like the idea of the pencil connections could be modified and expanded easily, for instance with the Darlington pair and an ARDUINO connection, triggering “drawing input” and using it to steer FLASH movies….

connecting to USB

2010-02-17T13:31:00.001-08:00

The USB port can be used to power a chip, ATTINY, ATM168 and send/receive data at the same time.

You can connect to FLASH for instance using serial proxy.
You can connect sensors to the chip and send the data to the laptop.
You can build your own buttonboard (usb interface keyboard)
And also you can build your own programmer!

The only things you need is a chip, USB connector, a few zenerdiodes and resistors, capacitors.

links: http://www.obdev.at/products/vusb/index.html (with lots of example projects!)

to make your own programmer: http://www.fundf.net/usbasp/

or to order a DIY kit, about 17 euro.....

2010-02-17T13:13:00.001-08:00

Russian is not as difficult as it seems (sometimes :-)

if you like AVR and ARDUINO's what can ever stop you???

we start with LOVE:

я люблю контроллеры AVR : i love AVR microcontrollers

Then just for fun a few basic words (most of these words - pronounce them and you know what it is...)

вольт: volt

Конденсаторы: capacitor, (condensator)
Резистор: resistor
диод: diode
светодиод: LED, literally "light diode"
транзистор: transistor
кнопка: button (knopje in Dutch!)
регистр: registry, memory place like R15 etc
вход с подтяжкой: pullUp port
порт-земля: GND, literally port ground
порт-питание: VCC
лаборатория: laboratory
Подключение: connections, ключ = key
контроллер AVR: AVR controller
архитектуре контроллера AVR : AVR architecture
Ассемблер assembler
порты ввода вывод, input output ports
даташит, datasheet

Если что непонятно, то не стесняйся спрашивать у меня в комментах. : If all this was not clear, ask me about it in the comments :-)

If you don't believe me look here:

http://easyelectronics.ru/podklyuchenie-mikrokontrollera-likbez.html

He makes interesting art too:

this is a good translator, most of the text was not poetical spaghetti:

http://www.online-translator.com/Default.aspx/Text

inspired by the movie AVATAR

2010-02-17T13:09:00.000-08:00

Apparently people in the States are much favored: they can do the blue avatar happyness and electronics AND eating fast food at the same time:

http://www.robotroom.com/Inside-Avatar-McDonalds-Toy.html

(poor little blue fellow though :-(
He will be taken apart!

See the nice blue images on this site!

Distance sensors

2010-02-17T13:05:00.000-08:00

Distance sensors are relatively expensive.

Here is a list of some of the cheapest:

Infrared:

small distances:

http://home.cogeco.ca/~rpaisley4/IrProximity.html

intermediate:

SHARP GP2D12: (10-80 cm) examples and connections:

http://www.acroname.com/robotics/parts/R48-IR12.html

(can be bought at www.conrad.nl)

ultrasound: ( from 10 cm to 255 cm )

SRF02 series

I had a problem with too stiff wires, and I had really to get the MODE pin HIGH to get it functioning
This script is showing how:
http://www.tigoe.net/pcomp/code/category/arduinowiring/39

Because it is I2C you can add this to other I2C devices on pins 4 and 5 analog of the Arduino

http://www.antratek.nl/Ultrasonic-sensors.html

There is an inexpensive one I have built from a kit:
(dutch: Ultrasoon Afstandsalarm)

Ultrasonic distance warning

www.conrad.nl article number 114456
but this is for warning between 10 - 80 cm, not really measuring distance.

linux starter links

2009-12-31T22:02:00.000-08:00

http://www.cyberciti.biz/faq/ubuntu-linux-root-password-default-password/
https://help.ubuntu.com/6.06/ubuntu/desktopguide/C/apt-get.html
http://linuxreviews.org/beginner/

working with ubuntu in the terminal window the problem was how to get to the root user to get things installed.

basically:

sudo bash

sudo -s

then to get a file executable:

chmod a+x someFile

to copy files from somewhere to there:

cp somewhere there

somwhere and there being path/someFileName

8 x 8 LED Display

2009-07-07T08:16:00.000-07:00

Remark: In this post we use the frequency timer library, which was only working for the ATmega168. Better use the "real AVR" interrupt immediately...

Some time ago we bought the LED DISPL. GR 2 3" 8X8 MATRI
Bestnr.: 156380 - 8A at conrad.nl.
Very important you can download the datasheet at conrad service.
First we thought it would be easy to connect the 16 pins, steering 64 LED's. But it proved to be a bit more complicated than we thought. (As usual.)
Looking at the connections you see that you can light one LED, but how to get a pattern running across the matrix of 8 x 8 LED's.

Some tricks are needed!
We have to use a fast timer, from a CPP lib to fool the eye of the beholder, working with the slow response time of the eye. Indeed a camera sees more, which can be seen in the pictures.
here we found the necessary info: http://www.arduino.cc/playground/Main/DirectDriveLEDMatrix
but the FrequencyTimer2.h did not compile right away, we had to modify some lines using advice from here:
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1239820770
then we still had a problem, we dived into the CPP file, we encountered some things we didn't really understand.....we tried several changes....
...
...***
...
then as a final try we changed the HIGH in the LOW everywhere in the ARDUINO script, and it worked, why?
comparing the datasheets we noticed that ...indeed...the LED's were turned around, in our device they were in the other way around, compared to the LED matrix used in the script of the link.....
:-(, always the same.....look closer, expect changes everywhere, details details....
but ok, in the end....it worked within a day, and the script is great!

(In this last image the camera sees what the eye cannot see: the LED steered on and off faster than we can see.) Our plan is to built this LED matrix into clothing behind a half transparent outer layer. Use a distance sensor, and change the running text according to distance of others from ourselves...
*** Peter van Vliet explained the (for me) incomprehensible part in the C++ file of the FrequencyTimer2 lib.
What was the problem? We noticed this part at the top of the source file:
{
static uint8_t inHandler = 0; // protect us from recursion if our handler enables interrupts
if ( !inHandler && FrequencyTimer2::onOverflow) {
inHandler = 1;
(*FrequencyTimer2::onOverflow)();
inHandler = 0;
}
}
without a function name....
The explanation is that this part will be flashed in the first part of the program section on top op everything else. It will be called every cycle, which makes sense seeing the purpose of the FrequencyTimer2 lib. So this is special chip (embedded) programming.

Liquid crystal display WD-C2704M and the ARDUINO

2009-06-25T13:15:00.000-07:00

Some time ago we bought a liquid crystal display WD-C2704M. It was a cheap one with 4 lines of possible text.

Of course there are a lot of liquid crystal, some preprogrammed, some with nice connected wires etc, the best (probably the most expensive too :-)

http://www.eink.com/press/releases/pr87.html

But back to our thing the WD-C2704M, of about 5 euro's....at www.pollin.de

It came with a the wires in a special flat plastic setting:

we should have bought the special slot for this, but we soldered, and all wires got mixed up, because they came loose from the ground....we scratched holes in the plastic isolation and succeeded in soldering the wires again. This already made the task daunting: around 20 wires so close together!

It took a while to find the specs. (Because we didn't buy it at pollins, there the datasheets can be found easily, we also paid tooo much at the other place (about 10 euro too much) haha!). Documentations are in German. No problem for the dutch...

WD-C2704M-1HNN.pdf
Text-LCDs.pdf

the pins of the display:

The display is HD44780 compatible, indeed it should be a double separated display. How to program this?
There is a liquid crystal lib for the ARDUINO. But this one is for 4 or 8 bits, so a max of two lines. This display has 4 lines.
We could make a new CPP lib out of the liquidCrystal.h, using the Cpp in the folder hardware\libraries\LiquidCrystal of the ARDUINO files.
This was our first try, following the instructions carefully of the setting up. We tried to set the display up in one go, setting the enable pins the one after the other.
Somehow this file got mixed up, and it refused to function.

The second try was nice and clean, the idea was just to make two different instances of this liquid crystal object:

LiquidCrystal lcd(13, 12, 11, 9,8,7,6,5,4,3,2);//the upper two lines
LiquidCrystal lcd1(13, 12, 10, 9,8,7,6,5,4,3,2);//the lower two lines

the last parameters are the ports, the difference is the enable port, coming from crystal pin: enable one goes to ARDUINO 10 and enable 2 to ARDUINO 11.
This way the two halves, upper and under are seperatly steered. And this solved the problem!

#include

//then setting up is easy: (actually already done)

void setup()
{

lcd.print("hello there");
lcd1.print("goodbye");
}

the two lines are displayed in the two halves.

a test to see what is possible:

lcd.print("hello there and how are you0123456789012hello there and how are you");//first two lines filled.

displays:
hello there and how are you
hello there and how are you

we have 27 characters on the first line of upper, then several spaces not shown, then the next line starts.
The first 27 are mentioned in the specs, but the gap is not what is described....the gap in memory addressing is 13 spaces, making it to 40 (decimal, which is not 64) to start the next line.

so here something is wrong in the data of this image.

The second line the same of course, because it is the same kind of object.

Possible mistakes (the ones we made :-)

As already mentioned: not buying the right slot for the wire connection.

then not connecting the right wires, because of the amount of wires, this is easy....this shows by not producing the right characters, or a lot of spaces.
the next mistake was to connect the pins in the wrong direction, that is , the other way around. Then the setting up wont be done properly and all kinds of problems occur, like not using the 4 lines etc.

Then there seem to be several LiquidCrystal.h files around in different ARDUINO versions.

The ones which worked (also on PC) were the files from the MAC 012 version of the ARDUINO.
Testing on other .h files will be done, now that the wiring is ok.

Also sometimes the ARDUINO + display must be disconnected and connected again to show all lines. This feature is described: resetting the ARDUINO does not reset the display.

ok in the end, when it works, all is fine.

We learnt a lot on the library CPP files of the ARDUINO. So in fact how to write our own classes for the ARDUINO scripts in CPP.

And we learnt where we could buy the cheapest LCD of this kind! www.pollin.de, much other cheap fun around there, the only problem is that they don't accept credit cards or paypal.

E paper workshop example files

2009-05-28T22:38:00.001-07:00

The technical aspect: you ask for images, sounds, using a FLASH movie from keys from the keyboard. But then you decide to make a paper switch, which is just more fun than a dull key. So you need a device/program in between, there are lots of possibilities: hacking a keyboard, using a HID, or using the ARDUINO.

With a hacked keyboard (see other blog) all is easy, just use the FLASH movie.

With the HID, KeyWiz40 interface (we have some at CROSSLAB) use a program between this thing and the FLASH called USB OVERDRIVE (Mac - Windows Joycur for instance)

With the ARDUINO use Serproxy, both MAC and Windows, but different files.

All is included in the download file below, (search USB OVERDRIVE here: http://www.macupdate.com/info.php/id/7115 )

So:

MAC and WINDOWS:

download this folder with the example files in FLASH:

http://www.contrechoc.com/flash/e-paperFiles.zip

all can be tested with the normal keyboard too.

added is also the posibility to stream a video (flv format). Just add the video in the folder and ask for the name of the video (under button “6″)

then for the KeyWiz40 interface:
For “normal” e-paper using the keyboard interfaces from Crosslab we can use this example flash movie, with he folders sounds and images:

keyboard input examples.fla

we need for MAC: USB OVERDRIVE between the Whiz HID and FLASH, configure the buttons after choosing the “joystick” tab on the left.

for WINDOWS: for example JOYCUR (or other freeware), also configure some buttons

——————————————————————————————————–

ARDUINO triggered e-paper, with the same FLASH movie:

WINDOWS:

For e-paper triggered by input from the ARDUINO we start the SERPROXY (windows version) first (after having configured the right port in the serproxy.config, see the com port in arduino tools insert it (three times or so) and the FLASH port must be 5331 please!)

then we need the ARDUINO script: arduinoAsKeyboard.pde in the ARDUINO.

then this flash movie: ARDUINO input examples.fla

MAC:

also use SERPROXY but the mac one found in the folder.

You have to configure the serproxy.config file, using your serial connection, found in the arduino tools, or via the terminal using “ls /dev/cu.usb*” as explained on this page: http://protolab.pbworks.com/TutorialFlashSetup

for the rest all the same, so upload the ARDUINO and run arduino script, and then run the FLASH movie.

/*******************************************************************************

For the real lover of e-paper: in the folder above is added a Processing example of reading the ports of the ARDUINO and triggering sounds, images, and text using Processing.The Arduino script used is the same as the last example: reading inputs from ports 12,11,10,9,8, this can be expanded. This eliminates the use of serproxy, or overdrive. But of course the Processing is not as flashy as FLASH!

Cheapo’s - or an Instable Multi Vibrator (!)

2009-05-28T22:29:00.002-07:00

The ARDUINO is sometimes far too big, like a dinosaur in a cupboard. If you want to do a few switches or some simple sensor effects you can use an ATTINY13 for instance, lots of examples to be found on www.instructables.com. You have to program these insects, but the hex files are given too. So in fact it only resolves to loading the program another (clever) person made in assembler.

Another example of a useful IC is the 555 timer (also abundant on instructables), i came across some nice examples:

this is a switchlight, costing about 80 cents! http://www.circuitsonline.net/circuits/view/13

and then the instable multivibrator, or in normal language an ORGAN,

http://www.circuitsonline.net/circuits/view/130

very makeable, so i ordered some 555’s fast at conrad’s

The big advantage of these smaller IC’s is that they can be built/hidden into books, clothing, in toys without a problem, of course on itself they can do not too much, but with the help of the relais (see the blog before this one), they can steer processes as big as you want!

Cool materials, smart whatever, where do i buy it?

2009-05-28T22:29:00.001-07:00

You know all kinds of interesting things are everywhere, but even with internet they are pretty difficult to find.

So here the result of a bit of experience, and indeed lots of houres searching.

Since I am on a tight budget, trying to make the most of it, i try to avoid “handling costs” or expensive ways of posting.

These links may change or disappear!

First of course: search in your neighbourhood: Harolds has graphite powder, thin metal wire to sew.

A real cool site is this one:

http://mutr.co.uk/ —postal costs not indicated???

thermo sensitive stuff, conductive stuff, EL, phone flasher, fancy switches, and even expensive things, like conductive cloth in small quantities so it remains affordable….

http://www.sparkfun.com/

for all around Arduino (and the lilypad ), very exciting
(for me as a contrechoc.com and addict to five sided things:) ProtoBoard - Penta-shape, five angled board, don’t buy these, because these are mine :-)!

Sparkfun for conductive thread: yes expensive (everywhere) 20 euros…:-(

for all kinds of electronic equipments, resistors, relays, diodes, also EL sheet:

http://www.conrad.nl/

this comes in handy because the delivery is relatively fast, for us in Holland.

For EL wire, in Rotterdam! So i can go there on bike and save me 6 euros posting

http://www.kitelight.nl/

For thermo-sensitive pigments, used for silkscreen:

http://www.zijdelings.eu/dupont.html

ok here the direct link: http://www.zijdelings.eu/overige-pigmenten.html

For Liquid tape, used with graphite powder from Harolds, to make conductive glue:

http://www.classicinternational.nl/textned/plastidip.htm

(minimum order 25 euro)

Ok, no, not at all: they don’t pay me for making this publicity!

The other way around, also on three legs

2009-05-28T22:28:00.003-07:00

A pushbutton for the ARDUINO needs three wires, this is for an input. The output, steering something from the ARDUINO has (no wonder) also three legs, it can be done by a transistor:

The middle wire of a transistor is the boss. When it has the proper signal (depending on type of the transistor , HIGH or LOW) it lets current pass through the outer two legs:

The port can have a 4.7K Ohm resistor, the effect only depends on the HIGH or LOW!

Cees Baarda provided with a transistor type: BC547C, others can be used too.

This way you can switch on or off: LED’s, speakers, etc. For more complex things to switch on, being on higher voltage than the ARDUINO, or if you want to save the power of the ARDUINO (using it stand alone, not on USB) and the thing to switch on has its own power, then you use a relay (relais).

A relay has two circuits, one to switch it (on low voltage) and the other (independant) with the real voltage, which can be much higher. The small voltage switches the high voltage circuit. Here is the picture from the datasheet from a relay:

You see legs 1 and 10 are the low voltage steering pins, and both sides have a high voltage switch between pins 7 and 8 (3 and 4).

So you can use the transistor to drive the relais, and the relais to switch on heavy duty things! Here the drawing of Cees Baarda, tested!

From this relay the High Voltage of EL wire, or EL sheet can be switched of and on, regulated by the ARDUINO. The relais makes a sound (the magnetic jumper like a ticking “cloque de coucou”

PS there is one more: the diode protecting the input port…..but it all very do it yourselfable.

PSS what does this cost? - where to get it?

relatively cheap: transistor BC547c conrad.nl 0,13 euro

resistors (koolfilmweerstand) conrad.nl 0.09 euro

relay (relais) conrad.nl 1.69 euro

diode conrad.nl 0.04 euro

Even a button has three legs

2009-05-28T22:28:00.001-07:00

Connecting a button is one of the easiest things to do. A light switch should transmit, or not transmit current, being on of off.

Although some reflection reveals that in reality it is not easy either: a window won’t stay open or shut without a hook, nor a door…

Receiving a signal from a button on an Arduino (Lilypad) is just a bit more complicated than the Boolean (TRUE - FALSE) character found in the laptop

A button on the ARDUINO (or comparable) is read in a digital input port registering either a HIGH or a LOW (being either a connection to 5V or to the Ground GND). So a button has three wires! Two wires to 5V and GND respectively and one to the digital input port.

Also: the button needs a resistor (otherwise there might start running a current and you have a short circuit!). You have to make “the standard” state of a port either a HIGH or LOW, and the non standard, pushed, state where the button connects to the reverse but this last connection through the resistor (10K).

When you make connection only to the HIGH for example through the resistor, then the LOW state might become HIGH too, because it is not kept LOW. This gives erratic (artistic) behaviour! (Ever waked up at night because of an unsecured windowmaking lot’s of noise?)

See all this explained much more technically:

http://www.arduino.cc/en/Tutorial/Button

This is not at all difficult, but just a bit more complicated then you would think, seeing a light switch in a lamp.

Details:

in this link

http://www.lulu.com/items/volume_63/1108000/1108699/4/print/ARDUINO_NOTEBOOKv6.pdf

i came across an important remark, apparently saving the trouble of putting the pullup resistors, because the input port is already protected:

“Arduino digital pins default to inputs, so they don’t need to be explicitly declared as inputs with pinMode(). Pins configured as INPUT are said to be in a high-impedance state.
There are also convenient 20KΩ pullup resistors built into the Atmega chip that can be accessed from software. These built-in pullup resistors are accessed in the following manner:
pinMode(pin, INPUT); // set ‘pin’ to input
digitalWrite(pin, HIGH); // turn on pullup resistors
Pullup resistors would normally be used for connecting inputs like switches. Notice in the above example it does not convert pin to an output, it is merely a method for activating the internal pull-ups.”

more interesting stuff on the pull-up: (apparently the above is partially copied from this source or the other way around:)

http://www.arduino.cc/en/Tutorial/DigitalPins

a very extended bunch of ARDUINO things:

http://www.freeduino.org/

Lilypad

2009-05-28T22:27:00.001-07:00

The Lilypad is much more designed than the ARDUINO. The arduino itself is a working horse, a factory. All kinds of hidden extra possibilities, like we have seen in other posts on this blog, even more to come! The ARDUINO board is rectangular, functional. The Lilypad is round, and the pins are shaped like a flower. Also the habit of putting shields on top of the ARDUINO is not possible with the Lilypad. The microcontroller is a bit different, being a ATMAGE168V, smaller, and not replacable(so be careful!). Lilypad can run on a 3V coin battery.

The Lilypad was designed and developed by Leah Buechley and SparkFun Electronics. It can be used as a wearable much more comfortable than the ARDUINO, although, when using small scripts, either a “naked” ATMEGA168 can be used, or even a Tiny13. These IC’s without the boards can be hidden quite easily too.

But no using the Lilipad, you have to SHOW it!

Starting it up is different too. You can use the ARDUINO (without the ATMEGA168) to transfer scripts. See the http://web.media.mit.edu/~leah/LilyPad/01_computer_attach.html The resetting of the Lilypad and the starting the transfer of the script is rather tricky! I saw my Lilypad flickering so I knew it was alive, otherwise… In XP it didnt work at all, On my OS side (of my MACBOOK) with apparently a different setup of the ARDUINO software (version 012) it works after a few tries. So first you get an error “out of sync” or “programmer not connected” the suddenly, the normal announcement of the script size (in the editor window of the ARDUINO software). So keep trying, resetting the Lilypad after hitting the transfer button varying a bit in seconds between these two actions.

My first real test was sewing the Lilypad on a cap, with a light resistor, when the light goes, (or somebody tries to steal my cap) a LED is fired up. Not very spectacular, but good as a starter. I didn’t try to hide the wiring!

Having to transfer these scripts (after testing the script on a normal ARDUINO), having to sew the Lilypad on the clothing, and thinking about how to hide, or show the wiring…this becomes a complex job!

And be careful not to walk around showing the Lilypad in Airport areas, because people might think that you want to blast the place away and call the police (this has actually happenend, see the last MAKE magazine, and the consequences for the “really innocent”wearer were not pleasant!).

A few links:Very much the Lilypad home: http://www.cs.colorado.edu/~buechley/LilyPad/index.html

This link to get arduino (in general) running in 15 minutes and…the help!:http://www.ladyada.net/learn/arduino/help.html

lilypad doc:http://arduino.cc/en/Guide/ArduinoLilyPad

a report of a workshop:link:http://web.media.mit.edu/~leah/publications/buechley_CHI_08.pdf

Saving an ATMEGA 168

2009-05-28T22:26:00.000-07:00

Why did I write this mail to Jeff?: (it is a long story…)

http://mightyohm.com/blog/2008/09/arduino-based-avr-high-voltage-programmer/

He Jeff, thx, for the artschool in Rotterdam Holland (WDKA) I thought I could save a bit of money buying ATMega’s instead of Lilypads and Arduino’s. I ran in the same fuses trouble I found in your blog (having more experience in Iphone programming :-). Just in this holiday week I decided I could try building your shield. I had to be careful (so being not at all artistic) and indeed I succeeded in…yes! making a tiny shortcut in between two near pins, of course the 5.5V and the GND of the ARDUINO. Invisible to the naked eye, there was a microscopic soldering error on my board between the not even “used” pins!
USB protection saved me twice, but then amazingly my shield (a master copy of your shield) worked! I could recuperate the ATMEGA 168. (And the 9 others I had apparently meshed up!)

(See Bootloading the Arduino a blog of 27 januari.)

you see the Arduino is so rectangular, the lilypad is already nicer, but the single ATMEGA is even more small and “hideable”. Only, get this thing programmed! (Don’t forget to set the internal timer….)

What happened? I wanted to try “the naked ATMega168″. But I ran into trouble: the hex file to bootload the ATMEGA was nt the right one. First i started altering settings, I didn’t know about fuses, lockbits, so….in the end I foudn the right HEXfile, see former blog about this. But then apparemtly I already had bad settings for quite a few of the 10 ATMEGA’s.

So I started digging the internet and found the blog of Jeff. But well, it took me a few weeks to decide to build this shield (picture above). And after some trouble it did save 7 out of 10 ATMEGA’s. For the last three i am writing in the file of Jeff on the ARDUINO the eraseChip function, but that does not save me at the moment. Anyway, you don’t save time buying naked ATMEGA’s But i have learnt a lot! Being able t make a shield is perfect and from the script of Jeff i learnt the possibility of setting ports 0-7 at once using the DATA.

And in the end the best reward is when it actually works!

I lost this link several times: the datasheet, the page to program HIGH VOLTAGE stuff is around 297:

http://www.atmel.com/dyn/resources/prod_documents/doc2545.pdf

Hacking a keyboard

2009-05-28T22:25:00.000-07:00

Looking for an easy way to get a lot of input possibilities attached to the computer, you could think of hacking a keyboard. That is taking it apart, finding the key matrix (a matrix is like a chessboard), and making the switches you need. It is all very well described here:

http://www.extremetech.com/article2/0,2845,2301149,00.asp

but also the writer warns that: there is no standard key matrix, so all types of keyboards have to be checked individually and that you have to be careful not to damage your computer, third you have the problem of ghosting, that is three buttons might awaken an extra ghost button.

Alternatives are available: prepared boards. A bit more expensiv, but first of all, you know it will work, second, you cannot damage you computer.

These hacks are listed here: http://wiki.arcadecontrols.com/wiki/Keyboard_Encoders

So I-PAC (USB): (31 euro’s + 4 TAX, feb 2009)

http://www.ultimarc.com/ipacve.html

it comes with WinIPAC:

http://ultimarc.com/download.html

KeyWiz40-Eco (26 dollar, TAX ? )

http://groovygamegear.com/webstore/index.php?main_page=product_info&cPath=76_80&products_id=200

(no experience yet with these hack-boards! But they seem to be good…although noting is better then DIY, ok maybe sometimes it does not function then….:-)

Since the keyboard strokes are recorded and taken care of in FLASH (for instance) no need to reprogram the strokes anywhere else.

As an alternative to keyboard or the above mentioned keyboard chip, one could simple use the ARDUINO like the key matrix. Making ports input, and reading out the combinations, using the FLASH connection (or other) described elsewhere in this DIY blog.

first possibility: simple using the ports, setting all ports to input, use a 100 - 200 Ohm resistor and a switch.

second possibility:(using less ports, making combinations)

For instance: using 3 ports:0 = low, 1 = high, ports are connected to a single switch.

000 = a, (sending an a through the serial connections)

001 = b

010 = c

011 = d, etcetera

since the ARDUINO has 14 input ports (not counting the analog ports) we have a bewildering number of possibilities. (2 to the power of 14)

Third possibility, like the keyboard matrix:

use two rows of ports, look at the keyboard, 4 rows of keys, from bottom to top, use 4 porst for these rows, then take for instance 5 keys in each row, and connect these to five other ports, so each key is connected (with a switch) to 2 ports, the first determining which row to pick and the second which character in the row.

Then you see suddenly how many keys there are on a keyboard! Covering the whole keyboard with an ARDUINO, you have to divide the keyboard into regions, adding the number of rows, or take an extra switch to connect to each key…This will be a lot of work!

Maybe the above mentioned keyboard alternative is not so bad after all?

(Using the ARDUINO with FLASH, you need serproxy, and setting the serproxy config to the port used by the ARDUINO software - see other blog.)

So i started buying a flexible keyboard on the market. The purple one i didn’t sacrified, but a white one. Seeing through the layer reveals the wiring. On the side we have the chip. There are a lot of shortcut revealed! Trying out connections from the two side, sometimes the computer falls asleep, sometiems all is saved :-). So indeed be careful! I used male connectors to slip inside the matrix board. Here some pictures: (try connecting wires from the strip left under to the strip right under…

we bought this for CrossLab:

http://groovygamegear.com/webstore/index.php?main_page=product_info&cPath=76_81&products_id=235

Bootloading the Arduino

2009-05-28T22:24:00.001-07:00

The heart of the Arduino is the ATMEGA chip. The rest is only decoration! Decoration needed to get your program at the right spot, so useful decoration in the end. When you have an Arduino you can change programs all the time, but that means you always loose the last experiment. So buying the ATMEGA heart and storing your program on it, wiring the sensors and other elements definitively together you can save your stuff, without buying another Arduino.This saves you about 20 euro’s, but you have to do something 4 it!

The atmega168 can be bought for 4 .5 euro’s, with the 28 pin foot about 5.

This chip has to be bootloaded, so that the Arduino software can write to it. Crosslab has AVRISPmkll as an external programmer.

It took me a while to find out which hexfile to load. The Duemilanove needed the ATmegaBOOT_168_ng.hex, the configs given on the page http://www.arduino.cc/playground/Learning/Burn168

configs, fuses, whatever — were ok, but the bootloader to be downloaded (ATmegaBOOT_168.hex) was not. (Although indicated on the Arduino playground page.)

Be careful with the fuses and never set the disable reset pin!!! See below or: http://tinker.it/now/2007/02/24/the-tale-of-avrdude-atmega168-and-extended-bits-fuses/

The fact that it was not working could be checked when resetting: the LED 13 did not light up. Then transferring a script from the Arduino software gave an error.

With the right bootloader HEX file, the reset worked, and the transferring too.

Ok with this knowledge and experience, we can quickly make ready and program ATMEGA 168IC’s and use them for our projects. The chip can be sewn in clothing making smart textiles.

link adaboot: http://wulfden.org/TheShoppe/freeduino/ADABOOT.shtml

One of the ten ATMEGA168 refused to get flashed, it was one of the first, and suffered probably a setting of the DISABLE RESET PIN. That is something to be avoided next time. The solution will cost a bit of extra effort and time: high voltage programming and making a shield: http://mightyohm.com/blog/2008/09/arduino-based-avr-high-voltage-programmer/

may be that Do-It-Yourself is for another day!

for the moment 9 out of 10 ATMEGA168’s are bootloaded…

The last ATMEGA has to what for high voltage programming (well high = 12V)

link for the AVR if you want to program in assembler (only then u r a real ‘man’) _ http://www.howtofriends.com/avr/

good ATMEGA info: http://en.wikipedia.org/wiki/Atmel_AVR

pinmapping: http://www.arduino.cc/en/Hacking/PinMapping168

connecting the ATMEGA168 “naked”: http://itp.nyu.edu/physcomp/Tutorials/ArduinoBreadboard

or http://blog.makezine.com/archive/2007/07/barebones_arduino_on_a_br.html

later on I found the best link explaining about the ATMega168:

https://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=93

and all about oscillators:

https://www.sparkfun.com/commerce/tutorial_info.php?tutorials_id=95

I2C on the NXT again! ( no: PCF8574A!)

2009-05-05T11:34:00.000-07:00

We went back to the nxt for a moment.
We tried the PCF8574, (actually mindsensors.com sent PCF8574A) I2C chip of mindsensors.com with the arduino, that worked fine on a breadboard with the wire.h class of the ARDUINO example.

But the PCF8574A would not come alive with the NXT. We used the Anderson CPP lib, with bluetooth.
But we discovered again what we already did actually know: you cannot write registers on the brick using bluetooth, so the address is not reached.
(not very understandable at the moment, but we saw this too with the clock sensor....:-(((, it did cost a lot of time to figure this out.....why is the Anderson lib giving this possibility?? Did he succeed here?)

So we tried the program on the brick. We had to reflash it, and we stumbled over my multiple USB connections (nxt not found......but without the hub, USB directly into the laptop, the NXT was at last found.)

Then we had to figure out the i2c lejos class, we had this trouble with the former lib, (before the update) that it had the I2c addresses doubled, and indeed we found out from examples that some used 0x70 as the address.

But the last update (nov 2008 0.7) just uses the (official) address also used for the ARDUINO: 0x38.
(So not the 0x40 mentioned in the mindsensors.com documentation.)

Finally the LED's lighted up on the breedboard and on the mindsensors thing.

The only problem left is this one: sensor.sendData(address, byte); but this means i can steer only 4 pins of the PCF8574A (1111 = F is one byte)....(?).....how to steer all 8? (Solution is simple see rest of blog)

sensor.sendData(address, byte[], len); did not help......

anyway we used this code to steer half the PCF8574A:

import lejos.nxt.*;

public class I2C {
public static void main(String[] args) throws Exception {

I2CSensor sensor = new I2CSensor(SensorPort.S1) ;

int address = 0x38;
byte value = 0x0;
while (!Button.ESCAPE.isPressed())

{
sensor.setAddress(address);
LCD.drawInt(address,0,0);
value = 0x5;
sensor.sendData(address, value);
LCD.drawString("High",3,4);

Thread.sleep(500);

value = 0xA;
sensor.sendData(address, value);
LCD.drawString("low ",3,4);

Thread.sleep(500);
}
}
}

Then we searched for further solution of this last problem on the web and found this interesting application of the I2C sensor:

http://www.extremenxt.com/keyboard.html

What is this byte problem?
Eclipse registered a mistake in: sensor.sendData(address, 0xFF); -- saying this 0xFF is no byte. The solution is simple: sensor.sendData(address, (byte)0xFF); -- and you can steer your eigth pins!

ok the A0, A1, A2 pins can be used to attach rather a lot other PCF8574A chips to the same port. Because these pins make 8 base adresses possible, of chips steering 8 LEDS, makes 64 LEDS from one port!

my idea is to let the ARDUINO and the NXT talk to each other by way of the I2C chips.....then you have a ARDUINO with bluetooth connection...well in principle.....

it is nice to have some different controllers and consoles around, NXT ARDUINO, NDS (serial extension), IPHONE......it is very interesting to compare these systems. In the end the connections and the sensors are the same.....

last tutorial lejos: http://lejos.sourceforge.net/nxt/nxj/tutorial/index.htm

found a good descritpion of the PCF8574: http://www.i2cchip.com/pcf8574.html#PCF8574

at voti the PCF8574 costs 2,62 euro, http://www.voti.nl/winkel/catalog.html

ever wanted to know all about i2c: http://www.i2c-bus.org/

Last problem: when connecting the UltraSound distance sensor to the brick and steering the LEDS on the I2C "sensor" from the distance, refreshing all the time, we got a terrible effect of the LEDS between refresh all lighting up. So between indicating the distance we get a flash of all LEDS. This was still the case on a breadboard (without the mindsensor.com print). Not resolved.

the ARDUINO script can be found here: http://www.contrechoc.com/flash/arduino-i2c.txt
the JAVA script (made in eclipse) can be found here: http://www.contrechoc.com/flash/lejos-i2c.txt

RFID ARDUINO SL performance on “Open dag”

2009-02-11T08:51:00.000-08:00

All about having the right connections, like in real life:

See the tag hidden under the robot’s foot, the reader was hidden under the table. The walking robot triggered the RFID reader, wich was connected to a FLASH movie.

Then the ARDUINO was triggered by this FLASH movie. Sound was played on a speaker attached to the ARDUINO. The FLASH movie also changed a setting in an external database. This database is frequently checked by an object in Second Life called RFID Poltergeist. When this object sensed the changed setting, a wheelchair was rezzed in mid air. Since this wheelchair was made physical, it crashed down on the Poltergeist!

See the pile of wheelchairs, all temporary of course, one should keep the world tidy.

A teacher told me this was all too funny. ICT is not funny at all according to him. I quite agree. But i cannot help it. All i do becomes funny, sorry.

FLOSC GLOVEPIE FLASH

2009-02-08T00:06:00.000-08:00

Working on a MACBOOK the "wiiflash server" did not see my connected wii remote. It told me no wii remotes were connected.

(Not on the XP side, neither on the OS side)

(Never buy a MacBook: the double boot is ok, but all kind of problems with 3D programs, like Second Life BLENDER, and now also wiiflash, the Xcode is ok though, nice making a game for the Iphone, see other blogs)

Working on the XP side:

BlueSoleil only caused other problems.
So i relied on the simple bluetooth window provided by XP for connecting the wii remote.
Then i remembered the FLOSC, i searched the internet and found some vague references to this alternative to the wiiflash server.

After a bit of experimenting i found out what to combine and how:

1. Connect the wiiremote
2. start up GlovePie with this script (example script to connect and read a few values, change to what you need)

OSC.port = 5000 // referring to OSC port in FLOSC ... OSC can be changed, it is just a variable name
OSC.ip = "localhost"
OSC.broadcast = true

OSC.wii.x = Wiimote.gx
OSC.wii.y = Wiimote.gy
OSC.wii.z = Wiimote.gx

OSC.roll = RemoveUnits(Wiimote.Roll)
OSC.pitch = RemoveUnits(Wiimote.Pitch)

3. start FLOSC:
portnumbers from GLOVEPIE and FLASH

4. example script in FLASH with a XMLsocket connection reading the XML input coming from FLOSC:

import flash.events.*;
import flash.net.XMLSocket;

var hostName:String = "127.0.0.1";
var port:uint = 1250; // referring to flash port in FLOSC
var socket:XMLSocket;

socket = new XMLSocket();
socket.connect(hostName, port);

socket.addEventListener(DataEvent.DATA, dataHandler);

function dataHandler(event:DataEvent):void {
var xmlData = new XML();
xmlData.ignoreWhite=true;
xmlData = XML(event.data);

/* comment example
ADDRESS = attribute
MESSAGE = descendant

incoming: (picture, because XML data are not visible on this page :-)

gives: (with trace line below)

/wii/x
f -3.9451861
*/

trace( xmlData.descendants("MESSAGE").attribute("NAME") );
trace( xmlData.descendants("ARGUMENT").attribute("TYPE") + " " + xmlData.descendants("ARGUMENT").attribute("VALUE") );

}

6. make use of the data in fancy flash application!

for instance: asking for the x value:

if ( String(xmlData.descendants("MESSAGE").attribute("NAME")) == "/wii/x")
giveNumberX.text =String(xmlData.descendants("ARGUMENT").attribute("VALUE"));

putting the value in the field giveNumberX.

Have fun!

ARDUINO for 5 euro (?)

2009-01-27T12:58:00.000-08:00

The atmega168 can be bought for 4 .5 euro's, with the 28 pin foot about 5.

This chip has to be bootloaded, so that the Arduino software can write to it.You need for instance AVRISPmkll as an external programmer.

It took me a while to find out which hexfile to load. The Duemilanove needed the ATmegaBOOT_168_ng.hex, the configs given on the page http://www.arduino.cc/playground/Learning/Burn168

configs, fuses, whatever -- were ok, but the bootloader to be downloaded (ATmegaBOOT_168.hex) was not. (Although indicated on the Arduino playground page.)

The fact it was not working could be seen when resetting: the LED 13 did not light up. Then transferring a script from the Arduino software gave an error.

With the right bootloader HEX file, the reset worked, and the transferring too.

Ok with this knowledge and experience, we can quickly make ready and program ATMEGA 168IC's and use them for our projects. The chip can be sewn in clothing making smart textiles.

link adaboot: http://wulfden.org/TheShoppe/freeduino/ADABOOT.shtml

One of the ten ATMEGA168 refused to get flashed, it was one of the first, and suffered probably a setting of the DIABLE RESET PIN. That is something to be avoided next time. The solution will cost a bit of effort and time: high voltage programming and making a shield:http://mightyohm.com/blog/2008/09/arduino-based-avr-high-voltage-programmer/

:-) may be that Do It Yourself is for another day!

for the moment 9 out of 10 ATMEGA168's are bootloaded...

(from my DIY blog on the WDKA)

Communicating reading writing Arduino FLASH

2009-01-20T22:54:00.000-08:00

Using TinkerProxy you can receive data from the Arduino doing something in FLASH.
(Using the socket server)
But you cannot send data back from FLASH to the Arduino
This can be done with Serproxy, but you have to change the config file to the right port:
(several links explaining for instance: http://www.tinker.it/en/Teaching/Flash )

when configured the Serproxy allows reading and writing.

so this Arduino script sends 0 and 100 alternately and listens for a value.
When this value comes it puts this value on ledport 9.

/* read and write script (combining two arduino sketchbook scripts
*
* blink without delay and send the values to a socket
* listen for data sent to the arduino and react on a ledPin 9
* from FLASH an int between 0-255 is sent
*
*/

int ledPin13 = 13; // LED connected to digital pin 13
int ledPin9 = 9;
int value = LOW; // previous value of the LED
long previousMillis = 0; // will store last time LED was updated
long interval = 1000; // interval at which to blink (milliseconds)

void setup()
{
pinMode(ledPin13, OUTPUT); // sets the digital pin as output

// begin the serial communication
Serial.begin(9600);
pinMode(ledPin9, OUTPUT);

}

void loop()
{

if (millis() - previousMillis > interval) {
previousMillis = millis(); // remember the last time we blinked the LED

// if the LED is off turn it on and vice-versa.
if (value == LOW)
{
value = HIGH;
Serial.println("100");
}
else
{
value = LOW;
Serial.println("0");
}

digitalWrite(ledPin13, value);

}

byte val;

// check if data has been sent from the computer
if (Serial.available()) {
// read the most recent byte (which will be from 0 to 255)
val = Serial.read();
// set the brightness of the LED
analogWrite(ledPin9, val);
}
}

Then the flash script is opening a socket port: (using a simple modified script found on the arduino playground)

function openArduinoSocket()
{
//Create a socket connection to serproxy
arduinoSocket = new Socket("localhost",5331);
arduinoSocket.addEventListener(Event.CLOSE, closeHandler); arduinoSocket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
}

reading the data from the port:
function socketDataHandler(event:ProgressEvent):void
{
// Get the value from the potentiometer (0-1024) and
// normalize it to (0-2) range for the fire component.
var nb : uint = arduinoSocket.bytesAvailable;
var bytes:ByteArray = new ByteArray();
var input:String = String(arduinoSocket.readUTFBytes(arduinoSocket.bytesAvailable));
var ST: String ="";
for (var i=0; i<> {
if ( !(input.charCodeAt(i)==10 || input.charCodeAt(i)==13))
ST += input.charAt(i); } //we have to make a number from the chars or string getting in.....:-(
//right order????
var STNumber : Number = Number(ST.charAt(0))*100 + Number(ST.charAt(1))*10 + Number(ST.charAt(2))*1;

giveNumber.text = String(STNumber) ;
//writing it in a text field //from arduino script coming out either 0 or 100
if( STNumber > 25 ) {
giveResult.text = "high";
}
else {
giveResult.text = "low"; }
}

then comes the sending part: (just a timer which brightens up a led on the arduino)

var minuteTimer:Timer = new Timer(500);
minuteTimer.addEventListener(TimerEvent.TIMER, onTick);
minuteTimer.start();
var counter : int= 0;
function onTick(event:TimerEvent):void {
counter +=10; arduinoSocket.writeInt(counter % 250 ); //not higher then 250 arduinoSocket.flush();
}

ok next step is to take a rfid reader and make the rfid reader when seeing the right tag, sending a signal to the arduino, we need another USB port reader for this Phidget21 (we are using the phidget reader) ...

The Flash movie in connection with the rfid reader gave three mp3 sounds on three different tags. Then the functions of the Arduino socket were installed, the Arduino script a bit changed, adding a speaker to the Arduino.

The tags gave sounds in the FLASH movie, and at the same time the Arduino produced a tone on the speaker....an image (yeah, it is a shame you cannot here the sounds :-)

The Arduino can be seen, with the speaker, and the rfid reader with the tags, what cannot be seen are the Phidget21 and the serproxy, and the flash movie triggered by the rfid reader and sending data to the arduino...

Arduino and Sound

2009-01-11T05:51:00.000-08:00

What about making the Arduino and a simple loudspeaker produce a tone?

Quite simple:
http://www.uchobby.com/index.php/2007/11/14/arduino-sound-part-2-hello-world/

i quickly made a small change in the script to get a lightsensor alter the pitch:

#define SOUNDOUT_PIN 13
#define potPin 0
int val = 0;

void setup(void){
//Set the sound out pin to output mode
pinMode(SOUNDOUT_PIN,OUTPUT);
//output the serial port to check the values
Serial.begin(9600);
}

void loop(void){
//Generate sound by toggling the I/O pin High and Low
//Generate a 1KHz tone. set the pin high for 500uS then
//low for 500uS to make the period 1ms or 1KHz.

//Set the pin high and delay for 1/2 a cycle of 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,HIGH);
delayMicroseconds(val);//val instead of the fixed 500

//Set the pin low and delay for 1/2 a cycle of 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,LOW);
delayMicroseconds(val);//val instead of the fixed 500

val = analogRead(potPin);
Serial.print(val, DEC); //reading a lightsensor from a second volt divider, here checking values
Serial.print("\n");//to get an idea of what is read in and make a calibration of the pitch
}

Now I had a tone from a speaker, steered from a lightsensor, which could be replaced by other sensors. The volume can be regulated by a potentiometer in the first volt divider.

Then I used a small laser (the one to hang pictures really horizontally) and really could make the pitch jump, when the laser was on the lightsensor.
This could be the start of a low budget laserharp. Just make the tone only when a certain level of light is detected.

Here are the simple connecting drawings, the values of resisters and lightsensors must be experimentally tried out, for me it just worked with a 1 K resistor, lying around.

Arduino and Flash Second Attempt

2009-01-09T08:11:00.000-08:00

First in the Arduino program we created a simple program reading a light sensor (combined with a resistor).

Using this script:
//Arduino script
/*
int potPin = 0; // select the input pin for the potentiometer
int val = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
Serial.begin(9600);
}

void loop() {
val = analogRead(potPin); // read the value from the sensor
Serial.print(val,DEC);
Serial.print("\n");
}
*/

Using tinkerproxy this time, configuring the COM-port

Then starting Flash, with a socket:

arduinoSocket = new Socket("localhost",5331);
arduinoSocket.addEventListener(Event.CLOSE, closeHandler);
arduinoSocket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);

then reading the incoming bytes we have to make from this string a number:

var nb : uint = arduinoSocket.bytesAvailable;
var bytes:ByteArray = new ByteArray();
var input:String = String(arduinoSocket.readUTFBytes(arduinoSocket.bytesAvailable));

var ST: String ="";
for (var i=0; i<>
{
if ( !(input.charCodeAt(i)==10 || input.charCodeAt(i)==13))
ST += input.charAt(i);

}

var STNumber : Number = Number(ST.charAt(0))*100 + Number(ST.charAt(1))*10 + Number(ST.charAt(2))*1;

//we have to check if the order for one-decimal-hundred's is right??

ok this gave us a start.
but the values read were rather erratic

so we changed the script on the Arduino so that either a 0 or a 100 is sent:

//Arduino script
/*
int potPin = 0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int val = 0; // variable to store the value coming from the sensor

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT
Serial.begin(9600);
}

void loop() {
val = analogRead(potPin); // read the value from the sensor
if (val > 100)
Serial.print(0,DEC);
else
Serial.print(100,DEC);
Serial.print("\n");
}
*/

then the reading becomes:

//from arduino script coming out either 0 or 100
if( STNumber > 25 )
{
giveResult.text = "high";
}
else
{
giveResult.text = "low";
if ( myVideo == null )
{
myVideo = new VideoExample( videoPlayer );//loading video in videoPlayer Sprite
}
}

so this starts a video, in a separate class (from a FLASH example)

but we dont want to start this video all the time, :-)

var now2:Date = new Date();
var timeDifference: Number = now2.getTime() - timeTag1;

//here give length in time of video : this blocks reading
var lengthOfVideoInSeconds = 15;

if ( timeDifference /1000 > lengthOfVideoInSeconds )
{
myVideo = null;
timeTag1 = now2.getTime();
}

This procedure can be altered, and should be optimized, but it worked.

Arduino and Flash

2008-12-20T01:13:00.000-08:00

The Arduino can be made to cooperate with FLASH CS3 (and other languages).
A prog is put on the Arduino and running a XML socket in FLASH and a serverproxy we could get the serial port doing the connection.
The glue lib posed some problems, not really working with the firmata ???
In the end the example from the sketchbook called SimpleAnalogFirmata gave readings from an analog port and these readings were dispaled in the FLASH outputusing the SimpleIO from the glue library.

It seems CS3 poses more problems than CS2.
The code on this page, which must have worked then, didn't really work with me, it gave output, but the values were kind of rubbish: http://aralbalkan.com/1243

NXT Arduino and I2C

2008-12-20T01:00:00.000-08:00

Having ordered the I2C sensorkits from mindsensors.com we quickly soldered the components to the bord. But, it did not work. Since we had no idea how to analyze the situation, nor any idea how the real I2C sensor worked we left it where it was...

After a few months we obtained an Arduino. The philosophy of the Arduino is really different from the NXT. (Books can be written on this...:-)

A bit of research on the internet showed examples of how to connect the NXT to the I2C chip from mindsensors.com: http://www.tau.ac.il/~stoledo/lego/i2c-8574/
This schema also showes how to connect it in general, so also to the ARDUINO.
With the wiring.h lib of the ARDUINO we can connect to I2C input output ports. So the IC's from the mindsensor I2C kit could be steered using the Arduino too. Maybe we can get the I2C chip working and resolve the problem of the I2C chip and the NXT, finding our mistake with my soldering the mindsensor setup.
But not having too much experience (coming from the NXT, which shields this kind of troubles) we had to figure out the pin config of the chip.
First we were put on the wrong track by the sketch on the page of Silvan Toledo, which suggests quite a different pin config. ( http://www.tau.ac.il/~stoledo/lego/i2c-8574/ )
After a bit of time, (and failure) we found out the right pin config by looking at the datasheet of Philips.
(found here: http://www.datasheetcatalog.com/datasheets_pdf/P/C/F/8/PCF8574.shtml )

And now these IC's worked, we got the address right and we could connect 2 IC's to the same Arduino using different addresses. (More is possible, but we had only two PCF8574A.)
This gives the possibility to connect up to 8 times 8 LEDS to one Arduino.
(Something for a Led matrix...but these can be steered directly from the ATMega168 in other ways)

(actually reading nxtasy.org/wp-content/uploads/2006/08/digital%20vs%20analog.pdf
we can wonder about how many sensors can be connected to the NXT...)

Actually mindsensors.com ships the PCF8574A, and not the promised PCF8574. Does this make a difference? Actually in the Arduino code i had to change the adress from B0100000 (PCF8574) to B0111000 (PCF8574A)
(this hint was found out here: (also this code was used to test)
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1173047782/5
)

analog port 4 SDA
analog port 5 SCL (http://www.neufeld.newton.ks.us/electronics/?p=241 )

another experiment used one address port A0 to HIGH for the second PCF8574A.
and the second PCF8574A could steer LEDS.

The next step will be to get back to the NXT, now that we know the adress and the workings of the I2C inport output IC's.

The comment from Vinh Vu made us review the original text and add links and the picture. Vinh Vu asks how to connect the ULTRA sonic sensor (I2C) to the ARDUINO. The pin fig of the sensor showes the SDA SCL in the connector: connection to the NXT:
http://forums.nxtasy.org/index.php?showtopic=2092
this works: the ultrasound sensor clicks if the 9V is applied.

The experience with the bluetooth commands researched in other blogs seems to be the way to go...(? or does the NXT perform special things in between the commands, normally filtered out, to prevent hacking its expensive sensors for the cheapo ARDUINO :-)....

then looking at the Hardware Developer Kit (HDK) of Lego
http://mindstorms.lego.com/Overview/nxtreme.aspx
you find the communication protocol with the ultrasound sensor...will this work?

all seems to be understandable, but this remark indicates possibly (the expected) interference of the NXT:
---NXT firmware will deal with the "R + 0x03" part---

This links explains how to deal with the "R + 0x03" (does it?)
http://forums.nxtasy.org/lofiversion/index.php?t141.html

the above mentioned link explains the R in ARDUINO - wire terms: endtransmission begintransmission - i did already try it that way...

anyway first try the most basic: shutting the sensor off using:
0x02 write address 0x41 internal address 0x00 write zero

all kind of variations tried out,
Wire.beginTransmission(expander);// tried expander 0x01 and 0x02

Wire.send(0x41);
Wire.send(0x00);
etc.
or

char a[]= { 0x00, 0x41, 0x00 }; // { 0x41, 0x00 }
Wire.send(a);

the sensor still clicks....
so.....

unsolved problem, better either use the nxt in combination with the Ultrasound and use bluetooth in combination with C#, see bram fokke lib, or use a distance sensor the ARDUINO can handle without a problem?

PSP-NX and the lejos JAVA class

2008-06-26T07:18:00.000-07:00

This PSP-NX sensor (www.mindsensors.com) can receive signals from the Sony Playstation controller and this input can be used to steer the motors or activate other sensors on the brick. In this sense this PSP-NX sensor is not a real sensor, not measuring "physical" data like light or sound. On the other hand it is funny to be able to steer the NXT around with the conveniance of this controler. Really convenient. The PSP is base on I2C so it is not the fasted around. Of course, because activating commands must be sent to the I2C sensor chip, this sensor has to be controlled in a prog from the brick, like the Camera, no bluetooth control of this sensor. We made the JAVA lejos class for this sensor: The only problem was (again, like the clock sensor) the strange handling of the COMMAND address by lejos JAVA: is has to be divided by 2!!! (See also the clock sensor class in this blogg) For the rest the buttons1 and button2 have to be decoded: Button 2 digits: 1 left down 2 right down 4 left up 8 right up triangle 16 circle 32 cross 64 square 128 Button1 digits: 1 select 8 start 16 left circle up 32 left circle left 64 left circle down 128 left circle left then the joysticks, the mode has to be analog, and then you have a nice range of 0 - 255 for both x and y directions

//JAVA class:
import lejos.nxt.*;

public class playstation extends I2CSensor implements SensorConstants
{
// Mindsensors.com constants:
private final static byte COMMAND = 0x02 / 2;//here the strange lejos divide by 2 to get address
private final static byte SENDADDRESS = 0x41 / 2;//to send the activation etc

byte[] buf = new byte[2];
SensorPort myPort;

public playstation(SensorPort port)
{
super(port);
myPort = port;
activate();
pause(100);
analog();
pause(100);
}

public void activate()
{
buf[0] = 'E';
super.sendDataSENDADDRESS , buf, 1);//energize
}

public void deactivate()
{
buf[0] = 'D';
super.sendData(SENDADDRESS , buf, 1);//power off
}

public void digital()
{
buf[0] = 'A';
super.sendData(SENDADDRESS , buf, 1);//digital mode
}

public void analog()
{
buf[0] = 's';
super.sendData(SENDADDRESS , buf, 1);//analog mode (for working joysticks)
}

public void ADPAON()
{
buf[0] = 'N';
super.sendData(SENDADDRESS , buf, 1);//connecting more sensors to one sensorport
}

public void ADPAOFF()
{
buf[0] = 'O';
super.sendData(SENDADDRESS , buf, 1);//not connecting more sensors to one sensorport
}

public int getData(int register, byte [] buf, int len) {
int ret = myPort.i2cStart(COMMAND , register, len, buf, len, 0);
if (ret != 0) return ret;
while (myPort.i2cBusy() != 0) {
Thread.yield();
}
return 0;
}

public String getMyProductID()
{
String version = " ";
char [] versionChars = StringUtils.getCharacters(version);
byte[] byteBuff = new byte[8];
int ret = getData(0x00, byteBuff, 8);

for(int i=0;i<8;i++) { versionChars[i] = (ret == 0 ? (char) byteBuff[i] : ' '); }
return version;
}

public String getMyDeviceID()
{
String version = " "; char [] versionChars = StringUtils.getCharacters(version);
byte[] byteBuff = new byte[8];
int ret = getData(0x10, byteBuff, 8);
for(int i=0;i<8;i++) { versionChars[i] = (ret == 0 ? (char) byteBuff[i] : ' ');
}
return version;
}

public String getMyVendorID()
{
String version = " ";
char [] versionChars = StringUtils.getCharacters(version);
byte[] byteBuff = new byte[8];
int ret = getData(0x08, byteBuff, 8);
for(int i=0;i<8;i++)
{ versionChars[i] = (ret == 0 ? (char) byteBuff[i] : ' ');
}
return version;
}

public int Button1()
{
int ret = getData(0x42, buf, 1);
return (ret == 0 ? ( 255 - buf[0] & 0xFF ) : -1);
}

public int Button2()
{ int ret = getData(0x43, buf, 1);
return (ret == 0 ? ( 255 - buf[0] & 0xFF ) : -1);
}

public int xLeftJoystick()
{ int ret = getData(0x44, buf, 1);
return (ret == 0 ? (buf[0] & 0xFF ) : -1);
}

public int yLeftJoystick()
{ int ret = getData(0x45, buf, 1);
return (ret == 0 ? (buf[0] & 0xFF ) : -1);
}

public int xRightJoystick()
{ int ret = getData(0x46, buf, 1);
return (ret == 0 ? (buf[0] & 0xFF ) : -1);
}

public int yRightJoystick()
{ int ret = getData(0x47, buf, 1);
return (ret == 0 ? (buf[0] & 0xFF ) : -1);
}

private static void pause(int time)
{
try{ Thread.sleep(time);
}
catch(InterruptedException e){}
}
}

With this class we made a nice prog in JAVA to steer the brick around.

nxt camera following

2008-05-06T01:10:00.000-07:00

all speaking for itself we think......(nxt is provided with a felt-tipped pen)
he will become a great artist this nxt
:-)

the prog has 2 modes: one displaying the light source on the screen, for checking what the nxt "sees". This is not very predictable from our human point of view. The second mode, if the responses are adequate, is direct reactions of the two motors to visual input.

left right movements are just seeing the source left right
forward backwards is done by detecting the source above or under the middle of the field of vision.

The movements should become more smooth.

Hopper

2008-04-22T06:04:00.000-07:00

We found this model of Laurens on the web:
http://ricquin.net/lego/laurens/
We got interested because of the use of the special Lego piece which we already used "in concept" for a gear box, see blog : gearbox of Jos. Here it is used to turn the model, the foot being attached to the inner circle, the motor to turn it, to the black outer half of this lego piece.

The Hopper is complicated and simple at the same time, the good thing of building models as examples is that you see how others use the Lego pieces to construct, there is always something to learn. For instance the use of the double black triangles.
Also we see Pythagoras is still working in a small triangle: square 8 + square 6 = square 10: the famous 3:4:5 trangle!
Ingenious is the way to combine the two motors to get the Hopper movement.
The use of the sensor is reduced: the ultrasonic sensor measures the distance and the Hopper turns when the distance is too small.
This turning is really something nice: first the thing turns on the middle foot, then it lift itself half a cycle, and the foot is turned, then another half cycle and the Hopper continues its way.

With the building instructions comes the NXT-G or firmware program.
It is really a beauty programm: where the FIRMWARE can be very concise:

We redid this program in Lejos-Java, it become somewhat longer.
Think of the synchronisation: adding the true in the Motor.A.rotate(360, true);

Here is the Lejos JAVA version of this prog: (somehow it looks more complicated, it isn't of course...)

//HOPPER JAVA

import lejos.nxt.Button;
import lejos.nxt.LCD;
import lejos.nxt.Motor;
import lejos.nxt.SensorPort;
import lejos.nxt.Sound;
import lejos.nxt.UltrasonicSensor;

/**
* leJOS version of the HOPPER program by Laurens
*
*
* @author Five March
*
*/

public class walker {

public static void main(String[] args )
{

Motor.A.smoothAcceleration(true);
Motor.B.smoothAcceleration(true);
Motor.C.smoothAcceleration(true);

UltrasonicSensor sonar = new UltrasonicSensor(SensorPort.S1);

Motor.A.setSpeed(200);
Motor.B.setSpeed(200);
Motor.C.setSpeed(200);
//--------------------------------------------------------
Sound.beep();//we are starting
LCD.clear();
while(!Button.ESCAPE.isPressed() )
{
LCD.drawInt(sonar.getDistance(), 0, 2);//to test draw the distance on the LCD screen
LCD.refresh();

if (sonar.getDistance() > 25)
{
Motor.A.rotate(360, true);
Motor.B.rotate(-360, true);
pause(1500);
}
else{
Sound.beep();//encounter an obstacle
int rotateAngle = 0;
while ( sonar.getDistance() <50)>

Because of the middle foot turning around, we thought of adding the "radar" possibility, making a map of surrounding objects. We already did this using the fantom lib and a very simple model.

But then we have to shift the software, choose a lib, so fantom lib, why not, this is JAVA too.
Now we'll do the commanding from the PC.

We add a few other sensors, the compass sensor, to get a bearing when making the map, the time, and the sound.

The sound will be used to get from the "Hopper"-mode into the mapping - mode.

The sensors will be mounted at the side of the model, the inside, because at the start, the thing had a tendency to fall down....( i forgot one tiny bit of lego, :-)

This is the result (output from Eclipse, beautified in Photoshop...)

The red line gives the "hopps", then the hopper encounters an object, and starts a round of getting distances, then it decides to take a bearing without an object (white line: no object within range) and it continues till it senses another something near.

The process of scouting a room is very slow. The sensors have to be not moving while reading a value.

Also you can see the compass is not very horizontal, because the lines around the "radaring" point should be regularly rotating around this point.

At the moment the nxt can avoid obstacles, but the track it follows is still random. The next step will be an "intelligent" way to search a room and make a map of the objects in it.

to be continued....

nxtcamera

2008-04-19T08:17:00.001-07:00

At last, after experimenting a lot with bluetooth and the I2C sensors we had enough experience to start working with the more complicated camera sensor. We thought!

Because we started trying to read out the objects the camera sensor saw from the fantom lib, we got stuck! Nothing was seen.
After a lot of trying out different settings we discovered and concluded that in the bluetooth setting the commands A and E for setting up the sensor were not received.
We started trying out the clock sensor, which has RAM registers, and we tried out setting the clock, all using bluetooth. This didn't work. So in the end we remembered reading somewhere about the master slave concept and tested a prog on the brick. In this prog, so without using bluetooth, the camera registers could be set, and it started tracking objects.

As expected the tracking of objects is not a very sensitive proces. The colors have to be well set in the PC prog NXTCAMVIEW, then uploaded. All depends on the setting of the light in the environment. But in the end it worked and we learnt again about some other complexities of the NXT.

Here an example in Lejos JAVA using the nxtcam, it draws the recognized blob on the LCD screen and can be expanded to an NXT following this blob...

import java.awt.Rectangle;
import javax.microedition.lcdui.Graphics;
import lejos.nxt.Button;
import lejos.nxt.NXTCam;
import lejos.nxt.Sound;
import lejos.nxt.LCD;
import lejos.nxt.SensorPort;

/**
* Demonstration of leJOS nxtcam
*
* draws the rectangle of a recognized color on the LCD screen
* gives different beeps for the two sides of the screen (left right)
* can be used to steer motors to make a following NXT
*
* uses one very good recognizable color entered with NXTCAMVIEW
*
* @author Five March
*
*/

public class follow {

static NXTCam cam = new NXTCam(SensorPort.S1);
static Rectangle myRect = new Rectangle();
static Sound beep;

public static void main(String[] args )
{
Graphics g = new Graphics();//to draw a rectangle on the screen

//--------------------------------------------------------
Sound.beep();//we are starting
cam.sendCommand('A');//preparation of the camera: sort objects
cam.sendCommand('E');//start camera tracking
//--------------------------------------------------------
while(!Button.ESCAPE.isPressed() )
{
int nb = cam.getNumberOfObjects() ;
if (nb ==1 )
{
LCD.clear();

g.drawRect(0,0,98,63);//max width on screen

myRect = cam.getRectangle(0);//the biggest rectangle seen by the camera
double scale = .6;//the camera width is different from the LCD with

int rectWidth = (int)(scale*myRect.width);
int middle = (int)(scale*myRect.x) + (int)(.5*rectWidth);
g.drawRect((int)(scale*myRect.x), (int)(scale*myRect.y), (int)(scale*myRect.width), (int)(scale*myRect.height));
//Integer midInt = new Integer(middle);//JAVA way of doing difficult converting an int to a String
//g.drawString( midInt.toString(),1,1);
g.refresh();

if (middle > 50 )
beep.playTone(2000, 100);//shape to the right
else
beep.playTone(4000, 100);//shape to the left

pause(100);//small pause otherwise the rectangles are only partially drawn
}
}
}

public static void pause(int time)
{
try{ Thread.sleep(time);
}
catch(InterruptedException e){}
}
}

to be continued...

Master Slave

2008-04-19T07:38:00.001-07:00

Using bluetooth you can steer the NXT.
This steering, commanding and reading of sensors can be done from several programming environments, like the fantom lib, or the C++ or the C# lib, many others available. For all these libs there is a limit to what can be done due to the master slave concept.

Working with several sensors all went well.
But trying out the camera sensor we ran into trouble: this camera has to be put in tracking mode by setting a register on this I2C sensor.

We discovered after quite a bit of time that the setting of registers by sending of DIRECT COMMANDS using bluetooth was not working.

Only by a prog on the brick, in our case in JAVA lejos, the camera can be set into tracking mode.
The same is true for setting the time on the clock sensor. We had written a method in the clock C++ class for setting the time, but this method can be thrown away.

The idea is that in the bluetooth relation there is a master and a slave. The master, in this case the NXT brick can set registers of the sensors, the slave, apparently (for us the PC) cannot.

So the sensors can be read, but not really put into other modes by the LSWRITE command.

This means that changing the factory address of an I2C sensor must be done on the brick too.
(Changing this address of an I2C sensor is necessary when connecting several I2C sensors to the same sensor port. The method is described in the mindsensors sheets.)

This resolves a few days of frustration, trying to get the camera sensor working.
After making a JAVA Lejos prog and transferring it to the brick, the camera was tracking without any problems, given that the colors of the objects to be tracked were defined in the NXTCAM view prog.

searching further, i came across this site: http://www.pspwp.pwp.blueyonder.co.uk/science/robotics/nxt/index.html
having a prog to steer the nxt

trying to make sense of the I2C setup

2008-04-05T00:49:00.000-07:00

Warning: this is a kind of diary of the problems you will encounter playing with the NXT!
Where is my time gone? What did I do with my life?

Ok the problems described here are solved, as always it was a combination of a few causes, a wrong setting of the battery reading before starting the reading of the sensors messed up the rest of the readings.
In the fantom api you have to be careful destinguishing between the bytes read by LSREAD and the bytes read through the fantomlib SENDDIRECTCOMMANDS, also the description of the DIRECT COMMANDS in the Bluetooth Developers Kit has to be read with care, not being quite what it is....so:
fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);
reads 4 bytes (see getBattery() in fantom lib blog )
but this is different from a reading of a sensor which starts with LSWRITE to the sensor and then used LSWRITE again to read the 21 bytes coming in...

To give an account of some of the difficulties and mistakes occuring during "research" i leave this story here......

But a nice training in detective work!
I am recording our efforts and thoughts, if something works all the roundabouts are so quickly forgotten!

we started having an idea of making a "room mapping" robot,
first we used C++ to do the job, with bluetooth, we could have mapped in OpenGL but we didn't, did that in FLASH.
(We just happen to like mixing all kind of environments:-)
then we discovered the fantom api and could get all the JAVA working on the brick and the PC
(This is fun: Lejos JAVA on the brick and fantom lib JAVA on the PC.)
so we redid the mapping idea using our homebrew lib, built on the fantom interface of E. Pirsch.
(Learning a lot about the DIRECT COMMANDS and the I2C sensors, but we had to learn more....:-(
mapping objects around the NXT worked but then it turned out the combination of 2 I2C sensors got mixed up
the sonar reading coming in during a compass reading.
(This is not the way we want it!!!! All must be neatly fit into it own objects!!!)

we started researching why, and we found this strange I2C set up procedure.
We are trying to make sense of this, and hoping to do a better job then just discarding the first 5 or 6 measurements.
The different sensors ask for different numbers of bits, and because the set up seems to be done only once, even if you use more and/or different I2C sensors.

So resuming:
Working with the fantom api we made a radar, that means the NXT mapping the distance to objects around it.
For this we used two different I2C sensors: compass and sonar.
Making a map of objects around the NXT worked but there was a problem: the distance value came in as a angle and the compass value as a distance.

The values read where coming in, but in the wrong order. Something wrong with our classes? This seemed in order...
It could be understood if we see the responses to the DIRECT COMMANDS as being read in the order they come in, and having started with the wrong reading. The instances of the objects don't "know" what they are reading, since there is no signature provided from the I2C response. Another reason could be that the setup order must be followed in the reading order, this makes sens if the bytes are "waiting" to be read, and cannot be skipped, neither recognized.
This was confirmed using three I2C sensor measurements (from different sensors). The values were still coming in, but all shifted into the "wrong instance" of the I2C sensor.

In the end we considered the setup of the I2C sensor:
This is what we got: (coming in)

recording the preparation of the I2C mode: (reading bytes with LSREAD 21 at a time)

reading a byte at a time, but getting this value in by 21 at the time:
I2Cprep 14 0 1 20 0 2 16 0 1 -1 0 0 0 0 0 0
I2Cprep 0 2 14 0 1 20 0 2 16 0 1 2 -1 0 0 0
I2Cprep 14 0 1 4 0 2 14 0 1 20 0 0 2 16 0 1
I2Cprep 14 0 1 4 0 2 14 0 1 4 0 0 2 14 0 1
I2Cprep 0 2 14 0 1 4 0 2 14 0 1 2 4 0 2 14
I2Cprep 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0

after this came a "normal" reading:
normal measurement (byte[3] is the value)
16 0 1 46 0 0 0 0 0 0 0 0 0 0 0 0

trying to make sense of this: (taking the 14 for LSGETSTATUS signature)

14 0 1 20 0 2 = LSGETSTATUS (?)
16 0 1 46 0 0 0 0 0 0 0 2 this seems like a normal measurement? - 1
14 0 1 20 0 2 LSGETSTATUS (?)
16 0 1 2 46 0 0 0 this seems like starting a normal measurement? - 2
14 0 1 4 0 2 LSGETSTATUS (?)
14 0 1 20 0 0 2 LSGETSTATUS (?)
16 0 1 this seems like starting a normal measurement? - 3
14 0 1 4 0 2 LSGETSTATUS (?)
14 0 1 4 0 0 2 LSGETSTATUS (?)
14 0 1 0 2 LSGETSTATUS (?)
14 0 1 4 0 2 LSGETSTATUS (?)
14 0 1 2 4 0 2 LSGETSTATUS (?)
14 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0

later on from calling LSGETSTATUS intead of readbytes, this 14 could be seen as: "number of bytes in waiting, ready to be read"

provoking these bytes were 6 reading of the I2c sensor.
In the C++ Anders lib we find for the I2C compass sensor three reading in preparation:

from the Anders lib:(with his comment)

int Compass::setup(){
sensor.sensor_type(LOWSPEED);
Sleep(500);
degree();
degree();
degree();//Otherwise the first measurement fails
return 1;
}

//degree is reading two bytes at a time, so six bytes are read? No, because the LSGETSTATUS gives the number of bytes ready, but the reading is always in 21 bytes, the 3 and 4 being the value. This difference between bytes ready and bytes read does not make life easier.

Another things we saw is that even if there are 2 I2C sensors attached to the ports that the preparation takes the same number of bytes, the second sensor, on another port, is also ready.

There is no difference in the bytes coming in using LOWSPEED or LOWSPEED_9V as sensor mode.

The problem is that is takes six measurements to "clear" the I2C sensor communication, but an uneven number to get the right order in the readings. So in case of two sensors should we also introduce a dummy measurement?

We tried building a method in the our I2C class reading the 14 bytes, but then we have to provide the portnumber, and the address to read from in the sensor (which differs, sonar 0x41, clock 0x00 for instance) so this solution could not be considered very cool, giving the different sensors.

Experimenting around with different kinds of set ups did not improve the result, the sonar sensor, which reads one byte, and the compass sensor, which reads two, both need three readings before behaving "normal".

to be continued...

A probable solution could be changing the address of the compass sensor. We tried this. It failed!
We re-used the Robot-C format found in the blog of
Done something wrong?
Ok, in C++ then, the lib of Anders, hm, no method to change the address found here.
We made a method for the compass, it failed!
But making a I2C sensor array of clock, distance, and compass in a C++ setup did work without problems, only the reading came in at a speed of (this three together) around 2 seconds.....a bit slow, but no shifted readings.....
so if we dont put I2C sensors on the same port, we dont have to change the I2C address?

fantom API and JAVA

2008-03-24T12:19:00.000-07:00

found this blog of Emmanuel: (all credits to @author Emmanuel Pirsch)
http://epirsch.blogspot.com/2008/02/jna-love-nxt.html
good news for the struggle to get ECLIPSE JAVA and bluetooth together.

Since Emmanuel Pirsch only presented the base of the project, with just an example how start a prog on the brick, we could try out our skills making this in an ECLIPSE project and making classes for some sensors.
It worked!

So what did we do?
added the exception classes.
I saw the timeout is used totally to search for devices before starting the program, so i reduced the time-out to 5 seconds, can be probably even less. (The C++ and the C# libs connect within a few seconds if all is well.)
Later on Emmanuel Pirsch suggested the possibility to connect directly to the brick (see his comment) we tried his suggestion and this worked, reducing the waiting time to nearly nothing. (You have to do the search first to get the exact name, after that, you can use this name.)

I tested this projects and our sketchy classes with HSL homebrew for playing a sound on the brick, the lightsensor (Custom) and the I2C sensors(sonar, clock for the moment). It works!

The direct commands must be used without the starting code (which chooses between expecting a response or not, this is indicated in the method.)
Playing a sound uses command 0x03 freq freq duration duration 0x00
Reading a sensor: 0x07 port 0x00 and expecting back a byte[15] (so not the byte[18] of C++)

public void playSound(int freq, int duration)
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(6);

command.put((byte)0x03);//direct command play tone
command.put((byte)freq);
command.put((byte)(freq >>8));
command.put((byte)duration);
command.put((byte)(duration>>8));
command.put((byte)0x00);

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);
System.out.println(status.getStatus().toString());
}

public int getBattery()
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(1);

command.put((byte)0x0B);//direct command get battery

byte[] response = new byte[4]; //this 4 bytes are vital to get the following readings right

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);
return response[0];
}

public int readSensor(int port)
{
//used for the lightsensor
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(3);

command.put((byte)0x07);//direct command read sensor
command.put((byte)port);
command.put((byte)0x00);

byte[] response = new byte[15];//expected back

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);

//the values are not really what they should be at the moment???
int raw=((0xff & response[5]) | (response[6] << adc="((0xff" best="((0xff" calcu="((0xff">

while changing this in the connect method: timeout 5 instead of 30.

Pointer iNXTIterator= fantom.nFANTOM100_createNXTIterator(true, 5, status);

Alternative in case you already have the name available:
In the Fantom interface add:
Pointer nFANTOM100_createNXT(String resourceString, Status status, boolean checkFirmwareVersion);

Then in the NXT.java class:

private Pointer directConnect()throws UnableToCreateNXTException
{
Status status= new Status();
Pointer iNXT = fantom.nFANTOM100_createNXT("BTH::5brickXT::00:16:53:01:BA:74::8", status, false );

if (Status.Statuses.SUCCESS.equals(status.getStatus())) {
return iNXT;
} else {
throw new UnableToCreateNXTException( " not able to create connection" );
}
}

and adding the exceptions: (in the package treelaws.mindstorm)

package treelaws.mindstorm;

public class NXTNotFoundException extends Exception
{
public NXTNotFoundException(final String message) {
super(message);
}
}

package treelaws.mindstorm;

public class UnableToCreateNXTException extends Exception

{
public UnableToCreateNXTException(final String message) {
super( message );
}
}

then adding the throw in some methods, requiring this:

public NXT(String name) throws NXTNotFoundException, UnableToCreateNXTException
private Pointer connect(String name) throws NXTNotFoundException, UnableToCreateNXTException

and changing the exceptions ( in method connect) to include the message:

throw new UnableToCreateNXTException( " not able to create connection" );
throw new NXTNotFoundException( " no nxt found" );

The lejos in the brick still does not allow a new connection (after having had a connection) it has to be restarted.

Later on I tested the more complicated I2C sensors: the sonar, and the clock, all went well, here is the class:

package treelaws.mindstorm;

import java.nio.ByteBuffer;

import com.sun.jna.Pointer;

import treelaws.fantom.Fantom;
import treelaws.fantom.Status;

public class I2Csensor {

private static Fantom fantom = Fantom.INSTANCE;
private Pointer nxtPointer;
int myPort;
String sensorName;

public I2Csensor (int port, Pointer NXTPointer, String name )
{
myPort = port;
nxtPointer = NXTPointer;
sensorName = name;
setUpI2CSensor();
}

public int setUpI2CSensor()
{
//used for the distance, clock, compass, acceleration sensors
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(4);

command.put((byte)0x05);//setinputmode
command.put((byte)myPort);//port
command.put((byte)0x0B);//sensortype LOWSPEED_9V
command.put((byte)0x00);//sensormode

byte[] response = new byte[2];

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);

return response[0]; //status
}

public int getStatusI2CSensor()
{
//used for the distance
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(2);

command.put((byte)0x0E);//setinputmode
command.put((byte)myPort);//port

byte[] response = new byte[1];

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);
return response[0]; //number of bytes ready to read
}

public int readI2C()
{
int value = -999;
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(6);

command.put((byte)0x0F);//LSWRITE
command.put((byte)myPort); //port
command.put((byte)2);//lenght of bytes to send

if ( sensorName == "sonar" || sensorName == "compass") { //sonar and compass
command.put((byte)1);//length of bytes to receive sonar
command.put((byte)0x02);//sonar address sonar: 0x02
command.put((byte)0x42);//register to read sonar: 0x42
}
if ( sensorName == "clock" ) {
command.put((byte)1);//length of bytes to receive
command.put((byte)0xD0);//sonar address clock: 0x02
command.put((byte)0x00);//register to read clock seconds: 0x42
}

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);

int nb = 1; //number of bytes to read
if ( waitI2CSensor( nb) )
value = readBytesI2CSensor( nb) ;
return value;
}

p public int getStatusI2CSensor()
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(2);

command.put((byte)0x0E);//setinputmode
command.put((byte)myPort);//port

byte[] response = new byte[1];

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, true, command, command.capacity(), response, response.length, status);

return response[0]; //number of bytes ready to read
}

public int readI2C()
{
int value = -999;
//System.out.println( "--startread---" + port );
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(6);

command.put((byte)0x0F);//LSWRITE
command.put((byte)myPort); //port
command.put((byte)2);//lenght of bytes to send

if ( sensorName == "sonar" || sensorName == "compass") { //sonar and compass
command.put((byte)1);//length of bytes to receive sonar
command.put((byte)0x02);//sonar address sonar: 0x02
command.put((byte)0x42);//register to read sonar: 0x42
}
if ( sensorName == "clock" ) {
command.put((byte)1);//length of bytes to receive
command.put((byte)0xD0);//address clock: 0xD0
command.put((byte)0x00);//register to read clock seconds: 0x00 - seconds
}

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);

int nb = 1; //number of bytes to read
if ( waitI2CSensor( nb) )
value = readBytesI2CSensor( nb) ;
return value;
}

public boolean waitI2CSensor( int numberBytes)
{
int nB = getStatusI2CSensor();
while ( nB < nb =" getStatusI2CSensor();" status=" new" command=" ByteBuffer.allocate(4);" response =" new" sensorname ="=" a =" response[3]">>4) *6;//otherwise the number of seconds will be jumping
System.out.println("clock " + response[0] + " " + response[1] + " " + response[2] + " "+ response[3] + " " + response[4]+ " " + response[5]+ " " + response[6]);
return a;
}
if ( sensorName == "sonar" || sensorName == "compass") {

return 0xff & response[3]; } //value read, starting from 5
return -999;//no known sensor
}
}

Remark: using this constructor to make instances for the compass and the sonar sensor, using the above example, somehow these two sensors seem to "switch" values. hmmmmmmmmm...:-)

To make a map of the surroundings, we also need a motor class, a sketch using the tacholimit:

package treelaws.mindstorm;

import com.sun.jna.Pointer;
import java.nio.ByteBuffer;

import treelaws.fantom.*;
import treelaws.fantom.Status;

public class motor {

private static Fantom fantom = Fantom.INSTANCE;
private Pointer nxtPointer;
private int motorPort;

int MOTORON = 0x01;
int BRAKE = 0x02;
int REGULATED = 0x04;

int REGULATION_MODE_IDLE = 0x00;
int REGULATION_MODE_MOTOR_SPEED = 0x01;
int REGULATION_MODE_MOTOR_SYNC = 0x02;

int MOTOR_RUN_STATE_IDLE = 0x00;
int MOTOR_RUN_STATE_RAMPUP = 0x10;
int MOTOR_RUN_STATE_RUNNING = 0x20;
int MOTOR_RUN_STATE_RAMPDOWN = 0x40;

public motor (int port, Pointer NXTPointer)
{
motorPort = port;
nxtPointer = NXTPointer;
}

public void reset()
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(2);

command.put((byte)0x0A);//reset
command.put((byte)motorPort);//port

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);
System.out.println("reset" + " " + status.code);
}

public void speedMotor( int power, int turnratio)
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(13);

command.put((byte)0x04);//LSREAD
command.put((byte)motorPort);//port
command.put((byte)power);//power -100 - 100
command.put((byte)MOTORON );//mode
command.put((byte)REGULATION_MODE_MOTOR_SYNC );//regulation synchronized
command.put((byte)(128 - turnratio) );//turnratio
command.put((byte)REGULATION_MODE_MOTOR_SPEED );//runstate
command.put((byte)0x50 );//tacholimit = 0
command.put((byte)0x00 );//tacholimit = 0>> 8
command.put((byte)0x00 );//tacholimit = 0>> 16
command.put( (byte)0x00 );//tacholimit = 0>> 24
command.put( (byte)0x00 );//tacholimit = 0>> 32
command.put( (byte)0x00 );//closing

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);

}

public void stopMotor()
{
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(12);

command.put((byte)0x04);//LSREAD
command.put((byte)motorPort);//port
command.put((byte)0x00);//power -100 - 100
command.put( (byte)REGULATED );//mode
command.put( (byte)REGULATION_MODE_MOTOR_SYNC );//regulation
command.put( (byte)0x00 );//turnratio
command.put( (byte)MOTOR_RUN_STATE_IDLE );//runstate
command.put( (byte)0x00 );//tacholimit = 0
command.put( (byte)0x00 );//tacholimit = 0
command.put( (byte)0x00 );//tacholimit = 0
command.put( (byte)0x00 );//tacholimit = 0
command.put( (byte)0x00 );//tacholimit = 0

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);

}
}

With a bit of JAVA Graphic, i got this result, NXT scanning for objects, using compass and sonar, some strange effects have to be investigated,
some other effects are resulting from the sonar, which is not a straightforward linear razorsharp distance device!

Connection setup XP or VISTA (tested for both)
Needed:

installing NXT Mindstorms CD (this installs the fantom lib)
bluetooth dongle

make a project, install all the classes given in the referenced blog of Emmanuel Pirsch, (include your own classes or use the classes sketched here)
You have to install a comport:
In bluetooth manager Search for device
Wizard, manual key 1234
ready with wizard
first use connect method in the JAVA project with search for device
copy name of brick BTH::name of device::Mac-address::comport
then you can switch to directConnect

Troubleshooting:
After having worked with a fantom lib project yesterday, today it won't connect!
I had to redo the COMPORT settings. Desinstall existing COMPORTS, do a search, give the preconfigured key, check the ports again.
Possible cause: the Brick was running from my laptop on XP, and Michel tested it from VISTA. This might have reconfigured the brick???

Big problem with the fantom lib or this kind of interface: writing commands does not seem to be working.
(see solution...:-( )
LSWRITE is ok to check registers, reading values etc, but LSWRITE to the command register with a command has no effect. Testing for several I2C sensors, compaas, camera, and clock. The clock has a RAM, which can be written to using C++ (my own classes in the Anders lib).
This is the code:

public void sendCommand(byte cmd)
{
System.out.println(" sendCommand " + cmd);
Status status= new Status();
ByteBuffer command= ByteBuffer.allocate(7);

command.put((byte)0x0F);//LSWRITE
command.put((byte)myPort); //port
command.put((byte)3);//length of bytes to send

command.put((byte)0);//length of bytes to receive camera
command.put((byte)0x02);//camera address camera: 0x02
command.put((byte)0x41);//command address
command.put((byte)cmd);//command byte to send

fantom.nFANTOM100_iNXT_sendDirectCommand(nxtPointer, false, command, command.capacity(), null, 0, status);
System.out.println( "sendcommand back: " + nb + " char= " + cmd + " " + myPort ) ;
pause(100); //should check I2C status
}

This means that reading values from the usual I2C sensors is possible (Compass, Clock, Tilt for instance) but no changes can be made, nor the camera can be put in the following objects mode.

Solution: the bluetooth connection is on a master- slave basis which means that writing registers is not possible. So reading from sensors is ok, but starting the camera, or setting the time in the clock sensor is not possible.

reference:
http://nxtasy.org/2006/12/23/fantomtalk/
http://mindstorms.lego.com/Overview/NXTreme.aspx

sites and ideas

2008-03-24T03:47:00.000-07:00

Here a list of sites i found, which contain all kind of ideas and info:

latest:

ebook by Juan Antonio Brena Moral, excellent!

general

bluetooth/direct commands

radar project

http://www.juanantonio.info/jab_cms.php?id=93

ideas for models:

http://ricquin.net/lego/instructions/

NXT mapping radar

2008-03-02T07:15:00.000-08:00

The sonar sensor of the NXT can measure the distance to objects. So this sensor can make a map of the surroundings of the brick.
To make a map the sonar needs to be turned around 360 degrees, while measuring the distance of the objects. Because the sensor needs to be attached with the cord, this turning is most easily done by rotating the whole brick, with its wheels. These wheels can provide a measure for the angle rotated, if you don't have a compass sensor.

Then the data need to be analyzed. Writing a file from a C++ prog (with bluetooth conenction to the NXT, steering it around its axis too) is really easy:
add some headers:

#include

ofstream out1;
out1.open("result.txt",ios::app);
//in the while loop:
out1 << motorD << "***"<< sonarD << "***"<< endl;
//writing "***" between the values, to get a nice split of the string into an array
//and close it after stopping the measurements:
out1.close();

Then you have a textfile, how to unwrap the data into a map? For the moment I used FLASH CS3 for this. It can be done with OpenGL too. In the FLASH the data are loaded and the string is split into an array using the "a"'a between the values. Then the angle (coming from the motor sensor) is used to put the dots (from the sonar) at the indicated distance from the NXT, using a bit of mathematic, sine and cosine: abstract: (can be used like this everywhere) centre: 300,200 ff: scale factor for the radius = distance from the centre results: array containing angle1, distance1, angle2, distance2, etc Math.PI/180 : needed to get from degrees to radians so a point becomes: (300 - ff* results[i+1]*Math.sin(-results[i] * Math.PI/180 ), 200 + - ff* results[i+1]*Math.cos(results[i] * Math.PI/180 )) Actually this is going from rectangular to "polar" coordinates, turning a rectangle around a point. There is a filter of this in Photoshop, quite fun to play with it, in 17th century art, painters were doing this trick making paintings which could only be seen through a circular mirror wrapped around a stick! They called this anamorphoses...

In the picture you see the result: the test environment and the dots.
You can observe that the sonar sees slightly "bigger" objects then the objects we see. Also the rounded object can pose a problem, the sonar works with signals reflected from the object, so how does he see this circle? The NXT was going around several times before this image was built.
Some more experiments are needed with different materials and shapes to get a real notion of his viewing capabilities.

The next step is to steer to another position, make a second map, and trying to relate these two maps.

work in progress!

//-----------------------------------------------------------------------------------------------------------------------------------------------------

When I found the fantom Lib possibilities the map could be made immediately using the bluetooth JAVA connection.
The I2C sensors and the DIRECT COMMANDS cuased some problems but in the end it worked, using the compass and the sonar sensor.

The compass sensor has to be very horizontal, otherwise the degrees do not cover the circle evenly, as can be seen in the picture in the fantom lib blog.

Direct Commands using Bluetooth, I2C

2008-03-01T04:55:00.000-08:00

Direct commands are bits of code send through Bluetooth to the NXT.
You can control all the functions of the NXT using the direct commands, and the JAVA and C++ and C# libs using the bluetooth/COMPort are built on these commands.

Using the different libraries which are available, the Direct Commands are hidden in the objects for instance the sonar is based on the I2C class, which uses Direct Commands.

So in the Bram Fokke, the Anders and the Lejos libraries, the ones I studied, because they are free, the Direct Commands are hidden in the classes. (The fantom lib found later allowed us to built our own library.)

But then you encounter a sensor which was not there in the time they wrote their classes and this sensor just doesn't behave like the sensor types they have provided for. Then suddenly you have to study the Direct Commands.

In principle not very difficult and there is the documentation of the Bluetooth Developers Kit of Lego: http://mindstorms.lego.com/Overview/NXTreme.aspx
In principle you can find your way with these docs.
I was especially interested in the control of the I2C clock sensor.
The only reference about these sensors I eventually found on the web is:
http://hsrc.static.net/Research/NXT%20I2C%20Communication/

Details:

the first two bits are sometimes included sometimes hidden (length of command)
the LSREAD in the mindstorm pdf has a mistake: it is 21 bytes long (or 24), the rx length from 4-21, Anders lib 24 bytes.
what comes back can be status included, or not (fantom lib)
the setup of a sensor (I2C) produces a lot of bytes which should be discarded
the commands responses must be all taken care of! One byte in between, not read will mesh everything up!

But even the last doc of the links was not really clear to me, missing the two first Bytes to write!
So here some examples, building on this page:

As written above these three commands are used:

LSWRITE is used for both reading registers and writing commands from the NXT.
LSGETSTATUS is used basically to wait until the i2c bus is free.
LSREAD will read any bytes that the NXT has received from the i2c device.

First in the row of commands are two bytes: the total length LSB and the same MSB
(so the second byte is always 0! In some libes these 2 bytes are integrated differently!)

Then you can follow this last doclink:

send(&command[0],7); replaces LSWRITE
sensor.read() does the LSREAD
sensor.wait_ans(nr) waits for nr bytes, using the LSGETSTATUS and a timer
(to be found in the Lib of Anders)

for instance: play a tone: (C++ lib of Anders)
char command[10];
//---------------------------------------------playtone
command[0]=0x06;//length LSB
command[1]=0x00;//length MSB
command[2]=0x00;//do not bother to send anything back (0x80 when something is expected back)
command[3]=0x03;//play tone
int freq = 4000;
command[4]=freq;
command[5]=freq >>8;
int time = 100;
command[6]=time;
command[7]=time>>8;
command[8]=0;
comport->send(&command[0],8);
//----------------------------------------------------end playtone----

example 2: set output state of a sensor:
command[0]=5;//total length
command[1]=0x00;//second byte of the length
command[2]=0x80; //0x00 would block the measurements because sending something
command[3]=0x05;//setinputmode command
command[4]=0x00;//port of the sensor on the brick NXT
command[5]=0x0A;//constant for type of sensor
command[6]=0x00;//sensormode
comport->send(&command[0],7);
}
if(sensor.wait_ans(4)){
answer=sensor.read();
}
//---------end set output state

example 3 reading a register of an I2C sensor
char command[9];

command[0]=7;//total length
command[1]=0x00;//total length

command[2]=0x80;//expect something back
command[3]=0x0F;//LSWRITE
command[4]=0x00; //port
command[5]=2;//lenght of bytes to send
command[6]=1;//length of bytes to receive
command[7]=CLOCK_ADDRESS; //i2c address of the clock
command[8]=reg_adr;

comport->send(&command[0],9);
char *answer;
if(sensor.wait_ans(1)){ //and wait for the one byte back
answer=sensor.read();
return answer[1] ; //reading this was using not the answer[0], but this depends on the sensor
}

//------------------------end reading a register

example 4: writing to e register, that is copy the last one, but add one register after this commandList:

char command[10];
command[0]=8;
command[1]=0x00;

command[2]=0x80;
command[3]=0x0F;//LSWRITE
command[4]=0x00; //port
command[5]=3;//lenght of bytes to send
command[6]=1;//length of bytes to receive
command[7]=CLOCK_ADDRESS; //i2c address
command[8]=reg_adr;
command[9]=val; //thus giving the value you want to give this register
comport->send(&command[0],10);

char *answer;
if(sensor.wait_ans(1)){
answer=sensor.read();
return answer[1] ; //again, the reading back of the response has to be looked at, depending on sensor
}

//end ----------------------------------------------------reading a register

With these direct commands, the Dev - Cpp classes for the clock sensor were built.
See the blog: I2C setup to see more details (and problems), using the fantom lib

Limits: using DIRECT COMMANDS from the PC, you cannot set registers on sensors, due to the master slave relation, see master slave blog.

clock sensor

2008-02-29T10:23:00.000-08:00

Having bought the Acceleration sensor, mindsensors.com send me the clock sensor. So they have sent me the acceleration sensor and let me keep the clock sensor.

This clock sensor comes with a block for the Lego FIRMWARE, which worked fine, displaying time and date.
Then i wanted to implement the sensor in C# for the measuring of the time the various sensors use. Although i can use sustem time for this I wanted to make use of another sensor and learn something about it.
The sensorclass wasn't to easy to build! So back to Lejos Java. In this language the same problem. This was not as easyas the acceleration sensor.
So back to Dev Cpp, with the library of Anders, which is very clear to understand. I had to study the direct commands more closely, and constructed my own direct commands sequences, learning a lot about this.

Eevntually the Dev-Cpp classes for the clock started working.
The Datasheet provided by mindsensors.com has all the necessary informations, but....you have to read carefully!

Having made these classes, i'll construct the Lejos Java, and the C# classes. But that is for later.

First these classes, which can be downloaded. First Version: be careful!
NXT clock classes
To be used with the lib of Anders

more versions will follow, for the Lejos, and the C3 lib of Bram Fokke.

I2C sensor, lejos clock sensor class

2008-02-27T12:32:00.000-08:00

I2Csensor, abstract class, wiring, solution reading clock sensor in lejos

This type of sensor is different from the custom sensors like the light, the touch and the sound.

First of all very handy is this site:
http://www.koders.com/info.aspx?c=ProjectInfo&pid=RHGY8H3PWYCG28MNNNS8V1BLGC
where all the classes are shown.
These class can be found in the lejos folder too: lejos_nxj/src/java/classes as textfiles, but the Koders is handy, it has a search.

You can see that the I2Csensor class is an abstract class: you have to use the super() as a constructor:

//------------------------------------------------------------
// I2Csensor class
//------------------------------------------------------------
For instance you can see how to write a class for an I2Csensor which is not in the list (i did the clock), see on Koders how it is done with the tilt sensor.

import lejos.nxt.*;
public class clock extends I2CSensor
{
byte[] buf = new byte[2];

public clock(SensorPort port)
{
super(port);
}

public int getByte(byte myByte)
{
int ret = getData(myByte, buf, 1);
return ret;
}
}

Then continuing trying to get the clocksensor to work under lejos JAVA, (it works in Dev Cpp).
i found this bit of important information:

The sensor ports have two channels to them:
1) Analog channel. These are read with the raw value. This is used to 
read devices like the light sensor and push button and other resistive 
sensors.
2) Digital wires. These can be used as inputs or outputs. On the light sensor 
they are used to turn the LED on or off. Thay also can be used to make an I2C 
port which can be used to communicate with a compass sensor or ultrasonic 
sensor.

Note!!! I2C only works with port 1.. port 3 at the moment. There is something 
wrong with trying to use it on port 4 at present, but this is being debugged.

So, trying to use the raw reading method for an I2C sensor does not even look 
at the correct wires on the port.
(by Charles Manning)

But that is not the way to proceed.
The problem is the getData.
This method used i2cStart( address, register, len, buf, len, 0);
where the address is written in the I2Csensor class as 1.
Actually this int 1 is shifted in the lowlevel routine (written in C, can also be
found in the lejos folder:  lejos_nxj/src/nxtvm\platform\nxt : i2c.c , in C)
This address is the what is called the factory address. But for the tilt and compass sensors this is 0x02.
The clocksensor has a factory address 0xD0.
All a bit mysterious, till I made the link: in the lejos JAVA I2C sensor class the factory setting is shifted,
to become 1: 2>>1 = 1.
So trying: 0xD0>>1 = 0xD0/2 (as address) worked in the i2cStart method.

I wrote a method for the clock sensor oerriding the getData in the I2C class.

public int getData(int register, byte [] buf, int len) { 
  int ret = myPort.i2cStart(0xD0 / 2, register, len, buf, len, 0);
  if (ret != 0) return ret;
  while (myPort.i2cBusy() != 0) {
   Thread.yield();
  }
  return 0;
 }
then you can use the data provided by the mindsensor pdf:

public int rawSec()
 {
  int ret = getData(0x00, buf, 1);
  return (ret == 0 ? (buf[0]  ) : -1);
 }
 public int rawMin()
 {
  int ret = getData(0x01, buf, 1);
  return (ret == 0 ? (buf[0]  ) : -1);
 }
 public int rawHoures()
 {
  int ret =  getData(0x02, buf, 1);
  return (ret == 0 ? (buf[0]  ) : -1);
 }
etc, why "rawSec", because of the byte structure:
(see clock sensor pdf)

public int getSec()
 {
  int a = rawSec();
  return a - (a>>4) *6; 
 }
 
 public int getMin()
 {
  int a = rawHoures();
  return a - (a>>4) *6;
 }

etc gives the right seconds.....

The clocksensor class will be available here soon for download.

//------------------------------------------------------------
// long in Lejos?
//------------------------------------------------------------
You can get a time in milliseconds on the NXT. I used it for measuring the responsetime of the sensors. This is given in: long currentTimeMillis()
But adding arithmetical operations are not supported in the Lejos Java (told Eclipse).
So what to do?
This was my solution:
before the measurments
double startTime= (double) System.currentTimeMillis();
after:
double nowTime = (double)System.currentTimeMillis() ;
int now = (int)(( nowTime - startTime)/1000);
LCD.drawInt( now ,0,5) ;
LCD.refresh();
Mind also the System before the currentTimeMillis();!

//--------------------------------------------------------------------------------------------

The gearbox of Jos

2008-02-19T00:39:00.000-08:00

In the standard box of the NXT there are three motors. Also on the brick itself there are three plugs for motors. So three sources of power are provided for, very basic as it turns out.
In the car mode:
Steering and driving takes two, (whatever the construction) so one motor is left for doing something, grabbing a ball, lifting a peddle, or turning the sonar around.
In the crane mode:
turning, lifting and grabbing.

You wonder if it could be possible to do more. (That is without simply buying more motors and putting in some wiring to get these running on the three plugs.)
Is there another possibility?
There is this wonderful complicated piece in the set, having inner and outer cogwheel teeth. It is used in the crane, described on the Lego CD.
This double cogwheel really inspires fantasies about spaces filled with gears and shifting components, clicking and humming and working and producing and……

The idea of a gearbox spring to mind!

Suddenly Jos made a drawing like a Leonardo da Vinci and got to work. He constructed a complicated little, watch like device, which has the possibility of shifting a cogwheel to several other cogwheels. In principle two motors can steer a whole set of activities. This gearbox has to be built in the total Lego structure, which will be another little challenge.

Now it gets to real engineering and you could possible understand why all the cranks, bolts and screws you need to turn are so difficult to reach in cars :-)……

And a model i came across by accident using this phantastic piece in a creative way is the hopper:
http://ricquin.net/lego/instructions/hopper.htm

NXT, "the thing's" of Arnold

2008-02-08T05:38:00.000-08:00

The first example of an impossible design is "the thing" (1) of Arnold.
It looks like a body, and arms attached to the knees...the head being the sonar.
This design was able to make a scissor movement, the actual advantage of this was unknown.

The goal was scanning the objects in the room and constructing a map by combining observations from different positions,
using the sonar sensor, and three motors.

This requires also a bit of programming, combining observation data and a bit of recognition. A compass sensor is very convenient and probably necessary for this.

The plan is to do the programming in C or C++, with the addition of OpenGL to make the map. This kind of program should run on the computer, connected with bluetooth to the NXT.
Another thought is to do it "all" on the NXT itself. A real challenge, which asks for a bit of thought about effective reducing and storing data. After making the map, the file can be send to a PC.

To Arnolds total deception and desparation another model had to be made before his "thing" was finished. But he will come back to this idea, which will be very consolating.
To save his ideas for the future we took a few pictures.

Particularly nice was the cogwheel construction, for turning the sonar sensor. These cogwheels, especially rounded for this purpose, can be used standing in a right angle to each other. They can be seen at 1400 houres above the centre of the picture.

The next thing was built a few weeks later, totally different, but also with a special signature: redundancy of parts and hybris in design - idea.

//------------------------------------------------------------------------------------------

In his second Thing Arnold tried to use all the pieces in the Lego Box. The white connection pieces, but also the handy black double pins were all exhausted. The upper build of sensors had to be done using axes.
The design has only two wheels. A third turning wheel would become instable because of the weight. The structure is supposed to steer, sliding on the part without the wheels.
The third motor can steer the upper sensor strutcture around.
The goal was the same as the first thing: building to a considerable height for putting the sonar sensor on top. Then program to make a map of the room. In short: a radar.
Cogwheels are another speciality as can be seen in a few pictures.

The upper structure has three custom sensors the only problem will be that these sensors have to be connected to the brick. This will prevent considerably the ability to turn the sensors around. The idea of putting the sound sensor in is to be able to follow a talking target.
The light sensor, of course, will be able to follow the light. In this setting the sonar will also serve to avoid becoming a nuisance to the target! So the second "Thing" of Arnold has great stalking capabilities, only the surface must be very smooth!

nxt, lejos, array and arrayList

2008-02-04T09:02:00.000-08:00

Due to some inexperience in JAVA, a bit of trouble was caused by the special reduced JAVA class of ArrayList. The simplest things in other languages cost most of the time, so here a simple example is given with code that works on the brick.

Arrays and ArrayLists can be of good use when you want to find a good configuration and you let the brick get the best answer, by simply trying out all the possible combinations stored in the Array!

The code of this ArrayList class can be found here:
http://www.koders.com/java/fid9EB794717148396BA1384B9B134F7C37FB77C880.aspx#L131
this helps understanding the things that doesn't seem to work.

for instance:
Object myArray = someArraList.toArray() ;// does not work...because it isn't in this special class (Eclipse gives it as a choice though! To let the prog crash in the brick...)
also
someArrayList.add(0, 7); //does not work, it does not even compile (the int is not recognized as object, ( but this could be official JAVA, although the comment is that the lejos Int class lacks some method...)

so what to do about that? This: make an integer object yourself!

Integer myInt = new Integer(55);
someArrayList.add(0, myInt ) ; //this works and compiles

someArrayList.add(0, "aString" ); //is accepted to, strange the int and the string are not treated the same simple way....

Now say you have your own object: (constructor in the example, nothing exceptional, haha)
integerObject someInt = new integerObject(55); //whatever this is....
then
someArrayList.add(0, someInt ); //works fine

ok so lets make it into an complete though not too functional example prog for the NXT:

import java.util.*;
import lejos.nxt.*;

public class arraytest {

static ArrayList myMotorSpeedPlus = new ArrayList (20);//accepted in brick

public static void main(String[] args) throws Exception {

integerObject someInt = new integerObject(55); //my own integer object see class below
integerObject otherInt = new integerObject(); //another one

integerObject[] rij = new integerObject[5]; //making this into an Array
rij[0] = someInt;
otherInt = rij[0]; //this works and compiles

int helloInt = (int) otherInt.ReadmyInteger (); //doing some things
LCD.drawInt( helloInt , 0 , 7 );
LCD.drawInt( (int) rij[0].ReadmyInteger () , 5 , 7 );

int myTest[] = new int [5];
myTest[0]=5;
myTest[1]=4;
myTest[2]=3;
myTest[3]=2;
myTest[4]=1;

ArrayList someArrayList= new ArrayList ();
//someArrayList.add( 3, "hello" );//this compiles
int mySize = someArrayList.size();
//+++++++++ adding strings
//someArrayList.add(0, "hello" );//this compiles and works
//++++++++++ my own objects
//someArrayList.add(0, new integerObject(55) ) ; //this works and compiles
//otherInt = (integerObject) someArrayList.get(0); //this compiles and works

Integer myInt = new Integer(55);
someArrayList.add(0, myInt ) ; //this works and compiles
myInt = (Integer) someArrayList.get(0);
mySize = someArrayList.size();
someArrayList.add(0, myInt );
someArrayList.add(0, myInt );
someArrayList.add(0, otherInt );
LCD.drawInt( myMotorAL.size() , 8 , 7 ); //and this gives the size

while(!Button.ESCAPE.isPressed() ) { //ok this keeps going on till the button is pressed
for(int teller=0;teller<>

LCD.drawInt( myTest[teller] , 0 , teller ); //it displays the content of the int array

LCD.refresh();
}

}

//here the simple class integerObject

public class integerObject {

private int myInt;

public integerObject (int comingIn ){
myInt = comingIn;
}

public integerObject ( ){
myInt = 0;
}

public int ReadmyInteger ( ){
return myInt;
}

}

ok , only to show the use of the Arrays of int and string and the ArrayList.

nxt webfun

2008-01-26T12:46:00.000-08:00

--------------------------------------------------------------
See blog "hoofdmenu" for a list of subjects around the NXT
--------------------------------------------------------------

Just a few links, using the searchengine on Mindstorms and NXT will reveal much more!
Have fun!

* http://www.marioferrari.org/lego_mindstorm.html
* http://www.extremenxt.com/lego.htm
* http://www.youtube.com
* http://www.tau.ac.il/~stoledo/lego/

nxt, lejos and environmental variables

2008-01-26T12:45:00.001-08:00

--------------------------------------------------------------
See blog "hoofdmenu" for a list of subjects around the NXT
--------------------------------------------------------------

What are environmental variables:
These are path, for Windows needed to findJAVA or Lejos.

Where to find:
My Computer, right mouseclick in folder, system properties, TAB advanced, and environmental variables

Needed for JAVA and lejos (the JAVA for the NXT):
Example:
PATH c:\java\jdk1.6.0_02\bin;c:\JAVA\lejos_nxj\bin
not necessary: CLASSPATH

Check it with the Command window
Eclipse finds the paths itself, the paths are included in the .bat files of the lejos-JAVA environment

commandwindow for lejos

2008-01-26T12:43:00.000-08:00

The Commandwindow is not needed for firmware, nor for C or C#.
Needed for installing and flashing JAVA Lejos, and sometimes conveniant for other languages (Ruby)

(Icommand also, belonging to JAVA asks for a renewed struggle wit PATH, CLASSPATH, .jar's and other strange monsters. Problem: every laptop has to be configured again. If it works you tend to forget how it was done, because it is not something you reinstall everyday.)

Features of the command window

in the command window, capital letters and lower case can be used
if environmental variables are changed: close command window, to reopen it with the new settings

GENERAL COMMANDS in the COMMANDWINDOW

The commandwindow is a bit primitive, no direct copy paste, luckily if a command does not work with the arrows (UP) you can get the command back and correct is, in all other cases: retype!

cd\ to go to the root
to get into a folder cd (foldername), but also cd (foldername partial)* the wild card star
cd.. with two points, to get back into a directory path one level
dir to look at programs in the directory
path to see the configuration of the path, for instance for JAVA: c:\java\jdk1.6.0_02\bin;c:\JAVA\lejos_nxj\bin
echo %path% the same as path
echo %classpath% gives CLASSPATH aan
java (check for JAVA) gives a list of JAVA, otherwise configure PATH :c:\java\jdk1.6.0_02\bin
copy and paste??? Hmmm: CTRL V doesn't work, but Yes: copy a command from somewhere and use in COMMANDWINDOW: right mouse-click and choose copy

Lejos Commands

When compiling with Eclipse (and not with the command window) the .bat file of Lejos finds it's way to the libraries

lejosdl (check on installation of lejos) gives a list of commands, otherwise reconfigure PATH: c:\JAVA\lejos_nxj\lejosfirmdl to flash the firmware of lejos to the NXT (using USB)
lejosc programName.java to compile a JAVA program, using the command window
lejos programName to send the compiled programm to the lejos (no .class)

For Icommand: (i am saving these experiments, for the next installations....)

set classpath , to check the classpath in the commandwindow
java -jar icommand.jar checking the placements of the icommand.jar (although this is costing houres again, still not working, do I love the JAVA commandwindow combination?)

error: Unable to access jarfile icommand.jar

java %classpath% -jar icommand.jar

error: Exception in thread "main" java.lang.NoClassDefFoundError: shwoing classpath

in the JAVA directory: (first cd\ then in root C: cd java, java -jar icommand.jar

error: Exception in thread "main" java.lang.NoClassDefFoundError: icommand.Properties, it seems to look for the icommand.Properties file, but cannot find it...hmmmm

in Eclipse, he finally found the icommand.properties.

device address is found in the bluetooth application (Bluesoleil with me)

nxt troubleshooting

2008-01-26T12:42:00.000-08:00

--------------------------------------------------------------
See blog "hoofdmenu" for a list of subjects around the NXT
--------------------------------------------------------------

The actual robot "around" the NXT can be rebuilt and rethought every time. Then while building you have to have an idea about the programming, using which language, and bluetooth or not. So you have to shift around the language on the brick, Lego firmware or Lejos JAVA, or even others. Bluetooth can be hindered by another language, different from the Lego firmware.

I want to record here some of the problems encountered:

Reinstalling Lego Firmware

After using Lejos JAVA. Connected to USB, working from the Firmware CD program. Problem: NXY not found, after minutes of waiting.

Cause: using an extra USB HUB i had connected about 6 things to the laptop. Connecting the USB from the brick directly to the laptop solved this problem.

Firmware has to be installing itself within 60 seconds.

ECLIPS problems

JAVA installed watch it: no space in the name of the folder Program Files -> ProgramFiles
Lejos installed , check lejos with lejosdl in Commandwindow
Eclips installed , using the JRE 1.3, as advised, can only be done when installed seperately, and is not really necessary.
Eclips gives problem {project_loc} unknown; try configuring hardpath
Eclips gives problem java_type_name , this was caused by dragging a file into eclipse, but not adding it to the project......
Eclipse ok, compile, ok, upload incredible fast (<500>
Eclipse ok, USB connected, compile & upload: warning: bluetooth not found: can be caused by compiling and uploading too fast after connecting USB. Wait 3 seconds after the positive Windows beep of USB connection.

Bluetooth

In the beginning all went wrong, but actually this is simple!

In general:

installed Bluetooth does not work: use dongle....20 euro's.
first the Bluetooth dongle, V2.0 PROMEDION is ok on a Toshiba, Toshiba's own bluetooth does not function
install WIDCOMM, free download, or
Bluecove , this comes in a try out version, but still functions on my laptop.
start bluetooth search: NXT is shown (or you have to ask: get name devices)
select NXT: pairing in principle once.
ouble click or right click, connect to serial (for instance devB, or directly serial COM8)
pairing connection
NXT asks a pin, and the Bluetooth too, dont imagine anything different from the preset 1234
after this: you can test the connection in the bluetooth prog, but
Eclipse and C# programs connect and disconnect themselves!!!
ok the COM port is installed on YOUR computer, it is not something of the NXT
COM port number bigger than 10: not working reconfigure COM Ports (see below)
COM port number gets higher and higher : see below

Bluetooth -> COMpoorten problems

Repeat: dont connect first to the NXT and then start a prog from the laptop to connect, this prog connects itself. (I made this mistake in the beginning costing me quite some time to reconfigure the COM ports.....)

Ok, when made this mistake of double connecting and messing up your Ports:

Where to find theCOM ports:

A: Mycomputer, properties, hardware, (peripheriques ), Ports (Com en LPT)
B: or commandwindow en regedit.exe, HKEY_LOCAL_MACHINE, HARDWARE, DEVICEMAP, SERIALCOMM,

vanuit versie A:

right click on PORT, TAB parameters, advanced, bottom, numberCOMport, configure: the number must be below 10

The COM port numbers get higher and higher, while not using the lower ones, they were not cleaned up. In this window you can "reclaim" numbers a few times, thus "emptying" the PORT numbers. Primitive, but it works.

Then desinstall the old portnumbers, start the bluetooth configuring again, and in the end, the COM PORT mess, caused by double connections to the NXT, will be cleaned up.

nxt en harde data met de lejos classes

2008-01-26T12:41:00.000-08:00

Hier is nog genoeg te doen!!!

De classes van de Lejos firmware zijn goed beschreven, maar wat zegt een getal, in de method, wat wordt dit als de NXT werkelijk rijdt?

Als je in de firmware wilt werken zal je een beetje moeten gaan meten, hier een paar voorbeelden.

(Natuurlijk geldt dit evenzeer als je alles met bluetooth vanaf de PC gaat besturen, dat wil zeggen: dan mag je opnieuw meten....)

Meetresultaten Pilot class

Rechte lijn:

Pilot robot = new Pilot(2.1f,4.4f,Motor.B, Motor.C,false);
robot.setSpeed(250);

// battery level around 8300

robot.travel(-2);// 5 cm
robot.travel(-4);// 10 cm
robot.travel(-6);// 15 cm
robot.travel(-8);//- 20 cm

//dit ziet er redelijk lineair uit

-------------------------------------------------------------------------------------------

Cirkel:

robot.steer( 75,400,false)
een hele cirkel is 400 , de 75 is het turnRate

turnRate straal, positief de ene kant op negatief de andere -100, 100

100 5.5 cm (kleinste cirkel in deze klasse, ene wiel staat stil, in de andere klasse kan je op een punt draaien)
75 11.5 cm de ene kant op 14 de andere kant op (dit kan niet liggen aan de positie van de pen)
50 19 cm
25 48 cm

Met het draaien is de spreiding in de resultaten vrij groot, ondergrond?

nxt coming in balance

2008-01-26T12:39:00.002-08:00

These movies look really funny:

some movies are really fake like this:

http://video.aol.com/video-detail/another-balancebot-lego-mindstorms-nxt/3625739070

Let us try to reproduce these things and learn something about balance and the sensors.

First the model: the nxt brick is upright, that means that the centre of mass is rather high up.
(Similar balance examples are this child game with the stick balancing on your nose, or the bike with one wheel...)

First observations:

this must be done with a prog in the brick, bluetooth has a considerable lag
the movie seems to use the light sensor, this is rather dependent on the surface...
let us try lejos JAVA with the acceleration sensor i bought...

The movements should be short and not to far from equilibrium...

(In the picture two sensors can be seen: the lightsensor (used in the movies) and the tiltsensor. I was too naiv: sensors cost time, and the tiltsensor (I2C) above all....i continued with the wrong one: the tiltsensor....)

sensors:

most movies use the lightsensor: strange, because in this setting only about three values are available, say -1, 0, 1 around equilibrium.

(ok later on i found out that the JAVA "readvalue()" method gives only values between 0 and 100 (normalized) You have to use contrary to expectations: readNormalizedValue() which gives values between 0 ans 1023)

the acceleration (tilt) sensor, using the x-angle, this gives a range of about 30 steps , 15 each side of equilibrium

motor methods:

motor.A.forwards(speed) and backwards, steers 2 motors (A and B) at the same time
motor.A.rotateTo(angle, true), this steers one motor, and the other lags behind!

First try: find equilibrium and then just drive in the opposite direction when needed:

if ( (senosrValue - midPoint) > 0 )
{
Motor.A.forward();
Motor.B.forward();
}
else
{
Motor.A.backward();
Motor.B.backward();
}

But this seems to brutal, there are four parameters involved:

equilibrium
driving time
speed of driving
waiting time, between the driving (waiting time??? please dont waist any time!!!)

The next thing to try is, make the speed a function of the measured angle
............hmmm doesn't work to well

Let's think: this is actually a reversed pendulum, and the acrobat on the one wheel bike is also in perpetual movement, she is not waiting to fall, and then reacting, could we try a balancing movement?

Then we have to find the time this this is swinging on.....
a long time ago Huygens mae his clocks and since then this is called the law of Huygens...

this means a swing time of about ...... 6/10 or a thread of 600 milliseconds, way to long.....
anyway also this experiment fails
the centre of mass could be moved higher up.
of course much depends on the model...

Nelleke proposed to make the robot self learning, but actually this is a 4 parameter space,

equilibrium
driving time
waiting time
force of driving

this as a minimum...

could he find his way in this space at random? (No of course not, this is 4 dimensional, easy to loose your way! Later on i reduced this space to : one! speed!)

what is the criterium to decide a good match?

I have tried to reduce the parameter space, and after that i could use an array for each amplitude around equilibrium and get the outcome decide to change this value, this didn't improve things much.

I tried to reduce the driving/waiting time altogehter, and only change backwards forwards when neccessary, so in case of going over to the other side of equilibrium. Using a few switches.
This seemed to improve things but not too enough.

Driving speeds: depends on battery level, but normally below 300 (Lejos value) is was too slow, i used values aroud 500.

Problems:

the corrections are too brutal, it is impossible to stay close enough to equilibrium. When the angle of falling is too large, the NXT is too late to get itself upright. It should become more subtile and gracious in its movements!

For the moment this experiment failed!

Could we use the acceleration and not the angle, in the acceleration sensor?

//-----------------------------------------------------------------------------

This failure prompted a more detailed study of the sensors.
The accel sensors, as all the I2C sensors are considerably slower then the light sensor.
Also changing the speed in the motors has to be studied.
(Any difference using bluetooth - yes: back to lejos JAVA in the brick.)
Then an estimate can be made of the response time of the total system
them we can see if this response time is fast enough to do the balancing trick,- or not! In the brick the lightsensor is speedy, the limiting factor is now the reaction time of the motors.

//-----------------------------------------------------------------------------

Research on the sensors showed that the lightsensor is the fastest, and has to be used instead of the tiltsensor, which is I2C.
But also using the lightsensor in the readNormalizedValue() mode, it gives more accurate measurements then the readValue(). The only problem is these measurements are not symmetric: closer to the table and further from the table, the light is not linearly increasing/decreasing.
But only using a small middle range of floating motors and the quickest possible reaction of the motors at fixed speed of 600 gave a far better result then anything before.
It starts balancing!

//---------------------------------------------------------------------------------
Tried using bigger wheels, and went back to the smaller ones.
Introduced the angle for the motors, Motor.B.rotate(angleT, true).
Speed fixed, but is very important: 600 in Lejos JAVA.
Time consuming is configuring the average for the lightsensor. Each surface is different in reflection. Eventually I calibrated before letting it balance like this:

Sound.beep();
for(int x=0;x<10000;x++) equilib = (int)((equilib + tilt.readNormalizedValue())/2); Sound.beep();
//the beeps to indicate starting and ending calibration, the lightsensor is very fast!

then here what i used in the loop:

if ( Math.abs( myAverage) >5 ){
angleT = 15 + 15 * Math.abs(myAverage ); //angle varying for being out of balance
if ( myAverage < 5 )
{ Motor.B.rotate(angleT, true); Motor.A.rotate(angleT, true); }
else
{ Motor.B.rotate(-angleT, true); Motor.A.rotate(-angleT, true); }
} else
{ Motor.A.stop(); Motor.B.stop(); }

with a speed of 600 it started balancing for a second or so, and had still to be helped
example movie (really no fake!) But I could leave the supporting strips out now!

work in progress!

nxt bike

2008-01-26T12:39:00.001-08:00

Het idee is om een voertuig te testen dat in evenwicht moet blijven. Een Nederlandse fiets heeft deze eigenschap. Met name de voorvorkconstructie helpt hierbij enorm. Zouden we dat idee kunnen vertalen naar een 'fietsende robot'?

Hier de schets:

We gaan het ding bouwen!

Aanschouw de schoonheid!

Een geweldig, slim gemaakt, voorwiel.

En een gammel achterwiel.

nxt base model scorpion (arnold and bram)

2008-01-26T12:37:00.002-08:00

Scorpion? Six legged thing?

The lego thing is great, that you can make all kinds of models from the same set of components in no time.

The disadvantage is only that each time you have to deconstruct the last model. The smart solution used in the last models are quickly forgotten.

Making a few pictures helps, but documenting the whole process of assemblege is quite a job, as can be seen when you follow the instructions to build the standard models on the website of the NXT.

pictures of Jos....

This animal model, a sort of insect or scorpion, seems to have six legs....and all these legs are driven by two motors. So how is this done? Well it is a combination of smart transfer of motors with the help of a few cogwheels, and pure suggestion!

The stinger is a very fascinating object, generating a sudden and large movement with all its hinges.

The program going with the scorpion in firmware worked well, detecting an objet and stinging, please put yous hand under the sting, because otherwise the touch sensor might be hurt :-)

nxt en letters

2008-01-26T12:37:00.001-08:00

Letters tekenen

Hiervoor gebruik ik niet de methode van de vormen met het vector algorithme, want dan worden de letters zo hoekig.

Ik heb gewoon alle letters gemaakt met cirkels en lijnen, was een heel gedoe, vooral de s....

De NXT kan je naam schrijven!

Hier komt een foto....:-)

Hier komt het progje....:-)

Er kan nog veel gesleuteld worden aan dit idee....bv zou het leuk zijn een ellips te kunnen tekenen voor de ronde letters als de o, de a, de p enzovoort...

nxt, drawing shapes

2008-01-26T12:36:00.001-08:00

Drawing shapes (lejos JAVA)

For this you need a model which can be steered and has a possibility of making a line on a piece of paper.

You could make a shape by carefully putting together the steering commands, but then you can only make one shape and rescaling is not possible anymore.

This is a way of programming a shape coming from a list of points. You have to calculate angles and length, depending on the scale you choose.

(This is one of the ways)

public static void myAngle ( Point p1, Point p2, Point p3 ) //always three points, from where, where am I, where am i going to?
{
double scale = 2.0; //putting in the scaling factor

double p1x = scale * (double) p1.getX(); //using a simple Point class to get components X, Y
double p1y = scale * (double) p1.getY();

double p2x = scale * (double) p2.getX();
double p2y = scale * (double) p2.getY();

double p3x = scale * (double) p3.getX();
double p3y = scale * (double) p3.getY();

double v1x = p2x - p1x; //making a vector of the points

double v1y = p2y - p1y;

double v2x = p3x - p2x;
double v2y = p3y - p2y;

//length of vector 1
double l = Math.sqrt( v1x * v1x + v1y* v1y ); //the formula of Pythagore, for length

//length of vector 2
double lv = Math.sqrt( v2x * v2x + v2y* v2y );

//projection on vector 1 of vector 2
double ill = v1x/l*v2x + v1y/l*v2y ; //using an inner product

//other part of vector
double ikk = Math.sqrt( lv * lv - ill * ill );

//get angle
double pi = 3.141592654;

if(Math.abs(ikk) < .001){ ikk = .001; } //dont divide by zero!!!

double atan = 100 - Math.atan( ill/ikk ) / pi * 200; //use the arctan to get the angle back, but wait!

//get further info on direction
double dir = v1y * v2x - v1x * v2y;//left or right of the line from p1 to p2?
if (dir<0) atan =" -atan;">

robot.travel( (float) (lv*3) );

}

Then the only thing you need to draw your logo is a list of those points.

Here should be added a nice photo and the example prog to make life easier!!

:-)

nxt als turtlebot (dutch)

2008-01-26T12:33:00.000-08:00

Mindstorms voorbeelden en experimenten

als eerste bouwden we de dertig minuten robot. Daarmee kan je de voorbeelden doornemen die allerlei mogelijkheden laten zien. Als eerste via het drag en drop menu van de lego mindstorms software.

programmeren is een kant, de andere kant is de bot zelf, het ding. Hoe 'het ding' is gebouwd blijkt nogal wat invloed te hebben op de uitvoering van het progje. Voor deze wijshied moet vast wel ergens een interessant citaat te vinden zijn.

turtlebot

het tweede experiment is een tekenende robot, (twee motoren)

Bij tekenen speelt de lijn een grote rol, het karakter van de lijn, lijnspanning etc, de verwachting is dat de verschillen tussen een objectieve plot zoals die uit een computer komt en de lijn van de bot die beinvloedt wordt door de buitenwereld, oppervlak, wielen instabiliteit een interessant exploratieterrein kunnen vormen, voor zowel de programmeur als de kunstenaar.)

paar voorbeelden van wat voor de mindstorms nog even niet te doen is....

De Mindstorms heeft voorlopig nog voorkeur voor wat meer formele en abstracte kunst....

Bij de turtlebot komen wat 'uitdagingen' aan het licht: de bouw van de robot heeft veel invloed op de uitvoering van zijn progje. Bv de tekenstift moet wel tussen de twee wielen instaan, anders krijg je al bij een simpel vierkant zwabbers in je getekende lijn. Nelleke merkt op dat je dit met behulp van programmatuur kan compenseren. bram denkt dat dit niet kan, zolang de pen niet van het papier te halen is, je dan hebt immers geen draaipunt om de penpunt heen.

iemand een idee voor een ontwerp met een op en neergaande pen? Niels denkt aan veren, bram denkt aan een versie die zijn evenwichtspunt kan 'kiepen'.
er is een probleem met de 'brick' in dit ontwerp, die is vanwege de batterijen ook vrij zwaar en zou dus laag moeten liggen, boven de wielen, maar dan is er geen plaats meer voor de pen, moeten de batterijen apart worden geplaatst? Dan kan je namelijk ze verdelen aan twee kanten en de pen in het midden laten, ideeen?
een kiepmodel heeft het nadeel dat als het kiepen de pen van papier moet halen, dit alleen kan als de pen niet meer in het midden tussen de rijdende as kan staan

Als de pen precies midden tussen de wielen staat is er geen afwijking meer, maar zie je dat desondanks vervomingen optreden, doordat de orientatie blijkbaar toch verstoord wordt, hoe zou dit te verhelpen zijn?.

vanuit het oogpunt van een kunstenaar behoren deze afwijkingen tot de 'signatuur' van de robot, en zijn daarom interessant. De resultaten worden daarom ook niet vergeten.

Vanwege de afwijkingen komt bram op het volgende idee: kan je de afstandsensor gebruiken om met de hand (die je in de buurt van de sensor beweegt) de robot te 'duwen' en kan je met deze handbewegingen dan de robot en daarmee de tekenlijn sturen? Dit wordt de volgende test.

NXT, steering with page on the web

2008-01-26T12:31:00.000-08:00

Very remote steering this time!
Idea: steering of the NXT with a page on the internet.

PHP -> Server -> C# prog ->bluetooth -> NXT

The C# prog can be found here, it is a changed version of the example of Bram Fokke.

Je kan via de webpagina de NXT aansturen vanaf

* laptops,
* nDS met browser, inn de buurt van een hotspot
* Second Life (Lindenscript)
* en waarop je verder nog een browser aan de praat kunt krijgen, of een POST of GET connectie met een server kan maken.

Voorwaarde: het C# prog moet aanstaan om de NXT te besturen met een bluetooth dongle

Voordeel: geen last meer van VISTA MAC of PC specifieke dingen

Nadeel, een 'zekere' traagheid (twee oorzaken, de serververbindingen en de bluetooth)

Het prog is nog in ontwikkeling, je kan de COMpoort instellen voor het connecten, nu ook ingestelbaar is de motorpower, (alhoewel de C# er niet uitziet, met zijn windowsgrafgrijs, is het toevoegen van sliders en invoervelden wel erg comfortabel....)

* ok, weer wat uitgevonden in C#: de picturebox, voor plaatjes
* deBackColor property van het hoofddesign, (weg grafgrijs...) wat kan er allemaal niet, in C# :-), nou: een gele achtergrond.......?

De PHP pagina, waarop je dus de NXT aanstuurt, is ook nog in ontwikkeling: http://www.contrechoc.com/sl/nxt/motorA.php

(De PHP pagina wordt binnenkort vervangen door een FLASH animatie die de server 'in design' gaat bespelen.)

Op Second Life kan je ook al terecht voor deze methode, er staan nu een aantal knoppen op het grondstuk 'Silly Things',

NXT and the WII remote control

2008-01-26T12:27:00.000-08:00

Who doesn't want to programme the WII (remote control)?
First get the bluetooth working!
then read this article to get to know Glove Pie:

http://crustea.vjfrance.com/article-130714-6.html

BlueSoleil, is more easy to use then other bluetooth prog's, like Widcomm.

if you are lucky the COMPORTS behave normally and bluetooth is no problem (otherwise try troubleshooting)

* connection WII <-> bluetooth reaaly without a problem
* de C++ <-> bluetooth normally too, unless... ... --my mistake wat to think i had to start the bluetooth connection before i started the prog--
o watch it the cobbection can go two ways, from laptop to NXT or the other way around for Wii you need PC to NXT
o ok the progs in C++ or C# make the connection themselves

The article describes how to get the Wii remote control working actually for all programmes.

* in fact the steering is from the PC, only the PC prog is steered by the Wii.

So you need a prog on your laptop with mouseEvents or Keyboardevents which sends signals through bluetooth to the NXT .

In the example of Anders, ( http://www.norgesgade14.dk/bluetoothlibrary.php ) i added openGL, then you can get a better interface then the simple console window, and you have an event loop at the same time. Wii input is directed by GlovePie to the C++ prog and hurray!!! The bot is being driven around by the Wii...!!!
Can be done in any language of course, which has the bluetooth connection.
Tip: in the C++ lib of Anders to get both motors driving at the same time: use the motorA.on() method in the C++ lib van Anders, and there will be synchronisation between the motors.

(Doc: LEGO Mindstorms Direct Commands, can be found in the LEGO MINDSTORMS NXT Bluetooth Developer)

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Wii programming in general: (C++ lib, and other Wii features)

* http://www.wiili.org/index.php/Wiiuse_C
* http://onakasuita.org/wii/index-e.html

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Johnny Lee has some wonderful and simple ideas for the Wii, just type Wii and 3D in the searchengine and look for the Youtube video.

nxt bluetooth

2008-01-26T12:23:00.000-08:00

Bluetooth, the magical word!
With Bluetooth you don't need the USB wire anymore, the NXT is freed!

Send a programm to the brick without cable connection.
Or programming on your computer, using big memory and speed, sending the commands to the brick and receiving back the sensor values.
be careful: setting registers in sensors is not possible, see master slave

You can steer the brick from your laptop!

Preliminaries:

the hardware: buy a dongle (sitecom...)
install bluetooth software, Bluesoleil, or Widcomm

if all is in place (The sitecom dongle seems to have bluetooth all in itself, later i connected without widcomm nor bluesoleil)
do a "search" of bluetooth devices
find the brick and connect: pairing will be done (always use pin-key 1234 for both laptop and brick (in lejos only the PC askes for a code)
a COMPORT number will be given
when this is done you can connect (by hand", using the COMPORT (in leftclick on brick icon in BlueSoleil)
the COMPORT number is something on the laptop, not on the brick (another laptop another COMPORT number)
the connection can go two ways: from laptop or from brick: you need from laptop

choose a programming environment, Dev Cpp, or C# (visual express)

if JAVA is wanted, use icommand, but somehow, this is difficult to get working in ECLIPSE

get some of the free libs, (I used Anders of Bram Fokke to start from, links see below)

the the examples coming with these libs connect and deconnect themselves
in case of programm stopping, look if Brick is deconnected to, sometimes need to restart brick and or dongle in and out of the laptop, to reset the bluetooth

another possibility is the "fantom API" provided by LEGO itself. I found this link: http://epirsch.blogspot.com/2008/02/jna-love-nxt.html, built the packages in ECLIPSE (added a bit of exception classes) and it worked! For this only a dongle is needed, and the JAVA of course, including the jna.jar

In principle the bluetooth is very easy, but problems can be around every corner. My problems were: starting the bluetooth connection by hand before the prog on the laptop wanted to start too, getting a mess of COMPORTS numbers.

The COMPORT number needs to be smaller then 10. If you encounter a number higher then 10, try troubleshooting

Other tips:

don't confuse icommands and bluetooth! Bluetooth is in the standard lib of Lejos and others, icommand only for JAVA-fans who want to steer the NXT from for instance ECLIPSE using bluetooth.
as told: bluetooth is one, but steering the NXT is another: you need a prog on the laptop to send and receive the DIRECT COMMANDS send through Bluetooth. This can be found in the libs of Bram Fokke, using Microsoft Visual C# (good introduction!) or the libs of Anders in Dev Cpp.
bluesoleil is ok for C++ and C#, for icommand/ECLIPSE bluesoleil seems to block the connection (see below)

Free libs:

Anders C++: http://www.norgesgade14.dk/bluetoothlibrary.php
Bram Fokke C#: http://www.codeproject.com/useritems/nxtBluetooth.asp?df=100&forumid=420165&exp=0&select=2211060

Documentation:

de Bluetooth Developer Kit: http://mindstorms.lego.com/Overview/NXTreme.aspx
all the libs are based on DIRECT COMMANDS

Ok using these libs, and building on the examples the NXT is driving around, steered from the PC.

Further ideas: Steering from the web, or Second Life, using a server.

Bluetooth problem: (loading progs to the brick)
Later on with Bluesoleil installed i could not connect from the COMMANDWINDOW using lejos.
Although the brick was running (lejos) the brick was not found from the COMMANDWINDOW, i could connect manually using Bluesoleil
The solution was to desinstall Bluesoleil. This probably has to do with the dongel of sitecom i used.
In the COMMANDWINDOW i used this to check:

C;\java\lejos_nxj\samples\tune> lejosdl -b tune
Linking...
Uploading...
Bluecove version 2.0.0 on winsock
Found 5brickXT
Upload succesful in 2344 milliseconds
Bluecove stack shutdown completed

Also using the ECLIPSE utility for the lejos i could now browse the brick using bluetooth and run programs
From the console in ECLIPSE:

Linking...
Uploading...

BlueCove version 2.0.0 on winsock

Found: 5brickXT
Upload successful in 5062 milliseconds
BlueCove stack shutdown completed

NXT sensors

2008-01-26T11:58:00.000-08:00

In the NXT box there are 4 sensors:

touch (on off switch)
sound (sound level reading)
sonar (distance reading between 7 cm and 255 cm), see mapping radar blog
light (difficult to give a scale here,

fast sensor

important is (in lejos) to use readNormalizedValue() method for values between 0 and 1023)
on sensor port 4 the floodlight does not function (on my brick)

motor, the degrees of turning can be measured

used in the radar, to compare with the compass, quite good cheap alternative!
someone found out that the motor ports differ in properties: philohome

Other sensors can be bought, i bought them here: http://www.mindsensors.com/

These are I2C sensors, so they are much slower than the custom sensors. Also reading these sensors in one loop is a good test of the software you use: reading multiple I2C sensors poses a problem for the fantom lib and NEC. The C++ lib of Anders gives the right values, but is very slow: 3 sensor readings in 2 sec., for instance clock, compass, distance.

compass (one readout raw: 0 - 512, in Anders Lib two precisions degree of half degree)

watch it: if the compass sensor too close to the brick it gives garbage! (10 cm is ok)
I2C sensor: not fast
this sensor has to be as horizontal as possible otherwise the degrees measured will not cover the circle evenly, or even stay at one side of the center, this was discovered in the radar experiments.

acceleration (6 readouts, tilt an accelaration, this can be used as a compass too?)

I2C sensor: not fast

camera (can follow objects, see camera blog)

quite a lot of basic documentation: and the texts on www.mindsensors.com
it helps a bit to know about DIRECT COMMANDS

clock (giving a time readout, blocks available for FIRMWARE; made ourselves classes for C++ and Lejos

has free memory available, non volatile, 56 bytes!

homebrew classes for Dev-Cpp Lejos and fantom lib

PSP-NX this is not really a sensor, but a digital interface to the playstation controller, we made the Lejos JAVA class for this I2C sensor

(Later more about the clock, for a start here: the LEGO FIRMWARE reads it well with the block, downloaded from the link in mindsensors. Lejos JAVA: here you have to write a class for the clock, extending the I2CSensor class, using the super(SensorPort port); in your constructor, because I2CSensor is an abstract class.)

see classes for lejos written out:
http://www.koders.com/info.aspx?c=ProjectInfo&pid=RHGY8H3PWYCG28MNNNS8V1BLGC)

For these extra sensors special blocks can be downloaded for use in the FIRMWARE.

You need to make this possible: Dynamic Block Update
examples: http://www.teamhassenplug.org/NXT/

Then testing the time the sensors use to measure: (quite neccesary, sometimes performance depends on speed.)

the light sensor works fast, being in the core of the NXT
the acceleration sensor is lowspeed, (I2C) this makes a big difference!
the compass is low speed, so stopping motors on a certain heading can be not too precise

Measurements (first on my laptop, using bluetooth connection, and then a lejos JAVA prog on brick)

comparing the times the different sensors react in combination with the software and the bluetooth.

//--------------------------------------------------------------------------------------------------------------------------
// DevCpp (small standard console prog with lib of Anders)
//--------------------------------------------------------------------------------------------------------------------------
(using the fastest possible while statement, without sleep or thread)

lightsensor: 1000 times (included readout in console) 22 sec
acceleration sensor: 1000 times (included readout in console) 273 sec (reading only the xTilt)
1000 times all six values 1640 sec (wow!)

(I wrote the accel class like the other sensor classes)
compass: 1000 times (included readout in console) 273 sec (exactly the same as the low speed acceleration sensor.)

So with this knowledge, for instance making a balancing robot, the lightsensor should be used.

//--------------------------------------------------------------------------------------------------------------------------
// C#, using bluetooth connection.
//--------------------------------------------------------------------------------------------------------------------------

I used my example prog TryoutClasses, since this is a minimum setting, without having installed all kinds of sensors at the same time nor polling time

lightsensor 1000 times 22220 milliseconds (you would not believe this!) = 22 sec, exactly the DevCpp value
compass sensor 1000 times 66697 milliseconds, which is faster than the DevCpp, why? Reading at double degree?
accelleration sensor 100 times 6688 milliseconds for one reading xTilt
accelleration sensor 100 times 40178 milliseconds for six readings 3 tilts and three accelerations

So in the C#, the readings of the low speed sensors seem to be faster!

//--------------------------------------------------------------------------------------------------------------------------
// comparing this with reading sensors in a lejos program on the brick
//--------------------------------------------------------------------------------------------------------------------------

for a prog on the brick how is this to know the elapsed time?
The clock sensor! (This is one way)
The internal clock. (This is another)

The internal clock gives a long, which has to be cast to an int or double:
double nowTime = (double)System.currentTimeMillis() ;
because this Lejos JAVA doesn't operate on long's

tiltsensor xTilt() : 1000 measurements 26 sec (included displaying currentTimeMillis())
tiltsensor 3 times xTilt, yTilt, zTilt, without displaying the elapsed time, or anything: 13 sec!

lightsensor 10000 times (yes) in 4 sec
lightsensor with displaying the value and the time on the LCD 1000 measurements: 22 sec!

Conclusion: the readings of the sensors is much faster when on the brick, and the lightsensor is always faster then the tilt, other I2C sensors, like compass.
Sonar is I2C too, but has a special connection to the ARM7 Brick processor.

//--------------------------------------------------------------------------------------------------------------------------
// putting sensors together
//--------------------------------------------------------------------------------------------------------------------------

One of the goals is a radar device, scanning the environment and making a map, eventually following intruders in the environment he scanned.

For this sensors had to be put together.
The compass and the motor-degrees can be compared.

The image shows a brick which is only built to trun around its axis and giving measurements. When polling this array of I2C sensors, time must be given for each measurement, as described above.

(Using the bluetooth and some language on the laptop, data can be analysed easily, using the JAVA lejos, everything has to be done on the brick itself.)

(In principle, when always orientating the brick to some main wall, the motor-degrees can be used replacing the compass. So the radar device can be made with the motor and the sonar-distance sensor.)

The compass and the motor-degrees were behaving (aren't we lucky!) linearly.

The RAM of the clock can be made useful too, storing the information gathered.

ok to be continued................

NXT and C#

2008-01-26T11:47:00.000-08:00

Bram Fokke wrote a very useful C# prog, for steering the NXT with bluetooth, you can find it at:

http://nxtsharp.fokke.net/

I transformed and added this basic design and use this prog to connect to the NXT from a website or even from Second Life! Through PHP my server has the neccassary dBAse for moto and senosr values. These are asked for by the prog and send to the brick by bluetooth.

In C# adding a browser is so easy! But the Bram Fokke prog uses quite a lot of his own classes, the structure is not very clearly visible if you are coming to C# for the first time, so i made a little demo program in C#, doing things with button, having it's class in a namespace, and thirdly connecting to the NXT (choosing a ComPort) and playing a sound in the brick. Download.

In the Bram Fokke prog i added sliders to change the motorpower and added buttons to connect and disconnect. This altered the structure of the program (which connected on running) so i have to do some extra errorchecking on the motor buttons, not doing anything when not connected.

The disadvantage of the website - server - bluetooth connection is that is becomes rather slow... dont drive your own car like this!

So this is how the program looks now...

NXT remote steering

NXT visual C++ Express

2008-01-26T11:45:00.000-08:00

The library of Anders (see other blogs for link) runs without problems in Dev Cpp.

But Dev Cpp is really "old style" great for fast experimenting (several times i went back to it, for instance for writing the clock sensor class) but more cool environments are available free..

That is why i present here an example in Visual C++ Express, running with a few class coming from Anders library.

Dont forget to add #include "stdafx.h" everywhere.

In the serial.cpp i had to change CreateFile in CreateFileA.

You must get used to the way Visual C++ links classes....

download the example Visual C++ Express voorbeeld.zip

explore and be creative!

NXT and DevCpp

2008-01-26T11:40:00.000-08:00

Dev Cpp, free to download.

here a page to help installing Dev Cpp: http://www.uniqueness-template.com/devcpp/

Using the library of Anders, this is a great way to experiment, because the structure stays very simple, unlike the C# skyscraper.

http://www.norgesgade14.dk/bluetoothlibrary.php

With the library of Anders, bluetooth and all kind of non standard sensors can be tested.

I used it in the console window.
I added an openGL environment which also works fine.

To get a notion of the speed of the sensors, I used DevCpp in comparison with C#. See sensors.

Example: Dev Cpp voorbeeld.zip

In the Anders library examples are included.

Firmware revisited

2008-01-26T11:39:00.000-08:00

Making programmes in the FIRMWARE is easy and difficult at the same time! Making small programmes to test sensors is done intuitively and works fine. Trying to programme in the way a programmer works in C++ or JAVA is difficult. With the FIRMWARE you have to develope another strategy of programming.

New sensors: for these sensors there are new "block" to be downloaded. For this, the FIRMWARE itself needs to be updated:

http://mindstorms.lego.com/Support/Updates/

A nice feature of the FIRMWARE is that you can make blocks yourself! By selecting a part of your FIRMWARE program and using the blockeditor: under menu->edit you find Make a new myBlock, the My Block Builder windows opens, you can define or make an icon for your new block.

Usefull new blocks, made with a special block editor can be found at:

http://www.teamhassenplug.org/NXT/

What i find difficult is the use of Variables in FIRMWARE. Under Menu-> Edit you are able to define a variable, there is a block called Variable ( a suitcase) but writing to it, or reading it, or changing it was not really obvious to me. So for what i needed, i programmed around the use of Variables!

NXT Tower of Babylon

2008-01-26T11:36:00.000-08:00

The NXT is a programmable robot, so which language do you want to use?
Many around!
a big comparison table can be found here.

FIRMWARE:
The language coming with the NXT is the FIRMWARE of Lego. Programming is done with drag and drop of elements. With this language the basic functions can be explored. It gets more interesting when you make your own blocks, but in the end some features of normal programming, like easily introducing new variables is somewhat cumbersome.
Good for: testing.
more about FIRMWARE

JAVA can be done in the Lejos JAVA.
Programming is possible in a text document and compiling and transmitting can be done from the COMMAND WINDOW. But easier is to use a roundabout with ECLIPSE. ECLIPSE is a bit cumbersome to install and link with the Lejos libs, but in the end it is value for money (because it is free :-) and it helps a lot avoiding mistakes in programming.
The JAVA is transmitted to the NXT using USB or Bluetooth, all from ECLIPSE.
description API of Lejos
Koders Very important: the sourcecode of the classes can be found here!
FilIO on the brick in lejos : an example used in eclipse
Lejos Java and the arraylist: an example using an extra class and using the arraylist
abstract classes and a long: building on the I2C abstract class and making a double from a long
There are quite a few limitations, look carefully at this list. (Search limitations)

latest about Lejos and robotics: ebook by Juan Antonio Brena Moral

C++
Dev-CPP can be used too, running on the laptop, using bluetooth actually sending DIRECT COMMANDS to the brick. The libs I used and expanded are coming from Anders. (see Table)
I use Dev Cpp in the console mode for basic testing, for instance of the sensors.
I use Dev Cpp also with OpenGL to be able to draw the environment of the brick (using the sonar sensor).
Microsof Visual C++ works fine too, using his Anders classes, with a few alterations.
an example in C++

An independant and semi commercial lib is the RobotC. This is very nice seeming to run on the brick and the PC at the same time. You can use it a month for evaluation. I continued with the free available libs Dev-Cpp, ECLIPSE and C#, so no further experience. Many examples can be found on the web.

C# of Microsoft Visual Express, can be used, with the lib of Bram Fokke, see table. I have expanded and rewritten this lib and the features of Visual Express, coming free are really great (webbrowser and toolbox for instance, i used this for steering the NXT from the web and from Second Life.)
The modified Bram Fokke steering

Language	Editor	where?	features	Costs	source
Firmware	Lego Mindstorms CD	in Brick	drag & drop (USB bluetooth versturen)	comes with buying the NXT
JAVA/lejos	Eclipse	in Brick	(USB bluetooth versturen)	free	http://lejos.sourceforge.net/
C++	Dev++ Lid of Anders	in PC/bluetooth	Console/Windows appl (Bluetooth Direct Commands)	free	http://www.norgesgade14.dk/bluetoothlibrary.php
C#	NXT C#/ Visual C# Lib of Bram Fokke	in PC/bluetooth	Console/Windows appl	free	Visual C# Express - http://nxtsharp.fokke.net/

RobotC	RobotC editor	in PC/bluetooth	runtime debugging, showing all regsiters When RobotC is in the brick, sending bluetooth is hindered	30$	http://www.robotc.net/

There are other languages like NQC, not quite C and Ruby for instance, i have not done too much with these languages at the moment.

nxt lejos fileIO

2008-01-26T11:34:00.000-08:00

Writing data to a file on the brick (in the JAVA of lejos ) is possible, this is an example of how it can be done:

(The JAVA running on the NXT is not as powerful as normal JAVA, some classes cannot be used.)

//file exists? when not: make it:

File file1 = new File("tryout.txt" ) ;
if (! file1.exists() )
file1.createNewFile();

//writing 2 bytes to the file

FileOutputStream filestream = new FileOutputStream( file1 );
filestream.write(43);
filestream.write(22);
filestream.close();

// write() en close() in the FileOutputStream class are available

//read back the bytes and put them on the screen NXT

FileInputStream fileInstream = new FileInputStream( file1 );
LCD.drawInt( fileInstream.read(),5,5 );
LCD.drawInt( fileInstream.read(),5,7 );
fileInstream.close();

//available are the methods read() en reset() in the FileInStream class

---------------------------------------------------------------
when stored data from the sensors, these data can be read back like this:

public static void reportFile (File filex)
{

//input de fileName
//output on the LCD screen in two colums

LCD.drawString("start",0, 0 );
try {
//open inputstream
FileInputStream fileInstream = new FileInputStream( filex );
int testByte = fileInstream.read();

int uy = 0;
int ux = 0;
//make the values appear on screen in columns
while ( testByte != -1 )
{
LCD.drawInt( testByte, ux, 2 + (uy++) );

testByte = fileInstream.read( );

if (uy>3)
{
ux+=3;
uy=0;
}
}
//finish
LCD.drawString("finished",0, 7 );
fileInstream.close();
LCD.refresh();
} catch (IOException ioe) { LCD.drawString("IO Exception", 0, 0); }
}

To be explored: Can this file be downloaded to the laptop?

Installing JAVA and Eclipse (without bluetooth)

2008-01-26T11:33:00.000-08:00

Good news: available since 18 march 2008: an ECLIPSE PLUGIN for the Lejos
http://lejos.sourceforge.net/
installing lejos in Netbeans, link:
http://homepages.feis.herts.ac.uk/~comqdhb/lego/netbeans.php

Why not want to use the firmware of Lego?

Firmware is good to test some simple ideas and getting a notion of the sensors
Firmware becomes cumbersome when really programming around, for instance using variables
(but dont forget: some people really do marvellous things in the firmware!)

All kinds of other possibilities (C, C++, C#, NQT, Ruby), nearly too much.

In this blog we present some experiences with the Lejos, Java library, later on experiments in C++ and C#, and the fantom lib.

This intro is added lately on the sourceforge site: http://lejos.sourceforge.net/tutorial/index.html

Beware: the lejos-JAVA is reduced, sometimes Eclipse accepts something which fails in the brick, see limitations of Lejos.
but: now we can programme!

classes
arrays
input output

Installing Lejos and Eclipse is quite an undertaking! This is not really a quickstart.

Slowstart (see also other pages on the web)

Download Java for Mindstorms NXT: http://lejos.sourceforge.net/
(JAVA JDK is installed? Don't forget about paths, don't forget about the naming conventions without spaces in the folder names for JDK)
You can programm JAVA lejos from the command window, some people say this is better to learn JAVA, but programming becomes more comfortable in Eclipse, (at a certain price: starting it up!)

JAVA JDK, Lejos and Eclipse, are three parts which have to come togehter

This description is ok: ('bartneck') : http://www.bartneck.de/work/education/masterClassLego/javaInstallNXT/index.html

to transfer data, a program to the brick, also downlaod and install LIBUSB
environmental variables, for everybody a bit different depending on the placing of JDK and Lejos.

'this computer', 'properties', 'advanced', 'environmental variables',

Warning: Dont put the JDK in the folder named "Program Files" this contains a space and can be a problem for JAVA.

System variabels
testing the Lejos in the commandwindow, ('bartneck')
ECLIPSE and lejos configuring ('bartneck')
in the running project in ECLIPSE mind the BUILD PATH!

(ECLIPSE uses external jars but also in the nxj.bat file it searches the CLASSPATH, using the environmental variables, what is the difference? While all worked well, for use of JAVA progs transmitted to the brick, I got a persistent error trying to compile something using icommand...not finding the icommand.jar while it was in the CLASSPATH and even in BUILDPATH...)

Checking:

in commandwindow type: lejosdl and it has to show a list of options (see special on commandwindow)
ECLIPSE compiles the JAVA, finding the lejos libraries
at last transferring the program to the brick using USB, the brick gives a signal

After connecting:

wait three seconds, after Windows gives the USB connect beep, before compiling and transferring

//--------------------------------------------------------------------------------------------------------------

some other features:

USB uploading ok: start the file by switching to the file and executing it.
but using bluetooth (to transmit the program) it can already be running too!

depending on how you have written your program it can be on and waiting for you, without showing anything, spoiling its batteries.
so to prevent this programme something to show a message on the LCD screen

//--------------------------------------------------------------------------------------------------------------

if there is an unchecked exception in th program or other wrong things the LCD screen displays the error, and the brick is not to be shut off. Reset it!

problem:

from ECLIPSE, compiling/uploading (USB)...in the console window of Eclipse: Bluetooth not found, ok you started too quickly uploading

//--------------------------------------------------------------------------------------------------------------

emulator

an emulator could be super, but really because you have to build your own robot, it doesn't make much sense!

//--------------------------------------------------------------------------------------------------------------

In this document describing the installation of Lejos i found this warning:

Warning:

There is a theoretical limit to the number of times you can replace the firmware on your NXT before it wears out. Every time you replace the firmware, a piece of data called a lock bit is used up. This bit is rated to work 100 times (minimum) before it expires. However, don’t let this dissuade you from replacing the firmware with something you want more. Most engineers agree that the lock bit will last far in excess of 100 times. Chances are you will never even notice this limitation and you probably won’t replace your firmware enough to approach even 100.

That is bad news? Why "wear out" the brick????? Anyone suffered this?

//--------------------------------------------------------------------------------------------------------------

TESTING installation: (functioning of lejos in Command Window)
ok: another page for installing, with a good test: see under number 9 on this page
This page has a special on installing Lejos in Eclipse.

quickstart firmware

2008-01-26T11:31:00.000-08:00

a good description of the NXT can be found in the wikipedia: http://en.wikipedia.org/wiki/Lego_Mindstorms

This entry also gives a list of languages to programm the bot, besides the drag and drop FIRMWARE of Lego, coming with the box.

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

This is really a uickstart , you can built a robot in no time, and experiment with small prog's.

actually without building anything: attach sensors and fool atound with the sample program's already installed with the FIRMWARE.
Somehow all these legoparts must be put together, there is a special collection of parts which you can use to construct the simple TriBot in 30 minutes! Starting in the small book.
In the bigger book, parts and sensors are added to give yo
when you really programme the drag and drop feels clumsy, but it has more hidden features, for instance making your own blocks which make it more interesting.

But in the end you can better choose a "language", then there is a whole spectrum:

JAVA, free Lejos software for running on the brick: http://lejos.sourceforge.net/
RobotC, C: http://www.robotc.net/index.htm , with the advantage of convenient debugging possibilities (30US$)
Not Quite C, (not yet tried) http://bricxcc.sourceforge.net/nqc/
later on, in bluetooth mode you can rely on your laptop power for intance the lib of Anders http://www.norgesgade14.dk/bluetoothlibrary.php