Mech - User contributions [en]

V-REP Introduction

2016-10-26T19:56:46Z

JarvisSchultz: /* Switching Between Scenes */

== V-REP Introduction ==

On [http://www.coppeliarobotics.com/index.html V-REP's homepage] the program is described as

...the Swiss army knife among robot simulators: you won't find a simulator with more functions, features, or more elaborate APIs.

V-REP's strength comes from several features:

# V-REP provides a unified framework combining many powerful internal and external libraries that are often useful for robotics simulations. This includes dynamic simulation engines, forward/inverse kinematics tools, collision detection libraries, vision sensor simulations, path planning, GUI development tools, and built-in models of many common robots.
# V-REP is highly extensible. V-REP developers provide an API that allows one to write custom plugins that add new features. You can embed [https://en.wikipedia.org/wiki/Lua_(programming_language) Lua] scripts directly into a simulation scene that, for example, process simulated sensor data, run control algorithms, implement user interfaces, or even send data to a physical robot. They also provide a remote API that allows one to develop standalone applications in many programming languages that are able to pass data in and out of a running V-REP simulation.
# V-REP is cross-platform, mostly open-source, and provides a free educational license.

The purpose of this page is not to teach you how to use V-REP. Rather it is to
describe demonstration scenes that have been developed to help
visualize robot arm kinematics. If you are interested in learning more about
V-REP, check out the [[#Useful Resources|Useful Resources]] section below.

== Demonstration V-REP Scenes ==

To run either of the scenes below, the first step will be to [http://www.coppeliarobotics.com/downloads.html download V-REP] for your operating system. You should download the latest Non-limited EDUCATIONAL version. Next you will have to install V-REP. On Windows, you simply have an EXE that installs V-REP. On a Mac, you first need to unzip the download. The directory that is produced by unzipping the download contains a <code>vrep.app</code> directory that should allow you start V-REP through normal mechanisms, e.g., Finder/Spotlight/Launchpad. On Linux, you will need to extract the compressed tar archive (e.g., using a command like <code>tar xvf V-REP_PRO_EDU_V3_3_2_64_Linux.tar.gz</code>). Then you need to change directories into the V-REP source directory and run the <code>vrep.sh</code> shell script.

Once V-REP is open you will want to run one of the scenes below. To run either of them, you first run V-REP, then you click <code>File->Open scene...</code> and open one of the ttt files that are linked below. Then click either the ''Play'' button from the top toolbar or click <code>Simulation->Start simulation</code> and a GUI should pop up. Clicking the ''Stop'' button or <code>Simulation->Stop simulation</code> will close the GUI and stop the simulation.

The scenes below are implemented similarly. They both feature a simulation of a kinematically-controlled, non-respondable [https://www.universal-robots.com/products/ur5-robot/ UR5 robot] from [https://www.universal-robots.com/ Universal Robots]. ''Kinematically controlled'' means that all dynamics (inertias, torques, friction, etc.) of the system are neglected. We can specify a set of joint angles and the simulation is capable of instantaneously "teleporting" the robot to be at the new set of joint angles. ''Non-respondable'' means that the links of the robot are not capable of interacting with the world or each other through collisions. In other words, we can put the robot in configurations that result in self-collisions, but the simulation will ignore the collisions. The physical UR5 robot features 6 joints each with 720 degrees of rotation, and this simulated robot has the same joints and limits. The model of the UR5 in each of the scenes was created by importing a URDF from the ROS-Industrial [https://github.com/ros-industrial/universal_robot/tree/indigo-devel/ur_description/urdf ur5_description package].

In each scene, there is a single Lua script called a [http://www.coppeliarobotics.com/helpFiles/en/childScripts.htm Non-threaded child script]. When the scene is first run, there is a function that is called that sets up the GUI and creates variables that are going to be needed later on in the simulation. Then during every step of the simulation the [http://www.coppeliarobotics.com/helpFiles/en/mainScript.htm main script], which is part of every V-REP scene, runs an "actuation" function from the child script. This actuation function is responsible for processing all of the changes to the GUI since the last time it was called (buttons clicked, label updates, etc.), and for sending joint commands to the simulated robot. Technically, there is also a "sensing" function in the child script that gets called by the main script, but in each of these demos, the sensing function is empty. The GUIs are both built with V-REP's [http://www.coppeliarobotics.com/helpFiles/en/customUIPlugin.htm Qt-based custom UI framework].

=== Scene 1: Interactive UR5 ===

In this demo, the GUI features two tabs. One tab lets you drag sliders to modify the joint angles of each joint, and the other tab allows you to specify comma-separated angles for all 6 joints in an editable text box and ask for the <math>SE(3)</math> transformation from the base frame to the end-effector frame. ('''Note''': You have to click the "Calculate SE(3) Transform" button to see the transformation.) The frames attached to the base and end-effector are persistently displayed (x-axis in red, y-axis in green, z-axis in blue). Note that all angles are specified in radians.

* Download the ttt scene file here: [[Media:UR5_imported_interactive.ttt]]

=== Scene 2: CSV Animation UR5 ===

This demo allows you to specify a CSV file containing a trajectory of joint angles, and then animate this trajectory. Each column of the CSV file is the joint angle through time for one of the joints (first column is joint 1, last column is joint 6). In other words, a single row of the CSV file represents a complete configuration of the robot at a particular time. The assumed timestep between rows is equal to the timestep that V-REP uses for simulation; the default is 0.05 seconds. Note that will need to provide a complete path to your CSV file. Alternatively, you may be able to provide a relative path, but you'll need to figure out what V-REP uses as its base directory on your OS. On Linux, this directory is the root directory of the V-REP source code. If you figure out this directory, you could also move your CSV files to be in this directory and just reference them by name without specifying the path at all. A typical path on the Mac is something like <code>/Users/kevin/yourdirectoryname/example.csv</code>.

* Download the ttt scene file here: [[Media:UR5_imported_csvplayer.ttt]]
* Download an example csv file here: [[Media:UR5_example_jointstates.csv]]

=== Switching Between Scenes ===

Press the ''Stop'' button to stop the simulation of the current scene, then choose <code>File>Open scene...</code>. You can also use <code>File>Open recent scene</code> to switch to a scene you previously loaded. Then you press the ''Play'' button to run the scene. Alternatively, stop the simulation and then press the <code>Scenes</code> button in the top toolbar to see which scenes are currently open and select one to be in the foreground. The scene selector toolbar button may also be used to switch between opened scenes. Read more [http://www.coppeliarobotics.com/helpFiles/en/scenes.htm here]

=== Exploring Other Scenes ===

You are encouraged to explore some of the (quite impressive) scenes that come pre-loaded with V-REP. You can find these scenes in the <code>scenes</code> directory under the V-REP directory. Running and studying these can be a great way to learn more about the V-REP capabilities and to understand how to put together more complex scenes.

== Useful Resources ==

* [http://www.coppeliarobotics.com/v-repOverviewPresentation.pdf V-REP Overview Presentation]
* [http://www.coppeliarobotics.com/videos.html V-REP Videos Page]
* [http://www.coppeliarobotics.com/helpFiles/en/tutorials.htm V-REP Tutorial Series]
* [http://www.coppeliarobotics.com/features.html Overview of V-REP Features]
* [http://www.coppeliarobotics.com/helpFiles/en/apiOverview.htm V-REP API Documentation] These are all functions that can either be called directly from a custom C/C++ plugin or through a Lua embedded script.
* [http://www.coppeliarobotics.com/helpFiles/en/remoteApiOverview.htm Remote API Documentation] The Remote API is how V-REP enables scripts and programs written in other languages (MATLAB, Java, Python, etc.) to interact with a V-REP simulation

File:Ur5 example jointstates.csv

2016-10-26T17:24:52Z

JarvisSchultz:

File:Ur5 imported csvplayer.ttt

2016-10-26T17:24:08Z

JarvisSchultz:

File:Ur5 imported interactive.ttt

2016-10-26T17:20:54Z

JarvisSchultz:

V-rep-intro

2016-10-26T17:02:05Z

JarvisSchultz: moved V-rep-intro to V-Rep Introduction

#REDIRECT [[V-Rep Introduction]]

File:FinalDemo.zip

2012-03-06T07:40:48Z

JarvisSchultz: uploaded a new version of "Image:FinalDemo.zip"

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-03-06T07:31:48Z

JarvisSchultz: /* Approximate Syllabus */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Family Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes quite a lot of example code. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|'''Sample Code for ME 333''']]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2. [[Media:Assignment4Solutionsv2.zip|Solutions]]
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4. [[Media:ME333_2012_quiz5_solns.txt|Solutions]] (average 5.57/7, stdev 2.0)
: '''Topic''': Sensors, op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]], [[Operational Amplifiers (Op-Amps)|wiki page on op amps]], [http://en.wikipedia.org/wiki/Operational_amplifier_applications wikipedia page on op amps]
: '''Assignment 5 out''': [[Media:ME333_winter2012_Assignment5.pdf|Simple real-time control with the PIC32]] Note that if you do not get the entire assignment done, you can turn in screenshots from your NUScope demonstrating the tasks that you did accomplish. If you do this, in the filenames, clearly indicate which section the image corresponds to.

'''Class 13''' (Th 2/16)
: '''Topic''': DSP: digital filtering, FIR, IIR, FFT, iFFT.
: '''Reading''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Assignment 5 due''': Handed out on Tues 2/14. [[Media:Assignment5Solutions.pdf|Solutions]] ([[Media:MyProjectCode.zip|MyProject Code]])
: '''Topic''': DSP (continued).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter 11 on DSP]].
: '''Assignment 6 out''': [[Media:Asst6.zip|Introduction to Digital Filtering with the PIC32]].

'''Class 15''' (Th 2/23)
: '''Quiz''': On the topic of Assignment 5. [[Media:ME333_2012_quiz6_solns.txt|Solutions]] (average 5.5/7, stdev 1.65)
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter 12 on brushed DC motors]].

'''Class 16''' (T 2/28)
: '''Assignment 6 due''': Handed out on Tues 2/21.
: '''Topic''': In-class DC motor characterization.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter 12 on brushed DC motors]].
: '''Assignment 7 out''': Motor characterization and the three problems at the end of Chapter 12.

'''Class 17''' (Th 3/1)
: '''Quiz''': On the topic of Assignment 6. You should be able to recognize the magnitude responses of the different kinds of filters, understand the impulse response of an FIR filter, understand the axes of a filter magnitude response, and understand the axes of the FFT magnitude plot (e.g., Nyquist frequency and the frequency spacing between components). [[Media:ME333_2012_quiz7_solns.txt|Solutions]] (average score 5.8/7, stdev 1.56)
: '''Topic''': DC motor control.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter 14 on DC motor control]] (updated 3/1/2012).

'''Class 18''' (T 3/6)
: '''Assignment 7 due''': Handed out on Tues 2/28.
: '''Quiz''': On the topic of Assignment 7. You should know Chapter 12.1-12.4.
: '''Topic''': Work on final demo. You should have built three circuits as indicated in email (H-bridge, current sensor, encoder reading) before class.
: '''Final demo assignment''': Demos on 3/12 and 3/14. [[Media:FinalDemo.zip|Final Project Assignment and Starter Code]]

'''Class 19''' (Th 3/8)
: '''Topic''': Time permitting: steppers and RC servos; gearing, inertia and torque, motor sizing and selection.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter 15 on steppers and RC servos]], [[Media:PIC32Chapters.pdf|Chapter 13 on gearing and motor sizing]].

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section. You can attend either demo session, but if everyone comes on Wednesday, we won't have enough room to accommodate everyone.

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

File:FinalDemo.zip

2012-03-06T07:30:40Z

JarvisSchultz: uploaded a new version of "Image:FinalDemo.zip"

ME333 Sample Code

2012-02-23T17:42:41Z

JarvisSchultz:

'''Simple PIC'''

* [[Media:simplePIC.c|simplePIC.c]]: Flashes LEDs on the NU32 unless the USER button is pressed.

'''NU32 library, header file, procdefs, and terminal comm test'''

* [[Media:NU32.c|NU32.c]]: NU32 board library.
* [[Media:NU32.h|NU32.h]]: NU32 header file.
* [[Media:procdefs.ld|procdefs.ld]]: Linker file for NU32.
* [[Media:NU32_serial_comm.c|NU32_serial_comm.c]]: Serial communication test with the terminal.
* [[Media:NU32_serial_plot.c|NU32_serial_plot.c]]: Plot data with serial communication in NU32_Utility.

'''Analog to digital'''

* [[Media:ADC_Read2.c|ADC_Read2.c]]: Reads two analog inputs repetitively and prints the results to the user's terminal.
* [[Media:ADC_Read2_LCD.c|ADC_Read2_LCD.c]] Reads two analog inputs repetitively and prints the results to the LCD.

'''Digital I/O'''

* [[Media:DIGIO_sfrs.c|DIGIO_sfrs.c]]: Digital I/O and change notification using SFR manipulation.
* [[Media:DIGI0_plib.c|DIGIO_plib.c]]: Digital I/O and change notification using the peripheral library.

'''Interrupts'''

* [[Media:INT_core_timer.c|INT_core_timer.c]]: Interrupt on core timer period match.
* [[Media:INT_ext_int.c|INT_ext_int.c]]: Interrupt on rising edge of external interrupt line INT0.

'''LCD code'''

* [[Media:LCD.c|LCD.c]]: LCD library.
* [[Media:LCD.h|LCD.h]]: LCD header file.
* [[Media:LCDtest.c|LCDtest.c]]: Test program for LCD library.

'''Output compare (PWM)'''

* [[Media:OC_PWM_nolib.c|OC_PWM_nolib.c]]: Set up PWM by setting SFRs.
* [[Media:OC_PWM_lib.c|OC_PWM_lib.c]]: Set up PWM using peripheral library functions.
* [[Media:OC_square_wave.c|OC_square_wave.c]]: Alternate between two different PWM duty cycles at 1 Hz. PWM is at 100 kHz and can be low-pass filtered to get a square wave analog output.

'''Counter/timer'''

* [[Media:TMR_16bit.c|TMR_16bit.c]]: Set up a 16-bit timer to count the PBCLK.
* [[Media:TMR_16bit_external_clocks.c|TMR_16bit_external_clocks.c]]: Count two external clock sources, such as the A and B channel from a motor encoder.

'''DSP and FFT'''
* [[Media:DSP_sample_square_wave.zip|DSP_sample_square_wave.zip]]: Examples of FIR and FFT in both MATLAB and on the PIC32.
* [[Media:DSP_mips32_fft.zip|DSP_mips32_fft.zip]]: Example of using the Q31 mips library for FFT. Contains a C source file and a header file.

File:DSP mips32 fft.zip

2012-02-23T17:41:32Z

JarvisSchultz: Small sample source and header file showing an example of using the mips32_fft library.

Small sample source and header file showing an example of using the mips32_fft library.

ME333 Sample Code

2012-02-23T04:37:53Z

JarvisSchultz:

File:DSP sample square wave.zip

2012-02-23T04:35:25Z

JarvisSchultz: A zip file containing some MATLAB code and some C code that demonstrates the use of the mips fixed-point library for DSP and FFT. MATLAB is used to generate a header file containing a square wave, and the coefficients of a high-order FIR. The FIR coeffi

A zip file containing some MATLAB code and some C code that demonstrates the use of the mips fixed-point library for DSP and FFT. MATLAB is used to generate a header file containing a square wave, and the coefficients of a high-order FIR. The FIR coefficients are used to filter the square wave using the mips library, and the results are sent to the PIC via UART1. MATLAB then generates plots comparing the PIC results and its own results.

File:ME333 winter2012 Assignment5.pdf

2012-02-14T17:14:07Z

JarvisSchultz: uploaded a new version of "Image:ME333 winter2012 Assignment5.pdf"

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-14T17:07:43Z

JarvisSchultz: /* Approximate Syllabus */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Family Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes quite a lot of example code. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|Sample Code for ME 333]]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2. [[Media:Assignment4Solutionsv2.zip|Solutions]]
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''': Sensors, op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]], [[Operational Amplifiers (Op-Amps)|wiki page on op amps]], [http://en.wikipedia.org/wiki/Operational_amplifier_applications wikipedia page on op amps]
: '''Assignment 5 out''': [[Media:ME333_winter2012_Assignment5.pdf|Simple real-time control with the PIC32]] Note that if you do not get the entire assignment done, you can turn in screenshots from your NUScope demonstrating the tasks that you did accomplish. If you do this, in the filenames, clearly indicate which section the image corresponds to.

'''Class 13''' (Th 2/16)
: '''Topic''': DSP: digital filtering, FIR, IIR, FFT, iFFT.
: '''Reading''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Assignment 5 due''': Handed out on Tues 2/14.
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Brushed DC Motor Theory]]
: '''Assignment 6 out''':

'''Class 15''' (Th 2/23)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''': DC motors.
: '''Reading''': Continued from previous class.

'''Class 16''' (T 2/28)
: '''Assignment 6 due''': Handed out on Tues 2/21.
: '''Topic''': Gearing, inertia and torque, motor sizing and selection
: '''Reading''': [[Choosing a Motor and Gearing Combination]]
: '''Assignment 7 out''':

'''Class 17''' (Th 3/1)
: '''Quiz''': On the topic of Assignment 6.
: '''Topic''': Stepper motors and RC servo motors.
: '''Reading''': From previous versions of the NU32 board: [[PIC32MX: Driving a Stepper Motor]], [[PIC32MX: Servo Control]]

'''Class 18''' (T 3/6)
: '''Assignment 7 due''': Handed out on Tues 2/28.
: '''Topic''': Serial communication.
: '''Reading''':
: '''Final demo assignment''':

'''Class 19''' (Th 3/8)
: '''Quiz'''': On the topic of Assignment 7.
: '''Topic''': Wrapup.

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section. You can attend either demo session, but if everyone comes on Wednesday, we won't have enough room to accommodate everyone.

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

File:ME333 winter2012 Assignment5.pdf

2012-02-14T16:54:07Z

JarvisSchultz: uploaded a new version of "Image:ME333 winter2012 Assignment5.pdf"

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-14T16:35:39Z

JarvisSchultz: /* Approximate Syllabus */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Family Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes quite a lot of example code. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|Sample Code for ME 333]]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2. [[Media:Assignment4Solutionsv2.zip|Solutions]]
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''': Sensors, op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]], [[Operational Amplifiers (Op-Amps)|wiki page on op amps]], [http://en.wikipedia.org/wiki/Operational_amplifier_applications wikipedia page on op amps]
: '''Assignment 5 out''': [[Media:ME333_winter2012_Assignment5.pdf|Simple real-time control with the PIC32]]

'''Class 13''' (Th 2/16)
: '''Topic''': DSP: digital filtering, FFT, iFFT.
: '''Reading''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Brushed DC Motor Theory]]
: '''Assignment 6 out''':

'''Class 15''' (Th 2/23)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''': DC motors.
: '''Reading''': Continued from previous class.

'''Class 16''' (T 2/28)
: '''Assignment 6 due''': Handed out on Tues 2/21.
: '''Topic''': Gearing, inertia and torque, motor sizing and selection
: '''Reading''': [[Choosing a Motor and Gearing Combination]]
: '''Assignment 7 out''':

'''Class 17''' (Th 3/1)
: '''Quiz''': On the topic of Assignment 6.
: '''Topic''': Stepper motors and RC servo motors.
: '''Reading''': From previous versions of the NU32 board: [[PIC32MX: Driving a Stepper Motor]], [[PIC32MX: Servo Control]]

'''Class 18''' (T 3/6)
: '''Assignment 7 due''': Handed out on Tues 2/28.
: '''Topic''': Serial communication.
: '''Reading''':
: '''Final demo assignment''':

'''Class 19''' (Th 3/8)
: '''Quiz'''': On the topic of Assignment 7.
: '''Topic''': Wrapup.

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section. You can attend either demo session, but if everyone comes on Wednesday, we won't have enough room to accommodate everyone.

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

File:ME333 winter2012 Assignment5.pdf

2012-02-14T16:33:12Z

JarvisSchultz:

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-09T17:36:26Z

JarvisSchultz: /* Reading */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Family Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes quite a lot of example code. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|Sample Code for ME 333]]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''': [[Sensor Overview|Sensors]], op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]]

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''': DSP: digital filtering, FFT, iFFT.
: '''Reading''':
: '''Assignment 6 out''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Brushed DC Motor Theory]]

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''': DC motors.
: '''Reading''': Continued from previous class.
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''': Gearing, inertia and torque, motor sizing and selection
: '''Reading''': [[Choosing a Motor and Gearing Combination]]

'''Class 17''' (Th 3/1)
: '''Topic''': Stepper motors and RC servo motors.
: '''Reading''': From previous versions of the NU32 board: [[PIC32MX: Driving a Stepper Motor]], [[PIC32MX: Servo Control]]

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''': Serial communication.
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-09T17:35:57Z

JarvisSchultz: /* Reading */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes quite a lot of example code. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|Sample Code for ME 333]]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''': [[Sensor Overview|Sensors]], op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]]

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''': DSP: digital filtering, FFT, iFFT.
: '''Reading''':
: '''Assignment 6 out''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Brushed DC Motor Theory]]

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''': DC motors.
: '''Reading''': Continued from previous class.
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''': Gearing, inertia and torque, motor sizing and selection
: '''Reading''': [[Choosing a Motor and Gearing Combination]]

'''Class 17''' (Th 3/1)
: '''Topic''': Stepper motors and RC servo motors.
: '''Reading''': From previous versions of the NU32 board: [[PIC32MX: Driving a Stepper Motor]], [[PIC32MX: Servo Control]]

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''': Serial communication.
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-09T17:35:21Z

JarvisSchultz: /* Reading */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* The old version of the [[Media:61132B_PIC32ReferenceManual.pdf|PIC32 Reference Manual]] has many more pages than the chapter-by-chapter version linked above. It includes a lot of example code as well. '''Be warned though, Microchip was not very careful when writing the sample code; some of it contains syntax errors, or values in registers that are incorrect.''' Even with this being the case, this is still a very useful document.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

[[ME333 Sample Code|Sample Code for ME 333]]

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32Chapters.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions; average 6.93/8, stdev 1.63]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26. [[Media:Assignment3Solutions.pdf|Solutions]], ave: 27.7/33, stdev 7.8
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32Chapters.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3. [[Media:ME333_2012_quiz4_solns2.c|Solutions; average 4.67/6, stdev 1.37]]
: '''Topic''': Digital I/O, counter/timers, and output compare (PWM).
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapters on digital input and output, timers, and output compare]].

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''': RC LPF (and its Bode plot) of PWM for analog output; analog input; LED and phototransistor pairs; PID control and integer math; analog input example.
: '''Reading''': [[Media:PIC32Chapters.pdf|Chapter on analog input]].
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''': [[Sensor Overview|Sensors]], op amp circuits for signal conditioning.
: '''Reading''': [[Sensor Overview]], [[Rotary Encoder]]

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''': DSP: digital filtering, FFT, iFFT.
: '''Reading''':
: '''Assignment 6 out''': [http://www.falstad.com/dfilter/directions.html A cool digital filter applet]. Background material (not required): [http://www.dspguide.com/pdfbook.htm Chapters 14-17, on FIR filters, of this pdf book], and these wikipedia pages on [http://en.wikipedia.org/wiki/Low-pass_filter low-pass filters], [http://en.wikipedia.org/wiki/Fir_filter FIR filters], [http://en.wikipedia.org/wiki/Iir_filter IIR filters], and [http://en.wikipedia.org/wiki/Fast_fourier_transform FFT].

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''': Brushed DC motor theory.
: '''Reading''': [[Brushed DC Motor Theory]]

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''': DC motors.
: '''Reading''': Continued from previous class.
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''': Gearing, inertia and torque, motor sizing and selection
: '''Reading''': [[Choosing a Motor and Gearing Combination]]

'''Class 17''' (Th 3/1)
: '''Topic''': Stepper motors and RC servo motors.
: '''Reading''': From previous versions of the NU32 board: [[PIC32MX: Driving a Stepper Motor]], [[PIC32MX: Servo Control]]

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''': Serial communication.
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

NU32: 16x2 LCD

2012-02-08T17:33:50Z

JarvisSchultz: /* LCD Hookup */

[[Image:NU32_LCD.jpg|thumb|300 px|left]] 

== Parallel LCD ==

The popular HD44780 (and compatible chipsets) can be interfaced to the NU32 PIC32 board using 11 pins for easy character output to an LCD. This can be highly useful in either debugging or generating a more complex user interface for a PIC (or other microcontroller)-based device.

This implementation of an HD44780 LCD uses 11 I/O on the PIC as output only, so it is not optimized for speed.

== LCD Hookup ==

The LCD uses the following connections with the NU32:

<table border = 1>
<tr><td>LCD Pin</td><td>PIC Pin</td></tr>
<tr><td>1 - VSS</td><td>GND</td></tr>
<tr><td>2 - VDD</td><td>+5V</td></tr>
<tr><td>3 - V0</td><td>~1.5k resistor to GND</td></tr>
<tr><td>4 - RS</td><td>G12</td></tr>
<tr><td>5 - RW</td><td>G13</td></tr>
<tr><td>6 - E</td><td>G15</td></tr>
<tr><td>7 - D0</td><td>E0</td></tr>
<tr><td>8 - D1</td><td>E1</td></tr>
<tr><td>9 - D2</td><td>E2</td></tr>
<tr><td>10 - D3</td><td>E3</td></tr>
<tr><td>11 - D4</td><td>E4</td></tr>
<tr><td>12 - D5</td><td>E5</td></tr>
<tr><td>13 - D6</td><td>E6</td></tr>
<tr><td>14 - D7</td><td>E7</td></tr>
<tr><td>15 - A</td><td>100 ohm resistor to 3.3V</td></tr>
<tr><td>16 - K</td><td>GND</td></tr>
</table>

The VEE pin on the LCD (labeled 'A') sets the contrast of the characters on the LCD. Create with a voltage around 1V using a 10k pot to get a nice contrast, or hook it to GND through a 1.5kOhm resistor, which also seems to work well.

If you power the LCD but do not send it any commands, the top row should fill with boxes. Use this to set your contrast and check that your LCD works.

The NU32 board is based on 3.3V logical outputs, which works fine for most LCDs, but this LCD must be supplied with 5V on VDD.

== LCD Commands ==

In the main.c file, before the main while loop, you must initialize the LCD
<code><pre>
setupLCD();
</pre></code>

The basic command used to write to the LCD is
<code><pre>
LCDWriteString("Hello World", 1, 2);
</pre></code>
where 1 is the first row (options are 1 or 2), and 2 is the location to start in (options 1-16). There are only 16 characters per row, so don't try to print a string with more than 16 characters!

You can clear everything on the LCD by using
<code><pre>
LCDClear(0);
</pre></code>

Write the contents of a variable using
<code><pre>
sprintf(LCD_Out_Buffer,"k = %5.2f", k);
LCDWriteString(LCD_Out_Buffer, 2, 1);
</pre></code>
LCD_Out_Buffer is a 16 element char array declared in LCD.h
Use sprintf just like in serial communication, but pay attention to the modifies to your variable.
In this case, k is a float, and we don't want to print every character in the decimal number. %5.2f means use at least 5 characters (including the .) to represent the number, but only two decimals, so we should see 12.34, not 12.345, but we could see 123.45, and _1.23, where _ is really a blank space.

== Files and Example Code ==

Include the following h and c files to your project: [[Media:NU32LCD.zip|h and c files]]

File:HW4 Interrupts and Programming.zip

2012-02-03T23:09:31Z

JarvisSchultz: uploaded a new version of "Image:HW4 Interrupts and Programming.zip"

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-02-03T15:17:59Z

JarvisSchultz: /* Approximate Syllabus */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments (including the final project). We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final project and demo in lieu of a final exam.

All quizzes and assignments have equal weight, regardless of how many points they are graded out of. If one homework is graded out of 20 points, and the next out of 40, the formula for calculating your grade for these two assignments would be 0.5*(score1/20) + 0.5*(score2/40).

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* When writing your responses, please follow any instructions on how to write your response. For example, if we ask for a snippet of code, please do not submit your entire C program with header files and a main routine. We typically are only expecting a few lines of code that solves the problem.
* When submitting written responses, we prefer PDF files, but will accept word documents (.doc, .docx), .txt, and .rtf files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]]) (ave score: 16.4/20, stdev 4.2)
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32hardware.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document [[Media:Quiz_2_soln.pdf|(Solutions)]]. (ave score: 5.6/7, stdev 1.8)
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:Simple_pic2.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19. [[Media:Assignment2Solutions.pdf|Solutions]] (ave score: 21.8/25; stdev 4.8)
: '''Topic''': Continue analyzing the Simple_pic.c program.
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''': [[Media:Assignment3v2.pdf|Investigating the PIC C32 Tool Suite (v2)]]

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2. [[Media:ME333_2012_quiz3_solns.c|Solutions]]
: '''Topic''': CPU: core timer and and interrupts.
: '''Reading''': A reading on [[Media:PIC32SoftwareAndInterrupts.pdf|PIC32 software and interrupts]] and some [[Media:core_timer_tester.c|code for working with the core timer and interrupts]].

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26.
: '''Topic''': Interrupts, cont.
: '''Reading''': Updated version of [[Media:PIC32SoftwareAndInterrupts.pdf|PIC32 software and interrupts]] (the section on interrupts has been completed), [[Media:SampleCode6-1.c|sample code 6.1]], [[Media:SampleCode6-2.c|sample code 6.2]]
: '''Assignment 4 out''': [[Media:HW4_Interrupts_and_Programming.zip|Assignment 4 on Interrupts]] The assignment is described in the pdf included with the zip file. Solutions must be uploaded to [https://courses.northwestern.edu/webapps/login/ Blackboard] by Thursday, February 9 at 11:00AM.

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3.
: '''Topic''':
: '''Reading''':

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''':
: '''Reading''':
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''':
: '''Reading''':

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''':
: '''Reading''':
: '''Assignment 6 out''':

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''':
: '''Reading''':

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''':
: '''Reading''':
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''':
: '''Reading''':

'''Class 17''' (Th 3/1)
: '''Topic''':
: '''Reading''':

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''':
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

File:HW4 Interrupts and Programming.zip

2012-02-03T15:17:14Z

JarvisSchultz: uploaded a new version of "Image:HW4 Interrupts and Programming.zip"

File:HW4 Interrupts and Programming.zip

2012-02-03T15:10:35Z

JarvisSchultz:

File:Core timer tester.c

2012-01-31T17:09:46Z

JarvisSchultz: uploaded a new version of "Image:Core timer tester.c"

File:Core timer tester.c

2012-01-31T17:04:03Z

JarvisSchultz: uploaded a new version of "Image:Core timer tester.c"

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-01-24T17:42:10Z

JarvisSchultz: /* Homework Submission */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments. We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final demo in lieu of a final exam.

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Alt+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]])
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32hardware.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document.
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:simple_pic.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19.
: '''Topic''':
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''':

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2.
: '''Topic''':
: '''Reading''':

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26.
: '''Topic''':
: '''Reading''':
: '''Assignment 4 out''':

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3.
: '''Topic''':
: '''Reading''':

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''':
: '''Reading''':
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''':
: '''Reading''':

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''':
: '''Reading''':
: '''Assignment 6 out''':

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''':
: '''Reading''':

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''':
: '''Reading''':
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''':
: '''Reading''':

'''Class 17''' (Th 3/1)
: '''Topic''':
: '''Reading''':

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''':
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2012-01-24T17:31:15Z

JarvisSchultz: /* Grading */

'''Winter Quarter 2012'''

(Here is an [[ME 333 Introduction to Mechatronics (Archive Winter 2011)|Archive of Winter 2011]])

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Circuits Review Session: Mon Jan 9, 7 PM, Prof. Lynch, Tech L221; Wed Jan 11, 7 PM, Prof. Marchuk, Tech L221
* C Peer Instruction Sessions, 7-8:30 PM, Seeley-Mudd Engineering Library Room 230
** Thurs Jan 12
** Tues Jan 17
** Wed Jan 18
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM
* Office Hours:
** Mon 4-6 PM: Jarvis Schultz, Mechatronics Lab, Ford B100
** Tues 2-3 PM: Prof. Lynch, B221
** Wed 3-5 PM: Nelson Rosa, Mechatronics Lab, Ford B100
**Thurs 3-4 PM: Prof. Lynch, B221
** Fri 3-4 PM: Prof. Marchuk, Mechatronics Lab, Ford B100
** Mon-Fri 4-5 PM: Prof. Marchuk, Mechatronics Lab, Ford B100

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope.
* Buy your class kit [http://it.mccormick.northwestern.edu/matlab/student_license/login.php '''here''']. If you already have the oscilloscope and multimeter from this year's ME 233 offering, you should choose "ME 333 (w/o ME 233 equipment)" for the price of $75. If you do not have the oscilloscope and multimeter, you should choose "ME 333 (w/ ME 233 equipment)" for the price of $135. You will not be able to start the course until you have completed the purchase of your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.
* '''If you are not already comfortable with the C language, or if you do not already have a C compiler installed on your laptop, this step is recommended before the first day of class. This will give you a headstart on learning C. If you don't complete this before the first day of class, you will need to do it before the second class.''' Download and install the GCC GNU compiler collection and the Netbeans IDE (Integrated Development Environment) following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run the sample programs at the end of that page. Read the comments in invest.c to find references to the [[Media:CrashCourseinC.pdf|Crash Course in C document]] and answer the questions to learn more about C. '''If you have problems installing a C compiler and running the programs, then you can still get a headstart before the first class by focusing on reading the C programs and the Crash Course in C manual to understand how they work.'''


== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the third day of class, but you are on your own to prepare for it, apart from one review class and some night review sessions. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:CrashCourseinC.pdf|A Crash Course in C]]: A brief introduction to the C programming language
([[Media:EssentialC.pdf|Essential C]] is also a very nice intro to C)
* handouts associated with individual classes
* wiki info on [[Microchip PICs]]
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (256 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments. We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. (Your lowest quiz score and homework score will be dropped.) We will have a final demo in lieu of a final exam.

== Homework Submission ==
All homework will be submitted on Blackboard. Here are a few guidelines/ tips associated with homework submissions:
* We expect the required files for each assignment to be compressed together in a zip file (no rar files).
* When asked to submit C code for a given programming assignment, we are only concerned with receiving the relevant source files i.e. all *.c and *.h files. We do not want entire NetBeans/MPLAB X projects or executables/object files.
* It helps both us and you if you format your code nicely. Clean looking code is easier for us to grade and easier for you to debug. Both NetBeans and MPLAB X (as well as other good editors) have tools for auto-formatting code. For example, highlighting a region and hitting Ctrl+Shift+f (Linux and Windows) will format that region according to your local formatting preferences.
* When you compile your code (by clicking the hammer in NetBeans/MPLAB X), the output window in the IDE shows any compiler warnings. Pay attention to these! They are there for a reason. You should be able to eventually get your code to produce no warnings. Often if a piece of code is not working, the warnings will give a clue as to why. Note that in "project properties" in both IDEs, it is possible to generate "Additional warnings." This tells your compiler to be more strict about the rules of C. The better you adhere to these rules, the more likely it is that your code will compile.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32: Introduction to the PIC32|NU32 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1''' (Th 1/5)
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.
: '''Assignment out''': If you do not already have a C compiler, install a C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. For all students: compile and run the tutorial code [[Installing_a_C_Compiler_and_IDE#Tutorial_Sample_Code|here]] and begin to understand it.

'''Class 2''' (T 1/10)
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling and linking).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).

'''Class 3''' (Th 1/12)
: '''Quiz''': Circuits. ([[Media:ME333_Quiz1_2012_Solutions.pdf|Solutions]]; high score 45/46, average 33.4, stdev 7.8)
: '''Topic''': Introduction to C (syntax). We will compile and run programs together in this class, so bring your laptop with your installed C compiler and IDE.
: '''Reading''': Continue with [[Media:invest.c|sample program]], [[Media:CrashCourseinC.pdf|A Crash Course in C]] (section numbers referenced in program comments).
: '''Assignment 1 out''': '''Problems 1-6 and 9''' of [[Media:CrashCourseinC.pdf|A Crash Course in C]] (v0.2 of Thurs, Jan 12). Due by electronic submission by 11 AM Thurs 1/19. Solutions to problems 1-6 must be typed. Place these solutions, plus your .c file from the programming assignment (problem 9), in a .zip file and submit the zip file through [https://courses.northwestern.edu/webapps/login/ Blackboard]. The name of your zip file should be Lastname_Firstname_a1.zip. You will also demonstrate your program in class on Thurs 1/19. For full credit, you must follow these instructions exactly.

'''Class 4''' (T 1/17)
: '''Topic''': Introduction to C (syntax).
: '''Reading''':
: '''Assignment out''':

'''Class 5''' (Th 1/19)
: '''Assignment 1 due''': Handed out on Thurs 1/12. [[Media:Assignment1Solutions.pdf|Solutions]] ([[Media:lightbulbs.c|lightbulbs.c]])
: '''Topic''': The PIC32 microcontroller hardware.
: '''Reading''': [[Media:PIC32hardware.pdf|PIC 32 hardware handout]], Data Sheet, Reference Manual
: '''Assignment 2 out''': Complete the questions at the end of the reading. Solutions must be submitted by blackboard at [https://courses.northwestern.edu/webapps/login/ Blackboard] by 11 AM Thurs 1/26. The name of your zip file should be Lastname_Firstname_a2.zip. You will also demo your NUscope and PIC32 in class on 1/26.

'''Class 6''' (T 1/24)
: '''Quiz''': On the topic of Assignment 1, particularly Section 1.1 and Sections 1.2.5-1.2.8 of the CCC document.
: '''Topic''': virtual and physical memory, NU32 board, beginning PIC32 programming, digital I/O SFRs
: '''Reading''': [[Media:PIC32_Ref_Man_Sec_12_IO_Ports.pdf|PIC32 Family Reference Manual Section 12, I/O Ports]]. This version is clearer than the current version on Microchip's website. We will discuss [[Media:simple_pic.c|this simple PIC program]]. Also, [[NU32: A Detailed Look at Programming the PIC32 on the NU32]].

'''Class 7''' (Th 1/26)
: '''Assignment 2 due''': Handed out on Thurs 1/19.
: '''Topic''':
: '''Reading''': Continued from previous class.
: '''Assignment 3 out''':

'''Class 8''' (T 1/31)
: '''Quiz''': On the topic of Assignment 2.
: '''Topic''':
: '''Reading''':

'''Class 9''' (Th 2/2)
: '''Assignment 3 due''': Handed out on Thurs 1/26.
: '''Topic''':
: '''Reading''':
: '''Assignment 4 out''':

'''Class 10''' (T 2/7)
: '''Quiz''': On the topic of Assignment 3.
: '''Topic''':
: '''Reading''':

'''Class 11''' (Th 2/9)
: '''Assignment 4 due''': Handed out on Thurs 2/2.
: '''Topic''':
: '''Reading''':
: '''Assignment 5 out''':

'''Class 12''' (T 2/14)
: '''Quiz''': On the topic of Assignment 4.
: '''Topic''':
: '''Reading''':

'''Class 13''' (Th 2/16)
: '''Assignment 5 due''': Handed out on Thurs 2/9.
: '''Topic''':
: '''Reading''':
: '''Assignment 6 out''':

'''Class 14''' (T 2/21)
: '''Quiz''': On the topic of Assignment 5.
: '''Topic''':
: '''Reading''':

'''Class 15''' (Th 2/23)
: '''Assignment 6 due''': Handed out on Thurs 2/16.
: '''Topic''':
: '''Reading''':
: '''Assignment 7 out''':

'''Class 16''' (T 2/28)
: '''Quiz''': On the topic of Assignment 6
: '''Topic''':
: '''Reading''':

'''Class 17''' (Th 3/1)
: '''Topic''':
: '''Reading''':

'''Class 18''' (T 3/6)
: '''Quiz''': yes
: '''Topic''':
: '''Reading''':

'''Class 19''' (Th 3/8)
: '''Topic''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

NU32: Serial Communication with the PC

2012-01-24T16:32:42Z

JarvisSchultz: /* Python */

The NU32 has the ability to talk directly with a computer over a virtual serial port connection. This ability can be used to debug code, transfer data, and interact with the microcontroller using a computer.

== Overview ==

The NU32 uses an on board [http://www.ftdichip.com/Products/ICs/FT2232H.htm FT2232H] chip from FTDI to convert [http://en.wikipedia.org/wiki/RS-232 RS-232 TTL serial communication] to USB. Using drivers from FTDI, the communication can be opened by any program that can access a [http://en.wikipedia.org/wiki/Serial_port virtual serial port]. On the NU32, sample code has been created to enable the UART module on the PIC32. Using this code you can write strings to the computer, and generate an interrupt when characters are received. On the computer, several programs that can access the serial connection are discussed, including Processing, MATLAB, Python, and terminal programs.

== Details ==
The FT2232H chip is hardwired the to UART1 (F2 and F8, for general communication) and UART4 (D14 and D15, for bootloading) modules on the PIC32MX795F512L. The Receive (RX) pins, F2 and D14, and Transmit (TX) pins, F8 and D15, are also brought out to the sides of the NU32 board. '''They should not be used as general IO.'''

Serial communication is asynchronous, it does not use an external clock signal to know when to read individual bits. Instead, the sender and receiver decide beforehand what frequency to transmit data. This frequency is called the baud rate and must match on both the NU32 and computer for the data to be interpreted correctly.

The NU32 uses the UART1 and UART4 modules at 115200 baud, as does the sample code below.

== Library Functions ==
[[Media:NU32_serial_example.zip | This code]] contains functions to read characters and write strings over the serial port. It uses the same header files as "Hello World".
*NU32.c contains the functions to initialize the LEDs and USER button on the NU32 board, and to initialize the UART modules.
*NU32.h contains function prototypes for the .c file.
**'''You do not need to modify these files to use serial communication.'''

The functions that control the serial communication are:
*void initSerialNU32(void) - enables UART1 and UART4 at 115200 baud with an interrupt at priority level 2 and 3
*void WriteString(UART_MODULE, const char *) - call with UART1 and the character array you wish to send
*void PutCharacter(UART_MODULE, const char) - writes an individual character to the computer when the module is able to, called by WriteString()

NU32_serial_example.c in the .zip file above demonstrates how to use the functions.

== Sample Code ==

To initialize the serial communication, call initSerialNU32():

<pre>
initSerialNU32();
</pre>

To write a string to the computer, use WriteString(UART1, charArray). The special characters '\r' and '\n' are carriage return and newline. Using them together puts the cursor on the next line.

<pre>
WriteString(UART1, "\r\nHello World!\r\n");
</pre>

To write a string with the value of a variable in it, use sprintf(RS232_Out_Buffer,charArray) and WriteString(UART1, charArray). RS232_Out_Buffer is declared in NU32.h as a char array with 32 elements.

<pre>
sprintf(RS232_Out_Buffer, "the value of i is: %d\r\n", i);
WriteString(UART3, RS232_Out_Buffer);
</pre>

To receive characters in an interrupt, use this interrupt service routine (ISR):

<pre>
void __ISR(_UART_1_VECTOR, ipl2) IntUart1Handler(void) {
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART1))){
char data = UARTGetDataByte(UART1);

// now do something with data

// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART1));
}

// If the interrupt was on TX (ignore it)
if(INTGetFlag(INT_SOURCE_UART_TX(UART1))) {
INTClearFlag(INT_SOURCE_UART_TX(UART1));
}
}
</pre>

NU32_serial_example.c initializes the serial communication, and then waits until it receives the character 'a' from the computer. When it gets an 'a', it replies back with numbers 0 through 9, each on their own line, and then waits for another 'a'.

<pre>
//////LIBRARIES
#include <plib.h> // for PIC specific functions
#include "NU32.h" // for NU32 board specific functions

//////GLOBAL VARIABLES

//////FUNCTION PROTOTYPES

//////MAIN
int main(void)
{
startup(); // from NU32.c, maximizes performance
initialize(); // from NU32.c, inits USER, L1 and L2, serial fns

// infinite loop
while(1)
{
// nothing, do everything in the UART1 ISR
}
return 0;
}

//////FUNCTIONS

//////ISRs
// interrupt when the NU32 gets a character from the computer
void __ISR(_UART_1_VECTOR, ipl2) IntUart1Handler(void)
{
int i = 0;

// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART1)))
{
// read the byte
char data = UARTGetDataByte(UART1);

// if the byte is an 'a', send back 0-9
if (data == 'a') {
for (i=0; i<10; i++) {
sprintf(RS232_Out_Buffer,"%d\r\n", i);
WriteString(UART1, RS232_Out_Buffer);
}
}

// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART1));
}

// We don't care about TX interrupt
if(INTGetFlag(INT_SOURCE_UART_TX(UART1)))
{
INTClearFlag(INT_SOURCE_UART_TX(UART1));
}
}
</pre>

== Communicating with NU32_Utility ==
The right hand side of the NU32_Utility program is a debugger that will display any character received from the 'Debug' port, and will send any characters in the text entry using 'Send'.

Compile the code and put it on your NU32. Send an 'a' with the debugger and you should see the following:

[[Image:NU32_utility_serial_ex.png|thumb|300 px|left]] 

== Communicating with a Terminal Program ==
The NU32_Utility debugger is based on a more traditional [http://en.wikipedia.org/wiki/Terminal_emulator Terminal emulator] program. Terminal programs let you choose the baud rate, flow control, and many other aspects of serial communication, and let you view the incoming bytes as ASCII text or hex bytes. A Terminal program is useful when you want to see hidden characters that the NU32_Utility can not display.

On Windows, you can use [http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY] or [http://realterm.sourceforge.net/index.html#downloads_Download RealTerm].

On a MAC, you can use [http://www.iterm2.com/#/section/home iTerm2].

In Linux people commonly use [https://help.ubuntu.com/community/Minicom minicom] or [https://fedorahosted.org/gtkterm/ gtkterm].

When you use a Terminal program, make sure that you know the communication port name and baud before opening the program. '''Also be sure that the port is not already open in another program. A port can only be open in one place at a time!'''

The Terminal programs vary in use, but for example, launch Putty.exe. Set up your communication by:
*Selecting the 'Serial' radio button

Select the 'Serial' branch in the tree on the bottom left.
*Enter the name of your COM port in 'Serial line to connect to'
*Enter 115200 in 'Speed (baud)'
*Change 'Flow control' from 'XON/XOFF' to 'None'

Go back to the 'Session' screen by selecting the 'Session' in the top left of the tree.
*Name your settings in 'Saved Sessions' and click 'Save'
*Click the 'Open' button

Type an 'a'. Notice you do not get to see what you typed in! In this case it would be the responsibility of the NU32 to echo back any characters it receives so that you can verify what was typed in.

[[Image:PuTTY_serial_ex.png|thumb|300 px|left]] 

== Processing ==
[http://processing.org/ Processing] is a free IDE that is easy to use, makes nice graphics, and easily performs serial communication. The NU32_Utility was written in Processing.
'''See the [[Processing]] page for more specific information on Processing.'''

The following code is a simple Processing sketch that will open a serial port, print any characters received to the Debug window, and send an 'a' if a key on the keyboard is pressed and released:

<pre>
// Based on the SimpleRead example
import processing.serial.*;

Serial myPort; // Create object from Serial class

// setup() runs first but only once, use it to initialize things
void setup()
{
size(200, 200); // the size of the Processing window in pixels
background(255); // Set background to white
println(Serial.list()); // print all of the serial ports that
// are available, you need to know what
// port to open in the next line
// guess which port to open, if you get it wrong rerun the progam
// after changing which port you open
String portName = Serial.list()[1];
myPort = new Serial(this, portName, 115200); // open the port
}

// draw runs at 30fps (default)
void draw()
{
if ( myPort.available() > 0) { // If data is available,
println(myPort.read()); // read it and store it in val
}
}

// if a key is pressed, on release send an 'a'
void keyReleased() {
myPort.write('a');
}
</pre>

The following is output in the Debug window:
[[Image:Processing_serial_ex1.png|thumb|300 px|left]] 

What is that? Note that there are 30 characters. Processing has printed the decimal value of each character received!

Try something else- Processing has the ability to check for incoming characters in parallel to running code in the Draw() routine:

<pre>
// Based on the SimpleRead example
import processing.serial.*;

Serial myPort; // Create object from Serial class

// setup() runs first but only once, use it to initialize things
void setup()
{
size(200, 200); // the size of the Processing window in pixels
background(255); // Set background to white
println(Serial.list()); // print all of the serial ports that
// are available, you need to know what
// port to open in the next line
// guess which port to open, if you get it wrong rerun the progam
// after changing which port you open
String portName = Serial.list()[1];
myPort = new Serial(this, portName, 115200); // open the port
}

// draw runs at 30fps (default)
void draw()
{
// nothing, do it in the serialEvent
}

void serialEvent(Serial thisPort) {
// read a byte from the port:
int inByte = thisPort.read();
println((char)inByte);
}

// if a key is pressed, on release send an 'a'
void keyReleased() {
myPort.write('a');
}

</pre>

[[Image:Processing_serial_ex2.png|thumb|300 px|left]] 

Using
<pre>
int inByte = thisPort.read();
println((char)inByte);
</pre>
shows the actual ASCII values for the numbers, but the '\r' and '\n' are not displayed! This is why it is sometimes nice to use the Terminal emulator.

== MATLAB ==
MATLAB can open a serial port and send and receive data as well. This is useful when you need to plot data, perform a complicated mathematical function, or error check a function that you wrote in C to the function in MATLAB.

To open a port in MATLAB, be sure to check if ports were not closed correctly, then try to open them:

<pre>
% check to see if any ports are open
% matlab is easily hung up if
% the port is already open
if ~isempty(instrfind)
fclose(instrfind);
delete(instrfind);
end

% open up the port
COM = serial('COM14');
set(COM,'BaudRate',115200);
set(COM,'OutputBufferSize',100);
% set how long to wait when
% doing fscanf
set(COM,'Timeout',20);
fopen(COM);
</pre>

To send data:

<pre>
fwrite(COM,'a');
</pre>

To receive data:

<pre>
reading = fscanf(COM,'%i');
</pre>

Put together, the code looks like:

<pre>
% clear the screen and memory
clc;
clear;

% check to see if any ports are open
% matlab is easily hung up if
% the port is already open
if ~isempty(instrfind)
fclose(instrfind);
delete(instrfind);
end

% open up the port
COM = serial('COM14');
set(COM,'BaudRate',115200);
set(COM,'OutputBufferSize',100);
% set how long to wait when
% doing fscanf
set(COM,'Timeout',20);
fopen(COM);

% send an 'a'
fwrite(COM,'a');
% print to the screen
% that we sent an 'a'
disp('sent a');

% we know to expect 10 numbers
i = 0;
while (i<10)
% read the number and print
% to the screen
reading = fscanf(COM,'%i');
disp(num2str(reading));
i = i+1;
end

% be sure to close the port
fclose(COM);
disp('done');
</pre>

The result looks like:
[[Image:Matlab_serial_ex.png|thumb|300 px|left]] 

== Python ==
For those familiar with Python, its [http://pyserial.sf.net/ serial library] can provide several useful, platform-independent functions for interfacing with the NU32 board. The latest installation comes with a terminal emulator written in Python called [http://pyserial.sourceforge.net/examples.html#miniterm miniterm] (source code [http://pyserial.svn.sourceforge.net/viewvc/*checkout*/pyserial/trunk/pyserial/serial/tools/miniterm.py here]). To run miniterm with the NU32 you would run a command on the command line similar to

<pre>
python miniterm.py -p COM7 -b 115200 -e
</pre>

Note that the argument after the "-p" will be different depending on which port the NU32 is attached to on your computer. On a MAC it would be something like "/DEV/TTY.USBSERIAL-000030FDA" and in Linux it might be "/dev/ttyUSB0". Also note that the "-e" argument is for turning on local echo. In other words, when you hit a key it will show up in the output window.

The following is a piece of sample Python code that replicates the other serial examples from above:

<pre>
## First we import the system module
import sys

## First thing that we need to do is import the serial library:
try:
import serial
except ImportError:
print "[FATAL] Serial library not found"
sys.exit(0)

## open comm port
com = serial.Serial('COM7',baudrate=115200)

## send 'a' character
com.write('a')
print "sent 'a'"

## read in values sent by PIC
data = com.read(30) ## we read 30 characters because Python counts the
## \n and \r as characters
print "Incoming data:"
print data

## close serial port:
com.close()
</pre>

== More Information ==

NA

NU32: Serial Communication with the PC

2012-01-24T16:09:02Z

JarvisSchultz: /* Python */

NU32: Serial Communication with the PC

2012-01-24T15:54:09Z

JarvisSchultz: /* MATLAB */

NU32: Serial Communication with the PC

2012-01-24T15:52:13Z

JarvisSchultz: /* Overview */

NU32: Serial Communication with the PC

2012-01-24T15:48:02Z

JarvisSchultz: /* Communicating with a Terminal Program */

The NU32 has the ability to talk directly with a computer over a virtual serial port connection. This ability can be used to debug code, transfer data, and interact with the microcontroller using a computer.

== Overview ==

The NU32 uses an on board [http://www.ftdichip.com/Products/ICs/FT2232H.htm FT2232H] chip from FTDI to convert [http://en.wikipedia.org/wiki/RS-232 RS-232 TTL serial communication] to USB. Using drivers from FTDI, the communication can be opened by any program that can access a [http://en.wikipedia.org/wiki/Serial_port virtual serial port]. On the NU32, sample code has been created to enable the UART module on the PIC32. Using this code you can write strings to the computer, and generate an interrupt when characters are received. On the computer, several programs that can access the serial connection are discussed, including Processing, MATLAB, and terminal programs.

== Details ==
The FT2232H chip is hardwired the to UART1 (F2 and F8, for general communication) and UART4 (D14 and D15, for bootloading) modules on the PIC32MX795F512L. The Receive (RX) pins, F2 and D14, and Transmit (TX) pins, F8 and D15, are also brought out to the sides of the NU32 board. '''They should not be used as general IO.'''

Serial communication is asynchronous, it does not use an external clock signal to know when to read individual bits. Instead, the sender and receiver decide beforehand what frequency to transmit data. This frequency is called the baud rate and must match on both the NU32 and computer for the data to be interpreted correctly.

The NU32 uses the UART1 and UART4 modules at 115200 baud, as does the sample code below.

== Library Functions ==
[[Media:NU32_serial_example.zip | This code]] contains functions to read characters and write strings over the serial port. It uses the same header files as "Hello World".
*NU32.c contains the functions to initialize the LEDs and USER button on the NU32 board, and to initialize the UART modules.
*NU32.h contains function prototypes for the .c file.
**'''You do not need to modify these files to use serial communication.'''

The functions that control the serial communication are:
*void initSerialNU32(void) - enables UART1 and UART4 at 115200 baud with an interrupt at priority level 2 and 3
*void WriteString(UART_MODULE, const char *) - call with UART1 and the character array you wish to send
*void PutCharacter(UART_MODULE, const char) - writes an individual character to the computer when the module is able to, called by WriteString()

NU32_serial_example.c in the .zip file above demonstrates how to use the functions.

== Sample Code ==

To initialize the serial communication, call initSerialNU32():

<pre>
initSerialNU32();
</pre>

To write a string to the computer, use WriteString(UART1, charArray). The special characters '\r' and '\n' are carriage return and newline. Using them together puts the cursor on the next line.

<pre>
WriteString(UART1, "\r\nHello World!\r\n");
</pre>

To write a string with the value of a variable in it, use sprintf(RS232_Out_Buffer,charArray) and WriteString(UART1, charArray). RS232_Out_Buffer is declared in NU32.h as a char array with 32 elements.

<pre>
sprintf(RS232_Out_Buffer, "the value of i is: %d\r\n", i);
WriteString(UART3, RS232_Out_Buffer);
</pre>

To receive characters in an interrupt, use this interrupt service routine (ISR):

<pre>
void __ISR(_UART_1_VECTOR, ipl2) IntUart1Handler(void) {
// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART1))){
char data = UARTGetDataByte(UART1);

// now do something with data

// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART1));
}

// If the interrupt was on TX (ignore it)
if(INTGetFlag(INT_SOURCE_UART_TX(UART1))) {
INTClearFlag(INT_SOURCE_UART_TX(UART1));
}
}
</pre>

NU32_serial_example.c initializes the serial communication, and then waits until it receives the character 'a' from the computer. When it gets an 'a', it replies back with numbers 0 through 9, each on their own line, and then waits for another 'a'.

<pre>
//////LIBRARIES
#include <plib.h> // for PIC specific functions
#include "NU32.h" // for NU32 board specific functions

//////GLOBAL VARIABLES

//////FUNCTION PROTOTYPES

//////MAIN
int main(void)
{
startup(); // from NU32.c, maximizes performance
initialize(); // from NU32.c, inits USER, L1 and L2, serial fns

// infinite loop
while(1)
{
// nothing, do everything in the UART1 ISR
}
return 0;
}

//////FUNCTIONS

//////ISRs
// interrupt when the NU32 gets a character from the computer
void __ISR(_UART_1_VECTOR, ipl2) IntUart1Handler(void)
{
int i = 0;

// Is this an RX interrupt?
if(INTGetFlag(INT_SOURCE_UART_RX(UART1)))
{
// read the byte
char data = UARTGetDataByte(UART1);

// if the byte is an 'a', send back 0-9
if (data == 'a') {
for (i=0; i<10; i++) {
sprintf(RS232_Out_Buffer,"%d\r\n", i);
WriteString(UART1, RS232_Out_Buffer);
}
}

// Clear the RX interrupt Flag
INTClearFlag(INT_SOURCE_UART_RX(UART1));
}

// We don't care about TX interrupt
if(INTGetFlag(INT_SOURCE_UART_TX(UART1)))
{
INTClearFlag(INT_SOURCE_UART_TX(UART1));
}
}
</pre>

== Communicating with NU32_Utility ==
The right hand side of the NU32_Utility program is a debugger that will display any character received from the 'Debug' port, and will send any characters in the text entry using 'Send'.

Compile the code and put it on your NU32. Send an 'a' with the debugger and you should see the following:

[[Image:NU32_utility_serial_ex.png|thumb|300 px|left]] 

== Communicating with a Terminal Program ==
The NU32_Utility debugger is based on a more traditional [http://en.wikipedia.org/wiki/Terminal_emulator Terminal emulator] program. Terminal programs let you choose the baud rate, flow control, and many other aspects of serial communication, and let you view the incoming bytes as ASCII text or hex bytes. A Terminal program is useful when you want to see hidden characters that the NU32_Utility can not display.

On Windows, you can use [http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html PuTTY] or [http://realterm.sourceforge.net/index.html#downloads_Download RealTerm].

On a MAC, you can use [http://www.iterm2.com/#/section/home iTerm2].

In Linux people commonly use [https://help.ubuntu.com/community/Minicom minicom] or [https://fedorahosted.org/gtkterm/ gtkterm].

When you use a Terminal program, make sure that you know the communication port name and baud before opening the program. '''Also be sure that the port is not already open in another program. A port can only be open in one place at a time!'''

The Terminal programs vary in use, but for example, launch Putty.exe. Set up your communication by:
*Selecting the 'Serial' radio button

Select the 'Serial' branch in the tree on the bottom left.
*Enter the name of your COM port in 'Serial line to connect to'
*Enter 115200 in 'Speed (baud)'
*Change 'Flow control' from 'XON/XOFF' to 'None'

Go back to the 'Session' screen by selecting the 'Session' in the top left of the tree.
*Name your settings in 'Saved Sessions' and click 'Save'
*Click the 'Open' button

Type an 'a'. Notice you do not get to see what you typed in! In this case it would be the responsibility of the NU32 to echo back any characters it receives so that you can verify what was typed in.

[[Image:PuTTY_serial_ex.png|thumb|300 px|left]] 

== Processing ==
[http://processing.org/ Processing] is a free IDE that is easy to use, makes nice graphics, and easily performs serial communication. The NU32_Utility was written in Processing.
'''See the [[Processing]] page for more specific information on Processing.'''

The following code is a simple Processing sketch that will open a serial port, print any characters received to the Debug window, and send an 'a' if a key on the keyboard is pressed and released:

<pre>
// Based on the SimpleRead example
import processing.serial.*;

Serial myPort; // Create object from Serial class

// setup() runs first but only once, use it to initialize things
void setup()
{
size(200, 200); // the size of the Processing window in pixels
background(255); // Set background to white
println(Serial.list()); // print all of the serial ports that
// are available, you need to know what
// port to open in the next line
// guess which port to open, if you get it wrong rerun the progam
// after changing which port you open
String portName = Serial.list()[1];
myPort = new Serial(this, portName, 115200); // open the port
}

// draw runs at 30fps (default)
void draw()
{
if ( myPort.available() > 0) { // If data is available,
println(myPort.read()); // read it and store it in val
}
}

// if a key is pressed, on release send an 'a'
void keyReleased() {
myPort.write('a');
}
</pre>

The following is output in the Debug window:
[[Image:Processing_serial_ex1.png|thumb|300 px|left]] 

What is that? Note that there are 30 characters. Processing has printed the decimal value of each character received!

Try something else- Processing has the ability to check for incoming characters in parallel to running code in the Draw() routine:

<pre>
// Based on the SimpleRead example
import processing.serial.*;

Serial myPort; // Create object from Serial class

// setup() runs first but only once, use it to initialize things
void setup()
{
size(200, 200); // the size of the Processing window in pixels
background(255); // Set background to white
println(Serial.list()); // print all of the serial ports that
// are available, you need to know what
// port to open in the next line
// guess which port to open, if you get it wrong rerun the progam
// after changing which port you open
String portName = Serial.list()[1];
myPort = new Serial(this, portName, 115200); // open the port
}

// draw runs at 30fps (default)
void draw()
{
// nothing, do it in the serialEvent
}

void serialEvent(Serial thisPort) {
// read a byte from the port:
int inByte = thisPort.read();
println((char)inByte);
}

// if a key is pressed, on release send an 'a'
void keyReleased() {
myPort.write('a');
}

</pre>

[[Image:Processing_serial_ex2.png|thumb|300 px|left]] 

Using
<pre>
int inByte = thisPort.read();
println((char)inByte);
</pre>
shows the actual ASCII values for the numbers, but the '\r' and '\n' are not displayed! This is why it is sometimes nice to use the Terminal emulator.

== MATLAB ==
MATLAB can open a serial port and send and receive data as well. This is useful when you need to plot data, perform a complicated mathematical function, or error check a function that you wrote in C to the function in MATLAB.

To open a port in MATLAB, be sure to check if ports were not closed correctly, then try to open them:

<pre>
% check to see if any ports are open
% matlab is easily hung up if
% the port is already open
if ~isempty(instrfind)
fclose(instrfind);
delete(instrfind);
end

% open up the port
COM = serial('COM14');
set(COM,'BaudRate',115200);
set(COM,'OutputBufferSize',100);
% set how long to wait when
% doing fscanf
set(COM,'Timeout',20);
fopen(COM);
</pre>

To send data:

<pre>
fwrite(COM,'a');
</pre>

To receive data:

<pre>
reading = fscanf(COM,'%i');
</pre>

Put together, the code looks like:

<pre>
% clear the screen and memory
clc;
clear;

% check to see if any ports are open
% matlab is easily hung up if
% the port is already open
if ~isempty(instrfind)
fclose(instrfind);
delete(instrfind);
end

% open up the port
COM = serial('COM14');
set(COM,'BaudRate',115200);
set(COM,'OutputBufferSize',100);
% set how long to wait when
% doing fscanf
set(COM,'Timeout',20);
fopen(COM);

% send an 'a'
fwrite(COM,'a');
% print to the screen
% that we sent an 'a'
disp('sent a');

% we know to expect 10 numbers
i = 0;
while (i<10)
% read the number and print
% to the screen
reading = fscanf(COM,'%i');
disp(num2str(reading));
i = i+1;
end

% be sure to close the port
fclose(COM);
disp('done');
</pre>

The result looks like:
[[Image:Matlab_serial_ex.png|thumb|300 px|left]] 

== More Information ==

NA

Installing a C Compiler and IDE

2012-01-12T18:49:42Z

JarvisSchultz: /* Setting up the IDE */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free Apple Developer membership.

If you are running Mac OSX 10.7 (commonly known as Lion), you will download Xcode 4 from the Mac App Store. If you are running Mac OSX 10.6 or earlier, you will download Xcode 3. The .dmg download for Xcode 3 is available directly from the box on the left hand side of [http://developer.apple.com/xcode the Xcode page].

If you are not yet an Apple Developer, which is necessary to download Xcode, you can sign up for free [http://developer.apple.com/programs/register here] by filling out the questionnaire.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''Note to Windows users:''' When deciding between 6.9 and 7.0 versions, you should
read the notes directly under the "Hello World" test program in the
[[Installing a C Compiler and IDE#Test Programs| Test Programs]] section of this page.
Even though 6.9 is older you may be interested in installing it instead.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options" '''(Mac users: go to Netbeans>Preferences>Editor)'''
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well. As far as I can tell, this is only an issue in versions of NetBeans newer than 7.0, and it may be quite annoying as it seems there is no way to set this to a default. If you are bothered by it, consider installing a slightly older version of NetBeans (such as 6.9).

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several simple sample programs to get you started with
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen. This is the output of running the executable version:
<pre>
This is a simple message
The value of the variable c is: c.
The value of the variable i is: 25.
The value of the variable f is: 12.500000.
Again, the values are: c = c, i = 25, and f = 12.500000.
</pre>
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, and loops. This is the output:
<pre>
The value of i is 0 and 0/2 is 0.000000.
The value of i is 1 and 1/2 is 0.500000.
The value of i is 2 and 2/2 is 1.000000.
The value of i is 3 and 3/2 is 1.500000.
The value of i is 4 and 4/2 is 2.000000.
</pre>
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] for further reading. Below is some sample output. You should be able to understand each step of the program to see how this output is produced.
<pre>
Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 5
Valid input? 1

RESULTS:

Year 0: 1000.00
Year 1: 1050.00
Year 2: 1102.50
Year 3: 1157.62
Year 4: 1215.51
Year 5: 1276.28

Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 500
Valid input? 0
Invalid input; exiting.

Casting example.
Ratio, 5/2: 2.00
Ratio, 5/((float) 2): 2.50
Ratio, ((float) 5)/((float) 2): 2.50
</pre>

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2012-01-12T18:49:10Z

JarvisSchultz: /* Setting up the IDE */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free Apple Developer membership.

If you are running Mac OSX 10.7 (commonly known as Lion), you will download Xcode 4 from the Mac App Store. If you are running Mac OSX 10.6 or earlier, you will download Xcode 3. The .dmg download for Xcode 3 is available directly from the box on the left hand side of [http://developer.apple.com/xcode the Xcode page].

If you are not yet an Apple Developer, which is necessary to download Xcode, you can sign up for free [http://developer.apple.com/programs/register here] by filling out the questionnaire.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.
'''Note to Windows users:''' When deciding between 6.9 and 7.0 versions, you should
read the notes directly under the "Hello World" test program in the
[[Installing a C Compiler and IDE#Test Programs| Test Programs]] section of this page.
Even though 6.9 is older you may be interested in installing it instead.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options" '''(Mac users: go to Netbeans>Preferences>Editor)'''
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well. As far as I can tell, this is only an issue in versions of NetBeans newer than 7.0, and it may be quite annoying as it seems there is no way to set this to a default. If you are bothered by it, consider installing a slightly older version of NetBeans (such as 6.9).

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several simple sample programs to get you started with
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen. This is the output of running the executable version:
<pre>
This is a simple message
The value of the variable c is: c.
The value of the variable i is: 25.
The value of the variable f is: 12.500000.
Again, the values are: c = c, i = 25, and f = 12.500000.
</pre>
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, and loops. This is the output:
<pre>
The value of i is 0 and 0/2 is 0.000000.
The value of i is 1 and 1/2 is 0.500000.
The value of i is 2 and 2/2 is 1.000000.
The value of i is 3 and 3/2 is 1.500000.
The value of i is 4 and 4/2 is 2.000000.
</pre>
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] for further reading. Below is some sample output. You should be able to understand each step of the program to see how this output is produced.
<pre>
Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 5
Valid input? 1

RESULTS:

Year 0: 1000.00
Year 1: 1050.00
Year 2: 1102.50
Year 3: 1157.62
Year 4: 1215.51
Year 5: 1276.28

Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 500
Valid input? 0
Invalid input; exiting.

Casting example.
Ratio, 5/2: 2.00
Ratio, 5/((float) 2): 2.50
Ratio, ((float) 5)/((float) 2): 2.50
</pre>

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2012-01-12T18:47:44Z

JarvisSchultz: /* Setting up the IDE */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free Apple Developer membership.

If you are running Mac OSX 10.7 (commonly known as Lion), you will download Xcode 4 from the Mac App Store. If you are running Mac OSX 10.6 or earlier, you will download Xcode 3. The .dmg download for Xcode 3 is available directly from the box on the left hand side of [http://developer.apple.com/xcode the Xcode page].

If you are not yet an Apple Developer, which is necessary to download Xcode, you can sign up for free [http://developer.apple.com/programs/register here] by filling out the questionnaire.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.
'''Note to Windows users:''' When deciding between 6.9 and 7.0 versions, you should
read the notes directly under the "Hello World" test program
[[Installing a C Compiler and IDE#Test Programs| on this page.]]
Even though 6.9 is older you may be interested in installing it instead.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options" '''(Mac users: go to Netbeans>Preferences>Editor)'''
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well. As far as I can tell, this is only an issue in versions of NetBeans newer than 7.0, and it may be quite annoying as it seems there is no way to set this to a default. If you are bothered by it, consider installing a slightly older version of NetBeans (such as 6.9).

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several simple sample programs to get you started with
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen. This is the output of running the executable version:
<pre>
This is a simple message
The value of the variable c is: c.
The value of the variable i is: 25.
The value of the variable f is: 12.500000.
Again, the values are: c = c, i = 25, and f = 12.500000.
</pre>
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, and loops. This is the output:
<pre>
The value of i is 0 and 0/2 is 0.000000.
The value of i is 1 and 1/2 is 0.500000.
The value of i is 2 and 2/2 is 1.000000.
The value of i is 3 and 3/2 is 1.500000.
The value of i is 4 and 4/2 is 2.000000.
</pre>
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] for further reading. Below is some sample output. You should be able to understand each step of the program to see how this output is produced.
<pre>
Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 5
Valid input? 1

RESULTS:

Year 0: 1000.00
Year 1: 1050.00
Year 2: 1102.50
Year 3: 1157.62
Year 4: 1215.51
Year 5: 1276.28

Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 500
Valid input? 0
Invalid input; exiting.

Casting example.
Ratio, 5/2: 2.00
Ratio, 5/((float) 2): 2.50
Ratio, ((float) 5)/((float) 2): 2.50
</pre>

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2012-01-12T18:47:16Z

JarvisSchultz: /* Setting up the IDE */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free Apple Developer membership.

If you are running Mac OSX 10.7 (commonly known as Lion), you will download Xcode 4 from the Mac App Store. If you are running Mac OSX 10.6 or earlier, you will download Xcode 3. The .dmg download for Xcode 3 is available directly from the box on the left hand side of [http://developer.apple.com/xcode the Xcode page].

If you are not yet an Apple Developer, which is necessary to download Xcode, you can sign up for free [http://developer.apple.com/programs/register here] by filling out the questionnaire.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.
'''Note to Windows users:''' When deciding between 6.9 and 7.0 versions, you should
read the notes directly under the "Hello World" test program
[[Installing a C Compiler and IDE#Test Programs| here.]]
Even though 6.9 is older you may be interested in installing it instead.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options" '''(Mac users: go to Netbeans>Preferences>Editor)'''
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well. As far as I can tell, this is only an issue in versions of NetBeans newer than 7.0, and it may be quite annoying as it seems there is no way to set this to a default. If you are bothered by it, consider installing a slightly older version of NetBeans (such as 6.9).

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several simple sample programs to get you started with
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen. This is the output of running the executable version:
<pre>
This is a simple message
The value of the variable c is: c.
The value of the variable i is: 25.
The value of the variable f is: 12.500000.
Again, the values are: c = c, i = 25, and f = 12.500000.
</pre>
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, and loops. This is the output:
<pre>
The value of i is 0 and 0/2 is 0.000000.
The value of i is 1 and 1/2 is 0.500000.
The value of i is 2 and 2/2 is 1.000000.
The value of i is 3 and 3/2 is 1.500000.
The value of i is 4 and 4/2 is 2.000000.
</pre>
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] for further reading. Below is some sample output. You should be able to understand each step of the program to see how this output is produced.
<pre>
Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 5
Valid input? 1

RESULTS:

Year 0: 1000.00
Year 1: 1050.00
Year 2: 1102.50
Year 3: 1157.62
Year 4: 1215.51
Year 5: 1276.28

Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 500
Valid input? 0
Invalid input; exiting.

Casting example.
Ratio, 5/2: 2.00
Ratio, 5/((float) 2): 2.50
Ratio, ((float) 5)/((float) 2): 2.50
</pre>

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2012-01-12T18:37:00Z

JarvisSchultz: /* Test Programs */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free Apple Developer membership.

If you are running Mac OSX 10.7 (commonly known as Lion), you will download Xcode 4 from the Mac App Store. If you are running Mac OSX 10.6 or earlier, you will download Xcode 3. The .dmg download for Xcode 3 is available directly from the box on the left hand side of [http://developer.apple.com/xcode the Xcode page].

If you are not yet an Apple Developer, which is necessary to download Xcode, you can sign up for free [http://developer.apple.com/programs/register here] by filling out the questionnaire.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options" '''(Mac users: go to Netbeans>Preferences>Editor)'''
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well. As far as I can tell, this is only an issue in versions of NetBeans newer than 7.0, and it may be quite annoying as it seems there is no way to set this to a default. If you are bothered by it, consider installing a slightly older version of NetBeans (such as 6.9).

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several simple sample programs to get you started with
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen. This is the output of running the executable version:
<pre>
This is a simple message
The value of the variable c is: c.
The value of the variable i is: 25.
The value of the variable f is: 12.500000.
Again, the values are: c = c, i = 25, and f = 12.500000.
</pre>
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, and loops. This is the output:
<pre>
The value of i is 0 and 0/2 is 0.000000.
The value of i is 1 and 1/2 is 0.500000.
The value of i is 2 and 2/2 is 1.000000.
The value of i is 3 and 3/2 is 1.500000.
The value of i is 4 and 4/2 is 2.000000.
</pre>
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the [[Media:CrashCourseinC.pdf|Crash Course in C manual]] for further reading. Below is some sample output. You should be able to understand each step of the program to see how this output is produced.
<pre>
Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 5
Valid input? 1

RESULTS:

Year 0: 1000.00
Year 1: 1050.00
Year 2: 1102.50
Year 3: 1157.62
Year 4: 1215.51
Year 5: 1276.28

Enter investment, growth rate, number of yrs (up to 100): 1000.00 1.05 500
Valid input? 0
Invalid input; exiting.

Casting example.
Ratio, 5/2: 2.00
Ratio, 5/((float) 2): 2.50
Ratio, ((float) 5)/((float) 2): 2.50
</pre>

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-16T15:15:17Z

JarvisSchultz: /* Windows */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings]. This is the most complex portion of the install process; read the directions in the link carefully.
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using [http://www.winzip.com/ WinZip] (must purchase), [http://www.gzip.org/#exe gzip], or [http://www.7-zip.org/ 7-zip] (recommended) such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options"
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well.

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several other pieces of sample code to facilitate learning
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of [[Media:EssentialC.pdf|the Essential C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen.
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, loops, and this [[media:Invest.c|tutorial code]].
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the Essential C manual for further reading.

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-16T15:07:40Z

JarvisSchultz: /* Setting up a compiler */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C language
compiler and an integrated development environment or IDE.

If you already have a C compiler you are comfortable with, you can ignore this page.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. If you run into any issues installing GCC,
check out NetBeans' instructions for each operating system. They have very thorough
directions that could definitely help to sort out any problems; you can find those instructions
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW. [http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. To install, do the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

'''If you have any issues, check out the more detailed instructions for this process [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options"
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well.

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

= Tutorial Sample Code =
We have provided several other pieces of sample code to facilitate learning
the C language. You should compile and run each of them, read the comments, answer the questions, and read the portions of [[Media:EssentialC.pdf|the Essential C manual]] referenced for more background.

* [[Media:Simple1.c|Simple1.c]]: A first simple program to learn about different data types and printing to screen.
* [[Media:Simple2.c|Simple2.c]]: A second program to learn about useful C constructs including functions, if statements, loops, and this [[media:Invest.c|tutorial code]].
* [[Media:Invest.c|Invest.c]]: The most complex tutorial program, which exercises a number of the features and capabilities of the C language while performing a very simple function: calculating the value of an investment over time. It also provides references to the Essential C manual for further reading.

Each of these programs can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

ME 333 Introduction to Mechatronics (Archive Winter 2012)

2011-12-15T23:41:47Z

JarvisSchultz: /* Checklist to Complete Before the First Day of Class */

'''Winter Quarter 2012 -- ***UNDER CONSTRUCTION***'''

[[ME 333 Introduction to Mechatronics (Archive Winter 2011)|(Archive of Winter 2011)]]

'''First day of class is Thursday Jan 5!'''
* Section 20: Prof. Kevin Lynch, T Th, 11:00-12:20, Tech LR5
* Section 21: Prof. Nick Marchuk, T Th, 12:30-1:50, Tech LR5
* TAs: Nelson Rosa, nelsonrosa2013 at u.northwestern.edu; Jarvis Schultz, JarvisSchultz2012 at u.northwestern.edu
* Office Hours: TBA
* Circuits Q&A Session: TBA
* '''Final demo''' (in lieu of final exam): 11-12:20 section Wed March 14 9-11 AM; 12:30-1:50 section Monday March 12 3-5 PM

== Checklist to Complete Before the First Day of Class ==

Attendance at the first day of class (Thursday Jan 5) is mandatory. By the first day of class, you should:

* Be able to solve circuit problems similar to those on the practice problem set and last year's quiz at the bottom of [[ME_333_Circuits_Review_Material|this page]]. Be prepared for a short quiz on this material in the second week of class. We will only spend one class period reviewing this material.
* Have a laptop with at least 2 USB ports. Any operating system is fine. One port will be used to program and communicate with your PIC microcontroller, and the other will be used for your portable oscilloscope. Your laptop should have Matlab installed.
* Download and install the Netbeans C compiler following the instructions [[Installing_a_C_Compiler_and_IDE|here]]. Verify that you can compile and run this [[Media:starter.c|starter C program]] and this second, more complex, [[Media:invest.c|tutorial C program]]. If you are new to C, it would be a good idea to experiment with these in advance of the course and to read the portions of [[Media:EssentialC.pdf|Essential C]] referenced in the second tutorial program. This will allow you to start quickly in ME 333.
* Download and install software described on [[NU32v2: Software to Install|this page]].
* Buy your class kit [http:// here]. You will not be able to start the course until you have purchased your kit. If you decide to drop the course, you will be refunded the purchase price upon return of all the equipment in working shape.

== Student Contract ==

By signing up for this course, you agree to complete the checklist above before the course starts. You understand that learning from classmates is encouraged, up to the stage of conceptualizing solutions. You understand that copying assignment solutions and program code plagiarism is not tolerated. You will report instances of code plagiarism you are aware of. Code plagiarism includes, but is not limited to:

* Allowing another student to copy your code.
* Copying another student's code, in whole or in part.
* Transforming copied sections of code to try to disguise their origin.
* Borrowing code from others not in the course, e.g., code found on the internet, without attribution. Borrowing code found on the internet is acceptable if the source is clearly indicated in your code comments.

On our part (faculty and TAs), we commit to do our best to provide you a curriculum and set of experimental materials to get you up to speed on sophisticated mechatronics integration as quickly and efficiently as possible, while giving you a foundation in concepts needed to go further in future projects and courses.

== Prerequisite ==

ME 233 Electronics Design or similar (EECS 221, 225) is required. You will be expected to analyze circuits with resistors, capacitors, inductors, diodes, transistors, and op-amps on the first day of class. There will be a quiz on this material on the second day of class, but you are on your own to prepare for it. To see if you have the right background, or if you will need to freshen up before the quarter starts, do the practice problem set and the 2011 quiz on [[ME_333_Circuits_Review_Material|this page]].

== Reading ==

Required:

* [[Media:EssentialC.pdf|Essential C]]: A brief introduction to the C programming language
* [[Media:PIC32MX5XX6XX7XX_Family_Data_Sheet.pdf|PIC32 Data Sheet]] (254 pages, 5 MB pdf)
* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2612 PIC32 Family Reference Manual, by chapter.] Lots of useful and detailed information on the PIC32 architecture and how the peripherals work, including detailed description of their SFRs. Only certain parts of certain chapters will be assigned.
* PIC32MX Peripheral Library (included as a .chm file under "Program Files\Microchip\MPLAB C32\doc" with your C32 compiler installation)

Useful, but not required:

* [http://www.amazon.com/Programming-32-bit-Microcontrollers-Exploring-Technology/dp/0750687096/ref=sr_1_1?ie=UTF8&s=books&qid=1294091438&sr=8-1-spell Programming 32-bit Microcontrollers in C: Exploring the PIC32] by Lucio Di Jasio. This is an easy to read and informative exploration of the PIC32.
* MPLAB C32 Libraries Guide and MPLAB C32 User Guide, included under "doc" of your C32 compiler installation
* Other C resources, such as [http://publications.gbdirect.co.uk/c_book/ online] as well as this [[Media:CBook.pdf|pdf version]] of "The C Book," and the classic [http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_1?s=books&ie=UTF8&qid=1294091625&sr=1-1 C Programming Language] reference book by Kernighan and Ritchie

== Grading ==

Grades will be approximately 40% quizzes and 60% assignments. We will have short quizzes once a week at the beginning of class covering material on the previous assignment. Bring a sheet of paper you can turn in with your quiz answers. We will have a final demo in lieu of a final exam.

== Approximate Syllabus ==

ME 333 focuses on three topics: (1) general C programming; (2) Microchip PIC microcontroller architecture and C programming specific to the PIC (e.g., using the PIC's peripherals, such as analog inputs, digital I/O, counters/timers, comm ports, etc.); and (3) interfacing the PIC to sensors and actuators, some theory of sensor and actuator operation, and interface circuitry and signal processing.

You will bring your laptop to each class. As the quarter progresses, we will be handing out other equipment that you will need to bring to class, such as the [[NU32v2: Introduction to the PIC32|NU32v2 development board]] that breaks out the [http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en545660 PIC32MX795F512L] microcontroller.

Topics we will cover include:

* introduction to C programming (here's a [[Media:invest.c|simple tutorial C program]])
* quiz on circuits
* introduction to the PIC32 hardware, and programming the PIC32 in C
* digital I/O
* counters/timers and interrupts
* analog input
* sensor smorgasbord
* digital signal processing: filters and FFTs
* analog output and pulse-width modulation
* brushed permanent magnet DC motors: theory and control
* stepper motors and RC servo motors
* communication by SPI, I2C, and RS-232

By class (note: DS = Data Sheet, RM = Reference Manual):

'''Class 1'''
: '''Quiz''': None.
: '''Topic''': Course overview. Circuits review.
: '''Reading''': Practice problem set and quiz on [[ME_333_Circuits_Review_Material|this page]], as well as background reading as needed.

'''Class 2'''
: '''Quiz''': None.
: '''Topic''': Introduction to C (bits, bytes, binary, hex, data types, memory, pointers, compiling).
: '''Reading''': [[Media:invest.c|Sample program]], [[Media:EssentialC.pdf|Essential C]] (page numbers referenced in program comments).

'''Class 3'''
: '''Quiz''': Circuits.
: '''Topic''': Introduction to C (cont).
: '''Reading''':
: '''Assignment out''':

'''Final Demo''': Monday 3/12, 3-5 PM, for 12:30-1:50 section; Wednesday 3/14, 9-11 AM, for 11:00-12:20 section

== FAQ ==

Q: Do I need to know the C language to take this course?

A: No. But if you already know C, there is still plenty else in this course for you. If you already know C, know how to use microcontrollers for real-time control, and have a good understanding how common sensors and actuators work and how to interface to them, this course may not be for you. Consider taking ME 433 Advanced Mechatronics in the spring quarter.

Q: Is there an independent project?

A: There is no large independent project. There will be an individual two-week project at the end of the course, but there will be no machining. For a significant project, do a quarter-long project in ME 433 Advanced Mechatronics, offered in the spring quarter. ME 333 is good preparation for ME 433.

Q: What kind of laptop do I need?

A: You need a laptop with at least 2 USB ports. Any operating system is fine.

== ME 333 Winter 2010 (obsolete) ==

* [[ME 333 Circuits Review Material]]
* [http://www.youtube.com/NUmechatronics NUmechatronics youtube channel]
* [[ME 333 final projects]]
* [[PCB Artist]]
* [[ME 333 Suggested Final Projects]]
* [[ME 333 end of course schedule]]
* [[ME 333 Lab Kits]]
* [[Processing]] (software allowing you to create GUIs on your PC and interface through your USB port)
* Labs from Winter 2010
** [[Getting Started with PIC32|ME 333 Lab 1: Getting started with the PIC32]]
** [[ME 333 Lab 2]]
** [http://lims.mech.northwestern.edu/~lynch/courses/ME333/PIClabs/lab3/lab3.html ME 333 Lab 3]
** [[ME 333 Lab 4]]
** [[ME 333 Lab 5]]
* Ungraded study problems (be sure to attempt to solve the problems before looking at the solutions!)
** [[ME 333 Circuits Review Material]]
** [[Media:MotorProblems.pdf|Practice DC motor problems]] and their [[Media:MotorProblemSolutions.pdf|solutions]]
** [[Media:PIC32StudyGuide.pdf|PIC32 Study Guide]] and [[Media:PIC32StudyGuideSolutions.pdf|solutions]]

[[NU32v2: A Detailed Look at Programming the PIC32]]

Installing a C Compiler and IDE

2011-12-15T23:39:03Z

JarvisSchultz: /* Test Programs */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options"
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options, an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting. Note that "External Terminal" is appropriate for other operating systems as well.

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:37:47Z

JarvisSchultz: /* Test Programs */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options"
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:

int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

'''This next step may be very important for Windows users!''' When a compiled project is run inside of NetBeans, it must decide where to display the output, and if the user is expected to provide input, where that input will come from. There are three options an "External Terminal", "Standard Output" and "Internal Terminal" (at least in NetBeans 7.+). Depending on how you have your system setup these are not all guaranteed to work! What you should do is right click on the project name in the "Projects" window, and then click "Project Properties". Next click "Run" and locate the "Console Type" drop down menu. Make sure it is set to "External Terminal". In the future if you are getting strange behavior such as print statements that aren't showing up you might want to check this setting.

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:28:44Z

JarvisSchultz: /* Setting up the IDE */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

=== ME333 Customization ===
In this course we plan on using two spaces for an indent, and no more than 80 characters per line. To set these options in NetBeans do the following:
#click "Tools>Options"
#Then select "Editor" from the buttons at the top
#Then select the "Formatting" tab
#Set "Languages" to "All Languages"
##change "Number of Spaces per Indent" to 2
##"Tab Size" to 2
##"Right Margin" to 80
##make sure the checkbox for "Expand Tabs to Spaces" is checked
##"Line Wrap" is set to "After words"
#Then set "Language" to C, and make sure that the "Override Global Options" checkbox is unchecked.

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:11:15Z

JarvisSchultz: /* Setting up a compiler */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:11:01Z

JarvisSchultz: /* Test Programs */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:10:10Z

JarvisSchultz: /* Conclusions */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Other Resources=

[http://netbeans.org/kb/docs/cnd/quickstart.html NetBeans C/C++ Projects Quick Start Tutorial]

[http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite HOWTO Install MinGW Compiler Suite]

[http://netbeans.org/community/releases/69/cpp-setup-instructions.html Configuring the NetBeans IDE for C/C++/Fortran]

[http://www.cprogramming.com/compilingandlinking.html CProgramming Compiling and Linking]

[http://www.jfranken.de/homepages/johannes/vortraege/make_inhalt.en.html An introduction to Makefiles]

Installing a C Compiler and IDE

2011-12-15T23:08:09Z

JarvisSchultz: /* Test Programs */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

=== Other Sample Code ===
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Conclusions =

Installing a C Compiler and IDE

2011-12-15T23:07:27Z

JarvisSchultz: /* Makefiles */

= Introduction =
One of the purposes of this course is to learn the basics of the C programming
language. Towards that goal, we will begin the course by writing some simple C
programs that are built to run on a computer alone, and not any sort of
microprocessor. This section will guide you through setting up a C-language
compiler and an integrated development environment or IDE.

Note that if you already have a compiler and/ or IDE that you are comfortable
and experienced with this page may be of little use to you.

= Setting up a compiler =
Unlike some languages that you may be familiar with (MATLAB for one) the C
programming language must be "compiled" before it can be run on the computer.
A compiler's job is to take the code that a person writes in the C-language and
convert it to a "binary file" in machine language that the computer understands.
For more info see [http://en.wikipedia.org/wiki/Compiler wikipedia].

The compiler that we recommend is the GNU Compiler collection or [http://gcc.gnu.org/ GCC].
This is a widely used cross-platform compiler toolsuite that has libraries and compilers
for C, C++, Fortran, Java, and more. Additionally the compiler that we will use
later on in the course for compiling C code to run on the PIC32 is based on GCC.

In the next section we are going to discuss setting up an integrated development
environment ([http://en.wikipedia.org/wiki/Integrated_development_environment IDE])
called [http://netbeans.org/ NetBeans]. They have very thorough directions for
setting up the GCC compiler on every operating system
[http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].

=== Windows ===
Windows is arguably the most difficult operating system to get the compiler
working with. The GCC toolsuite was originally developed to work with
Unix/Linux operating systems, but there are two popular Windows ports available,
Cygwin and MinGW.

[http://mingw.org/ MinGW] is probably the easier of the two to setup so that is
what we recommend. '''Complete, detailed instructions for this process can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html#mingw here].'''

A quick summary of these steps is provided in the following:

# Install [http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486 MinGW-5.1.4.exe] (direct link).
# Add C:\MinGW\bin to the system path by editing your system's [http://www.mingw.org/wiki/Getting_Started#toc4 Environment Settings].
# Install MSYS 1.0 files by running [http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe MSYS-1.0.10.exe] (direct link).
# Install the gdb debugger by downloading [http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146 gdb-6.8-mingw-3.tar.bz2] (direct link) and extracting using WinZip, gzip, or 7-zip such that the gdb executable is in the C:\MinGW\bin directory.

=== Apple OSx ===
To get all of the required tools you must install Xcode and X11 from the [http://developer.apple.com/devcenter/mac/index.action Apple Developer Connection].
Note that you must sign up for a free ADC membership.

=== Linux ===
Many linux distributions have GCC bundled with the install, if you do not have
it you should be able to get it from your distribution's repositories using your
favorite package manager.

= Setting up the IDE =
Now that you have a compiler, all you really need is a text editor, and you are
ready to start coding in C. However, learning the ins and the outs of
compiling, linking, debugging, Makefiles, etc. can be a bit overwhelming. So we
are going to recommend the use of an [http://en.wikipedia.org/wiki/Integrated_development_environment IDE]
to help you get started. As well as helping beginners, many experienced
programmers do all of their development in an IDE. An IDE can act as a
source code editor, it can provide graphical interfaces to debuggers and
compilers, it can autogenerate useful configuration files, and many more useful
features. The IDE that we are going to recommend is [http://netbeans.org NetBeans].
NetBeans is totally free, it is cross-platform, and Microchip has paired with
NetBeans to develop their new-generation IDE for PIC development, MPLABX (which
you will be using later in the course).

To install NetBeans simply visit [http://netbeans.org/downloads/index.html this link] and
install either 6.9.1 or 7.0.1 for your operating system. You can install either
the full version, or just the C/C++ version (recommended). Note that this
doesn't really matter as modules can be added or deleted later on.

'''More detailed tips on configuring and troubleshooting can be found [http://netbeans.org/community/releases/69/cpp-setup-instructions.html here].'''

'''A decent tutorial on setting up and configuring C/C++ projects within NetBeans can be found [http://netbeans.org/kb/docs/cnd/quickstart.html here].'''

= Test Programs =
[[Image:NetBeansSampleProjectConfiguration_1.JPG|400px|thumb|Step 2 configuration.|right]]
[[Image:NetBeansSampleProjectConfiguration_2.JPG|400px|thumb|Screenshot of step 3 configuration.|right]]
In this section, we are going to create a very simple project in NetBeans, and
then compile it and analyze the output using a few different techniques.

#First open NetBeans, and click File>New Project
#Select C/C++ Application
#Configure project as shown. Be sure "Create Main File" and "Set as Main Project" checkboxes are selected, and that the language of choice is C (not C++). Also be sure your compiler is selected under "Tool Collection."
#Locate the "Projects" window. If it is not already visible, you can select it under the Window menu at the top of the screen.
#Clicking the plus next to "Source Files" in the project window should reveal a file called "main.c". This is basically a blank C source code template that you can work from. Open this file by double clicking on it.
#Edit the "main" function so that it looks like the following:


int main(int argc, char** argv) {
printf("Hello World!");
return (EXIT_SUCCESS);
}

Your project is now created, and we will look at a couple of different ways to compile and run it.

=== Using the IDE to compile ===
To compile the code you can click "Run>Build Main Project". Note the text that
is printed in the "Output" window. If no errors are printed and you see
something like

 BUILD SUCCESSFUL (total time: 2s) 

then everything worked and you are ready to run the code. Clicking the green
triangle button, or "Run>Run Main Project" will actually run the code. You
should see something like

 Hello World! 
 RUN SUCCESSFUL (total time: 144ms) 

printed in the "Output" window. If all of this worked, you have just written,
compiled, and ran a test C program.

Note that there are several output files that are created by this compilation
process. In your project directory there are two subdirectories called "build/"
and "dist/". Inside of the "build/" directory are the so-called object files
generated by the compiler. These are essentially just machine code versions of
the raw source code that you wrote. Inside of the "dist/" directory, you will
find an executable file that is actually capable of running on your system.
For example, on a Windows machine that followed all previous instructions, you
will find the following file

 <PROJECT_DIRECTORY>\dist\Debug\MinGW-Windows\helloworld.exe 

This executable can be run just like any other executable on your system. Note
that in OSx or Linux there will not be a ".exe" extension on your executable.
The compiler name found in the above directory may vary as well.

=== Command Line Usage ===
To further analyze what just happened we are going to do a couple of things from
the command line. In your OS, open a command line. In OSx this is called
"Terminal" and in Windows this is called cmd (Click "Start>Run" then type cmd
and hit enter).

Let's start by simply executing the file generated by the previous compilation.
So we are going to navigate to the aforementioned executable
output directory of the project. Note that the command "cd" will allow you to
change directories. So for example on Windows you might type something like

 cd C:\Users\<USERNAME>\Documents\NetBeansProjects\HelloWorld\dist\Debug\MinGW-Windows 

or on OSx or Linux I might type something like

 cd /home/<USERNAME>/NetBeansProjects/dist/Debug/GNU-Linux-x86/ 

where you must replace <USERNAME> with your username.

Typing "ls" in the command line will then print the contents of the current
directory. Note that in Windows, "ls" is not part of the normal command line
interface, but earlier when we installed MSYS, we enabled this. If for some
reason "ls" does not work to print the directory contents, try typing "dir".
Printing the contents of the output directory should reveal just one executable
file, "helloworld.exe" (Windows) or simply "helloworld" (Linux/OSx). Let's run
that executable now so we can see its output. On Windows simply type
"helloworld.exe" (no quotes) into the command line and press enter; in OSx,
type "./helloworld". You should see "Hello World!" echoed back to you.

Now let's attempt to compile this file by invoking the compiler manually. We
want to navigate to the base project directory. On any OS that can be
accomplished by typing

 cd ../../../ 

Note that here the ".." implies the parent directory of the current directory. Now we are ready
to compile the file using GCC. On Windows we can type

 gcc.exe -o helloworld.exe main.c 

or on OSx you can type

 gcc -o helloworld main.c 

This will generate a new executable file in the current directory called
"helloworld(.exe)". This can be executed as we just did above. Note that the
"-o" in the above commands is an option telling the compiler where to generate
the output. There hundreds of different options that can be passed to the compiler and many
different configurations for how projects are compiled. It can be quite
confusing! This is one of the things that the IDE does for you. It sets all of
these options either automatically or through graphical interfaces.

=== Makefiles ===
Note that in the project base directory there is a file called "Makefile."
This file combined with several other "Makefiles" in the nbproject directory is
where all of these options are stored. One of the programs that was
installed earlier when we setup a compiler is called "make". Its job is to read
the configurations stored in "Makefiles" and call the compiler accordingly.

On complicated projects, compiling can take a very long time. One of the main
features of "make" is that before it compiles anything, it looks at what files
have changed since compilation last occurred. It then compiles only the files
that must be recompiled to reflect changes. This can significantly increase
compilation speed. "Make" is what NetBeans is actually calling when you are
clicking "Build" or "Clean and Build".

We can invoke it from the project base directory by simply typing the word
"make" in the command line. The printed output should be the same thing that
you would see if you opened NetBeans and clicked "Run>Build Main Project".

== Other Sample Code ==
We have provided several other sample pieces of code to facilitate learning
the C-language. The first you should look at can be found [[media:starter.c|here]], and a
slightly more complicated piece of code can be found [[media:Invest.c| here]].
Each of these can be compiled by creating a new NetBeans project as described above except
this time you will want to uncheck "Create Main File." To add one of the downloaded example codes
to your project simply alternate click (right click Windows, Ctrl+click OSx) where it says
"Source Files" in the "Projects" window and select "Add Existing Item...". Once the file is added to
your project you should be able to build and run it using the instructions from above.

= Conclusions =