Serial Error When Loading Code. Please Help!


I am trying to load the gcode interpreter onto my arduino Uno but I keep getting this error message "GCode_Interpreterdc:15: error: 'Serial' was not declared in this scope" I got the code from here I am running Arduiino Ver 0022 Windows 7 x64. I'm fairly new with programming in arduino so please be very specific when explaining how to fix this please. Thanks

If you look at the error message, you will see that it occurs long before any attempt to load code, so your topic title is wrong.

"GCode_Interpreterdc:15: error: 'Serial' was not declared in this scope"

Well, you need to show us the code that caused that message (that you did NOT cut and paste properly), and exactly the message that results.

Your board type would be useful information, too.

I'm fairly new with programming in arduino so please be very specific when explaining how to fix this please.

Let's see if I can make this simple enough. Post your code. Is that simple enough?

I am trying to load the gcode interpreter onto my arduino Uno

I got the code from here

Arduino Uno is my board type as stated, and the code can be found at the link provided above and stated previously. The code is unaltered.

Read. Is that simple enough?

If you dont want to dl the code i have most of it shown below but it is fairly long and has multiple sheets, It wont let me post it all.

Here are the exact error messages that I get.

GCode_Interpreterdc.cpp: In function 'void setup()':
GCode_Interpreterdc:15: error: 'Serial' was not declared in this scope
GCode_Interpreterdc.cpp: In function 'void loop()':
GCode_Interpreterdc:32: error: 'Serial' was not declared in this scope
GCode_Interpreterdc.cpp: In function 'void process_string(char*, int)':
process_string:53: error: 'Serial' was not declared in this scope
process_string:299: error: 'Serial' was not declared in this scope
process_string:319: error: 'Serial' was not declared in this scope
process_string:325: error: 'Serial' was not declared in this scope
// Arduino G-code Interpreter
// v1.0 Carlos guilarte y diego colonnello...
// Modificado para manejar tres ejes en un cnc chimbo... jejeje

#include <HardwareSerial.h>

//our command string
#define COMMAND_SIZE 128
char palabra[COMMAND_SIZE];
byte serial_count;
int no_data = 0;

void setup()
	//Do startup stuff here
	//other initialization.

void loop()
	char c;
	//keep it hot!

	//read in characters if we got them.
	if (Serial.available() > 0)
		c =;
		no_data = 0;
		//newlines are ends of commands.
		if (c != '\n')
			palabra[serial_count] = c;
	//mark no data.

	//if theres a pause or we got a real command, do it
	if (serial_count && (c == '\n' || no_data > 100))
		//process our command!
		process_string(palabra, serial_count);

		//clear command.

	//no data?  turn off steppers
	if (no_data > 1000)
//init our variables
long max_delta;
long x_counter;
long y_counter;
long z_counter;
bool x_can_step;
bool y_can_step;
bool z_can_step;
int milli_delay;

void init_steppers()
	//turn them off to start.
	//init our points.
	current_units.x = 0.0;
	current_units.y = 0.0;
	current_units.z = 0.0;
	target_units.x = 0.0;
	target_units.y = 0.0;
	target_units.z = 0.0;
	pinMode(X_DIR_PIN, OUTPUT);
	pinMode(X_MIN_PIN, INPUT);
	pinMode(X_MAX_PIN, INPUT);
	pinMode(Y_DIR_PIN, OUTPUT);
	pinMode(Y_MIN_PIN, INPUT);
	pinMode(Y_MAX_PIN, INPUT);
	pinMode(Z_DIR_PIN, OUTPUT);
	pinMode(Z_MIN_PIN, INPUT);
	pinMode(Z_MAX_PIN, INPUT);
	//figure our stuff.

void dda_move(long micro_delay)
	//enable our steppers
	digitalWrite(X_ENABLE_PIN, HIGH);
	digitalWrite(Y_ENABLE_PIN, HIGH);
	digitalWrite(Z_ENABLE_PIN, HIGH);
	//figure out our deltas
	max_delta = max(delta_steps.x, delta_steps.y);
	max_delta = max(delta_steps.z, max_delta);

	//init stuff.
	long x_counter = -max_delta/2;
	long y_counter = -max_delta/2;
	long z_counter = -max_delta/2;
	//our step flags
	bool x_can_step = 0;
	bool y_can_step = 0;
	bool z_can_step = 0;
	if (micro_delay >= 16383)
		milli_delay = micro_delay / 1000;
		milli_delay = 0;

	//do our DDA line!
		x_can_step = can_step(X_MIN_PIN, X_MAX_PIN, current_steps.x, target_steps.x, x_direction);
		y_can_step = can_step(Y_MIN_PIN, Y_MAX_PIN, current_steps.y, target_steps.y, y_direction);
		z_can_step = can_step(Z_MIN_PIN, Z_MAX_PIN, current_steps.z, target_steps.z, z_direction);

		if (x_can_step)
			x_counter += delta_steps.x;
			if (x_counter > 0)
				do_step(X_STEP_PIN, X_DIR_PIN, x_direction);
				x_counter -= max_delta;
				if (x_direction)

		if (y_can_step)
			y_counter += delta_steps.y;
			if (y_counter > 0)
				do_step(Y_STEP_PIN, Y_DIR_PIN, y_direction);
				y_counter -= max_delta;

				if (y_direction)
		if (z_can_step)
			z_counter += delta_steps.z;
			if (z_counter > 0)
				do_step(Z_STEP_PIN, Z_DIR_PIN, z_direction);
				z_counter -= max_delta;
				if (z_direction)
		//wait for next step.
		if (milli_delay > 0)
	while (x_can_step || y_can_step || z_can_step);
	//set our points to be the same
	current_units.x = target_units.x;
	current_units.y = target_units.y;
	current_units.z = target_units.z;

bool can_step(byte min_pin, byte max_pin, long current, long target, byte direction)
	//stop us if we're on target
	if (target == current)
		return false;
	//stop us if we're at home and still going 
	else if (read_switch(min_pin) && !direction)
		return false;
	//stop us if we're at max and still going
	else if (read_switch(max_pin) && direction)
		return false;

	//default to being able to step
	return true;

void do_step(byte pinA, byte pinB, byte dir)
        switch (dir << 2 | digitalRead(pinA) << 1 | digitalRead(pinB)) {
            case 0: /* 0 00 -> 10 */
            case 5: /* 1 01 -> 11 */
                digitalWrite(pinA, HIGH);
            case 1: /* 0 01 -> 00 */
            case 7: /* 1 11 -> 10 */
                digitalWrite(pinB, LOW);
            case 2: /* 0 10 -> 11 */
            case 4: /* 1 00 -> 01 */   
                digitalWrite(pinB, HIGH);
            case 3: /* 0 11 -> 01 */
            case 6: /* 1 10 -> 00 */
                digitalWrite(pinA, LOW);

bool read_switch(byte pin)
	//dual read as crude debounce
		return !digitalRead(pin) && !digitalRead(pin);
		return digitalRead(pin) && digitalRead(pin);

long to_steps(float steps_per_unit, float units)
	return steps_per_unit * units;

void set_target(float x, float y, float z)
	target_units.x = x;
	target_units.y = y;
	target_units.z = z;

void set_position(float x, float y, float z)
	current_units.x = x;
	current_units.y = y;
	current_units.z = z;

void calculate_deltas()
	//figure our deltas.
	delta_units.x = abs(target_units.x - current_units.x);
	delta_units.y = abs(target_units.y - current_units.y);
	delta_units.z = abs(target_units.z - current_units.z);
	//set our steps current, target, and delta
	current_steps.x = to_steps(x_units, current_units.x);
	current_steps.y = to_steps(y_units, current_units.y);
	current_steps.z = to_steps(z_units, current_units.z);

	target_steps.x = to_steps(x_units, target_units.x);
	target_steps.y = to_steps(y_units, target_units.y);
	target_steps.z = to_steps(z_units, target_units.z);

	delta_steps.x = abs(target_steps.x - current_steps.x);
	delta_steps.y = abs(target_steps.y - current_steps.y);
	delta_steps.z = abs(target_steps.z - current_steps.z);
	//what is our direction
	x_direction = (target_units.x >= current_units.x);
	y_direction = (target_units.y >= current_units.y);
	z_direction = (target_units.z >= current_units.z);

	//set our direction pins as well
	digitalWrite(X_DIR_PIN, x_direction);
	digitalWrite(Y_DIR_PIN, y_direction);
	digitalWrite(Z_DIR_PIN, z_direction);

long calculate_feedrate_delay(float feedrate)
	//how long is our line length?
	float distance = sqrt(delta_units.x*delta_units.x + delta_units.y*delta_units.y + delta_units.z*delta_units.z);
	long master_steps = 0;
	//find the dominant axis.
	if (delta_steps.x > delta_steps.y)
		if (delta_steps.z > delta_steps.x)
			master_steps = delta_steps.z;
			master_steps = delta_steps.x;
		if (delta_steps.z > delta_steps.y)
			master_steps = delta_steps.z;
			master_steps = delta_steps.y;

	//calculate delay between steps in microseconds.  this is sort of tricky, but not too bad.
	//the formula has been condensed to save space.  here it is in english:
	// distance / feedrate * 60000000.0 = move duration in microseconds
	// move duration / master_steps = time between steps for master axis.

	return ((distance * 600000000.0) / feedrate) / master_steps;	

long getMaxSpeed()
	if (delta_steps.z > 0)
		return calculate_feedrate_delay(FAST_Z_FEEDRATE);
		return calculate_feedrate_delay(FAST_XY_FEEDRATE);

void disable_steppers()
	//enable our steppers
	digitalWrite(X_ENABLE_PIN, LOW);
	digitalWrite(Y_ENABLE_PIN, LOW);
	digitalWrite(Z_ENABLE_PIN, LOW);

I am guessing that I have to add some libraries or do something with the applet file that is included in the download but I'm not sure.

I downloaded the code, and extracted the folder to my sketchbook (on Win7). When I compile it (for a Duemilanove), this is the "error" I get:

Binary sketch size: 12250 bytes (of a 30720 byte maximum)

What OS are you using? Where did you unzip the file?

I unzipped it to a location on my desktop and I am running window 7 x64.

I unzipped it to a location on my desktop

Is your desktop your sketchbook location?

This is the location where I unzipped the files. The Arduino program is located in my program files dir. I'm not entirely sure what you are asking.


Use File + Preferences…

The first field on the posted panel shows where the Arduino IDE loos for sketches. Put the GCode_Interpreterdc folder in the sketch folder.