4.30 score from hupso.pl for:
pieter-jan.com



HTML Content


Titlepieter-jan.com | creativity in automation & more

Length: 52, Words: 7
Description pusty

Length: 0, Words: 0
Keywords pusty
Robots
Charset UTF-8
Og Meta - Title pusty
Og Meta - Description pusty
Og Meta - Site name pusty
Tytuł powinien zawierać pomiędzy 10 a 70 znaków (ze spacjami), a mniej niż 12 słów w długości.
Meta opis powinien zawierać pomiędzy 50 a 160 znaków (łącznie ze spacjami), a mniej niż 24 słów w długości.
Kodowanie znaków powinny być określone , UTF-8 jest chyba najlepszy zestaw znaków, aby przejść z powodu UTF-8 jest bardziej międzynarodowy kodowaniem.
Otwarte obiekty wykresu powinny być obecne w stronie internetowej (więcej informacji na temat protokołu OpenGraph: http://ogp.me/)

SEO Content

Words/Characters 14206
Text/HTML 42.99 %
Headings H1 1
H2 44
H3 24
H4 3
H5 0
H6 0
H1
pieter-jan.com
H2
main menu
low level programming of the raspberry pi in c
getting started
gpio
i2c
github repository
diy raspberry pi breakout cable
reading a imu without kalman: the complementary filter
why do i need a filter?
the complementary filter
replacing the raspberry pi's sd card socket
choosing an appropriate replacement slot
desoldering the remainders of the old slot & soldering the new slot in place
enjoying the enhanced pi
reading nintendo 64 controller with pic microcontroller
connector
hardware
interface
the full assembly (asm) program
video
getting the angular position from gyroscope data
a little math
the gyroscope sensor
the arduino program
the pic program
results
setting up the raspberry pi for programming from mac os x
step 1: prepare the sd-card
step 2: basic configurations
step 3: find out the raspberry pi's ip adres
step 4: connect to the raspberry pi from your mac
step 5: setup a basic programming environment
universal/jamming gripper prototype
hacking the hobbyking hk401b gyroscope module
four (4) independent pwm-signals generated with one pic
the signal
prototype
program structure
the c program
results
narf keypoint test
custom roi (region of interest) with opencv
bachelor assignment
articles
H3
example - blink a led
example 1 - real time clock (rtc)
example 2 - imu (mpu6050)
mpu6050.h
mpu6050.c
tags:
tags:
the problem with accelerometers
the problem with gyroscopes
tags:
tags:
signal shapes
controller data
polling signal
reading the controller data
tags:
tags:
tags:
tags:
tags:
tags:
tags:
tags:
tags:
H4 rpi.h
rpi.c
main.c
H5
H6
strong
add the macro's below to our header file (rpi.h)
#define inp_gpio(g) *(gpio.addr + ((g)/10)) &= ~(7<<(((g)%10)*3))
#define out_gpio(g) *(gpio.addr + ((g)/10)) |= (1<<(((g)%10)*3))
#define set_gpio_alt(g,a) *(gpio.addr + (((g)/10))) |= (((a)<=3?(a) + 4:(a)==4?3:2)<<(((g)%10)*3))
#define gpio_set *(gpio.addr + 7)
#define gpio_read(g) *(gpio.addr + 13) &= (1<<(g))
adding the following macro's to our rpi.h file
combinations
add the following functions to our rpi.c file
sda
scl
it's so easy!
epic stuff
split the cable in 2 pieces
seperate the individual wires
strip them
solder them to the 1x13 header
3.3v
very fast
1 us takes only 5 instruction cycles
zero
one
0b000000011
2.65v
107.42 mv/deg./s
break open
desolder the gyroscope
three parts
no wires attached to it
build flying stuff
finding a way to control the speed of the motors
a brushless dc motor is a permanent magnet ac motor with a block waveform
esc
generate a pwm-signal of 100hz (period 10ms) with a duty cycle that is variable between 10% and 20%
pic16f684 with 128 bytes of ram and 2048 words of flash
sorting the pulses from short to long
cut my code into three big pieces
part 1: 0 - 1 ms
part 2: 1 - 2 ms
part 3: 2 - 8 ms
license free variant
b
add the macro's below to our header file (rpi.h)
#define inp_gpio(g) *(gpio.addr + ((g)/10)) &= ~(7<<(((g)%10)*3))
#define out_gpio(g) *(gpio.addr + ((g)/10)) |= (1<<(((g)%10)*3))
#define set_gpio_alt(g,a) *(gpio.addr + (((g)/10))) |= (((a)<=3?(a) + 4:(a)==4?3:2)<<(((g)%10)*3))
#define gpio_set *(gpio.addr + 7)
#define gpio_read(g) *(gpio.addr + 13) &= (1<<(g))
adding the following macro's to our rpi.h file
combinations
add the following functions to our rpi.c file
sda
scl
it's so easy!
epic stuff
split the cable in 2 pieces
seperate the individual wires
strip them
solder them to the 1x13 header
3.3v
very fast
1 us takes only 5 instruction cycles
zero
one
0b000000011
2.65v
107.42 mv/deg./s
break open
desolder the gyroscope
three parts
no wires attached to it
build flying stuff
finding a way to control the speed of the motors
a brushless dc motor is a permanent magnet ac motor with a block waveform
esc
generate a pwm-signal of 100hz (period 10ms) with a duty cycle that is variable between 10% and 20%
pic16f684 with 128 bytes of ram and 2048 words of flash
sorting the pulses from short to long
cut my code into three big pieces
part 1: 0 - 1 ms
part 2: 1 - 2 ms
part 3: 2 - 8 ms
license free variant
i
add the macro's below to our header file (rpi.h)
#define inp_gpio(g) *(gpio.addr + ((g)/10)) &= ~(7<<(((g)%10)*3))
#define out_gpio(g) *(gpio.addr + ((g)/10)) |= (1<<(((g)%10)*3))
#define set_gpio_alt(g,a) *(gpio.addr + (((g)/10))) |= (((a)<=3?(a) + 4:(a)==4?3:2)<<(((g)%10)*3))
#define gpio_set *(gpio.addr + 7)
#define gpio_read(g) *(gpio.addr + 13) &= (1<<(g))
adding the following macro's to our rpi.h file
combinations
add the following functions to our rpi.c file
sda
scl
it's so easy!
epic stuff
split the cable in 2 pieces
seperate the individual wires
strip them
solder them to the 1x13 header
3.3v
very fast
1 us takes only 5 instruction cycles
zero
one
0b000000011
2.65v
107.42 mv/deg./s
break open
desolder the gyroscope
three parts
no wires attached to it
build flying stuff
finding a way to control the speed of the motors
a brushless dc motor is a permanent magnet ac motor with a block waveform
esc
generate a pwm-signal of 100hz (period 10ms) with a duty cycle that is variable between 10% and 20%
pic16f684 with 128 bytes of ram and 2048 words of flash
sorting the pulses from short to long
cut my code into three big pieces
part 1: 0 - 1 ms
part 2: 1 - 2 ms
part 3: 2 - 8 ms
license free variant
em
Bolds strong 41
b 41
i 41
em 0
Zawartość strony internetowej powinno zawierać więcej niż 250 słów, z stopa tekst / kod jest wyższy niż 20%.
Pozycji używać znaczników (h1, h2, h3, ...), aby określić temat sekcji lub ustępów na stronie, ale zwykle, użyj mniej niż 6 dla każdego tagu pozycje zachować swoją stronę zwięzły.
Styl używać silnych i kursywy znaczniki podkreślić swoje słowa kluczowe swojej stronie, ale nie nadużywać (mniej niż 16 silnych tagi i 16 znaczników kursywy)

Statystyki strony

twitter:title pusty
twitter:description pusty
google+ itemprop=name pusty
Pliki zewnętrzne 11
Pliki CSS 1
Pliki javascript 10
Plik należy zmniejszyć całkowite odwołanie plików (CSS + JavaScript) do 7-8 maksymalnie.

Linki wewnętrzne i zewnętrzne

Linki 148
Linki wewnętrzne 56
Linki zewnętrzne 92
Linki bez atrybutu Title 145
Linki z atrybutem NOFOLLOW 0
Linki - Użyj atrybutu tytuł dla każdego łącza. Nofollow link jest link, który nie pozwala wyszukiwarkom boty zrealizują są odnośniki no follow. Należy zwracać uwagę na ich użytkowania

Linki wewnętrzne

skip to main content #main-content
- /
pieter-jan.com /
home /
contact /contact
low level programming of the raspberry pi in c /node/15
- /images/rpi_lowlevelprogramming/gpsel_layout.png
- /images/rpi_lowlevelprogramming/gpset0_location.png
raspberry pi /taxonomy/term/1
diy raspberry pi breakout cable /node/14
raspberry pi /taxonomy/term/1
reading a imu without kalman: the complementary filter /node/11
complementary filter /taxonomy/term/11
gyroscope /taxonomy/term/12
accelerometer /taxonomy/term/13
imu /taxonomy/term/14
quadrocopter /taxonomy/term/9
replacing the raspberry pi's sd card socket /node/12
raspberry pi /taxonomy/term/1
reading nintendo 64 controller with pic microcontroller /node/10
microcontrollers /taxonomy/term/5
getting the angular position from gyroscope data /node/7
quadrocopter /taxonomy/term/9
setting up the raspberry pi for programming from mac os x /node/4
raspberry pi /taxonomy/term/1
universal/jamming gripper prototype /node/13
mechanics /taxonomy/term/8
grippers /taxonomy/term/16
robotics /taxonomy/term/4
hacking the hobbyking hk401b gyroscope module /node/3
quadrocopter /taxonomy/term/9
four (4) independent pwm-signals generated with one pic /node/6
quadrocopter /taxonomy/term/9
microcontrollers /taxonomy/term/5
narf keypoint test /node/17
kinect /taxonomy/term/7
computer vision /taxonomy/term/3
custom roi (region of interest) with opencv /node/5
computer vision /taxonomy/term/3
bachelor assignment /node/2
microcontrollers /taxonomy/term/5
mechanics /taxonomy/term/8
low level programming of the raspberry pi in c /node/15
diy raspberry pi breakout cable /node/14
reading a imu without kalman: the complementary filter /node/11
replacing the raspberry pi's sd card socket /node/12
reading nintendo 64 controller with pic microcontroller /node/10
getting the angular position from gyroscope data /node/7
setting up the raspberry pi for programming from mac os x /node/4
universal/jamming gripper prototype /node/13
hacking the hobbyking hk401b gyroscope module /node/3
four (4) independent pwm-signals generated with one pic /node/6
narf keypoint test /node/17
custom roi (region of interest) with opencv /node/5
bachelor assignment /node/2

Linki zewnętrzne

bcm2835 arm peripherals manual http://www.raspberrypi.org/wp-content/uploads/2012/02/bcm2835-arm-peripherals.pdf
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
perror http://www.opengroup.org/onlinepubs/009695399/functions/perror.html
modulo % operator http://en.wikipedia.org/wiki/modulo_operation
pinout http://www.hobbytronics.co.uk/image/data/tutorial/raspberry-pi/gpio-pinout.jpg
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
pinout http://www.hobbytronics.co.uk/image/data/tutorial/raspberry-pi/gpio-pinout.jpg
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
printf http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
contact me http://www.pieter-jan.com/contact
https://github.com/pieter-jan/pj_rpi https://github.com/pieter-jan/pj_rpi
- http://www.pieter-jan.com/images/rpi_breakout/rpi_breakout_1.jpg
- http://www.pieter-jan.com/images/rpi_breakout/rpi_breakout_2.jpg
- http://www.pieter-jan.com/images/rpi_breakout/rpi_breakout_3.jpg
- http://www.pieter-jan.com/images/rpi_breakout/rpi_breakout_4.jpg
- http://www.pieter-jan.com/images/rpi_breakout/rpi_breakout_5.jpg
atan2 http://en.wikipedia.org/wiki/atan2
in one of the previous articles http://www.pieter-jan.com/node/7
abs http://www.opengroup.org/onlinepubs/009695399/functions/abs.html
abs http://www.opengroup.org/onlinepubs/009695399/functions/abs.html
abs http://www.opengroup.org/onlinepubs/009695399/functions/abs.html
- http://www.pieter-jan.com/images/complementary_filter.png
- http://www.pieter-jan.com/images/rpi_sd/rpi_conn.png
- http://www.pieter-jan.com/images/rpi_sd/sd11_conn.png
- http://www.pieter-jan.com/images/rpi_sd/resolderedpi1.jpg
- http://www.pieter-jan.com/images/rpi_sd/resolderedpi2.jpg
- http://www.pieter-jan.com/images/rpi_sd/pibow.jpg
- http://www.pieter-jan.com/images/n64_controller/n6controller.jpg
pickit2 http://www.microchip.com/stellent/idcplg?idcservice=ss_get_page&nodeid=1406&ddocname=en023805&redirects=pickit2
icsp http://en.wikipedia.org/wiki/in-circuit_serial_programming
- http://www.pieter-jan.com/images/n64_controller/n64converterprototype.jpg
one wire http://en.wikipedia.org/wiki/1-wire
low-level programming language http://en.wikipedia.org/wiki/low-level_programming_language
pic instructions http://tutor.al-williams.com/pic-inst.html
here http://ww1.microchip.com/downloads/en/devicedoc/39500a.pdf
- http://www.pieter-jan.com/images/n64_controller/pollsignal.jpg
- http://www.pieter-jan.com/images/n64_controller/signalshapes.jpg
- http://www.pieter-jan.com/images/n64_controller/responsebnotpressed.jpg
- http://www.pieter-jan.com/images/n64_controller/responsebpressed.jpg
indirect addressing http://www.pictutorials.com/indirect_addressing_exam.htm
webpage http://tutor.al-williams.com/pic-inst.html
i hacked in a previous article http://www.pieter-jan.com/node/3
previous article http://www.pieter-jan.com/node/3
hi-tech c lite compiler http://www.htsoft.com
here http://www.pieter-jan.com/node/11
ssh http://en.wikipedia.org/wiki/secure_shell
http://www.raspberrypi.org/downloads/ http://www.raspberrypi.org/downloads
the elinux website http://elinux.org/rpi_easy_sd_card_setup#copying_an_image_to_the_sd_card_in_mac_os_x
- http://www.pieter-jan.com/images/rpi_sd.png
- http://www.pieter-jan.com/images/raspi-config.jpg
- http://www.pieter-jan.com/images/internet_sharing.png
- http://www.pieter-jan.com/images/ssh.png
vim http://www.vim.org
tutorial http://linuxconfig.org/vim_tutorial
- http://www.pieter-jan.com/images/helloworld.png
low level programming of the raspberry pi http://www.pieter-jan.com/node/15
universal/jamming gripper http://www.youtube.com/watch?v=0d4f8feysf8
- http://www.pieter-jan.com/images/universalgripper.png
- http://www.pieter-jan.com/images/universalgripper_test.png
- http://www.pieter-jan.com/images/universalgripper_sketch.png
hk401b http://www.hobbyking.com/hobbyking/store/uh_viewitem.asp?idproduct=10113
- http://www.pieter-jan.com/images/hk401b_1.jpg
- http://www.pieter-jan.com/images/hk401b_2.jpg
- http://www.pieter-jan.com/images/hk401b_3.jpg
datasheet http://www.murata.com/products/catalog/pdf/s42e.pdf
quadrocopter http://en.wikipedia.org/wiki/quadrotor
http://www.hobbyking.com/ http://www.hobbyking.com/
electronic speed controller http://en.wikipedia.org/wiki/electronic_speed_control
- http://www.pieter-jan.com/images/4pwm_scheme.png
- http://www.pieter-jan.com/images/bordje1.jpg
pic timer calculator http://eng-serve.com/pic/pic_timer.html
- http://www.pieter-jan.com/images/pwm1.jpg
- http://www.pieter-jan.com/images/pwm3.jpg
narf http://www.ros.org/workshops/iros/2010/steder_paper.pdf
pcl http://www.pointclouds.org
sift http://www.cs.ubc.ca/~lowe/keypoints/
registration http://www.pointclouds.org/assets/iros2011/registration.pdf
tutorial http://pointclouds.org/documentation/tutorials/narf_keypoint_extraction.php#narf-keypoint-extraction
range image http://en.wikipedia.org/wiki/range_imaging
roi http://en.wikipedia.org/wiki/region_of_interest
- http://www.pieter-jan.com/images/bachelorassignmentcircuit.jpg
- http://www.pieter-jan.com/images/bachelorassignment1.jpg
- http://www.pieter-jan.com/images/bachelorassignment2.jpg
- http://www.pieter-jan.com/images/bachelorassignment5.jpg
- http://www.pieter-jan.com/images/bachelorassignment3.jpg
- http://www.pieter-jan.com/images/bachelorassignment4.jpg
- http://www.pieter-jan.com/images/bachelorassignment6.jpg
- http://pieter-jan.com/rss.xml
follow @pieterjanvdm https://twitter.com/pieterjanvdm
- http://be.linkedin.com/pub/pieter-jan-van-de-maele/24/14/217

Zdjęcia

Zdjęcia 71
Zdjęcia bez atrybutu ALT 67
Zdjęcia bez atrybutu TITLE 71
Korzystanie Obraz ALT i TITLE atrybutu dla każdego obrazu.

Zdjęcia bez atrybutu TITLE

http://pieter-jan.com/sites/default/files/logotest_0.png
http://www.pieter-jan.com/images/rpi_lowlevelprogramming/rpi_gpio.jpg
/images/resize/rpi_lowlevelprogramming/gpsel_layout.png
/images/resize/rpi_lowlevelprogramming/gpset0_location.png
/images/resize/rpi_lowlevelprogramming/rpi_ledex.jpg
/images/resize/rpi_lowlevelprogramming/rpi_alternatefunction.png
/images/resize/rpi_lowlevelprogramming/rpi_rtcex.jpg
/images/rpi_lowlevelprogramming/rtc_i2c_read.png
/images/resize/rpi_lowlevelprogramming/rpi_mpu6050ex.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_1.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_2.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_3.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_4.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_5.jpg
http://www.pieter-jan.com/images/equations/compfilter_eq.gif
http://www.pieter-jan.com/images/resize/complementary_filter.png
http://www.pieter-jan.com/images/resize/rpi_sd/rpi_conn.png
http://www.pieter-jan.com/images/rpi_sd/rpi_replacementsocket_1.jpg
http://www.pieter-jan.com/images/rpi_sd/rpi_replacementsocket_2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/sd11_conn.png
http://www.pieter-jan.com/images/rpi_sd/rpi_sdsocketsolderedoff.jpg
http://www.pieter-jan.com/images/rpi_sd/mechanicalstabil1.jpg
http://www.pieter-jan.com/images/rpi_sd/mechanicalstabil2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/resolderedpi1.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/resolderedpi2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/pibow.jpg
http://www.pieter-jan.com/images/resize/n64_controller/n64controller.jpg
http://www.pieter-jan.com/images/n64_controller/connector.jpg
http://www.pieter-jan.com/images/n64_controller/n64converterschematic.png
http://www.pieter-jan.com/images/resize/n64_controller/n64converterprototype.jpg
http://www.pieter-jan.com/images/n64_controller/zero.png
http://www.pieter-jan.com/images/n64_controller/one.png
http://www.pieter-jan.com/images/n64_controller/signal.png
http://www.pieter-jan.com/images/resize/n64_controller/pollsignal.jpg
http://www.pieter-jan.com/images/resize/n64_controller/signalshapes.jpg
http://www.pieter-jan.com/images/resize/n64_controller/responsebnotpressed.jpg
http://www.pieter-jan.com/images/resize/n64_controller/responsebpressed.jpg
http://www.pieter-jan.com/images/equations/thetadot.png
http://www.pieter-jan.com/images/equations/theta.png
http://www.pieter-jan.com/images/quadrogyro.png
http://www.pieter-jan.com/images/equations/gyrooffset.png
http://www.pieter-jan.com/images/resize/rpi_sd-500x153.png
http://www.pieter-jan.com/images/resize/raspi-config-500x361.jpg
http://www.pieter-jan.com/images/resize/internet_sharing-500x411.png
http://www.pieter-jan.com/images/resize/ssh-500x267.png
http://www.pieter-jan.com/images/resize/helloworld-500x320.png
http://www.pieter-jan.com/images/resize/universalgripper.png
http://www.pieter-jan.com/images/resize/universalgripper_test.png
http://www.pieter-jan.com/images/resize/universalgripper_sketch.png
http://www.pieter-jan.com/images/resize/hk401b_1-500x333.jpg
http://www.pieter-jan.com/images/resize/hk401b_2-500x333.jpg
http://www.pieter-jan.com/images/resize/hk401b_3-500x333.jpg
http://www.pieter-jan.com/images/esc_pwm.png
http://www.pieter-jan.com/images/resize/4pwm_scheme-700x364.png
http://www.pieter-jan.com/images/resize/bordje1-500x333.jpg
http://www.pieter-jan.com/images/resize/pwm1-500x333.jpg
http://www.pieter-jan.com/images/resize/pwm3-500x333.jpg
http://www.pieter-jan.com/images/narftest.jpg
http://www.pieter-jan.com/images/mask.jpg
http://www.pieter-jan.com/images/cutout.jpg
http://www.pieter-jan.com/images/resize/bachelorassignmentcircuit.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment1.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment2.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment5.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment3.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment4.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment6.jpg
http://pieter-jan.com/misc/feed.png
http://www.pieter-jan.com/images/08af29c.jpg
http://www.linkedin.com/img/webpromo/btn_liprofile_blue_80x15.png
http://www.pieter-jan.com/images/logocompact_smaller.png

Zdjęcia bez atrybutu ALT

http://www.pieter-jan.com/images/rpi_lowlevelprogramming/rpi_gpio.jpg
/images/resize/rpi_lowlevelprogramming/gpsel_layout.png
/images/resize/rpi_lowlevelprogramming/gpset0_location.png
/images/resize/rpi_lowlevelprogramming/rpi_ledex.jpg
/images/resize/rpi_lowlevelprogramming/rpi_alternatefunction.png
/images/resize/rpi_lowlevelprogramming/rpi_rtcex.jpg
/images/rpi_lowlevelprogramming/rtc_i2c_read.png
/images/resize/rpi_lowlevelprogramming/rpi_mpu6050ex.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_1.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_2.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_3.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_4.jpg
http://www.pieter-jan.com/images/resize/rpi_breakout/rpi_breakout_5.jpg
http://www.pieter-jan.com/images/equations/compfilter_eq.gif
http://www.pieter-jan.com/images/resize/complementary_filter.png
http://www.pieter-jan.com/images/resize/rpi_sd/rpi_conn.png
http://www.pieter-jan.com/images/rpi_sd/rpi_replacementsocket_1.jpg
http://www.pieter-jan.com/images/rpi_sd/rpi_replacementsocket_2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/sd11_conn.png
http://www.pieter-jan.com/images/rpi_sd/rpi_sdsocketsolderedoff.jpg
http://www.pieter-jan.com/images/rpi_sd/mechanicalstabil1.jpg
http://www.pieter-jan.com/images/rpi_sd/mechanicalstabil2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/resolderedpi1.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/resolderedpi2.jpg
http://www.pieter-jan.com/images/resize/rpi_sd/pibow.jpg
http://www.pieter-jan.com/images/resize/n64_controller/n64controller.jpg
http://www.pieter-jan.com/images/n64_controller/connector.jpg
http://www.pieter-jan.com/images/n64_controller/n64converterschematic.png
http://www.pieter-jan.com/images/resize/n64_controller/n64converterprototype.jpg
http://www.pieter-jan.com/images/n64_controller/zero.png
http://www.pieter-jan.com/images/n64_controller/one.png
http://www.pieter-jan.com/images/n64_controller/signal.png
http://www.pieter-jan.com/images/resize/n64_controller/pollsignal.jpg
http://www.pieter-jan.com/images/resize/n64_controller/signalshapes.jpg
http://www.pieter-jan.com/images/resize/n64_controller/responsebnotpressed.jpg
http://www.pieter-jan.com/images/resize/n64_controller/responsebpressed.jpg
http://www.pieter-jan.com/images/equations/thetadot.png
http://www.pieter-jan.com/images/equations/theta.png
http://www.pieter-jan.com/images/quadrogyro.png
http://www.pieter-jan.com/images/equations/gyrooffset.png
http://www.pieter-jan.com/images/resize/raspi-config-500x361.jpg
http://www.pieter-jan.com/images/resize/internet_sharing-500x411.png
http://www.pieter-jan.com/images/resize/ssh-500x267.png
http://www.pieter-jan.com/images/resize/helloworld-500x320.png
http://www.pieter-jan.com/images/resize/universalgripper.png
http://www.pieter-jan.com/images/resize/universalgripper_test.png
http://www.pieter-jan.com/images/resize/universalgripper_sketch.png
http://www.pieter-jan.com/images/resize/hk401b_1-500x333.jpg
http://www.pieter-jan.com/images/resize/hk401b_2-500x333.jpg
http://www.pieter-jan.com/images/resize/hk401b_3-500x333.jpg
http://www.pieter-jan.com/images/esc_pwm.png
http://www.pieter-jan.com/images/resize/4pwm_scheme-700x364.png
http://www.pieter-jan.com/images/resize/bordje1-500x333.jpg
http://www.pieter-jan.com/images/resize/pwm1-500x333.jpg
http://www.pieter-jan.com/images/resize/pwm3-500x333.jpg
http://www.pieter-jan.com/images/narftest.jpg
http://www.pieter-jan.com/images/mask.jpg
http://www.pieter-jan.com/images/cutout.jpg
http://www.pieter-jan.com/images/resize/bachelorassignmentcircuit.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment1.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment2.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment5.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment3.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment4.jpg
http://www.pieter-jan.com/images/resize/bachelorassignment6.jpg
http://www.pieter-jan.com/images/08af29c.jpg
http://www.pieter-jan.com/images/logocompact_smaller.png

Ranking:


Alexa Traffic
Daily Global Rank Trend
Daily Reach (Percent)









Majestic SEO











Text on page:

skip to main content pieter-jan.com creativity in automation & more main menuhome contact low level programming of the raspberry pi in c submitted by pieter-jan on fri, 24/05/2013 - 05:10 one of the things that disappointed me when i first got my raspberry pi was the fact that everybody was doing very high level programming with it. i wanted to program it like i used to do with microcontrollers, but it seemed like this was not as easy as i thought it would be. i believe however, that for embedded applications, you should be very cautious about dependencies, thus try to use as few libraries as possible. this article will show you how to program the raspberry pi in c code in a low level way. tackling this can be a challenge, so let's get started! note that this tutorial will make use of the bcm2835 arm peripherals manual. i will also refer to this as "datasheet", because it sound natural to me. getting started if you have any experience with low level programming of microcontrollers, then you know that everything is done by writing to the registers in the memory of the device. if you, for example, want to set a pin high, then you write a "1" to the register that corresponds to that certain pin. that means that, if we want to program our raspberry pi, we need to gain access to the memory of the bcm2835 first. this is by far the most complex part of programming the raspberry pi, so don't be discouraged! first, we need a header file which defines some macro's. rpi.h #include #include #include #include #include #define bcm2708_peri_base 0x20000000 #define gpio_base (bcm2708_peri_base + 0x200000) // gpio controller #define block_size (4*1024) // io acces struct bcm2835_peripheral { unsigned long addr_p; int mem_fd; void *map; volatile unsigned int *addr; }; struct bcm2835_peripheral gpio = {gpio_base}; extern struct bcm2835_peripheral gpio; // they have to be found somewhere, but can't be in the header so, what is this? if we look at the broadcom bcm2835 arm peripherals manual at page 6, we read: physical addresses range from 0x20000000 to 0x20ffffff for peripherals. the bus addresses for peripherals are set up to map onto the peripheral bus address range starting at 0x7e000000. thus a peripheral advertised here at bus address 0x7ennnnnn is available at physical address 0x20nnnnnn. so the bcm2708_peri_base macro contains the physical adress value at which the peripheral registers start. this is the adress we will need to use in our program. the virtual address value is 0x7e000000, and it are these virtual adresses that will be found in the datasheet. there are a lot of different peripherals available on the bcm2835 (timers, usb, gpio, i2c, ...), and they will be defined by an offset to this virtual adress! for example, if we are interested in the gpio peripheral (like in the example code above), we can find in the manual at page 90 that the virtual address is 0x7e200000. this means that the offset to the physical adress will be 0x200000 which explains the gpio_base. for every peripheral we define a struct of the type bcm2835_peripheral, which will contain the information about the location of the registers. then we intialize it with the map_peripheral() function from the c file below. it is not so important to understand how this works in detail, as you can just copy paste the code. if you do want to know this, search for "accessing /dev/mem" on the internet. to release the peripheral, we can use unmap_peripheral() rpi.c #include "rpi.h" struct bcm2835_peripheral gpio = {gpio_base}; // exposes the physical address defined in the passed structure using mmap on /dev/mem int map_peripheral(struct bcm2835_peripheral *p) { // open /dev/mem if ((p->mem_fd = open("/dev/mem", o_rdwr|o_sync) ) < 0) { printf("failed to open /dev/mem, try checking permissions.\n"); return -1; } p->map = mmap( null, block_size, prot_read|prot_write, map_shared, p->mem_fd, // file descriptor to physical memory virtual file '/dev/mem' p->addr_p // address in physical map that we want this memory block to expose ); if (p->map == map_failed) { perror("mmap"); return -1; } p->addr = (volatile unsigned int *)p->map; return 0; } void unmap_peripheral(struct bcm2835_peripheral *p) { munmap(p->map, block_size); close(p->mem_fd); } now we have code to access the memory of the bcm2835, we can start to use the peripherals to do some badass projects! if you didn't fully grasp the above code, this is not a problem! everything will start making sense after you see that code in action. gpio gpio stands for general purpose in/out, so this peripheral will allow us to set a pin either as in- or output and read or write (to) it. we can add the macro's below to our header file (rpi.h) to support this. i will explain how they work underneath. // gpio setup macros. always use inp_gpio(x) before using out_gpio(x) #define inp_gpio(g) *(gpio.addr + ((g)/10)) &= ~(7<<(((g)%10)*3)) #define out_gpio(g) *(gpio.addr + ((g)/10)) |= (1<<(((g)%10)*3)) #define set_gpio_alt(g,a) *(gpio.addr + (((g)/10))) |= (((a)<=3?(a) + 4:(a)==4?3:2)<<(((g)%10)*3)) #define gpio_set *(gpio.addr + 7) // sets bits which are 1 ignores bits which are 0 #define gpio_clr *(gpio.addr + 10) // clears bits which are 1 ignores bits which are 0 #define gpio_read(g) *(gpio.addr + 13) &= (1<<(g)) at first sight, those macro's look terrifying! but actually they are quite easy to understand, so don't be scared! gpio is a struct of the type bcm2835_peripheral that was initialized with map_peripheral() at the adress gpio_base. this is what we discussed above. to be able to use this code, this need to be done first! to understand properly how the macro's work, we need to take a look at the broadcom bcm2835 arm peripherals manual at chapter 6 (page 89 etc.). we will go over all the macro's in the following text. #define inp_gpio(g) *(gpio.addr + ((g)/10)) &= ~(7 this macro sets pin "g" as an input. how? in the datasheet at page 91 we find that the gpfsel registers are organised per 10 pins. so one 32-bit register contains the setup bits for 10 pins. *gpio.addr + ((g))/10 is the register address that contains the gpfsel bits of the pin "g" (and 9 other pins we are not interested in). remember that the result of a division on integers in c does not contain the part behind the komma. there are three gpfsel bits per pin (000: input, 001: output). the location of these three bits inside the gpfsel register is given by ((g)%10)*3 (three times the remainder, remember the modulo % operator). so to set pin "g" as an input, we need to set these bits to "000". this is done with a and-operation between the gpsel register and a string of which everything except those bits are 1. this string is created by bitshifting 7, which is binary 111, over ((g)%10)*3 places, and taking the inverse of that. a little example: say that we want to use gpio4 as an input. the gpsel address containing the function select bits for gpio4 is *gpio.addr + 4/10=*gpio.addr + 0 inside this 32-bit register, the bits concerning gpio4 start from bit (4%10)*3=12 if we bitshift binary 111 over 12 positions we get: 00000000000000000111000000000000 we have to make those three bits zero in the gpfsel register, so we have to invert that 32-bit string and perform an and operation with the gpsel register. (x = unknown) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x (gpfsel old) and --------------------------------------------------------------- x x x x x x x x x x x x x x x x x 0 0 0 x x x x x x x x x x x x (gpfsel new) #define out_gpio(g) *(gpio.addr + ((g)/10)) |= (1 to set pin "g" as an output, we have to set its setup bits to 001. this is done in the same way as before, but now we bitshift a 1, and use a or operation on the normal (not inverted) string. this is also the reason that the comment says to "always use inp_gpio(x) before using out_gpio(x)". this way you are sure that the other 2 bits are 0, and justifies the use of a or operation here. if you don't do that, you are not sure those bits will be zero and you might have given the pin "g" a different setup. #define set_gpio_alt(g,a) *(gpio.addr + (((g)/10))) |= (((a) as you can see in the picture above, input and output are not the only functionalities available for the pins. there are 6 "alternate function" possibilities for each pin. it are these alternate functions that you will want to use if you need to use other peripherals than the gpio, like i2c and spi. the alternate function possibilities are on page 102 in section 6.2 of the manual. with set_gpio_alt(g,a) you can set pin g to function 0,1,... in the part about i2c below, we will use this function to set gpio0 and gpio1 to sda and scl for use with i2c. #define gpio_set *(gpio.addr + 7) in the datasheet on page 90, we seet that the gpset register is located 7 32-bit registers further than the gpio base register. there is a small mistake on this page of the datasheet, as the first line is printed twice. gpio.addr is defined as a pointer to an unsigned int, which is 32-bit on the raspberry pi. when you add an integer to a pointer, it will know that we are working with 32-bit values, so we don't need to multiply this with 4 (7*4 = 0x1c) to obtain the address from the datasheet. so to use the macro gpio_set to set e.g. gpio 4 pin we can set the 4'th bit of this register to 1 using a bitshift: gpio_set = 1 it's important to note that writing a "0" to the gpio_set register will not reset that pin. you have to write a "1" to the gpio_clr register to reset a pin. this is very useful, as this means that we can use the above bitshift operation to write to all pins, without taking the risk of accidentally resetting a pin we forgot that was on. awesome. the gpio clear is ofcourse similar. #define gpio_read(g) *(gpio.addr + 13) &= (1 to read a pin we simply perform a bitwise and on the gplev register and the pin we are interested in (g). the result is the value of that pin. example - blink a led hopefully the above analysis helped you understanding how to use the gpio functionality of the raspberry pi. it really is nothing more than writing 1's and 0's to the correct registers ... as a little example, here is the code to blink a led. note that pin 7 corresponds to gpio 4 if you look a the pinout. to run this, make sure you added the gpio macro's to your header file! don't try this at home (without a resistor in series with the led)! main.c #include "rpi.h" int main( { if(map_peripheral(&gpio) == -1) { printf("failed to map the physical gpio registers into the virtual memory space.\n"); return -1; } // define pin 7 as output inp_gpio(4); out_gpio(4); while(1) { // toggle pin 7 (blink a led!) gpio_set = 1 << 4; sleep(1); gpio_clr = 1 << 4; sleep(1); } return 0; } i2c the peripheral we will need to use the i2c functionality of the raspberry pi is the bsc (broadcom serial controller). information about this can be found in de datasheet chapter 3 (p. 28 and further). there are two bsc's: bsc0 and bsc1. we will use bsc0. first we map all the registers by adding the following macro's to our rpi.h file. #define bsc0_base (bcm2708_peri_base + 0x205000) // i2c controller extern struct bcm2835_peripheral bsc0; // i2c macros #define bsc0_c *(bsc0.addr + 0x00) #define bsc0_s *(bsc0.addr + 0x01) #define bsc0_dlen *(bsc0.addr + 0x02) #define bsc0_a *(bsc0.addr + 0x03) #define bsc0_fifo *(bsc0.addr + 0x04) #define bsc_c_i2cen (1 << 15) #define bsc_c_intr (1 << 10) #define bsc_c_intt (1 << 9) #define bsc_c_intd (1 << 8) #define bsc_c_st (1 << 7) #define bsc_c_clear (1 << 4) #define bsc_c_read 1 #define start_read bsc_c_i2cen|bsc_c_st|bsc_c_clear|bsc_c_read #define start_write bsc_c_i2cen|bsc_c_st #define bsc_s_clkt (1 << 9) #define bsc_s_err (1 << 8) #define bsc_s_rxf (1 << 7) #define bsc_s_txe (1 << 6) #define bsc_s_rxd (1 << 5) #define bsc_s_txd (1 << 4) #define bsc_s_rxr (1 << 3) #define bsc_s_txw (1 << 2) #define bsc_s_done (1 << 1) #define bsc_s_ta 1 #define clear_status bsc_s_clkt|bsc_s_err|bsc_s_done // i2c function prototypes void i2c_init(); void wait_i2c_done(); not much special here, except maybe for the start_read, start_write and clear_status. of course, these are just the combinations (or) of bits in the status register that need to be set for that action to occur. it's just easier to do it like that than to set all the bits seperately every time. then we need to add the following functions to our rpi.c file. struct bcm2835_peripheral bsc0 = {bsc0_base}; // initialize i2c void i2c_init() { inp_gpio(0); set_gpio_alt(0, 0); inp_gpio(1); set_gpio_alt(1, 0); } // function to wait for the i2c transaction to complete void wait_i2c_done() { int timeout = 50; while((!((bsc0_s) & bsc_s_done)) && --timeout) { usleep(1000); } if(timeout == 0) printf("error: wait_i2c_done() timeout.\n"); } notice how we access the memory of the bsc0 peripheral with a struct of the type bcm2835_peripheral called bsc0. we initalize it so that the address points to bsc0_base. the classic i2c delay is implemented with wait_i2c_done(). it constantly polls the "done" bit of the bsc0 s register (status). this bit becomes 1 when the transfer is completed. see datasheet p. 32. now we need to make sure that the gpio pins are set up properly for i2c. for this we need one pin to behave as sda, and one pin to behave as scl. if we look at the pinout again, we see that gpio0 and gpio1 are the proper pins for this. they have to be enabled first though. for this we use the i2c_init() function. inside you will find the set_alt_gpio() macro used to set these pins to alternate functionality 0. the reason we set these to alternate functionality 0 is because the datasheet shows the following table at page 102: ok, so after initializing the i2c we are very close to start sending data over the i2c bus! to send or write some data, we need to take the following steps: write the i2c slave address of the device you want to communicate with (you can find this in the datasheet) to the bsc0_a adress (slave adress register). write the amount/quantity of bytes you want to send/receive to the bsc0_dlen register (data length). if you want to write to the slave, write the bytes you want to write in the bsc0_fifo. remember: fifo = first in first out! clear the status register: bsc0_s = clear_status start write or start read by writing to the bsc0 c register (control): bsc0_c = start_write or bsc0_c = start_read are you totally confused? me too! let's take a look at some examples! example 1 - real time clock (rtc) in this example we will read a real time clock (rtc) with a raspberry pi using i2c. the rtc we are using is the pcf8563, a very classic device. normally you would want to be able to write the rtc as well for initializing, but i want to start with a simple example. the data from the pcf8563 starts at register 2 (seconds) and the 6 sequential adresses contain minutes, hours, ... so in total there are 7 registers we need to read, starting from adress 2. reading data from the rtc is described in the pcf8563 datasheet and should be performed like this: the first step, writing the slave address to the bus, will be done automatically for us if we write this address to the bsc0_a register. so we have to do this before starting communication. after this we need to write the register address of the rtc we want to start reading from to the bus. in our case, this is "2". after that, it will start sending the data, so we have to start reading data from the bus. the code example below nicely illustrates how this is done on the raspberry pi. #include "rpi.h" #include #include #include struct tm t; /* functions to do conversions between bcd and decimal */ unsigned int bcd_to_decimal(unsigned int bcd) { return ((bcd & 0xf0) >> 4) * 10 + (bcd & 0x0f); } unsigned int decimal_to_bcd(unsigned int d) { return ((d / 10) << 4) + (d % 10); } int main(int argc, char *argv[]) { /* gain access to raspberry pi gpio and i2c peripherals */ if(map_peripheral(&gpio) == -1) { printf("failed to map the physical gpio registers into the virtual memory space.\n"); return -1; } if(map_peripheral(&bsc0) == -1) { printf("failed to map the physical bsc0 (i2c) registers into the virtual memory space.\n"); return -1; } /* bsc0 is on gpio 0 & 1 */ i2c_init(); /* i2c device address 0x51 (see datasheet) */ bsc0_a = 0x51; /* write operation to restart the pcf8563 register at index 2 ('secs' field) */ bsc0_dlen = 1; // one byte bsc0_fifo = 2; // value 2 bsc0_s = clear_status; // reset status bits (see #define) bsc0_c = start_write; // start write (see #define) wait_i2c_done(); /* start read of rtc chip's time */ bsc0_dlen = 7; bsc0_s = clear_status; // reset status bits (see #define) bsc0_c = start_read; // start read after clearing fifo (see #define) wait_i2c_done(); /* store values in struct */ t.tm_sec = bcd_to_decimal(bsc0_fifo & 0x7f); t.tm_min = bcd_to_decimal(bsc0_fifo & 0x7f); t.tm_hour = bcd_to_decimal(bsc0_fifo & 0x3f); t.tm_mday = bcd_to_decimal(bsc0_fifo & 0x3f); t.tm_wday = bcd_to_decimal(bsc0_fifo & 0x07); t.tm_mon = bcd_to_decimal(bsc0_fifo & 0x1f) - 1; // 1-12 --> 0-11 t.tm_year = bcd_to_decimal(bsc0_fifo) + 100; printf("%02d:%02d:%02d %02d/%02d/%02d (utc on pcf8563)\n", t.tm_hour,t.tm_min,t.tm_sec, t.tm_mday,t.tm_mon + 1,t.tm_year - 100); /* unmap the peripheral */ unmap_peripheral(&gpio); unmap_peripheral(&bsc0);decimal_to_bcd } example 2 - imu (mpu6050) for reading the mpu6050 imu i will just provide the source code and hope that you understand what to do with it after the previous examination. if there still is something that is not clear, please contact me, and i will add more explanation here. mpu6050.h #ifndef _inc_mpu6050_h #define _inc_mpu6050_h #include "rpi.h" #include #define mpu6050_addr 0b01101001 // 7 bit adres #define config 0x1a #define accel_config 0x1c #define gyro_config 0x1b #define pwr_mgmt_1 0x6b void mpu6050_read(short * accdata, short * gyrdata); void mpu6050_init(void); void mpu6050_setregister(unsigned char regaddr, unsigned char regvalue); #endif mpu6050.c #include "mpu6050.h" void mpu6050_init(void) { // mpu6050_setregister(pwr_mgmt_1, 0x80); // device reset mpu6050_setregister(pwr_mgmt_1, 0x00); // clear sleep bit mpu6050_setregister(config, 0x00); mpu6050_setregister(gyro_config, 0x08); mpu6050_setregister(accel_config, 0x08); } void mpu6050_setregister(unsigned char regaddr, unsigned char regvalue) { // see datasheet (ps) page 36: single byte write sequence // master: s ad+w ra data p // slave : ack ack ack bsc0_a = mpu6050_addr; bsc0_dlen = 2; bsc0_fifo = (unsigned char)regaddr; bsc0_fifo = (unsigned char)regvalue; bsc0_s = clear_status; // reset status bits (see #define) bsc0_c = start_write; // start write (see #define) wait_i2c_done(); } void mpu6050_read(short * accdata, short * gyrdata) { // see datasheet (ps) page 37: burst byte read sequence // master: s ad+w ra s ad+r ack nack p // slave : ack ack ack data data bsc0_dlen = 1; // one byte bsc0_fifo = 0x3b; // value of first register bsc0_s = clear_status; // reset status bits (see #define) bsc0_c = start_write; // start write (see #define) wait_i2c_done(); bsc0_dlen = 14; bsc0_s = clear_status; // reset status bits (see #define) bsc0_c = start_read; // start read after clearing fifo (see #define) wait_i2c_done(); short tmp; int i = 0; for(i; i < 3; i++) // accelerometer { tmp = bsc0_fifo << 8; tmp += bsc0_fifo; accdata[i] = tmp; } tmp = bsc0_fifo << 8; // temperature tmp += bsc0_fifo; i = 0; for(i; i < 3; i++) // gyroscope { tmp = bsc0_fifo << 8; tmp += bsc0_fifo; gyrdata[i] = tmp; } } github repository all this code can also be found in my github repository: https://github.com/pieter-jan/pj_rpi. you will need cmake (sudo apt-get install cmake) and git (sudo apt-get install git) to use it. to use it, create a folder on the pi where you want to put the files in and extract the git repository in there: git clone git://github.com/pieter-jan/pj_rpi.git then you have to install the library, so cd into the pj_rpi directory and: mkdir build cd build cmake ../ make sudo make install now the library is installed and you can build the examples that are in the "examples" folder using cmake. if you want to build the mpu6050 example you will also need ncurses for the visualization (sudo apt-get install ncurses-dev). tags: raspberry pi diy raspberry pi breakout cable submitted by pieter-jan on mon, 20/05/2013 - 09:54 suprisingly enough, a lot of people have asked me how i made the breakout / expansion cable for my raspberry pi. it's so easy! so if you don't want to wait on some online order, and want to get started as soon as possible doing epic stuff, you can follow the simple instructions below. a cable like this can be extremely useful for connecting the raspberry pi to a breadboard and doing some prototyping! the following things are needed: 2x13 flat cable 2 times 1x13 male header with 2.54 mm (1 inch) spacing electrical tape with a nice color it's also necessary that you know how to solder and have the right equipment for this. the first step is cut the flat cable nicely in two pieces. if you have a flat cable from an old computer that is 2x13, you can definitely use this! if you don't have one (my case), there are a lot of stores where you can find it. we will continue working with one half of the cable as shown in the figure below. the second step is to split the cable in 2 pieces, so that you have 2 parts that each contain 13 wires. then you need to seperate the individual wires a little bit (not too far!) with a knife. now you should be able to strip them, and solder them to the 1x13 header. you will have to do this for both parts of the cable. note that it might be useful to make the wires in the middle a little bit shorter than those at the ends, because the header is a lot wider than the half flat cable. the result should look like shown in the picture below. make sure that you don't make short circuits! if you are in doubt, double check with a multimeter. because the above result does not look good, and having unstripped wires is a bit dangerous, i decided to tape this in with some electrical tape. be careful not to apply too much pressure to the wires so that the pins of the header don't bend! you should end up with a nice looking cable ready for action! tags: raspberry pi reading a imu without kalman: the complementary filter submitted by pieter-jan on fri, 26/04/2013 - 08:38 these days, imu's (intertial measurement units) are used everywhere. they are e.g. the sensors that are responsible for keeping track of the oriëntation of your mobile phone. this can be very useful for automatic screen tilting etc. the reason i am interested in this sensor is because i want to use it to stabilize my quadrocopter. if you are here for another reason, this is not a problem as this tutorial will apply for everyone. when looking for the best way to make use of a imu-sensor, thus combine the accelerometer and gyroscope data, a lot of people get fooled into using the very powerful but complex kalman filter. however the kalman filter is great, there are 2 big problems with it that make it hard to use: very complex to understand. very hard, if not impossible, to implement on certain hardware (8-bit microcontroller etc.) in this tutorial i will present a solution for both of these problems with another type of filter: the complementary filter. it's extremely easy to understand, and even easier to implement. why do i need a filter? most imu's have 6 dof (degrees of freedom). this means that there are 3 accelerometers, and 3 gyrosocopes inside the unit. if you remember anything from a robotics class you might have taken, you might be fooled into thinking that the imu will be able to measure the precise position and orientation of the object it is attached to. this because they have told you that an object in free space has 6dof. so if we can measure them all, we know everything, right? well ... not really. the sensor data is not good enough to be used in this way. we will use both the accelerometer and gyroscope data for the same purpose: obtaining the angular position of the object. the gyroscope can do this by integrating the angular velocity over time, as was explained in a previous article. to obtain the angular position with the accelerometer, we are going to determine the position of the gravity vector (g-force) which is always visible on the accelerometer. this can easily be done by using an atan2 function. in both these cases, there is a big problem, which makes the data very hard to use without filter. the problem with accelerometers as an accelerometer measures all forces that are working on the object, it will also see a lot more than just the gravity vector. every small force working on the object will disturb our measurement completely. if we are working on an actuated system (like the quadrocopter), then the forces that drive the system will be visible on the sensor as well. the accelerometer data is reliable only on the long term, so a "low pass" filter has to be used. the problem with gyroscopes in one of the previous articles i explained how to obtain the angular position by use of a gyroscope. we saw that it was very easy to obtain an accurate measurement that was not susceptible to external forces. the less good news was that, because of the integration over time, the measurement has the tendency to drift, not returning to zero when the system went back to its original position. the gyroscope data is reliable only on the short term, as it starts to drift on the long term. the complementary filter the complementary filter gives us a "best of both worlds" kind of deal. on the short term, we use the data from the gyroscope, because it is very precise and not susceptible to external forces. on the long term, we use the data from the accelerometer, as it does not drift. in it's most simple form, the filter looks as follows: the gyroscope data is integrated every timestep with the current angle value. after this it is combined with the low-pass data from the accelerometer (already processed with atan2). the constants (0.98 and 0.02) have to add up to 1 but can of course be changed to tune the filter properly. i implemented this filter on a raspberry pi using a mpu6050 imu. i will not discuss how to read data from the mpu6050 in this article (contact me if you want the source code). the implementation of the filter is shown in the code snippet below. as you can see it is very easy in comparison to kalman. the function "complementaryfilter" has to be used in a infinite loop. every iteration the pitch and roll angle values are updated with the new gyroscope values by means of integration over time. the filter then checks if the magnitude of the force seen by the accelerometer has a reasonable value that could be the real g-force vector. if the value is too small or too big, we know for sure that it is a disturbance we don't need to take into account. afterwards, it will update the pitch and roll angles with the accelerometer data by taking 98% of the current value, and adding 2% of the angle calculated by the accelerometer. this will ensure that the measurement won't drift, but that it will be very accurate on the short term. it should be noted that this code snippet is only an example, and should not be copy pasted as it will probably not work like that without using the exact same settings as me. #define accelerometer_sensitivity 8192.0 #define gyroscope_sensitivity 65.536 #define m_pi 3.14159265359 #define dt 0.01 // 10 ms sample rate! void complementaryfilter(short accdata[3], short gyrdata[3], float *pitch, float *roll) { float pitchacc, rollacc; // integrate the gyroscope data -> int(angularspeed) = angle *pitch += ((float)gyrdata[0] / gyroscope_sensitivity) * dt; // angle around the x-axis *roll -= ((float)gyrdata[1] / gyroscope_sensitivity) * dt; // angle around the y-axis // compensate for drift with accelerometer data if !bullshit // sensitivity = -2 to 2 g at 16bit -> 2g = 32768 && 0.5g = 8192 int forcemagnitudeapprox = abs(accdata[0]) + abs(accdata[1]) + abs(accdata[2]); if (forcemagnitudeapprox > 8192 && forcemagnitudeapprox < 32768) { // turning around the x axis results in a vector on the y-axis pitchacc = atan2f((float)accdata[1], (float)accdata[2]) * 180 / m_pi; *pitch = *pitch * 0.98 + pitchacc * 0.02; // turning around the y axis results in a vector on the x-axis rollacc = atan2f((float)accdata[0], (float)accdata[2]) * 180 / m_pi; *roll = *roll * 0.98 + rollacc * 0.02; } } if we use the sweetness of having a real computer (raspberry pi) collecting our data, we can easily create a graph using gnuplot. it's easily seen that the filter (red) follows the gyroscope (blue) for fast changes, but keeps following the mean value of the accelerometer (green) for slower changes, thus not feeling the noisy accelerometer data and not drifting away eiter. the filter is very easy and light to implement making it perfect for embedded systems. it should be noted that for stabilization systems (like the quadrocopter), the angle will never be very big. the atan2 function can then be approximated by using a small angle approximation. in this way, this filter could easily fit on an 8 bit system. hope this article was of any help. tags: complementary filtergyroscopeaccelerometerimuquadrocopter replacing the raspberry pi's sd card socket submitted by pieter-jan on thu, 11/10/2012 - 11:06 not so long ago i dropped my raspberry pi. it fell on the sd card, which resulted in breaking the slot. after a long search on the internet it was clear that a lot of people had the exact same problem, but all of them solved it by gluing the slot back together in some way or another. because this solution was not satisfactory for me, i replaced my slot with a new one. in this article i will describe how to do that. choosing an appropriate replacement slot first we need to know how the sd card slot of the raspberry pi is built up. this is shown in the figure below. (sorry it is hand drawn and everything, but i really didn't have the time to make proper figures on the computer) as you can see it is a 13-pin slot, using 2 pins for both for the "write protect" and "card detect". this is a problem, as most of the available slots we can find at electronic parts vendors have either 9 pins (no "card detect" and "write protect") or 11 pins, using just one pin for each function. i chose to use a 11-pin slot that i found on ebay. most of the 11 pin slots have a similar layout. it's very cheap and shown in the picture below. the layout of the slot is given in the picture below: because of the bad positioning of the "write protect" and "card detect" pins, we will not be able to attatch these pins correctly to the raspberry pi. we can solder the "card detect" pins on the pi together, so they make a short circuit and the pi will work. i don't think this is a big problem. and correct me if i'm wrong, but i might have read somewhere that the "wire protect" is not even used. desoldering the remainders of the old slot & soldering the new slot in place first get rid of the old slot by desoldering all the broken parts! then just solder on the new slot and leave the pins "card detect" and "write protect" from the sd connector floating (or cut them off if you want to be safe). the other pins should nicely align with the solder pads on the raspberry pi. use the figures (poorly drawn sketches) above for reference and proper alignment. make sure to short circuit the "card detect" solder pads on the raspberry pi. for mechanical strength, i added a wire as tightly as possible to the slot and the solder pads of the raspberry pi. it is shown in the picture below. i strongly recommend doing this, as it will increase the lifetime of the slot a lot. enjoying the enhanced pi now you should be done. when you plug in your sd card and power on the pi, everything should work as it did before. enjoy your frankenberry pi! it even still fits in a pibow! tags: raspberry pi reading nintendo 64 controller with pic microcontroller submitted by pieter-jan on wed, 12/09/2012 - 08:37 i have a few old n64 controllers lying around and figured that it would be pretty cool to use them to control other things. in this article i will describe in detail every step i took to achieve this. i've used a pic microcontroller, but it should not be too hard to port the code to any other architecture. connector the n64 controller has three connections. from right to left with the round side up: ground, data and vcc (3.3v). just plug some cables in the holes and you're ready to go. hardware the circuit i created for reading out the controller is shown in the schematic below. it is based around a pic18f2550. i chose a pic from the 18f range, because i am interested in the usb capabilities, as i might try to use the n64 controller with a computer some day (future article maybe?). i did however limit my oscillator frequency to 20 mhz, so that everything should work on a 16f pic as well if you don't need usb. i've connected three led's to rb5, rb4 and rb3. they will provide some visual feedback so we can see if everything works properly. a 3.3v voltage regulator provides the voltage for the board. the maximum voltage the n64 controller can handle is 3.6v, so don't exceed that. if you use 5v you will risk frying your controller. the n64 controller is connected to the board with a simple screw connector. here the supply voltage is given, and the data pin is connected to the rb7 pin of the pic18f2550. i've also connected a header (jp1) for the pickit2. this allows me to program the pic without having to take it out of the circuit (icsp). at the moment it also provides the supply voltage to the board because i am to lazy to find a good power supply. make sure you set the pickit to 3.3v instead of the default 5v for the reason i mentioned earlier. the image below shows the fully built circuit built on perfboard. the rectangular thing to the right of the microcontroller is a wireless rf transmitter. i will talk about this in a next article, but it is of no importance to us now. interface now we're going to take a quick look at the communication with the nintendo 64 controller. the interface looks a little bit like one wire, but is still different. it's a serial interface, which means that all the signals discussed here, will take place on one pin: the data (middle) pin of the connector (white wire in the pictures above). signal shapes the signal shapes used by the n64 controller for one and zero are shown below. as you can see these signals are very fast with a period of 4 us and a resolution of 1 us! on a pic microcontroller, one instruction cycle equals 4 oscillator cycles, which means that with a 20 mhz oscillator, 1 us takes only 5 instruction cycles! to generate these signals, we will need a low-level programming language like assembly, as c just won't cut it. i will give as much information as needed, so if this is your first experience with assembly, you will be able to follow easily. a good reference for the pic instruction set can be found here: pic instructions. zero one movlw 0x00 movwf portb nop nop nop nop nop nop nop nop nop nop nop nop nop movlw 0x80 movwf portb nop nop nop 5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 2 3 4 movlw 0x00 movwf portb nop nop nop movlw 0x80 movwf portb nop nop nop nop nop nop nop nop nop nop nop nop nop 15 1 2 3 4 5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 below both signal shapes i have included a very simple program to generate the signal in asm (of course there are other possibilities e.g. with bsf and bcf). there are only three different instructions used: movlw: place the value that you indicate in the w register. movwf: place the value that is currently in the w register, in the register that you indicate. nop: do nothing. it's easy to see that a combo of movlw with movwf can set a pin by modifying the portb register. as our n64 controller is connected to pin rb7, we set this pin high by sending the binary signal 0b10000000 to portb, which is 0x80 in hexadecimals. ofcouse sending 0x00 makes the pin 0. all three instructions we used take 1 instruction cycle (check the pic 18f instruction set here). this means that it is very easy to count every step. as i said previously: 1 us takes 5 instruction cycles. that means that, to generate a zero, we have to set pin rb7 low, wait for 15 instructions, and then set it high for 5 instructions. i have counted and indicated the instructions that the pin is high with a bold font, and the instructions that it is low with a gray font. you have to think about these code blocks as if a lot of them are cascaded after each other, so that the first instruction of every code block, is actually the last instruction of the previous block. this will make the timing exact. of course this code will only work with an oscillator frequency of 20 mhz on a pic microcontroller. if you have another oscillator you can easily calculate how many instruction cycles you need for 1 us though. if you are using another architecture (avr, arm, ...) you have to figure out how many oscillator cycles one instruction takes first (it is usually less than 4, which makes it easier to use c on those architectures). controller data the n64 controller data consists of a 32 bit (4 bytes), which gives you the status (on/off) of all buttons and the joystick position (2 bytes) and one stop bit. the array is built up like this: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16-23 24-31 32 a b z start up down left right / / l r c-up c-down c-left c-right x-axis y-axis stop bit (1) e.g. if the z button is pressed, the 3th element of this array will read one etc. the position of the joystick can be determined from the two bytes given by "x-axis" and "y-axis". polling signal to receive the data array from the controller, a polling signal has to be sent first. this signal is: 0b000000011 (9 bits). after this signal is sent, the controller will respond with the 33 bit array (4 bytes + stop bit). this is shown in the picture below. the b-button is pushed so the second bit of the response is 1. the assembly code used to generate the polling signal is shown below. instead of copy pasting 7 zero blocks and 2 one blocks from above (which would work perfectly). i used the decfsz (decrement file, skip if zero) instruction to create loops. this instruction will decrement the register you indicate, and skip the next instruction if this register becomes zero. it takes two instruction cycles if it skips, else one! the registers d1, d2 and d3 can be defined in the beginning of the program using a cblock. after the decfsz instruction there is a goto instruction, which will move the program counter to the instruction after the word that you have indicated. it should be clear to see how a combo of these two instructions create a loop. all instructions use one instruction cycle (4 oscillator cycles), except for: goto, which uses 2 instruction cycles. of course decfsz also takes two instruction cycles when it skips, as mentioned earlier. its not so hard to distinguish the two code blocks we saw earlier, only this time i tried to make them a little shorter by replacing some of the nop's with loops (zeroloop, oneloop). if you take the time to count the instruction cycles carefully for each loop (which i strongly recommend), you will see that there would be no difference if we would copy paste 7 zero's and 2 one's from the previous code. bcf trisb, 7 ; make rb7 output ; 0b000000011 movlw 0x07 ; number of zeros that need to be sent movwf d2 movlw 0x02 ; number of ones that need to be sent movwf d3 zero movlw 0x00 movwf portb movlw 0x03 movwf d1 zeroloop ; 3 instruction cycles * 3 = 9 decfsz d1, f goto zeroloop nop nop movlw 0x80 movwf portb decfsz d2 goto zero one movlw 0x00 movwf portb nop nop nop movlw 0x80 movwf portb movlw 0x02 movwf d1 oneloop ; 4 instruction cycles * 2 = 8 nop decfsz d1, f goto oneloop decfsz d3 goto one note: the pin rb7 is set to function as an output pin by setting the trisb register (duh!). in the image below you can see a picture of an oscilloscope measuring the polling signal generated with the code above. you can clearly see the signal 0b00000011. this is a close up of the 7th (0) and 8th (1) bit of the polling signal. the timebase is set to 1 us. as you can see, the signal is extremely correct. if you now connect the n64 controller, you should see that it responds immediately after the polling signal was sent. i have shown this in the pictures below. in the second picture the b button is pressed, so you can see that the second bit of the response is a 1. once you attach the controller, the signal wil deform because of its impedance. this is normal and not really a problem for us. reading the controller data now we succeeded in triggering the nintendo 64 controller so that it sends its data, we have to find a way to read & store this data properly. the easiest way to do this, is to wait until the middle of the signal (approx 2 us) and then see if it is one or zero with the btfss (bit file, skip if set) instruction. this instruction will check the bit you indicate (e.g. "portb, 7" -> 7th bit of the portb register) and then skip the next instruction if this bit is one. it will take one instruction cycle, except if it skips when it will take 2 instruction cycles (it compensates automatically for the skipped instruction - nice!). of course, we have to switch the rb7 pin to an intput now by setting it to 1 in the trisb register. once we know if the bit was a 0 or a 1, we can store this somewhere in the ram by using indirect addressing. the indf0 register contains the value of the register pointed to by fsr0l, so if we increment fsr0l, we go to the next adress etc. we can now read and store all values, so we will do this 33 times as there are 33 bits in the n64 array (see higher). movlw 0x22 ; 0x21 = 33 bits movwf d4 ; contains the number of buttons movlw 0x20 ; set up the array adress for indirect adressing movwf fsr0l bsf trisb, 7 ; rb7 as input readloop ; read all 33 bits and store them on locations 0x20 etc. nop ; wait nop nop nop nop nop nop movlw 0xff ; if bit is one btfss portb, 7 ; read the bit (9th instruction) movlw 0x00 ; if bit is zero movwf indf0 ; wait & store the value of the bit in the array incf fsr0l ; go to next adres in the array nop nop nop nop nop decfsz d4 ; end loop if all 33 bits are read goto readloop note 1: the syntax for indirect addressing is a little bit different on 16f architectures. they use fsr and indf. note 2: this is definitely not the best way to read out a serial signal. a better way would be to re-sync the signal after every bit, by searching for a rising edge and then falling edge. this way you know for sure that you are at the beginning of the pulse form. i have tried to do this, but it seemed impossible with the slow pic (4 oscillator cycles / instruction cycle). you might succeed with this approach on an avr though (1 oscillator cycle / instruction). please let me know if you find a cleaner way! (this works perfectly though ...) the full assembly (asm) program the full assembly program is given below. it blinks the leds rb3, rb4 and rb5 respectively when the buttons a, b & z are pressed. i made use of the mpasm (v5.46) compiler which comes with the mplab x ide. it's probably pretty easy to figure out what everything does if you look up the instructions on the webpage i referred to earlier, so i won't go into detail here. #include <p18f2550.inc> config wdt = off ; disable watchdog timer config fosc = hs ; oscillator crystal of 20mhz! config lvp = off ; low-voltage programming disabled config debug = off config cp0 = off config cp1 = off config mclre = off org 0 init cblock d1 d2 d3 d4 endc movlw 0x00 movwf latb movwf trisb movwf portb movlw 0x80 ; initalise the line = high movwf portb main ; part 1 - read the n64 controller and store the status values movlw 0x22 ; 0x21 = 33 bits movwf d4 ; contains the number of buttons movlw 0x20 ; set up the array adress movwf fsr0l bcf trisb, 7 ; make rb7 output call poll ; send the polling signal (0b000000011) bsf trisb, 7 ; rb7 as input (is also last instruction of poll) readloop ; read all 33 bits and store them on locations 0x20 etc. nop ; wait nop nop nop nop nop nop movlw 0xff ; if bit is one btfss portb, 7 ; read the bit (9th instruction) movlw 0x00 ; if bit is zero movwf indf0 ; wait & store the value of the bit in the array incf fsr0l ; go to next adres in the array nop nop nop nop nop decfsz d4 ; end loop if all 33 bits are read goto readloop ; blink some leds movlw 0x20 ; read a button (0x20) from array movwf fsr0l movlw 0x20 ; led rb5 btfsc indf0, 0 iorwf latb, portb incf fsr0l ; read b button (0x21) from array movlw 0x10 ; led rb4 btfsc indf0, 0 iorwf latb, portb incf fsr0l ; read z button (0x22) from array movlw 0x08 ; led rb3 btfsc indf0, 0 iorwf latb, portb call delay goto main poll ; 0b000000011 movlw 0x07 ; number of zeros that need to be sent movwf d2 movlw 0x02 ; number of ones that need to be sent movwf d3 zero movlw 0x00 movwf portb movlw 0x03 movwf d1 zeroloop ; 9 instruction cycles decfsz d1 goto zeroloop nop nop movlw 0x80 movwf portb decfsz d2 goto zero one movlw 0x00 movwf portb nop nop nop movlw 0x80 movwf portb movlw 0x02 movwf d1 oneloop ; 8 instruction cycles nop decfsz d1 goto oneloop decfsz d3 goto one return delay movlw 0x5f ; +- 1500 us = 1.5 ms movwf d1 outer movlw 0x60 movwf d2 inner nop nop decfsz d2 goto inner ; inner loop = 5 cycles = 1us decfsz d1 goto outer ; outer loop = inner + 4 cycles return end video here is a small video of the result. i'm sorry that i didn't do anything cooler with it than blinking some leds, but that's for when i have some more time! tags: microcontrollers getting the angular position from gyroscope data submitted by pieter-jan on thu, 06/09/2012 - 02:41 in this article i will explain how i succeeded in finding the angular position (angle) of one axis of a quadrocopter by integrating gyroscope data. for this article i will use the gyrosocope from the hobbyking hk401b module i hacked in a previous article. because i wanted a fast prototyping method i used an arduino, but the principle is the same on any other device. i will include the code for a pic microcontroller as well. a little math before we take a look at the program we will go through the basic mathematics involved here, as they will make understanding the program a lot easier. the gyroscope gives us the rate of change of the angular position over time (angular velocity) with a unit of [deg./s]. this means that we get the derivative of the angular position over time. however rate feedback is extremely useful in control engineering, it is usually used in combination with position feedback. to obtain the angular position, we can simply integrate the angular velocity. so, assuming that at t=0 theta=0, we can find the angular position at any given moment t with the following equation: the third part in this equation shows the approximation we make when using digital systems. because we can't take a perfectly continuous integral, we have to take the sum of a finite number of samples taken at a constant interval ts. ts is called the sampling period. of course this approximation will introduce errors. when gyrosocope data changes faster than the sampling frequency, we will not detect it, and the integral approximation will be incorrect. this error is called drift, as it increases in time. it results in the sensor reading not returning to 0 at the rest position. for this, it is important that we choose a good sampling period. the sampling frequency recommended for mechanical systems lies between 100 and 200hz. i will use 100hz (sampling period of 10ms) as this equals the cycle time of my quadrocopter pwm program. choosing a sampling frequency of 100hz is a good choice for an "ideal case" mechanical system. it has to be understood though that disturbance inputs like shocks & vibrations because of the motors can have a much higher frequency and will not be measured properly. this is mostly the case for disturbances that work directly on the sensor, and it is a big problem of this integration method. disturbances like wind and external forces that work on the system (quadrocopter) will be slowed down by the intertia of this system so that they will be measured correctly and can be compensated for. the gyroscope sensor this sensor was already discussed briefly in a previous article. it is an analog sensor, which means that it will output an analog voltage that will be a measure for the angular velocity. it is also a one axis gyroscope, which means that there is only one output. the axis that this sensor can measure falls together with the axis of the wires. it is shown in the picture below. when the angular velocity is 0 deg./s, the sensor will output a voltage that is close to half of the supply voltage. a negative velocity will decrease this voltage while a positive velocity will increase this voltage. in the previous article i put a reference to a datasheet, but it doesn't seem to be correct. after 50 mails to hobbyking, i gave up finding the datasheet, and just found out my values by trial/error. this what i came up with at a supply voltage of 5v: offset (output at angular velocity = 0): 2.65v sensitivity (scale factor): 107.42 mv/deg./s the value for the offset can be measured with a multimeter. to find the value for the sensitivity, i wrote the arduino program that is shown below, and used the serial monitor to check the correctness. e.g. hold the quadrocopter at 90 deg. and see if the measurement is correct or not. trial/error! the weird number "107.42" was a result of the conversion from digital to analog. the arduino program let's take a closer look at the arduino program now. if you are using the gyroscope from the hk401b like me, you can connect it by putting 5v between the black and red wires of the gyro (or whatever colors you soldered to the supply pins) and by connecting the white (signal) cable to the a0 analog input. if you are using another analog sensor, it should be easy enough to figure out how to connect it! the whole program works with 8 bit values. this means that the analog offset value of 2.65 results in a digital value of 136: the same principle would apply to the sensitivity if it was given in the datasheet. i found this value by trial/error so i knew it was 5.5 digitally. however the arduino has a 10-bit adc, i only use the 8 most significant bits. the last two bits of the adc are usually not used because they contain a lot of noise and it is a lot more efficiënt to work with 8-bit values on an 8-bit processor ;). it should be very easy now to see how i converted the approximated integral equation we saw earlier into an extremely simple program. the program runs at 100hz. every iteration we read the sensor, and convert its value into an 8-bit digital number (gyrovalue). after this, the offset is removed and the gyrovalue is being converted to [deg. /s] by multiplying it with the sensitvity. finally we multiply it with the sampling period (*0.01 or /100) and add it to the angle, which is the sum (approximated integral) of all previous values. it is very important to take a look at the datatypes you are using. i recommend using a float for the angle and the rate. the reason for this is that if you make more approximations by rounding off to another datatype, the drift would grow (extremely) fast. the only way this integral approximation will work, is by doing it very precise. unsigned char gyrovalue = 0; unsigned char offset = 136; float angle = 0; float gyrorate; void setup() { serial.begin(9600); } void loop() { gyrovalue = analogread(a0) >> 2; // work with 8 most significant bits! gyrorate = (gyrovalue - offset) * 5.5; // sensitivity has been found trial/error angle += gyrorate / 100.0; serial.print(angle); serial.print("\n"); delay(10); } the pic program to demonstrate how easy it is to port this code on another platform, i included my implementation for the pic16f690. a 20mhz crystal was used, and the gyro is connected the ra0-pin. i make use of the hi-tech c lite compiler. #include #include __config(fosc_hs & wdte_off & pwrte_off & mclre_off & cp_off); #define _xtal_freq 20000000 /* function prototypes */ void adc(void); void main(void); unsigned char gyrovalue; unsigned char gyrooffset = 136; float gyrorate; float angle = 0; /* main program */ void main(void) { // init trisa = 0b00000001; // ra0 input (analog) adcon0 = 0b00000001; // ad conversion init ra0 = input adcon1 = 0b00000000; while(1) { // read gyro adc(); gyrovalue = adresh; gyrorate = (gyrovalue - gyrooffset) * 5.5; angle += gyrorate / 100.0; __delay_us(10000); // 10 ms } } void adc(void) { go_done = 1; while(go_done); } results here is a little video of the program in action. it is very clear to see the problem of drift introduced by approximating the integral by a sum. i also gave the sensor a few ticks with my finger to show that the drift is much stronger as a result of external forces that work directly on the sensor (e.g. motor vibrations, shocks, etc.). update: to solve the drift error, we can combine the gyroscope data with accelerometer data using a complementary filter. this is described here. tags: quadrocopter setting up the raspberry pi for programming from mac os x submitted by pieter-jan on mon, 03/09/2012 - 13:49 in this article i will explain how i set up my raspberry pi to be programmable from my macbook pro. i didn't want to use an external monitor & keyboard, nor did i want to connect my pi to the router of my home network as this setup would not be very mobile. to achieve this, i made use of ssh and the mac's ability to share its internet with other computers. i will not use any gui to do the programming, as i find that running a gui on a small embedded computer like this is overkill. instead i will do all the programming from the command line. a small example of how to do this is included here as well. this article was mainly written as a future reference for myself, but i hope it can be useful for others as well. step 1: prepare the sd-card first of all, you will need an sd-card with a bootable linux image. i recommend using the "raspbian wheezy" image, which is an optimized version of debian. it is downloadable from http://www.raspberrypi.org/downloads/. instructions for putting the image on the card properly can be found on the elinux website. if this has succeeded, you can boot up your raspberry pi! for the initial boot we will need an external monitor & keyboard, so we can set everything up properly. step 2: basic configurations the easiest way to do the basic setup is by making use of the raspi-config tool, it should start up automatically on your first boot. if it doesn't start automatically, you can also launch it with: sudo raspi-config i would recommend starting off by setting configure_keyboard and change_timezone. as we won't use any gui for our programming, it is a good idea to set up memory_split so that the arm gets 240mb of ram and the videocore only 16mb as this will speed up things a lot. if you have a large sd-card (> 4g) you might want to consider using expand_rootfs to enable all this space. the downside of this is that backups of your sd image will be significantly larger. the most important thing we had to do here, was to enable ssh. the more recent versions of raspbian have this enabled by default though. if you have used configure_keyboard, you should run: sudo setupcon to avoid a massive delay in the boot process. step 3: find out the raspberry pi's ip adres at this point, we need our pi connected to the internet. if you have a router close to your working environment, plugging it in there would be fine. if you don't however, it is very easy to use the "internet sharing" option on a mac to provide internet to your raspberry pi. on your mac, go to: "system preferences > sharing". as you can see, i chose to share my macbook's wifi through the ethernet port. if i plug in my raspberry there, it will have internet. now go back to the raspberry pi's monitor & keyboard. to be able to connect to the pi through ssh, we need to know the ip adres it is using. to find it out, we enter the following command: ifconfig you should see something like "inet addr: 192.168.2.2". step 4: connect to the raspberry pi from your mac now we know everything we need to know and everything is set up properly, we can disconnect the monitor & keyboard from our pi (forever). to connect establish the ssh connection, go to the mac terminal and type (you should of course change the ip with the one you found earlier): ssh -lpi 192.168.2.2 if it is the first time you connect to this device, you will probably see something like "the authenticity of the host can't be ... blabla". you can answer "yes" to this. you will be prompted for the password now. if you did not change this in step 2, and you are using the recommended raspbian image, the password is "raspberry". enter this, and you are now logged in to the pi! you should see something like this: step 5: setup a basic programming environment you don't need much to programming from the command line in linux, but you do need a good text editor. i use vim. if this is the first time you work with vim, i recommend taking 10 minutes time to check out a good tutorial. to install vim on your raspberry pi, simply type: sudo apt-get install vim because i think syntax highlighting and line numbering are essential programming tools, i want to enable these by default. you can do this by editing (or creating) the .vimrc file in your user directory. we'll do this using vim: vim ~/.vimrc then add the following two lines: syntax on set number now it's time to test our tools! if you write a very simple "hello world!"-program with vim, it should look like this: if you name the file "main.cpp", you can compile it with: g++ main.cpp -o helloworld if you then run it with: ./helloworld you can sit back, and enjoy the most simple program in the world! if you're interested in doing some more advanced programming of your raspberry pi, check out my article on low level programming of the raspberry pi. tags: raspberry pi universal/jamming gripper prototype submitted by pieter-jan on mon, 03/09/2012 - 12:25 i made my own version of the universal/jamming gripper created by john ahmend. you can do this too in 5 minutes! the recourses you need are: plastic syringe (ask your pharmacist, he/she will look weird but give it to you if you don't look like a drug addict) balloon (a small one) ground coffee duct tape piece of cloth/woven tissue (should act as a filter to let the air pass but not the coffee so keep this in mind) superglue to assemble it you have to go through the following steps: step 1 - cutt off the tip of the plastic syringe as cleanly as possible. step 2 - cover the hole that is now in the syringe with the piece of hankerchief and glue it reasonably tight with the superglue. let it dry. step 3 - fill the balloon as good as you can with the coffee. this is a difficult step! it might help if you fill the balloon with air a few times so that it stretches. step 4 - make sure the syringe is closed so that it does not contain any air. then pull the neck from the balloon over the syringe, and make sure you don't trap any air. if you do trap air, try to get it out as much as possible as it will drastically decrease the performance of your gripper. step 5 - tape the balloon and the syringe together as tightly as possible using the duct tape. here is the gripper in action! the cool thing about this gripper is that you don't need a pump or anything pneumatic. so if you could find a way to professionally make this, and actuate the seringe with a solenoïd, you can turn this into a very compact and fast device which has all the actuators on board. this would make it fully electrically controllable. i quickly sketched up an idea i had for this in which i added some extra "fingers" which would make the universal gripper even more universal ;). the first part of the finger would be driven with a small motor and a worm wheel to block it when the motor is not on. the second part part of the finger would be driven by small linear actuators. i never really built this, it's just an idea. tags: mechanicsgrippersrobotics hacking the hobbyking hk401b gyroscope module submitted by pieter-jan on sat, 21/07/2012 - 10:12 for the quadrocopter project we are doing, we bought a hobbyking hk401b gyro module. this module includes a one axis analog gyroscope and a full microcontroller circuit, that already processes the gyroscope data. it sends out the "corrections" the motors should make and can be connected directly to the typical rc-setup. because we are not interested in processed data, we decided to break open the module, and desolder the gyroscope. here are some pictures of the proces: as you can see on the pictures, the hk401b consists of three parts. the gyro part is the one that has initially no wires attached to it (in the pictures above i already added wires though). once you desolder this part, it is sufficient to add the supply voltage (black and red wires: 5v - check the picture to see which is which) and a third wire for the signal (white). the axis of rotation that the gyro can "sense" is in the same direction of the wires. the following video shows the signal that can be expected: this datasheet seems like it might be the right one. tags: quadrocopter four (4) independent pwm-signals generated with one pic submitted by pieter-jan on tue, 17/07/2012 - 11:55 every self-respecting engineer has at least one moment in his or her life when it seems like the right thing to do is build flying stuff. in the case of me and a few friends, this means that we are going to do an attempt at creating our own quadrocopter. we quickly started looking around the internet, and placed an order at http://www.hobbyking.com/ (i will describe the contents of this order in a later post once it has shipped to my doorstep). because the shipping would take a few days, and another property of the self-respecting engineer is that he does not have any form of patience when it comes to building stuff. we decided that we would already start designing the control circuitry, which we will try to do from scratch. a first step in this is finding a way to control the speed of the motors. the signal quadrocopters are built with brushless dc motors. a common mistake is to assume that these are conventional dc-motors, and can be driven as such, which is far from true!! actually, a brushless dc motor is a permanent magnet ac motor with a block waveform. i won't go into detail, but this is important stuff! because of this ac-block waveform we can't just drive this motor with a normal h-bridge, other circuitry is required. it would be very possible to build this ourselves, but the challenge is pretty low and because this is part of the power-circuit, the risk of introducing power-loss is too high. this makes that we use what the industry has provided for us: the esc (electronic speed controller). we can just hook up our motor and our battery to the esc. if this is driven with a specific pwm signal, the speed of the motor will vary. this is what the pwm signal looks like: first send a 1 ms pulse, then send the second pulse that controls the speed (max. speed = 1ms, min. speed = 0ms) and then wait until the total period is about 10ms. the waiting time can be longer than 10 ms because it would be hard to do this with rc otherwise. it is only the pulse length that is important. from this information, we know that we have to generate a pwm-signal of 100hz (period 10ms) with a duty cycle that is variable between 10% and 20%. we will have to be able to do this 4 times independently, because a quadrocopter has four motors that have to be able to operate at different speeds (duh!). prototype as the title said, we created this pwm-controller using a pic microcontroller. the one we chose was a very small one: a pic16f684 with 128 bytes of ram and 2048 words of flash. because we don't have any rc-setup yet, the inputs that control the motor speed are 4 potentiometers that are read in with an analog multiplexer (74hct4051). this saves us a pin on the mcu and makes it a little easier to program the adc unit properly. also when we want to add accelerometer or gyro modules later with analog signals, we can easily do this without losing pins (except for one extra adres pin ofcouse!). the full schematic looks like this: here's a picture of the prototype: the four led's are at the output pins (where the esc's will be attached to) and give some visual feedback during prototyping (the intensity of a led changes when the duty cycle is modified, duh!). we could have chosen a pic that has 4 independent pwm channels like the pic18f4x31. why didn't we? because we believe that this is one of the simplest parts of making a quadrocopter and it shouldn't have any impact on the choice of your hardware. it's also a nice exercise in efficiency to work with low resources. if we want to cram the full quadrocopter control-software in a pic one day, we might want to start thinking efficient from day one. the code i provide here is not 100% optimal, but i did my best (let me know if you have any improvements!). program structure the hardest thing about writing the code was finding a way of outputting the 4 pwm signals with varying duty cycles at the same time . it is possible that motor 1 had to go faster than motor 2 at first (motor 1's pulse is longer than motor 2's pulse), but when the direction ischanged, motor 2 has to go faster than motor 1. this made it a little more awkward to generate the 4 pwm's at the same time. a little creativity though, easily solved this problem by sorting the pulses from short to long so that they could be turned off sequentially. because there are 3 obvious parts to the signal shown above, i decided to cut my code into three big pieces. this is how the program was organized: part 1: 0 - 1 ms set all output pins to high. read the 4 potentiometers and convert them to digital values using the internal adc of the pic. the values are stored in the adcvalues table. sort the adcvalues table from low to high and keep track of which output corresponds to which value (whichmotor). wait until the first millisecond has passed part 2: 1 - 2 ms wait until first output pin has to be turned off, and then turn it off. do this for the other 3 pins as well. - wait until the second millisecond has passed. part 3: 2 - 8 ms wait until 8 ms have passed. the c program i make extensive use of the internal timers (timer 1) of the microcontroller because this gives a lot of control over the actual time passed, and you can do other stuff in the meantime instead of just waiting like with a delay function. the time that passes for a value of the tmr1-register can be easily calculated with: time = 1/oscvalue * 4 * prescaler * (65536 - tmr1). a very useful tool for this is the pic timer calculator. as you can see in the code underneath, the remaining program has to be put in the two while loops. i indicated this with "// do something" in the comment. i make use of the mplabx ide and the hi-tech c lite compiler. #include #include #include __config(fosc_hs & wdte_off & pwrte_off & mclre_off & cp_off); #define _xtal_freq 20000000 /* function prototypes */ void adc(void); void main(void); /* global variables */ unsigned char adcvalues[4]; unsigned char whichmotor[4]; unsigned char help; static int accdata[3], gyrdata[3]; // accx ; accy ; accz ; gyrx; gyry; gyrz //spid pitchpid, rollpid; static int pitch = 0, roll = 0; /* main program */ void main(void) { unsigned char i, j; unsigned char portavalue = 0b00000000, portcvalue = 0b00000000; // init trisa = 0b00000001; // ra0 input (analog), ra1 & ra2 output (mux adres) trisc = 0b00000000; // port c output (pwm signals) adcon0 = 0b00000001; // ad conversie init adcon1 = 0b00000000; peie = 1; // peripheral interrupt enable gie = 1; // global interrupt enable tmr1ie = 1; // timer 1 interrupt enable t0ie = 1; tmr1if = 0; t1con = 0b00000000; // timer 1 prescale 1:1 // infinite loop while(1) { // ------------------------------------------------------------------ // // -------------------------- ms 0 to ms 1 -------------------------- // // ------------------------------------------------------------------ // // set all the pins high to start the pwm portcvalue = 0b00001111; // keep track of current state of the ports in a register to walk around // the rmw-problem portc = portcvalue; // start timer 1 ms (time = 1/oscvalue * 4 * prescaler * (65536 - tmr1)) tmr1 = 60536; // 1 ms with prescaler 1:1 and freq 20mhz tmr1on = 1; // get adc value of all input pot's i=0; for(i; i < 4; i++) { // set mux adres on ra1 and ra2 // without affecting current state of porta (read modify write) portavalue &= 0b11111001; portavalue |= (i << 1); porta = portavalue; __delay_us(1); // delay here to wait until mux value is on the pin adc(); (adresh <= 250)? adcvalues[i] = adresh : adcvalues[i] = 250; } // initialise the whichmotor table i = 0; for(i; i<4; i++) whichmotor[i] = i; // sort the adc values from low to high // (this is the order in which they will be turned off) i=0; for(i; i<4; i++) { j = i+1; for(j; j < 4; j++) { if(adcvalues[j] < adcvalues[i]) { help = adcvalues[i]; adcvalues[i]=adcvalues[j]; adcvalues[j]=help; help = whichmotor[i]; // keep track of output pins whichmotor[i] = whichmotor[j]; whichmotor[j] = help; } } } // calculate the values that have to be loaded in the timer unsigned int delayvalues[5]; i = 0; delayvalues[0] = 65535 - adcvalues[0]*20; for(i; i<3; i++) { // time = 1/oscvalue * 4 * prescaler * (65536 - tmr1) // adc value is scaled to 1/4 of 1000 (value * 4) delayvalues[i+1] = 65535 - (adcvalues[i+1] - adcvalues[i])*20; } delayvalues[4] = 60535 + adcvalues[3]*20; // remaining time to 1 ms // wait until the first ms is passed while(!tmr1if) // wait until the timer overflows { // do something } tmr1if = 0; // must be cleared in the software tmr1on = 0; // ------------------------------------------------------------------ // // -------------------------- ms 2 to ms 3 -------------------------- // // ------------------------------------------------------------------ // // turn off the outputs in the right order: ~ is binary invert // wait until first output has to be turned off // whichmotor holds the index of the current output pin // (bitshift inverted 1 this many places to turn that output off) i = 0; for (i; i<4; i++) { tmr1 = delayvalues[i]; tmr1on = 1; portcvalue &= ~(0b00000001 << whichmotor[i]); while(!tmr1if); tmr1on = 0; tmr1if = 0; portc = portcvalue; } tmr1 = delayvalues[4]; tmr1on = 1; while(!tmr1if); tmr1on = 0; tmr1if = 0; // ------------------------------------------------------------------ // // -------------------------- ms 3 to ms 10 ------------------------- // // ------------------------------------------------------------------ // // start timer 8 ms tmr1 = 25536; // 8 ms with prescaler 1:1 and freq 20mhz tmr1on = 1; while(!tmr1if) { // do shit - read sensor or whatever } tmr1if = 0; tmr1on = 0; } } void adc(void) { go_done = 1; while(go_done); } results it has to be said that this code is not perfect yet. because stopping & starting the timers and writing to portc all happens outside the timer, a small error is made here. of course this could be compensated for, but this would make the code more complex, which is not necessairy.here are some pictures and a video to show the working circuit. here is a video of our pwm-controller driving two motors (i was too lazy to screw on all four motors because i will have to take them off soon anyway ...): tags: quadrocoptermicrocontrollers narf keypoint test submitted by pieter-jan on sat, 26/05/2012 - 10:23 narf is a method for interest point detection developed by the pcl-community. however the algorithm is different, it is mostly used as a license free variant of the sift-algorithm. these kind of algorithms have proven to be very effective for object recognition, which is an important reason i found it necessary to check them out. a second reason is that i still haven't succeeded in getting good results with the icp-algorithm for point cloud alignment (registration). i hope that, when using icp on two sets of keypoints, the algorithm will be faster and less prone to accumulative errors. to implement the narf-detector i took a quick look at the tutorial on the pcl-website. i used the code as a starting point to make my own cleaner version of it. it is given in the code block underneath. note that this is part of a class called "model3d". the code basically creates a range image, and then simply detects the keypoints on that image. afterwards the found points are transformed back to 3d, and added to the original cloud in green (for visualization purposes!). void model3d::createrangeimage() { pcl::pointcloud& pointcloud = *this->cloud; eigen::affine3f scenesensorpose = eigen::affine3f(eigen::translation3f(pointcloud.sensor_origin_[0], pointcloud.sensor_origin_[1], pointcloud.sensor_origin_[2]))*eigen::affine3f (pointcloud.sensor_orientation_); this->rangeimage->createfrompointcloud (pointcloud, pcl::deg2rad (0.5f), pcl::deg2rad (360.0f), pcl::deg2rad (180.0f), scenesensorpose, pcl::rangeimage::camera_frame, 0.0, 0.0f, 1); this->rangeimage->setunseentomaxrange(); } void model3d::detectnarfkeypoints() { this->createrangeimage(); /* extract narf keypoints */ pcl::rangeimageborderextractor rangeimageborderextractor; pcl::narfkeypoint narfkeypointdetector; narfkeypointdetector.setrangeimageborderextractor (&rangeimageborderextractor); narfkeypointdetector.setrangeimage (this->rangeimage.get()); narfkeypointdetector.getparameters().support_size = 0.2f; narfkeypointdetector.setradiussearch(0.01); //narfkeypointdetector.setsearchmethod(tree); pcl::pointcloud keypointindices; narfkeypointdetector.compute (keypointindices); cout << "found "<keypoints->points.resize(keypointindices.points.size()); for (size_t i=0; ikeypoints->points[i].getvector3fmap () = this->rangeimage->points[keypointindices.points[i]].getvector3fmap(); this->keypoints->points[i].r = 0; this->keypoints->points[i].g = 255; this->keypoints->points[i].b = 0; //this->keypoints->points[i].size } *this->cloud += *this->keypoints; /* extract narf descriptors for interest points */ std::vector keypointindices2; keypointindices2.resize (keypointindices.points.size ()); for (unsigned int i=0; irangeimage.get(), &keypointindices2); narfdescriptor.getparameters().support_size = 0.2f; narfdescriptor.getparameters().rotation_invariant = true; pcl::pointcloud narfdescriptors; narfdescriptor.compute (narfdescriptors); cout << "extracted "<(point(i,j)) = 0; // create polygon from vertices vector roi_poly; approxpolydp(roi_vertices, roi_poly, 1.0, true); // fill polygon white fillconvexpoly(mask, &roi_poly[0], roi_poly.size(), 255, 8, 0); // create new image for result storage mat imagedest = cvcreatemat(480, 640, cv_8uc3); // cut out roi and store it in imagedest image->copyto(imagedest, mask); the mask looks like this: the subtracted part is shown here: tags: computer vision bachelor assignment submitted by pieter-jan on mon, 30/05/2011 - 08:33 the assignment was to build a solar tracker as efficiently as possible. we decided to build one that is controlled by a microcontroller-circuit. a real time clock was used to calculate the position of the sun with a time-based algorithm. this is the circuit we designed: here are some pictures of the fully soldered circuit: i also built a prototype in wood to see if it works well. the solar tracker only moves a few times a day. here is a video taken when it did: tags: microcontrollersmechanics welcome to my website! i'm pieter-jan van de maele, an engineering student living in brussels, belgium. i try to know as much as possible about electronics, robotics and programming. every day is a learning experience, and i hope to use this website as a way to organize the chaos in my head. connect with me: follow @pieterjanvdm articles low level programming of the raspberry pi in c post date: friday, may 24, 2013 - 05:10 diy raspberry pi breakout cable post date: monday, may 20, 2013 - 09:54 reading a imu without kalman: the complementary filter post date: friday, april 26, 2013 - 08:38 replacing the raspberry pi's sd card socket post date: thursday, october 11, 2012 - 11:06 reading nintendo 64 controller with pic microcontroller post date: wednesday, september 12, 2012 - 08:37 getting the angular position from gyroscope data post date: thursday, september 6, 2012 - 02:41 setting up the raspberry pi for programming from mac os x post date: monday, september 3, 2012 - 13:49 universal/jamming gripper prototype post date: monday, september 3, 2012 - 12:25 hacking the hobbyking hk401b gyroscope module post date: saturday, july 21, 2012 - 10:12 four (4) independent pwm-signals generated with one pic post date: tuesday, july 17, 2012 - 11:55 narf keypoint test post date: saturday, may 26, 2012 - 10:23 custom roi (region of interest) with opencv post date: friday, april 6, 2012 - 15:44 bachelor assignment post date: monday, may 30, 2011 - 08:33 © 2013 pieter-jan van de maele all rights reserved


Here you find all texts from your page as Google (googlebot) and others search engines seen it.

Words density analysis:

Numbers of all words: 13872

One word

Two words phrases

Three words phrases

the - 7.35% (1019)
his - 1.59% (221)
this - 1.59% (220)
int - 1.32% (183)
and - 1.26% (175)
you - 1.24% (172)
for - 1.12% (155)
that - 1.1% (152)
her - 0.97% (135)
use - 0.92% (128)
with - 0.87% (121)
wil - 0.76% (105)
per - 0.76% (105)
will - 0.75% (104)
set - 0.73% (101)
bsc - 0.7% (97)
all - 0.68% (95)
are - 0.66% (91)
one - 0.65% (90)
bit - 0.63% (88)
value - 0.62% (86)
can - 0.62% (86)
out - 0.61% (84)
data - 0.59% (82)
gpio - 0.58% (81)
point - 0.56% (78)
pin - 0.56% (78)
not - 0.53% (74)
nop - 0.52% (72)
define - 0.5% (70)
add - 0.49% (68)
read - 0.49% (68)
bsc0 - 0.48% (67)
low - 0.47% (65)
have - 0.46% (64)
struct - 0.45% (63)
#define - 0.45% (62)
time - 0.44% (61)
very - 0.43% (60)
ram - 0.43% (60)
our - 0.43% (60)
here - 0.42% (58)
roll - 0.41% (57)
register - 0.41% (57)
gyro - 0.41% (57)
put - 0.4% (56)
control - 0.4% (55)
port - 0.39% (54)
how - 0.39% (54)
see - 0.38% (53)
pic - 0.37% (52)
which - 0.37% (51)
its - 0.36% (50)
able - 0.36% (50)
from - 0.35% (49)
program - 0.35% (49)
start - 0.35% (49)
instruction - 0.35% (48)
controller - 0.32% (44)
raspberry - 0.32% (44)
key - 0.31% (43)
make - 0.3% (42)
need - 0.3% (41)
peripheral - 0.3% (41)
end - 0.3% (41)
off - 0.29% (40)
bits - 0.29% (40)
sit - 0.29% (40)
movlw - 0.27% (38)
but - 0.27% (38)
ide - 0.27% (37)
now - 0.27% (37)
i2c - 0.26% (36)
code - 0.26% (36)
void - 0.26% (36)
act - 0.26% (36)
signal - 0.26% (36)
keypoint - 0.26% (36)
movwf - 0.25% (35)
adc - 0.25% (35)
values - 0.25% (35)
using - 0.25% (34)
because - 0.24% (33)
first - 0.24% (33)
motor - 0.24% (33)
write - 0.23% (32)
mat - 0.23% (32)
thing - 0.23% (32)
points - 0.23% (32)
ack - 0.23% (32)
lot - 0.23% (32)
like - 0.22% (31)
led - 0.22% (31)
image - 0.22% (31)
some - 0.22% (31)
rate - 0.22% (30)
map - 0.22% (30)
want - 0.22% (30)
gyroscope - 0.21% (29)
work - 0.21% (29)
get - 0.21% (29)
was - 0.2% (28)
wait - 0.2% (28)
take - 0.2% (28)
cycle - 0.2% (28)
sure - 0.19% (27)
every - 0.19% (27)
tmr1 - 0.19% (26)
should - 0.19% (26)
loop - 0.19% (26)
connect - 0.19% (26)
narf - 0.18% (25)
adres - 0.18% (25)
has - 0.18% (25)
init - 0.18% (25)
way - 0.18% (25)
include - 0.18% (25)
done - 0.18% (25)
used - 0.18% (25)
own - 0.18% (25)
function - 0.18% (25)
look - 0.18% (25)
unsigned - 0.18% (25)
esc - 0.18% (25)
old - 0.18% (25)
pi. - 0.17% (24)
pins - 0.17% (24)
other - 0.17% (24)
filter - 0.17% (24)
output - 0.17% (24)
zero - 0.17% (24)
day - 0.17% (24)
below - 0.17% (24)
turn - 0.17% (23)
step - 0.17% (23)
then - 0.17% (23)
mpu6050 - 0.17% (23)
sensor - 0.17% (23)
show - 0.17% (23)
part - 0.17% (23)
portb - 0.17% (23)
mac - 0.17% (23)
clear - 0.16% (22)
there - 0.16% (22)
fifo - 0.16% (22)
config - 0.15% (21)
would - 0.15% (21)
when - 0.15% (21)
accelerometer - 0.15% (21)
------------------------- - 0.14% (20)
position - 0.14% (20)
#include - 0.14% (20)
address - 0.14% (20)
any - 0.14% (20)
main - 0.14% (20)
after - 0.14% (20)
find - 0.14% (19)
bsc0_fifo - 0.14% (19)
your - 0.14% (19)
cycles - 0.14% (19)
type - 0.14% (19)
don't - 0.14% (19)
size - 0.14% (19)
-------------------------- - 0.14% (19)
create - 0.14% (19)
these - 0.13% (18)
pieter-jan - 0.13% (18)
range - 0.13% (18)
article - 0.13% (18)
programming - 0.13% (18)
picture - 0.13% (18)
angular - 0.13% (18)
follow - 0.13% (18)
datasheet - 0.13% (18)
2012 - 0.13% (18)
status - 0.13% (18)
detect - 0.13% (18)
100 - 0.13% (18)
wire - 0.12% (17)
know - 0.12% (17)
microcontroller - 0.12% (17)
quadrocopter - 0.12% (17)
block - 0.12% (17)
char - 0.12% (17)
got - 0.12% (17)
bcm2835 - 0.12% (17)
10) - 0.12% (17)
example - 0.12% (17)
form - 0.12% (17)
angle - 0.12% (17)
also - 0.12% (16)
give - 0.12% (16)
base - 0.12% (16)
slot - 0.12% (16)
result - 0.12% (16)
too - 0.12% (16)
mean - 0.12% (16)
axis - 0.12% (16)
git - 0.12% (16)
below. - 0.12% (16)
day, - 0.12% (16)
short - 0.12% (16)
just - 0.11% (15)
float - 0.11% (15)
decfsz - 0.11% (15)
gpio.addr - 0.11% (15)
porta - 0.11% (15)
red - 0.11% (15)
(); - 0.11% (15)
problem - 0.11% (15)
adcvalues - 0.11% (15)
card - 0.11% (15)
goto - 0.11% (15)
them - 0.11% (15)
cloud - 0.11% (15)
they - 0.11% (15)
rtc - 0.11% (15)
shown - 0.11% (15)
delay - 0.11% (15)
date: - 0.1% (14)
0); - 0.1% (14)
means - 0.1% (14)
over - 0.1% (14)
cable - 0.1% (14)
proper - 0.1% (14)
adress - 0.1% (14)
on. - 0.1% (14)
above - 0.1% (14)
solder - 0.1% (14)
than - 0.1% (14)
input - 0.1% (14)
0x20 - 0.1% (14)
only - 0.1% (14)
found - 0.1% (14)
high - 0.1% (14)
roi - 0.1% (14)
easy - 0.1% (14)
bcd - 0.1% (14)
post - 0.1% (14)
circuit - 0.1% (14)
array - 0.1% (14)
measure - 0.1% (14)
contain - 0.1% (14)
it's - 0.1% (14)
two - 0.09% (13)
call - 0.09% (13)
submitted - 0.09% (13)
0x00 - 0.09% (13)
following - 0.09% (13)
voltage - 0.09% (13)
into - 0.09% (13)
rest - 0.09% (13)
timer - 0.09% (13)
pwm - 0.09% (13)
tags: - 0.09% (13)
round - 0.09% (13)
macro - 0.09% (13)
return - 0.09% (13)
file - 0.09% (13)
force - 0.09% (13)
pass - 0.09% (12)
good - 0.09% (12)
little - 0.09% (12)
instructions - 0.09% (12)
decimal - 0.09% (12)
possible - 0.09% (12)
board - 0.09% (12)
(see - 0.09% (12)
store - 0.09% (12)
keypoints - 0.09% (12)
while - 0.09% (12)
everything - 0.09% (12)
system - 0.09% (12)
registers - 0.09% (12)
more - 0.09% (12)
analog - 0.09% (12)
small - 0.09% (12)
drift - 0.08% (11)
reading - 0.08% (11)
wires - 0.08% (11)
number - 0.08% (11)
second - 0.08% (11)
vector - 0.08% (11)
full - 0.08% (11)
imu - 0.08% (11)
course - 0.08% (11)
byte - 0.08% (11)
might - 0.08% (11)
this, - 0.08% (11)
right - 0.08% (11)
bcm2835_peripheral - 0.08% (11)
pitch - 0.08% (11)
page - 0.08% (11)
descriptor - 0.08% (11)
poll - 0.08% (11)
*(gpio.addr - 0.08% (11)
most - 0.08% (11)
ts. - 0.08% (11)
send - 0.08% (11)
setup - 0.08% (11)
error - 0.08% (11)
did - 0.08% (11)
interest - 0.08% (11)
n64 - 0.08% (11)
physical - 0.07% (10)
until - 0.07% (10)
check - 0.07% (10)
previous - 0.07% (10)
correct - 0.07% (10)
oscillator - 0.07% (10)
freq - 0.07% (10)
fsr - 0.07% (10)
reason - 0.07% (10)
extra - 0.07% (10)
properly - 0.07% (10)
#define) - 0.07% (10)
same - 0.07% (10)
button - 0.07% (10)
figure - 0.07% (10)
try - 0.07% (10)
back - 0.07% (10)
about - 0.07% (10)
pointcloud - 0.07% (10)
whichmotor - 0.07% (10)
note - 0.07% (10)
three - 0.07% (10)
memory - 0.07% (10)
hard - 0.07% (10)
speed - 0.07% (10)
real - 0.07% (10)
let - 0.07% (10)
change - 0.07% (10)
it. - 0.07% (10)
offset - 0.07% (10)
without - 0.06% (9)
reset - 0.06% (9)
sent - 0.06% (9)
complementary - 0.06% (9)
wait_i2c_done() - 0.06% (9)
generate - 0.06% (9)
(1) - 0.06% (9)
easily - 0.06% (9)
build - 0.06% (9)
around - 0.06% (9)
simple - 0.06% (9)
... - 0.06% (9)
sensitivity - 0.06% (9)
fast - 0.06% (9)
0x80 - 0.06% (9)
rb7 - 0.06% (9)
place - 0.06% (9)
tmp - 0.06% (9)
well - 0.06% (9)
another - 0.06% (9)
skip - 0.06% (9)
given - 0.06% (9)
mask - 0.06% (9)
order - 0.06% (9)
tmr1if - 0.06% (9)
peripherals - 0.06% (9)
fsr0l - 0.06% (9)
long - 0.06% (9)
what - 0.06% (9)
me. - 0.06% (9)
header - 0.06% (9)
video - 0.06% (9)
though - 0.06% (9)
vim - 0.06% (9)
side - 0.06% (8)
bsc0_c - 0.06% (8)
etc. - 0.06% (8)
extern - 0.06% (8)
bsc0_s - 0.06% (8)
motors - 0.06% (8)
1); - 0.06% (8)
gripper - 0.06% (8)
i++) - 0.06% (8)
signals - 0.06% (8)
extract - 0.06% (8)
connected - 0.06% (8)
where - 0.06% (8)
tmr1on - 0.06% (8)
does - 0.06% (8)
clear_status - 0.06% (8)
portc - 0.06% (8)
implement - 0.06% (8)
much - 0.06% (8)
install - 0.06% (8)
velocity - 0.06% (8)
recommend - 0.06% (8)
virtual - 0.06% (8)
understand - 0.06% (8)
prototype - 0.06% (8)
enable - 0.06% (8)
open - 0.06% (8)
line - 0.06% (8)
internet - 0.06% (8)
computer - 0.06% (8)
one. - 0.06% (8)
new - 0.06% (8)
narfdescriptor - 0.06% (8)
important - 0.06% (8)
help - 0.06% (8)
big - 0.06% (8)
gyrovalue - 0.06% (8)
data, - 0.06% (8)
device - 0.06% (8)
bcd_to_decimal(bsc0_fifo - 0.05% (7)
rpi.h - 0.05% (7)
bus - 0.05% (7)
close - 0.05% (7)
different - 0.05% (7)
initial - 0.05% (7)
version - 0.05% (7)
provide - 0.05% (7)
interested - 0.05% (7)
built - 0.05% (7)
bytes - 0.05% (7)
macro's - 0.05% (7)
contains - 0.05% (7)
nor - 0.05% (7)
sampling - 0.05% (7)
(unsigned - 0.05% (7)
working - 0.05% (7)
gpfsel - 0.05% (7)
however - 0.05% (7)
parts - 0.05% (7)
(i; - 0.05% (7)
--------------------------------------------------------------- - 0.05% (7)
indicate - 0.05% (7)
supply - 0.05% (7)
refer - 0.05% (7)
pulse - 0.05% (7)
useful - 0.05% (7)
few - 0.05% (7)
trisb - 0.05% (7)
serial - 0.05% (7)
setting - 0.05% (7)
doing - 0.05% (7)
polling - 0.05% (7)
nice - 0.05% (7)
level - 0.05% (7)
e.g. - 0.05% (7)
2013 - 0.05% (7)
is: - 0.05% (7)
writing - 0.05% (7)
both - 0.05% (7)
ready - 0.05% (7)
bsc0. - 0.05% (7)
pictures - 0.05% (7)
period - 0.05% (7)
module - 0.05% (7)
times - 0.05% (7)
mhz - 0.05% (7)
sudo - 0.05% (7)
bsc0_dlen - 0.05% (7)
results - 0.05% (7)
forces - 0.04% (6)
starting - 0.04% (6)
keep - 0.04% (6)
copy - 0.04% (6)
acces - 0.04% (6)
for(i; - 0.04% (6)
tape - 0.04% (6)
drive - 0.04% (6)
well. - 0.04% (6)
may - 0.04% (6)
prescale - 0.04% (6)
air - 0.04% (6)
syringe - 0.04% (6)
that, - 0.04% (6)
------------------------------------------------------------------ - 0.04% (6)
could - 0.04% (6)
measurement - 0.04% (6)
current - 0.04% (6)
arm - 0.04% (6)
track - 0.04% (6)
me, - 0.04% (6)
made - 0.04% (6)
less - 0.04% (6)
external - 0.04% (6)
something - 0.04% (6)
algorithm - 0.04% (6)
object - 0.04% (6)
hope - 0.04% (6)
properly. - 0.04% (6)
extremely - 0.04% (6)
adcvalues[i] - 0.04% (6)
fill - 0.04% (6)
unmap - 0.04% (6)
pin. - 0.04% (6)
cut - 0.04% (6)
passed - 0.04% (6)
start_write - 0.04% (6)
gpio_set - 0.04% (6)
case - 0.04% (6)
those - 0.04% (6)
18f - 0.04% (6)
/dev/mem - 0.04% (6)
digital - 0.04% (6)
approximation - 0.04% (6)
16f - 0.04% (6)
time. - 0.04% (6)
action - 0.04% (6)
32-bit - 0.04% (6)
here, - 0.04% (6)
wait_i2c_done(); - 0.04% (6)
next - 0.04% (6)
hk401b - 0.04% (6)
controllers - 0.04% (6)
integral - 0.04% (6)
obtain - 0.04% (6)
sda - 0.04% (6)
blink - 0.04% (6)
down - 0.04% (6)
indf0 - 0.04% (6)
here. - 0.04% (6)
added - 0.04% (6)
hobbyking - 0.04% (6)
main( - 0.04% (6)
register. - 0.04% (6)
operation - 0.04% (6)
bitshift - 0.04% (6)
org - 0.04% (6)
created - 0.04% (6)
((g)/10)) - 0.04% (6)
frequency - 0.04% (6)
before - 0.04% (6)
explain - 0.04% (6)
gyrorate - 0.04% (6)
detect" - 0.04% (6)
"card - 0.04% (6)
earlier - 0.04% (6)
white - 0.04% (6)
slave - 0.04% (6)
this: - 0.04% (6)
fully - 0.04% (6)
keyboard - 0.04% (6)
us. - 0.04% (5)
succeed - 0.04% (5)
microcontrollers - 0.04% (5)
tip - 0.04% (5)
outer - 0.04% (5)
chose - 0.04% (5)
off) - 0.04% (5)
1000 - 0.04% (5)
assembly - 0.04% (5)
0x02 - 0.04% (5)
zeroloop - 0.04% (5)
protect" - 0.04% (5)
decided - 0.04% (5)
controller, - 0.04% (5)
piece - 0.04% (5)
oneloop - 0.04% (5)
count - 0.04% (5)
image. - 0.04% (5)
last - 0.04% (5)
ssh - 0.04% (5)
balloon - 0.04% (5)
won't - 0.04% (5)
respond - 0.04% (5)
boot - 0.04% (5)
once - 0.04% (5)
descriptors - 0.04% (5)
perfect - 0.04% (5)
calculate - 0.04% (5)
0b00000000; - 0.04% (5)
automatic - 0.04% (5)
finite - 0.04% (5)
disturb - 0.04% (5)
seem - 0.04% (5)
power - 0.04% (5)
makes - 0.04% (5)
atan2 - 0.04% (5)
monitor - 0.04% (5)
already - 0.04% (5)
deg. - 0.04% (5)
sensor, - 0.04% (5)
stuff - 0.04% (5)
space - 0.04% (5)
four - 0.04% (5)
prescaler - 0.04% (5)
reference - 0.04% (5)
sum - 0.04% (5)
takes - 0.04% (5)
universal - 0.04% (5)
arduino - 0.04% (5)
quick - 0.04% (5)
think - 0.04% (5)
i=0; - 0.04% (5)
method - 0.04% (5)
basic - 0.04% (5)
kalman - 0.04% (5)
(in - 0.04% (5)
unit - 0.04% (5)
rid - 0.04% (5)
visual - 0.04% (5)
looks - 0.04% (5)
portcvalue - 0.04% (5)
break - 0.04% (5)
describe - 0.04% (5)
run - 0.04% (5)
-1; - 0.04% (5)
clear_status; - 0.04% (5)
alternate - 0.04% (5)
"g" - 0.04% (5)
except - 0.04% (5)
this. - 0.04% (5)
didn't - 0.04% (5)
it, - 0.04% (5)
gpio_base - 0.04% (5)
bsc0_a - 0.04% (5)
each - 0.04% (5)
access - 0.04% (5)
*(bsc0.addr - 0.04% (5)
pi, - 0.04% (5)
search - 0.04% (5)
works - 0.04% (5)
tutorial - 0.04% (5)
really - 0.04% (5)
111 - 0.04% (5)
manual - 0.04% (5)
start_read - 0.04% (5)
easier - 0.04% (5)
pcf8563 - 0.04% (5)
shows - 0.04% (5)
table - 0.04% (5)
((g)%10)*3 - 0.04% (5)
between - 0.04% (5)
defined - 0.03% (4)
desolder - 0.03% (4)
faster - 0.03% (4)
whichmotor[i] - 0.03% (4)
example, - 0.03% (4)
p->map - 0.03% (4)
seen - 0.03% (4)
magnitude - 0.03% (4)
*pitch - 0.03% (4)
making - 0.03% (4)
latb - 0.03% (4)
portb, - 0.03% (4)
finger - 0.03% (4)
changes - 0.03% (4)
while(!tmr1if) - 0.03% (4)
disturbance - 0.03% (4)
discuss - 0.03% (4)
x-axis - 0.03% (4)
out. - 0.03% (4)
remember - 0.03% (4)
0b00000001; - 0.03% (4)
function. - 0.03% (4)
ra0 - 0.03% (4)
thus - 0.03% (4)
...) - 0.03% (4)
architecture - 0.03% (4)
0x200000 - 0.03% (4)
driven - 0.03% (4)
100hz - 0.03% (4)
nintendo - 0.03% (4)
gives - 0.03% (4)
blocks - 0.03% (4)
getting - 0.03% (4)
adc(void) - 0.03% (4)
through - 0.03% (4)
go_done - 0.03% (4)
still - 0.03% (4)
plug - 0.03% (4)
y-axis - 0.03% (4)
*roll - 0.03% (4)
tool - 0.03% (4)
instead - 0.03% (4)
together - 0.03% (4)
available - 0.03% (4)
automatically - 0.03% (4)
(or - 0.03% (4)
connector - 0.03% (4)
can't - 0.03% (4)
timeout - 0.03% (4)
had - 0.03% (4)
"write - 0.03% (4)
i2c_init() - 0.03% (4)
finding - 0.03% (4)
board. - 0.03% (4)
string - 0.03% (4)
incf - 0.03% (4)
feedback - 0.03% (4)
actual - 0.03% (4)
called - 0.03% (4)
portavalue - 0.03% (4)
gui - 0.03% (4)
turned - 0.03% (4)
compensate - 0.03% (4)
lot. - 0.03% (4)
(4) - 0.03% (4)
turning - 0.03% (4)
inside - 0.03% (4)
independent - 0.03% (4)
(time - 0.03% (4)
complex - 0.03% (4)
binary - 0.03% (4)
buttons - 0.03% (4)
engineer - 0.03% (4)
bcm2708_peri_base - 0.03% (4)
taking - 0.03% (4)
systems - 0.03% (4)
sending - 0.03% (4)
inner - 0.03% (4)
pi's - 0.03% (4)
controller. - 0.03% (4)
started - 0.03% (4)
term, - 0.03% (4)
(this - 0.03% (4)
perform - 0.03% (4)
things - 0.03% (4)
best - 0.03% (4)
"rpi.h" - 0.03% (4)
apt-get - 0.03% (4)
filter. - 0.03% (4)
cmake - 0.03% (4)
github - 0.03% (4)
printf("failed - 0.03% (4)
invert - 0.03% (4)
even - 0.03% (4)
vertices - 0.03% (4)
one) - 0.03% (4)
class - 0.03% (4)
shape - 0.03% (4)
trisb, - 0.03% (4)
idea - 0.03% (4)
black - 0.03% (4)
opencv - 0.03% (4)
5.5 - 0.03% (4)
convert - 0.03% (4)
readloop - 0.03% (4)
september - 0.03% (4)
flat - 0.03% (4)
space. - 0.03% (4)
8-bit - 0.03% (4)
monday, - 0.03% (4)
mon, - 0.03% (4)
responds - 0.03% (4)
trial/error - 0.03% (4)
website - 0.03% (4)
compile - 0.03% (4)
normal - 0.03% (4)
succeeded - 0.03% (4)
attach - 0.03% (4)
20mhz - 0.03% (4)
mask. - 0.03% (4)
detail - 0.03% (4)
information - 0.03% (4)
word - 0.03% (4)
sets - 0.03% (4)
functionality - 0.03% (4)
location - 0.03% (4)
comes - 0.03% (4)
main(void) - 0.03% (4)
20000000 - 0.03% (4)
stop - 0.03% (4)
with: - 0.03% (4)
0b000000011 - 0.03% (4)
sleep - 0.03% (4)
simply - 0.03% (4)
set) - 0.02% (3)
rb4 - 0.02% (3)
linux - 0.02% (3)
gyrosocope - 0.02% (3)
necessary - 0.02% (3)
btfss - 0.02% (3)
many - 0.02% (3)
bsf - 0.02% (3)
3.3v - 0.02% (3)
home - 0.02% (3)
slow - 0.02% (3)
test - 0.02% (3)
mmap - 0.02% (3)
main.c - 0.02% (3)
risk - 0.02% (3)
image, - 0.02% (3)
functions - 0.02% (3)
prototypes - 0.02% (3)
moment - 0.02% (3)
(like - 0.02% (3)
wdt - 0.02% (3)
complete - 0.02% (3)
0x21 - 0.02% (3)
math - 0.02% (3)
i've - 0.02% (3)
syntax - 0.02% (3)
sd-card - 0.02% (3)
duty - 0.02% (3)
raspbian - 0.02% (3)
left - 0.02% (3)
pwm-signal - 0.02% (3)
usually - 0.02% (3)
better - 0.02% (3)
prototyping - 0.02% (3)
gpsel - 0.02% (3)
0x22 - 0.02% (3)
mclre - 0.02% (3)
0ms) - 0.02% (3)
broadcom - 0.02% (3)
indirect - 0.02% (3)
possibilities - 0.02% (3)
usb - 0.02% (3)
skips - 0.02% (3)
correct. - 0.02% (3)
minutes - 0.02% (3)
102 - 0.02% (3)
low, - 0.02% (3)
indicated - 0.02% (3)
indf0, - 0.02% (3)
0x00) - 0.02% (3)
leds - 0.02% (3)
datasheet. - 0.02% (3)
paste - 0.02% (3)
rb5 - 0.02% (3)
d1, - 0.02% (3)
-1) - 0.02% (3)
0x07 - 0.02% (3)
iorwf - 0.02% (3)
code. - 0.02% (3)
move - 0.02% (3)
bsc0_base - 0.02% (3)
0x03 - 0.02% (3)
here: - 0.02% (3)
bcf - 0.02% (3)
btfsc - 0.02% (3)
that. - 0.02% (3)
datasheet, - 0.02% (3)
while(1) - 0.02% (3)
space.\n"); - 0.02% (3)
loops - 0.02% (3)
coffee - 0.02% (3)
included - 0.02% (3)
compiler - 0.02% (3)
internet. - 0.02% (3)
bsc_c_i2cen - 0.02% (3)
pins, - 0.02% (3)
glue - 0.02% (3)
asm - 0.02% (3)
multiply - 0.02% (3)
default - 0.02% (3)
creating - 0.02% (3)
bsc_s_done - 0.02% (3)
tight - 0.02% (3)
universal/jamming - 0.02% (3)
register, - 0.02% (3)
program. - 0.02% (3)
now. - 0.02% (3)
interface - 0.02% (3)
hole - 0.02% (3)
i2c. - 0.02% (3)
generated - 0.02% (3)
said - 0.02% (3)
(which - 0.02% (3)
perfectly - 0.02% (3)
gpio4 - 0.02% (3)
rb3 - 0.02% (3)
fosc - 0.02% (3)
map_peripheral() - 0.02% (3)
latb, - 0.02% (3)
shapes - 0.02% (3)
bsc_c_st - 0.02% (3)
0x08 - 0.02% (3)
(no - 0.02% (3)
cool - 0.02% (3)
master - 0.02% (3)
problem, - 0.02% (3)
visible - 0.02% (3)
()); - 0.02% (3)
going - 0.02% (3)
article. - 0.02% (3)
()<< - 0.02% (3)
demo - 0.02% (3)
directly - 0.02% (3)
enough - 0.02% (3)
vision - 0.02% (3)
custom - 0.02% (3)
free - 0.02% (3)
attached - 0.02% (3)
always - 0.02% (3)
set_gpio_alt(g,a) - 0.02% (3)
pcl::deg2rad - 0.02% (3)
tmp; - 0.02% (3)
gpio_clr - 0.02% (3)
device. - 0.02% (3)
software - 0.02% (3)
source - 0.02% (3)
experience - 0.02% (3)
let's - 0.02% (3)
original - 0.02% (3)
drift, - 0.02% (3)
pwr_mgmt_1 - 0.02% (3)
pretty - 0.02% (3)
possible. - 0.02% (3)
measured - 0.02% (3)
saw - 0.02% (3)
(for - 0.02% (3)
embedded - 0.02% (3)
eigen::affine3f - 0.02% (3)
precise - 0.02% (3)
robotics - 0.02% (3)
actually - 0.02% (3)
middle - 0.02% (3)
breakout - 0.02% (3)
apply - 0.02% (3)
having - 0.02% (3)
fri, - 0.02% (3)
friday, - 0.02% (3)
contact - 0.02% (3)
people - 0.02% (3)
van - 0.02% (3)
significant - 0.02% (3)
(gyrovalue - 0.02% (3)
wires. - 0.02% (3)
electrical - 0.02% (3)
half - 0.02% (3)
purpose - 0.02% (3)
looking - 0.02% (3)
support - 0.02% (3)
anything - 0.02% (3)
(sudo - 0.02% (3)
solution - 0.02% (3)
etc.) - 0.02% (3)
bsc0_fifo; - 0.02% (3)
hardware - 0.02% (3)
repository - 0.02% (3)
polygon - 0.02% (3)
fact - 0.02% (3)
pic16f690. - 0.02% (3)
combine - 0.02% (3)
conversion - 0.02% (3)
pj_rpi - 0.02% (3)
putting - 0.02% (3)
imagedest - 0.02% (3)
examples - 0.02% (3)
assignment - 0.02% (3)
tmr1) - 0.02% (3)
integration - 0.02% (3)
solve - 0.02% (3)
help; - 0.02% (3)
1/oscvalue - 0.02% (3)
electronic - 0.02% (3)
equation - 0.02% (3)
total - 0.02% (3)
(65536 - 0.02% (3)
up. - 0.02% (3)
block_size - 0.02% (3)
nicely - 0.02% (3)
timers - 0.02% (3)
taken - 0.02% (3)
constant - 0.02% (3)
keyboard, - 0.02% (3)
discussed - 0.02% (3)
replacing - 0.02% (3)
fit - 0.02% (3)
approximated - 0.02% (3)
share - 0.02% (3)
input. - 0.02% (3)
- 0.02% (3)
pins. - 0.02% (3)
lying - 0.02% (3)
though. - 0.02% (3)
duh!). - 0.02% (3)
pi! - 0.02% (3)
enjoy - 0.02% (3)
increase - 0.02% (3)
*gpio.addr - 0.02% (3)
mechanical - 0.02% (3)
i'm - 0.02% (3)
command - 0.02% (3)
pads - 0.02% (3)
align - 0.02% (3)
pic. - 0.02% (3)
clock - 0.02% (3)
soldering - 0.02% (3)
sort - 0.02% (3)
somewhere - 0.02% (3)
1:1 - 0.02% (3)
interrupt - 0.02% (3)
instruction) - 0.02% (3)
adresh - 0.02% (3)
start_write; - 0.02% (3)
forcemagnitudeapprox - 0.02% (3)
8192 - 0.02% (3)
mux - 0.02% (3)
integrate - 0.02% (3)
corresponds - 0.02% (3)
0.01 - 0.02% (3)
first. - 0.02% (3)
m_pi - 0.02% (3)
gyroscope_sensitivity - 0.02% (3)
exact - 0.02% (3)
probably - 0.02% (3)
i<4; - 0.02% (3)
update - 0.02% (3)
pitchacc - 0.02% (3)
gain - 0.02% (3)
far - 0.02% (3)
rollacc - 0.02% (3)
180 - 0.02% (3)
0.98 - 0.02% (3)
*p) - 0.01% (2)
adcon1 - 0.01% (2)
sense - 0.01% (2)
adc(); - 0.01% (2)
macbook - 0.01% (2)
website. - 0.01% (2)
5.5; - 0.01% (2)
large - 0.01% (2)
main(void); - 0.01% (2)
mclre_off - 0.01% (2)
offset) - 0.01% (2)
while(go_done); - 0.01% (2)
03/09/2012 - 0.01% (2)
versions - 0.01% (2)
action. - 0.01% (2)
pwrte_off - 0.01% (2)
__config(fosc_hs - 0.01% (2)
sharing" - 0.01% (2)
future - 0.01% (2)
adcon0 - 0.01% (2)
100.0; - 0.01% (2)
cp_off); - 0.01% (2)
adc(void); - 0.01% (2)
router - 0.01% (2)
gyrooffset - 0.01% (2)
expose - 0.01% (2)
p->addr - 0.01% (2)
raspi-config - 0.01% (2)
configure_keyboard - 0.01% (2)
trisa - 0.01% (2)
(p->map - 0.01% (2)
_xtal_freq - 0.01% (2)
- 0.01% (2)
wdte_off - 0.01% (2)
hi-tech - 0.01% (2)
programming, - 0.01% (2)
code, - 0.01% (2)
(analog) - 0.01% (2)
compiler. - 0.01% (2)
demonstrate - 0.01% (2)
- 0.01% (2)
lite - 0.01% (2)
13:49 - 0.01% (2)
pieces. - 0.01% (2)
out, - 0.01% (2)
while(!tmr1if); - 0.01% (2)
cout - 0.01% (2)
0.2f; - 0.01% (2)
narfkeypointdetector.setrangeimage - 0.01% (2)
scenesensorpose - 0.01% (2)
green - 0.01% (2)
afterwards - 0.01% (2)
icp - 0.01% (2)
alignment - 0.01% (2)
variant - 0.01% (2)
way. - 0.01% (2)
10:23 - 0.01% (2)
manual. - 0.01% (2)
circuit. - 0.01% (2)
shit - 0.01% (2)
places - 0.01% (2)
however, - 0.01% (2)
modify - 0.01% (2)
(bcm2708_peri_base - 0.01% (2)
ra1 - 0.01% (2)
ra2 - 0.01% (2)
0x20000000 - 0.01% (2)
state - 0.01% (2)
portcvalue; - 0.01% (2)
certain - 0.01% (2)
inverted - 0.01% (2)
"1" - 0.01% (2)
j++) - 0.01% (2)
adcvalues[i]) - 0.01% (2)
whichmotor[j] - 0.01% (2)
65535 - 0.01% (2)
delayvalues[4] - 0.01% (2)
()<<" - 0.01% (2)
points.\n"; - 0.01% (2)
global - 0.01% (2)
april - 0.01% (2)
solar - 0.01% (2)
tracker - 0.01% (2)
algorithm. - 0.01% (2)
engineering - 0.01% (2)
organize - 0.01% (2)
creativity - 0.01% (2)
26, - 0.01% (2)
bachelor - 0.01% (2)
thursday, - 0.01% (2)
11, - 0.01% (2)
content - 0.01% (2)
saturday, - 0.01% (2)
july - 0.01% (2)
2011 - 0.01% (2)
08:33 - 0.01% (2)
for(int - 0.01% (2)
++i) - 0.01% (2)
<this->keypoints->points[i].g - 0.01% (2)
*this->cloud - 0.01% (2)
believe - 0.01% (2)
(keypointindices.points.size - 0.01% (2)
seemed - 0.01% (2)
microcontrollers, - 0.01% (2)
wanted - 0.01% (2)
05:10 - 0.01% (2)
(region - 0.01% (2)
interest) - 0.01% (2)
15:44 - 0.01% (2)
subtract - 0.01% (2)
cvcreatemat(480, - 0.01% (2)
640, - 0.01% (2)
static - 0.01% (2)
remaining - 0.01% (2)
enter - 0.01% (2)
gpio_base. - 0.01% (2)
duct - 0.01% (2)
detail, - 0.01% (2)
superglue - 0.01% (2)
air. - 0.01% (2)
trap - 0.01% (2)
actuate - 0.01% (2)
actuators - 0.01% (2)
/dev/mem" - 0.01% (2)
quickly - 0.01% (2)
hacking - 0.01% (2)
sat, - 0.01% (2)
10:12 - 0.01% (2)
project - 0.01% (2)
circuit, - 0.01% (2)
ground - 0.01% (2)
plastic - 0.01% (2)
rotation - 0.01% (2)
type: - 0.01% (2)
map_peripheral(struct - 0.01% (2)
192.168.2.2 - 0.01% (2)
password - 0.01% (2)
environment - 0.01% (2)
text - 0.01% (2)
vim, - 0.01% (2)
.vimrc - 0.01% (2)
peripheral, - 0.01% (2)
main.cpp - 0.01% (2)
helloworld - 0.01% (2)
structure - 0.01% (2)
world! - 0.01% (2)
rpi.c - 0.01% (2)
12:25 - 0.01% (2)
gpio, - 0.01% (2)
direction - 0.01% (2)
underneath, - 0.01% (2)
so, - 0.01% (2)
length - 0.01% (2)
variable - 0.01% (2)
pwm-controller - 0.01% (2)
rc-setup - 0.01% (2)
potentiometers - 0.01% (2)
to) - 0.01% (2)
efficient - 0.01% (2)
waiting - 0.01% (2)
internal - 0.01% (2)
millisecond - 0.01% (2)
passed. - 0.01% (2)
(timer - 0.01% (2)
{gpio_base}; - 0.01% (2)
volatile - 0.01% (2)
longer - 0.01% (2)
high. - 0.01% (2)
seems - 0.01% (2)
placed - 0.01% (2)
pwm-signals - 0.01% (2)
11:55 - 0.01% (2)
self-respecting - 0.01% (2)
adresses - 0.01% (2)
life - 0.01% (2)
stuff. - 0.01% (2)
later - 0.01% (2)
challenge - 0.01% (2)
addresses - 0.01% (2)
136; - 0.01% (2)
motors. - 0.01% (2)
brushless - 0.01% (2)
waveform - 0.01% (2)
circuitry - 0.01% (2)
gyrorate; - 0.01% (2)
impossible - 0.01% (2)
using. - 0.01% (2)
start_read; - 0.01% (2)
accdata[3], - 0.01% (2)
0x7f); - 0.01% (2)
gyroscope_sensitivity) - 0.01% (2)
dt; - 0.01% (2)
t.tm_sec - 0.01% (2)
clearing - 0.01% (2)
32768 - 0.01% (2)
(float)accdata[2]) - 0.01% (2)
noted - 0.01% (2)
m_pi; - 0.01% (2)
0.02; - 0.01% (2)
follows - 0.01% (2)
changes, - 0.01% (2)
index - 0.01% (2)
light - 0.01% (2)
0x51 - 0.01% (2)
sample - 0.01% (2)
t.tm_min - 0.01% (2)
never - 0.01% (2)
snippet - 0.01% (2)
_inc_mpu6050_h - 0.01% (2)
mpu6050.h - 0.01% (2)
please - 0.01% (2)
value. - 0.01% (2)
processed - 0.01% (2)
changed - 0.01% (2)
implementation - 0.01% (2)
infinite - 0.01% (2)
t.tm_hour - 0.01% (2)
loop. - 0.01% (2)
iteration - 0.01% (2)
t.tm_year - 0.01% (2)
t.tm_mon - 0.01% (2)
t.tm_mday - 0.01% (2)
0x3f); - 0.01% (2)
g-force - 0.01% (2)
systems. - 0.01% (2)
system. - 0.01% (2)
gyroscope, - 0.01% (2)
08:37 - 0.01% (2)
desoldering - 0.01% (2)
datasheet) - 0.01% (2)
(you - 0.01% (2)
steps: - 0.01% (2)
tightly - 0.01% (2)
strongly - 0.01% (2)
initializing - 0.01% (2)
enabled - 0.01% (2)
correctly - 0.01% (2)
pinout - 0.01% (2)
took - 0.01% (2)
achieve - 0.01% (2)
microcontroller, - 0.01% (2)
behave - 0.01% (2)
becomes - 0.01% (2)
implemented - 0.01% (2)
(rtc) - 0.01% (2)
bad - 0.01% (2)
10); - 0.01% (2)
described - 0.01% (2)
socket - 0.01% (2)
thu, - 0.01% (2)
11:06 - 0.01% (2)
(bcd - 0.01% (2)
solved - 0.01% (2)
bus. - 0.01% (2)
choosing - 0.01% (2)
hand - 0.01% (2)
layout - 0.01% (2)
drawn - 0.01% (2)
figures - 0.01% (2)
read, - 0.01% (2)
slots - 0.01% (2)
sequential - 0.01% (2)
starts - 0.01% (2)
similar - 0.01% (2)
form, - 0.01% (2)
kind - 0.01% (2)
classic - 0.01% (2)
directory - 0.01% (2)
ncurses - 0.01% (2)
08:38 - 0.01% (2)
days, - 0.01% (2)
imu's - 0.01% (2)
library - 0.01% (2)
mobile - 0.01% (2)
and: - 0.01% (2)
quadrocopter. - 0.01% (2)
kalman: - 0.01% (2)
folder - 0.01% (2)
fooled - 0.01% (2)
problems - 0.01% (2)
why - 0.01% (2)
dof - 0.01% (2)
thinking - 0.01% (2)
gyrdata) - 0.01% (2)
visualization - 0.01% (2)
action! - 0.01% (2)
ad+w - 0.01% (2)
strip - 0.01% (2)
definitely - 0.01% (2)
color - 0.01% (2)
1x13 - 0.01% (2)
split - 0.01% (2)
seperate - 0.01% (2)
2x13 - 0.01% (2)
connecting - 0.01% (2)
soon - 0.01% (2)
diy - 0.01% (2)
cable. - 0.01% (2)
shorter - 0.01% (2)
ends, - 0.01% (2)
09:54 - 0.01% (2)
multimeter. - 0.01% (2)
tape. - 0.01% (2)
careful - 0.01% (2)
orientation - 0.01% (2)
master: - 0.01% (2)
term. - 0.01% (2)
accurate - 0.01% (2)
accdata, - 0.01% (2)
quadrocopter), - 0.01% (2)
mpu6050_read(short - 0.01% (2)
reliable - 0.01% (2)
used. - 0.01% (2)
articles - 0.01% (2)
gyroscope. - 0.01% (2)
susceptible - 0.01% (2)
regaddr, - 0.01% (2)
gyro_config - 0.01% (2)
forces. - 0.01% (2)
0x1c - 0.01% (2)
returning - 0.01% (2)
accel_config - 0.01% (2)
position. - 0.01% (2)
mpu6050_addr - 0.01% (2)
mpu6050_setregister(unsigned - 0.01% (2)
vector. - 0.01% (2)
sequence - 0.01% (2)
explained - 0.01% (2)
all, - 0.01% (2)
everything, - 0.01% (2)
36: - 0.01% (2)
(ps) - 0.01% (2)
integrating - 0.01% (2)
regvalue) - 0.01% (2)
time, - 0.01% (2)
accelerometer, - 0.01% (2)
mpu6050_init(void) - 0.01% (2)
determine - 0.01% (2)
gravity - 0.01% (2)
0x08); - 0.01% (2)
accelerometer. - 0.01% (2)
0x00); - 0.01% (2)
mpu6050_setregister(pwr_mgmt_1, - 0.01% (2)
accelerometers - 0.01% (2)
you're - 0.01% (2)
schematic - 0.01% (2)
/s] - 0.01% (2)
velocity. - 0.01% (2)
02:41 - 0.01% (2)
(angle) - 0.01% (2)
data. - 0.01% (2)
principle - 0.01% (2)
input, - 0.01% (2)
(angular - 0.01% (2)
combination - 0.01% (2)
third - 0.01% (2)
say - 0.01% (2)
~(7 - 0.01% (2)
etc.). - 0.01% (2)
chapter - 0.01% (2)
work, - 0.01% (2)
above. - 0.01% (2)
period. - 0.01% (2)
introduce - 0.01% (2)
sorry - 0.01% (2)
cblock - 0.01% (2)
calculated - 0.01% (2)
rising - 0.01% (2)
(((a) - 0.01% (2)
setup. - 0.01% (2)
locations - 0.01% (2)
0xff - 0.01% (2)
(9th - 0.01% (2)
addressing - 0.01% (2)
comment - 0.01% (2)
edge - 0.01% (2)
crystal - 0.01% (2)
(not - 0.01% (2)
form. - 0.01% (2)
avr - 0.01% (2)
(gpfsel - 0.01% (2)
cleaner - 0.01% (2)
mplab - 0.01% (2)
disable - 0.01% (2)
errors. - 0.01% (2)
understand, - 0.01% (2)
pointed - 0.01% (2)
whatever - 0.01% (2)
came - 0.01% (2)
107.42 - 0.01% (2)
out_gpio(x) - 0.01% (2)
inp_gpio(x) - 0.01% (2)
hold - 0.01% (2)
weird - 0.01% (2)
underneath. - 0.01% (2)
soldered - 0.01% (2)
inp_gpio(g) - 0.01% (2)
values. - 0.01% (2)
2.65 - 0.01% (2)
either - 0.01% (2)
;). - 0.01% (2)
converted - 0.01% (2)
allow - 0.01% (2)
[deg. - 0.01% (2)
gave - 0.01% (2)
doesn't - 0.01% (2)
recommended - 0.01% (2)
higher - 0.01% (2)
13) - 0.01% (2)
10ms) - 0.01% (2)
gpio_read(g) - 0.01% (2)
choice - 0.01% (2)
inputs - 0.01% (2)
shocks - 0.01% (2)
vibrations - 0.01% (2)
mostly - 0.01% (2)
out_gpio(g) - 0.01% (2)
ignores - 0.01% (2)
disturbances - 0.01% (2)
intertia - 0.01% (2)
compensated - 0.01% (2)
(((g)/10))) - 0.01% (2)
voltage. - 0.01% (2)
decrease - 0.01% (2)
fsr0l, - 0.01% (2)
above, - 0.01% (2)
based - 0.01% (2)
adding - 0.01% (2)
us! - 0.01% (2)
equals - 0.01% (2)
macros - 0.01% (2)
signals, - 0.01% (2)
assembly, - 0.01% (2)
instructions. - 0.01% (2)
file. - 0.01% (2)
controller). - 0.01% (2)
bsc_c_read - 0.01% (2)
sleep(1); - 0.01% (2)
combo - 0.01% (2)
ofcouse - 0.01% (2)
if(map_peripheral(&gpio) - 0.01% (2)
cycles. - 0.01% (2)
block. - 0.01% (2)
microcontroller. - 0.01% (2)
bsc_c_clear - 0.01% (2)
(white - 0.01% (2)
(it - 0.01% (2)
screw - 0.01% (2)
pic18f2550. - 0.01% (2)
50; - 0.01% (2)
initialize - 0.01% (2)
led's - 0.01% (2)
course, - 0.01% (2)
provides - 0.01% (2)
maybe - 0.01% (2)
i2c_init(); - 0.01% (2)
communication - 0.01% (2)
lazy - 0.01% (2)
pickit - 0.01% (2)
mentioned - 0.01% (2)
earlier. - 0.01% (2)
bsc_s_err - 0.01% (2)
bsc_s_clkt - 0.01% (2)
bsc_c_i2cen|bsc_c_st - 0.01% (2)
1's - 0.01% (2)
consists - 0.01% (2)
register) - 0.01% (2)
signal. - 0.01% (2)
ones - 0.01% (2)
scl - 0.01% (2)
gpio1 - 0.01% (2)
gpio0 - 0.01% (2)
(duh!). - 0.01% (2)
7th - 0.01% (2)
(0) - 0.01% (2)
below, - 0.01% (2)
zeros - 0.01% (2)
see, - 0.01% (2)
sends - 0.01% (2)
easiest - 0.01% (2)
(approx - 0.01% (2)
us) - 0.01% (2)
(bit - 0.01% (2)
(e.g. - 0.01% (2)
further - 0.01% (2)
mistake - 0.01% (2)
joystick - 0.01% (2)
integer - 0.01% (2)
bytes) - 0.01% (2)
nothing - 0.01% (2)
understanding - 0.01% (2)
pressed, - 0.01% (2)
receive - 0.01% (2)
values, - 0.01% (2)
response - 0.01% (2)
int, - 0.01% (2)
tried - 0.01% (2)
file, - 0.01% (2)
loops. - 0.01% (2)
decrement - 0.01% (2)
skips, - 0.01% (2)
beginning - 0.01% (2)
pointer - 0.01% (2)
earlier, - 0.01% (2)
maele - 0.01% (2)
of the - 0.78% (108)
in the - 0.54% (75)
at the - 0.32% (45)
the pi - 0.32% (45)
to the - 0.32% (44)
if you - 0.3% (42)
raspberry pi - 0.3% (41)
on the - 0.29% (40)
this is - 0.28% (39)
with a - 0.27% (37)
you can - 0.22% (30)
nop nop - 0.21% (29)
that the - 0.19% (27)
with the - 0.19% (26)
that i - 0.19% (26)
want to - 0.19% (26)
have to - 0.18% (25)
to use - 0.17% (24)
and the - 0.17% (24)
the pic - 0.17% (23)
use the - 0.17% (23)
need to - 0.17% (23)
for the - 0.17% (23)
we can - 0.16% (22)
the raspberry - 0.16% (22)
from the - 0.14% (20)
i will - 0.14% (20)
t with - 0.14% (19)
can be - 0.14% (19)
will be - 0.13% (18)
the gyro - 0.13% (18)
2012 - - 0.13% (18)
the data - 0.13% (18)
instruction cycle - 0.12% (17)
the code - 0.12% (16)
we will - 0.12% (16)
is the - 0.12% (16)
here are - 0.11% (15)
do this - 0.11% (15)
have a - 0.11% (15)
use of - 0.11% (15)
unsigned char - 0.11% (15)
movwf portb - 0.1% (14)
the angular - 0.1% (14)
we need - 0.1% (14)
64 controller - 0.1% (14)
you have - 0.1% (14)
this in - 0.09% (13)
the pin - 0.09% (13)
submitted by - 0.09% (13)
pieter-jan on - 0.09% (13)
you do - 0.09% (13)
means that - 0.09% (13)
by pieter-jan - 0.09% (13)
post date: - 0.09% (13)
you will - 0.09% (12)
the signal - 0.09% (12)
that it - 0.09% (12)
it will - 0.09% (12)
the picture - 0.09% (12)
to set - 0.09% (12)
instruction cycles - 0.09% (12)
a little - 0.09% (12)
here is - 0.09% (12)
there are - 0.09% (12)
in this - 0.09% (12)
the following - 0.09% (12)
the gyroscope - 0.09% (12)
so that - 0.08% (11)
we have - 0.08% (11)
the accelerometer - 0.08% (11)
you are - 0.08% (11)
we are - 0.08% (11)
is not - 0.08% (11)
raspberry pi. - 0.08% (11)
that a - 0.08% (11)
*(gpio.addr + - 0.08% (11)
can see - 0.08% (11)
the value - 0.08% (11)
which is - 0.07% (10)
because i - 0.07% (10)
n64 controller - 0.07% (10)
as you - 0.07% (10)
look a - 0.07% (10)
the gpio - 0.07% (10)
that we - 0.07% (10)
able to - 0.07% (10)
that you - 0.07% (10)
the register - 0.07% (10)
(see #define) - 0.07% (10)
using a - 0.07% (10)
gyroscope data - 0.07% (10)
angular position - 0.07% (10)
value of - 0.07% (10)
wait until - 0.07% (10)
you don't - 0.07% (10)
has to - 0.06% (9)
way to - 0.06% (9)
the n64 - 0.06% (9)
shown in - 0.06% (9)
movlw 0x00 - 0.06% (9)
the program - 0.06% (9)
------------------------- // - 0.06% (9)
unsigned int - 0.06% (9)
read a - 0.06% (9)
the sensor - 0.06% (9)
it should - 0.06% (9)
of course - 0.06% (9)
is shown - 0.06% (9)
this article - 0.06% (9)
would be - 0.06% (9)
the first - 0.06% (9)
should be - 0.06% (9)
all the - 0.06% (9)
lot of - 0.06% (9)
look at - 0.06% (9)
// -------------------------- - 0.06% (9)
you should - 0.06% (9)
for this - 0.06% (9)
be able - 0.06% (9)
like this - 0.06% (9)
that is - 0.06% (9)
as the - 0.06% (8)
need a - 0.06% (8)
tmr1on = - 0.06% (8)
using the - 0.06% (8)
be very - 0.06% (8)
take a - 0.06% (8)
to take - 0.06% (8)
and then - 0.06% (8)
the bit - 0.06% (8)
because the - 0.06% (8)
is very - 0.06% (8)
how to - 0.06% (8)
33 bit - 0.06% (8)
you want - 0.06% (8)
as possible - 0.06% (8)
struct bcm2835_peripheral - 0.06% (8)
nop movlw - 0.06% (8)
the same - 0.06% (8)
a small - 0.06% (8)
use this - 0.05% (7)
bsc0_c = - 0.05% (7)
a good - 0.05% (7)
of this - 0.05% (7)
contains the - 0.05% (7)
the second - 0.05% (7)
; read - 0.05% (7)
a very - 0.05% (7)
i want - 0.05% (7)
data from - 0.05% (7)
movlw 0x80 - 0.05% (7)
= bcd_to_decimal(bsc0_fifo - 0.05% (7)
// start - 0.05% (7)
pic microcontroller - 0.05% (7)
easy to - 0.05% (7)
from a - 0.05% (7)
} void - 0.05% (7)
complementary filter - 0.05% (7)
0x00 movwf - 0.05% (7)
the bsc0 - 0.05% (7)
when the - 0.05% (7)
polling signal - 0.05% (7)
it with - 0.05% (7)
make sure - 0.05% (7)
to read - 0.05% (7)
interested in - 0.05% (7)
to make - 0.05% (7)
33 bits - 0.05% (7)
this means - 0.05% (7)
i have - 0.05% (7)
number of - 0.05% (7)
the array - 0.05% (7)
sure that - 0.04% (6)
------------------------------------------------------------------ // - 0.04% (6)
for(i; i - 0.04% (6)
// ------------------------------------------------------------------ - 0.04% (6)
the filter - 0.04% (6)
the motor - 0.04% (6)
very easy - 0.04% (6)
"card detect" - 0.04% (6)
bcd_to_decimal(bsc0_fifo & - 0.04% (6)
this can - 0.04% (6)
we use - 0.04% (6)
0; for(i; - 0.04% (6)
the i2c - 0.04% (6)
to write - 0.04% (6)
bsc0_s = - 0.04% (6)
will not - 0.04% (6)
that this - 0.04% (6)
start read - 0.04% (6)
to start - 0.04% (6)
bit of - 0.04% (6)
= bsc0_fifo - 0.04% (6)
like this: - 0.04% (6)
if the - 0.04% (6)
the control - 0.04% (6)
is that - 0.04% (6)
article i - 0.04% (6)
s register - 0.04% (6)
angular velocity - 0.04% (6)
level programming - 0.04% (6)
now we - 0.04% (6)
portb nop - 0.04% (6)
to program - 0.04% (6)
the right - 0.04% (6)
until the - 0.04% (6)
the peripheral - 0.04% (6)
will need - 0.04% (6)
0x80 movwf - 0.04% (6)
output pin - 0.04% (6)
the full - 0.04% (6)
the physical - 0.04% (6)
to see - 0.04% (6)
to generate - 0.04% (6)
2013 - - 0.04% (6)
are using - 0.04% (6)
code i - 0.04% (6)
see that - 0.04% (6)
we want - 0.04% (6)
be found - 0.04% (6)
if this - 0.04% (6)
read the - 0.04% (5)
#define) wait_i2c_done(); - 0.04% (5)
are the - 0.04% (5)
the complementary - 0.04% (5)
of your - 0.04% (5)
// reset - 0.04% (5)
nop decfsz - 0.04% (5)
the virtual - 0.04% (5)
bsc0_dlen = - 0.04% (5)
hard to - 0.04% (5)
portb movlw - 0.04% (5)
= clear_status; - 0.04% (5)
they will - 0.04% (5)
can find - 0.04% (5)
= 0b00000000; - 0.04% (5)
programming of - 0.04% (5)
low level - 0.04% (5)
that need - 0.04% (5)
work with - 0.04% (5)
step i - 0.04% (5)
clear_status; // - 0.04% (5)
reset status - 0.04% (5)
bits (see - 0.04% (5)
when it - 0.04% (5)
to understand - 0.04% (5)
there is - 0.04% (5)
*(bsc0.addr + - 0.04% (5)
accelerometer data - 0.04% (5)
status bits - 0.04% (5)
used to - 0.04% (5)
we know - 0.04% (5)
fifo = - 0.04% (5)
over time - 0.04% (5)
but it - 0.04% (5)
are in - 0.04% (5)
to build - 0.04% (5)
as this - 0.04% (5)
store the - 0.04% (5)
bit is - 0.04% (5)
note that - 0.04% (5)
have any - 0.04% (5)
decfsz d1 - 0.04% (5)
our raspberry - 0.04% (5)
and store - 0.04% (5)
part of - 0.04% (5)
as well. - 0.04% (5)
up the - 0.04% (5)
write the - 0.04% (5)
output a - 0.04% (5)
check the - 0.04% (5)
is one - 0.04% (5)
it was - 0.04% (5)
the previous - 0.04% (5)
the supply - 0.04% (5)
set to - 0.04% (5)
the reason - 0.04% (5)
picture below. - 0.04% (5)
the adc - 0.04% (5)
movwf d1 - 0.04% (5)
the instruction - 0.04% (5)
#define) bsc0_c - 0.04% (5)
the polling - 0.04% (5)
sd card - 0.04% (5)
by the - 0.04% (5)
tmr1if = - 0.04% (5)
alternate function - 0.04% (5)
time to - 0.04% (5)
does not - 0.04% (5)
not be - 0.04% (5)
around the - 0.04% (5)
the above - 0.04% (5)
how the - 0.04% (5)
the slot - 0.04% (5)
will use - 0.04% (5)
to know - 0.04% (5)
shows the - 0.04% (5)
pin "g" - 0.04% (5)
code block - 0.04% (5)
to obtain - 0.04% (5)
don't need - 0.04% (5)
my raspberry - 0.04% (5)
supply voltage - 0.04% (5)
value is - 0.04% (5)
be sent - 0.04% (5)
is given - 0.04% (5)
you might - 0.04% (5)
will have - 0.04% (5)
try to - 0.04% (5)
out the - 0.04% (5)
return -1; - 0.04% (5)
make the - 0.04% (5)
the controller - 0.04% (5)
because of - 0.04% (5)
it would - 0.03% (4)
connected to - 0.03% (4)
apt-get install - 0.03% (4)
the internet - 0.03% (4)
the sd - 0.03% (4)
; wait - 0.03% (4)
nintendo 64 - 0.03% (4)
back to - 0.03% (4)
on mon, - 0.03% (4)
controller is - 0.03% (4)
to port - 0.03% (4)
goto zero - 0.03% (4)
the sampling - 0.03% (4)
your raspberry - 0.03% (4)
see if - 0.03% (4)
short * - 0.03% (4)
start write - 0.03% (4)
is connected - 0.03% (4)
below. the - 0.03% (4)
0x20 ; - 0.03% (4)
movlw 0x02 - 0.03% (4)
"write protect" - 0.03% (4)
i made - 0.03% (4)
fsr0l ; - 0.03% (4)
this, i - 0.03% (4)
be turned - 0.03% (4)
monitor & - 0.03% (4)
with it - 0.03% (4)
because we - 0.03% (4)
all 33 - 0.03% (4)
that are - 0.03% (4)
flat cable - 0.03% (4)
the pictures - 0.03% (4)
which means - 0.03% (4)
the balloon - 0.03% (4)
easier to - 0.03% (4)
the syringe - 0.03% (4)
sent movwf - 0.03% (4)
void main(void) - 0.03% (4)
; number - 0.03% (4)
the object - 0.03% (4)
trisb, 7 - 0.03% (4)
position of - 0.03% (4)
be used - 0.03% (4)
take the - 0.03% (4)
of all - 0.03% (4)
obtain the - 0.03% (4)
oscillator cycles - 0.03% (4)
one instruction - 0.03% (4)
decided to - 0.03% (4)
forces that - 0.03% (4)
hobbyking hk401b - 0.03% (4)
data is - 0.03% (4)
make use - 0.03% (4)
after the - 0.03% (4)
with an - 0.03% (4)
to implement - 0.03% (4)
movlw 0x20 - 0.03% (4)
data, we - 0.03% (4)
to this - 0.03% (4)
the arduino - 0.03% (4)
signal is - 0.03% (4)
the angle - 0.03% (4)
programming from - 0.03% (4)
the wires - 0.03% (4)
can easily - 0.03% (4)
the result - 0.03% (4)
5 instruction - 0.03% (4)
results in - 0.03% (4)
= 0b00000001; - 0.03% (4)
tags: raspberry - 0.03% (4)
to you - 0.03% (4)
track of - 0.03% (4)
is set - 0.03% (4)
external forces - 0.03% (4)
goto one - 0.03% (4)
generate the - 0.03% (4)
you indicate - 0.03% (4)
void adc(void) - 0.03% (4)
0b00000001; // - 0.03% (4)
can do - 0.03% (4)
little bit - 0.03% (4)
which are - 0.03% (4)
#include "rpi.h" - 0.03% (4)
the registers - 0.03% (4)
memory of - 0.03% (4)
write a - 0.03% (4)
*/ void - 0.03% (4)
printf("failed to - 0.03% (4)
can set - 0.03% (4)
see datasheet - 0.03% (4)
tmr1 = - 0.03% (4)
than the - 0.03% (4)
raspberry pi, - 0.03% (4)
you need - 0.03% (4)
the memory - 0.03% (4)
raspberry pi's - 0.03% (4)
over the - 0.03% (4)
are not - 0.03% (4)
reason i - 0.03% (4)
to wait - 0.03% (4)
bits which - 0.03% (4)
this way - 0.03% (4)
to find - 0.03% (4)
add the - 0.03% (4)
the gpfsel - 0.03% (4)
the pcf8563 - 0.03% (4)
set pin - 0.03% (4)
the rtc - 0.03% (4)
the status - 0.03% (4)
bits are - 0.03% (4)
1. this - 0.03% (4)
is done - 0.03% (4)
and it - 0.03% (4)
into the - 0.03% (4)
bsc0_fifo = - 0.03% (4)
+ ((g)/10)) - 0.03% (4)
// init - 0.03% (4)
pi. it - 0.03% (4)
like i - 0.03% (4)
0 #define - 0.03% (4)
i++) { - 0.03% (4)
date: monday, - 0.03% (4)
map the - 0.03% (4)
this we - 0.03% (4)
{ printf("failed - 0.03% (4)
program the - 0.03% (4)
to map - 0.03% (4)
timer 1 - 0.03% (4)
the timer - 0.03% (4)
be done - 0.03% (4)
one pin - 0.03% (4)
then you - 0.03% (4)
pin we - 0.03% (4)
a look - 0.03% (4)
the bcm2835 - 0.03% (4)
this with - 0.03% (4)
the macro - 0.03% (4)
on that - 0.02% (3)
i hope - 0.02% (3)
version of - 0.02% (3)
"g" as - 0.02% (3)
it's a - 0.02% (3)
controller. the - 0.02% (3)
zero one - 0.02% (3)
result of - 0.02% (3)
*gpio.addr + - 0.02% (3)
don't be - 0.02% (3)
instead of - 0.02% (3)
that work - 0.02% (3)
explain how - 0.02% (3)
will take - 0.02% (3)
a quick - 0.02% (3)
tags: quadrocopter - 0.02% (3)
signal shapes - 0.02% (3)
= start_write; - 0.02% (3)
created by - 0.02% (3)
register to - 0.02% (3)
of people - 0.02% (3)
// turn - 0.02% (3)
// wait - 0.02% (3)
not so - 0.02% (3)
by using - 0.02% (3)
adc value - 0.02% (3)
to check - 0.02% (3)
and line - 0.02% (3)
because this - 0.02% (3)
simple program - 0.02% (3)
that was - 0.02% (3)
is only - 0.02% (3)
and on - 0.02% (3)
the current - 0.02% (3)
we don't - 0.02% (3)
could be - 0.02% (3)
value that - 0.02% (3)
the one - 0.02% (3)
will describe - 0.02% (3)
a video - 0.02% (3)
to enable - 0.02% (3)
the circuit - 0.02% (3)
the gpsel - 0.02% (3)
them to - 0.02% (3)
write (see - 0.02% (3)
this will - 0.02% (3)
-------------------------- ms - 0.02% (3)
i added - 0.02% (3)
the most - 0.02% (3)
the figure - 0.02% (3)
the new - 0.02% (3)
the other - 0.02% (3)
connect to - 0.02% (3)
see something - 0.02% (3)
} tmr1 - 0.02% (3)
i found - 0.02% (3)
i chose - 0.02% (3)
i<4; i++) - 0.02% (3)
short circuit - 0.02% (3)
figure out - 0.02% (3)
(unsigned int - 0.02% (3)
readloop ; - 0.02% (3)
not the - 0.02% (3)
approximation will - 0.02% (3)
writing to - 0.02% (3)
next adres - 0.02% (3)
the motors - 0.02% (3)
portb, 7 - 0.02% (3)
and can - 0.02% (3)
an analog - 0.02% (3)
is also - 0.02% (3)
will also - 0.02% (3)
that there - 0.02% (3)
so don't - 0.02% (3)
the axis - 0.02% (3)
header file - 0.02% (3)
controller with - 0.02% (3)
know if - 0.02% (3)
the offset - 0.02% (3)
arduino program - 0.02% (3)
know that - 0.02% (3)
find the - 0.02% (3)
bcm2835_peripheral gpio - 0.02% (3)
universal/jamming gripper - 0.02% (3)
one axis - 0.02% (3)
succeeded in - 0.02% (3)
one of - 0.02% (3)
video of - 0.02% (3)
d1 goto - 0.02% (3)
movwf d2 - 0.02% (3)
was not - 0.02% (3)
one movlw - 0.02% (3)
decfsz d2 - 0.02% (3)
arm peripherals - 0.02% (3)
through the - 0.02% (3)
code in - 0.02% (3)
read b - 0.02% (3)
iorwf latb, - 0.02% (3)
indf0, 0 - 0.02% (3)
from array - 0.02% (3)
this tutorial - 0.02% (3)
will make - 0.02% (3)
movwf fsr0l - 0.02% (3)
it skips - 0.02% (3)
& store - 0.02% (3)
pin rb7 - 0.02% (3)
/* function - 0.02% (3)
below. it - 0.02% (3)
was to - 0.02% (3)
two instruction - 0.02% (3)
the next - 0.02% (3)
used the - 0.02% (3)
looks like - 0.02% (3)
// create - 0.02% (3)
code to - 0.02% (3)
stop bit - 0.02% (3)
we saw - 0.02% (3)
controller data - 0.02% (3)
do some - 0.02% (3)
step 2 - 0.02% (3)
the macro's - 0.02% (3)
will explain - 0.02% (3)
course this - 0.02% (3)
instruction of - 0.02% (3)
custom roi - 0.02% (3)
the instructions - 0.02% (3)
the two - 0.02% (3)
them a - 0.02% (3)
and not - 0.02% (3)
d2 goto - 0.02% (3)
with 8 - 0.02% (3)
manual at - 0.02% (3)
see the - 0.02% (3)
generated with - 0.02% (3)
by setting - 0.02% (3)
bus address - 0.02% (3)
physical address - 0.02% (3)
use in - 0.02% (3)
date: friday, - 0.02% (3)
c file - 0.02% (3)
and add - 0.02% (3)
i recommend - 0.02% (3)
as much - 0.02% (3)
the drift - 0.02% (3)
define a - 0.02% (3)
struct of - 0.02% (3)
gyrovalue = - 0.02% (3)
the type - 0.02% (3)
copy paste - 0.02% (3)
as possible. - 0.02% (3)
it with: - 0.02% (3)
the hobbyking - 0.02% (3)
it like - 0.02% (3)
are working - 0.02% (3)
used in - 0.02% (3)
* (65536 - 0.02% (3)
for my - 0.02% (3)
working on - 0.02% (3)
to get - 0.02% (3)
previous article. - 0.02% (3)
output pins - 0.02% (3)
// i2c - 0.02% (3)
below. a - 0.02% (3)
useful for - 0.02% (3)
4) #define - 0.02% (3)
time clock - 0.02% (3)
only on - 0.02% (3)
the long - 0.02% (3)
the problem - 0.02% (3)
is too - 0.02% (3)
#include - 0.02% (3)
duty cycle - 0.02% (3)
corresponds to - 0.02% (3)
found in - 0.02% (3)
3; i++) - 0.02% (3)
the speed - 0.02% (3)
on fri, - 0.02% (3)
a quadrocopter - 0.02% (3)
the header - 0.02% (3)
the mpu6050 - 0.02% (3)
+= bsc0_fifo; - 0.02% (3)
a previous - 0.02% (3)
bsc0_fifo << - 0.02% (3)
bits in - 0.02% (3)
very useful - 0.02% (3)
the position - 0.02% (3)
register that - 0.02% (3)
(65536 - - 0.02% (3)
// set - 0.02% (3)
they have - 0.02% (3)
is what - 0.02% (3)
first step - 0.02% (3)
prescaler * - 0.02% (3)
some pictures - 0.02% (3)
1/oscvalue * - 0.02% (3)
real time - 0.02% (3)
using an - 0.02% (3)
= 1/oscvalue - 0.02% (3)
* prescaler - 0.02% (3)
start_write; // - 0.02% (3)
tmp += - 0.02% (3)
independent pwm - 0.02% (3)
on. the - 0.02% (3)
while(1) { - 0.02% (3)
low to - 0.02% (3)
0b00000000; // - 0.02% (3)
the measurement - 0.02% (3)
faster than - 0.02% (3)
might be - 0.02% (3)
this sensor - 0.02% (3)
set all - 0.02% (3)
step is - 0.02% (3)
sure the - 0.02% (3)
however the - 0.02% (3)
up properly - 0.02% (3)
keep track - 0.02% (3)
c program - 0.02% (3)
== -1) - 0.02% (3)
registers into - 0.02% (3)
the cable - 0.02% (3)
memory space.\n"); - 0.02% (3)
is because - 0.02% (3)
is important - 0.02% (3)
to your - 0.02% (3)
sure you - 0.02% (3)
create a - 0.02% (3)
with one - 0.02% (3)
interrupt enable - 0.02% (3)
than motor - 0.02% (3)
i make - 0.02% (3)
to our - 0.02% (3)
be driven - 0.02% (3)
a nice - 0.02% (3)
the system - 0.02% (3)
space.\n"); return - 0.02% (3)
is part - 0.02% (3)
(sudo apt-get - 0.02% (3)
it might - 0.02% (3)
you know - 0.02% (3)
time = - 0.02% (3)
virtual memory - 0.02% (3)
the short - 0.02% (3)
we decided - 0.02% (3)
would make - 0.02% (3)
about this - 0.02% (3)
for both - 0.02% (3)
function prototypes - 0.02% (3)
pin to - 0.02% (3)
of these - 0.02% (3)
because it - 0.02% (3)
motor 1 - 0.02% (3)
enough to - 0.01% (2)
#include - 0.01% (2)
the sensitivity - 0.01% (2)
the pwm - 0.01% (2)
driven with - 0.01% (2)
apply to - 0.01% (2)
digital value - 0.01% (2)
bits of - 0.01% (2)
most significant - 0.01% (2)
reading a - 0.01% (2)
- 09:54 - 0.01% (2)
breakout cable - 0.01% (2)
because they - 0.01% (2)
one that - 0.01% (2)
= 136; - 0.01% (2)
float angle - 0.01% (2)
float gyrorate; - 0.01% (2)
van de - 0.01% (2)
calculate the - 0.01% (2)
& mclre_off - 0.01% (2)
8 most - 0.01% (2)
possible to - 0.01% (2)
we can't - 0.01% (2)
& cp_off); - 0.01% (2)
#define _xtal_freq - 0.01% (2)
gyrorate = - 0.01% (2)
(gyrovalue - - 0.01% (2)
offset) * - 0.01% (2)
& pwrte_off - 0.01% (2)
integral approximation - 0.01% (2)
contain a - 0.01% (2)
approximated integral - 0.01% (2)
motor and - 0.01% (2)
what the - 0.01% (2)
monday, may - 0.01% (2)
to work - 0.01% (2)
an 8-bit - 0.01% (2)
& wdte_off - 0.01% (2)
saw earlier - 0.01% (2)
c post - 0.01% (2)
into an - 0.01% (2)
program. the - 0.01% (2)
we read - 0.01% (2)
the sensor, - 0.01% (2)
and convert - 0.01% (2)
using another - 0.01% (2)
analog sensor, - 0.01% (2)
voltage that - 0.01% (2)
compiler. #include - 0.01% (2)
when using - 0.01% (2)
extremely useful - 0.01% (2)
thing about - 0.01% (2)
is usually - 0.01% (2)
integrate the - 0.01% (2)
angular velocity. - 0.01% (2)
- 13:49 - 0.01% (2)
the sum - 0.01% (2)
we get - 0.01% (2)
sampling period. - 0.01% (2)
the integral - 0.01% (2)
3, 2012 - 0.01% (2)
visual feedback - 0.01% (2)
is called - 0.01% (2)
monday, september - 0.01% (2)
not returning - 0.01% (2)
over time. - 0.01% (2)
finding a - 0.01% (2)
for mechanical - 0.01% (2)
september 3, - 0.01% (2)
of which - 0.01% (2)
date: saturday, - 0.01% (2)
millisecond has - 0.01% (2)
any other - 0.01% (2)
device. i - 0.01% (2)
hk401b gyroscope - 0.01% (2)
the adcvalues - 0.01% (2)
ms wait - 0.01% (2)
the rate - 0.01% (2)
values are - 0.01% (2)
above, i - 0.01% (2)
until first - 0.01% (2)
ms have - 0.01% (2)
go faster - 0.01% (2)
gives us - 0.01% (2)
had to - 0.01% (2)
for one - 0.01% (2)
makes it - 0.01% (2)
imu without - 0.01% (2)
c lite - 0.01% (2)
is close - 0.01% (2)
velocity will - 0.01% (2)
and just - 0.01% (2)
up with - 0.01% (2)
four motors - 0.01% (2)
value for - 0.01% (2)
generate a - 0.01% (2)
now. if - 0.01% (2)
/ 100.0; - 0.01% (2)
replacing the - 0.01% (2)
the hk401b - 0.01% (2)
- 08:38 - 0.01% (2)
friday, april - 0.01% (2)
connect it - 0.01% (2)
and red - 0.01% (2)
kalman: the - 0.01% (2)
date: thursday, - 0.01% (2)
the hi-tech - 0.01% (2)
4 potentiometers - 0.01% (2)
from gyroscope - 0.01% (2)
that control - 0.01% (2)
from mac - 0.01% (2)
frequency of - 0.01% (2)
work directly - 0.01% (2)
sensor, and - 0.01% (2)
problem of - 0.01% (2)
for programming - 0.01% (2)
getting the - 0.01% (2)
put in - 0.01% (2)
that they - 0.01% (2)
be compensated - 0.01% (2)
- 08:37 - 0.01% (2)
very small - 0.01% (2)
output an - 0.01% (2)
pic microcontroller. - 0.01% (2)
that have - 0.01% (2)
+= gyrorate - 0.01% (2)
the hole - 0.01% (2)
port this - 0.01% (2)
0; tmr1if - 0.01% (2)
by default - 0.01% (2)
though. if - 0.01% (2)
our pi - 0.01% (2)
- 10:12 - 0.01% (2)
the internet. - 0.01% (2)
in there - 0.01% (2)
gyroscope module - 0.01% (2)
the ip - 0.01% (2)
things a - 0.01% (2)
hacking the - 0.01% (2)
it's just - 0.01% (2)
while(!tmr1if); tmr1on - 0.01% (2)
the finger - 0.01% (2)
your mac - 0.01% (2)
know everything - 0.01% (2)
and everything - 0.01% (2)
with prescaler - 0.01% (2)
might want - 0.01% (2)
= portcvalue; - 0.01% (2)
off) i - 0.01% (2)
that has - 0.01% (2)
putting the - 0.01% (2)
them off - 0.01% (2)
portcvalue = - 0.01% (2)
pictures above - 0.01% (2)
state of - 0.01% (2)
the easiest - 0.01% (2)
// the - 0.01% (2)
this would - 0.01% (2)
of ram - 0.01% (2)
error is - 0.01% (2)
- read - 0.01% (2)
1; while(!tmr1if) - 0.01% (2)
start timer - 0.01% (2)
start up - 0.01% (2)
it doesn't - 0.01% (2)
part is - 0.01% (2)
any gui - 0.01% (2)
1:1 and - 0.01% (2)
first output - 0.01% (2)
recommend using - 0.01% (2)
for(i; i<4; - 0.01% (2)
plastic syringe - 0.01% (2)
the values - 0.01% (2)
of output - 0.01% (2)
like a - 0.01% (2)
step 4 - 0.01% (2)
duct tape - 0.01% (2)
help = - 0.01% (2)
piece of - 0.01% (2)
- 12:25 - 0.01% (2)
the coffee - 0.01% (2)
few times - 0.01% (2)
it you - 0.01% (2)
adcvalues[i] = - 0.01% (2)
fill the - 0.01% (2)
mux adres - 0.01% (2)
go through - 0.01% (2)
step 3 - 0.01% (2)
my own - 0.01% (2)
mon, 03/09/2012 - 0.01% (2)
is binary - 0.01% (2)
in which - 0.01% (2)
off the - 0.01% (2)
freq 20mhz - 0.01% (2)
the software - 0.01% (2)
first time - 0.01% (2)
finger would - 0.01% (2)
this, and - 0.01% (2)
= 65535 - 0.01% (2)
the universal - 0.01% (2)
the command - 0.01% (2)
much as - 0.01% (2)
with vim, - 0.01% (2)
an idea - 0.01% (2)
65535 - - 0.01% (2)
to install - 0.01% (2)
you write - 0.01% (2)
tightly as - 0.01% (2)
check out - 0.01% (2)
gripper prototype - 0.01% (2)
wires. the - 0.01% (2)
article was - 0.01% (2)
solar tracker - 0.01% (2)
program */ - 0.01% (2)
void main(void); - 0.01% (2)
static int - 0.01% (2)
/* main - 0.01% (2)
roll = - 0.01% (2)
cvcreatemat(480, 640, - 0.01% (2)
main program - 0.01% (2)
the roi - 0.01% (2)
interest) with - 0.01% (2)
prototypes */ - 0.01% (2)
init trisa - 0.01% (2)
main(void) { - 0.01% (2)
to control - 0.01% (2)
(region of - 0.01% (2)
// ra0 - 0.01% (2)
input (analog) - 0.01% (2)
adcon0 = - 0.01% (2)
an image - 0.01% (2)
the original - 0.01% (2)
brushless dc - 0.01% (2)
the points - 0.01% (2)
__config(fosc_hs & - 0.01% (2)
but this - 0.01% (2)
- 08:33 - 0.01% (2)
hi-tech c - 0.01% (2)
lite compiler. - 0.01% (2)
#include - 0.01% (2)
motor with - 0.01% (2)
#include - 0.01% (2)
20000000 /* - 0.01% (2)
_xtal_freq 20000000 - 0.01% (2)
wdte_off & - 0.01% (2)
bachelor assignment - 0.01% (2)
computer vision - 0.01% (2)
pwrte_off & - 0.01% (2)
adc(void); void - 0.01% (2)
mclre_off & - 0.01% (2)
motor is - 0.01% (2)
cp_off); #define - 0.01% (2)
adcon1 = - 0.01% (2)
{ go_done - 0.01% (2)
the programming - 0.01% (2)
an external - 0.01% (2)
03/09/2012 - - 0.01% (2)
i took - 0.01% (2)
pwm-signals generated - 0.01% (2)
(4) independent - 0.01% (2)
necessary to - 0.01% (2)
following video - 0.01% (2)
my macbook - 0.01% (2)
is mostly - 0.01% (2)
self-respecting engineer - 0.01% (2)
for interest - 0.01% (2)
to achieve - 0.01% (2)
made use - 0.01% (2)
- 10:23 - 0.01% (2)
to share - 0.01% (2)
use any - 0.01% (2)
keypoint test - 0.01% (2)
do the - 0.01% (2)
mac os - 0.01% (2)
his or - 0.01% (2)
while(go_done); } - 0.01% (2)
ra0 input - 0.01% (2)
program in - 0.01% (2)
software i - 0.01% (2)
<get the - 0.01% (2)
(); ++i) - 0.01% (2)
to show - 0.01% (2)
trisa = - 0.01% (2)
()); for - 0.01% (2)
points */ - 0.01% (2)
pi for - 0.01% (2)
the case - 0.01% (2)
cout << - 0.01% (2)
= 0.2f; - 0.01% (2)
directly on - 0.01% (2)
complementary filter. - 0.01% (2)
/* extract - 0.01% (2)
setting up - 0.01% (2)
seems like - 0.01% (2)
void adc(void); - 0.01% (2)
this: the - 0.01% (2)
finding the - 0.01% (2)
physical gpio - 0.01% (2)
register address - 0.01% (2)
rtc we - 0.01% (2)
start reading - 0.01% (2)
the bus. - 0.01% (2)
in our - 0.01% (2)
start sending - 0.01% (2)
functions to - 0.01% (2)
*/ unsigned - 0.01% (2)
{ return - 0.01% (2)
(bcd & - 0.01% (2)
if(map_peripheral(&gpio) == - 0.01% (2)
operation to - 0.01% (2)
writing the - 0.01% (2)
one byte - 0.01% (2)
start_read; // - 0.01% (2)
after clearing - 0.01% (2)
fifo (see - 0.01% (2)
& 0x7f); - 0.01% (2)
& 0x3f); - 0.01% (2)
reading the - 0.01% (2)
mpu6050 imu - 0.01% (2)
the source - 0.01% (2)
hope that - 0.01% (2)
you understand - 0.01% (2)
"rpi.h" #include - 0.01% (2)
automatically for - 0.01% (2)
reading data - 0.01% (2)
* accdata, - 0.01% (2)
and gpio1 - 0.01% (2)
3) #define - 0.01% (2)
1) #define - 0.01% (2)
i2c function - 0.01% (2)
action to - 0.01% (2)
void i2c_init() - 0.01% (2)
void wait_i2c_done() - 0.01% (2)
timeout = - 0.01% (2)
to behave - 0.01% (2)
and one - 0.01% (2)
behave as - 0.01% (2)
we see - 0.01% (2)
for this. - 0.01% (2)
clock (rtc) - 0.01% (2)
these pins - 0.01% (2)
to alternate - 0.01% (2)
we set - 0.01% (2)
alternate functionality - 0.01% (2)
to send - 0.01% (2)
or write - 0.01% (2)
slave address - 0.01% (2)
the bsc0_a - 0.01% (2)
bytes you - 0.01% (2)
first in - 0.01% (2)
write or - 0.01% (2)
by writing - 0.01% (2)
void mpu6050_read(short - 0.01% (2)
mpu6050_setregister(unsigned char - 0.01% (2)
7) #define - 0.01% (2)
they are - 0.01% (2)
don't have - 0.01% (2)
half of - 0.01% (2)
figure below. - 0.01% (2)
parts of - 0.01% (2)
be useful - 0.01% (2)
should look - 0.01% (2)
a multimeter. - 0.01% (2)
i decided - 0.01% (2)
not to - 0.01% (2)
pi reading - 0.01% (2)
without kalman: - 0.01% (2)
best way - 0.01% (2)
have the - 0.01% (2)
and gyroscope - 0.01% (2)
fooled into - 0.01% (2)
kalman filter - 0.01% (2)
problems with - 0.01% (2)
make it - 0.01% (2)
to understand, - 0.01% (2)
this by - 0.01% (2)
over time, - 0.01% (2)
are going - 0.01% (2)
gravity vector - 0.01% (2)
visible on - 0.01% (2)
the accelerometer. - 0.01% (2)
cut the - 0.01% (2)
it's also - 0.01% (2)
regaddr, unsigned - 0.01% (2)
i++) // - 0.01% (2)
void mpu6050_init(void) - 0.01% (2)
void mpu6050_setregister(unsigned - 0.01% (2)
char regaddr, - 0.01% (2)
// see - 0.01% (2)
datasheet (ps) - 0.01% (2)
// master: - 0.01% (2)
s ad+w - 0.01% (2)
slave : - 0.01% (2)
ack ack - 0.01% (2)
= (unsigned - 0.01% (2)
// slave - 0.01% (2)
8; tmp - 0.01% (2)
electrical tape - 0.01% (2)
tmp; } - 0.01% (2)
= tmp; - 0.01% (2)
github repository - 0.01% (2)
all this - 0.01% (2)
where you - 0.01% (2)
put the - 0.01% (2)
now the - 0.01% (2)
build the - 0.01% (2)
diy raspberry - 0.01% (2)
pi breakout - 0.01% (2)
connecting the - 0.01% (2)
doing some - 0.01% (2)
5) #define - 0.01% (2)
9) #define - 0.01% (2)
problem with - 0.01% (2)
map_peripheral(struct bcm2835_peripheral - 0.01% (2)
page 90 - 0.01% (2)
virtual address - 0.01% (2)
for every - 0.01% (2)
peripheral we - 0.01% (2)
about the - 0.01% (2)
location of - 0.01% (2)
then we - 0.01% (2)
how this - 0.01% (2)
can use - 0.01% (2)
gpio = - 0.01% (2)
defined in - 0.01% (2)
p->map = - 0.01% (2)
be defined - 0.01% (2)
bcm2835_peripheral *p) - 0.01% (2)
access the - 0.01% (2)
will start - 0.01% (2)
it. we - 0.01% (2)
our header - 0.01% (2)
this. i - 0.01% (2)
// gpio - 0.01% (2)
always use - 0.01% (2)
inp_gpio(x) before - 0.01% (2)
using out_gpio(x) - 0.01% (2)
#define inp_gpio(g) - 0.01% (2)
((g)/10)) &= - 0.01% (2)
offset to - 0.01% (2)
that will - 0.01% (2)
#define set_gpio_alt(g,a) - 0.01% (2)
gain access - 0.01% (2)
- 05:10 - 0.01% (2)
i first - 0.01% (2)
do with - 0.01% (2)
it seemed - 0.01% (2)
for embedded - 0.01% (2)
with low - 0.01% (2)
everything is - 0.01% (2)
done by - 0.01% (2)
for example, - 0.01% (2)
"1" to - 0.01% (2)
that means - 0.01% (2)
first. this - 0.01% (2)
are these - 0.01% (2)
#include - 0.01% (2)
(bcm2708_peri_base + - 0.01% (2)
{ unsigned - 0.01% (2)
volatile unsigned - 0.01% (2)
= {gpio_base}; - 0.01% (2)
extern struct - 0.01% (2)
can't be - 0.01% (2)
we look - 0.01% (2)
broadcom bcm2835 - 0.01% (2)
for peripherals - 0.01% (2)
are set - 0.01% (2)
the adress - 0.01% (2)
out_gpio(g) *(gpio.addr - 0.01% (2)
(((g)/10))) |= - 0.01% (2)
8) #define - 0.01% (2)
this register - 0.01% (2)
on page - 0.01% (2)
to function - 0.01% (2)
the part - 0.01% (2)
gpio0 and - 0.01% (2)
use with - 0.01% (2)
the datasheet, - 0.01% (2)
is 32-bit - 0.01% (2)
when you - 0.01% (2)
working with - 0.01% (2)
the address - 0.01% (2)
gpio 4 - 0.01% (2)
risk of - 0.01% (2)
the only - 0.01% (2)
#define gpio_read(g) - 0.01% (2)
13) &= - 0.01% (2)
register and - 0.01% (2)
of that - 0.01% (2)
functionality of - 0.01% (2)
the correct - 0.01% (2)
int main( - 0.01% (2)
gpio registers - 0.01% (2)
return 0; - 0.01% (2)
information about - 0.01% (2)
first we - 0.01% (2)
macro's to - 0.01% (2)
it are - 0.01% (2)
see in - 0.01% (2)
gpio_set *(gpio.addr - 0.01% (2)
contain the - 0.01% (2)
ignores bits - 0.01% (2)
gpio_read(g) *(gpio.addr - 0.01% (2)
at first - 0.01% (2)
code, this - 0.01% (2)
will go - 0.01% (2)
register contains - 0.01% (2)
bits for - 0.01% (2)
10 pins. - 0.01% (2)
gpfsel bits - 0.01% (2)
other pins - 0.01% (2)
not interested - 0.01% (2)
register is - 0.01% (2)
those bits - 0.01% (2)
given by - 0.01% (2)
between the - 0.01% (2)
gpsel register - 0.01% (2)
taking the - 0.01% (2)
an input. - 0.01% (2)
the function - 0.01% (2)
the bits - 0.01% (2)
three bits - 0.01% (2)
x (gpfsel - 0.01% (2)
setup bits - 0.01% (2)
or operation - 0.01% (2)
the comment - 0.01% (2)
makes the - 0.01% (2)
lot more - 0.01% (2)
- 02:41 - 0.01% (2)
d1 oneloop - 0.01% (2)
0x02 ; - 0.01% (2)
ones that - 0.01% (2)
movwf d3 - 0.01% (2)
zero movlw - 0.01% (2)
0x03 movwf - 0.01% (2)
d1 zeroloop - 0.01% (2)
decfsz d1, - 0.01% (2)
f goto - 0.01% (2)
zeroloop nop - 0.01% (2)
portb decfsz - 0.01% (2)
0x02 movwf - 0.01% (2)
goto oneloop - 0.01% (2)
of zeros - 0.01% (2)
decfsz d3 - 0.01% (2)
the trisb - 0.01% (2)
picture of - 0.01% (2)
a close - 0.01% (2)
can see, - 0.01% (2)
is extremely - 0.01% (2)
connect the - 0.01% (2)
below. in - 0.01% (2)
b button - 0.01% (2)
so you - 0.01% (2)
second bit - 0.01% (2)
response is - 0.01% (2)
d2 movlw - 0.01% (2)
movlw 0x07 - 0.01% (2)
the nintendo - 0.01% (2)
instruction if - 0.01% (2)
consists of - 0.01% (2)
bit (4 - 0.01% (2)
is built - 0.01% (2)
z button - 0.01% (2)
is pressed, - 0.01% (2)
will read - 0.01% (2)
this signal - 0.01% (2)
the response - 0.01% (2)
7 zero - 0.01% (2)
file, skip - 0.01% (2)
this instruction - 0.01% (2)
it skips, - 0.01% (2)
; 0b000000011 - 0.01% (2)
the beginning - 0.01% (2)
clear to - 0.01% (2)
see how - 0.01% (2)
a combo - 0.01% (2)
instructions use - 0.01% (2)
instruction cycles. - 0.01% (2)
takes two - 0.01% (2)
mentioned earlier. - 0.01% (2)
there would - 0.01% (2)
we would - 0.01% (2)
; make - 0.01% (2)
rb7 output - 0.01% (2)
once you - 0.01% (2)
it sends - 0.01% (2)
how many - 0.01% (2)
full assembly - 0.01% (2)
array nop - 0.01% (2)
decfsz d4 - 0.01% (2)
loop if - 0.01% (2)
read goto - 0.01% (2)
indirect addressing - 0.01% (2)
for sure - 0.01% (2)
are at - 0.01% (2)
tried to - 0.01% (2)
do this, - 0.01% (2)
(4 oscillator - 0.01% (2)
let me - 0.01% (2)
you look - 0.01% (2)
wait & - 0.01% (2)
won't go - 0.01% (2)
into detail - 0.01% (2)
bcf trisb, - 0.01% (2)
make rb7 - 0.01% (2)
poll ; - 0.01% (2)
send the - 0.01% (2)
last instruction - 0.01% (2)
portb incf - 0.01% (2)
goto zeroloop - 0.01% (2)
oneloop ; - 0.01% (2)
some more - 0.01% (2)
position from - 0.01% (2)
array incf - 0.01% (2)
indf0 ; - 0.01% (2)
this data - 0.01% (2)
movwf d4 - 0.01% (2)
easiest way - 0.01% (2)
instruction will - 0.01% (2)
the portb - 0.01% (2)
this bit - 0.01% (2)
2 instruction - 0.01% (2)
of course, - 0.01% (2)
the rb7 - 0.01% (2)
store this - 0.01% (2)
values, so - 0.01% (2)
0x22 ; - 0.01% (2)
0x21 = - 0.01% (2)
; contains - 0.01% (2)
zero movwf - 0.01% (2)
the number - 0.01% (2)
of buttons - 0.01% (2)
array adress - 0.01% (2)
for indirect - 0.01% (2)
as input - 0.01% (2)
read all - 0.01% (2)
them on - 0.01% (2)
locations 0x20 - 0.01% (2)
etc. nop - 0.01% (2)
movlw 0xff - 0.01% (2)
one btfss - 0.01% (2)
(9th instruction) - 0.01% (2)
which makes - 0.01% (2)
easily calculate - 0.01% (2)
the gravity - 0.01% (2)
* 0.02; - 0.01% (2)
and should - 0.01% (2)
will probably - 0.01% (2)
like that - 0.01% (2)
the exact - 0.01% (2)
/ gyroscope_sensitivity) - 0.01% (2)
// angle - 0.01% (2)
// sensitivity - 0.01% (2)
// turning - 0.01% (2)
a vector - 0.01% (2)
(float)accdata[2]) * - 0.01% (2)
* 0.98 - 0.01% (2)
the mean - 0.01% (2)
accelerometer. this - 0.01% (2)
data and - 0.01% (2)
noted that - 0.01% (2)
atan2 function - 0.01% (2)
pi's sd - 0.01% (2)
card socket - 0.01% (2)
- 11:06 - 0.01% (2)
exact same - 0.01% (2)
and "card - 0.01% (2)
most of - 0.01% (2)
detect" and - 0.01% (2)
the "write - 0.01% (2)
protect" and - 0.01% (2)
be noted - 0.01% (2)
pitch and - 0.01% (2)
detect" pins - 0.01% (2)
to external - 0.01% (2)
the quadrocopter), - 0.01% (2)
well. the - 0.01% (2)
is reliable - 0.01% (2)
susceptible to - 0.01% (2)
external forces. - 0.01% (2)
returning to - 0.01% (2)
reliable only - 0.01% (2)
short term, - 0.01% (2)
kind of - 0.01% (2)
term, we - 0.01% (2)
not susceptible - 0.01% (2)
the accelerometer, - 0.01% (2)
know for - 0.01% (2)
but can - 0.01% (2)
a raspberry - 0.01% (2)
pi using - 0.01% (2)
code snippet - 0.01% (2)
below. as - 0.01% (2)
see it - 0.01% (2)
every iteration - 0.01% (2)
the pitch - 0.01% (2)
and roll - 0.01% (2)
values by - 0.01% (2)
integration over - 0.01% (2)
time. the - 0.01% (2)
the "card - 0.01% (2)
make a - 0.01% (2)
oscillator frequency - 0.01% (2)
instruction set - 0.01% (2)
the pickit - 0.01% (2)
image below - 0.01% (2)
thing to - 0.01% (2)
shown below. - 0.01% (2)
these signals - 0.01% (2)
are very - 0.01% (2)
that with - 0.01% (2)
signals, we - 0.01% (2)
your first - 0.01% (2)
experience with - 0.01% (2)
reference for - 0.01% (2)
very simple - 0.01% (2)
out of - 0.01% (2)
program to - 0.01% (2)
place the - 0.01% (2)
combo of - 0.01% (2)
pin by - 0.01% (2)
pin high - 0.01% (2)
us takes - 0.01% (2)
means that, - 0.01% (2)
pin is - 0.01% (2)
to think - 0.01% (2)
code blocks - 0.01% (2)
of them - 0.01% (2)
the last - 0.01% (2)
provides the - 0.01% (2)
a header - 0.01% (2)
i might - 0.01% (2)
should work - 0.01% (2)
old slot - 0.01% (2)
slot and - 0.01% (2)
the solder - 0.01% (2)
pads on - 0.01% (2)
and proper - 0.01% (2)
sure to - 0.01% (2)
a wire - 0.01% (2)
as tightly - 0.01% (2)
i strongly - 0.01% (2)
a lot. - 0.01% (2)
now you - 0.01% (2)
in your - 0.01% (2)
reading nintendo - 0.01% (2)
rb7 pin - 0.01% (2)
with pic - 0.01% (2)
for reading - 0.01% (2)
around a - 0.01% (2)
pic18f2550. i - 0.01% (2)
everything should - 0.01% (2)
work on - 0.01% (2)
rb4 and - 0.01% (2)
some visual - 0.01% (2)
properly. a - 0.01% (2)
board. the - 0.01% (2)
a simple - 0.01% (2)
here the - 0.01% (2)
2011 - - 0.01% (2)
the raspberry pi - 0.16% (22)
nop nop nop - 0.13% (18)
submitted by pieter-jan - 0.09% (13)
by pieter-jan on - 0.09% (13)
we need to - 0.08% (11)
we have to - 0.07% (10)
as you can - 0.07% (10)
the angular position - 0.07% (10)
you can see - 0.07% (10)
in the picture - 0.07% (10)
be able to - 0.06% (9)
shown in the - 0.06% (9)
------------------------- // // - 0.06% (9)
here is a - 0.06% (8)
the n64 controller - 0.06% (8)
look at the - 0.06% (8)
has to be - 0.06% (8)
to do this - 0.06% (8)
nop nop movlw - 0.06% (8)
the raspberry pi. - 0.06% (8)
if you have - 0.05% (7)
movlw 0x00 movwf - 0.05% (7)
data from the - 0.05% (7)
this means that - 0.05% (7)
of the raspberry - 0.05% (7)
to use the - 0.05% (7)
you want to - 0.05% (7)
------------------------------------------------------------------ // // - 0.04% (6)
is shown in - 0.04% (6)
// ------------------------------------------------------------------ // - 0.04% (6)
bsc0_s = clear_status - 0.04% (6)
if you don't - 0.04% (6)
it is very - 0.04% (6)
wait until the - 0.04% (6)
so that the - 0.04% (6)
0x80 movwf portb - 0.04% (6)
t with the - 0.04% (6)
0x00 movwf portb - 0.04% (6)
need to be - 0.04% (6)
= bcd_to_decimal(bsc0_fifo & - 0.04% (6)
// // -------------------------- - 0.04% (6)
portb nop nop - 0.04% (6)
movwf portb nop - 0.04% (6)
nop movlw 0x80 - 0.04% (6)
movlw 0x80 movwf - 0.04% (6)
if you are - 0.04% (5)
in the datasheet - 0.04% (5)
article i will - 0.04% (5)
the complementary filter - 0.04% (5)
to be sent - 0.04% (5)
tmr1if = 0; - 0.04% (5)
this can be - 0.04% (5)
this article i - 0.04% (5)
this is the - 0.04% (5)
the gyroscope data - 0.04% (5)
it should be - 0.04% (5)
you have to - 0.04% (5)
want to use - 0.04% (5)
to be able - 0.04% (5)
#define) bsc0_c = - 0.04% (5)
value of the - 0.04% (5)
return -1; } - 0.04% (5)
bit of the - 0.04% (5)
we want to - 0.04% (5)
bits (see #define) - 0.04% (5)
// reset status - 0.04% (5)
(see #define) wait_i2c_done(); - 0.04% (5)
the picture below. - 0.04% (5)
bsc0_s = clear_status; - 0.04% (5)
status bits (see - 0.04% (5)
that need to - 0.04% (5)
the polling signal - 0.04% (5)
clear_status; // reset - 0.04% (5)
in this article - 0.04% (5)
in the array - 0.03% (4)
we will need - 0.03% (4)
{ printf("failed to - 0.03% (4)
raspberry pi. it - 0.03% (4)
on the raspberry - 0.03% (4)
if bit is - 0.03% (4)
incf fsr0l ; - 0.03% (4)
if you want - 0.03% (4)
the value of - 0.03% (4)
low level programming - 0.03% (4)
sudo apt-get install - 0.03% (4)
; number of - 0.03% (4)
be turned off - 0.03% (4)
is very easy - 0.03% (4)
the memory of - 0.03% (4)
to obtain the - 0.03% (4)
take a look - 0.03% (4)
the supply voltage - 0.03% (4)
make use of - 0.03% (4)
movlw 0x20 ; - 0.03% (4)
the angular velocity - 0.03% (4)
tmr1on = 1; - 0.03% (4)
means that the - 0.03% (4)
it is one - 0.03% (4)
a look at - 0.03% (4)
trisb, 7 ; - 0.03% (4)
= 0b00000001; // - 0.03% (4)
to generate the - 0.03% (4)
be sent movwf - 0.03% (4)
will have to - 0.03% (4)
level programming of - 0.03% (4)
bits which are - 0.03% (4)
post date: monday, - 0.03% (4)
*(gpio.addr + ((g)/10)) - 0.03% (4)
pieter-jan on mon, - 0.03% (4)
which means that - 0.03% (4)
it would be - 0.03% (4)
we use the - 0.03% (4)
position of the - 0.03% (4)
tmr1on = 0; - 0.03% (4)
all 33 bits - 0.03% (4)
memory of the - 0.03% (4)
there is a - 0.03% (4)
from the c - 0.03% (4)
we will use - 0.02% (3)
keep track of - 0.02% (3)
to be used - 0.02% (3)
and can be - 0.02% (3)
want to start - 0.02% (3)
of the motor - 0.02% (3)
tmp += bsc0_fifo; - 0.02% (3)
there are 3 - 0.02% (3)
= bsc0_fifo << - 0.02% (3)
on the sensor - 0.02% (3)
(sudo apt-get install - 0.02% (3)
to use it - 0.02% (3)
for(i; i < - 0.02% (3)
programming of the - 0.02% (3)
because of the - 0.02% (3)
i will explain - 0.02% (3)
raspberry pi in - 0.02% (3)
to figure out - 0.02% (3)
the arduino program - 0.02% (3)
in a previous - 0.02% (3)
to take the - 0.02% (3)
obtain the angular - 0.02% (3)
decfsz d1 goto - 0.02% (3)
zero one movlw - 0.02% (3)
one movlw 0x00 - 0.02% (3)
nop nop decfsz - 0.02% (3)
= off config - 0.02% (3)
indf0, 0 iorwf - 0.02% (3)
iorwf latb, portb - 0.02% (3)
btfsc indf0, 0 - 0.02% (3)
0 iorwf latb, - 0.02% (3)
results in a - 0.02% (3)
decfsz d2 goto - 0.02% (3)
use the data - 0.02% (3)
we can find - 0.02% (3)
part of the - 0.02% (3)
so that it - 0.02% (3)
as it will - 0.02% (3)
can do this - 0.02% (3)
you don't need - 0.02% (3)
lot of people - 0.02% (3)
you should be - 0.02% (3)
given in the - 0.02% (3)
64 controller with - 0.02% (3)
is connected to - 0.02% (3)
connected to the - 0.02% (3)
to take a - 0.02% (3)
one instruction cycle - 0.02% (3)
will need a - 0.02% (3)
it with the - 0.02% (3)
// start write - 0.02% (3)
a previous article. - 0.02% (3)
bsc0_c = start_write; - 0.02% (3)
need to use - 0.02% (3)
printf("failed to map - 0.02% (3)
they have to - 0.02% (3)
so we have - 0.02% (3)
the data from - 0.02% (3)
= 0b00000000; // - 0.02% (3)
real time clock - 0.02% (3)
struct of the - 0.02% (3)
// -------------------------- ms - 0.02% (3)
way to do - 0.02% (3)
will explain how - 0.02% (3)
1/oscvalue * 4 - 0.02% (3)
* prescaler * - 0.02% (3)
(65536 - tmr1) - 0.02% (3)
while(1) { // - 0.02% (3)
virtual memory space.\n"); - 0.02% (3)
space.\n"); return -1; - 0.02% (3)
the virtual memory - 0.02% (3)
a struct of - 0.02% (3)
map the physical - 0.02% (3)
make sure you - 0.02% (3)
// // ------------------------------------------------------------------ - 0.02% (3)
the type bcm2835_peripheral - 0.02% (3)
means that we - 0.02% (3)
need to take - 0.02% (3)
this is done - 0.02% (3)
are some pictures - 0.02% (3)
the gpfsel register - 0.02% (3)
arm peripherals manual - 0.02% (3)
pin "g" as - 0.02% (3)
registers into the - 0.02% (3)
prescaler * (65536 - 0.02% (3)
into the virtual - 0.02% (3)
of the bcm2835 - 0.02% (3)
post date: friday, - 0.02% (3)
one of the - 0.02% (3)
pieter-jan on fri, - 0.02% (3)
write (see #define) - 0.02% (3)
* (65536 - - 0.02% (3)
start_write; // start - 0.02% (3)
4 * prescaler - 0.02% (3)
memory space.\n"); return - 0.02% (3)
= 1/oscvalue * - 0.02% (3)
you can do - 0.02% (3)
2011 - 08:33 - 0.01% (2)
portb incf fsr0l - 0.01% (2)
bits are read - 0.01% (2)
= cvcreatemat(480, 640, - 0.01% (2)
like this: the - 0.01% (2)
0; /* main - 0.01% (2)
the sensor, and - 0.01% (2)
array incf fsr0l - 0.01% (2)
to work with - 0.01% (2)
we decided to - 0.01% (2)
; end loop - 0.01% (2)
see if it - 0.01% (2)
pieter-jan van de - 0.01% (2)
a imu without - 0.01% (2)
kalman: the complementary - 0.01% (2)
2013 - 08:38 - 0.01% (2)
program */ void - 0.01% (2)
and red wires - 0.01% (2)
to check the - 0.01% (2)
if all 33 - 0.01% (2)
nop decfsz d4 - 0.01% (2)
*/ void adc(void); - 0.01% (2)
the hi-tech c - 0.01% (2)
/* function prototypes - 0.01% (2)
to use as - 0.01% (2)
#define _xtal_freq 20000000 - 0.01% (2)
mclre_off & cp_off); - 0.01% (2)
& pwrte_off & - 0.01% (2)
__config(fosc_hs & wdte_off - 0.01% (2)
#include - 0.01% (2)
lite compiler. #include - 0.01% (2)
angle += gyrorate - 0.01% (2)
next adres in - 0.01% (2)
you will have - 0.01% (2)
offset) * 5.5; - 0.01% (2)
= (gyrovalue - - 0.01% (2)
the array nop - 0.01% (2)
2012 - 11:06 - 0.01% (2)
the code block - 0.01% (2)
offset = 136; - 0.01% (2)
for this is - 0.01% (2)
float angle = - 0.01% (2)
value for the - 0.01% (2)
reading nintendo 64 - 0.01% (2)
2012 - 12:25 - 0.01% (2)
programming from mac - 0.01% (2)
date: monday, september - 0.01% (2)
d2 movlw 0x02 - 0.01% (2)
position from gyroscope - 0.01% (2)
getting the angular - 0.01% (2)
3, 2012 - - 0.01% (2)
monday, september 3, - 0.01% (2)
nop decfsz d1 - 0.01% (2)
d1 oneloop ; - 0.01% (2)
movlw 0x02 movwf - 0.01% (2)
hacking the hobbyking - 0.01% (2)
of the angular - 0.01% (2)
hk401b gyroscope module - 0.01% (2)
d2 goto zero - 0.01% (2)
movwf portb decfsz - 0.01% (2)
ones that need - 0.01% (2)
post date: saturday, - 0.01% (2)
movwf d3 zero - 0.01% (2)
(4) independent pwm-signals - 0.01% (2)
goto zeroloop nop - 0.01% (2)
movwf d1 zeroloop - 0.01% (2)
portb movlw 0x03 - 0.01% (2)
number of zeros - 0.01% (2)
position over time - 0.01% (2)
interest) with opencv - 0.01% (2)
2012 - 08:37 - 0.01% (2)
roi (region of - 0.01% (2)
narf keypoint test - 0.01% (2)
the previous article - 0.01% (2)
it is shown - 0.01% (2)
2012 - 11:55 - 0.01% (2)
of the wires. - 0.01% (2)
a one axis - 0.01% (2)
the angular velocity. - 0.01% (2)
that will be - 0.01% (2)
controller with pic - 0.01% (2)
so that they - 0.01% (2)
raspberry pi for - 0.01% (2)
external forces that - 0.01% (2)
directly on the - 0.01% (2)
of the motors - 0.01% (2)
is a good - 0.01% (2)
not returning to - 0.01% (2)
integral approximation will - 0.01% (2)
movlw 0x07 ; - 0.01% (2)
2012 - 02:41 - 0.01% (2)
generated with one - 0.01% (2)
setting up the - 0.01% (2)
init trisa = - 0.01% (2)
void adc(void) { - 0.01% (2)
0b00000001; // ra0 - 0.01% (2)
pieter-jan on sat, - 0.01% (2)
with one pic - 0.01% (2)
independent pwm-signals generated - 0.01% (2)
the following video - 0.01% (2)
adc(void); void main(void); - 0.01% (2)
the pictures above - 0.01% (2)
some pictures of - 0.01% (2)
not interested in - 0.01% (2)
main program */ - 0.01% (2)
void main(void) { - 0.01% (2)
// init trisa - 0.01% (2)
hobbyking hk401b gyroscope - 0.01% (2)
prototypes */ void - 0.01% (2)
adcon0 = 0b00000001; - 0.01% (2)
driven with a - 0.01% (2)
finger would be - 0.01% (2)
// timer 1 - 0.01% (2)
this would make - 0.01% (2)
so if you - 0.01% (2)
that you don't - 0.01% (2)
as tightly as - 0.01% (2)
as much as - 0.01% (2)
does not contain - 0.01% (2)
fill the balloon - 0.01% (2)
& store the - 0.01% (2)
that we are - 0.01% (2)
prescaler 1:1 and - 0.01% (2)
compiler. #include - 0.01% (2)
until first output - 0.01% (2)
i decided to - 0.01% (2)
at the same - 0.01% (2)
to go faster - 0.01% (2)
go faster than - 0.01% (2)
see in the - 0.01% (2)
i make use - 0.01% (2)
the same time - 0.01% (2)
the 4 pwm - 0.01% (2)
hi-tech c lite - 0.01% (2)
wdte_off & pwrte_off - 0.01% (2)
brushless dc motor - 0.01% (2)
are at the - 0.01% (2)
looks like this: - 0.01% (2)
we can easily - 0.01% (2)
it a little - 0.01% (2)
a pic microcontroller. - 0.01% (2)
that have to - 0.01% (2)
& mclre_off & - 0.01% (2)
is part of - 0.01% (2)
cp_off); #define _xtal_freq - 0.01% (2)
motor with a - 0.01% (2)
20000000 /* function - 0.01% (2)
go through the - 0.01% (2)
freq 20mhz tmr1on - 0.01% (2)
(region of interest) - 0.01% (2)
go_done = 1; - 0.01% (2)
wait until first - 0.01% (2)
from mac os - 0.01% (2)
pi for programming - 0.01% (2)
up the raspberry - 0.01% (2)
work directly on - 0.01% (2)
a result of - 0.01% (2)
portc = portcvalue; - 0.01% (2)
= 0; tmr1if - 0.01% (2)
ms with prescaler - 0.01% (2)
while(go_done); } results - 0.01% (2)
1:1 and freq - 0.01% (2)
monitor & keyboard, - 0.01% (2)
ms wait until - 0.01% (2)
gyrorate / 100.0; - 0.01% (2)
20mhz tmr1on = - 0.01% (2)
adc(void) { go_done - 0.01% (2)
gyrorate = (gyrovalue - 0.01% (2)
= 1; while(go_done); - 0.01% (2)
adcon1 = 0b00000000; - 0.01% (2)
is a video - 0.01% (2)
a quick look - 0.01% (2)
note that this - 0.01% (2)
/* extract narf - 0.01% (2)
0; // ------------------------------------------------------------------ - 0.01% (2)
made use of - 0.01% (2)
mon, 03/09/2012 - - 0.01% (2)
// keep track - 0.01% (2)
you write a - 0.01% (2)
i++) { // - 0.01% (2)
0; for(i; i<4; - 0.01% (2)
from low to - 0.01% (2)
i<4; i++) { - 0.01% (2)
and you are - 0.01% (2)
if you did - 0.01% (2)
first time you - 0.01% (2)
go to the - 0.01% (2)
we know everything - 0.01% (2)
should see something - 0.01% (2)
use any gui - 0.01% (2)
connect to the - 0.01% (2)
you can see, - 0.01% (2)
might want to - 0.01% (2)
of ram and - 0.01% (2)
the easiest way - 0.01% (2)
external monitor & - 0.01% (2)
i recommend using - 0.01% (2)
will need an - 0.01% (2)
until the first - 0.01% (2)
from the command - 0.01% (2)
to do the - 0.01% (2)
bit in the - 0.01% (2)
movwf d1 oneloop - 0.01% (2)
indf0 ; wait - 0.01% (2)
*/ bsc0_dlen = - 0.01% (2)
: ack ack - 0.01% (2)
p // slave - 0.01% (2)
// master: s - 0.01% (2)
see datasheet (ps) - 0.01% (2)
regaddr, unsigned char - 0.01% (2)
void mpu6050_setregister(unsigned char - 0.01% (2)
accdata, short * - 0.01% (2)
void mpu6050_read(short * - 0.01% (2)
bcd_to_decimal(bsc0_fifo & 0x3f); - 0.01% (2)
after clearing fifo - 0.01% (2)
// start read - 0.01% (2)
bsc0_c = start_read; - 0.01% (2)
byte bsc0_fifo = - 0.01% (2)
1; // one - 0.01% (2)
the physical gpio - 0.01% (2)
// see datasheet - 0.01% (2)
#include "rpi.h" #include - 0.01% (2)
to start reading - 0.01% (2)
address of the - 0.01% (2)
have to do - 0.01% (2)
address to the - 0.01% (2)
want to be - 0.01% (2)
the rtc we - 0.01% (2)
time clock (rtc) - 0.01% (2)
writing to the - 0.01% (2)
want to write - 0.01% (2)
to the bsc0_a - 0.01% (2)
of the device - 0.01% (2)
to alternate functionality - 0.01% (2)
if we look - 0.01% (2)
* accdata, short - 0.01% (2)
sequence // master: - 0.01% (2)
pin to behave - 0.01% (2)
because i want - 0.01% (2)
raspberry pi using - 0.01% (2)
not susceptible to - 0.01% (2)
the short term, - 0.01% (2)
gyroscope data is - 0.01% (2)
to external forces. - 0.01% (2)
of the previous - 0.01% (2)
the problem with - 0.01% (2)
the long term, - 0.01% (2)
reliable only on - 0.01% (2)
working on the - 0.01% (2)
hard to use - 0.01% (2)
are going to - 0.01% (2)
and gyroscope data - 0.01% (2)
best way to - 0.01% (2)
am interested in - 0.01% (2)
s ad+w ra - 0.01% (2)
the reason i - 0.01% (2)
imu without kalman: - 0.01% (2)
with a multimeter. - 0.01% (2)
make sure that - 0.01% (2)
it might be - 0.01% (2)
you need to - 0.01% (2)
in the figure - 0.01% (2)
half of the - 0.01% (2)
the first step - 0.01% (2)
pi breakout cable - 0.01% (2)
and you can - 0.01% (2)
8; tmp += - 0.01% (2)
3; i++) // - 0.01% (2)
slave : ack - 0.01% (2)
one pin to - 0.01% (2)
add the following - 0.01% (2)
below. as you - 0.01% (2)
if we are - 0.01% (2)
are 0 #define - 0.01% (2)
ignores bits which - 0.01% (2)
which are 1 - 0.01% (2)
are 1 ignores - 0.01% (2)
#define gpio_set *(gpio.addr - 0.01% (2)
+ (((g)/10))) |= - 0.01% (2)
#define set_gpio_alt(g,a) *(gpio.addr - 0.01% (2)
out_gpio(g) *(gpio.addr + - 0.01% (2)
inp_gpio(x) before using - 0.01% (2)
this is not - 0.01% (2)
defined in the - 0.01% (2)
location of the - 0.01% (2)
the virtual address - 0.01% (2)
interested in the - 0.01% (2)
there are a - 0.01% (2)
easy to understand, - 0.01% (2)
in the datasheet. - 0.01% (2)
it are these - 0.01% (2)
are set up - 0.01% (2)
peripherals manual at - 0.01% (2)
broadcom bcm2835 arm - 0.01% (2)
bcm2835_peripheral gpio = - 0.01% (2)
volatile unsigned int - 0.01% (2)
the register that - 0.01% (2)
by writing to - 0.01% (2)
this tutorial will - 0.01% (2)
code in a - 0.01% (2)
try to use - 0.01% (2)
but it seemed - 0.01% (2)
c submitted by - 0.01% (2)
gpio_read(g) *(gpio.addr + - 0.01% (2)
so don't be - 0.01% (2)
bits in the - 0.01% (2)
gpio_set *(gpio.addr + - 0.01% (2)
<< 8) #define - 0.01% (2)
<< 7) #define - 0.01% (2)
<< 4; sleep(1); - 0.01% (2)
gpio_set = 1 - 0.01% (2)
gpio registers into - 0.01% (2)
if(map_peripheral(&gpio) == -1) - 0.01% (2)
if you look - 0.01% (2)
are interested in - 0.01% (2)
13) &= (1 - 0.01% (2)
to write to - 0.01% (2)
"1" to the - 0.01% (2)
we can set - 0.01% (2)
we don't need - 0.01% (2)
know that we - 0.01% (2)
gpio0 and gpio1 - 0.01% (2)
this is what - 0.01% (2)
*(gpio.addr + (((g)/10))) - 0.01% (2)
you might have - 0.01% (2)
this way you - 0.01% (2)
in the same - 0.01% (2)
x x (gpfsel - 0.01% (2)
the gpsel register - 0.01% (2)
set pin "g" - 0.01% (2)
we are not - 0.01% (2)
bits of the - 0.01% (2)
((g)/10)) &= ~(7 - 0.01% (2)
inp_gpio(g) *(gpio.addr + - 0.01% (2)
we will go - 0.01% (2)
the broadcom bcm2835 - 0.01% (2)
to use this - 0.01% (2)
i will not - 0.01% (2)
can see it - 0.01% (2)
is zero movwf - 0.01% (2)
values, so we - 0.01% (2)
portb, 7 ; - 0.01% (2)
is one btfss - 0.01% (2)
nop movlw 0xff - 0.01% (2)
wait nop nop - 0.01% (2)
etc. nop ; - 0.01% (2)
on locations 0x20 - 0.01% (2)
and store them - 0.01% (2)
readloop ; read - 0.01% (2)
rb7 as input - 0.01% (2)
the array adress - 0.01% (2)
buttons movlw 0x20 - 0.01% (2)
the number of - 0.01% (2)
d4 ; contains - 0.01% (2)
33 bits movwf - 0.01% (2)
register contains the - 0.01% (2)
(9th instruction) movlw - 0.01% (2)
the rb7 pin - 0.01% (2)
2 instruction cycles - 0.01% (2)
it will take - 0.01% (2)
file, skip if - 0.01% (2)
to wait until - 0.01% (2)
easiest way to - 0.01% (2)
way to read - 0.01% (2)
this in the - 0.01% (2)
d3 goto one - 0.01% (2)
goto oneloop decfsz - 0.01% (2)
decfsz d1, f - 0.01% (2)
portb movlw 0x02 - 0.01% (2)
d1 zeroloop ; - 0.01% (2)
movlw 0x03 movwf - 0.01% (2)
read the bit - 0.01% (2)
0x00 ; if - 0.01% (2)
number of ones - 0.01% (2)
movlw 0x22 ; - 0.01% (2)
instruction) movlw 0x00 - 0.01% (2)
the bit (9th - 0.01% (2)
one btfss portb, - 0.01% (2)
movlw 0xff ; - 0.01% (2)
nop ; wait - 0.01% (2)
locations 0x20 etc. - 0.01% (2)
store them on - 0.01% (2)
33 bits and - 0.01% (2)
; read all - 0.01% (2)
set up the - 0.01% (2)
number of buttons - 0.01% (2)
; contains the - 0.01% (2)
bits movwf d4 - 0.01% (2)
0x21 = 33 - 0.01% (2)
i won't go - 0.01% (2)
bit is zero - 0.01% (2)
i made use - 0.01% (2)
the full assembly - 0.01% (2)
know if you - 0.01% (2)
(4 oscillator cycles - 0.01% (2)
know for sure - 0.01% (2)
read goto readloop - 0.01% (2)
33 bits are - 0.01% (2)
loop if all - 0.01% (2)
to next adres - 0.01% (2)
fsr0l ; go - 0.01% (2)
the array incf - 0.01% (2)
the bit in - 0.01% (2)
wait & store - 0.01% (2)
movwf indf0 ; - 0.01% (2)
d3 zero movlw - 0.01% (2)
movlw 0x02 ; - 0.01% (2)
be used in - 0.01% (2)
pieter-jan on thu, - 0.01% (2)
pads on the - 0.01% (2)
and "write protect" - 0.01% (2)
the new slot - 0.01% (2)
the old slot - 0.01% (2)
the "card detect" - 0.01% (2)
and "card detect" - 0.01% (2)
the "write protect" - 0.01% (2)
is given in - 0.01% (2)
of the slot - 0.01% (2)
most of the - 0.01% (2)
i chose to - 0.01% (2)
"card detect" and - 0.01% (2)
"write protect" and - 0.01% (2)
my raspberry pi. - 0.01% (2)
pi's sd card - 0.01% (2)
i strongly recommend - 0.01% (2)
replacing the raspberry - 0.01% (2)
this article was - 0.01% (2)
the quadrocopter), the - 0.01% (2)
the filter is - 0.01% (2)
(float)accdata[2]) * 180 - 0.01% (2)
in a vector - 0.01% (2)
turning around the - 0.01% (2)
angle around the - 0.01% (2)
the accelerometer. this - 0.01% (2)
of the current - 0.01% (2)
the accelerometer data - 0.01% (2)
the pitch and - 0.01% (2)
for sure that - 0.01% (2)
pitch and roll - 0.01% (2)
tightly as possible - 0.01% (2)
the slot a - 0.01% (2)
sent movwf d2 - 0.01% (2)
the instructions that - 0.01% (2)
of zeros that - 0.01% (2)
0x07 ; number - 0.01% (2)
; 0b000000011 movlw - 0.01% (2)
make rb7 output - 0.01% (2)
the time to - 0.01% (2)
clear to see - 0.01% (2)
the beginning of - 0.01% (2)
two instruction cycles - 0.01% (2)
next instruction if - 0.01% (2)
i used the - 0.01% (2)
the response is - 0.01% (2)
second bit of - 0.01% (2)
is built up - 0.01% (2)
figure out how - 0.01% (2)
means that it - 0.01% (2)
a pic microcontroller, - 0.01% (2)
controller is connected - 0.01% (2)
a combo of - 0.01% (2)
place the value - 0.01% (2)
set can be - 0.01% (2)
1 us takes - 0.01% (2)
the nintendo 64 - 0.01% (2)
quick look at - 0.01% (2)
of the microcontroller - 0.01% (2)
to find a - 0.01% (2)
so we can - 0.01% (2)
some visual feedback - 0.01% (2)
because i am - 0.01% (2)
below. it is - 0.01% (2)
the code to - 0.01% (2)
van de maele - 0.01% (2)

Here you can find chart of all your popular one, two and three word phrases. Google and others search engines means your page is about words you use frequently.

Copyright © 2015-2016 hupso.pl. All rights reserved. FB | +G | Twitter

Hupso.pl jest serwisem internetowym, w którym jednym kliknieciem możesz szybko i łatwo sprawdź stronę www pod kątem SEO. Oferujemy darmowe pozycjonowanie stron internetowych oraz wycena domen i stron internetowych. Prowadzimy ranking polskich stron internetowych oraz ranking stron alexa.