jackcartersmith/blackmagic
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Deduplicate example README file contents.

Browse Source
This commit is contained in:
Uwe Hermann 2010-12-29 19:49:59 +01:00
parent d9f6f200c1
commit 01bfbfed41
23 changed files with 26 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
README
View File

@ -52,6 +52,18 @@ The Makefiles of the examples are configured to use a certain OpenOCD
flash programmer, you might need to change some of the variables in the
Makefile if you use a different one.
You can also flash manually like this:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase foobar.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm32.cfg" with your respective config file. Replace "foobar.hex"
with the file name of the image you want to flash.
Installation
------------

36
examples/lisa-m/usb_dfu/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Device Firmware Upgrade (DFU) bootloader
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/lisa-m/usb_hid/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Human Interface Device (HID)
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

41
examples/mb525/fancyblink/README
View File

@ -5,43 +5,6 @@ README
This is a blink example program using libopenstm32.
It's intended for the ST STM32-based MB525 eval board (see
http://www.st.com/stonline/products/literature/um/13472.htm for details). It
should blink the LED on the board.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the MB525 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jlink.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase fancyblink.hex
> reset
Replace the "jlink.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.
http://www.st.com/stonline/products/literature/um/13472.htm for details).
It should blink the LED on the board.

41
examples/mb525/pwmleds/README
View File

@ -5,43 +5,6 @@ README
This is a PWM based LED fading example using libopenstm32.
It's intended for the ST STM32-based MB525 eval board (see
http://www.st.com/stonline/products/literature/um/13472.htm for details). It
should blink the LED on the board.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the MB525 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jlink.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase pwmleds.hex
> reset
Replace the "jlink.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.
http://www.st.com/stonline/products/literature/um/13472.htm for details).
It should blink the LED on the board.

39
examples/other/adc_temperature_sensor/README
View File

@ -3,45 +3,8 @@ README
------------------------------------------------------------------------------
This example program sends some characters on USART1.
Afterwards it read out the internal temperature sensor of the stm32 and
Afterwards it read out the internal temperature sensor of the STM32 and
sends the value read out from the ADC to the USART1.
The terminal settings for the receiving device/PC are 115200 8n1.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase adc.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

37
examples/other/dma_mem2mem/README
View File

@ -9,40 +9,3 @@ USART1.
The terminal settings for the receiving device/PC are 115200 8n1.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase dma.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

39
examples/other/dogm128/README
View File

@ -2,41 +2,6 @@
README
------------------------------------------------------------------------------
This example program writes some text on an DOGM128 LCD display connected to SPI2.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase main.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.
This example program writes some text on an DOGM128 LCD display connected
to SPI2.

38
examples/other/i2c_stts75_sensor/README
View File

@ -5,45 +5,9 @@ README
This example program sends some characters on USART1.
Afterwards it connects to an STTS75 sensor (ST LM75 compatible)
at adress A0/1/2=0 and sets reverse polarity, 26 degree Tos and Thyst.
It reads out the temperature and submits the temperature over USART1 in
binary format (ASCII 0/1).
The terminal settings for the receiving device/PC are 115200 8n1.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase i2c_stts75_sensor.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

37
examples/other/rtc/README
View File

@ -4,40 +4,3 @@ README
This is a small RTC example project.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase rtc.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.

38
examples/other/systick/README
View File

@ -3,41 +3,5 @@ README
------------------------------------------------------------------------------
This example program blinks a LED on PortB Pin 6. 1 second on / 1 second off.
Blinking is done thru the systick timer interrupt.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.
Blinking is done via the systick timer interrupt.

38
examples/other/timer_interrupt/README
View File

@ -3,41 +3,5 @@ README
------------------------------------------------------------------------------
This example program blinks a LED on PortB Pin 6. 1 second on / 1 second off.
Blinking is made only with timer interrupt from TIM2 timer.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase timer.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.
Blinking is made only with the timer interrupt of the TIM2 timer.

36
examples/other/usb_cdcacm/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB CDC-ACM device (aka Virtual Serial Port)
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/other/usb_dfu/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Device Firmware Upgrade (DFU) bootloader
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/other/usb_hid/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Human Interface Device (HID)
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm32.cfg" with your respective config file.

39
examples/stm32-h103/fancyblink/README
View File

@ -2,46 +2,9 @@
README
------------------------------------------------------------------------------
This is the smallest-possible example program using libopenstm32.
This is small LED blinking example program using libopenstm32.
It's intended for the ST STM32-based Olimex STM32-H103 eval board (see
http://olimex.com/dev/stm32-h103.html for details). It should blink
the LED on the board.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the STM32-H103 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase fancyblink.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.

37
examples/stm32-h103/miniblink/README
View File

@ -8,40 +8,3 @@ It's intended for the ST STM32-based Olimex STM32-H103 eval board (see
http://olimex.com/dev/stm32-h103.html for details). It should blink
the LED on the board.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the STM32-H103 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase miniblink.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.

38
examples/stm32-h103/spi/README
View File

@ -6,41 +6,3 @@ This example program repeatedly sends characters on SPI1 on the ST STM32-based
Olimex STM32-H103 eval board (see http://olimex.com/dev/stm32-h103.html
for details).
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the STM32-H103 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> init
> reset halt
> flash write_image erase spi.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.

38
examples/stm32-h103/usart/README
View File

@ -8,40 +8,6 @@ for details).
The terminal settings for the receiving device/PC are 38400 8n1.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code on the STM32-H103 board using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f board/olimex_stm32_h103.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase usart.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "olimex_stm32_h103.cfg" with your respective board config file.
The sending is done in a blocking way in the code, see the usart_irq example
for a more elaborate USART example.

36
examples/stm32-h103/usb_cdcacm/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB CDC-ACM device (aka Virtual Serial Port)
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/stm32-h103/usb_dfu/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Device Firmware Upgrade (DFU) bootloader
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/stm32-h103/usb_hid/README
View File

@ -5,39 +5,3 @@ README
This example implements a USB Human Interface Device (HID)
to demonstrate the use of the USB device stack.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase systick.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.

36
examples/stm32-h103/usb_iap/README
View File

@ -4,39 +4,5 @@ README
This example implements a USB bootloader for the Paparazzi project.
Building
--------
$ make
Running 'make' on the top-level libopenstm32 directory will automatically
also build this example. Or you can build the library "manually" and
then run 'make' in this directory.
You may want to override the toolchain (e.g., arm-elf or arm-none-eabi):
$ PREFIX=arm-none-eabi make
For a more verbose build you can use
$ make V=1
Flashing
--------
You can flash the generated code using OpenOCD:
$ make flash
Or you can do the same manually via:
$ openocd -f interface/jtagkey-tiny.cfg -f target/stm32.cfg
$ telnet localhost 4444
> reset halt
> flash write_image erase usbiap.hex
> reset
Replace the "jtagkey-tiny.cfg" with whatever JTAG device you are using, and/or
replace "stm.cfg" with your respective config file.
TODO: Move to examples/lisa-m?