ChibiOS Free Embedded RTOS

Code: Select all

#include <stdio.h>
int main()
{
char str[80];

while (1) {
  printf("Hello! What say, ye? ");
  scanf("%s", str);
  puts(str);
}
  return 0;
}

Code: Select all

#include <stdio.h>
int main()
{
  char str[80];
  int i, isquared;
  FILE *fp;
  fp = fopen("hello.txt", "r+");
  if (fp == NULL) {
    printf("Could not open hello.txt.\n");
    return 0;
  }

  /* write to the file */
  for (i=0; i<=10; ++i)
    fprintf(fp, "%d, %d\n", i, i*i);
  /* read the file */
  fseek (fp, 0, SEEK_SET);
  while (fscanf(fp, "%d,%d\n", &i, &isquared) == 2)
    printf("i: %d,  isquared: %d\n", i, isquared);
  /* Interact */
  str[0] = '\0';
  while (str[0] != '0') {
    printf("Hello! What say, ye? (0 to exit) ");
    scanf("%s", str);
    fprintf(fp, "%s\n", str);
    printf("%s\n", str);
    //fflush(fp);
  }

  /* close the file */
  fclose(fp);
  return 0;
}

#ifndef __NO_SYSTEM_INIT
void SystemInit()
{}
#endif

Code: Select all

openocd -f interface/stlink-v2.cfg -f target/stm32f1x_stlink.cfg

Code: Select all

gdbinit:
set mem inaccessible-by-default off
set confirm off
set target-async on

launch command:
arm-none-eabi-gdb -ex "target ext localhost:3333" -ex "mon reset halt" -ex "mon arm semihosting enable"

gdb commands:
load
run

switch to openocd terminal to see the stdout/stdin streams.

Code: Select all

include makefile.conf
NAME=semihost
STARTUP_DEFS=

LDSCRIPTS=-L. -L$(BASE)/ldscripts -T gcc.ld
LFLAGS=$(USE_NANO) $(USE_SEMIHOST) $(LDSCRIPTS) $(GC) $(MAP) -g3 -std=gnu99
$(NAME)-$(CORE).axf: $(NAME).c $(STARTUP)
   $(CC) $^ $(CFLAGS) $(LFLAGS) -o $@

clean: 
   rm -f $(NAME)*.axf *.map

Code: Select all

# Selecting Core
CORTEX_M=3

# Use newlib-nano. To disable it, specify USE_NANO=
USE_NANO=--specs=nano.specs

# Use seimhosting or not
USE_SEMIHOST=--specs=rdimon.specs -lc -lc -lrdimon
USE_NOHOST=-lc -lc -lnosys

CORE=CM$(CORTEX_M)
BASE=./

# Compiler & Linker
CC=arm-none-eabi-gcc
CXX=arm-none-eabi-g++

# Options for specific architecture
ARCH_FLAGS=-mthumb -mcpu=cortex-m$(CORTEX_M)

# Startup code
STARTUP=$(BASE)/startup/startup_ARM$(CORE).S

# -Os -ffunction-sections -fdata-sections to compile for code size
CFLAGS=$(ARCH_FLAGS) $(STARTUP_DEFS) -Os -ffunction-sections -fdata-sections -g3 -fasynchronous-unwind-tables
#-funwind-tables

# Link for code size
GC=-Wl,--gc-sections

# Create map file
MAP=-Wl,-Map=$(NAME).map

Code: Select all

/* Linker script to configure memory regions. 
 * Need modifying for a specific board. 
 *   FLASH.ORIGIN: starting address of flash
 *   FLASH.LENGTH: length of flash
 *   RAM.ORIGIN: starting address of RAM bank 0
 *   RAM.LENGTH: length of RAM bank 0
 */

/* STM32F107VCT6, 256K flash, 64K RAM. */

MEMORY
{
  FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 0x40000 /* 256k */ /* 0x20000 128K */
  RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 0x10000 /* 64k */ /* 0x2000  8K */
}

/* Linker script to configure memory regions. 
 * Need modifying for a specific board. 
 *   FLASH.ORIGIN: starting address of flash
 *   FLASH.LENGTH: length of flash
 *   RAM.ORIGIN: starting address of RAM bank 0
 *   RAM.LENGTH: length of RAM bank 0
 */

/* STM32F107VCT6, 256K flash, 64K RAM. */

MEMORY
{
  FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 0x40000 /* 256k */ /* 0x20000 128K */
  RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 0x10000 /* 64k */ /* 0x2000  8K */
}
/* Linker script to place sections and symbol values. Should be used together
 * with other linker script that defines memory regions FLASH and RAM.
 * It references following symbols, which must be defined in code:
 *   Reset_Handler : Entry of reset handler
 * 
 * It defines following symbols, which code can use without definition:
 *   __exidx_start
 *   __exidx_end
 *   __etext
 *   __data_start__
 *   __preinit_array_start
 *   __preinit_array_end
 *   __init_array_start
 *   __init_array_end
 *   __fini_array_start
 *   __fini_array_end
 *   __data_end__
 *   __bss_start__
 *   __bss_end__
 *   __end__
 *   end
 *   __HeapLimit
 *   __StackLimit
 *   __StackTop
 *   __stack
 */
ENTRY(Reset_Handler)

SECTIONS
{
   .text :
   {
      KEEP(*(.isr_vector))
      *(.text*)

      KEEP(*(.init))
      KEEP(*(.fini))

      /* .ctors */
      *crtbegin.o(.ctors)
      *crtbegin?.o(.ctors)
      *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
      *(SORT(.ctors.*))
      *(.ctors)

      /* .dtors */
       *crtbegin.o(.dtors)
       *crtbegin?.o(.dtors)
       *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
       *(SORT(.dtors.*))
       *(.dtors)

      *(.rodata*)

      KEEP(*(.eh_frame*))
   } > FLASH

   .ARM.extab : 
   {
      *(.ARM.extab* .gnu.linkonce.armextab.*)
   } > FLASH

   __exidx_start = .;
   .ARM.exidx :
   {
      *(.ARM.exidx* .gnu.linkonce.armexidx.*)
   } > FLASH
   __exidx_end = .;

   __etext = .;
      
   .data : AT (__etext)
   {
      __data_start__ = .;
      *(vtable)
      *(.data*)

      . = ALIGN(4);
      /* preinit data */
      PROVIDE_HIDDEN (__preinit_array_start = .);
      KEEP(*(.preinit_array))
      PROVIDE_HIDDEN (__preinit_array_end = .);

      . = ALIGN(4);
      /* init data */
      PROVIDE_HIDDEN (__init_array_start = .);
      KEEP(*(SORT(.init_array.*)))
      KEEP(*(.init_array))
      PROVIDE_HIDDEN (__init_array_end = .);


      . = ALIGN(4);
      /* finit data */
      PROVIDE_HIDDEN (__fini_array_start = .);
      KEEP(*(SORT(.fini_array.*)))
      KEEP(*(.fini_array))
      PROVIDE_HIDDEN (__fini_array_end = .);

      KEEP(*(.jcr*))
      . = ALIGN(4);
      /* All data end */
      __data_end__ = .;

   } > RAM

   .bss :
   {
      . = ALIGN(4);
      __bss_start__ = .;
      *(.bss*)
      *(COMMON)
      . = ALIGN(4);
      __bss_end__ = .;
   } > RAM
   
   .heap (COPY):
   {
      __end__ = .;
      end = __end__;
      *(.heap*)
      __HeapLimit = .;
   } > RAM

   /* .stack_dummy section doesn't contains any symbols. It is only
    * used for linker to calculate size of stack sections, and assign
    * values to stack symbols later */
   .stack_dummy (COPY):
   {
      *(.stack*)
   } > RAM

   /* Set stack top to end of RAM, and stack limit move down by
    * size of stack_dummy section */
   __StackTop = ORIGIN(RAM) + LENGTH(RAM);
   __StackLimit = __StackTop - SIZEOF(.stack_dummy);
   PROVIDE(__stack = __StackTop);
   
   /* Check if data + heap + stack exceeds RAM limit */
   ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack")
}

Code: Select all

.text:08001FD0                 EXPORT _malloc_r
.text:08001FD0 _malloc_r                               ; CODE XREF: __sfmoreglue+Cp
.text:08001FD0                                         ; __smakebuf_r+52p
.text:08001FD0                 PUSH    {R4-R6,LR}
.text:08001FD2                 ADDS    R5, R1, #3
.text:08001FD4                 BIC.W   R5, R5, #3
.text:08001FD8                 ADDS    R5, #8
.text:08001FDA                 CMP     R5, #0xC
.text:08001FDC                 IT CC
.text:08001FDE                 MOVCC   R5, #0xC
.text:08001FE0                 CMP     R5, #0
.text:08001FE2                 MOV     R6, R0
.text:08001FE4                 BLT loc_8002042

Code: Select all

.text:08002150
.text:08002150                 EXPORT __sfmoreglue
.text:08002150 __sfmoreglue                            ; CODE XREF: __sfp+32p
.text:08002150                 PUSH    {R4-R6,LR}
.text:08002152                 MOVS    R5, #0x68
.text:08002154                 MULS    R5, R1
.text:08002156                 MOV     R6, R1
.text:08002158                 ADD.W   R1, R5, #0xC
.text:0800215C                CBZ        R0, loc_8002176

Code: Select all

#include <stdio.h>
#include "ch.h"
#include "hal.h"
#include "chprintf.h"

// Create semihost BaseChannel struct pointing to our semihosting Virtual Methods Table (vmt)
BaseChannel semihostBC;
BaseChannel *chp = &semihostBC;

// writes for semihost: (void *instance, const uint8_t *bp, size_t n)
static size_t writes(BaseChannel *stream, const char *ptr, size_t size)
{
    (void)stream;
    static uint32_t args[3];
    args[0] = 1;
    args[1] = (uint32_t)ptr;
    args[2] = size;
    asm("mov r0, #5\n"
        "mov r1, %0\n"
        "bkpt 0x00ab"  : : "r"(args) : "r0", "r1");
    return args[2];
}

// Stolen from boiler plate BaseChannel methods from chioch.h

// This putt is an ugly hack. TODO: a line buffer up to length n.
static msg_t putt(void *ip, uint8_t b, systime_t time) {
  (void)time;
  return writes(ip, (char*) &b, 1);
}

// 
static msg_t puttc(void *ip, uint8_t b, systime_t time) {
  (void)time;
  (void)ip;
  fputc(b, stdout);
  fflush(stdout);
  return RDY_OK;
}

// Instantiate BaseSequentialStreamVMT with #define _base_channel_methods
//static const struct BaseSequentialStreamVMT vmt = { 
static const struct BaseChannelVMT vmt = { 
  (void*)writes, // size_t (*write)(void *instance, const uint8_t *bp, size_t n)
  NULL,  // size_t (*read)(void *instance, uint8_t *bp, size_t n);
  NULL, NULL, // would blocks
  (void*)putt, NULL, // put/get
  NULL, NULL  // writet/readt
};

int main(void) {
  uint8_t str1[] = "Raw DeadSemiBeef!\n";
  uint8_t str2[] = "chSequentialStreamWrite Foobar!\n";
  halInit();
  chSysInit();
  
  chThdSleepMilliseconds(500);
  semihostBC.vmt = &vmt;


 /* Raw DeadSemiBeef!
  * Works in all tested configurations as the raw bkpt func.
  */ 
  static uint32_t args[3];
  args[0] = 1;
  args[1] = (uint32_t)str1;
  args[2] = sizeof(str1)-1;
  asm("mov r0, #5\n"
      "mov r1, %0\n"
      "bkpt 0x00ab"  : : "r"(args) : "r0", "r1");  

 /* chSequentialStreamWrite Foobar!
  * Works in all tested configurations as the mapped accessor to the bkpt func.
  */ 
  chSequentialStreamWrite(chp, str2, sizeof(str2)-1);
 /* chprintf Foobar!
  * Prints very slowly with putt and not at all with puttc in VMT.
  * The puttc (newlib-nano) should be one way to satisfy the put requirement
  * for chprintf().
  * Works in -O0, not -O2
  */
  chprintf(chp, "chprintf Foobar!\n");
 /* printf Footbar!
  * Prints in GCC-ARM-Embedded examples, not in ChibiOS.
  * Occasionally hardfaults with other -Ox optimizations than -O0.
  */
  printf("printf Footbar!\n");
  
  return 0;
}