computer science summer term 2012 final project team 2
Post on 18-Jan-2018
218 Views
Preview:
DESCRIPTION
TRANSCRIPT
Computer Science Summer term 2012
Final Project
Team 2
Content1.- Organization 2.- Request2.- Software Development3.- Team work experience4.- Final Product
Project Manager (Salvador Reyes)Technical Managed David Tecuanhuehue
Amri Mohamed
Quality ManagedCecilia Cruz
Documentation ManagedSpandan Shroff
Amin Mitul
Integration ManagedEdgar Escobar
Rodrigo Gutierrez
Team organization
Write an ACUAS μCEasy package for the AVR Butterfly board. The following macros must be available
PROGRAM_INITPROGRAM_STARTPROGRAM_ENDVARIABLESTRINGWAIT_SEC
ACTIVATE_ADCBRIGHTNESSTEMPERATUREVOLTAGEBEEPACTIVATE_LCDINIT_UARTDATAFLASH
Request
ATMEL AVR Butterfly
ATmega169Low power designPeripherals:● 120 segment LCD● 4 Mbit external DataFlash● Programming Methods: Bootloader, SPI, Parallel, JTAG● Joystick, 4 directions● Piezo speaker● 32768 Hz oscillator for real time clock● RS232 level converter for PC● Temperature sensor● Light sensor● 3V, 600 mA button cell battery●
Request
A macro is a fragment of code which has been given a name. Whenever the name is used, it is replaced by the contents of the macro. There are two kinds of macros.
Macro…
Object-like It looks like a data object in code that uses it
function-like Resemble function calls
Software development
Macro- Function-like…#define
#define PROGRAM_INIT()
( )parentheses immediately after the macro name
Macro Arguments To define a macro that uses arguments, to insert parameters between the pair of parentheses in the macro definition is necessary.The parameters must be valid C identifiers, separated by commas and optionally whitespace.
Software development
JOYSTICK PORT/PIN CONFIGURATION
Up PB6
Down PB7
Right PE3
Left PE2
Joystick port/pin configuration
Pin configuration from the pin diagram were observed.
///Execute the following instruction if the joystick up button is pressed#define ON_JOYSTICK_UP if(!(PINB & (1 << 6)))
///Execute the following instruction if the joystick up button is not pressed#define OFF_JOYSTICK_UP if(PINB & (1 << 6))
///Wait until the joystick up button is pressed#define WAIT_FOR_JOYSTICK_UP while(PINB & (1 << 6));
///Wait until the joystick up button is released#define WAIT_FOR_RELEASE_JOYSTICK_UP while(!(PINB & (1 << 6)));
Joystick Macros
#include "projectdefinitions.h"
PROGRAM_INITPROGRAM_STARTON_JOYSTICK_UPPORTA = PORTA | 0b00000001;OFF_JOYSTICK_UPPORTA = PORTA & 0b11111110;ON_JOYSTICK_DOWNPORTA = PORTA | 0b00000010;OFF_JOYSTICK_DOWNPORTA = PORTA & 0b11111101;ON_JOYSTICK_RIGHTPORTA = PORTA | 0b00000100;OFF_JOYSTICK_RIGHT PORTA = PORTA & 0b11111011;ON_JOYSTICK_LEFTPORTA = PORTA | 0b00001000;OFF_JOYSTICK_LEFTPORTA = PORTA & 0b11110111;ON_JOYSTICK_CENTERPORTA = PORTA | 0b00010000;OFF_JOYSTICK_CENTERPORTA = PORTA & 0b11101111;PROGRAM_END
Example:
// The volume must be between a value of 0 to 100, this macro must be used to allow the sound be heard
#define BEEP_VOLUME(v) {OCR1AH = 0; OCR1AL = v;}
OCR1A is a 16 bit register. In order to modify the value of the volume of the speaker the value of this register must be modified. This register controls the PWM pulse width. Thereby it controls the power of the signal (volume).
Buzzer Macros
// The tone is a vale between 20 and 20000 in Hz (the “audible” frequencies), duration in seconds in values between 0.1 and 25
#define BEEP(tone,duration) {InitBuzzer(tone,duration);}
BEEP macro calls InitBuzzer function.
Buzzer Macros
void InitBuzzer(int f, int d){
int icr1;icr1 = 1000000/(2*f);ICR1 = icr1; // Top value of the Timer1TCCR1A = (1<<COM1A1); // Set OC1A when upcounting, clear when downcountingTCCR1B = (1<<WGM13); // Phase/Freq-correct PWM, top value = ICR1SET_BIT(TCCR1B, CS10) // Start Timer1, prescaler=1 WAIT_SEC(d) // Waits d secondsCLEAR_BIT(TCCR1B, CS10) // Stop Timer1
}
Buzzer Macros
ACTIVATE_ADC ADCSRA = (1<<ADEN); ADMUX |= (0<<REFS1) | (1<<REFS0); autoADCps();
Set ADEN bit to activate AD Converter.
Reference voltage AVCC = 5V
Function that sets the ADC prescaler value depending from clock frequency.
ADC MacrosTo switch on the AD converter
This instruction has to be executed only one time (in the PROGRAM_INIT part).
ADC_CHANNEL(ch) ADMUX &= 0b11110000;ADMUX |= (ch-1); PORTF &= ~(1 << (ch-1));
initialize channel bits (0-3)
Clear PORTF selected channel bit -->switch off pull up resistor “ch-1”
set channel “ch”.
ADC MacrosTo chose for analogue input (from 1 to 8)
ADC_CHANNEL(1) // pin 0 of port A is chosen for analogue input
ADCONVERT(x) ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);x=ADCW;
start a single conversion
Wait for completion of ADC
x acquires the value of the AD conversion
ADC Macros
The result is of 10 bit resolution and will be stored in the 16 bit variable <x>. This variable has to be previously declared
The actual conversion is started
ADCONVERTlow(x)
ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);x=ADCW >> 2;
ADC Macros
start a single conversion
Wait for completion of ADC
Shifting bit to show only 8 bits value
The actual conversion is started
The 8 most significant bits of the 10 bit result will be stored in the 8 bit variable <x>.
ADCONVERT_MV(x) ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC);x=ADCW*5./1.024;
start a single conversion
Wait for completion of ADC
Shifting bit to show only 8 bits value
ADC MacrosThe actual conversion is started
Performs a 10 bit AD conversion and store the result in mV in an integer or float variable x.
Example:
#include “easybutterfly.h“ // library for ButerflyPROGRAM_INITVAR16(mvolt) // Declares a 16 bit unsigned variableACTIVATE_ADC // To switch on the AD converterADC_CHANNEL(1) // Select pin 0 of the ADC
multiplexerPROGRAM_STARTADCONVERT_MV(mvolt) //The AD conversion is executed
and store in // the variable “mvolt”PROGRAM_END
ADC Macros
// Perform a 10 bit AD conversion from the value of the brightness sensor and store the value in a 8 bit variable
#define BRIGHTNESS(x) {ACTIVATE_ADC ADC_CHANNEL(3) ADCONVERTlow(x)}
The BRIGHTNESS macro uses the macros of the ADC previously
defined, the output of the brightness sensor is input in thePORTF2, the result of the conversion is a 8 bits value.
Brightness
// Perform a 10 bit AD conversion from the value of the V_in pin and store the result in volts in an integer (or double or float) variable
#define VOLTAGE(x) {ACTIVATE_ADC ADC_CHANNEL(2) ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC); ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC); x=ADCW*5.0/1023.0;}
The VOLTAGE macro uses some macros of the ADC previouslydefined, the input for the V_in pin is the PORTF1,the result of the conversion is a float value that can be stored in aninteger (or double or float) variable.
Voltage Measurement
#define TEMPERATURE(x) {ACTIVATE_ADC ADC_CHANNEL(1) ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC); ADCSRA |= (1<<ADSC); loop_until_bit_is_clear(ADCSRA,ADSC); int adc=ADCW; float t=adc/(1024-adc); float r=log(t); x=4250/(r+14.2617)-273;}
The TEMPERATURE macro uses some macros of the ADC previouslydefined, the output of the temperature sensor is input in the PORTF0,the result of the conversion is a float value that can be stored in aninteger (or double or float) variable.
Temperature Measurement
LCD Macros#define ACTIVATE_LCD LCD_Init (); //Macro to initialize the LCD
#define CLEAR_LCD LCD_Clear(); //Macro to clear the LCD
#define LCD_CHAR(character) LCD_putc(character); //Macro to write a character on the LCD
#define LCD_TEXT(pStr) LCD_puts(pStr); //Macro to write a string on the LCD
#define LCD_NUMBER(v) {itoa(v,lcd_str,10); LCD_puts(lcd_str);};//Macro to write a number on the LCD
#define LCD_D_NUMBER(v,w,p) {dtostrf((v),w,p,lcd_str); LCD_puts(lcd_str);};//Macro to write a float on the LCD
LCD MacrosKey Variables
char gTextBuffer[TEXTBUFFER_SIZE];// Buffer that contains the text to be displayed
char gScroll;// Only six letters can be shown on the LCD.
unsigned int LCD_character_table[] PROGMEM ={ 0x0A51, // '*' (?) 0x2A80, // '+' 0x0000, // ',' (Not defined) 0x0A00, // '-' 0x4000, // '.' Degree sign
LCD Macros
LCD Segments Connections on the STK502
• The LCD glass has in total 120 segments
LCD MacrosLCD digit segment mapping into the LCD Data Registers
#include "projectdefinitions.h"PROGRAM_INITACTIVATE_LCD // initialize the LCD. The output begins at the first position of the display.CLEAR_LCD // Clears the LCD screen.
PROGRAM_START
LCD_TEXT("HALLO WIE GEHTS")WAIT_SEC(25)CLEAR_LCD // Clears the LCD screen.LCD_CHAR (‘G')WAIT_SEC(10)CLEAR_LCD // Clears the LCD screen.LCD_D_NUMBER(11.31,1,2)WAIT_SEC(5)CLEAR_LCD // Clears the LCD screen.
PROGRAM_END
Example LCD Macro :
UART:
UART is Available on pin header J406With level converters
Connections : Just connect TxD , RxD and GND
with Vcc min 2.0V
uart.c File Reference :
Uart Macros:UART_TEXTUART_TEXT_CONSTUART_NUMBERUART_CHARUART_CRLF
UART_READ_CHARUART_READ_LINE
#define INIT_UART {uart_init( UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU) ); sei();}
Initialises the UART. Must be invoked in the PROGRAM_INIT part. Sets frame format: asynchronous, 8 data bits, no parity, 1
stop bit
#define UART_TEXT(string) uart_puts((char*) string);
Sends a string which is located in SRAM over UART
#define UART_TEXT_CONST(string) uart_puts_p(string);
Sends a string which is located in flash ROM over UART. The string must be declared as: static const char PText[] PROGMEM = "text"
Macros definition:
#define UART_NUMBER (x) {itoa( x, (char*)uart_str, 10); uart_puts((char*)uart_str);}
Used to ”Sends a number over UART“
#define UART_CHAR(c) uart_putc(c);Used to ”Sends one character over UART“
#define UART_CRLF uart_putc(13) ; uart_putc(10) ;Used to ”Sends a linefeed over UART“
#define UART_READ_CHAR(c) c = uart_getc();Used to ”Reads one character from UART“
#define UART_READ_LINE(c_array,max_char) uart_read_line((c_array), (max_char), 3)
Used to ”Reads a Line from UART“
DataFlash is a low pin-count serial interface for flash memory compatible with the SPI standard.
The DataFlash only supports the most commonly used SPI modes, 0 and 3.
Dataflash Memory
DATAFLASH Architecture
INIT_DFInitialize the communication with the dataflash
via SPIEND_DF
Disable the communication with the dataflash
Dataflash Macros
WRITE_BYTE_BUFFER(IntPageAdr, Data)Writes a byte in the buffer
WRITE_STR_BUFFER(IntPageAdr, NB, string)Writes a string in the buffer
BUFFER_TO_DF(PageAdr)Sends the buffer information in to a page
address of the dataflash
Dataflash Macro for writing
DF_TO_BUFFER(PageAdr)Reads the data in a page address of the buffer
and sends the information to the buffer.READ_STR_BUFFER(IntPageAdr, NB, string)
Reads a string in the internal address of the buffer to save it into an array
READ_BYTE_BUFFER(IntPageAdr)Reads a byte from the buffer
Dataflash Macro for reading
#include "projectdefinitions.h"#include <avr/delay.h>
int main(void) {
INIT_DF unsigned char Word[4]; Word[0]= ‘T'; Word[1]= 'e'; Word[2]= ‘a'; Word[3]= ‘m';
WRITE_STR_BUFFER(1,8,Word) _delay_ms(100); BUFFER_TO_DF(1)END_DF
Example Dataflash Macro :
unsigned char FRIEND[8] = {0};
while(1)
{ ACTIVATE_LCD CLEAR_LCD
INIT_DF DF_TO_BUFFER(2) READ_STR_BUFFER(1, 8, FRIEND) LCD_TEXT(FRIEND) _delay_ms(2000); END_DF }}
GoodCan be improved
Team work experience
top related