MilisecondsTimer.cpp
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#include <avr/io.h> #include <avr/interrupt.h> #include "MillisecondTimer.h" volatile uint32_t MillisecondTimer::_counter=0; volatile uint8_t MillisecondTimer::_subCounter=0; /* * Timer 0 interrupt handler */ ISR(TIMER0_OVF_vect) { MillisecondTimer::_subCounter++; if((MillisecondTimer::_subCounter & 0x3)==0) MillisecondTimer::_counter++; TCNT0+=6; } |
Teraz możemy odmierzać czas. Potrzebuję prostego sposobu na adresowanie pinów GPIO. Oto efektywne rozwiązanie: szablony i definicje typów pozwalają uzyskać czytelny kod, a implementacja w czystym asemblerze zapewnia, że rozwiązanie jest maksymalnie wydajne.
GpioPin.h
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 |
#pragma once /* * GPIO ports */ struct GPIOB { enum { Port = 0x18, Dir = 0x17, Pin = 0x16 }; }; struct GPIOC { enum { Port = 0x15, Dir = 0x14, Pin = 0x13 }; }; struct GPIOD { enum { Port = 0x12, Dir = 0x11, Pin = 0x10 }; }; /* * Base template for all GPIO pins. Provide support for set/reset */ template<uint8_t TPort,uint8_t TPin> struct GpioPin { static void set() { asm volatile( " sbi %[port],%[pin] \n\t" :: [port] "I" (TPort), [pin] "I" (TPin) ); } static void reset() { asm volatile( " cbi %[port],%[pin] \n\t" :: [port] "I" (TPort), [pin] "I" (TPin) ); } static void changeTo(bool state) { if(state) set(); else reset(); } }; /* * GPIO output, provide support for init */ template<class TPort,uint8_t TPin> struct GpioOutputPin : GpioPin<TPort::Port,TPin> { static void setup() { asm volatile( " sbi %[port],%[pin] \n\t" :: [port] "I" (TPort::Dir), [pin] "I" (TPin) ); } }; /* * GPIO input, provide support for init, read */ template<class TPort,uint8_t TPin> struct GpioInputPin : GpioPin<TPort::Port,TPin> { static void setup() { asm volatile( " cbi %[port],%[pin] \n\t" :: [port] "I" (TPort::Dir), [pin] "I" (TPin) ); } static bool read() { uint8_t r; asm volatile( " clr %[result] \n\t" // result = 0 " sbic %[port],%[pin] \n\t" // skip next if port bit is clear " inc %[result] \n\t" // result = 1 : [result] "=r" (r) : [port] "I" (TPort::Pin), [pin] "I" (TPin) ); return r; } }; /* * All pins used in this project */ typedef GpioOutputPin<GPIOD,5> GpioLed; |
Po tych przygotowaniach napisanie funkcji main, która obsługuje miganie, jest trywialne.
Blink.cpp
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
#include <avr/io.h> #include <avr/interrupt.h> #include "GpioPin.h" #include "MillisecondTimer.h" int main() { MillisecondTimer::setup(); GpioLed::setup(); // PD5 (pin 11) sei(); for(;;) { GpioLed::set(); MillisecondTimer::delay(1000); GpioLed::reset(); MillisecondTimer::delay(1000); } // not reached return 0; } |
Kod jest już napisany i musimy go skompilować. Wykorzystuję narzędzie scons, ponieważ jest oparte na Pythonie – języku użytecznym też w innych sytuacjach.
Oto mój plik SConstruct. Wykorzystujemy program avrdude do wgrania pliku binarnego do pamięci mikrokontrolera za pomocą programatora USBAPA, a polecenie fuse ustawia zworki na wykorzystanie zewnętrznego oscylatora.
SConstruct
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
""" Usage: scons [upload] [upload] specify this option to automatically upload to using avrdude to a USBASP connected MCU. To do a 'clean' use the -c flag To do a parallel build use the -jN flag """ import os # source the environment env=Environment(ENV=os.environ) # compiler is avr-gcc env.Replace(CC="avr-gcc") env.Replace(CXX="avr-g++") env.Replace(PROGSUFFIX=".elf") # set up our options env.Replace(CXXFLAGS=["-mmcu=atmega8", "-Os", "-g", "-DF_CPU=8000000", "-std=c++11", "-Wall", "-Werror", "-Wextra", "-pedantic-errors", "-fno-rtti", "-ffunction-sections", "-fdata-sections", "-fno-exceptions"]) env.Replace(LINKFLAGS=["-Wl,-Map,blink.map", "-mrelax", "-g", "-Wl,--gc-sections", "-mmcu=atmega8"]) # compile source code to .elf binary elf=env.Program("blink",[Glob("*.cpp")]) Decider('timestamp-newer') # convert elf to hex flashable image env.Command("blink.hex",elf,"avr-objcopy -j .text -j .data -O ihex $SOURCE $TARGET") # calculate size and generate assembly source env.Command("blink.siz",elf,"avr-size $SOURCE | tee $TARGET") env.Command("blink.lst",elf,"avr-objdump -S $SOURCE > $TARGET") # upload target uses avrdude flash_cmd="avrdude -c usbasp -p m8 -e -U flash:w:blink.hex" # internal oscillator #fuse_cmd="avrdude -c usbasp -p m8 -e -U lfuse:w:0xe4:m -U hfuse:w:0xd9:m" # external crystal fuse_cmd="avrdude -c usbasp -p m8 -e -U lfuse:w:0xff:m -U hfuse:w:0xd9:m" upload=env.Alias("upload","blink.hex",flash_cmd) fuse=env.Alias("fuse","blink.hex",fuse_cmd) AlwaysBuild([upload,fuse]) |
