Gumstix User Wiki - User contributions [en]

File:LoginSuccess.png

2010-08-05T16:43:28Z

Gustavs: uploaded a new version of "File:LoginSuccess.png"

File:TerminalWindow.png

2010-08-05T16:35:51Z

Gustavs: uploaded a new version of "File:TerminalWindow.png"

File:Terminal.png

2010-08-05T16:25:33Z

Gustavs: uploaded a new version of "File:Terminal.png"

Terminal

File:Terminal.png

2010-08-05T16:21:59Z

Gustavs: uploaded a new version of "File:Terminal.png"

Terminal

Remote Debugging with GDB

2010-07-29T15:39:11Z

Gustavs:

In this tutorial we will go over how to perform a basic debugging with GDB, the GNU debugger. This environment allows us to debug machine code. You will not be able to debug java programs with this unless you find a way to compile you java file into an executable that does not require a Java Virtual Machine.
*We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learn how to set Breakpoints
:*Learn how to navigate the code in your program
:*Learn how to diagnose an error and how to fix it

*Required Items
:*Overo COM with Expansion Board
:*Mini B to Standard A Cable
:*Bootable MicroSD card
:*5V Power Supply

*Required Reading (things you should know, or tutorials that explain)
:*[[HelloWorld | HelloWorld in Python, C and C++]]
:*[[Eclipse on Gumstix for new users | Eclipse Tutorial]]
::*Although the majority of this tutorial regards Eclipse and Java programming, it contains useful information which leads to basic understanding of your Overo COM

==Installing the GDB Debugger==
Before starting this, you should have Console access to your Overo COM and should know how to program and run a basic C++ program. If you do not know how to do this, see [[HelloWorld | HelloWorld in Python, C and C++]].

To install the GDB debugger, run the following command in your command line:
opkg update
opkg install gdb
Once this has completed, you will have the GNU GDB debugger installed on your Overo COM

==Creating the Test File==
Now that we have the debugging environment

Run the following in your command line:
nano broken.cpp
Then copy and paste the code from [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp |Broken.cpp] into your shell. When you copy and paste there will be two syntax errors that you must fix at the lines:
cout << "This program is used to compute the value of the following
series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

Copying and pasting added an extra line break to these two lines, and we want to undo this by deleting one space at the beginning of each second line so it looks like this:
cout << "This program is used to compute the value of the following series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl

Now save and exit by pressing the following:
:*Ctrl + O
:*<Enter>
:*Ctrl + X

==Compile and Run broken.cpp==
Now that we have our test file (broken.cpp) ready to go, it is time to run it.

Compile the program to create an executable file (broken) by entering the following command:
g++ -g broken.cpp -o broken
Then run it:
./broken
----
Note:
Use 'g++ -g broken.cpp -o broken' to compile. If you use g++ -o, g++ --ggdb -Wall, or any other method of compilation the debugging will not follow this tutorial exactly.
----

Enter any numbers into the program for x and n. Run it a couple times, you should notice that the answer is always the same: infinity. This is obviously wrong.

Consider: x=1, n=1
(1^0)/0! + (1^1)/1!
1/1 + 1/1
2

NOT infinity

==Debugging the Program==
Now, it is time that we debugged our program.

First, you need to start the GDB environment by issuing the following command:
gdb
You should see the following command line appear:
(gdb)
Then, you need to 'tell' the debugger which file it is that we are debugging, do this by issuing the command:
(gdb) exec-file broken
Now, it is time to run our program by issuing the command:
(gdb) run

Notice that the program runs normally and again, gives us the answer inf. This is because the error we have is a computation error, and does not cause our program to crash. So, its time to set a Breakpoint in our program.

===Setting a Breakpoint===
----
Hint:
A breakpoint is a point in the program at which the debugger will stop the code from executing. Then, you can choose to 'step' through the program line by line to 'see' exactly what the CPU is doing. This way, you can effectively watch the program execute and discover where the problem is!
----
Lets set a breakpoint within the program so that we can see what is going on. Lets start by setting a breakpoint at line 43. Do this with the following command:
(gdb) b 43
----
Note:
If the program outputs: No symbol table is loaded. Use the "file" command. Then use the following command:
(gdb) file broken
This will set the file so that you can add a breakpoint without error
----
Line 43 is the following:
double seriesValue = ComputeSeriesValue(x, n);
So the program will stop executing immediately before it executes the function ComputeSeriesValue(x, n).

Now, lets run the program with our command:
(gdb) run
Let's enter the values as x=2 and n=3, with an expected output value is 5.
Here is a snapshot of what the program should output at this point:
This program is used to compute the value of the following series :
(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!
Please enter the value of x : 2
Please enter an integer value for n : 3
Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);
The program has stopped at our breakpoint, line 43.

===Stepping into a function===
Next, we are going to step into the function ComputeSeriesValue(x, n)
----
Hint:
'Stepping' through a function allows us to go line by line, and see exactly what lines of code are being executed. This way we can manually diagnose the computation problem.
----
To start stepping, issue the following command
(gdb) step
----
Hint:
A nice thing about the GDB Debugger is that it will save the last command you issued so that you don't need to type it over and over. This way you can keep stepping through the function by pressing <enter>. You do not need to retype 'step'
----
You should see the following outputted:
ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;
At this point, the program has gone to line 17, and is at the first line of the function ComputeSeriesValue, which sets the double seriesValue to 0.0.

Now, we wish to use the 'next' function until we reach the function CompueFraction(). To do this, use the following commands:
(gdb) next
18 double xpow=1;
(gdb) <enter>
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) step
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

==Using Backtrace==
*If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:
(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43
----
Note:
Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.
----
See the error?

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

change the line
int fact = 0;
to
int fact =1;
and your all set!

For another tutorial see:
http://www.cs.cmu.edu/~gilpin/tutorial/

Remote Debugging with GDB

2010-07-29T15:31:12Z

Gustavs:

In this tutorial we will go over how to perform a basic debugging with GDB, the GNU debugger. This environment allows us to debug machine code. You will not be able to debug java programs with this unless you find a way to compile you java file into an executable that does not require a Java Virtual Machine.
*We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learn how to set Breakpoints
:*Learn how to navigate the code in your program
:*Learn how to diagnose an error and how to fix it

*Required Items
:*Overo COM with Expansion Board
:*Mini B to Standard A Cable
:*Bootable MicroSD card
:*5V Power Supply

*Required Reading (things you should know, or tutorials that explain)
:*[[HelloWorld | HelloWorld in Python, C and C++]]
:*[[Eclipse on Gumstix for new users | Eclipse Tutorial]]
::*Although the majority of this tutorial regards Eclipse and Java programming, it contains useful information which leads to basic understanding of your Overo COM

==Installing the GDB Debugger==
Before starting this, you should have Console access to your Overo COM and should know how to program and run a basic C++ program. If you do not know how to do this, see [[HelloWorld | HelloWorld in Python, C and C++]].

To install the GDB debugger, run the following command in your command line:
opkg update
opkg install gdb
Once this has completed, you will have the GNU GDB debugger installed on your Overo COM

==Creating the Test File==
Now that we have the debugging environment

Run the following in your command line:
nano broken.cpp
Then copy and paste the code from [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp |Broken.cpp] into your shell. When you copy and paste there will be two syntax errors that you must fix at the lines:
cout << "This program is used to compute the value of the following
series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

Copying and pasting added an extra line break to these two lines, and we want to undo this by deleting one space at the beginning of each second line so it looks like this:
cout << "This program is used to compute the value of the following series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl

Now save and exit by pressing the following:
:*Ctrl + O
:*<Enter>
:*Ctrl + X

==Compile and Run broken.cpp==
Now that we have our test file (broken.cpp) ready to go, it is time to run it.

Compile the program to create an executable file (broken) by entering the following command:
g++ -g broken.cpp -o broken
Then run it:
./broken
----
Note:
Use 'g++ -g broken.cpp -o broken' to compile. If you use g++ -o, g++ --ggdb -Wall, or any other method of compilation the debugging will not follow this tutorial exactly.
----

Enter any numbers into the program for x and n. Run it a couple times, you should notice that the answer is always the same: infinity. This is obviously wrong.

Consider: x=1, n=1
(1^0)/0! + (1^1)/1!
1/1 + 1/1
2

NOT infinity

==Debugging the Program==
Now, it is time that we debugged our program.

First, you need to start the GDB environment by issuing the following command:
gdb
You should see the following command line appear:
(gdb)
Then, you need to 'tell' the debugger which file it is that we are debugging, do this by issuing the command:
(gdb) exec-file broken
Now, it is time to run our program by issuing the command:
(gdb) run

Notice that the program runs normally and again, gives us the answer inf. This is because the error we have is a computation error, and does not cause our program to crash. So, its time to set a Breakpoint in our program.

===Setting a Breakpoint===
----
Hint:
A breakpoint is a point in the program at which the debugger will stop the code from executing. Then, you can choose to 'step' through the program line by line to 'see' exactly what the CPU is doing. This way, you can effectively watch the program execute and discover where the problem is!
----
Lets set a breakpoint within the program so that we can see what is going on. Lets start by setting a breakpoint at line 43. Do this with the following command:
(gdb) b 43
----
Hint:
If the program outputs: No symbol table is loaded. Use the "file" command. Then use the following command:
(gdb) file broken
This will set the file so that you can add a breakpoint without error
----
Line 43 is the following:
double seriesValue = ComputeSeriesValue(x, n);
So the program will stop executing immediately before it executes the function ComputeSeriesValue(x, n).

Now, lets run the program with our command:
(gdb) run
Let's enter the values as x=2 and n=3, with an expected output value is 5.
Here is a snapshot of what the program should output at this point:
This program is used to compute the value of the following series :
(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!
Please enter the value of x : 2
Please enter an integer value for n : 3
Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);
The program has stopped at our breakpoint, line 43.

===Stepping into a function===
Next, we are going to step into the function ComputeSeriesValue(x, n)
----
Hint:
'Stepping' through a function allows us to go line by line, and see exactly what lines of code are being executed. This way we can manually diagnose the computation problem.
----
To start stepping, issue the following command
(gdb) step
----
Hint:
A nice thing about the GDB Debugger is that it will save the last command you issued so that you don't need to type it over and over. This way you can keep stepping through the function by pressing <enter>. You do not need to retype 'step'
----
You should see the following outputted:
ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;
At this point, the program has gone to line 17, and is at the first line of the function ComputeSeriesValue, which sets the double seriesValue to 0.0.

Now, we wish to use the 'next' function until we reach the function CompueFraction(). To do this, use the following commands:
(gdb) next
18 double xpow=1;
(gdb) <enter>
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) step
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

==Using Backtrace==
*If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:
(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43
----
Note:
Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.
----
See the error?

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

change the line
int fact = 0;
to
int fact =1;
and your all set!

For another tutorial see:
http://www.cs.cmu.edu/~gilpin/tutorial/

Remote Debugging with GDB

2010-07-29T15:18:38Z

Gustavs:

In this tutorial we will go over how to perform a basic debugging with GDB, the GNU debugger. This environment allows us to debug machine code. You will not be able to debug java programs with this unless you find a way to compile you java file into an executable that does not require a Java Virtual Machine.
*We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learn how to set Breakpoints
:*Learn how to navigate the code in your program
:*Learn how to diagnose an error and how to fix it

*Required Items
:*Overo COM with Expansion Board
:*Mini B to Standard A Cable
:*Bootable MicroSD card

*Required Reading (things you should know, or tutorials that explain)
:*[[HelloWorld | HelloWorld in Python, C and C++]]
:*[[Eclipse on Gumstix for new users | Eclipse Tutorial]]
::*Although the majority of this tutorial regards Eclipse and Java programming, it contains useful information which leads to basic understanding of your Overo COM

==Installing the GDB Debugger==
Before starting this, you should have Console access to your Overo COM and should know how to program and run a basic C++ program. If you do not know how to do this, see [[HelloWorld | HelloWorld in Python, C and C++]].

To install the GDB debugger, run the following command in your command line:
opkg update
opkg install gdb
Once this has completed, you will have the GNU GDB debugger installed on your Overo COM

==Creating the Test File==
Now that we have the debugging environment

Run the following in your command line:
nano broken.cpp
Then copy and paste the code from [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp |Broken.cpp] into your shell. When you copy and paste there will be two syntax errors that you must fix at the lines:
cout << "This program is used to compute the value of the following
series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

Copying and pasting added an extra line break to these two lines, and we want to undo this by deleting one space at the beginning of each second line so it looks like this:
cout << "This program is used to compute the value of the following series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl

Now save and exit by pressing the following:
:*Ctrl + O
:*<Enter>
:*Ctrl + X

==Compile and Run broken.cpp==
Now that we have our test file (broken.cpp) ready to go, it is time to run it.

Compile the program to create an executable file (broken) by entering the following command:
g++ -g broken.cpp -o broken
Then run it:
./broken
----
Note:
Use 'g++ -g broken.cpp -o broken' to compile. If you use g++ -o, g++ --ggdb -Wall, or any other method of compilation the debugging will not follow this tutorial exactly.
----

Enter any numbers into the program for x and n. Run it a couple times, you should notice that the answer is always the same: infinity. This is obviously wrong.

Consider: x=1, n=1
(1^0)/0! + (1^1)/1!
1/1 + 1/1
2

NOT infinity

==Debugging the Program==
Now, it is time that we debugged our program.

First, you need to start the GDB environment by issuing the following command:
gdb
You should see the following command line appear:
(gdb)
Then, you need to 'tell' the debugger which file it is that we are debugging, do this by issuing the command:
(gdb) exec-file broken
Now, it is time to run our program by issuing the command:
(gdb) run

Notice that the program runs normally and again, gives us the answer inf. This is because the error we have is a computation error, and does not cause our program to crash. So, its time to set a Breakpoint in our program.

===Setting a Breakpoint===
----
Hint:
A breakpoint is a point in the program at which the debugger will stop the code from executing. Then, you can choose to 'step' through the program line by line to 'see' exactly what the CPU is doing. This way, you can effectively watch the program execute and discover where the problem is!
----
Lets set a breakpoint within the program so that we can see what is going on. Lets start by setting a breakpoint at line 43. Do this with the following command:
(gdb) b 43
----
Hint:
If the program outputs: No symbol table is loaded. Use the "file" command. Then use the following command:
(gdb) file broken
This will set the file so that you can add a breakpoint without error
----
Line 43 is the following:
double seriesValue = ComputeSeriesValue(x, n);
So the program will stop executing immediately before it executes the function ComputeSeriesValue(x, n).

Now, lets run the program with our command:
(gdb) run
Let's enter the values as x=2 and n=3, with an expected output value is 5.
Here is a snapshot of what the program should output at this point:
This program is used to compute the value of the following series :
(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!
Please enter the value of x : 2
Please enter an integer value for n : 3
Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);
The program has stopped at our breakpoint, line 43.

===Stepping into a function===
Next, we are going to step into the function ComputeSeriesValue(x, n)
----
Hint:
'Stepping' through a function allows us to go line by line, and see exactly what lines of code are being executed. This way we can manually diagnose the computation problem.
----
To start stepping, issue the following command
(gdb) step
----
Hint:
A nice thing about the GDB Debugger is that it will save the last command you issued so that you don't need to type it over and over. This way you can keep stepping through the function by pressing <enter>. You do not need to retype 'step'
----
You should see the following outputted:
ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;
At this point, the program has gone to line 17, and is at the first line of the function ComputeSeriesValue, which sets the double seriesValue to 0.0.

Now, we wish to use the 'next' function until we reach the function CompueFraction(). To do this, use the following commands:
(gdb) next
18 double xpow=1;
(gdb) <enter>
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) step
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

==Using Backtrace==
*If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:
(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43
----
Note:
Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.
----
See the error?

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

change the line
int fact = 0;
to
int fact =1;
and your all set!

For another tutorial see:
http://www.cs.cmu.edu/~gilpin/tutorial/

Remote Debugging with GDB

2010-07-29T15:16:51Z

Gustavs:

In this tutorial we will go over how to perform a basic debugging with GDB, the GNU debugger. This environment allows us to debug machine code. You will not be able to debug java programs with this unless you find a way to compile you java file into an executable that does not require a Java Virtual Machine.
*We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learn how to set Breakpoints
:*Learn how to navigate the code in your program
:*Learn how to diagnose an error and how to fix it

*Required Items
:*Overo COM with Expansion Board
:*Mini B to Standard A Cable
:*Bootable MicroSD card

*Required Reading (things you should know, or tutorials that explain)
:*[[HelloWorld | HelloWorld in Python, C and C++]]
:*[[Eclipse on Gumstix for new users | Eclipse Tutorial]]
::*Although the majority of this tutorial regards Eclipse and Java programming, it contains useful information which leads to basic understanding of your Overo COM

==Installing the GDB Debugger==
Before starting this, you should have Console access to your Overo COM and should know how to program and run a basic C++ program. If you do not know how to do this, see [HelloWorld | HelloWorld in Python, C and C++].

To install the GDB debugger, run the following command in your command line:
opkg update
opkg install gdb
Once this has completed, you will have the GNU GDB debugger installed on your Overo COM

==Creating the Test File==
Now that we have the debugging environment

Run the following in your command line:
nano broken.cpp
Then copy and paste the code from [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp |Broken.cpp] into your shell. When you copy and paste there will be two syntax errors that you must fix at the lines:
cout << "This program is used to compute the value of the following
series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

Copying and pasting added an extra line break to these two lines, and we want to undo this by deleting one space at the beginning of each second line so it looks like this:
cout << "This program is used to compute the value of the following series : " << endl;
and
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl

Now save and exit by pressing the following:
:*Ctrl + O
:*<Enter>
:*Ctrl + X

==Compile and Run broken.cpp==
Now that we have our test file (broken.cpp) ready to go, it is time to run it.

Compile the program to create an executable file (broken) by entering the following command:
g++ -g broken.cpp -o broken
Then run it:
./broken
----
Note:
Use 'g++ -g broken.cpp -o broken' to compile. If you use g++ -o, g++ --ggdb -Wall, or any other method of compilation the debugging will not follow this tutorial exactly.
----

Enter any numbers into the program for x and n. Run it a couple times, you should notice that the answer is always the same: infinity. This is obviously wrong.

Consider: x=1, n=1
(1^0)/0! + (1^1)/1!
1/1 + 1/1
2

NOT infinity

==Debugging the Program==
Now, it is time that we debugged our program.

First, you need to start the GDB environment by issuing the following command:
gdb
You should see the following command line appear:
(gdb)
Then, you need to 'tell' the debugger which file it is that we are debugging, do this by issuing the command:
(gdb) exec-file broken
Now, it is time to run our program by issuing the command:
(gdb) run

Notice that the program runs normally and again, gives us the answer inf. This is because the error we have is a computation error, and does not cause our program to crash. So, its time to set a Breakpoint in our program.

===Setting a Breakpoint===
----
Hint:
A breakpoint is a point in the program at which the debugger will stop the code from executing. Then, you can choose to 'step' through the program line by line to 'see' exactly what the CPU is doing. This way, you can effectively watch the program execute and discover where the problem is!
----
Lets set a breakpoint within the program so that we can see what is going on. Lets start by setting a breakpoint at line 43. Do this with the following command:
(gdb) b 43
----
Hint:
If the program outputs: No symbol table is loaded. Use the "file" command. Then use the following command:
(gdb) file broken
This will set the file so that you can add a breakpoint without error
----
Line 43 is the following:
double seriesValue = ComputeSeriesValue(x, n);
So the program will stop executing immediately before it executes the function ComputeSeriesValue(x, n).

Now, lets run the program with our command:
(gdb) run
Let's enter the values as x=2 and n=3, with an expected output value is 5.
Here is a snapshot of what the program should output at this point:
This program is used to compute the value of the following series :
(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!
Please enter the value of x : 2
Please enter an integer value for n : 3
Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);
The program has stopped at our breakpoint, line 43.

===Stepping into a function===
Next, we are going to step into the function ComputeSeriesValue(x, n)
----
Hint:
'Stepping' through a function allows us to go line by line, and see exactly what lines of code are being executed. This way we can manually diagnose the computation problem.
----
To start stepping, issue the following command
(gdb) step
----
Hint:
A nice thing about the GDB Debugger is that it will save the last command you issued so that you don't need to type it over and over. This way you can keep stepping through the function by pressing <enter>. You do not need to retype 'step'
----
You should see the following outputted:
ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;
At this point, the program has gone to line 17, and is at the first line of the function ComputeSeriesValue, which sets the double seriesValue to 0.0.

Now, we wish to use the 'next' function until we reach the function CompueFraction(). To do this, use the following commands:
(gdb) next
18 double xpow=1;
(gdb) <enter>
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) step
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

==Using Backtrace==
*If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:
(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43
----
Note:
Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.
----
See the error?

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

change the line
int fact = 0;
to
int fact =1;
and your all set!

For another tutorial see:
http://www.cs.cmu.edu/~gilpin/tutorial/

Eclipse on Gumstix for new users

2010-07-28T22:19:54Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the
Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a
Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this on a Macintosh Operating System go [http://www.gumstix.net/wiki/index.php?title=Gaining_Console_Connection_via_Terminal here].For a Windows Operating System use the Command Prompt. The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

File:LoginSuccess.png

2010-07-28T22:02:27Z

Gustavs:

File:TerminalWindow.png

2010-07-28T21:33:24Z

Gustavs: uploaded a new version of "File:TerminalWindow.png"

File:TerminalWindow.png

2010-07-28T21:31:50Z

Gustavs: uploaded a new version of "File:TerminalWindow.png"

File:Spotlight.png

2010-07-28T21:31:00Z

Gustavs: uploaded a new version of "File:Spotlight.png"

Spotlight

File:Spotlight.png

2010-07-28T21:30:58Z

Gustavs: uploaded a new version of "File:Spotlight.png"

Spotlight

File:Terminal.png

2010-07-28T21:30:35Z

Gustavs: uploaded a new version of "File:Terminal.png"

Terminal

File:Terminal.png

2010-07-28T21:29:13Z

Gustavs: uploaded a new version of "File:Terminal.png"

Terminal

File:TerminalWindow.png

2010-07-28T21:28:20Z

Gustavs: uploaded a new version of "File:TerminalWindow.png"

File:TerminalWindow.png

2010-07-28T21:28:12Z

Gustavs:

File:Spotlight.png

2010-07-28T19:39:14Z

Gustavs: uploaded a new version of "File:Spotlight.png": Spotlight

Spotlight

File:Terminal.png

2010-07-28T19:34:34Z

Gustavs: Terminal

Terminal

File:Spotlight.png

2010-07-28T19:34:04Z

Gustavs: Spotlight

Spotlight

Eclipse on Gumstix for new users

2010-07-28T17:08:46Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the
Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a
Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this, open up a Terminal window (Terminal for Mac users, XTerm or X11 for Windows users). The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

Eclipse on Gumstix for new users

2010-07-28T17:01:45Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the
Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a
Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this, open up a Terminal window (Terminal for Mac users, cmd for Windows users). To open terminal for windows go into the search bar in the start menu, and type cmp, the first option is the terminal window. The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

Eclipse on Gumstix for new users

2010-07-28T16:22:51Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the
Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a
Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this, open up a Terminal window (Terminal for Mac users, XTerm or X11 for Windows users). The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

Eclipse on Gumstix for new users

2010-07-28T16:22:19Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the
Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a
Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this, open up a Terminal window (Terminal for Mac users, XTerm or X11 for Windows users). The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

Eclipse on Gumstix for new users

2010-07-28T16:08:29Z

Gustavs:

This guide provides step-by-step instructions for using the Eclipse Integrated Development Environment (IDE) to develop applications for the Gumstix COMs.

We'll walk through these tasks:
:* setting up Eclipse
:* connection to your Gumstix system
:* creating a simple "Hello, World!" Python program
:* running a web server
:* installing new packages on your Gumstix
:* creating a small graphical Java application
:* remote debugging of your Java application
:* natively-compiling C/C++ code on your Gumstix
:* remote debugging C/C++ using the GDB server interface

We will also explain how to set up a cross-compilation toolchain so you can develop C/C++ applications on your development computer and upload them to your Gumstix.

Remember, Gumstix COMs are fully-fledged, albeit tiny, Linux systems so there are many tools we don't cover here. For example, [http://wiki.openembedded.net/index.php/OpenEmbedded_Tools_for_Eclipse_(OTE) this document] explains how to use the powerful OpenEmbedded build system within Eclipse.

Required Tools:
:* any Windows, Apple or Linux computer with a USB port
:* recent version of the Java Runtime Environment (available [http://java.sun.com/javase/downloads/index.jsp here])
:* a Gumstix COM running [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Downloading-pre-built-images/111.html up-to-date software]
:* any expansion board of the Gumstix Overo series, such as Chestnut or Tobi, that has both a USB console port and a 10/100
:* Ethernet jack
:* a 5V power supply
:* an ethernet cable and internet connection
:* a mini-A to Standard-A USB cable
:* a [http://www.gumstix.net/Setup-and-Programming/view/Overo-Setup-and-Programming/Creating-a-bootable-microSD-card/111.html bootable microSD card] (only needed for native C/C++ compilation)

Key Idea:
[[File:GumstixEclipse1.jpg|thumb]]

==Download Eclipse==
[http://www.eclipse.org/downloads/ Download] the Eclipse IDE for Java Developers for your Operating System: www.eclipse.org

[[Image: GumstixEclipse2.jpg | thumb | left]]

:* it is ''not'' necessary to install the Eclipse software; just double-click on the application once it has finished downloading
:* when prompted, choose a workspace folder in which you want to store your projects and your configuration information
:* then click through to the Eclipse workbench itself

==Install Plugins==
For developers, a great variety of additional features can be added to Eclipse from various repositories of plug-ins known as ''Update Sites''.
To install a new plugin in Eclipse, first select the ''Update Site''.
:* navigate to '''Help->Install New Software...'''
:* select the Update Site for your version of Eclipse from the "Work with"dropdown menu

[[File:GumstixEclipse3.jpg]]

:Note: If you are not sure which version of Eclipse you have, you can check by reopening Eclipse, it will be displayed on the loading screen.

----
Hint:
If the update site is not available, you can add it by clicking the 'Add...' button on the right. For the Galileo release, you can use the URL http://dowload.eclipse.org/releases/galileo
----

As we are working with a remote system, we'll install the Remote System Explorer plugin.
:* search for the ''Remote System Explorer End-User Runtime'' plugin
:* select it for installation

[[File:GumstixEclipse4.jpg]]

Still in Eclipse,
:* select "Next".... twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* choose "Yes" to restart Eclipse for the changes to take effect

Once Eclipse has restarted, let's add two other useful plugins that allow connection to the console port of our Gumstix without needing a terminal emulator program such as kermit or TeraTerm.
From within Eclipse,
:* navigate to '''Help->Install New Software'''
:* search on "Target" to find the ''Target Manager Terminal''

[[File:GumstixEclipse5.jpg]]

:* select the ''Target Manager Terminal''
:* click "Next"
:* click "Finish" to complete installation
:* choose "Yes" to restart Eclipse for the changes to take effect

We'll also need to add a new update site by doing these steps in Eclipse:
:* navigate to '''Help->Install New Software...'''
:* click the "Add..." button
:* type ''http://rxtx.qbang.org/eclipse'' into the ''Location'' field and create a name

[[File:GumstixEclipse6.jpg]]

:* Click the "OK" button
Go into the sub-directory as shown below to select the ''RXTX End-User Runtime'' plugin that this site provides.

[[File:GumstixEclipse7.jpg]]

:* click "Next" twice
:* select the radio button to "ACCEPT" the terms of the license agreement
:* click "OK" at the security warning window
:* click "Finish" to complete installation
:* choose the "Yes" button to restart Eclipse for the changes to take effect

==Connect Your Gumstix==
Now it is time to connect your Gumstix---let's get started by establishing a console connection.
:* mount your Gumstix COM down on to your expansion board
:* plug the mini-A USB plug into the port marked CONSOLE and end of the cable into a standard USB port on your computer
----
Hint:
Your computer should detect your Gumstix system when you first connect the USB cable, even though the power is not yet turned on. On Macintosh and Windows systems, a pop-up window should appear instructing you to download a new driver (do so) or notifying you that a USBserial device has been detected. If not, you can download drivers from [http://www.ftdichip.com/FTDrivers.htm this site]. Choose the "VCP" driver.
Once you have downloaded this driver, make sure to unplug and then replug the USB cable running from your computer to your Gumstix expansion board so the Gumstix will be recognized by your computer.
----
:* connect your Gumstix to the internet using an ethernet cable
NOTE: You still have NOT plugged the power cable in to the Gumstix expansion board! This diagram shows the locations
of the USB 'CONSOLE' port and the 'POWER' input port on a Summit board on which an Overo COM has been mounted.

[[File:GumstixEclipse8.jpg]]

:* if you are booting from a microSD card, insert this card now until you hear it click in place.
Before applying power to the board, let's open up a connection to the console port.
In Eclipse,
:* navigate to '''Window->Show View->Other->Terminal->Terminal'''
:* click on the 'N' connection icon in the window that appears

[[File:GumstixEclipse9.jpg]]

:* make the connection using the following settings:
Connection Type: Serial
Port: <port to which your Gumstix is connected>
Baud Rate: 115200
Data Bits: 8
Stop Bits: 1
Parity: none
Flow Control: none
Timeout: 5

----
Hint:
The port to which your Gumstix is connected will have a different name depending on your Host operating system.
:* On Windows, it should be ''USB-COM''
:* On Macintosh, it should be ''/dev/tty.usbserial-xxxxxxxx'' where ''xxxxxxxx'' is an arbitrary string of characters
:* On Linux, it should be ''/dev/ttyUSBx'' where ''x'' is a number.
----

[[File:GumstixEclipse10.jpg]]

*If this does not work, you can also get Console access to your Gumstix through a Terminal window. To do this, open up a Terminal window (Terminal for Mac users, XTerm or X11 for Windows users). The device will have the same name (USB-COM, /dev/cu..., /dev/tty.usb...).
----
Hint:
If you having a hard time find the device, you can search for it by doing a 
:*ls -l /dev/tty.* (for Mac and Linux) 
:*ls -l USB* (for Windows)
----
*Once you have found the device name, you can gain Console access with the screen command. If, for example, the device is /dev/tty.usb, issue the command:
screen /dev/tty.usb 115200
*The 115200 on the end is important, it tells your computer the Baud Rate. If you do not enter 115200, you will not be able to read what the Remote System is outputting. Once you have issued this command, you will have Console access to your Overo via Terminal.

*Now, it's time to apply power to the Gumstix expansion board so plug the 5V wall adapter into the power input jack on the Gumstix.

You should see text appear in this window; for now, just let the Gumstix boot. When prompted, you can log in to the root account. The default credentials are:

'''Overo'''

username: root

password: <leave blank>

'''VerdexPro'''

username: root

password: gumstix

==Write 'Hello, World' à la Python==

You are going to write a basic Python program for the Gumstix directly on the Gumstix; this is known as native development. Also, Python is an interpreted language which means you can run your programs directly without any compilation.

Once you have logged into your Gumstix, do these steps in the terminal window within Eclipse:
:* open an editor on the Gumstix by typing: 'nano hello.py'
:* type out this simple Python program: ''print "Hello, Gumstix!"''
:* press Ctrl+O, <Enter>
:* then press Ctrl+X to save and exit.
:* run your program by typing: ''python hello.py''
:* check that you see the words "Hello, Gumstix!" appear

If you see the words "Hello Gumstix", then you have just written your first program on a Gumstix Overo computer.

==Create a Web Site==
Each Gumstix comes with a built-in package manager called opkg. A package manager is a useful tool for installing software; you can install everything from media players to GPS mapping tools to the Firefox web browser. In this example, you'll use opkg tool to install a new application for your Gumstix: the Apache web server.

To make your own Gumstix web site, type the following in the terminal window:
opkg update <Enter>
opkg install apache2 <Enter>
Before you start using Apache, which is now running, you'll need to find the IP address (internet address) of your Gumstix COM. To do this, type the following command into the terminal window:
ifconfig | grep 'inet addr' <Enter>
You should see something like this appear on your screen.
inet addr: 10.0.1.73 Bcast: 192.168.0.255 Mask: 255.255.255.0
The IP address of your Gumstix is the first address shown: ''10.0.1.73'' in this case.
Now,
:* open up a web browser on your host computer
:* type that IP address of your Gumstix into the address bar
You should see something like this which is the default web site for Apache running on your Gumstix.

[[File:GumstixEclipse11.jpg]]

To make your web site say something more interesting, do the follow in your terminal window:
:* type: ''nano /usr/share/apache2/htdocs/index.html''
:* replace the words at the top of the screen "It Works" with the words "Gumstix Rocks!"
:* press 'Ctrl+O' <Enter>
:* press 'Ctrl+X' to save and exit
:* refresh your web browser

==Write a Java Application==
So far, you haven't actually used Eclipse other than as a console interface for your Gumstix. It is time to harness the power of Eclipse to write a small graphical Java application.
In Eclipse.
:* Navigate to '''File-> New-> Java Project''',
:* Name the project ''gumstix-java''
:* Select "Finish"
Once the project is created,
:* Select '''File->New->Class'''
:* Name your class ''Hello''
:* click "FINISH"

Add the following code to your class:

import javax.swing.JFrame;
import javax.swing.JLabel;
public class Hello {
public static void main(String [] args) {
JFrame frame = new JFrame("hello");
final JLabel label = new JLabel("hello from Gumstix");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}

You should get something that looks like this:

[[File:GumstixEclipse12.jpg]]

Press the green run button to test drive our application on our host machine.

----
Hint:
Eclipse has many auto-completion features. Simply typing /:*<Enter> before a class creates a standard documentation block. Likewise, pressing <Ctrl>+<Space> provides context specific auto-completion options. Many other hints for speedy development are explained in the tutorials [http://www.eclipse.org/resources/?category=Getting%20Started here].
----

==Upload Code==
In Step 5 we discovered the IP address of our Gumstix. With this, we can connect to our Gumstix using the SSH protocol which allows us to rapidly transfer files. For this step, navigate to '''Window->Open Perspective->Other->Remote System Explorer''' and click on the connection icon in the ''Remote Systems'' panel on the left. Select ''SSH without shells'' as the connection type and press Next. Put the internet address you found in Step 5 into the field marked ''Host Name'' and hit finish. To test that everything is working correctly, right-click on the terminal item list under your new connection and select ''Launch Terminal''. A console interface exactly like the USB console interface we set up in Step 3 should pop up.

----
Hint:
A 'Perspective' is an arrangement of windows and widgets, that is a specific view of the Eclipse workspace, designed for a particular task. If you wish to focus on any particular widget, double click the tab in Eclipse; return to the previous view by double-clicking again.
----

By installing the VNC viewer plugin, we can get a graphical interface to our Gumstix system. Do this by adding the ''Tools for mobile linux runtime'' plugin ('''Help->Install New Software''') from the main update site. To use, select the VNC viewer widget from '''Window->Show View->Other->VNC Category->VNC''' and click on the ''New Connection'' icon in the VNC Viewer panel. Again, the ''Host'' is the internet address of your Gumstix board.

[[File:GumstixEclipse13.jpg]]

Finally, we need to upload our java code before we can run it. Switch back to the Java Perspective ('''Window->Open Perspective->Java''') and right-click on our Java file and selecting Export. Choose the option to export file to a remote file system and choose to upload your ''Hello.class'' file.

[[File:GumstixEclipse14.jpg]]

You will need to ''Browse'' to find your Gumstix board; you should upload this code to your home directory on the Gumstix.

==Debug a Java Application==
We can debug our java application remotely from Eclipse. To do this, we need a Java Virtual Machine capable of doing debugging. This time, the package we need isn't available in our package sources however we can fetch the package directly from a web site and install it using the same opkg package management tool.
wget http://bugcommunity.com/downloads/files/phonemeadvanced- personal-debug_mr2-r1_armv6.ipk <Enter>
opkg install -force-depends phoneme-advanced-personaldebug_mr2-r1_armv6.ipk <Enter>
Let's also update our Java libraries so we have access to the standard graphical libraries.
opkg install classpath-gtk <Enter>
Next, let's start our Java code in debugging mode on the Overo:
java-cdc -Xdebug -Xrunjwdp:transport=dHt_socket,server=y,suspend=y,address=1234 Hello <Enter>
Finally, let's connect to our debugging session by navigating in Eclipse to '''Run->Debug Configurations''' and double-clicking on Remote Java Application to create a new configuration. Fill in the form as shown below using the internet address found in the previous step.

==Install a native C/C++ SDK==
When we discussed Python and Java we noted that both are interpreted languages--- neither needs to be compiled. C and C++ code requires compilation which can be done natively---on the Gumstix itself---or on a development machine using a cross-compiler. To do native compilation, you need to install a compiler as well as any required libraries. You'll need to be booting from a microSD card as this installation takes approximately 75MB of space.
$ echo 'src/gz angstrom-base http://www.angstromdistribution.org/feeds/unstable/ipk/glibc/armv7a/base' > /etc/opkg/angstrom-base.conf
$ opkg update
$ opkg install task-native-sdk
Firstly, we are adding a new package repository to our package manager and updating our list of available packages before actually installing the complete package needed to do native development.

Let's create either of the following files in Eclipse, upload the code and then compile on the Gumstix using our newly installed compiler.

===C++: HelloWorld.cpp===
#include <iostream>
using namespace std;
int main () {
cout << "Gumstix runs on C++" << endl;
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.cpp
g++ -o hello hello.cpp <enter>
Gumstix runs on C++ <enter>

===C: HelloWorld.c===
#include <stdio.h>
int main () {
printf("Gumstix runs on C\n");
return 0;
}

Save the file and issue the following commands to compile and run HelloWorld.c
gcc -o hello hello.c
Gumstix runs on C

<TODO: More exciting examples using on-board LEDs.>

==Using GDB as a remote debugger in C/C++==
These instructions will teach you how to download, install, and use the GDB debugger remotely on your Overo COM.

<pre>NOTE:
remote system - a device that is being operated remotely (via SSH, USB Serial, etc). This means that it is a device that you are operating from a different system
(ie: if you are accessing the Overo COM via connection with your PC, then the Overo COM is a remote system).
For the purpose of this guide, the Overo COM will be the remote system.

local host - the device that is being used to work on (ie: If you are working on your PC, that is the local host. If you then connect to another computer via VNC,
that is a remote system, and you laptop is still the localhost).
For the purpose of this guide, your Personal Computer will be the local host.</pre>

Before starting, it is important to note there are many different ways to run a remote debugger. The most fundamental choice when debugging remotely is whether you want to:
:*Run the debugger on the remote system or
:*Run the debugger on the local host with a cross debugger on the remote system

This guide will teach you how to download, install, and run the debugger on the remote system (choice A). If you wish to learn more about the cross debugger option, use Google. Also the wikipedia article on cross compilers (which operate in a very similar fashion) is very good, albeit a bit complicated. None of this is necessary in understanding the contents of this guide.

For the purposes of this guide, we will be using the GDB: the GNU project debugger. As stated on their website:

<pre>GDB, the GNU Project debugger, allows you to see what is going on `inside' another program while it executes -- or what another program was doing at the moment it
crashed.

GDB can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:
- Start your program, specifying anything that might affect its behavior.
- Make your program stop on specified conditions.
- Examine what has happened, when your program has stopped.
- Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.</pre>

While the reasons for using a debugger instead of trying to debug with the ‘brute force’ method of adding print statements throughout the entire program are enumerable, there are a few that stand out:
# The ability to ‘step’ through a program
#* The GDB debugger allows you to ‘step’ through a program. This means that instead of just executing the program and then leaving you with a final error message, it will execute one line at a time until the program crashes. This allows the user to see exactly where, and why, the program crashed.
# The ability to set breakpoints
#* The GDB debugger allows you to set breakpoints in the program. These are points where the CPU will stop executing the code and allow the user to decide whether to continue. This allows the user to explore what is ‘going on’ at certain points in the execution, something that otherwise is not possible.
# The ability to look at the Backtrace
#* This will show you where, and exactly why, your program crashed. Although SEGFAULT isn’t very useful, the backtrace will tell you what caused the SEGFAULT. Everything from what line, what variable, and even the address that variable was at.

===Installing the GDB===
Once the Overo COM has been connected to the local host, you should have access to the following command line:
<pre>root@overo:~# </pre>
Although you are working on your local host, this command line is for the remote system. It is the same as if you opened up Terminal (for Mac, Linux) or XTerm (for Windows). You now have access and control of the remote system.

Now there are some packages that must be downloaded and installed onto the Overo so that it can run the GDB environment. To do this issue the following command:
<pre>opkg update <enter>
opkg install gdb <enter></pre>
This should spew out a bunch of text such as:
<pre>Downloading http://www.angstrom...</pre>
Just let it run and once its done, you’ll have the GNU GDB debugger installed on your Overo COM.

===Creating a C/C++ Program to Debug===
Now, your Overo COM has a debugger installed and ready to use. However, this does not mean you are ready to go. There are two more things required before it is possible to use a GDB debugger.
:* A C/C++ program
:* A SDK to run the program on
To see how to install a SDK and write/run a simple program in C/C++, see [[#Install a native C/C++ SDK]].

Once you have a program ready, you first must create an executable file. Lets use for example the C++ program HelloWorld.cpp. To create the executable file HelloWorld, issue the following command:
<pre>g++ -o HelloWorld HelloWorld.cpp <enter></pre>
Now, to run the program:
<pre>./HelloWorld <enter></pre>
To do the same thing with a C program (HelloWorld.c), issue the command
<pre>gcc -o HelloWorld HelloWorld.c <enter></pre>
<pre>./HelloWorld <enter></pre>

What this command does is uses the GNU compiler (either g++ or gcc) and creates an executable object (HelloWorld) out of the C or C++ program file (either HelloWorld.cpp or HelloWorld.c). You may name the executable whatever you like, but it is considered best practice to name it the same thing as the program file.

===Debugging the Program===
Now that you have GDB installed and a C/C++ program ready to go, its time to debug. To open to GDB environment, run the following command
<pre>gdb <enter></pre>
Some text should spit out, and the following command line should appear
<pre>(gdb)</pre>
Now that the debugger is running, it is time to tell the debugger what program we want to debug. To do this, first we need to declare our HelloWorld file as an executable file. For this run the following command
<pre>(gdb) exec-file HelloWorld <enter></pre>
Now that we have an executable file ready to be debugged, its time to run the program
<pre>(gdb) run HelloWorld <enter></pre>
The debugger will now run your program. If the program has no syntax or logic errors, the program should run and end with the line:
Program exited normally.
If there are errors, or the program crashed, it is possible to extract the exact details of that crash by issuing the back trace command.
<pre>(gdb) bt <enter></pre>
Once you are done you can quit by issuing the command:
<pre>(gdb) quit <enter></pre>

A complete list of commands in GDB:
www.yolinux.com/TUTORIALS/GDB-Commands.html

====GDB Debugger Tutorial====
For a complete GDB Debugger tutorial (very good tutorial, comes with sample code they walk you through and extra errors for you to debug yourself!):
http://www.cs.cmu.edu/~gilpin/tutorial/

Now you have a debugger up and running! Play around with it by putting errors into your program on purpose to see the powers of having a remote debugger!

==Use a C/C++ cross-compiler==
In order to do C/C++ development on our host machine, we need to add in a plugin to Eclipse. Also, we need to download an appropriate cross-compilation toolchain. For now, I recommend the lovely instructions from

http://www.designarm.com/quickstart-guide/linux-software/eclipse.html &

http://www.bugcommunity.com/wiki/index.php/BUG_Kernel_Development_with_Eclipse

===Further Reading===
:* Tutorials built into Eclipse
:* Bitbake commander
:* OpenEmebedded|Poky docs + Bitbake docs
:* Eclipse Plugin Tutorial

[[Category:How_to_-_eclipse]]

Remote Debugging with GDB

2010-07-27T21:36:44Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

In this tutorial we will go over how to perform a basic debugging with GDB.
:We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learning how to set Breakpoints
:*Learning how to navigate the code in your program
:*Learning how to diagnose and error and how to fix it

----
'''NOTE:''' Before you continue make sure you have GDB installed. To install GDB complete the tasks below

root@overo:~# opkg update <enter>
root@overo:~# opkg install gdb <enter>

----

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

'''1. Download the test program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]'''

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The 3rd line in this section of code will drop down one line in your terminal, and look something like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

:::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

'''2. Compile the program and execute the program.'''

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:note: Do not type “g++ -o broken broken.cpp”

----

'''3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger'''

root@overo:~# gdb broken <enter>

----

'''4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43'''
(if GDB is not your command line do as follows)

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

'''5. Now, we start to run the program in the debugger.'''

(gdb) run

----

'''6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.'''

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

'''7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function'''

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

'''8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.'''
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: "step" lets you get a closer look at each function and line, while "next" skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

'''9. Where are we?'''

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

'''10. Watching changes We can go through the program (using the next command) and examine the values using the print command.'''

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

----
----

:::::This tutorial was based from http://cs.baylor.edu/~donahoo/tools/gdb/tutorial.html
::::::If you have any questions please visit their site
== [[Headline text]] ==

Remote Debugging with GDB

2010-07-27T21:35:57Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

In this tutorial we will go over how to perform a basic debugging with GDB.
:We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learning how to set Breakpoints
:*Learning how to navigate the code in your program
:*Learning how to diagnose and error and how to fix it

----
'''NOTE:''' Before you continue make sure you have GDB installed. To install GDB complete the tasks below

root@overo:~# opkg update <enter>
root@overo:~# opkg install gdb <enter>

----

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

'''1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]'''

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The 3rd line in this section of code will drop down one line in your terminal, and look something like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

:::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

'''2. Compile the program and execute the program.'''

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:note: Do not type “g++ -o broken broken.cpp”

----

'''3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger'''

root@overo:~# gdb broken <enter>

----

'''4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43'''
(if GDB is not your command line do as follows)

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

'''5. Now, we start to run the program in the debugger.'''

(gdb) run

----

'''6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.'''

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

'''7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function'''

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

'''8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.'''
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: "step" lets you get a closer look at each function and line, while "next" skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

'''9. Where are we?'''

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

'''10. Watching changes We can go through the program (using the next command) and examine the values using the print command.'''

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

----
----

:::::This tutorial was based from http://cs.baylor.edu/~donahoo/tools/gdb/tutorial.html
::::::If you have any questions please visit their site
== [[Headline text]] ==

Remote Debugging with GDB

2010-07-27T21:26:10Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

In this tutorial we will go over how to perform a basic debugging with GDB.
:We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*Learning how to set Breakpoints
:*Learning how to navigate the code in your program
:*Learning how to diagnose and error and how to fix it

----
'''NOTE:''' Before you continue make sure you have GDB installed. To install GDB complete the tasks below

root@overo:~# opkg update <enter>
root@overo:~# opkg install gdb <enter>

----

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

'''1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]'''

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The 3rd line in this section of code will drop down one line in your terminal, and look something like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

:::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

'''2. Compile the program and execute the program.'''

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:note: Do not type “g++ -o broken broken.cpp”

----

'''3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger'''

root@overo:~# gdb broken <enter>

----

'''4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43'''
(if GDB is not your command line do as follows)

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

'''5. Now, we start to run the program in the debugger.'''

(gdb) run

----

'''6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.'''

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

'''7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function'''

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

'''8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.'''
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: "step" lets you get a closer look at each function and line, while "next" skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

'''9. Where are we?'''

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

'''10. Watching changes We can go through the program (using the next command) and examine the values using the print command.'''

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T21:00:26Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

In this tutorial we will go over how to perform a basic debugging with GDB.
:We will complete these tasks step by step
:*Installing the GDB debugger
:*Running the debugger
:*How to set Breakpoints
:*How to navigate the code in your program
:*How to diagnose and error and how to fix it

----
'''NOTE:''' Before you continue make sure you have GDB installed. To install GDB complete the tasks below

root@overo:~# opkg update <enter>
root@overo:~# opkg install gdb <enter>

----

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

'''1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]'''

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The 3rd line in this section of code will drop down one line in your code, and look something like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

:::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

'''2. Compile the program and execute the program.'''

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

'''3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger'''

root@overo:~# gdb broken <enter>

----

'''4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43'''
(if GDB is not your command line do as follows)

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

'''5. Now, we start to run the program in the debugger.'''

(gdb) run

----

'''6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.'''

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

'''7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function'''

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

'''8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.'''
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

'''9. Where are we?'''

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

'''10. Watching changes We can step through the program (using the next command) and examine the values using the print command.'''

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T20:46:13Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----

'''1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]'''

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

'''2. Compile the program and execute the program.'''

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

'''3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger'''

root@overo:~# gdb broken <enter>

----

'''4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43'''
(if GDB is not your command line do as follows)

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

'''5. Now, we start to run the program in the debugger.'''

(gdb) run

----

'''6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.'''

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

'''7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function'''

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

'''8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.'''
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

'''9. Where are we?'''

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

'''10. Watching changes We can step through the program (using the next command) and examine the values using the print command.'''

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:55:08Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:54:48Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:54:08Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:53:05Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:51:22Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in! (around line #30)

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:50:20Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in!

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::The line with several points "........" will drop down one line in your code and look someting like this...

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:49:44Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.
:::::NOTE: The code below is the area that the Error occurs in!

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::'''The line with several points "........" will drop down one line in your code and look someting like this...'''

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:48:52Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.

int main() {
cout << "This program is used to compute the value of the following series : " << endl;
cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;
cout << "Please enter the value of x : " ;

:::'''The line with several points "........" will drop down one line in your code and look someting like this...'''

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:48:23Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.

int main() {
cout << "This program is used to compute the value of the following series : " << endl;

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

cout << "Please enter the value of x : " ;

:::'''The line with several points "........" will drop down one line in your code and look someting like this...'''

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

::::To fix this you have to bring all of the code back onto a single line. It should end up looking like this.

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:46:50Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

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

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

:::'''WARNING'''
::::If you copy and paste this code you will get an error!
::::To fix this error please follow these directions.

int main() {
cout << "This program is used to compute the value of the following series : " << endl;

cout << "(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n! " << endl;

cout << "Please enter the value of x : " ;

:::'''The line with several points "........" will drop down one line in your code and look someting like this...'''

cout << "(x^0)/0! + (x^1)/1

! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ....
.... + (x^n)/n! " << endl

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----
----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----
----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----
----

5. Now, we start to run the program in the debugger.

(gdb) run

----
----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----
----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----
----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----
----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----
----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:41:56Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----
----

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps:

(gdb) b 43

::This puts a breakpoint at line 43 in the program's code.

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:37:24Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----
----

1. Download the sample program [http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp Broken.cpp]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:36:31Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----
----

1. Download the sample program http://cs.baylor.edu/~donahoo/tools/gdb/broken.cpp

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:35:19Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----
----

1. Download the sample program [www.brokenprogram.com]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:34:42Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

----

1. Download the sample program [www.brokenprogram.com]

----

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

----

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

----

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

----

5. Now, we start to run the program in the debugger.

(gdb) run

----

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

----

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

----

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

----

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

----

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:33:24Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

1. Download the sample program [www.brokenprogram.com]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

5. Now, we start to run the program in the debugger.

(gdb) run

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: Now is the time to put in any commands you left out before.

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:32:13Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

1. Download the sample program [www.brokenprogram.com]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line do as follows

root@overo:~# gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

5. Now, we start to run the program in the debugger.

(gdb) run

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: if you left any commands out before or want to put one in, do it now

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:29:57Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

1. Download the sample program [www.brokenprogram.com]

2. Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

:hint: Do not type “g++ -o broken broken.cpp”

3. In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

4. This only starts the debugger; it does not start running the program in the debugger. Look at the source code and set a breakpoint at line 43
(if GDB is not your command line, i.e. (gdb), type) --> gdb

:Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

5. Now, we start to run the program in the debugger.

(gdb) run

6. Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: if you left any commands out before or want to put one in, do it now

Let's enter the values as x=2 and n=3.
The expected output value is 5.
The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

7. Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

8. At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

9. Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

10. Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.

(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.

::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.

Remote Debugging with GDB

2010-07-27T18:22:13Z

Gustavs: New Debugging Tutorial

'''Tutorial for Debugging a program with a logical error'''

:This sample program has some logical errors. The program is supposed to output the summation of
:(X^0)/0! + (X^1)/1! + (X^2)/2! + (X^3)/3! + (X^4)/4! + ... + (X^n)/n!, given x and n as inputs.
:However the program outputs a value of infinity, regardless of the inputs. We will take you step by step :through the debugging process and trace the errors:

# Download the sample program [www.brokenprogram.com]

# Compile the program and execute the program.

root@overo:~# g++ -g broken.cpp -o broken <enter>
root@overo:~# ./broken <enter>

hint: Do not type “g++ -o broken broken.cpp”

# In this program no matter the input the output always is infinity. The -g option is important because it enables meaningful GDB debugging. Start the debugger

root@overo:~# gdb broken <enter>

# This only starts the debugger; it does not start running the program in the debugger. Look at the source :code and set a breakpoint at line 43
:(if GDB is not your command line, i.e. (gdb), type) --> gdb

Complete the following steps

(gdb) b 43

Doing that will make this appear below

double seriesValue = ComputeSeriesValue(x, n);

# Now, we start to run the program in the debugger.

(gdb) run

# Note: If you still need to supply the command-line arguments for the execution of the program, simply include them after the run command, just as normally done on the command line. The program starts running and asks us for the input.

:HINT: if you left any commands out before or want to put one in, do it now

Let's enter the values as x=2 and n=3. The expected output value is 5. The following is a snapshot of the program running in the debugger:

:This program is used to compute the value of the following series :
:(x^0)/0! + (x^1)/1! + (x^2)/2! + (x^3)/3! + (x^4)/4! + ........ + (x^n)/n!

::Please enter the value of x : 2

::Please enter an integer value for n : 3

Breakpoint 1, main () at broken.cpp:43
43 double seriesValue = ComputeSeriesValue(x, n);

# Note that the program execution stopped at our first (and only) breakpoint. Step into the ComputeSeriesValue() function

To step into a function call, we use the following command:

(gdb) step

ComputeSeriesValue (x=2, n=3) at broken.cpp:17
17 double seriesValue=0.0;

# At this point, the program control is at the first statement of the function ComputeSeriesValue (x=2, n=3) Next let's step through the program until we get into ComputeFactorial.
To stay on track follow these commands carefully.

(gdb) next
18 double xpow=1;
(gdb) n
20 for (int k = 0; k <= n; k++) {
(gdb) <enter>
21 seriesValue += xpow / ComputeFactorial(k) ;
(gdb) s
ComputeFactorial (number=0) at broken.cpp:7
7 int fact=0;

:Note: Step lets you get a closer look at each function and line, while next skips over whole functions to the next one.

:Here we use n and s instead of next and step, respectively. If the command is simply a repeat of the previous command, you can just hit return, which will execute the last command. Finally, we step (with s) into ComputeFactorial(). (If we'd used next, it would have stepped over ComputeFactorial.)

# Where are we?

:If you want to know where you are in the program's execution (and how, to some extent, you got there), you can view the contents of the stack using the backtrace command as follows:

(gdb) bt
#0 ComputeFactorial (number=0) at broken.cpp:7
#1 0x08048907 in ComputeSeriesValue (x=3, n=2) at broken.cpp:21
#2 0x08048a31 in main () at broken.cpp:43

:Note: Backtrace lets you see where you have been and what you have done, in the case you get lost or confused it is very useful.

# Watching changes We can step through the program (using the next command) and examine the values using the print command.

:Once again, follow these commands carefully in order to stay on track.
(gdb) next
9 for (int j = 0; j <= number; j++) {
(gdb) n
10 fact = fact * j;
(gdb) n
9 for (int j = 0; j <= number; j++) {
(gdb) print fact
$2 = 0
(gdb) n
13 return fact;
(gdb) quit

:Try to find the error.
::HINT: Look inside the “print fact” command

The print command (abbreviated p) reveals that the value of fact never changes. Note that the function is returning a value of 0 for the function call ComputeFactorial(number=0). This is an ERROR! The answer will always equal zero.

By taking a closer look at the values printed above, we realize that we are computing fact=fact * j where fact has been initialized to 0, (0 = 0 * j); fact should have been initialized to 1. We quit GDB with the quit command. Next we need to change the following line:

(gdb) quit

:int fact = 1;
::HINT: It is near the top of the program’s code.

Recompile the code and run it, you will get the expected output.