Category Archives: Glowing Marquee

Please follow the protocol

As you have seen, the hardware part of the Glowing Marque prototype, build from an old scanner, is functioning. The last step I did is the programming of a protocol to communicate with the Arduino by the Insek Proxy Internet to Serial Proxy app.

The first issue is that I want to send a string of hexadecimal values and then convert it to real hex in the Arduino for displaying this data. The second problem to solve is to send a longer string that the serial buffer and the buffer of the Messenger library.

There is the piece of code I did for the protocol:

#include <Messenger.h>

#define DATASIZE 70
unsigned char data[DATASIZE+1]; // + 1 space for the closing \0 char.

Messenger message = Messenger();

/*
	2010-11-03: Append data.
	Args: source, target, position to start from zero to DATASIZE.
*/
void appendData(char * s, unsigned char * dp, int pos) {

	// Create and reset the pointer to display data.
	dp = dp + pos; // Move to starting position.

	char monkey[3];
	long chimp;
	for (int i=0; i<strlen(s); i=i+2) {
		monkey[0] = s[i];
		monkey[1] = s[i+1];
		monkey[2] = '\0';

		// Convert the monkey string to long int.
		chimp = strtol(monkey, NULL, 16);

		// Append chimp to displayData;
		*dp++ = (unsigned char)chimp; // Cast the long to an unsigned char.

		//Serial.print(chimp, BYTE);
	}

	*dp = '\0'; // Close the string.

}

void messageCompleted() {

	//Serial.println("Message completed.");

	while ( message.available() ) {
		//Serial.print(".");
		if ( message.checkString("data") ) { // Show text.

			if( message.checkString("flush")) {
				flushData();
				Serial.println("\nData flushed.");

			} else {
				// 1st get position
				int pos = message.readInt();

				// 2nd get length
				int length = message.readInt();

				// 3rd get data
				char tmp_data[128];

				// Move data to the temps string.
				message.copyString(tmp_data, 128);

				// Check if data length
				// Find the first position of the \0.
				int data_length = strlen(tmp_data);

				// Data are always 2 char to build one hex value.
				if( length*2 == data_length) {

						if( pos + data_length - 1 > DATASIZE) {
							Serial.println("\nData overflow.");
						} else {

						//Serial.println(strlen(tmp_data));

						//Serial.println(tmp_data);

						appendData(tmp_data, &data[0], pos);

						Serial.println("");
						Serial.println("Data:");

						for(int a=0; a < DATASIZE; a++) {
							if( data[a] == '\0' ) {
								Serial.print("-");
							} else {
								Serial.print(data[a], BYTE);
							}
						}
					}
				} else {
					Serial.println("Bad checksum.");
				}

			} // End append data.

		} else {
			message.readChar(); // Flush the rest of the message buffer.
		}

	}
}

void flushData() {
	for(int i=0; i<DATASIZE+1; i++) {
		data[i] = '\0';
	}
}

void setup() {

	Serial.begin(9600);
	message.attach(messageCompleted);

}
void loop() {
	while ( Serial.available( ) ) message.process(Serial.read( ) );
}

The protocol is relatively simple, there is the structure:

header position length data
  • The ‘header’ is the command, what the Arduino have to do with that string. I use ‘data’ as the header to send data.
  • The ‘position’ is the position in the array the data will be copied.
  • The ‘length’ is the quantity of numbers to send. It’s used to check if the Arduino received the right length of data and to verify if the data will not overflow the data array.

There is an example to send a first packet of data:

data 0 4 ff00ff00

Here I send four numbers build with two hexadecimal characters (from 00 to ff). They will be placed at the beginning of the array.

If I want to append ‘ddee33′ to this value in the array, I shall use this call:

data 4 3 ddee

So this way I can send many blocks of data and built an array longer than the serial buffer.

After that I can implement other calls to work with this data. A sample call can be (not built in this sample code): show data. I did that in code of the Glowing Marquee project, so I send packets of hex data, and ask the Arduino to show it. I will be back with more on this project in my next posts.

Stepper motor controller circuit and code

I build a step motor controller based on the schematics found on the Arduino Web site. First I try the 2 pins one for bipolar stepper motor. I wont be able to make it work, even less with the library available on the site. Maybe I’m dumb and I really dont understand something, but this circuit keeps both coils active at the same time.

So I tried the second circuit, the 4 pins one. With the same library I wasn’t able to make it work either. So I create a piece of code of my own and I finally managed to make the motor run correctly.

After that, I realize that I can merge the to circuits to possibly create a PWM abled bipolar motor controller with the L297D. A somewhat bizzare idea, but I think it’s possible if we can program the Arduino to send 4 synced PWM signals. I’ll come back later (maybe never) with this thought. After some research I found that the TI DRV8811 and the Allegro A3977 are much more appropriate chips to do microstepping.

But for now, there is my circuit. It’s advantage is that it can release the coils. Download the schematics (Fritzing format).

The two PNP transistors are connected like the circuit proposed on the Arduino Web site. Plus, I use the enable pins. So my circuit needs four pins, and I don’t found a way to use less.

Parts list

  • 1 x Arduino
  • 1 x L293 Quadruple Half H-Bridge
  • 2 x 1K Ohm Resistors
  • 2 x 10K Ohm Resistors
  • 2 x 2N2222 NPN Transistors
  • 1 x Bipolar Step Motor

There is the sequence to make the motor turn one direction, invert it to make it turn the other.

Control sequence
CTRL A EN A CTRL B EN B
0 0 1 1
1 1 0 0
0 0 0 1
0 1 0 0

There is my code to control the stepper motor. Like you see in my code I use direct port command to take less processor time. And I create a function called in the main loop for each steps. This way the code can do something else when the motor is running.

/*
	Stepper Motor Controller
	by Kevin Filteau 2010-05-29
	Playwithmyled.com
*/

// Motor controller pins.
#define pinMotorCtrlA 4
#define pinMotorCtrlB 7
#define pinMotorEnA 5
#define pinMotorEnB 6

// Direction constants.
#define GOLEFT 0
#define GORIGHT 1

// Motor states and position.
boolean motorRunning = false;
int motorMax = 700;
int motorPos = 0;

/**********************************************
	MOTOR
**********************************************/

// Setup the motor.
void motorSetup() {
  pinMode(pinMotorCtrlA, OUTPUT);
  pinMode(pinMotorCtrlB, OUTPUT);
  pinMode(pinMotorEnA, OUTPUT);
  pinMode(pinMotorEnB, OUTPUT);
  // Everybody to LOW.
  digitalWrite(pinMotorCtrlA, LOW);
  digitalWrite(pinMotorCtrlB, LOW);
  digitalWrite(pinMotorEnA, LOW);
  digitalWrite(pinMotorEnB, LOW);
}

// Free the motor.
void motorFree() {
  digitalWrite(pinMotorEnA, LOW);
  digitalWrite(pinMotorEnB, LOW);
}

// Make the motor spin one step in the direction specified.
// Pins    7654 ----
// Binary 0000 0000
void motorSpin(boolean dir) {

	static int pos = 0; // Starting step pos.

	int stepsSeq[] = {0xC0,0x30,0x40,0x20}; // Registry value.
	int st;

  // Timing
  static unsigned long previousMillis;
  long interval = 3;

	if(millis() - previousMillis > interval) {
		previousMillis = millis();

		st = stepsSeq[pos];
		if( dir == GOLEFT ) {
			pos++; if(pos>3) pos=0;
			motorPos++;
		} else {
			pos--; if(pos<0) pos=3;
			motorPos--;
		}
		PORTD &= 0xF;
		PORTD |= st;
	}

}

/**********************************************
	MAIN FUNCTIONS.
**********************************************/
void setup() {
	motorSetup();

}

void loop() {
	motorSpin(GOLEFT);
	// motorSpin(GORIGHT);
}

And to close this post. Some pictures of the prototype, the finalized circuit board (useful for the pinout) and a video taken while testing the circuit.

All parts are assembled and it’s ready to be programmed

All the mechanicals parts and the control boards are now assembled and wired up together. All functions have been tested separately. Now come the time to do some programming. But before I will show you what I’ve already done in my next posts.

Because some pins of the Arduino have a special function, like interrupt, the connections on the proto will be useful to connect thinks to the right pins when I will start programming. I’ll probably use my previous (modified yesterday) multitasking script to be able to control all things at virtually the same time.

Glowing Marquee prototype assembled and wired up

Put your image up in the air

My goal is to use an image and output it to the marquee. I really don’t want to build matrix characters one by one. I mostly want to create anti-aliased characters or graphics. How? By making the leds blink more or less time. That will make the glow-in-the-dark stripe illuminate more when the led lit more longer. So, for now, I code a test program in PHP, a familiar language for me, to read the image and output the result data I need to give to the Arduino microcontroler.

There is the idea of code :

<?php
/*
	This script display a black and white graphic
	constructed in a html table
	based on the readed jpg image.

*/
// Declare the image file to read.
$file = "test.jpg";
// Read the jpg file and create an image in memory.
$image = imagecreatefromjpeg($file);
// Get the size of the image.
$width = imagesx($image);
$height = imagesy($image);

print "<table><tr>";
// Read one row of the image at a time.
for ($y=0; $y < $height; $y++) {
	// Read one column of the image at a time.
	for ($x=0; $x < $width; $x++) {
		// Get the index of a pixel.
		$pix_index = imagecolorat($image,$x,$y);
		// Get the decimal RGB color of this pixel.
		$A = imagecolorsforindex($image,$pix_index);
		// Convert this color to gray scale.
		$col = ($A['red'] + $A['green'] + $A['blue'] ) / 3;
		// Convert this color to hex.
		$col = dechex($col);
		
		print "<td style=\"width:10px;height:10px;background-color:#{$col}{$col}{$col}\">&nbsp;</td>";
	}
	print"</tr><tr>";
}
print "</tr></table>";
?>

Glowing marquee

Inspired by the Record Player Display projet, I start doing one of my own. A glowing stripe marquee, using an old scanner ripped off. The objective is to learn how stepper motors works, optic switch and resume my experience with logic chips like the 74HC595 shift register. Globally, everything is relatively simple and it’s just a matter of seeking the right information over the internet, and a bit of thinking. The current video is presenting my first test, without the mechanical part. Just the leds and the glowing vinyl stripe moved manually. The last week, I solder the leds and the shift register on an permanent circuit board. It will be fixed on the scanner soon. The optic limit switch works and it will be used to know the reset position of the scanner. The next step will be to assemble the circuit board for the step motor driver. I use a L293D. So happy viewing. You will understand why I certainly make some mistake in my writing.

Step one, step two, motor on!

When I was young, I had two unipolar (don’t know that detail since this week) stepper motors. My pleasure was to connect them together and when I spinned one, the other performed nearly the same rotation. It was a great pleasure to play with. But I finally make one (bipolar) really work today. Yeah! I work hard to understand the motor I got, the MITSUMI M42SP-4. When I look over the Net to find some specs, it’s never what my motor look like. So I guest a four wires bipolar, and I tried it on 5v, safely. Something append, but not correctly. Any bad connections with the L293D? I think not. I found, after a while, that my problem was the Arduino stepper library. I don’t know if I was doing something wrong but it’s look like the stepper function always stimulate both coils at the same time. So I coded an ugly function to recreate the four steps needed, and Bingo! This will make my projet go further.