Nov 03 2012

NXT console v0.1

Category: Lego,Mindstorms,NXC,Programs,SoftwareSpiller @ 20:27

A long time ago on Mindboards some talk was made about displaying text-output like how it is done in a console, but I never ended up writing any code. Since it have been quite some while since I last wrote anything in NXC, I did this as a quick brush-up project.

Supports scrolling up and down with the left and right button on the NXT, and supports the control characters ‘\n’, ‘\t’, ‘\a’ and ‘\b’. ‘\b’ only works on the text you are currently adding though.


NXT console v0.1

Mar 05 2011

Writing NXC code in Notepad++

Category: Lego,Mindstorms,NXC,SoftwareSpiller @ 19:21

When writing programs in NXC I prefer using Notepad++ instead of BricxCC as the text editor. Notepad++ isn’t a IDE though so you can’t compile it directly in the program. However Notepad++ comes with a plug-in called NppExec that can execute other programs and we can use this to start the command line compiler (nbc.exe) directly in Notepad++.

Compiling files with NppExec

NppExec is a rather powerful plug-in which can do a lot for you. To start it up, simply press F6 (or find it in the menu, Plugins -> NppExec -> Execute…).

The NppExec main window

The big multi line textedit field will contain all the commands you want to execute. Each line is a separate command which will be executed after each other, starting from the top. To get started, we need to find nbc.exe’s location. It is in the same folder as BrixcCC which is normally:

"C:\Program Files\BricxCC\nbc.exe"

(The quote marks are necessary if  there are spaces in the path, they are NOT optional!)

First of all, as this is a command line compiler (because that is the reason we are using it), we need to know which parameters it takes. To do this, enter the following command in NppExec:

"C:\Program Files\BricxCC\nbc.exe" -help

(To get a command line program’s supported parameters, you often write “-help”, “-h” or “/?”. (To get a list for NppExec, simply write “help”.)) The result should look something like this:

The NppExec command line window

Notice the syntax: nbc.exe options filename options

So after nbc.exe you can place parameters (options), then the filename and after that more parameters. (I prefer having all the parameters together though.) The most important parameters are:
-d, which will compile and transfer (download) the program to the NXT.
-r, the same as -d, but will also start (run) the program when done.
-Z[1|2], this will turn compiler optimizations on, -Z2 is recommended.
-EF, if you are using Enhanced Firmware, remember to add this one.
-v=n, this specifies the version of your firmware. This apparently defaults to NXT 2.0 firmware now, so you most likely doesn’t need to specify it. (Otherwise write -v=128)

(I haven’t tried downloading over Bluetooth so don’t know how this is done. You might need to use the -S=portname parameter…)

So in order to compile your NXC file and download it, you write this in NppExec:

"C:\Program Files\BricxCC\nbc.exe" path_to_your_file -d

where “path_to_your_file” is the file path to the NXC file you want to compile. If you want to use Enhanced Firmware and compiler optimizations you can do it like this:

 "C:\Program Files\BricxCC\nbc.exe" path_to_your_file -d -EF -Z2

Everything we have done here is possible to do in the command prompt, if you try to run the commands in the command prompt it will work as you expect. However there isn’t much point of doing it in NppExec if you just use it as if it was a command prompt…

Taking advantage of NppExec

The first thing we want to avoid is to having to change “path_to_your_file” every time you need to compile another file. NppExec contains some macros that can help us with this which take the form: $(NAME_OF_MACRO) where “NAME_OF_MACRO” is the macro you want to use. The one we want to use is FULL_CURRENT_PATH which will be replaced by the file path of the document you are currently viewing. We simply needs to use this instead of “”:

"C:\Program Files\BricxCC\nbc.exe" "$(FULL_CURRENT_PATH)" -d

Notice that there are quotes around the macro. These aren’t necessarily needed, however as said before, if there are spaces in the file path you need to have them. Add quotes every time you automatically inserts something that can contain spaces, better safe than worry.

Saving files

One thing you need to be aware of is that it uses the file saved on the hard disk, so if you have made changes to the document and have not saved it yet, those changes will not be known by the compiler. So you will either have to remember to save or use the NppExec “NPP_SAVE” command which automatically saves the current document. You place this command on its separate line before your call nbc.exe:

"C:\Program Files\BricxCC\nbc.exe" "$(FULL_CURRENT_PATH)" -d

Improving NXC integration

Turning off compiler status messages

nbc.exe writes quite a bit of status messages in the console window which I aren’t really interested in normally, however you can turn those of easily by adding the parameter “-sm-“:

"C:\Program Files\BricxCC\nbc.exe" "$(FULL_CURRENT_PATH)" -d -sm-

Reducing the shown amount of compile errors

The command window autoscrolls so if you get 50 errors you will have to scroll all the way up again. You can set a limit on how many you want to be displayed with the -ER=n parameter (where n is the maximal amount).

"C:\Program Files\BricxCC\nbc.exe" "$(FULL_CURRENT_PATH)" -d -sm- -ER=5

(It seems it that nbc.exe didn’t output the error messages to the console in some of the older versions, but you can store the error messages to a file with the -E=filename parameter and then display this file in the console.)

Making the compile errors easily readable and add goto line

Right now the compile errors is a bit hard to read, however you can add coloring rules to make it more clear. Go to “Plugins -> NppExec -> Console Output Filters…” and a dialog window with three tabs appear which you can filter some of the lines out or only allow certain ones. You can replace text and the last tab, which we are going to use, highlight lines.

NppExec highlight dialog window

Take a closer look at the image to see the changed I made. The column of checkboxes turns the highlight marks on and off, the second column is the rule, the three next ones is the RGB color in hex (which nearly impossible to change, just use “0” and “ff”). The last three colomns with check boxes add Italics, Bold and Underline text decoration.

I will not go in dept with how to make rules though, look in the documentation or just read the text at the bottom if you want to learn how  to make your own. I will however go through the first line:

File "%ABSFILE%" ; line %LINE%

The %ABSFILE% part tells that this is an absolute file path and %LINE% tells that it is a line number. The cool thing is that if you double click on that line, it will automatically go the specified line in that document. Jumping to a specific line specified in the console

Make Notepad++ automatically add syntax highlighting

If you open a .nxc file in Notepad++ it will treat it as a text file. To make it recognize the file extension, go into “Settings -> Style Configurator” and select the language you want to use, most likely C or C++. Then in the “User ext. :” box, add “nxc”. (If you want multiple extension, separate each with a space.) Style Configurator dialog window

If you want to use a User Defined language instead, go into “View -> User-Defined dialogue…” and add the extension in the “Ext. :” box.

Function auto-complete and highlighting?

I found a User Defined language once that did this, but its C support wasn’t too good as User Defined languages are rather limited in that aspect. (Which is why I’m just using the standard C syntax highlighting.) Autocomplete worked great though.

I don’t have the link anymore and I think it was posted on… (And I will not redistribute it without permission from the author.) Does anyone know of a good alternative?

Other stuff…

Saving the compiled .rxe file

It can be done with the -O=filename parameter:


Notice the two new macros and how it is used to create a new file path.

Windows intergration

I have recently studied how to implement your own filetype in the Windows shell, so I’m going to try it out and write it in another post. Adding stuff like being able to compile .nxc files just by right clicking on them in Explorer and such.

It is going to involve manual editing in the Registry using regedit though.


Feb 16 2011

Bezier v2.4.0

Category: Lego,Mindstorms,NXC,Programs,SoftwareSpiller @ 00:31

\Quite some time ago, way back to the time of, I was writing a Bézier curve implementation in NXC. Muntoo was also writing one at the time, you can check his out on his blog, here. His implementation is generally more feature rich, like several different drawing modes, while mine is geared towards pure speed.

To start it off, here is a screenshot of the current progress:

The process is two-step, a initiation function which calculates some basic stuff which takes 11 msec, and then the drawing functions. In the screenshot there are 10 cubic curves drawn by the general Bézier algorithm which takes 419 msec in total, so ~42 msec per function call in average. (The first draw with a new amount of control points is a bit slower as some of the calculations are reused.)

Right now there is only a general Bézier algorithm, the one I optimized for cubic curves isn’t working correctly…

Implementation – v1.1.0

The general Bézier formula looks like this:

B(t)=\sum_{i=0}^n{n\choose i}(1-t)^{n-i}t^iP_i

So to draw a Bézier curve you would start with t=0, calculate the x and y positions, increment t by 1/”desired precision” and recalculate. This process is repeated until t=1. There is a lot of calculation needed for each t value, yet we might be able to do some of the calculation that doesn’t directly involve t beforehand.
We could for example calculate the binomial for each P and store it in C like this:

C_i={n\choose i}P_i


Implementation v2.+

NXC is compiled into a bytecode format in which math opcodes are polymorphic. If you try to multiply an array with a scalar, the scalar will be multiplied with each of the elements in the array. This is however a lot faster than manually iterating a loop multiplying each element.

So my idea was to take advantage of this by making an array containing each value of t. Instead of iterating a loop, you would simply do the math operations on this array. The array of t values would also only be calculated once in the beginning of the program, instead of each time you need to draw the curve.

So for the Bézier algorithm there would be two arrays, one containing each value of t and another containing each value of 1-t.

However we want to optimize this further. Since we start at i=0, lets consider that case:


We will only need to calculate (1-t)^n, so lets try finding the difference between the first iteration and the next:



We can therefore get to the next iteration by multiplying \frac{t}{1-t} into (1-t)^n and into the next iteration by multiplying again:

This fraction can be calculated without knowing n or i, so we can calculate this at the start of the program and reuse it. We will need to calculate (1-t)^n each time we get a new n value (but we can keep the array, so if the next curve have same n value, we also reuse this (and when done right, even the binomial)).

However a small loop is still needed to calculate the sum since ArraySum() isn’t polymorphic. Currently there is also a little bit of multiplication in the loop, but I’m working on removing that too.

The major downside with this approach is that if you use high resolutions the arrays become rather large (and they are using float to boot) so memory usage rise quite a bit. (Some temporary arrays are also needed, so it quickly becomes a few KB.)


Bezier v2.4.0

P.S. I should really have considered reading a tutorial about LaTeX before trying to add all that math which needs to be written in LaTeX…

Feb 09 2011

How to implement OO programs on the standard NXT firmware

Category: Lego,Mindstorms,NXC,SoftwareSpiller @ 23:39

OOP is not at this time supported in NXC. Even though the memory management in the standard firmware might be limiting it is still possible to achieve a simple OOP implementation fairly easily. It will however be a bit inefficient memory wise and you will have the standard issues with tread-safety.

However actually testing my hypothesis in the large scale turned out to be cumbersome and thus I didn’t… If you notice anything that wouldn’t work out, something I forgot to consider or anything, please leave a comment : )

Object representation

The base for every object is a data structure containing all non-static variables. Lets consider a class like this:

class monster{
    static const unsigned char LEVEL_EASY = 0;
    static const unsigned char LEVEL_MEDIUM = 1;
    static const unsigned char LEVEL_HARD = 2;

    unsigned char level;
    unsigned int hp;
    unsigned int max_hp;
    unsigned char attack[];

      //The destructor could reset large arrays
      ArrayInit( attack, 0, 0 );

    unsigned char difficulty() const{ return level; }
    float life() const{ return (float)hp/max_hp; }

    void receive_damage( unsigned char power, unsigned char attacker_level );
    void attack( monster opponent, unsigned char attack_id );

It would end up to something like this in NXC code:

const byte monster::LEVEL_EASY = 0;  //Yes, I know you can't do it like this in NXC...
const byte monster::LEVEL_MEDIUM = 1;
const byte monster::LEVEL_HARD = 2;
struct monster{
  byte level;
  unsigned int hp;
  unsigned int max_hp;
  byte attack[];
monster monster_paratemp;

The static variables are in global scope and the struct contains the other variables, nothing special here. Then an instantiation of the object is created, this will serve as a temporary object for function calls explained below.


At the NBC level, all variables are global and every reference to a variable is static and can’t be changed. Dynamic memory (other than arrays which content is dynamic) and pointers aren’t supported. This means that functions operate on a fixed set of variables and that all parameters must be passed by copying. If you want to pass a parameter by reference it is actually passed by copying and then copied back once the function returns.

This is problematic since in order to share the same function for multiple instances of the object we will need to tell the function which object to act upon, in short we need to pass the object by either reference or constant reference.; //The way we want to call it in code
life( object ); //The way it would be implemented behind the scenes

NXC currently makes a copy for each function however this isn’t optimal if we have many functions in the object. Even if we have a lot of free memory and doesn’t care about wasting some, it will have a rather negative effect on the file size of the .rxe file due to the way variables are declared.

To avoid making this effect to large, I suggest sharing a single object for all functions. It could also optimize repeated function calls in some cases as you could leave the copy in the function copy instead of copying it back and forth. (It will cause longer delays if you need to protect it with a mutex though.) This is the reason for the monster_paratemp variable in the example.

(It would be nice to see this form for optimization for general functions, though it would be a lot more complicated since you need to take treading and sub-functions into consideration…)

If there is only one instance of the class, then the functions should of course operate on the object directly instead of using a copy. Inline functions should do the same. And if  the class only contains inline or static functions, a copy shouldn’t be needed at all.


Here is an example where the monster class is inherited:

class magic_monster: public monster{
    unsigned int sp;
    unsigned int max_sp;

    magic_monster(): monster(){
      ArrayBuild( attack, attack, 45, 30 );
      ArrayInit( attack, 0, 0 );
    float magic_power() const{ return (float)sp/max_sp; }
    void attack( monster opponent, unsigned char attack_id );	//The attack might be magic

The NXC struct:

struct magic_monster{
  monster parent_monster;
  unsigned int sp;
  unsigned int max_sp;
magic_monster magic_monster_paratemp;

Instead of copying the monster struct and then add the extra variables, the struct is included as a sub-element. The reason is that this makes it a lot easier to call the functions defined in the inherited class. To call those, you simply copy parent_monster into monster_paratemp, call the function and then copy monster_paratemp back into parent_monster if necessary.

Multi-inheritance should also be easily possible this way, but I have never used it before so I don’t know if there are any special considerations to take…

Virtual functions

Unfortunately there is no way to properly implement virtual functions at runtime. It must be done completely at compile-time to work. (Well, fairly simple virtual functions could work, but the implementation would be inefficient and nowhere close to being sufficient.)

However because pointers aren’t supported, the cases where you need to save it in a parent class (and therefore having to rely on runtime detection) are rather few. There are only two cases I can think of. First one being function calls which accepts an object. And second one being the use of virtual functions directly in the base class, it would always use its own implementation (if available).

I think that we should depend on compile-time virtual functions, accept the changed functionality in the cases where it can’t be detected, but try to warn the programmer about issue. (Perhaps a custom keyword could be added to turn off the warning to show to compiler that you understand the issue?)

Functions accepting an object of the same class

One issue that appeared of using a single copy for the object parameter is apparent in the following example:

void monster::attack( monster opponent, unsigned char attack_id ){
  opponent.receive_damage( attack[attack_id], level );
monster dragon, ogre;
dragon.attack( ogre, 2 );

If we try to add how the temporary object is used together with the function calls it looks like this:

monster_paratemp = dragon;
attack( ogre, 2 );
  monster_paratemp = ogre;
  receive_damage( monster_paratemp.attack[2], monster_paratemp.level );
  ogre = monster_paratemp;
dragon = monster_paratemp;

Notice how dragon now is equal to ogre because it hijacked the temporary variable. Also note how the parameters send to the receive_damage function are actually holding ogre‘s values. (This might not always be the case though, depending on which order the parameters are copied.)

In order to make this work, we would need to copy the currently active object into another temporary object, move ogre into monster_paratemp like normal, call the function and then revert the whole process.

Hells begins once we start seeing stuff like this:

void monster::chained_attack( monster chained_monster, monster opponent, byte attack_id ){
  chained_monster.attack( opponent, attack_id );


It seems to me that OOP could very well work out just fine on the NXT using the standard firmware. It might not be exactly like C++, but considering the platform I would say it is quite satisfying.
In my opinion OO is a great way to program and I would love to see it in NXC. (I do realize that it will be quite some work to get it to parse C++ properly, but a man must dream. (Or make his own compiler))

I have only programmed OO for half a year though, so I’m sure  there are a lot of features that I don’t know and therefore haven’t considered how to (if possible) to implement.
And again, if you spot any errors, please leave a comment.

Jan 30 2011

NXC word-wrapping v0.5

Category: Lego,Mindstorms,NXC,Programs,SoftwareSpiller @ 23:25

Not really having done anything on my NXT-RPG game in a half year, I have now finally fixed some bugs in the word-wrapping code.

Word wrapping.nxc – version 0.5

Summery: Draws a text string on the NXT display, but will continue on the next line if the string is too long. This is done without breaking a word into two halves, it only breaks the string at spaces, preventing awkward looking text. Tabs are also handled correctly.
A custom made ricfont with variable width is used. The font is 8 pixels high (7px above the baseline, 1px beneath) and have a default width of 5 pixels.

Requirements: Enhanced firmware 1.28 (because of FontTextOut()) and the file “ASCII_7px.ric” present on the NXT.

Changes in this version

I had left a rather serious bug in the previous version which caused it to frequently break the string at wrong places.

The most significant change is the speed. I have optimized it in a few places which results the example string (in the screenshot) now only takes 76 msec to compile and render where it preciously took 109 msec. An improvement of about ~30% and the method to archive this was nothing special. I manually converted to if and one for statements at crucial places to NBC code instead of letting the NXC compiler do it. It is not an assembler optimization, I just do want the compiler should have done but fails to do properly (in terms of efficiency).
30% slower because of bad compilation… -__-

Update – v0.5.1

A few extra optimizations…

Speedtest: 62 ms


NXC source v0.5.1

Font file