Software Design Considerations, Narrative and Documentation

Transcription

1 Software Design Considerations, Narrative and Documentation Introduction The project under consideration is an automated shopping cart designed to follow a shopper around a simulated supermarket environment. An ultrasonic beacon is planted on the shopper. The cart tracks the shopper s movements by measuring the relative strength of the signals picked up by the ultrasonic receivers mounted on the different ends of the cart. The key responsibilities of the software running on the microcontroller on the cart are: To regularly poll the ultrasonic receivers and triangulate the shopper s position To use the data collected from the ultrasonic polling to determine the mode of operation To adjust the speeds of the motors driving the cart based on distance, bearing and mode of operation To take evasive action when the infrared proximity sensors are tripped Software Design Considerations Memory Models An Atmel ATMega32L microcontroller is used to operate the cart. This device is equipped with 32Kb of flash memory (program space) and 2Kb of SRAM for supporting run-time data and a program stack. This amount of storage space is sufficient to meet the modest requirements of the project, while leaving ample room for future expansion. The ATMega32L also provides 1Kb of EEPROM. However, the project does not utilize nonvolatile data and thus does not make use of this space. Page 1 of 16

2 Memory Sections and Mapping The ATMega32L s physical memory space is divided into three smaller memory spaces that are all linear and regular. These are: Data Memory Space: The data memory space is used to store and access all run-time data. The lowest 32 addresses of the data memory space access the register file that comprises 32 general purpose registers. These are typically used to hold values of operands and the results of intermediate operations while executing instructions. The next 64 addresses are the memory-mapped I/O ports and peripheral registers (also known as the I/O space). The remainder of the data memory space accesses the internal SRAM which is used to store volatile variables and the program stack. Figure 1 - Data Memory Space Mapping Program Memory Space: The program memory space (flash memory) holds the application code and other read-only data. The 32Kb of flash memory is wordaddressable i.e. it is organized as 16k x 16. The program memory space is further divided Page 2 of 16

3 into an application flash section and a boot loader flash section. While the former contains the software to operate the microcontroller, the latter section houses boot loader code that can be used to automatically upgrade the firmware. Figure 2 - Program Memory Space Mapping EEPROM Memory Space: The ATMega32L also contains a 1Kb, byte-addressable EEPROM memory space to hold non-volatile data. Due to the nature of the project, this space is not used by the design. All of the software development has been done in C and compiled using the CodeVision C Compiler for Atmel AVR. As a result, the programmer has been released from the burden of organizing the code neatly in memory and ensuring the correct memory mappings. Further details about the memory organization of the microcontroller may be found in the ATMega32L datasheet [1]. Page 3 of 16

4 Startup Code The startup code has some important duties to fulfill including: Initializing the stack pointer Allocating space for global variables Copying the value of initialized variables to the appropriate memory locations in the data section Jumping to main() Once again, thanks to the CodeVision Wizard that automatically generates startup code, the programmer is freed from the burden of having to write it. Organization of Embedded Application Code The software takes readings from the ultrasonic and infrared sensors and adjusts the speeds of the motors driving the cart appropriately. The infrared sensors produce a digital output signal that can be read instantly. The ultrasonic sensors on the other hand output an analog voltage value that is converted to a digital value by the microcontroller s A-D unit. The algorithm to adjust the motor speeds varies the duty cycles of the PWM output signals. The application code is organized in a command-driven fashion i.e. as a combination of program-driven and interrupt-driven modules. The infrared sensors generate external interrupt requests when they are tripped. One of the on-board timer modules is used to generate a periodic interrupt, the servicing of which polls the A-D inputs. The main loop of the program uses the current and past voltage samples read by the A-D unit to adjust the PWM duty cycles appropriately. Page 4 of 16

5 Software Design Narrative Function Signature: void main(void); Return Value: None Parameters: None Description: This function is the entry point of the program. Its first act is to initialize all the on-board peripherals via a call to initperipherals(). It then sets the global interrupt enable bit before entering the main loop. The main loop is a work in progress. The current algorithm (refer to flowchart in Fig. 3) adjusts the duty cycles of the drive motors in an attempt to make the ultrasonic voltage readings converge to an equilibrium value. While this algorithm enables the cart to follow a person, it is not capable of distinguishing between the different modes of operation. A more sophisticated algorithm that tweaks the drive motor duty cycle based on a sequence of previously observed voltage samples is required to realize this function. Function Signature: void initperipherals(void); Return Value: None Parameters: None Description: This procedure initializes the microcontroller peripherals and I/O ports as shown in the following table: Table 1 - Peripheral / Port Initialization Settings Peripheral / Port Register Settings Purpose Port A Port B Port C PORTA = 0x00 DDRA = 0x00 PORTB = 0x00 DDRB = 0x08 PORTC = 0x00 DDRC = 0x00 Port A configured as an input port. Pins PA0, PA1 and PA2 are the inputs to the A-D unit All port B pins other than PB3 are configured as inputs. PB3 outputs the PWM signal for the left drive motor Port C is unused and configured as an input port Page 5 of 16

6 Peripheral / Port Register Settings Purpose Port D Timer 0 Timer 1 Timer 2 External Interrupts A-D Unit PORTD = 0x00 DDRD = 0x80 TCCR0=0x61; TCNT0=0x00; OCR0=0xff; TCCR1A=0x00; TCCR1B=0x01; TCNT1H=0x00; TCNT1L=0x00; ICR1H=0x00; ICR1L=0x00; OCR1AH=0x01; OCR1AL=0xF4; OCR1BH=0x00; OCR1BL=0x00; ASSR=0x00; TCCR2=0x61; TCNT2=0x00; OCR2=0xff; GICR=0xC0; MCUCR=0x00; MCUCSR=0x00; GIFR=0xC0; ADMUX=0x60; ADCSRA=0x83; SFIOR&=0xEF; All port D pins other than PD7 are configured as inputs. PD7 outputs the PWM signal for the right motor. PD2 and PD3 are the external interrupt pins wired to the left and right infrared sensors respectively Timer 0 is configured to generate a PWM signal with variable duty cycle for the left drive motor Timer 1 is configured to generate a periodic interrupt every 0.5ms Timer 2 is configured to generate a PWM signal with variable duty cycle for the right drive motor External interrupts 0 and 1 are enabled to generate requests when the pins INT0 and INT1 are pulled low The A-D unit is configured to use the AVCC pin as the voltage reference and return the result of the conversion as an 8-bit value This initialization code was automatically generated by the CodeVision Wizard. Function Signature: void leftinfraredisr(void); Return Value: None Parameters: None Page 6 of 16

7 Description: This is the interrupt service routine for the INT0 pin that is wired to the infrared sensor mounted on the front left end of the cart. When the sensor is tripped and the ISR executed, the right motor (the one opposite the tripped sensor) is turned off. This causes the cart to swivel about its right wheel, steering away from the obstacle. Lastly, the routine clears the periodic timer interrupt flag. This ensures that periodic timer interrupts (that poll the A-D unit and cause the cart to follow the shopper) are ignored while the cart attempts to steer around an obstacle. Function Signature: void rightinfraredisr(void); Return Value: None Parameters: None Description: This is the interrupt service routine for the INT1 pin that is wired to the infrared sensor mounted on the front right end of the cart. It implements the same algorithm as the function leftinfraredisr(), except it controls the left wheel. Function Signature: void pollad(void); Return Value: None Parameters: None Description: This routine services the periodic interrupts generated by timer 1. It implements the algorithm depicted by the flowchart in Fig. 4. The ultrasonic receivers mounted on the front end of the carts are first polled. If both of these register no signal, only then is the rear sensor polled. The voltage readings are then stored in global variables to be read by the motor speed adjustment algorithm. The program will also need to keep track of past voltage readings to decode the operation mode. This will be achieved by storing the values read into a circular buffer. Function Signature: unsigned char readad(unsigned char adcinput); Return Value: The converted value of the analog voltage Parameters: The channel to convert Description: This automatically generated code segment converts the analog voltage input on the specified channel into a digital value and returns this 8-bit value. Page 7 of 16

8 Software Documentation Flowcharts Start Initialize on-board peripherals Enable global interrupts Note: Interrupt requests are not explicitly mentioned in the flowchart and may affect program flow. Once the interrupt has been serviced, control is restored to the point from where the jump was made. Read the last sampled front left, front right and rear voltages Turn off both motors Are front left and right voltages non-zero? Y Compute values by which to step up motor duty cycles based on the difference between equilibrium voltage and current voltage N N Is rear voltage non-zero? Y Turn on left motor, turn off the right motor Update the PWM duty cycle Figure 3 Main Loop Flowchart Page 8 of 16

9 Start Clear the interrupt flag Perform an A-D conversion on channel 0 (front left receiver) Perform an A-D conversion on channel 1 (front right receiver) Are front left and right voltages zero? N Y Perform an A-D conversion on channel 2 (rear receiver) Store sampled voltages in global data structure Return Figure 4 Periodic Interrupt Service Routine Page 9 of 16

10 Code Listing /***************************************************** This program was produced by the CodeWizardAVR V1.24.3b Standard Automatic Program Generator Copyright Pavel Haiduc, HP InfoTech s.r.l. Project : The Digijokers Version : Date : 11/8/2004 Author : Raghuram Ramanujan & Clive Lopez Company : Purdue University Comments: ECE 477 Group 8 Chip type : ATmega16 Program type : Application Clock frequency : MHz Memory model : Small External SRAM size : 0 Data Stack size : 256 *****************************************************/ #include <mega16.h> // Symbolic constants #define ADC_VREF_TYPE 0x60 #define TOLERANCE 0 #define NUM_SAMPLES 10 #define NUM_STEPS 2 #define EQBM_VOLTAGE 0x7f #define TRUE 1 #define FALSE 0 // Macros #define ISEQUAL(x, y) ((x >= y - TOLERANCE) && (x <= y + TOLERANCE)) #define ISLESS(x, y) (x < y - TOLERANCE) #define ISGREATER(x, y) (x > y + TOLERANCE) // Global variables unsigned char pastfrontleftsamples[num_samples] = 0; unsigned char pastfrontrightsamples[num_samples] = 0; Page 10 of 16

11 unsigned char pastrearsamples[num_samples] = 0; // Function prototypes unsigned char readad(unsigned char); void initperipherals(void); // External Interrupt 0 service routine interrupt [EXT_INT0] void leftinfraredisr(void) // Clear interrupt flag GIFR = 0x40; // Turn off right side motor OCR2 &= 0x00; // Clear timer interrupt flag to override A-D polling TIFR = 0x10; // External Interrupt 1 service routine interrupt [EXT_INT1] void rightinfraredisr(void) // Clear interrupt flag GIFR = 0x80; // Turn off left side motor OCR0 &= 0x00; // Clear timer interrupt flag to override A-D polling TIFR = 0x10; // Timer 1 output compare A interrupt service routine interrupt [TIM1_COMPA] void pollad(void) unsigned char channeltoconvert; unsigned char frontleftvoltage; unsigned char frontrightvoltage; unsigned char rearvoltage = 0; // Clear the timer interrupt flag TIFR = 0x10; // Read voltage on channel 0 - front left ultrasonic channeltoconvert = 0; frontleftvoltage = readad(channeltoconvert); Page 11 of 16

12 // Read voltage on channel 1 - front right ultrasonic channeltoconvert = 1; frontrightvoltage = readad(channeltoconvert); // If both the front receivers are not picking up anything, check the // receiver at the back end if (ISEQUAL(frontLeftVoltage, 0) && ISEQUAL(frontRightVoltage, 0)) channeltoconvert = 2; rearvoltage = readad(channeltoconvert); // Overwrite old samples /*for (i = 9; i > 0; i--) pastfrontleftsamples[i] = pastfrontleftsamples[i - 1]; pastfrontrightsamples[i] = pastfrontrightsamples[i - 1]; pastrearsamples[i] = pastrearsamples[i - 1]; */ pastfrontleftsamples[0] = frontleftvoltage; pastfrontrightsamples[0] = frontrightvoltage; pastrearsamples[0] = rearvoltage; return; // Read the 8 most significant bits of the AD conversion result unsigned char readad(unsigned char adcinput) // Set up ADMUX register to perform conversion on specified channel, // with result left-adjusted and truncated to 8 bits using AVCC as // reference voltage ADMUX = adcinput ADC_VREF_TYPE; // Start the AD conversion ADCSRA = 0x40; // Wait for the AD conversion to complete while ((ADCSRA & 0x10) == 0); // Clear the AD interrupt flag (just in case) ADCSRA = 0x10; return ADCH; Page 12 of 16

13 void initperipherals(void) // Input/Output Ports initialization // Port A initialization // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTA=0x00; DDRA=0x00; // Port B initialization // Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=0 State2=T State1=T State0=T PORTB=0x00; DDRB=0x08; // Port C initialization // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTC=0x00; DDRC=0x00; // Port D initialization // Func7=Out Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=0 State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTD=0x00; DDRD=0x80; // Timer/Counter 0 initialization // Clock source: System Clock // Clock value: khz // Mode: Phase correct PWM top=ffh // OC0 output: Non-Inverted PWM TCCR0=0x61; TCNT0=0x00; OCR0=0xff; // Timer/Counter 1 initialization // Clock source: System Clock // Clock value: khz // Mode: Normal top=ffffh // OC1A output: Discon. Page 13 of 16

14 // OC1B output: Discon. // Noise Canceler: Off // Input Capture on Falling Edge TCCR1A=0x00; TCCR1B=0x01; TCNT1H=0x00; TCNT1L=0x00; ICR1H=0x00; ICR1L=0x00; OCR1AH=0x01; OCR1AL=0xF4; OCR1BH=0x00; OCR1BL=0x00; // Timer/Counter 2 initialization // Clock source: System Clock // Clock value: khz // Mode: Phase correct PWM top=ffh // OC2 output: Non-Inverted PWM ASSR=0x00; TCCR2=0x61; TCNT2=0x00; OCR2=0xff; // External Interrupt(s) initialization // INT0: On // INT0 Mode: Low level // INT1: On // INT1 Mode: Low level // INT2: Off GICR =0xC0; MCUCR=0x00; MCUCSR=0x00; GIFR=0xC0; // Timer(s)/Counter(s) Interrupt(s) initialization TIMSK=0x10; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=0x80; SFIOR=0x00; // ADC initialization // ADC Clock frequency: khz Page 14 of 16

15 // ADC Voltage Reference: AVCC pin // ADC High Speed Mode: Off // ADC Auto Trigger Source: None // Only the 8 most significant bits of // the AD conversion result are used ADMUX=ADC_VREF_TYPE; ADCSRA=0x83; SFIOR&=0xEF; // Watchdog Timer initialization // Watchdog Timer Prescaler: OSC/512k // Disable watchdog for debugging purposes - will uncomment these lines later //WDTCR=0x1D; //WDTCR=0x0D; return; void main(void) unsigned char frontleftvoltage; unsigned char frontrightvoltage; unsigned char rearvoltage; unsigned char frontleftstepvalue; unsigned char frontrightstepvalue; // Initialize peripherals, configure ports initperipherals(); // Global enable interrupts #asm("sei") // Main loop while (1) // Hold voltage values constant while stepping through this algorithm - // otherwise, an interrupt could change these values in mid-execution with // unpredictable effects frontleftvoltage = pastfrontleftsamples[0]; frontrightvoltage = pastfrontrightsamples[0]; rearvoltage = pastrearsamples[0]; if (!ISEQUAL(frontLeftVoltage, 0) &&!ISEQUAL(frontRightVoltage, 0)) frontleftstepvalue = (EQBM_VOLTAGE - frontleftvoltage) >> NUM_STEPS; frontrightstepvalue = (EQBM_VOLTAGE - frontrightvoltage) >> NUM_STEPS; Page 15 of 16

16 OCR0 += frontleftstepvalue; OCR2 += frontrightstepvalue; else if (!ISEQUAL(rearVoltage, 0)) OCR0 = 0xff; OCR2 = 0x00; else OCR0 = 0x00; OCR2 = 0x00; References [1] Atmel Corporation, AVR ATMega32/ATMega32L Microcontroller Datasheet Page 16 of 16