AVR Programming CS-212 Dick Steflik. ATmega328P I/O for our labs To get data into and out of our Arduino its a little trickier than using printf and.

Slides:



Advertisements
Similar presentations
Introduction to Micro-controllers Anurag Dwivedi.
Advertisements

Lab7: Introduction to Arduino
Chung-Ta King National Tsing Hua University
Blackfin BF533 EZ-KIT Control The O in I/O Activating a FLASH memory “output line” Part 3 – New instruction recap Tutorial.
Programming Microcontrollers B. Furman 19MAR2011.
68HC11 Polling and Interrupts
 | bit OR & bit AND ~ bit NOT ^ bit EXLUSIVE OR (XOR) > bit RIGHT SHIFT.
CSC Timers Since this is a microcontroller it mainly finds itself in embedded devices Quite often embedded devices need to synchronize events The.
Intro to AVR ATtiny2313 CS423 Dick Steflik. AVR ATtiny2313.
Interrupts What is an interrupt? What does an interrupt do to the “flow of control” Interrupts used to overlap computation & I/O – Examples would be console.
COMP3221: Microprocessors and Embedded Systems Lecture 15: Interrupts I Lecturer: Hui Wu Session 1, 2005.
1 Homework Turn in HW2 at start of next class. Starting Chapter 2 K&R. Read ahead. HW3 is on line. –Due: class 9, but a lot to do! –You may want to get.
Structure of a C program
8-Bit Timer/Counter 0 Counter/Timer 0 and 2 (TCNT0, TCNT2) are nearly identical. Differences: -TCNT0 can run off an external 32Khz clock (Tosc) or the.
Debug Techinques for HW/SW Systems What's broken, the HW or the SW? Some basic thoughts: -assume that its broken -its not working correctly until proven.
Butterfly I/O Ports CS-212 Dick Steflik. I/O for our labs To get data into and out of our Butterfly its a little trickier than using printf and scanf.
Getting the O in I/O to work on a typical microcontroller Activating a FLASH memory “output line” Part 1 Main part of Laboratory 1 Also needed for “voice.
Timers and Interrupts Shivendu Bhushan Summer Camp ‘13.
Embedded Systems Interrupts C.-Z. Yang Sept.-Dec
An Embedded C Program 1 Mainly from textbook: Embedded C Programming and the Atmel AVR 2 nd Edition Barnett, Cox and O’Cull.
Working with Arduino: Lesson #1: Getting Acquainted with the Kit EGN1007.
Arduino John Marcoux Christopher Lesch Thomas Dodge Unless otherwise noted, all information and pictures came from:
Arduino Part 1 Topics: Microcontrollers Programming Basics: structure and variables Digital Output Analog to Digital Conversion.
Embedded Systems Programming 1 ETEE 3285 Topic HW3: Coding, Compiling, Simulating.
Revised: Aug 1, ECE 263 Embedded System Design Lessons 23, 24 - Exceptions - Resets and Interrupts.
1 ARM University Program Copyright © ARM Ltd 2013 General Purpose I/O.
MCU: Interrupts and Timers Ganesh Pitchiah. What’s an MCU ?
A Play Core Timer Interrupts Acted by the Human Microcontroller Ensemble from ENCM511.
Engineering Computing I Chapter 4 Functions and Program Structure.
Robotics Research Laboratory Louisiana State University.
AVR Programming: Interrupts September 17, What are interrupts? An asynchronous signal indicating the need for an event to be handled A synchronous.
ECS642U Embedded Systems Cyclic Execution and Polling William Marsh.
AVR Programming: Digital I/O September 10, What is Digital I/O? Digital – A 1 or 0 Input – Data (a voltage) that the microcontroller is reading.
Timers and Interrupts Anurag Dwivedi. Let Us Revise.
Code The Arduino Environment.
MIPS I/O and Interrupt.
Warmup – 16FEB2012 This one is for practice. I have paper if you need it. Suppose there are eight, single-pole, single-throw (SPST) switches connected.
LHO 22 C and the  The Silicon Labs ISE uses the Keil C51 compiler.  The code size is limiter to 2K  C has replaced PL/M (the original Intel high.
Microcontrollers, Microcomputers, and Microprocessors
Arduino libraries Datatekniker Udvidet hardware/software.
Arduino Mega Arduino Mega 2560 Arduino Mega 2560.
EE/CS-352: Embedded Microcontroller Systems Part V The 8051 Assembly Language Interrupts.
Lab. 1 – GPIO Pin control Using information ENEL353 and ENCM369 text books combined with Blackfin DATA manual.
CS-280 Dr. Mark L. Hornick 1 Sequential Execution Normally, CPU sequentially executes instructions in a program Subroutine calls are synchronous to the.
Embedded Programming and Robotics Lesson 11 Arduino Interrupts 1.
Embedded Systems Lecture 4 January 20, 2016.
ARM Embedded Programming Lecture 4 Accessing Memory Mapped Registers.
GUIDED BY PROFFESOR NILESH DESAI GROUP NO:-8 CHANDRASHIKHA SINGH( ) KURUP SHUBHAM VALSALAN( ) SAURAV SHUBHAM( )
Programming in Arduino Materials:Arduino Board Casperelectronics Pre Pres. Notes Photos from workshop?
Atmega328p Introduction for Digital and PWM Output Brion L Fuller II Robotics Club.
Programming PIC 16F84A in Assembly. PIC16F84 pin-out and required external components.
Arduino Part 1 Topics: Microcontrollers
LCD Interfacing using Atmega 32
Introduction to Arduino Microcontrollers
8-Bit Timer/Counter 0 Counter/Timer 0 and 2 (TCNT0, TCNT2) are nearly identical. Differences: -TCNT0 can run off an external 32Khz clock (Tosc) or the.
Timer/Counter Modified from Dr. Lam Phung’s Slides.
The slides must be understood in Lecture 5
1 Code
Working with Arduino: Lesson #1: Getting Acquainted with the Kit
Interrupts in C Programs
Register Variables Declaring a variable as a "register" variable is an advisory to the compiler to keep the normal location of the variable in a register,
AVR Programming in C Chapter 7
AVR Programming in C Chapter 7
ADC and DAC Programming in AVR
A Play Lab. 2 Task 8 Core Timer Interrupts
C Programming Getting started Variables Basic C operators Conditionals
Lab. 1 – GPIO Pin control Using information ENEL353 and ENCM369 text books combined with Blackfin DATA manual.
COMP3221: Microprocessors and Embedded Systems
ECE 3567 Microcontrollers Lab
Presentation transcript:

AVR Programming CS-212 Dick Steflik

ATmega328P

I/O for our labs To get data into and out of our Arduino its a little trickier than using printf and scanf as you did in CS211 Since the Arduino doesn't have an Operating System we need to write and read data directly to/from the I/O ports Access to the ports is through the Special Function Registers (SFRs) that are defined symbolically in iom328p.h which is included in your program by io.h

io.h # include #elif defined (__AVR_ATmega168__)‏ # include #elif defined (__AVR_ATmega168P__)‏ # include #elif defined (__AVR_ATmega169__)‏ # include #elif defined (__AVR_ATmega169P__)‏ # include #elif defined (__AVR_ATmega8HVA__)‏ # include #elif defined (__AVR_ATmega16HVA__). # include #elif defined (__AVR_ATmega3250P__) # include #elif defined (__AVR_ATmega328P__) || defined (__AVR_ATmega328__) # include #elif defined (__AVR_ATmega329__) # include #‏

iom328p.h /* avr/iom328p.h - definitions for ATmega328P. */ /* This file should only be included from, never directly. */ #ifndef _AVR_IO_H_ # error "Include instead of this file." #endif #ifndef _AVR_IOXXX_H_ # define _AVR_IOXXX_H_ "iom328p.h" #else # error "Attempt to include more than one file." #endif #ifndef _AVR_IOM328P_H_ #define _AVR_IOM328P_H_ 1 /* Registers and associated bit numbers */ #define PINB _SFR_IO8(0x03) #define PINB0 0 #define PINB1 1 #define PINB2 2 #define PINB3 3 #define PINB4 4 #define PINB5 5 #define PINB6 6 #define PINB7 7 #define DDRB _SFR_IO8(0x04) #define DDB0 0 #define DDB1 1 #define DDB2 2 #define DDB3 3 #define DDB4 4

sfr_defs.h included in every compile via io.h contains macro definitions for accessing Special Function Registers as if they were just c language variables in iom328p.h the statement: #define PINB _SFR_IO8(0x03) the symbol PINA is mapped to the SFR at address 0x03 in SFR memory _SFR_IO8( ) is a macro (look in sfr_defs.h )‏

Why this is done in your program you #include io.h and io.h in turn includes iom328p.h (because in your project definition you picked the ATmega328p as the processor)‏ pass 1 of the compiler does all includes and macro substitutions ( in our example with PINA all occurrences of the symbol PINB in your program will be replaced with a reference to SFR 0x03)‏ This makes all SFR references look like references to C variables

Memories

Getting Digital Data Into and Out Of Initialize the ports B or D  set bits in the Data Direction Registers (DDRB and DDRD) for input or output 1 for output ; 0 for input‏ use PORTB or PORTD for output  don't forget the current limiting, series resistors use PINB or PIND for input  don't forget the pull-up resistors

Blink.c /* */ /* Name: Blink.c */ /* Author: Steflik */ /* Description: This is the MCU equivalent of Hello World, instead of saying */ /* “Hello World” it blinks an led at a one second rate */ /* */ #include //This contains definitions for all the registers locations and some // other things, must always be included #define F_CPU UL //F_CPU tells the compiler that our crystal is an 16Mhz one so it // can generate an accurate delay, must be declared above delay so // delay knows what is the value of F_CPU #include //Contains some delay functions that will generate accurate delays // of ms and us int main(void){ //In ANSI C, the main function as always an int return and using // void will give you an warning DDRB |= (1<<PB5); //Define digital pin13/PORTB5 as an output so we can blink our led while(1){ //This gives us an infinite loop, there should always be an infinite loop // in your code, because micro-controllers cant return from main // to anywhere and that will give you bad results and unpredicted // behavior PORTB |= (1<<PB5); //Turn led on, this is the led included in the arduino(digital pin 13) _delay_ms(1000); //Wait 1 second PORTB &= ~(1<<PB5); //Turn led off _delay_ms(1000); //Wait another second } return 1; }

daemons a daemon is a program that will sit in memory forever and run until the system loses power since most embedded system run forever (until they lose power) our main() should be written as a never ending loop. processing to be done can be done either in the body of the loop or asynchronously in response to an external or internal event (interrupt)‏

Interrupts How Interrupts are handled Somewhere in your program you define an Interrupt Servicing Subroutine (ISS), the compiler will put the address of this routine into the proper location in the interrupt vector (low memory)‏ When the interrupt occurs the system state is saved, a branch to the ISS is made via the interrupt vector The ISS executes and returns the state of the system and you are right where you were before the interrupt occurred

ATmega328p Interrupt Vector

What we want to do use 8 LEDs for output 8 switches for input 1 button to tell when it is OK to read the switches  to do this we should us an interrupt

The way it should work /* Interrupt handler */ { // disable interruptes // read the switches // save the data at the next location in an array // light the lights // enable interrupts } int main ()‏ { // initialize ports B & D // initial Port E for interrupt on PE2 // loop forever – this is our daemon }

volatile keyword the keyword “volatile” should be used to define any variable that may be modified inside of an interrupt handler “volatile” flags a variable to the optimizing compiler to not optimize variables with the “volatile” keyword volatile char switches = 0; volatile uint8_t flags = 0;

char & uint8_t Remember the char data type can be used for ASCII characters or a signed 8 bit integer The AVR header files define another data type that allows an unsigned 8 bit integer, this is convenient for working with gpio ports as they are not usually signed data.

internal pullups for gpio inputs on many MCUs you must add an external pullup resistor on gpio input lines Atmel MCUs have built-in internal pullup resistors  to use the internal pullups write a one to that line after it has been defined as an input line in the DDR // define Port B as all outputs and Port D as all inputs DDRB = 0xFF; DDRD = 0x00; //turn on the internal pullup resistors for Port D PORTD = 0xFF;

Setting up an interrupt handler Signal or ISR  the ISR macro has superceded the Signal macro and is the preferred way of setting up an interrupt handler ISR( name of the int from processor.h file)‏ { } ISR(SIG_PIN_CHANGE1)‏ {.... }

Pin Change Interrupts Input lines on Ports B, C and D can be set up to generate a pin change interrupt Each port has an associated mask register to enable an interrupt put a 1 into the correct position in the appropriate mask register Port B PCMSK2 Port C PCMSK1 Port D PCMSK0

PCINT Mapping PORT D PCINT77SIG_PIN_CHANGE0 PCINT66 PCINT55 PCINT44 PCINT33 PCINT22 PCINT11 PCINT00 PORT B PCINT237 SIG_PIN_CHANGE1 PCINT226 PCINT215 PCINT204 PCINT193 PCINT182 PCINT171 PCINT160

Example //set bit 2 of Port B to cause an interrupt PCMSK1 = 0x04; // set bit 2 of Port B to cause interrupt EIMSK = 0xC0; // Ext Int Mask Reg EIFR = 0xC0; // Ext Int Flag Reg DDRB & = 0xFB; // make bit 2 an input line PORTB | = 0x04; // turn on pullup ISR(SIG_PIN_CHANGE1)‏ { cli( ); // disable interrupts. sei( ); // enable interrupts }