The weapons: CCS, Launchpad, Cookies (you may choose your favourite ones)

The reason: To familiarize yourself with the coding environment, or just for the heck of it.

The library:

#ifndef GRAND_H_
#define GRAND_H_
 
static unsigned long int rand_next = 1;
 
int gRand( void ) {
	rand_next = rand_next * 1103515245 + 12345;
	return (unsigned int)(rand_next/65536) % 32768;
}
 
void gSRand( unsigned int seed ) {
	rand_next = seed;
}
 
#define gRandom()		((gRand() & 0x7fff) / ((float)0x7fff)) 	// random in the range [0, 1]
#define gCRandom()		(2.0 * (gRandom() - 0.5)) 			// random in the range [-1, 1]
#define gMax(x,y)		(x > y ? x : y)				// minimum
#define gMin(x,y)		(x < y ? x : y)				// maximum
 
#endif /*GRAND_H_*/

That’s our random library, it’s grand.h

The “g” prefix is one I often use privately, it’s simply the first letter of my name. However because there may be other routines in the future with a similar naming convention, having “g” prefixed is not a bad idea; without having to fall into namespace gibberish.

The PRNG is an old standard. No need to discuss it.

You may recognize those macros, yes! They’re from Quake3! — Although we aren’t using them I left them there for future reference on how to obtain usable value ranges from the PRNG. There’s a lot to be said about floating point values and whatnot, But I’m going to restrain myself in this case.

Now to the main code:

// MSP430 Launchpad - Blink onboard LEDs using random delays.
//	GuShH - info@gushh.net
 
#include  "msp430x20x2.h"	// Include the necessary header for our target MCU
#include  "grand.h"		// Include our simplistic prng lib.
 
void delay_ms(unsigned int ms ) { // This function simply performs a software delay, hard from efficient but it's practical in this case.
	unsigned int i;
	for (i = 0; i < = ms; i++) { // Make sure your < and = has no space in between (the syntax parser seems to be messing things up)
		__delay_cycles(500); // This should be dependent on clock speed... but what the hell, even the loop itself should be taken into account...
	}
}
 
void set_and_wait( int led ) {
	P1OUT = led;			// Set the bits
	delay_ms( gRand() * 0.01 );	// Delay a "random" amount of time
}
 
void main(void) {
 
	WDTCTL = WDTPW + WDTHOLD; // Hold the WDT (WatchDog Timer)
	P1DIR |= BIT0|BIT6;       // Enable the appropriate output
 
	while(1) {
		set_and_wait( BIT0 );	// Set BIT0, that's our first LED.
		set_and_wait( BIT6 );	// Set BIT6, The other LED.
	}
 
}

No external hardware is required, just make sure both P1.0 and P1.6 jumpers are set.

As you can see we’re simply toggling the LEDs with a random delay, the delay_ms(); function was taken from here.

Like I said there are quite a few topics to explain, however I decided to keep this one as simple as possible (Alright, I’m in a rush!)

So… Compile, run and enjoy!

Once I get the time I’ll put together some utilitarian code libraries and lengthier explanations, promise.

For those interested, you may download the entire project directory from here: Random Software Delays. ]]> http://gushh.net/blog/random-software-delays/feed/ 0 http://gushh.net/blog/structuring-libraries-basic-design-tips/ http://gushh.net/blog/structuring-libraries-basic-design-tips/#comments Fri, 28 Aug 2009 23:20:56 +0000 GuShH http://gushh.net/blog/?p=227 One of the most important things a programmer has to know and learn is proper code design, structuring of the code, etc. This may not be imperative for you if you’re just starting out, but sooner or later you’ll be able to spot the patterns and realize that your current way of doing things is not optimal but rather cumbersome. This is when you start to separate things into modules and you begin to design your code with more meaning and purpose.

By breaking your code into modules or “classes” you can have a finer granularity of the code itself, you can encapsulate the base code and work on top of it, you can also reuse the code in other projects if you have a good design. An example would be a log library (for logging useful debugging information onto text files) with proper design and care you’ll be able to use the same library in almost all of your projects with little to no modification at all.

The main points you should never forget about are:

• Instancing
  • This is when you create an “object” – And as you create it, you should also be able to destroy it. (Constructors / Destructors in OOP). An object factory may be implemented (this would be another class) to handle the instances. In CPP you may use smart pointers, but we’re talking about PB in this case.
• Members
  • In our case a main structure is used as the “members” (Again, in reference to OOP) – This structure is instantiated by the constructor or “create” function. Don’t forget that anything you allocate you should also be able to deallocate. It doesn’t matter if the language or OS handles it underneath; it’s bad coding practice to avoid such trivial – but important – code.
• Methods
  • They give you functionality, in PB there are no methods but a similar concept applies: you have functions or routines that you create specifically for the library itself. Some may be of the Get / Set type (which either get or set a variable) Or other methods such as converters, helpers, accesibility calls, etc.

All together they make a class; in our case a library.

Let’s write one and follow by example!

Imagine you needed to encapsulate the random functions to provide extra functionality, then all you need to do is first define a structure (if you’re going to have members; for instance do you want the library to “remember” the previous and current numbers?, if so you would need a structure!)

;- Library Structure
Structure RANDOM
	LastNumber.i
	PreviousNumber.i
	Seed.i
EndStructure

Alright, now we need to write our constructor and destructor functions! This will create and destroy the instances.

;- Library Instancing
Procedure.i RandomCreate( Seed.i = 0 )
 
	Define.RANDOM *this = AllocateMemory( SizeOf( RANDOM ) )
 
	If *this
 
		If Not Seed
			Seed = ElapsedMilliseconds()
		EndIf
 
		With *this
			 \LastNumber 		= 0
			 \PreviousNumber 	= 0
			 \Seed 			= Seed
		EndWith
 
		RandomSeed( *this\Seed )
		ProcedureReturn *this
 
	EndIf
 
EndProcedure
 
Procedure.i RandomDestroy( *this.RANDOM )
 
	If *this
 
		FreeMemory( *this )
		*this = #Null
		ProcedureReturn *this
 
	EndIf
 
EndProcedure

That’s not too bad, first we allocate an instance and then we populate the member variables just to return the pointer of our new “object”. The destructor simply frees any allocated memory and clears out the pointer itself.

Now we need to define our library functions, in this case we only need one so we may generate a random number and keep track of the previous and current numbers.

;- Library functions
Procedure.i RandomGetInteger( *this.RANDOM, min.i, max.i )
 
	If *this
 
		*this\PreviousNumber 	= *this\LastNumber
		*this\LastNumber 	= ( min + Random( max-min ) )
		ProcedureReturn *this\LastNumber
 
	EndIf
 
EndProcedure

That’s ok, but we can still add functionality. For instance, we need a way to access the structure fields (or “members”) without having to cast pointers, etc. We can do this by implementing a few Get/Set routines. In this case we only need to get the previous and current numbers, so…

;- Helper functions
Procedure.i RandomGetLast( *this.RANDOM )
 
	If *this
		ProcedureReturn *this\LastNumber
	EndIf
 
EndProcedure
 
Procedure.i RandomGetPrevious( *this.RANDOM )
 
	If *this
		ProcedureReturn *this\PreviousNumber
	EndIf
 
EndProcedure

But wait, we can still add functionality! such as utility functions, in this case we would like to fill a given array with random numbers, so…

;- Utility functions
Procedure.i RandomFillArray( *this.RANDOM, min.i, max.i, Array DestArray.i(1) )
 
	If *this
 
		Define.i Size, i
		Size = ArraySize( DestArray(), 1 )
 
		If Size
			For i=0 To Size
				DestArray(i) = RandomGetInteger( *this, min, max )
			Next
		EndIf
 
	EndIf
 
EndProcedure

And while we’re at it, let’s fill lists as well!

Procedure.i RandomFillList( *this.RANDOM, min.i, max.i, elements.i, List DestList.i(), Clear.i=#False )
 
	If *this
 
		If Clear
			ClearList(DestList())
		EndIf
 
		Define.i i
 
		If elements
			For i=1 To elements
				If AddElement( DestList() )
					DestList() = RandomGetInteger( *this, min, max )
				EndIf
			Next
		EndIf
 
	EndIf
 
EndProcedure

If you don’t need to keep track of the current and previous numbers, you can just opt out the instancing system and modify the utility calls to work in an “instance-less” mode, however that’s up to you.

But, let’s take it for a ride first!

;- Example
Define.RANDOM *rnd = RandomCreate()
Define.i i
 
If *rnd
 
	For i=0 To 99
		Debug RandomGetInteger( *rnd, 5, 10 )
	Next
 
	Debug "--"
	Debug RandomGetLast( *rnd )
	Debug RandomGetPrevious( *rnd )
	Debug "--"
 
	Dim TestArray.i(9)
	RandomFillArray( *rnd, 100, 200, TestArray() )
 
	For i=0 To 9
		Debug TestArray(i)
	Next
 
	Debug "--"
 
	NewList TestList.i()
	RandomFillList( *rnd, 10, 20, 5, TestList() )
 
	ForEach TestList()
		Debug TestList()
	Next
 
	RandomDestroy(*rnd)
EndIf

Ok, so we tested the instancing and most if not all of the “methods” we just created. By now you should realize how useful such systems can be if you happen to design them correctly.

This particular lib could be extended to support averaging of the numbers, median / mean, etc. You could even implement a custom PRNG and give the option to choose between yours and the built-in one!.

You may download the entire source from here. As an exercise you could implement the Get/Set methods for the Seed.

Cheers!

PS: Someone remind me to update the language file for GeShi and to fix the font (The indentation is all wrong!)

Code:
http://gushh.net/dev/?file=pb/randomizearray.pb

Examples:
http://gushh.net/dev/?file=pb/randomizearray_test.pb

Simple, right?

A need for both a debug / format (to string) and random fills for string arrays is present, but I’m not in the need of them at the moment. Do request if you need them though.

Cheers.