Difference between revisions of "AVR Programming"

From CCRMA Wiki
Jump to: navigation, search
 
Line 99: Line 99:
 
         }
 
         }
 
       }
 
       }
 +
</pre>
 +
 +
==C Syntax==
 +
This is a very basic overview of the essential parts of the C language that are frequently encountered when writing simple programs for the AVR. It is obviously impossible to thoroughly cover the C language in a few pages, but this should provide a brief explanation of most things that will be encountered in demo programs. If you know C, you can skip this section. For a better reference, see Kernighan, B.W. and D. M. Richie (1988) The C Programming Language. Prentice Hall.
 +
 +
===Comments===
 +
 +
* Comments are not evaluated by the compiler. They are there to help the programmer. There are two styles of comments that can be used:
 +
<pre>
 +
      // This is a C++-style 'slash-slash comment'
 +
 +
      /* This is a C-style comment*/
 +
      /* These comments must be terminated with a star-slash */
 +
</pre>
 +
 +
===Variables===
 +
 +
* <i>Declaring</i> a variable means allocating a chunk of RAM on the AVR and giving it a name. After a variable is declared, the chunk of memory can be assigned a value, and that value can be recalled, using its name. A variable declaration looks like this:
 +
 +
<pre>
 +
      u08 myvar;  // unsigned 8-bit integer named myvar
 +
</pre>
 +
 +
      where <tt>u08</tt> is the type and <tt>myvar<tt> is the name. Notice the statement ends with a semicolon, like all C statements. A variable must be declared before it is used, and before any executable statements in the function in which it is declared. Integer types are:
 +
<pre>
 +
      u08 a; // unsigned 8-bit integer (0 to 255) or 0 to MAX_U08
 +
      s08 b; // signed 8-bit integer (-128 to 127) or MIN_S08 to MAX_S08
 +
      u16 c; // unsigned 16-bit integer (0 to 65535) or 0 to MAX_U16
 +
      s16 d; // signed 16-bit integer (-32768 to 32767) or MIN_S16 to MAX_S16
 +
      u32 e; // unsigned 32-bit integer (0 to 4294967295) or 0 to MAX_U32
 +
      s32 f; // signed 32-bit integer (-2147483648 to 2147483647) or MIN_S32 to MAX_S32
 +
</pre>
 +
 +
      <tt>MAX_U08</tt>, etc. are macros that are <tt>#defined</tt> in the AVRLib.
 +
 +
* An assignment gives a value to a variable, using the assignment operator = :
 +
<pre>
 +
      u08 foo, bar;  // define 2 unsigned 8-bit integers
 +
      foo = 12;      // assign the value 12 to the variable foo
 +
      bar = foo * 10; // assign the 10 times the value of foo to the variable bar
 
</pre>
 
</pre>

Revision as of 15:20, 21 June 2007

Anatomy of a C program for AVR

The following presents a rough overview and breakdown of a demo program from the avrlib-demos. The code is in the avrlib-demos in the button directory in the file button.c. Details of C syntax and AVR-specific commands will follow.

  • The first portion of a C program is usually a bunch of comments that describe the file. Usually this includes the name, author, and date of the file; a revision history; and directions on how to use the file.
      //---------------------------------------------------
      //---------------------------------------------------
      //
      //  AVRLIB-DEMO
      //  For avrlib and avrmini development board.
      //
      //
      //  File:     button.c
      //  Author:   Wendy Ju
      //            based on code written by Michael Gurevich & Matt Wright
      //
      // Revision History:
      // When           Who               Description of change
      // -----------  -----------         -----------------------
      // 04-Oct-2004  Wendy Ju            Created a new instance
      // 01-Jun-2006  Michael Gurevich    makefile->mega32, superfluous #includes
      //
      //---------------------------------------------------
      //  USING THE AVRMINI DEVELOPMENT BOARD, CONNECT
      //  THE LED/PUSHBUTTON JUMPER TO THE PORT B JUMPER.
      //---------------------------------------------------
      //
      //---------------------------------------------------
      //  This program will cause LED 0 to light when corresponding
      //  pushbutton 4 is pressed.
      //---------------------------------------------------
  • Next are #includes. They tell the compiler where to look for other bits of code you are using that do not reside in this file. They are normally ".h" or header files that contain macros and function prototypes. Before a the .c file is compiled, the contents of the #includes are literally copied into the file.
      // compiler includes
      #include <avr/io.h>

      // avrlib includes
      #include "global.h"
  • #defines are "macros". Before the program is compiled, the argument of the #define is simply substituted everywhere the name is used. They are handy for giving meaningful names to numbers and for changing a single value that may be used numerous times in a program without having to change every instance.
      #define DELAY 1000
  • Function prototypes give the name, arguments and return type of functions that will be used later in the program. They can be included in header files or in the .c file before the function is defined.
      int checkButton(int whichButton);
      void setLED(int whichLED, int on);
  • The main function is literally the main part of the code. There can only be one main function in the final compiled program. The code inside the main function is executed sequentially, one line at a time.
      int main(void) {

        // set LED pins as outputs,  button pins as inputs
        outb(DDRB, 0x0F);

        // Turn off LEDs - looking at the circuit
        // you can see that they are off when pulled high
        outb(PORTB, 0xFF);

        while(1) {  // loop forever
          setLED(0, checkButton(4));
          //sampling delay goes here
        }

        return 0;
      }
  • Finally, there are function definitions. These are pieces of code that are called from the main function or from other functions, that have a specific functionality that may want to be used over and over.
      int checkButton(whichButton) {
        // On our boards the four buttons are numbered 4, 5, 6, and 7

        return (! bit_is_set(PINB,whichButton));
        /* Logical negation is because when the button is pushed, the pin
           is drawn to ground, so the button is "on" when the bit is zero. */
      }

      void setLED(int whichLED, int on) {
        // On our board the four buttons are numbered 0, 1, 2, and 3

        if (on) {
          //light the LED
          cbi(PORTB,whichLED);
        } else {
          //turn off the LED
          sbi(PORTB,whichLED);
        }
      }

C Syntax

This is a very basic overview of the essential parts of the C language that are frequently encountered when writing simple programs for the AVR. It is obviously impossible to thoroughly cover the C language in a few pages, but this should provide a brief explanation of most things that will be encountered in demo programs. If you know C, you can skip this section. For a better reference, see Kernighan, B.W. and D. M. Richie (1988) The C Programming Language. Prentice Hall.

Comments

  • Comments are not evaluated by the compiler. They are there to help the programmer. There are two styles of comments that can be used:
      // This is a C++-style 'slash-slash comment' 

      /* This is a C-style comment*/
      /* These comments must be terminated with a star-slash */

Variables

  • Declaring a variable means allocating a chunk of RAM on the AVR and giving it a name. After a variable is declared, the chunk of memory can be assigned a value, and that value can be recalled, using its name. A variable declaration looks like this:
      u08 myvar;   // unsigned 8-bit integer named myvar
     where u08 is the type and myvar<tt> is the name. Notice the statement ends with a semicolon, like all C statements. A variable must be declared before it is used, and before any executable statements in the function in which it is declared. Integer types are:
      u08 a;	// unsigned 8-bit integer (0 to 255) or 0 to MAX_U08
      s08 b;	// signed 8-bit integer (-128 to 127) or MIN_S08 to MAX_S08
      u16 c;	// unsigned 16-bit integer (0 to 65535) or 0 to MAX_U16
      s16 d;	// signed 16-bit integer (-32768 to 32767) or MIN_S16 to MAX_S16
      u32 e;	// unsigned 32-bit integer (0 to 4294967295) or 0 to MAX_U32
      s32 f;	// signed 32-bit integer (-2147483648 to 2147483647) or MIN_S32 to MAX_S32
     <tt>MAX_U08, etc. are macros that are #defined in the AVRLib.
  • An assignment gives a value to a variable, using the assignment operator = :
      u08 foo, bar;   // define 2 unsigned 8-bit integers
      foo = 12;       // assign the value 12 to the variable foo
      bar = foo * 10; // assign the 10 times the value of foo to the variable bar