deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Merge pull request #175 from adamdunkels/feature-updated-stm32w

Browse source 
Cleanup and refactorization of the STM32w port
This commit is contained in:
Nicolas Tsiftes 2013-03-19 15:30:31 -07:00
commit 8c25ed20d9
118 changed files with 4470 additions and 4281 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
cpu/stm32w108/Makefile.stm32w108
View file

@ -21,17 +21,17 @@ CONTIKI_CPU=$(CONTIKI)/cpu/stm32w108
CONTIKI_CPU_DIRS = . dev hal simplemac hal/micro/cortexm3 hal/micro/cortexm3/stm32w108
STM32W_C = leds-arch.c leds.c clock.c watchdog.c uart1.c uart1-putchar.c slip_uart1.c slip.c\
stm32w-radio.c stm32w_systick.c uip_arch.c rtimer-arch.c adc.c micro.c sleep.c \
STM32W_C = leds-arch.c leds.c clock.c watchdog.c uart1.c uart1-putchar.c slip-uart1.c slip.c\
stm32w-radio.c stm32w-systick.c uip-arch.c rtimer-arch.c adc.c micro.c sleep.c \
micro-common.c micro-common-internal.c clocks.c mfg-token.c nvm.c flash.c rand.c system-timer.c
STM32W_S = spmr.s79 context-switch.s79
ifdef IAR
STM32W_C += low_level_init.c
STM32W_S += cstartup_M.s
STM32W_C += low-level-init.c
STM32W_S += cstartup-m.s
else
STM32W_C += crt_stm32w108.c
STM32W_C += crt-stm32w108.c
endif
ifdef ELF_LOADER
@ -104,9 +104,14 @@ CFLAGSNO = -mthumb -mcpu=cortex-m3 -D "PLATFORM_HEADER=\"hal/micro/cortexm3/comp
CFLAGS += $(CFLAGSNO) $(OPTI)
ASFLAGS = -mthumb -mcpu=cortex-m3 -c -g -Wall -Os -ffunction-sections \
-mlittle-endian -fshort-enums -x assembler-with-cpp -Wa,-EL
ifndef CPU_LD_CONFIG
CPU_LD_CONFIG=$(CONTIKI_CPU)/gnu.ld
endif # CPU_LD_CONFIG
LDFLAGS += -mcpu=cortex-m3 \
-mthumb \
-Wl,-T -Xlinker $(CONTIKI_CPU)/gnu.ld \
-Wl,-T -Xlinker $(CPU_LD_CONFIG) \
-Wl,-static \
-u Default_Handler \
-nostartfiles \
@ -188,7 +193,6 @@ FLASHEROPTS = -f -i rs232 -p $(PORT) -r
endif
endif
### Custom rules
OBJECTDIR = obj_$(TARGET)
@ -231,7 +235,7 @@ CUSTOM_RULE_LINK = 1
ifdef CORE
ifeq ($(wildcard $(CORE)),)
${error $(CORE) doesn't exist}
${error $(CORE) doesn\'t exist}
endif
.PHONY: symbols.c symbols.h
symbols.c:

49
cpu/stm32w108/board-sensors.h
View file

@ -1,3 +1,39 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
/**
* \file
* Declarations for sensor-related functions that are
@ -7,19 +43,24 @@
* \author Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
#ifndef BOARD_SENSORS_H
#define BOARD_SENSORS_H
/**
* Remember state of sensors (if active or not), in order to
* resume their original state after calling powerUpSensors().
* resume their original state after calling board_sensors_power_up().
* Useful when entering in sleep mode, since all system
* peripherals have to be reinitialized.
*/
void sensorsPowerDown();
void board_sensors_power_down(void);
/**
* Resume the state of all on-board sensors on to the state
* that they had when sensorsPowerDown() was called.
* that they had when board_sensors_power_down() was called.
* Useful when sensors have to be used after the micro was put
* in deep sleep mode.
*/
void sensorsPowerUp();
void board_sensors_power_up(void);
#endif /* BOARD_SENSORS_H */
/** @} */

231
cpu/stm32w108/cfs-coffee-arch.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2009, Swedish Institute of Computer Science
* All rights reserved.
@ -26,8 +32,6 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
@ -38,7 +42,6 @@
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
#include "cfs-coffee-arch.h"
#define DEBUG 1
@ -69,6 +72,7 @@
#define FILE_SIZE 512
/*--------------------------------------------------------------------------*/
int
coffee_file_test(void)
{
@ -83,7 +87,6 @@ coffee_file_test(void)
cfs_remove("T3");
cfs_remove("T4");
cfs_remove("T5");
wfd = rfd = afd = -1;
for(r = 0; r < sizeof(buf); r++) {
@ -139,7 +142,6 @@ coffee_file_test(void)
if(r >= 0) {
FAIL(-6);
}
PRINTF("PASSED\n");
PRINTF("TEST ");
PRINTF("7\n");
@ -276,30 +278,23 @@ coffee_file_test(void)
if(wfd < 0) {
FAIL(-25);
}
offset = random_rand() % FILE_SIZE;
for(r = 0; r < sizeof(buf); r++) {
buf[r] = r;
}
if(cfs_seek(wfd, offset, CFS_SEEK_SET) != offset) {
FAIL(-26);
}
if(cfs_write(wfd, buf, sizeof(buf)) != sizeof(buf)) {
FAIL(-27);
}
if(cfs_seek(wfd, offset, CFS_SEEK_SET) != offset) {
FAIL(-28);
}
memset(buf, 0, sizeof(buf));
if(cfs_read(wfd, buf, sizeof(buf)) != sizeof(buf)) {
FAIL(-29);
}
for(i = 0; i < sizeof(buf); i++) {
if(buf[i] != i) {
PRINTF_CFS("buf[%d] != %d\n", i, buf[i]);
@ -310,18 +305,19 @@ coffee_file_test(void)
PRINTF("PASSED\n");
PRINTF("TEST ");
PRINTF("17\n");
/* Test 17: Append data to the same file many times. */
#define APPEND_BYTES 3000
#define BULK_SIZE 10
for (i = 0; i < APPEND_BYTES; i += BULK_SIZE) {
for(i = 0; i < APPEND_BYTES; i += BULK_SIZE) {
afd = cfs_open("T3", CFS_WRITE | CFS_APPEND);
if (afd < 0) {
if(afd < 0) {
FAIL(-31);
}
for (j = 0; j < BULK_SIZE; j++) {
for(j = 0; j < BULK_SIZE; j++) {
buf[j] = 1 + ((i + j) & 0x7f);
}
if ((r = cfs_write(afd, buf, BULK_SIZE)) != BULK_SIZE) {
if((r = cfs_write(afd, buf, BULK_SIZE)) != BULK_SIZE) {
PRINTF_CFS("Count:%d, r=%d\n", i, r);
FAIL(-32);
}
@ -332,8 +328,7 @@ coffee_file_test(void)
PRINTF("TEST ");
PRINTF("18\n");
/* Test 18: Read back the data written in Test 17 and verify that it
is correct. */
/* Test 18: Read back the data written in Test 17 and verify. */
afd = cfs_open("T3", CFS_READ);
if(afd < 0) {
FAIL(-33);
@ -342,17 +337,17 @@ coffee_file_test(void)
while((r = cfs_read(afd, buf2, sizeof(buf2))) > 0) {
for(j = 0; j < r; j++) {
if(buf2[j] != 1 + ((total_read + j) & 0x7f)) {
FAIL(-34);
FAIL(-34);
}
}
total_read += r;
}
if(r < 0) {
PRINTF_CFS("FAIL:-35 r=%d\n",r);
PRINTF_CFS("FAIL:-35 r=%d\n", r);
FAIL(-35);
}
if(total_read != APPEND_BYTES) {
PRINTF_CFS("FAIL:-35 total_read=%d\n",total_read);
PRINTF_CFS("FAIL:-35 total_read=%d\n", total_read);
FAIL(-35);
}
cfs_close(afd);
@ -361,173 +356,183 @@ coffee_file_test(void)
PRINTF("TEST ");
PRINTF("19\n");
/***************T4********************/
/* file T4 and T5 writing forces to use garbage collector in greedy mode
* this test is designed for 10kb of file system
* */
/* T4 */
/*
* file T4 and T5 writing forces to use garbage collector in greedy mode
* this test is designed for 10kb of file system
*/
#define APPEND_BYTES_1 2000
#define BULK_SIZE_1 10
for (i = 0; i < APPEND_BYTES_1; i += BULK_SIZE_1) {
for(i = 0; i < APPEND_BYTES_1; i += BULK_SIZE_1) {
afd = cfs_open("T4", CFS_WRITE | CFS_APPEND);
if (afd < 0) {
FAIL(-36);
if(afd < 0) {
FAIL(-36);
}
for (j = 0; j < BULK_SIZE_1; j++) {
for(j = 0; j < BULK_SIZE_1; j++) {
buf[j] = 1 + ((i + j) & 0x7f);
}
if ((r = cfs_write(afd, buf, BULK_SIZE_1)) != BULK_SIZE_1) {
PRINTF_CFS("Count:%d, r=%d\n", i, r);
FAIL(-37);
}
cfs_close(afd);
}
if((r = cfs_write(afd, buf, BULK_SIZE_1)) != BULK_SIZE_1) {
PRINTF_CFS("Count:%d, r=%d\n", i, r);
FAIL(-37);
}
cfs_close(afd);
}
afd = cfs_open("T4", CFS_READ);
if(afd < 0) {
FAIL(-38);
}
total_read = 0;
while((r = cfs_read(afd, buf2, sizeof(buf2))) > 0) {
for(j = 0; j < r; j++) {
if(buf2[j] != 1 + ((total_read + j) & 0x7f)) {
PRINTF_CFS("FAIL:-39, total_read=%d r=%d\n",total_read,r);
FAIL(-39);
PRINTF_CFS("FAIL:-39, total_read=%d r=%d\n", total_read, r);
FAIL(-39);
}
}
total_read += r;
}
if(r < 0) {
PRINTF_CFS("FAIL:-40 r=%d\n",r);
PRINTF_CFS("FAIL:-40 r=%d\n", r);
FAIL(-40);
}
if(total_read != APPEND_BYTES_1) {
PRINTF_CFS("FAIL:-41 total_read=%d\n",total_read);
PRINTF_CFS("FAIL:-41 total_read=%d\n", total_read);
FAIL(-41);
}
cfs_close(afd);
/***************T5********************/
/* T5 */
PRINTF("PASSED\n");
PRINTF("TEST ");
PRINTF("20\n");
#define APPEND_BYTES_2 1000
#define BULK_SIZE_2 10
for (i = 0; i < APPEND_BYTES_2; i += BULK_SIZE_2) {
afd = cfs_open("T5", CFS_WRITE | CFS_APPEND);
if (afd < 0) {
FAIL(-42);
}
for (j = 0; j < BULK_SIZE_2; j++) {
buf[j] = 1 + ((i + j) & 0x7f);
}
if ((r = cfs_write(afd, buf, BULK_SIZE_2)) != BULK_SIZE_2) {
PRINTF_CFS("Count:%d, r=%d\n", i, r);
FAIL(-43);
}
cfs_close(afd);
}
afd = cfs_open("T5", CFS_READ);
for(i = 0; i < APPEND_BYTES_2; i += BULK_SIZE_2) {
afd = cfs_open("T5", CFS_WRITE | CFS_APPEND);
if(afd < 0) {
FAIL(-44);
FAIL(-42);
}
total_read = 0;
while((r = cfs_read(afd, buf2, sizeof(buf2))) > 0) {
for(j = 0; j < r; j++) {
if(buf2[j] != 1 + ((total_read + j) & 0x7f)) {
PRINTF_CFS("FAIL:-45, total_read=%d r=%d\n",total_read,r);
FAIL(-45);
}
}
total_read += r;
for(j = 0; j < BULK_SIZE_2; j++) {
buf[j] = 1 + ((i + j) & 0x7f);
}
if(r < 0) {
PRINTF_CFS("FAIL:-46 r=%d\n",r);
FAIL(-46);
}
if(total_read != APPEND_BYTES_2) {
PRINTF_CFS("FAIL:-47 total_read=%d\n",total_read);
FAIL(-47);
}
cfs_close(afd);
PRINTF("PASSED\n");
if((r = cfs_write(afd, buf, BULK_SIZE_2)) != BULK_SIZE_2) {
PRINTF_CFS("Count:%d, r=%d\n", i, r);
FAIL(-43);
}
cfs_close(afd);
}
afd = cfs_open("T5", CFS_READ);
if(afd < 0) {
FAIL(-44);
}
total_read = 0;
while((r = cfs_read(afd, buf2, sizeof(buf2))) > 0) {
for(j = 0; j < r; j++) {
if(buf2[j] != 1 + ((total_read + j) & 0x7f)) {
PRINTF_CFS("FAIL:-45, total_read=%d r=%d\n", total_read, r);
FAIL(-45);
}
}
total_read += r;
}
if(r < 0) {
PRINTF_CFS("FAIL:-46 r=%d\n", r);
FAIL(-46);
}
if(total_read != APPEND_BYTES_2) {
PRINTF_CFS("FAIL:-47 total_read=%d\n", total_read);
FAIL(-47);
}
cfs_close(afd);
PRINTF("PASSED\n");
error = 0;
end:
cfs_close(wfd); cfs_close(rfd); cfs_close(afd);
cfs_close(wfd);
cfs_close(rfd);
cfs_close(afd);
return error;
}
#endif /* TESTCOFFEE */
void stm32w_flash_read(int32u address, void * data, int32u length)
/*--------------------------------------------------------------------------*/
void
stm32w_flash_read(uint32_t address, void *data, uint32_t length)
{
int8u * pdata = (int8u *)address;
uint8_t *pdata = (uint8_t *) address;
ENERGEST_ON(ENERGEST_TYPE_FLASH_READ);
memcpy(data, pdata, length);
ENERGEST_OFF(ENERGEST_TYPE_FLASH_READ);
}
void stm32w_flash_erase(int8u sector)
/*--------------------------------------------------------------------------*/
void
stm32w_flash_erase(uint8_t sector)
{
//halInternalFlashErase(MFB_PAGE_ERASE, COFFEE_START + (sector) * COFFEE_SECTOR_SIZE);
int16u data = 0;
int32u addr = COFFEE_START + (sector) * COFFEE_SECTOR_SIZE;
int32u end = addr + COFFEE_SECTOR_SIZE;
/* halInternalFlashErase(MFB_PAGE_ERASE, COFFEE_START +
(sector) * COFFEE_SECTOR_SIZE); */
uint16_t data = 0;
uint32_t addr = COFFEE_START + (sector) * COFFEE_SECTOR_SIZE;
uint32_t end = addr + COFFEE_SECTOR_SIZE;
/* This prevents from accidental write to CIB. */
if (!(addr >= MFB_BOTTOM && end <= MFB_TOP + 1)) {
if(!(addr >= MFB_BOTTOM && end <= MFB_TOP + 1)) {
return;
}
for(; addr < end; addr += 2){
for(; addr < end; addr += 2) {
halInternalFlashWrite(addr, &data, 1);
}
}
// Allocates a buffer of FLASH_PAGE_SIZE bytes statically (rather than on the stack).
/*--------------------------------------------------------------------------*/
/*
* Allocates a buffer of FLASH_PAGE_SIZE bytes statically (rather than on
* the stack).
*/
#ifndef STATIC_FLASH_BUFFER
#define STATIC_FLASH_BUFFER 1
#define STATIC_FLASH_BUFFER 1
#endif
void stm32w_flash_write(int32u address, const void * data, int32u length)
void
stm32w_flash_write(uint32_t address, const void *data, uint32_t length)
{
const int32u end = address + length;
int32u i;
int32u next_page, curr_page;
int16u offset;
const uint32_t end = address + length;
uint32_t i;
uint32_t next_page, curr_page;
uint16_t offset;
#if STATIC_FLASH_BUFFER
static int8u buf[FLASH_PAGE_SIZE];
static uint8_t buf[FLASH_PAGE_SIZE];
#else
int8u buf[FLASH_PAGE_SIZE];
uint8_t buf[FLASH_PAGE_SIZE];
#endif
for(i = address; i < end;) {
next_page = (i | (FLASH_PAGE_SIZE-1)) + 1;
curr_page = i & ~(FLASH_PAGE_SIZE-1);
offset = i-curr_page;
next_page = (i | (FLASH_PAGE_SIZE - 1)) + 1;
curr_page = i & ~(FLASH_PAGE_SIZE - 1);
offset = i - curr_page;
if(next_page > end) {
next_page = end;
}
// Read a page from flash and put it into a mirror buffer.
/* Read a page from flash and put it into a mirror buffer. */
stm32w_flash_read(curr_page, buf, FLASH_PAGE_SIZE);
// Update flash mirror data with new data.
/* Update flash mirror data with new data. */
memcpy(buf + offset, data, next_page - i);
// Erase flash page.
/* Erase flash page. */
ENERGEST_ON(ENERGEST_TYPE_FLASH_WRITE);
halInternalFlashErase(MFB_PAGE_ERASE, i);
// Write modified data form mirror buffer into the flash.
halInternalFlashWrite(curr_page, (int16u *)buf, FLASH_PAGE_SIZE/2);
/* Write modified data form mirror buffer into the flash. */
halInternalFlashWrite(curr_page, (uint16_t *) buf, FLASH_PAGE_SIZE / 2);
ENERGEST_OFF(ENERGEST_TYPE_FLASH_WRITE);
data = (uint8_t *)data + next_page - i;
data = (uint8_t *) data + next_page - i;
i = next_page;
}
}
/** @} */

63
cpu/stm32w108/cfs-coffee-arch.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -26,15 +32,12 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
* \file
* Coffee architecture-dependent header for the STM32W108-based mb851
* platform.
* STM32W108 has 128KB of program flash.
* platform. STM32W108 has 128KB of program flash.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
@ -47,32 +50,34 @@
#include "hal/error.h"
#include "hal/micro/cortexm3/flash.h"
/* STM32W108 has 128 pages of 1024 bytes each = 128KB
/*
* STM32W108 has 128KB of program flash in 128 pages of 1024 bytes each = 128KB.
* The smallest erasable unit is one page and the smallest writable
* unit is an aligned 16-bit half-word.
*/
/* Byte page size, starting address on page boundary, and size of the file system */
/* Byte page size, starting address on page boundary, and size of file system */
#define FLASH_START 0x8000000
/* Minimum erasable unit. */
#define FLASH_PAGE_SIZE 1024
/* Last 3 pages reserved for NVM. */
#define FLASH_PAGES 125
/* Minimum reservation unit for Coffee. It can be changed by the user. */
#define COFFEE_PAGE_SIZE (FLASH_PAGE_SIZE/4)
/* If using IAR, COFFEE_ADDRESS reflects the static value in the linker script
iar-cfg-coffee.icf, so it can't be passed as a parameter for Make.*/
/*
* If using IAR, COFFEE_ADDRESS reflects the static value in the linker script
* iar-cfg-coffee.icf, so it can't be passed as a parameter for Make.
*/
#ifdef __ICCARM__
#define COFFEE_ADDRESS 0x8010c00
#endif
#if (COFFEE_ADDRESS & 0x3FF) !=0
#error "COFFEE_ADDRESS not aligned to a 1024-bytes page boundary."
#if (COFFEE_ADDRESS & 0x3FF) != 0
#error "COFFEE_ADDRESS not aligned to a 1024-bytes page boundary."
#endif
#define COFFEE_PAGES ((FLASH_PAGES*FLASH_PAGE_SIZE-(COFFEE_ADDRESS-FLASH_START))/COFFEE_PAGE_SIZE)
#define COFFEE_PAGES ((FLASH_PAGES*FLASH_PAGE_SIZE- \
(COFFEE_ADDRESS-FLASH_START))/COFFEE_PAGE_SIZE)
#define COFFEE_START (COFFEE_ADDRESS & ~(COFFEE_PAGE_SIZE-1))
#define COFFEE_SIZE (COFFEE_PAGES*COFFEE_PAGE_SIZE)
@ -80,21 +85,23 @@
#define COFFEE_SECTOR_SIZE FLASH_PAGE_SIZE
#define COFFEE_NAME_LENGTH 20
///* These are used internally by the AVR flash read routines */
///* Word reads are faster but take 130 bytes more PROGMEM */
//#define FLASH_WORD_READS 1
///* 1=Slower reads, but no page writes after erase and 18 bytes less PROGMEM. Best for dynamic file system */
//#define FLASH_COMPLEMENT_DATA 0
/* These are used internally by the AVR flash read routines */
/* Word reads are faster but take 130 bytes more PROGMEM */
/* #define FLASH_WORD_READS 1 */
/*
* 1 = Slower reads, but no page writes after erase and 18 bytes less PROGMEM.
* Best for dynamic file system
*/
/* #define FLASH_COMPLEMENT_DATA 0 */
/* These are used internally by the coffee file system */
/* Micro logs are not needed for single page sectors */
#define COFFEE_MAX_OPEN_FILES 4
#define COFFEE_FD_SET_SIZE 8
#define COFFEE_DYN_SIZE (COFFEE_PAGE_SIZE*1)
/* Micro logs are not needed for single page sectors */
#define COFFEE_MICRO_LOGS 0
#define COFFEE_LOG_TABLE_LIMIT 16 // It doesnt' matter as
#define COFFEE_LOG_SIZE 128 // COFFEE_MICRO_LOGS is 0.
#define COFFEE_LOG_TABLE_LIMIT 16 /* It doesnt' matter as */
#define COFFEE_LOG_SIZE 128 /* COFFEE_MICRO_LOGS is 0. */
#if COFFEE_PAGES <= 127
#define coffee_page_t int8_t
@ -102,7 +109,6 @@
#define coffee_page_t int16_t
#endif
#define COFFEE_WRITE(buf, size, offset) \
stm32w_flash_write(COFFEE_START + offset, buf, size)
@ -113,10 +119,13 @@
stm32w_flash_erase(sector)
void stm32w_flash_read(int32u address, void * data, int32u length);
void stm32w_flash_write(int32u address, const void * data, int32u length);
void stm32w_flash_erase(int8u sector);
void stm32w_flash_read(uint32_t address, void *data, uint32_t length);
void stm32w_flash_write(uint32_t address, const void *data, uint32_t length);
void stm32w_flash_erase(uint8_t sector);
int coffee_file_test(void);
#endif /* !COFFEE_ARCH_H */
/** @} */

97
cpu/stm32w108/clock.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,22 +33,20 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Clock.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include PLATFORM_HEADER
#include <stdio.h>
#include "hal/error.h"
#include "hal/hal.h"
#include "dev/stm32w_systick.h"
#include "dev/stm32w-systick.h"
#include "contiki.h"
#include "sys/clock.h"
@ -54,24 +58,23 @@
#define DEBUG DEBUG_NONE
#include "net/uip-debug.h"
/*--------------------------------------------------------------------------*/
/* The value that will be load in the SysTick value register. */
#define RELOAD_VALUE 24000-1 /* 1 ms with a 24 MHz clock */
#define RELOAD_VALUE 24000-1 /* 1 ms with a 24 MHz clock */
static volatile clock_time_t count;
static volatile unsigned long current_seconds = 0;
static unsigned int second_countdown = CLOCK_SECOND;
/*---------------------------------------------------------------------------*/
void
SysTick_Handler(void)
{
count++;
if(etimer_pending()) {
etimer_request_poll();
}
if (--second_countdown == 0) {
if(--second_countdown == 0) {
current_seconds++;
second_countdown = CLOCK_SECOND;
}
@ -81,19 +84,13 @@ SysTick_Handler(void)
void
clock_init(void)
{
ATOMIC(
//Counts the number of ticks.
count = 0;
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
SysTick_SetReload(RELOAD_VALUE);
SysTick_ITConfig(ENABLE);
SysTick_CounterCmd(SysTick_Counter_Enable);
)
/* Counts the number of ticks. */
count = 0;
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
SysTick_SetReload(RELOAD_VALUE);
SysTick_ITConfig(ENABLE);
SysTick_CounterCmd(SysTick_Counter_Enable);)
}
/*---------------------------------------------------------------------------*/
clock_time_t
@ -108,16 +105,16 @@ clock_time(void)
void
clock_delay(unsigned int i)
{
for (; i > 0; i--) { /* Needs fixing XXX */
for(; i > 0; i--) { /* Needs fixing XXX */
unsigned j;
for (j = 50; j > 0; j--)
asm ("nop");
for(j = 50; j > 0; j--) {
asm("nop");
}
}
}
/*---------------------------------------------------------------------------*/
/**
* Wait for a multiple of 1 ms.
*
*/
void
clock_wait(clock_time_t i)
@ -125,7 +122,7 @@ clock_wait(clock_time_t i)
clock_time_t start;
start = clock_time();
while(clock_time() - start < (clock_time_t)i);
while(clock_time() - start < (clock_time_t) i);
}
/*---------------------------------------------------------------------------*/
unsigned long
@ -133,49 +130,5 @@ clock_seconds(void)
{
return current_seconds;
}
#include <stdio.h>
void
sleep_seconds(int seconds)
{
int32u quarter_seconds = seconds * 4;
uint8_t radio_on;
halPowerDown();
radio_on = stm32w_radio_is_on();
stm32w_radio_driver.off();
halSleepForQsWithOptions(&quarter_seconds, 0);
ATOMIC(
halPowerUp();
/* Update OS system ticks. */
current_seconds += seconds - quarter_seconds / 4 ; /* Passed seconds */
count += seconds * CLOCK_SECOND - quarter_seconds * CLOCK_SECOND / 4 ;
if(etimer_pending()) {
etimer_request_poll();
}
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK);
SysTick_SetReload(RELOAD_VALUE);
SysTick_ITConfig(ENABLE);
SysTick_CounterCmd(SysTick_Counter_Enable);
)
stm32w_radio_driver.init();
if(radio_on) {
stm32w_radio_driver.on();
}
uart1_init(115200);
leds_init();
rtimer_init();
PRINTF("WakeInfo: %04x\r\n", halGetWakeInfo());
}
/*--------------------------------------------------------------------------*/
/** @} */

23
cpu/stm32w108/dev/cortexm3_macro.h → cpu/stm32w108/dev/cortexm3-macro.h
View file

@ -1,5 +1,11 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : cortexm3_macro.h
* File Name : cortexm3-macro.h
* Author : MCD Application Team
* Version : V2.0.3
* Date : 09/22/2008
@ -13,17 +19,11 @@
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __CORTEXM3_MACRO_H
#define __CORTEXM3_MACRO_H
/* Includes ------------------------------------------------------------------*/
#include "stm32w_type.h"
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
void __WFI(void);
void __WFE(void);
void __SEV(void);
@ -31,23 +31,30 @@ void __ISB(void);
void __DSB(void);
void __DMB(void);
void __SVC(void);
u32 __MRS_CONTROL(void);
void __MSR_CONTROL(u32 Control);
u32 __MRS_PSP(void);
void __MSR_PSP(u32 TopOfProcessStack);
u32 __MRS_MSP(void);
void __MSR_MSP(u32 TopOfMainStack);
void __RESETPRIMASK(void);
void __SETPRIMASK(void);
u32 __READ_PRIMASK(void);
void __RESETFAULTMASK(void);
void __SETFAULTMASK(void);
u32 __READ_FAULTMASK(void);
void __BASEPRICONFIG(u32 NewPriority);
u32 __GetBASEPRI(void);
u16 __REV_HalfWord(u16 Data);
u32 __REV_Word(u32 Data);
#endif /* __CORTEXM3_MACRO_H */
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
/** @} */

227
cpu/stm32w108/dev/stm32w-conf.h Normal file
View file

@ -0,0 +1,227 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32w-conf.h
* Author : MCD Application Team
* Version : V2.0.3
* Date : 09/22/2008
* Description : Library configuration file.
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
#ifndef __STM32F10x_CONF_H
#define __STM32F10x_CONF_H
#include "stm32w108-type.h"
/*
* Uncomment the line below to compile the library in DEBUG mode, this will
* expand the "assert_param" macro in the firmware library code (see "Exported
* macro" section below)
*/
/*#define DEBUG 1*/
/*---------------------------------------------------------------------------*/
/* Comment any line below to disable the specific peripheral inclusion */
/*
* ADC
*/
/* #define _ADC */
/* #define _ADC1 */
/* #define _ADC2 */
/* #define _ADC3 */
/*
* BKP
*/
/* #define _BKP */
/*
* CAN
*/
/* #define _CAN */
/*
* CRC
*/
/* #define _CRC */
/*
* DAC
*/
/* #define _DAC */
/*
* DBGMCU
*/
/* #define _DBGMCU */
/*
* DMA
*/
/* #define _DMA */
/* #define _DMA1_Channel1 */
/* #define _DMA1_Channel2 */
/* #define _DMA1_Channel3 */
/* #define _DMA1_Channel4 */
/* #define _DMA1_Channel5 */
/* #define _DMA1_Channel6 */
/* #define _DMA1_Channel7 */
/* #define _DMA2_Channel1 */
/* #define _DMA2_Channel2 */
/* #define _DMA2_Channel3 */
/* #define _DMA2_Channel4 */
/* #define _DMA2_Channel5 */
/*
* EXTI
*/
/* #define _EXTI */
/*
* FLASH and Option Bytes
*/
#define _FLASH
/*
* Uncomment the line below to enable FLASH program/erase/protections functions,
* otherwise only FLASH configuration (latency, prefetch, half cycle) functions
* are enabled
*/
/* #define _FLASH_PROG */
/*
* FSMC
*/
/* #define _FSMC */
/*
* GPIO
*/
#define _GPIO
/* #define _GPIOA */
/* #define _GPIOB */
#define _GPIOC
/* #define _GPIOD */
/* #define _GPIOE */
#define _GPIOF
/* #define _GPIOG */
#define _AFIO
/*
* I2C
*/
/* #define _I2C */
/* #define _I2C1 */
/* #define _I2C2 */
/*
* IWDG
*/
/* #define _IWDG */
/*
* NVIC
*/
#define _NVIC
/*
* PWR
*/
/* #define _PWR */
/*
* RCC
*/
#define _RCC
/*
* RTC
*/
/* #define _RTC */
/*
* SDIO
*/
/* #define _SDIO */
/*
* SPI
*/
/* #define _SPI */
/* #define _SPI1 */
/* #define _SPI2 */
/* #define _SPI3 */
/*
* SysTick
*/
#define _SysTick
/*
* TIM
*/
/* #define _TIM */
/* #define _TIM1 */
/* #define _TIM2 */
/* #define _TIM3 */
/* #define _TIM4 */
/* #define _TIM5 */
/* #define _TIM6 */
/* #define _TIM7 */
/* #define _TIM8 */
/*
* USART
*/
/* #define _USART */
/* #define _USART1 */
/* #define _USART2 */
/* #define _USART3 */
/* #define _UART4 */
/* #define _UART5 */
/*
* WWDG
*/
/* #define _WWDG */
/*
* In the following line adjust the value of External High Speed oscillator
* (HSE) used in your application
*/
#define HSE_Value ((u32)8000000) /* Value of the External oscillator in Hz */
/*
* In the following line adjust the External High Speed oscillator (HSE) Startup
* Timeout value.
*/
#define HSEStartUp_TimeOut ((u16)0x0500) /* Time out for HSE start up */
#ifdef DEBUG
/**
* \brief The assert_param macro is used for function's parameters check.
* It is used only if the library is compiled in DEBUG mode.
* \param expr If expr is false, it calls assert_failed function
* which reports the name of the source file and the source
* line number of the call that failed.
* If expr is true, it returns no value.
*/
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((u8 *)__FILE__, __LINE__))
void assert_failed(u8 * file, u32 line);
#else
#define assert_param(expr) ((void)0)
#endif /* DEBUG */
#endif /* __STM32F10x_CONF_H */
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
/** @} */

651
cpu/stm32w108/dev/stm32w-radio.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,10 +33,8 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Machine dependent STM32W radio code.
@ -39,7 +43,6 @@
* Chi-Anh La la@imag.fr
* Simon Duquennoy <simonduq@sics.se>
*/
/*---------------------------------------------------------------------------*/
#include PLATFORM_HEADER
#include "hal/error.h"
@ -72,39 +75,38 @@
#define LED_ACTIVITY 1
#else
#define LED_RDC 0
#endif
#endif /* RDC_CONF_DEBUG_LED */
#if DEBUG > 0
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...) do {} while (0)
#endif
#endif /* DEBUG > 0 */
#if LED_ACTIVITY
#define LED_TX_ON() leds_on(LEDS_GREEN)
#define LED_TX_OFF() leds_off(LEDS_GREEN)
#define LED_RX_ON() { \
#define LED_RX_ON() do { \
if(LED_RDC == 0){ \
leds_on(LEDS_RED); \
} \
}
#define LED_RX_OFF() { \
} while (0)
#define LED_RX_OFF() do { \
if(LED_RDC == 0){ \
leds_off(LEDS_RED); \
leds_off(LEDS_RED); \
} \
}
#define LED_RDC_ON() { \
} while (0)
#define LED_RDC_ON() do { \
if(LED_RDC == 1){ \
leds_on(LEDS_RED); \
} \
}
#define LED_RDC_OFF() { \
} while (0)
#define LED_RDC_OFF() do { \
if(LED_RDC == 1){ \
leds_off(LEDS_RED); \
leds_off(LEDS_RED); \
} \
}
} while (0)
#else
#define LED_TX_ON()
#define LED_TX_OFF()
@ -112,63 +114,59 @@
#define LED_RX_OFF()
#define LED_RDC_ON()
#define LED_RDC_OFF()
#endif
#endif /* LED_ACTIVITY */
#if RDC_CONF_HARDWARE_CSMA
#define MAC_RETRIES 0
#endif
#endif /* RDC_CONF_HARDWARE_CSMA */
#ifndef MAC_RETRIES
#define MAC_RETRIES 1
#endif
#endif /* MAC_RETRIES */
#if MAC_RETRIES
int8_t mac_retries_left;
#define INIT_RETRY_CNT() (mac_retries_left = packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS))
#define DEC_RETRY_CNT() (mac_retries_left--)
#define RETRY_CNT_GTZ() (mac_retries_left > 0)
int8_t mac_retries_left;
#define INIT_RETRY_CNT() (mac_retries_left = packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS))
#define DEC_RETRY_CNT() (mac_retries_left--)
#define RETRY_CNT_GTZ() (mac_retries_left > 0)
#else
#define INIT_RETRY_CNT()
#define DEC_RETRY_CNT()
#define RETRY_CNT_GTZ() 0
#endif
#define INIT_RETRY_CNT()
#define DEC_RETRY_CNT()
#define RETRY_CNT_GTZ() 0
#endif /* MAC_RETRIES */
/* If set to 1, a send() returns only after the packet has been transmitted.
This is necessary if you use the x-mac module, for example. */
#ifndef RADIO_WAIT_FOR_PACKET_SENT
#define RADIO_WAIT_FOR_PACKET_SENT 1
#endif
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
#define TO_PREV_STATE() { \
#define TO_PREV_STATE() do { \
if(onoroff == OFF){ \
ST_RadioSleep(); \
ENERGEST_OFF(ENERGEST_TYPE_LISTEN); \
} \
}
} while(0)
#if RDC_CONF_HARDWARE_CSMA
#define ST_RADIO_CHECK_CCA FALSE
#define ST_RADIO_CCA_ATTEMPT_MAX 0
#define ST_BACKOFF_EXP_MIN 0
#define ST_BACKOFF_EXP_MAX 0
#else
#else /* RDC_CONF_HARDWARE_CSMA */
#define ST_RADIO_CHECK_CCA TRUE
#define ST_RADIO_CCA_ATTEMPT_MAX 4
#define ST_BACKOFF_EXP_MIN 2
#define ST_BACKOFF_EXP_MAX 6
#endif
#endif /* RDC_CONF_HARDWARE_CSMA */
const RadioTransmitConfig radioTransmitConfig = {
TRUE, // waitForAck;
ST_RADIO_CHECK_CCA, // checkCca; // Set to FALSE with low-power MACs.
ST_RADIO_CCA_ATTEMPT_MAX, // ccaAttemptMax;
ST_BACKOFF_EXP_MIN, // backoffExponentMin;
ST_BACKOFF_EXP_MAX, // backoffExponentMax;
TRUE // appendCrc;
TRUE, /* waitForAck; */
ST_RADIO_CHECK_CCA, /* checkCca;Set to FALSE with low-power MACs. */
ST_RADIO_CCA_ATTEMPT_MAX, /* ccaAttemptMax; */
ST_BACKOFF_EXP_MIN, /* backoffExponentMin; */
ST_BACKOFF_EXP_MAX, /* backoffExponentMax; */
TRUE /* appendCrc; */
};
#define MAC_RETRIES 0
@ -178,38 +176,38 @@ const RadioTransmitConfig radioTransmitConfig = {
*/
#ifndef RADIO_RXBUFS
#define RADIO_RXBUFS 1
#endif
#endif /* RADIO_RXBUFS */
static uint8_t stm32w_rxbufs[RADIO_RXBUFS][STM32W_MAX_PACKET_LEN+1]; // +1 because of the first byte, which will contain the length of the packet.
/* +1 because of the first byte, which will contain the length of the packet. */
static uint8_t stm32w_rxbufs[RADIO_RXBUFS][STM32W_MAX_PACKET_LEN + 1];
#if RADIO_RXBUFS > 1
static volatile int8_t first = -1, last=0;
#else
static const int8_t first=0, last=0;
#endif
static volatile int8_t first = -1, last = 0;
#else /* RADIO_RXBUFS > 1 */
static const int8_t first = 0, last = 0;
#endif /* RADIO_RXBUFS > 1 */
#if RADIO_RXBUFS > 1
#define CLEAN_RXBUFS() do{first = -1; last = 0;}while(0)
#define RXBUFS_EMPTY() (first == -1)
int RXBUFS_FULL(){
int8_t first_tmp = first;
return first_tmp == last;
#define CLEAN_RXBUFS() do{first = -1; last = 0;}while(0)
#define RXBUFS_EMPTY() (first == -1)
int
RXBUFS_FULL()
{
int8_t first_tmp = first;
return first_tmp == last;
}
#else /* RADIO_RXBUFS > 1 */
#define CLEAN_RXBUFS() (stm32w_rxbufs[0][0] = 0)
#define RXBUFS_EMPTY() (stm32w_rxbufs[0][0] == 0)
#define RXBUFS_FULL() (stm32w_rxbufs[0][0] != 0)
#define CLEAN_RXBUFS() (stm32w_rxbufs[0][0] = 0)
#define RXBUFS_EMPTY() (stm32w_rxbufs[0][0] == 0)
#define RXBUFS_FULL() (stm32w_rxbufs[0][0] != 0)
#endif /* RADIO_RXBUFS > 1 */
static uint8_t __attribute__(( aligned(2) )) stm32w_txbuf[STM32W_MAX_PACKET_LEN+1];
static uint8_t
__attribute__ ((aligned(2))) stm32w_txbuf[STM32W_MAX_PACKET_LEN + 1];
#define CLEAN_TXBUF() (stm32w_txbuf[0] = 0)
#define TXBUF_EMPTY() (stm32w_txbuf[0] == 0)
#define CHECKSUM_LEN 2
/*
@ -218,65 +216,76 @@ static uint8_t __attribute__(( aligned(2) )) stm32w_txbuf[STM32W_MAX_PACKET_LEN+
#define ON 0
#define OFF 1
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))); \
} while(0)
#define GET_LOCK() locked++
static volatile uint8_t onoroff = OFF;
static uint8_t receiving_packet = 0;
static s8 last_rssi;
static int8_t last_rssi;
static volatile StStatus last_tx_status;
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))); \
} while(0)
static uint8_t locked;
#define GET_LOCK() locked++
static void RELEASE_LOCK(void) {
if(locked>0)
locked--;
}
static volatile uint8_t is_transmit_ack;
/*--------------------------------------------------------------------------*/
static void
RELEASE_LOCK(void)
{
if(locked > 0)
locked--;
}
/*---------------------------------------------------------------------------*/
PROCESS(stm32w_radio_process, "STM32W radio driver");
/*---------------------------------------------------------------------------*/
static int stm32w_radio_init(void);
static int stm32w_radio_prepare(const void *payload, unsigned short payload_len);
static int stm32w_radio_prepare(const void *payload,
unsigned short payload_len);
static int stm32w_radio_transmit(unsigned short payload_len);
static int stm32w_radio_send(const void *data, unsigned short len);
static int stm32w_radio_read(void *buf, unsigned short bufsize);
static int stm32w_radio_channel_clear(void);
static int stm32w_radio_receiving_packet(void);
static int stm32w_radio_pending_packet(void);
static int stm32w_radio_on(void);
static int stm32w_radio_off(void);
static int add_to_rxbuf(uint8_t * src);
static int read_from_rxbuf(void * dest, unsigned short len);
const struct radio_driver stm32w_radio_driver =
{
stm32w_radio_init,
stm32w_radio_prepare,
stm32w_radio_transmit,
stm32w_radio_send,
stm32w_radio_read,
stm32w_radio_channel_clear,
stm32w_radio_receiving_packet,
stm32w_radio_pending_packet,
stm32w_radio_on,
stm32w_radio_off,
};
static int read_from_rxbuf(void *dest, unsigned short len);
/*--------------------------------------------------------------------------*/
const struct radio_driver stm32w_radio_driver = {
stm32w_radio_init,
stm32w_radio_prepare,
stm32w_radio_transmit,
stm32w_radio_send,
stm32w_radio_read,
stm32w_radio_channel_clear,
stm32w_radio_receiving_packet,
stm32w_radio_pending_packet,
stm32w_radio_on,
stm32w_radio_off,
};
/*---------------------------------------------------------------------------*/
static int stm32w_radio_init(void)
static int
stm32w_radio_init(void)
{
// A channel needs also to be setted.
/* A channel also needs to be set. */
ST_RadioSetChannel(RF_CHANNEL);
// Initialize radio (analog section, digital baseband and MAC).
// Leave radio powered up in non-promiscuous rx mode.
/* Initialize radio (analog section, digital baseband and MAC). */
/* Leave radio powered up in non-promiscuous rx mode. */
ST_RadioInit(ST_RADIO_POWER_MODE_OFF);
onoroff = OFF;
@ -297,172 +306,185 @@ static int stm32w_radio_init(void)
return 0;
}
/*---------------------------------------------------------------------------*/
int stm32w_radio_set_channel(uint8_t channel)
void
stm32w_radio_set_promiscous(uint8_t on)
{
if (ST_RadioSetChannel(channel) == ST_SUCCESS)
return 0;
else
return 1;
if(on) {
ST_RadioEnableAddressFiltering(0);
} else {
ST_RadioEnableAddressFiltering(ST_RADIO_AUTOACK);
}
}
/*---------------------------------------------------------------------------*/
static int wait_for_tx(void){
int
stm32w_radio_set_channel(uint8_t channel)
{
if (ST_RadioSetChannel(channel) == ST_SUCCESS) {
return 0;
} else {
return 1;
}
}
/*---------------------------------------------------------------------------*/
static int
wait_for_tx(void)
{
struct timer t;
timer_set(&t, CLOCK_SECOND/10);
while(!TXBUF_EMPTY()){
if(timer_expired(&t)){
timer_set(&t, CLOCK_SECOND / 10);
while(!TXBUF_EMPTY()) {
if(timer_expired(&t)) {
PRINTF("stm32w: tx buffer full.\r\n");
return 1;
}
/* Put CPU in sleep mode. */
halSleepWithOptions(SLEEPMODE_IDLE,0);
halSleepWithOptions(SLEEPMODE_IDLE, 0);
}
return 0;
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_prepare(const void *payload, unsigned short payload_len)
static int
stm32w_radio_prepare(const void *payload, unsigned short payload_len)
{
if(payload_len > STM32W_MAX_PACKET_LEN){
PRINTF("stm32w: payload length=%d is too long.\r\n", payload_len);
return RADIO_TX_ERR;
}
if(payload_len > STM32W_MAX_PACKET_LEN) {
PRINTF("stm32w: payload length=%d is too long.\r\n", payload_len);
return RADIO_TX_ERR;
}
#if !RADIO_WAIT_FOR_PACKET_SENT
/* Check if the txbuf is empty.
* Wait for a finite time.
* This sould not occur if we wait for the end of transmission in stm32w_radio_transmit().
*/
if(wait_for_tx()){
PRINTF("stm32w: tx buffer full.\r\n");
return RADIO_TX_ERR;
}
/*
* Check if the txbuf is empty. Wait for a finite time.
* This should not occur if we wait for the end of transmission in
* stm32w_radio_transmit().
*/
if(wait_for_tx()) {
PRINTF("stm32w: tx buffer full.\r\n");
return RADIO_TX_ERR;
}
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
/* Copy to the txbuf.
* The first byte must be the packet length.
*/
CLEAN_TXBUF();
memcpy(stm32w_txbuf + 1, payload, payload_len);
return RADIO_TX_OK;
/*
* Copy to the txbuf.
* The first byte must be the packet length.
*/
CLEAN_TXBUF();
memcpy(stm32w_txbuf + 1, payload, payload_len);
return RADIO_TX_OK;
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_transmit(unsigned short payload_len)
static int
stm32w_radio_transmit(unsigned short payload_len)
{
stm32w_txbuf[0] = payload_len + CHECKSUM_LEN;
INIT_RETRY_CNT();
if(onoroff == OFF){
PRINTF("stm32w: Radio is off, turning it on.\r\n");
ST_RadioWake();
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
stm32w_txbuf[0] = payload_len + CHECKSUM_LEN;
INIT_RETRY_CNT();
if(onoroff == OFF) {
PRINTF("stm32w: Radio is off, turning it on.\r\n");
ST_RadioWake();
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
}
#if RADIO_WAIT_FOR_PACKET_SENT
GET_LOCK();
GET_LOCK();
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
last_tx_status = -1;
LED_TX_ON();
if(ST_RadioTransmit(stm32w_txbuf)==ST_SUCCESS){
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
PRINTF("stm32w: sending %d bytes\r\n", payload_len);
last_tx_status = -1;
LED_TX_ON();
if(ST_RadioTransmit(stm32w_txbuf) == ST_SUCCESS) {
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
PRINTF("stm32w: sending %d bytes\r\n", payload_len);
#if DEBUG > 1
for(uint8_t c=1; c <= stm32w_txbuf[0]-2; c++){
PRINTF("%x:",stm32w_txbuf[c]);
}
PRINTF("\r\n");
for(uint8_t c = 1; c <= stm32w_txbuf[0] - 2; c++) {
PRINTF("%x:", stm32w_txbuf[c]);
}
PRINTF("\r\n");
#endif
#if RADIO_WAIT_FOR_PACKET_SENT
if(wait_for_tx()){
PRINTF("stm32w: unknown tx error.\r\n");
TO_PREV_STATE();
LED_TX_OFF();
RELEASE_LOCK();
return RADIO_TX_ERR;
}
if(wait_for_tx()) {
PRINTF("stm32w: unknown tx error.\r\n");
TO_PREV_STATE();
if(last_tx_status == ST_SUCCESS || last_tx_status == ST_PHY_ACK_RECEIVED || last_tx_status == ST_MAC_NO_ACK_RECEIVED){
RELEASE_LOCK();
if(last_tx_status == ST_PHY_ACK_RECEIVED){
return RADIO_TX_OK; /* ACK status */
}
else if (last_tx_status == ST_MAC_NO_ACK_RECEIVED || last_tx_status == ST_SUCCESS){
return RADIO_TX_NOACK;
}
}
LED_TX_OFF();
RELEASE_LOCK();
return RADIO_TX_ERR;
#else /* RADIO_WAIT_FOR_PACKET_SENT */
TO_PREV_STATE();
LED_TX_OFF();
return RADIO_TX_OK;
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
}
#if RADIO_WAIT_FOR_PACKET_SENT
RELEASE_LOCK();
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
TO_PREV_STATE();
PRINTF("stm32w: transmission never started.\r\n");
/* TODO: Do we have to retransmit? */
CLEAN_TXBUF();
if(last_tx_status == ST_SUCCESS || last_tx_status == ST_PHY_ACK_RECEIVED ||
last_tx_status == ST_MAC_NO_ACK_RECEIVED) {
RELEASE_LOCK();
if(last_tx_status == ST_PHY_ACK_RECEIVED) {
return RADIO_TX_OK; /* ACK status */
} else if(last_tx_status == ST_MAC_NO_ACK_RECEIVED ||
last_tx_status == ST_SUCCESS) {
return RADIO_TX_NOACK;
}
}
LED_TX_OFF();
RELEASE_LOCK();
return RADIO_TX_ERR;
#else /* RADIO_WAIT_FOR_PACKET_SENT */
TO_PREV_STATE();
LED_TX_OFF();
return RADIO_TX_OK;
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
}
#if RADIO_WAIT_FOR_PACKET_SENT
RELEASE_LOCK();
#endif /* RADIO_WAIT_FOR_PACKET_SENT */
TO_PREV_STATE();
PRINTF("stm32w: transmission never started.\r\n");
/* TODO: Do we have to retransmit? */
CLEAN_TXBUF();
LED_TX_OFF();
return RADIO_TX_ERR;
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_send(const void *payload, unsigned short payload_len)
static int
stm32w_radio_send(const void *payload, unsigned short payload_len)
{
if(stm32w_radio_prepare(payload, payload_len) == RADIO_TX_ERR)
if (stm32w_radio_prepare(payload, payload_len) == RADIO_TX_ERR) {
return RADIO_TX_ERR;
}
return stm32w_radio_transmit(payload_len);
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_channel_clear(void)
static int
stm32w_radio_channel_clear(void)
{
return ST_RadioChannelIsClear();
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_receiving_packet(void)
static int
stm32w_radio_receiving_packet(void)
{
return receiving_packet;
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_pending_packet(void)
static int
stm32w_radio_pending_packet(void)
{
return !RXBUFS_EMPTY();
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_off(void)
static int
stm32w_radio_off(void)
{
/* Any transmit or receive packets in progress are aborted.
* Waiting for end of transmission or reception have to be done.
*/
if(locked)
{
PRINTF("stm32w: try to off while sending/receiving (lock=%u).\r\n", locked);
if(locked) {
PRINTF("stm32w: try to off while sending/receiving (lock=%u).\r\n",
locked);
return 0;
}
/* off only if there is no transmission or reception of packet. */
if(onoroff == ON && TXBUF_EMPTY() && !receiving_packet){
if(onoroff == ON && TXBUF_EMPTY() && !receiving_packet) {
LED_RDC_OFF();
ST_RadioSleep();
onoroff = OFF;
@ -475,10 +497,11 @@ static int stm32w_radio_off(void)
return 1;
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_on(void)
static int
stm32w_radio_on(void)
{
PRINTF("stm32w: turn radio on\n");
if(onoroff == OFF){
if(onoroff == OFF) {
LED_RDC_ON();
ST_RadioWake();
onoroff = ON;
@ -489,24 +512,23 @@ static int stm32w_radio_on(void)
return 1;
}
/*---------------------------------------------------------------------------*/
int stm32w_radio_is_on(void)
int
stm32w_radio_is_on(void)
{
return onoroff == ON;
}
/*---------------------------------------------------------------------------*/
void ST_RadioReceiveIsrCallback(u8 *packet,
boolean ackFramePendingSet,
u32 time,
u16 errors,
s8 rssi)
void
ST_RadioReceiveIsrCallback(uint8_t *packet,
boolean ackFramePendingSet,
uint32_t time, uint16_t errors, int8_t rssi)
{
LED_RX_ON();
PRINTF("stm32w: incomming packet received\n");
receiving_packet = 0;
/* Copy packet into the buffer. It is better to do this here. */
if(add_to_rxbuf(packet)){
if(add_to_rxbuf(packet)) {
process_poll(&stm32w_radio_process);
last_rssi = rssi;
}
@ -516,83 +538,76 @@ void ST_RadioReceiveIsrCallback(u8 *packet,
/* Wait for sending ACK */
BUSYWAIT_UNTIL(!is_transmit_ack, RTIMER_SECOND / 1500);
RELEASE_LOCK();
}
void ST_RadioTxAckIsrCallback (void)
/*--------------------------------------------------------------------------*/
void
ST_RadioTxAckIsrCallback(void)
{
/* This callback is for simplemac 1.1.0.
Till now we block (RTIMER_SECOND / 1500)
to prevent radio off during ACK transmission */
/*
* This callback is for simplemac 1.1.0.
* Till now we block (RTIMER_SECOND / 1500)
* to prevent radio off during ACK transmission.
*/
is_transmit_ack = 0;
//RELEASE_LOCK();
/* RELEASE_LOCK(); */
}
void ST_RadioTransmitCompleteIsrCallback(StStatus status,
u32 txSyncTime,
boolean framePending)
/*--------------------------------------------------------------------------*/
void
ST_RadioTransmitCompleteIsrCallback(StStatus status,
uint32_t txSyncTime, boolean framePending)
{
ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT);
ENERGEST_ON(ENERGEST_TYPE_LISTEN);
LED_TX_OFF();
last_tx_status = status;
if(status == ST_SUCCESS || status == ST_PHY_ACK_RECEIVED){
if(status == ST_SUCCESS || status == ST_PHY_ACK_RECEIVED) {
CLEAN_TXBUF();
} else {
if(RETRY_CNT_GTZ()) {
/* Retransmission */
LED_TX_ON();
if(ST_RadioTransmit(stm32w_txbuf) == ST_SUCCESS) {
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
PRINTF("stm32w: retransmission.\r\n");
DEC_RETRY_CNT();
} else {
CLEAN_TXBUF();
LED_TX_OFF();
PRINTF("stm32w: retransmission failed.\r\n");
}
} else {
CLEAN_TXBUF();
}
else {
if(RETRY_CNT_GTZ()){
// Retransmission
LED_TX_ON();
if(ST_RadioTransmit(stm32w_txbuf)==ST_SUCCESS){
ENERGEST_OFF(ENERGEST_TYPE_LISTEN);
ENERGEST_ON(ENERGEST_TYPE_TRANSMIT);
PRINTF("stm32w: retransmission.\r\n");
DEC_RETRY_CNT();
}
else {
CLEAN_TXBUF();
LED_TX_OFF();
PRINTF("stm32w: retransmission failed.\r\n");
}
}
else {
CLEAN_TXBUF();
}
}
}
/* Debug outputs. */
if(status == ST_SUCCESS || status == ST_PHY_ACK_RECEIVED){
PRINTF("stm32w: return status TX_END\r\n");
}
else if (status == ST_MAC_NO_ACK_RECEIVED){
PRINTF("stm32w: return status TX_END_NOACK\r\n");
}
else if (status == ST_PHY_TX_CCA_FAIL){
PRINTF("stm32w: return status TX_END_CCA_FAIL\r\n");
}
else if(status == ST_PHY_TX_UNDERFLOW){
PRINTF("stm32w: return status TX_END_UNDERFLOW\r\n");
}
else {
PRINTF("stm32w: return status TX_END_INCOMPLETE\r\n");
if(status == ST_SUCCESS || status == ST_PHY_ACK_RECEIVED) {
PRINTF("stm32w: return status TX_END\r\n");
} else if(status == ST_MAC_NO_ACK_RECEIVED) {
PRINTF("stm32w: return status TX_END_NOACK\r\n");
} else if(status == ST_PHY_TX_CCA_FAIL) {
PRINTF("stm32w: return status TX_END_CCA_FAIL\r\n");
} else if(status == ST_PHY_TX_UNDERFLOW) {
PRINTF("stm32w: return status TX_END_UNDERFLOW\r\n");
} else {
PRINTF("stm32w: return status TX_END_INCOMPLETE\r\n");
}
}
boolean ST_RadioDataPendingShortIdIsrCallback(int16u shortId) {
/*--------------------------------------------------------------------------*/
boolean
ST_RadioDataPendingShortIdIsrCallback(uint16_t shortId)
{
receiving_packet = 1;
return FALSE;
}
boolean ST_RadioDataPendingLongIdIsrCallback(int8u* longId) {
/*--------------------------------------------------------------------------*/
boolean
ST_RadioDataPendingLongIdIsrCallback(uint8_t * longId)
{
receiving_packet = 1;
return FALSE;
}
@ -600,20 +615,16 @@ boolean ST_RadioDataPendingLongIdIsrCallback(int8u* longId) {
PROCESS_THREAD(stm32w_radio_process, ev, data)
{
int len;
PROCESS_BEGIN();
PRINTF("stm32w_radio_process: started\r\n");
while(1) {
PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
PRINTF("stm32w_radio_process: calling receiver callback\r\n");
#if DEBUG > 1
for(uint8_t c=1; c <= RCVD_PACKET_LEN; c++){
PRINTF("%x",stm32w_rxbuf[c]);
for(uint8_t c = 1; c <= RCVD_PACKET_LEN; c++) {
PRINTF("%x", stm32w_rxbuf[c]);
}
PRINTF("\r\n");
#endif
@ -624,84 +635,88 @@ PROCESS_THREAD(stm32w_radio_process, ev, data)
packetbuf_set_datalen(len);
NETSTACK_RDC.input();
}
if(!RXBUFS_EMPTY()){
// Some data packet still in rx buffer (this happens because process_poll doesn't queue requests),
// so stm32w_radio_process need to be called again.
if(!RXBUFS_EMPTY()) {
/*
* Some data packet still in rx buffer (this happens because process_poll
* doesn't queue requests), so stm32w_radio_process needs to be called
* again.
*/
process_poll(&stm32w_radio_process);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
static int stm32w_radio_read(void *buf, unsigned short bufsize)
static int
stm32w_radio_read(void *buf, unsigned short bufsize)
{
return read_from_rxbuf(buf,bufsize);
return read_from_rxbuf(buf, bufsize);
}
/*---------------------------------------------------------------------------*/
void ST_RadioOverflowIsrCallback(void)
void
ST_RadioOverflowIsrCallback(void)
{
PRINTF("stm32w: radio overflow\r\n");
}
/*---------------------------------------------------------------------------*/
void ST_RadioSfdSentIsrCallback(u32 sfdSentTime)
void
ST_RadioSfdSentIsrCallback(uint32_t sfdSentTime)
{
}
/*---------------------------------------------------------------------------*/
void ST_RadioMacTimerCompareIsrCallback(void)
void
ST_RadioMacTimerCompareIsrCallback(void)
{
}
/*---------------------------------------------------------------------------*/
static int add_to_rxbuf(uint8_t * src)
static int
add_to_rxbuf(uint8_t *src)
{
if(RXBUFS_FULL()){
return 0;
}
if(RXBUFS_FULL()) {
return 0;
}
memcpy(stm32w_rxbufs[last], src, src[0] + 1);
memcpy(stm32w_rxbufs[last], src, src[0] + 1);
#if RADIO_RXBUFS > 1
last = (last + 1) % RADIO_RXBUFS;
if(first == -1){
first = 0;
}
last = (last + 1) % RADIO_RXBUFS;
if(first == -1) {
first = 0;
}
#endif
return 1;
return 1;
}
/*---------------------------------------------------------------------------*/
static int read_from_rxbuf(void * dest, unsigned short len)
static int
read_from_rxbuf(void *dest, unsigned short len)
{
if(RXBUFS_EMPTY()) { /* Buffers are all empty */
return 0;
}
if(RXBUFS_EMPTY()){ // Buffers are all empty
return 0;
}
if(stm32w_rxbufs[first][0] > len){ // Too large packet for dest.
len = 0;
}
else {
len = stm32w_rxbufs[first][0];
memcpy(dest,stm32w_rxbufs[first]+1,len);
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, last_rssi);
}
if(stm32w_rxbufs[first][0] > len) { /* Too large packet for dest. */
len = 0;
} else {
len = stm32w_rxbufs[first][0];
memcpy(dest, stm32w_rxbufs[first] + 1, len);
packetbuf_set_attr(PACKETBUF_ATTR_RSSI, last_rssi);
}
#if RADIO_RXBUFS > 1
ATOMIC(
first = (first + 1) % RADIO_RXBUFS;
int first_tmp = first;
if(first_tmp == last){
CLEAN_RXBUFS();
}
)
ATOMIC(first = (first + 1) % RADIO_RXBUFS;
int first_tmp = first; if(first_tmp == last) {
CLEAN_RXBUFS();}
)
#else
CLEAN_RXBUFS();
CLEAN_RXBUFS();
#endif
return len;
return len;
}
/*---------------------------------------------------------------------------*/
short last_packet_rssi(){
return last_rssi;
short
last_packet_rssi()
{
return last_rssi;
}
/** @} */

17
cpu/stm32w108/dev/stm32w-radio.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 2007, Swedish Institute of Computer Science.
* All rights reserved.
@ -26,8 +32,6 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
@ -45,14 +49,15 @@
#include "hal/hal.h"
#include "simplemac/include/phy-library.h"
int stm32w_radio_set_channel(uint8_t channel);
short last_packet_rssi();
#define STM32W_MAX_PACKET_LEN 127
extern const struct radio_driver stm32w_radio_driver;
int stm32w_radio_set_channel(uint8_t channel);
short last_packet_rssi();
int stm32w_radio_is_on(void);
#endif /* __STM32W_H__ */
/** @} */

150
cpu/stm32w108/dev/stm32w-systick.c Normal file
View file

@ -0,0 +1,150 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32w108_systick.c
* Author : MCD Application Team
* Version : V2.0.3
* Date : 09/22/2008
* Description : This file provides all the SysTick firmware functions.
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
#include <stdint.h>
#include "stm32w-systick.h"
/* SysTick registers bit mask */
/* CTRL TICKINT Mask */
#define CTRL_TICKINT_Set ((uint32_t)0x00000002)
#define CTRL_TICKINT_Reset ((uint32_t)0xFFFFFFFD)
/*--------------------------------------------------------------------------*/
/**
* \brief Configures the SysTick clock source.
* \param SysTick_CLKSource specifies the SysTick clock source.
* This parameter can be one of the following values:
* SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8
* selected as SysTick clock source.
* SysTick_CLKSource_HCLK: AHB clock selected as
* SysTick clock source.
*/
void
SysTick_CLKSourceConfig(uint32_t SysTick_CLKSource)
{
/* Check the parameters */
assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
if(SysTick_CLKSource == SysTick_CLKSource_HCLK) {
SysTick->CTRL |= SysTick_CLKSource_HCLK;
} else {
SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
}
}
/*--------------------------------------------------------------------------*/
/**
* \brief Sets SysTick Reload value.
* \param Reload SysTick Reload new value. Must be between 1 and 0xFFFFFF.
*/
void
SysTick_SetReload(uint32_t Reload)
{
/* Check the parameters */
assert_param(IS_SYSTICK_RELOAD(Reload));
SysTick->LOAD = Reload;
}
/*--------------------------------------------------------------------------*/
/**
* \brief Enables or disables the SysTick counter.
* \param SysTick_Counter new state of the SysTick counter.
* This parameter can be one of the following values:
* - SysTick_Counter_Disable: Disable counter
* - SysTick_Counter_Enable: Enable counter
* - SysTick_Counter_Clear: Clear counter value to 0
*/
void
SysTick_CounterCmd(uint32_t SysTick_Counter)
{
/* Check the parameters */
assert_param(IS_SYSTICK_COUNTER(SysTick_Counter));
if(SysTick_Counter == SysTick_Counter_Enable) {
SysTick->CTRL |= SysTick_Counter_Enable;
} else if(SysTick_Counter == SysTick_Counter_Disable) {
SysTick->CTRL &= SysTick_Counter_Disable;
} else { /* SysTick_Counter == SysTick_Counter_Clear */
SysTick->VAL = SysTick_Counter_Clear;
}
}
/*--------------------------------------------------------------------------*/
/**
* \brief Enables or disables the SysTick Interrupt.
* \param NewState new state of the SysTick Interrupt.
* This parameter can be: ENABLE or DISABLE.
*/
void
SysTick_ITConfig(FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
if(NewState != DISABLE) {
SysTick->CTRL |= CTRL_TICKINT_Set;
} else {
SysTick->CTRL &= CTRL_TICKINT_Reset;
}
}
/*--------------------------------------------------------------------------*/
/**
* \brief Gets SysTick counter value.
* \return SysTick current value
*/
uint32_t
SysTick_GetCounter(void)
{
return (SysTick->VAL);
}
/*--------------------------------------------------------------------------*/
/**
* \brief Checks whether the specified SysTick flag is set or not.
* \param SysTick_FLAG specifies the flag to check.
* This parameter can be one of the following values:
* - SysTick_FLAG_COUNT
* - SysTick_FLAG_SKEW
* - SysTick_FLAG_NOREF
*/
FlagStatus
SysTick_GetFlagStatus(uint8_t SysTick_FLAG)
{
uint32_t statusreg = 0, tmp = 0;
FlagStatus bitstatus = RESET;
/* Check the parameters */
assert_param(IS_SYSTICK_FLAG(SysTick_FLAG));
/* Get the SysTick register index */
tmp = SysTick_FLAG >> 3;
if(tmp == 2) { /* The flag to check is in CTRL register */
statusreg = SysTick->CTRL;
} else { /* The flag to check is in CALIB register */
statusreg = SysTick->CALIB;
}
if((statusreg & ((uint32_t) 1 << SysTick_FLAG)) != (uint32_t) RESET) {
bitstatus = SET;
} else {
bitstatus = RESET;
}
return bitstatus;
}
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
/** @} */

63
cpu/stm32w108/dev/stm32w_systick.h → cpu/stm32w108/dev/stm32w-systick.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32f10x_systick.h
* Author : MCD Application Team
@ -14,19 +20,17 @@
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32W_SYSTICK_H
#define __STM32W_SYSTICK_H
#include "stm32w108_type.h"
#include "stm32w_conf.h"
#include "stm32w108-type.h"
#include "stm32w-conf.h"
#ifndef EXT
#define EXT extern
#define EXT extern
#endif /* EXT */
typedef struct
{
typedef struct {
vu32 CTRL;
vu32 LOAD;
vu32 VAL;
@ -41,39 +45,47 @@ typedef struct
#define SCB_BASE (SCS_BASE + 0x0D00)
#ifdef _SysTick
#define SysTick ((SysTick_TypeDef *) SysTick_BASE)
#define SysTick ((SysTick_TypeDef *) SysTick_BASE)
#endif /*_SysTick */
/***************** Bit definition for SysTick_CTRL register *****************/
#define SysTick_CTRL_ENABLE ((u32)0x00000001) /* Counter enable */
#define SysTick_CTRL_TICKINT ((u32)0x00000002) /* Counting down to 0 pends the SysTick handler */
#define SysTick_CTRL_CLKSOURCE ((u32)0x00000004) /* Clock source */
#define SysTick_CTRL_COUNTFLAG ((u32)0x00010000) /* Count Flag */
/* Counter enable */
#define SysTick_CTRL_ENABLE ((u32)0x00000001)
/* Counting down to 0 pends the SysTick handler */
#define SysTick_CTRL_TICKINT ((u32)0x00000002)
/* Clock source */
#define SysTick_CTRL_CLKSOURCE ((u32)0x00000004)
/* Count Flag */
#define SysTick_CTRL_COUNTFLAG ((u32)0x00010000)
/***************** Bit definition for SysTick_LOAD register *****************/
#define SysTick_LOAD_RELOAD ((u32)0x00FFFFFF) /* Value to load into the SysTick Current Value Register when the counter reaches 0 */
/*
* Value to load into the SysTick Current Value Register when the
* counter reaches 0
*/
#define SysTick_LOAD_RELOAD ((u32)0x00FFFFFF)
/***************** Bit definition for SysTick_VAL register ******************/
#define SysTick_VAL_CURRENT ((u32)0x00FFFFFF) /* Current value at the time the register is accessed */
/* Current value at the time the register is accessed */
#define SysTick_VAL_CURRENT ((u32)0x00FFFFFF)
/***************** Bit definition for SysTick_CALIB register ****************/
#define SysTick_CALIB_TENMS ((u32)0x00FFFFFF) /* Reload value to use for 10ms timing */
#define SysTick_CALIB_SKEW ((u32)0x40000000) /* Calibration value is not exactly 10 ms */
#define SysTick_CALIB_NOREF ((u32)0x80000000) /* The reference clock is not provided */
/* Reload value to use for 10ms timing */
#define SysTick_CALIB_TENMS ((u32)0x00FFFFFF)
/* Calibration value is not exactly 10 ms */
#define SysTick_CALIB_SKEW ((u32)0x40000000)
/* The reference clock is not provided */
#define SysTick_CALIB_NOREF ((u32)0x80000000)
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* SysTick clock source */
#define SysTick_CLKSource_HCLK_Div8 ((u32)0xFFFFFFFB)
#define SysTick_CLKSource_HCLK ((u32)0x00000004)
#define IS_SYSTICK_CLK_SOURCE(SOURCE) (((SOURCE) == SysTick_CLKSource_HCLK) || \
((SOURCE) == SysTick_CLKSource_HCLK_Div8))
((SOURCE) == SysTick_CLKSource_HCLK_Div8))
/* SysTick counter state */
#define SysTick_Counter_Disable ((u32)0xFFFFFFFE)
@ -95,15 +107,18 @@ typedef struct
#define IS_SYSTICK_RELOAD(RELOAD) (((RELOAD) > 0) && ((RELOAD) <= 0xFFFFFF))
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
void SysTick_CLKSourceConfig(u32 SysTick_CLKSource);
void SysTick_SetReload(u32 Reload);
void SysTick_CounterCmd(u32 SysTick_Counter);
void SysTick_ITConfig(FunctionalState NewState);
u32 SysTick_GetCounter(void);
FlagStatus SysTick_GetFlagStatus(u8 SysTick_FLAG);
#endif /* __STM32F10x_SYSTICK_H */
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
/** @} */

174
cpu/stm32w108/dev/stm32w_conf.h
View file

@ -1,174 +0,0 @@
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32w_conf.h
* Author : MCD Application Team
* Version : V2.0.3
* Date : 09/22/2008
* Description : Library configuration file.
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32F10x_CONF_H
#define __STM32F10x_CONF_H
/* Includes ------------------------------------------------------------------*/
#include "stm32w108_type.h"
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* Uncomment the line below to compile the library in DEBUG mode, this will expanse
the "assert_param" macro in the firmware library code (see "Exported macro"
section below) */
/*#define DEBUG 1*/
/* Comment the line below to disable the specific peripheral inclusion */
/************************************* ADC ************************************/
//#define _ADC
//#define _ADC1
//#define _ADC2
//#define _ADC3
/************************************* BKP ************************************/
//#define _BKP
/************************************* CAN ************************************/
//#define _CAN
/************************************* CRC ************************************/
//#define _CRC
/************************************* DAC ************************************/
//#define _DAC
/************************************* DBGMCU *********************************/
//#define _DBGMCU
/************************************* DMA ************************************/
//#define _DMA
//#define _DMA1_Channel1
//#define _DMA1_Channel2
//#define _DMA1_Channel3
//#define _DMA1_Channel4
//#define _DMA1_Channel5
//#define _DMA1_Channel6
//#define _DMA1_Channel7
//#define _DMA2_Channel1
//#define _DMA2_Channel2
//#define _DMA2_Channel3
//#define _DMA2_Channel4
//#define _DMA2_Channel5
/************************************* EXTI ***********************************/
//#define _EXTI
/************************************* FLASH and Option Bytes *****************/
#define _FLASH
/* Uncomment the line below to enable FLASH program/erase/protections functions,
otherwise only FLASH configuration (latency, prefetch, half cycle) functions
are enabled */
/* #define _FLASH_PROG */
/************************************* FSMC ***********************************/
//#define _FSMC
/************************************* GPIO ***********************************/
#define _GPIO
//#define _GPIOA
//#define _GPIOB
#define _GPIOC
//#define _GPIOD
//#define _GPIOE
#define _GPIOF
//#define _GPIOG
#define _AFIO
/************************************* I2C ************************************/
//#define _I2C
//#define _I2C1
//#define _I2C2
/************************************* IWDG ***********************************/
//#define _IWDG
/************************************* NVIC ***********************************/
#define _NVIC
/************************************* PWR ************************************/
//#define _PWR
/************************************* RCC ************************************/
#define _RCC
/************************************* RTC ************************************/
//#define _RTC
/************************************* SDIO ***********************************/
//#define _SDIO
/************************************* SPI ************************************/
//#define _SPI
//#define _SPI1
//#define _SPI2
//#define _SPI3
/************************************* SysTick ********************************/
#define _SysTick
/************************************* TIM ************************************/
//#define _TIM
//#define _TIM1
//#define _TIM2
//#define _TIM3
//#define _TIM4
//#define _TIM5
//#define _TIM6
//#define _TIM7
//#define _TIM8
/************************************* USART **********************************/
//#define _USART
//#define _USART1
//#define _USART2
//#define _USART3
//#define _UART4
//#define _UART5
/************************************* WWDG ***********************************/
//#define _WWDG
/* In the following line adjust the value of External High Speed oscillator (HSE)
used in your application */
#define HSE_Value ((u32)8000000) /* Value of the External oscillator in Hz*/
/* In the following line adjust the External High Speed oscillator (HSE) Startup
Timeout value */
#define HSEStartUp_TimeOut ((u16)0x0500) /* Time out for HSE start up */
/* Exported macro ------------------------------------------------------------*/
#ifdef DEBUG
/*******************************************************************************
* Macro Name : assert_param
* Description : The assert_param macro is used for function's parameters check.
* It is used only if the library is compiled in DEBUG mode.
* Input : - expr: If expr is false, it calls assert_failed function
* which reports the name of the source file and the source
* line number of the call that failed.
* If expr is true, it returns no value.
* Return : None
*******************************************************************************/
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((u8 *)__FILE__, __LINE__))
/* Exported functions ------------------------------------------------------- */
void assert_failed(u8* file, u32 line);
#else
#define assert_param(expr) ((void)0)
#endif /* DEBUG */
#endif /* __STM32F10x_CONF_H */
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

181
cpu/stm32w108/dev/stm32w_systick.c
View file

@ -1,181 +0,0 @@
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32w108_systick.c
* Author : MCD Application Team
* Version : V2.0.3
* Date : 09/22/2008
* Description : This file provides all the SysTick firmware functions.
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
/* Includes ------------------------------------------------------------------*/
#include "stm32w_systick.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* ---------------------- SysTick registers bit mask -------------------- */
/* CTRL TICKINT Mask */
#define CTRL_TICKINT_Set ((u32)0x00000002)
#define CTRL_TICKINT_Reset ((u32)0xFFFFFFFD)
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : SysTick_CLKSourceConfig
* Description : Configures the SysTick clock source.
* Input : - SysTick_CLKSource: specifies the SysTick clock source.
* This parameter can be one of the following values:
* - SysTick_CLKSource_HCLK_Div8: AHB clock divided by 8
* selected as SysTick clock source.
* - SysTick_CLKSource_HCLK: AHB clock selected as
* SysTick clock source.
* Output : None
* Return : None
*******************************************************************************/
void SysTick_CLKSourceConfig(u32 SysTick_CLKSource)
{
/* Check the parameters */
assert_param(IS_SYSTICK_CLK_SOURCE(SysTick_CLKSource));
if (SysTick_CLKSource == SysTick_CLKSource_HCLK)
{
SysTick->CTRL |= SysTick_CLKSource_HCLK;
}
else
{
SysTick->CTRL &= SysTick_CLKSource_HCLK_Div8;
}
}
/*******************************************************************************
* Function Name : SysTick_SetReload
* Description : Sets SysTick Reload value.
* Input : - Reload: SysTick Reload new value.
* This parameter must be a number between 1 and 0xFFFFFF.
* Output : None
* Return : None
*******************************************************************************/
void SysTick_SetReload(u32 Reload)
{
/* Check the parameters */
assert_param(IS_SYSTICK_RELOAD(Reload));
SysTick->LOAD = Reload;
}
/*******************************************************************************
* Function Name : SysTick_CounterCmd
* Description : Enables or disables the SysTick counter.
* Input : - SysTick_Counter: new state of the SysTick counter.
* This parameter can be one of the following values:
* - SysTick_Counter_Disable: Disable counter
* - SysTick_Counter_Enable: Enable counter
* - SysTick_Counter_Clear: Clear counter value to 0
* Output : None
* Return : None
*******************************************************************************/
void SysTick_CounterCmd(u32 SysTick_Counter)
{
/* Check the parameters */
assert_param(IS_SYSTICK_COUNTER(SysTick_Counter));
if (SysTick_Counter == SysTick_Counter_Enable)
{
SysTick->CTRL |= SysTick_Counter_Enable;
}
else if (SysTick_Counter == SysTick_Counter_Disable)
{
SysTick->CTRL &= SysTick_Counter_Disable;
}
else /* SysTick_Counter == SysTick_Counter_Clear */
{
SysTick->VAL = SysTick_Counter_Clear;
}
}
/*******************************************************************************
* Function Name : SysTick_ITConfig
* Description : Enables or disables the SysTick Interrupt.
* Input : - NewState: new state of the SysTick Interrupt.
* This parameter can be: ENABLE or DISABLE.
* Output : None
* Return : None
*******************************************************************************/
void SysTick_ITConfig(FunctionalState NewState)
{
/* Check the parameters */
assert_param(IS_FUNCTIONAL_STATE(NewState));
if (NewState != DISABLE)
{
SysTick->CTRL |= CTRL_TICKINT_Set;
}
else
{
SysTick->CTRL &= CTRL_TICKINT_Reset;
}
}
/*******************************************************************************
* Function Name : SysTick_GetCounter
* Description : Gets SysTick counter value.
* Input : None
* Output : None
* Return : SysTick current value
*******************************************************************************/
u32 SysTick_GetCounter(void)
{
return(SysTick->VAL);
}
/*******************************************************************************
* Function Name : SysTick_GetFlagStatus
* Description : Checks whether the specified SysTick flag is set or not.
* Input : - SysTick_FLAG: specifies the flag to check.
* This parameter can be one of the following values:
* - SysTick_FLAG_COUNT
* - SysTick_FLAG_SKEW
* - SysTick_FLAG_NOREF
* Output : None
* Return : None
*******************************************************************************/
FlagStatus SysTick_GetFlagStatus(u8 SysTick_FLAG)
{
u32 statusreg = 0, tmp = 0 ;
FlagStatus bitstatus = RESET;
/* Check the parameters */
assert_param(IS_SYSTICK_FLAG(SysTick_FLAG));
/* Get the SysTick register index */
tmp = SysTick_FLAG >> 3;
if (tmp == 2) /* The flag to check is in CTRL register */
{
statusreg = SysTick->CTRL;
}
else /* The flag to check is in CALIB register */
{
statusreg = SysTick->CALIB;
}
if ((statusreg & ((u32)1 << SysTick_FLAG)) != (u32)RESET)
{
bitstatus = SET;
}
else
{
bitstatus = RESET;
}
return bitstatus;
}
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

77
cpu/stm32w108/dev/uart1-putchar.c
View file

@ -1,3 +1,39 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include <stdio.h>
#include "dev/uart1.h"
@ -5,7 +41,7 @@
#include PLATFORM_HEADER
#include "hal/micro/micro-common.h"
#include "hal/micro/cortexm3/micro-common.h"
//#include "uart.h"
/* #include "uart.h" */
#ifdef __GNUC__
# define _LLIO_STDIN ((int) stdin)
@ -19,38 +55,40 @@
#endif
#undef putchar
int __attribute__(( weak )) putchar(int c)
/*--------------------------------------------------------------------------*/
int
__attribute__ ((weak)) putchar(int c)
{
uart1_writeb(c);
return c;
}
void __io_putchar(char c)
/*--------------------------------------------------------------------------*/
void
__io_putchar(char c)
{
putchar(c);
}
size_t _write(int handle, const unsigned char * buffer, size_t size)
/*--------------------------------------------------------------------------*/
size_t
_write(int handle, const unsigned char *buffer, size_t size)
{
size_t nChars = 0;
if (handle != _LLIO_STDOUT && handle != _LLIO_STDERR) {
if(handle != _LLIO_STDOUT && handle != _LLIO_STDERR) {
return _LLIO_ERROR;
}
if (buffer == 0) {
// This means that we should flush internal buffers.
//spin until TX complete (TX is idle)
while ((SC1_UARTSTAT&SC_UARTTXIDLE)!=SC_UARTTXIDLE) {}
if(buffer == 0) {
/* This means that we should flush internal buffers. */
/* spin until TX complete (TX is idle) */
while((SC1_UARTSTAT & SC_UARTTXIDLE) != SC_UARTTXIDLE) {
}
return 0;
}
// ensure port is configured for UART
/* ensure port is configured for UART */
if(SC1_MODE != SC1_MODE_UART) {
return _LLIO_ERROR;
}
while(size--) {
__io_putchar(*buffer++);
++nChars;
@ -59,9 +97,10 @@ size_t _write(int handle, const unsigned char * buffer, size_t size)
return nChars;
}
size_t _read(int handle, unsigned char * buffer, size_t size)
/*--------------------------------------------------------------------------*/
size_t
_read(int handle, unsigned char *buffer, size_t size)
{
return 0;
return 0;
}
/** @} */

120
cpu/stm32w108/dev/uart1.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,10 +33,9 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Machine dependent STM32W UART1 code.
@ -41,53 +46,42 @@
* \since
* 03.04.2010
*/
/*---------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
//#include <io.h>
//#include <signal.h>
#include "sys/energest.h"
#include "dev/uart1.h"
#include "dev/watchdog.h"
#include "lib/ringbuf.h"
#include "dev/leds.h"
static int (*uart1_input_handler)(unsigned char c);
static int (*uart1_input_handler) (unsigned char c);
void uart1_rx_interrupt(void);
void uart1_tx_interrupt(void);
static volatile uint8_t transmitting;
#ifdef UART1_CONF_TX_WITH_INTERRUPT
#define TX_WITH_INTERRUPT UART1_CONF_TX_WITH_INTERRUPT
#else /* UART1_CONF_TX_WITH_INTERRUPT */
#define TX_WITH_INTERRUPT 1
#define TX_WITH_INTERRUPT 1
#endif /* UART1_CONF_TX_WITH_INTERRUPT */
#if TX_WITH_INTERRUPT
#ifdef UART1_CONF_TX_BUFSIZE
#define UART1_TX_BUFSIZE UART1_CONF_TX_BUFSIZE
#else /* UART1_CONF_TX_BUFSIZE */
#define UART1_TX_BUFSIZE 64
#endif /* UART1_CONF_TX_BUFSIZE */
static struct ringbuf txbuf;
static uint8_t txbuf_data[UART1_TX_BUFSIZE];
#endif /* TX_WITH_INTERRUPT */
/*---------------------------------------------------------------------------*/
//uint8_t
//uart1_active(void)
//{
// return ((~ UTCTL1) & TXEPT) | transmitting;
//}
/*---------------------------------------------------------------------------*/
void
uart1_set_input(int (*input)(unsigned char c))
uart1_set_input(int (*input) (unsigned char c))
{
uart1_input_handler = input;
}
@ -97,21 +91,23 @@ uart1_writeb(unsigned char c)
{
watchdog_periodic();
#if TX_WITH_INTERRUPT
/* Put the outgoing byte on the transmission buffer. If the buffer
is full, we just keep on trying to put the byte into the buffer
until it is possible to put it there. */
/*
* Put the outgoing byte on the transmission buffer. If the buffer
* is full, we just keep on trying to put the byte into the buffer
* until it is possible to put it there.
*/
while(ringbuf_put(&txbuf, c) == 0);
/* If there is no transmission going, we need to start it by putting
the first byte into the UART. */
/*
* If there is no transmission going, we need to start it by putting
* the first byte into the UART.
*/
if(transmitting == 0) {
transmitting = 1;
SC1_DATA = ringbuf_get(&txbuf);
INT_SC1FLAG = INT_SCTXFREE;
INT_SC1CFG |= INT_SCTXFREE;
}
#else /* TX_WITH_INTERRUPT */
/* Loop until the transmission buffer is available. */
@ -124,102 +120,92 @@ uart1_writeb(unsigned char c)
#endif /* TX_WITH_INTERRUPT */
}
/*---------------------------------------------------------------------------*/
#if ! WITH_UIP /* If WITH_UIP is defined, putchar() is defined by the SLIP driver */
#if ! WITH_UIP
/* If WITH_UIP is defined, putchar() is defined by the SLIP driver */
#endif /* ! WITH_UIP */
/*---------------------------------------------------------------------------*/
/**
/*
* Initalize the RS232 port.
*
*/
void
uart1_init(unsigned long ubr)
{
uint16_t uartper;
uint32_t rest;
GPIO_PBCFGL &= 0xF00F;
GPIO_PBCFGL |= 0x0490;
uint16_t uartper = (uint32_t)24e6/(2*ubr);
uint32_t rest = (uint32_t)24e6%(2*ubr);
uartper = (uint32_t) 24e6 / (2 * ubr);
rest = (uint32_t) 24e6 % (2 * ubr);
SC1_UARTFRAC = 0;
if(rest > (2*ubr)/4 && rest < (3*2*ubr)/4){
SC1_UARTFRAC = 1; // + 0.5
}
else if(rest >= (3*2*ubr)/4){
uartper++; // + 1
if(rest > (2 * ubr) / 4 && rest < (3 * 2 * ubr) / 4) {
SC1_UARTFRAC = 1; /* + 0.5 */
} else if(rest >= (3 * 2 * ubr) / 4) {
uartper++; /* + 1 */
}
SC1_UARTPER = uartper;
SC1_UARTCFG = SC_UART8BIT;
SC1_MODE = SC1_MODE_UART;
SC1_INTMODE = SC_RXVALLEVEL | SC_TXFREELEVEL; // Receive buffer has data interrupt mode and Transmit buffer free interrupt mode: Level triggered.
INT_SC1CFG = INT_SCRXVAL; // Receive buffer has data interrupt enable
/*
* Receive buffer has data interrupt mode and Transmit buffer free interrupt
* mode: Level triggered.
*/
SC1_INTMODE = SC_RXVALLEVEL | SC_TXFREELEVEL;
INT_SC1CFG = INT_SCRXVAL; /* Receive buffer has data interrupt enable */
transmitting = 0;
#if TX_WITH_INTERRUPT
ringbuf_init(&txbuf, txbuf_data, sizeof(txbuf_data));
#endif /* TX_WITH_INTERRUPT */
INT_SC1FLAG = 0xFFFF;
INT_CFGSET = INT_SC1;
}
/*---------------------------------------------------------------------------*/
void uart1_rx_interrupt(void);
void uart1_tx_interrupt(void);
void halSc1Isr(void)
void
halSc1Isr(void)
{
ENERGEST_ON(ENERGEST_TYPE_IRQ);
if(INT_SC1FLAG & INT_SCRXVAL){
if(INT_SC1FLAG & INT_SCRXVAL) {
uart1_rx_interrupt();
INT_SC1FLAG = INT_SCRXVAL;
}
#if TX_WITH_INTERRUPT
else if(INT_SC1FLAG & INT_SCTXFREE){
#if TX_WITH_INTERRUPT
else if(INT_SC1FLAG & INT_SCTXFREE) {
uart1_tx_interrupt();
INT_SC1FLAG = INT_SCTXFREE;
}
#endif /* TX_WITH_INTERRUPT */
#endif /* TX_WITH_INTERRUPT */
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
}
void uart1_rx_interrupt(void)
/*--------------------------------------------------------------------------*/
void
uart1_rx_interrupt(void)
{
uint8_t c;
c = SC1_DATA;
if(uart1_input_handler != NULL) {
uart1_input_handler(c);
}
}
/*---------------------------------------------------------------------------*/
#if TX_WITH_INTERRUPT
void uart1_tx_interrupt(void)
void
uart1_tx_interrupt(void)
{
if(ringbuf_elements(&txbuf) == 0) {
transmitting = 0;
INT_SC1CFG &= ~INT_SCTXFREE;
} else {
SC1_DATA = ringbuf_get(&txbuf);
}
}
#endif /* TX_WITH_INTERRUPT */
/*---------------------------------------------------------------------------*/
/** @} */

16
cpu/stm32w108/dev/uart1.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 2007, Swedish Institute of Computer Science.
* All rights reserved.
@ -26,8 +32,6 @@
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
/**
@ -42,9 +46,13 @@
#define BAUD2UBR(baud) baud
void uart1_set_input(int (*input)(unsigned char c));
void uart1_set_input(int (*input) (unsigned char c));
void uart1_writeb(unsigned char c);
void uart1_init(unsigned long ubr);
//uint8_t uart1_active(void);
/* uint8_t uart1_active(void); */
#endif /* __UART1_H__ */
/** @} */

8
cpu/stm32w108/e_stdio/Makefile
View file

@ -9,10 +9,10 @@ CFLAGS = -mthumb -mcpu=cortex-m3 -I "." -I "C:/Program\ Files/Raisonance/Ride/L
AROPTS = cq
SOURCE_DIR = src
SOURCE_FILES = small_mprec.c syscalls.c \
_SP_printf.c _SP_vfprintf.c _SP_puts.c _SP_sprintf.c _SP_snprintf.c\
small_dtoa.c small_wcsrtombs.c small_wcrtomb.c small_wctomb_r.c \
scanf.c small_vfsscanf.c sscanf.c small_strtod.c
SOURCE_FILES = small-mprec.c syscalls.c \
sp-printf.c sp-vfprintf.c sp-puts.c sp-sprintf.c sp-snprintf.c\
small-dtoa.c small-wcsrtombs.c small-wcrtomb.c small-wctomb-r.c \
scanf.c small-vfsscanf.c sscanf.c small-strtod.c
vpath %.c $(SOURCE_DIR)

10
cpu/stm32w108/e_stdio/src/small_dtoa.c → cpu/stm32w108/e_stdio/src/small-dtoa.c
View file

@ -56,7 +56,7 @@
#endif
#include <string.h>
#include "small_mprec.h"
#include "small-mprec.h"
static int
_DEFUN (quorem,
@ -203,8 +203,8 @@ _DEFUN (quorem,
*/
/* Scanf and printf call both the small_mprec.c file if small_printf
* has not been specfied optimizations concerning small_mprec.c and
/* Scanf and printf call both the small-mprec.c file if small_printf
* has not been specfied optimizations concerning small-mprec.c and
* call of balloc will be performed anyway for printf.
*/
@ -292,8 +292,8 @@ _DEFUN (_dtoa_r,
* provided by Balloc variables are initialized to the beginning of the array.
* - For some variables many buffers have been declared, in fact for each call of small_lshift we used a
* buffer that has not been used at the moment
* - This buffers are used in the call of function declared in small_mprec.h
* To have more informations look at small_mprec.c
* - This buffers are used in the call of function declared in small-mprec.h
* To have more informations look at small-mprec.c
*/
_Bigint tab_b[BUF_LSHIFT_SIZE],tab_b1[BUF_SIZE],tab_delta[BUF_SIZE],tab_mlo[BUF_SIZE],tab_mhi[BUF_LSHIFT_SIZE],tab_S[BUF_LSHIFT_SIZE];

2
cpu/stm32w108/e_stdio/src/small_mprec.c → cpu/stm32w108/e_stdio/src/small-mprec.c
View file

@ -86,7 +86,7 @@
#include <stdlib.h>
#include <string.h>
#include <reent.h>
#include "small_mprec.h"
#include "small-mprec.h"
/* reent.c knows this value */
#define _Kmax 15

0
cpu/stm32w108/e_stdio/src/small_mprec.h → cpu/stm32w108/e_stdio/src/small-mprec.h
View file

10
cpu/stm32w108/e_stdio/src/small_strtod.c → cpu/stm32w108/e_stdio/src/small-strtod.c
View file

@ -98,8 +98,8 @@ Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
*/
/* Scanf and printf call both the small_mprec.c file if small_scanf
* has not been specfied optimizations concerning small_mprec.c and
/* Scanf and printf call both the small-mprec.c file if small_scanf
* has not been specfied optimizations concerning small-mprec.c and
* call of balloc will be performed anyway for scanf.
*/
@ -113,7 +113,7 @@ Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,
#include <_ansi.h>
#include <reent.h>
#include <string.h>
#include "small_mprec.h"
#include "small-mprec.h"
double
_DEFUN (_strtod_r, (ptr, s00, se),
@ -141,8 +141,8 @@ _DEFUN (_strtod_r, (ptr, s00, se),
* provided by Balloc variables are initialized to the beginning of the array.
* - For some variables many buffers have been declared, in fact for each call of small_lshift we used a
* buffer that has not been used at the moment
* - This buffers are used in the call of function declared in small_mprec.h
* To have more informations look at small_mprec.c
* - This buffers are used in the call of function declared in small-mprec.h
* To have more informations look at small-mprec.c
*/

0
cpu/stm32w108/e_stdio/src/small_vfsscanf.c → cpu/stm32w108/e_stdio/src/small-vfsscanf.c
View file

0
cpu/stm32w108/e_stdio/src/small_wcrtomb.c → cpu/stm32w108/e_stdio/src/small-wcrtomb.c
View file

0
cpu/stm32w108/e_stdio/src/small_wcsrtombs.c → cpu/stm32w108/e_stdio/src/small-wcsrtombs.c
View file

0
cpu/stm32w108/e_stdio/src/small_wctomb_r.c → cpu/stm32w108/e_stdio/src/small-wctomb-r.c
View file

0
cpu/stm32w108/e_stdio/src/_SP_printf.c → cpu/stm32w108/e_stdio/src/sp-printf.c
View file

0
cpu/stm32w108/e_stdio/src/_SP_puts.c → cpu/stm32w108/e_stdio/src/sp-puts.c
View file

4
cpu/stm32w108/e_stdio/src/_SP_snprintf.c → cpu/stm32w108/e_stdio/src/sp-snprintf.c
View file

@ -14,8 +14,8 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/* doc in _SP_sprintf.c */
/* This code created by modifying _SP_sprintf.c so copyright inherited. */
/* doc in sp-sprintf.c */
/* This code created by modifying sp-sprintf.c so copyright inherited. */
#include <stdio.h>
#ifdef _HAVE_STDC

0
cpu/stm32w108/e_stdio/src/_SP_sprintf.c → cpu/stm32w108/e_stdio/src/sp-sprintf.c
View file

0
cpu/stm32w108/e_stdio/src/_SP_vfprintf.c → cpu/stm32w108/e_stdio/src/sp-vfprintf.c
View file

0
cpu/stm32w108/e_stdio/src/test_mes.c → cpu/stm32w108/e_stdio/src/test-mes.c
View file

0
cpu/stm32w108/e_stdio/src/test_printf.c → cpu/stm32w108/e_stdio/src/test-printf.c
View file

0
cpu/stm32w108/e_stdio/src/test_scanf.c → cpu/stm32w108/e_stdio/src/test-scanf.c
View file

149
cpu/stm32w108/elfloader-arch.c
View file

@ -1,3 +1,39 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2009, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include "contiki.h"
#include "elfloader-arch.h"
#include "cfs-coffee-arch.h"
@ -12,20 +48,22 @@
#define ELF32_R_TYPE(info) ((unsigned char)(info))
/* Supported relocations */
#define R_ARM_ABS32 2
#define R_ARM_THM_CALL 10
/* Adapted from elfloader-arm.c */
/* word aligned */
static uint32_t datamemory_aligned[(ELFLOADER_DATAMEMORY_SIZE + 3) / 4];
static uint8_t *datamemory = (uint8_t *) datamemory_aligned;
static uint32_t datamemory_aligned[(ELFLOADER_DATAMEMORY_SIZE+3)/4]; //word aligned
static uint8_t* datamemory = (uint8_t *)datamemory_aligned;
VAR_AT_SEGMENT (static const uint16_t textmemory[ELFLOADER_TEXTMEMORY_SIZE/2],".elf_text") = {0}; //halfword aligned
/* halfword aligned */
VAR_AT_SEGMENT(static const uint16_t
textmemory[ELFLOADER_TEXTMEMORY_SIZE / 2], ".elf_text") = {0};
/*---------------------------------------------------------------------------*/
void *
elfloader_arch_allocate_ram(int size)
{
if(size > sizeof(datamemory_aligned)){
if(size > sizeof(datamemory_aligned)) {
PRINTF("RESERVED RAM TOO SMALL\n");
}
return datamemory;
@ -34,7 +72,7 @@ elfloader_arch_allocate_ram(int size)
void *
elfloader_arch_allocate_rom(int size)
{
if(size > sizeof(textmemory)){
if(size > sizeof(textmemory)) {
PRINTF("RESERVED FLASH TOO SMALL\n");
}
return (void *)textmemory;
@ -42,50 +80,43 @@ elfloader_arch_allocate_rom(int size)
/*---------------------------------------------------------------------------*/
#define READSIZE sizeof(datamemory_aligned)
void elfloader_arch_write_rom(int fd, unsigned short textoff, unsigned int size, char *mem)
void
elfloader_arch_write_rom(int fd, unsigned short textoff, unsigned int size,
char *mem)
{
int32u ptr;
int nbytes;
uint32_t ptr;
int nbytes;
cfs_seek(fd, textoff, CFS_SEEK_SET);
cfs_seek(fd, textoff, CFS_SEEK_SET);
for(ptr = 0; ptr < size; ptr += READSIZE) {
/* Read data from file into RAM. */
nbytes = cfs_read(fd, (unsigned char *)datamemory, READSIZE);
/* Write data to flash. */
stm32w_flash_write((int32u)mem, datamemory, nbytes);
stm32w_flash_write((uint32_t) mem, datamemory, nbytes);
}
}
/*---------------------------------------------------------------------------*/
void elfloader_arch_relocate(int fd,
unsigned int sectionoffset,
char *sectionaddr,
void
elfloader_arch_relocate(int fd,
unsigned int sectionoffset,
char *sectionaddr,
struct elf32_rela *rela, char *addr)
{
unsigned int type;
type = ELF32_R_TYPE(rela->r_info);
cfs_seek(fd, sectionoffset + rela->r_offset, CFS_SEEK_SET);
/* PRINTF("elfloader_arch_relocate: type %d\n", type); */
/* PRINTF("Addr: %p, Addend: %ld\n", addr, rela->r_addend); */
switch(type) {
switch (type) {
case R_ARM_ABS32:
{
int32_t addend;
cfs_read(fd, (char*)&addend, 4);
cfs_read(fd, (char *)&addend, 4);
addr += addend;
cfs_seek(fd, -4, CFS_SEEK_CUR);
cfs_write(fd,&addr,4);
//elfloader_output_write_segment(output,(char*) &addr, 4);
PRINTF("%p: addr: %p\n", sectionaddr +rela->r_offset,
addr);
cfs_write(fd, &addr, 4);
/* elfloader_output_write_segment(output,(char*) &addr, 4); */
PRINTF("%p: addr: %p\n", sectionaddr + rela->r_offset, addr);
}
break;
case R_ARM_THM_CALL:
@ -93,45 +124,48 @@ void elfloader_arch_relocate(int fd,
uint16_t instr[2];
int32_t offset;
char *base;
cfs_read(fd, (char*)instr, 4);
cfs_read(fd, (char *)instr, 4);
cfs_seek(fd, -4, CFS_SEEK_CUR);
/* Ignore the addend since it will be zero for calls to symbols,
and I can't think of a case when doing a relative call to
a non-symbol position */
base = sectionaddr + (rela->r_offset + 4);
if (((instr[1]) & 0xe800) == 0xe800) {
/* BL or BLX */
if (((uint32_t)addr) & 0x1) {
/* BL */
instr[1] |= 0x1800;
} else {
/*
* Ignore the addend since it will be zero for calls to symbols,
* and I can't think of a case when doing a relative call to
* a non-symbol position
*/
base = sectionaddr + (rela->r_offset + 4);
if(((instr[1]) & 0xe800) == 0xe800) {
/* BL or BLX */
if(((uint32_t) addr) & 0x1) {
/* BL */
instr[1] |= 0x1800;
} else {
#if defined(__ARM_ARCH_4T__)
return ELFLOADER_UNHANDLED_RELOC;
return ELFLOADER_UNHANDLED_RELOC;
#else
/* BLX */
instr[1] &= ~0x1800;
instr[1] |= 0x0800;
/* BLX */
instr[1] &= ~0x1800;
instr[1] |= 0x0800;
#endif
}
}
}
/* Adjust address for BLX */
if ((instr[1] & 0x1800) == 0x0800) {
addr = (char*)((((uint32_t)addr) & 0xfffffffd)
| (((uint32_t)base) & 0x00000002));
if((instr[1] & 0x1800) == 0x0800) {
addr = (char *)((((uint32_t) addr) & 0xfffffffd) |
(((uint32_t) base) & 0x00000002));
}
offset = addr - (sectionaddr + (rela->r_offset + 4));
offset = addr - (sectionaddr + (rela->r_offset + 4));
PRINTF("elfloader-arm.c: offset %d\n", (int)offset);
if (offset < -(1<<22) || offset >= (1<<22)) {
PRINTF("elfloader-arm.c: offset %d too large for relative call\n",
(int)offset);
if(offset < -(1 << 22) || offset >= (1 << 22)) {
PRINTF("elfloader-arm.c: offset %d too large for relative call\n",
(int)offset);
}
/* PRINTF("%p: %04x %04x offset: %d addr: %p\n", sectionaddr +rela->r_offset, instr[0], instr[1], (int)offset, addr); */
instr[0] = (instr[0] & 0xf800) | ((offset>>12)&0x07ff);
instr[1] = (instr[1] & 0xf800) | ((offset>>1)&0x07ff);
cfs_write(fd,&instr,4);
//elfloader_output_write_segment(output, (char*)instr, 4);
/* PRINTF("cfs_write: %04x %04x\n",instr[0], instr[1]); */
/* PRINTF("%p: %04x %04x offset: %d addr: %p\n", sectionaddr +rela->r_offset, instr[0], instr[1], (int)offset, addr); */
instr[0] = (instr[0] & 0xf800) | ((offset >> 12) & 0x07ff);
instr[1] = (instr[1] & 0xf800) | ((offset >> 1) & 0x07ff);
cfs_write(fd, &instr, 4);
/* elfloader_output_write_segment(output, (char*)instr, 4); */
/* PRINTF("cfs_write: %04x %04x\n",instr[0], instr[1]); */
}
break;
@ -139,3 +173,4 @@ void elfloader_arch_relocate(int fd,
PRINTF("elfloader-arm.c: unsupported relocation type %d\n", type);
}
}
/** @} */

2
cpu/stm32w108/hal/error.h
View file

@ -15,7 +15,7 @@
*/
#ifndef __STSTATUS_TYPE__
#define __STSTATUS_TYPE__
typedef int8u StStatus;
typedef uint8_t StStatus;
#endif //__STSTATUS_TYPE__
/**

22
cpu/stm32w108/hal/micro/adc.h
View file

@ -37,7 +37,7 @@
#ifdef CORTEXM3_STM32W108
// A type for the ADC User enumeration.
typedef int8u ADCUser;
typedef uint8_t ADCUser;
enum
{
/** LQI User ID. */
@ -55,7 +55,7 @@ enum
// A type for the reference enumeration.
typedef int8u ADCReferenceType;
typedef uint8_t ADCReferenceType;
enum
{
/** AREF pin reference. */
@ -67,7 +67,7 @@ enum
};
// A type for the rate enumeration.
typedef int8u ADCRateType;
typedef uint8_t ADCRateType;
enum
{
/** Rate 32 us, 5 effective bits in ADC_DATA[15:11] */
@ -173,7 +173,7 @@ enum
/** @brief A type for the channel enumeration
* (such as ::ADC_SOURCE_ADC0_GND)
*/
typedef int8u ADCChannelType;
typedef uint8_t ADCChannelType;
/** @brief Returns the ADC channel from a given GPIO. Its value can can be used
* inside the ADC_SOURCE(P,N) macro to retrieve the input pair for
@ -184,7 +184,7 @@ typedef int8u ADCChannelType;
*
* @return The ADC_MUX value connected to the given GPIO.
*/
int8u halGetADCChannelFromGPIO(int32u io);
uint8_t halGetADCChannelFromGPIO(uint32_t io);
/** @brief Initializes and powers-up the ADC.
@ -226,7 +226,7 @@ StStatus halStartAdcConversion(ADCUser id,
*
* @param id An ADC user.
*
* @param value Pointer to an int16u to be loaded with the new value.
* @param value Pointer to an uint16_t to be loaded with the new value.
*
* @return One of the following:
* - ::ST_ADC_CONVERSION_DONE if the conversion is complete.
@ -237,7 +237,7 @@ StStatus halStartAdcConversion(ADCUser id,
* - ::ST_ADC_NO_CONVERSION_PENDING if \c id does not have a pending
* conversion.
*/
StStatus halRequestAdcData(ADCUser id, int16u *value);
StStatus halRequestAdcData(ADCUser id, uint16_t *value);
/** @brief Waits for the user's request to complete and then,
@ -248,14 +248,14 @@ StStatus halRequestAdcData(ADCUser id, int16u *value);
*
* @param id An ADC user.
*
* @param value Pointer to an int16u to be loaded with the new value.
* @param value Pointer to an uint16_t to be loaded with the new value.
*
* @return One of the following:
* - ::ST_ADC_CONVERSION_DONE if the conversion is complete.
* - ::ST_ADC_NO_CONVERSION_PENDING if \c id does not have a pending
* conversion.
*/
StStatus halReadAdcBlocking(ADCUser id, int16u *value);
StStatus halReadAdcBlocking(ADCUser id, uint16_t *value);
/** @brief Calibrates or recalibrates the ADC system.
@ -284,11 +284,11 @@ StStatus halAdcCalibrate(ADCUser id);
*
* @appusage Use this function to get a human useful value.
*
* @param value An int16u to be converted.
* @param value An uint16_t to be converted.
*
* @return Volts as signed fixed point with units 10^-4 Volts.
*/
int16s halConvertValueToVolts(int16u value);
int16_t halConvertValueToVolts(uint16_t value);
/** @brief Calibrates Vref to be 1.2V +/-10mV.

4
cpu/stm32w108/hal/micro/button.h
View file

@ -13,7 +13,7 @@
#define BUTTON_UNKNOWN 3
typedef int8u HalBoardButton;
typedef uint8_t HalBoardButton;
/* Functions -----------------------------------------------------------------*/
@ -21,7 +21,7 @@ typedef int8u HalBoardButton;
void halInitButton(void);
/** @brief Get button status */
int8u halGetButtonStatus(HalBoardButton button);
uint8_t halGetButtonStatus(HalBoardButton button);
#endif /* _BUTTON_H_ */

60
cpu/stm32w108/hal/micro/cortexm3/adc.c
View file

@ -10,18 +10,18 @@
#if (NUM_ADC_USERS > 8)
#error NUM_ADC_USERS must not be greater than 8, or int8u variables in adc.c must be changed
#error NUM_ADC_USERS must not be greater than 8, or uint8_t variables in adc.c must be changed
#endif
static int16u adcData; // conversion result written by DMA
static int8u adcPendingRequests; // bitmap of pending requests
volatile static int8u adcPendingConversion; // id of pending conversion
static int8u adcReadingValid; // bitmap of valid adcReadings
static int16u adcReadings[NUM_ADC_USERS];
static int16u adcConfig[NUM_ADC_USERS];
static uint16_t adcData; // conversion result written by DMA
static uint8_t adcPendingRequests; // bitmap of pending requests
volatile static uint8_t adcPendingConversion; // id of pending conversion
static uint8_t adcReadingValid; // bitmap of valid adcReadings
static uint16_t adcReadings[NUM_ADC_USERS];
static uint16_t adcConfig[NUM_ADC_USERS];
static boolean adcCalibrated;
static int16s Nvss;
static int16s Nvdd;
static int16_t Nvss;
static int16_t Nvdd;
/* Modified the original ADC driver for enabling the ADC extended range mode required for
supporting the STLM20 temperature sensor.
NOTE:
@ -30,10 +30,10 @@ static int16s Nvdd;
the temperature values
*/
#ifdef ENABLE_ADC_EXTENDED_RANGE_BROKEN
static int16s Nvref;
static int16s Nvref2;
static int16_t Nvref;
static int16_t Nvref2;
#endif /* ENABLE_ADC_EXTENDED_RANGE_BROKEN */
static int16u adcStaticConfig;
static uint16_t adcStaticConfig;
void halAdcSetClock(boolean slow)
{
@ -73,8 +73,8 @@ boolean halAdcGetRange(void)
void halAdcIsr(void)
{
int8u i;
int8u conversion = adcPendingConversion; //fix 'volatile' warning; costs no flash
uint8_t i;
uint8_t conversion = adcPendingConversion; //fix 'volatile' warning; costs no flash
// make sure data is ready and the desired conversion is valid
if ( (INT_ADCFLAG & INT_ADCULDFULL)
@ -105,7 +105,7 @@ void halAdcIsr(void)
// otherwise.
ADCUser startNextConversion()
{
int8u i;
uint8_t i;
ATOMIC (
// start the next requested conversion if any
@ -143,7 +143,7 @@ void halInternalInitAdc(void)
ADC_OFFSET = ADC_OFFSET_RESET;
ADC_GAIN = ADC_GAIN_RESET;
ADC_DMACFG = ADC_DMARST;
ADC_DMABEG = (int32u)&adcData;
ADC_DMABEG = (uint32_t)&adcData;
ADC_DMASIZE = 1;
ADC_DMACFG = (ADC_DMAAUTOWRAP | ADC_DMALOAD);
@ -186,7 +186,7 @@ StStatus halStartAdcConversion(ADCUser id,
return ST_ADC_CONVERSION_DEFERRED;
}
StStatus halRequestAdcData(ADCUser id, int16u *value)
StStatus halRequestAdcData(ADCUser id, uint16_t *value)
{
//Both the ADC interrupt and the global interrupt need to be enabled,
//otherwise the ADC ISR cannot be serviced.
@ -220,7 +220,7 @@ StStatus halRequestAdcData(ADCUser id, int16u *value)
return stat;
}
StStatus halReadAdcBlocking(ADCUser id, int16u *value)
StStatus halReadAdcBlocking(ADCUser id, uint16_t *value)
{
StStatus stat;
@ -250,13 +250,13 @@ StStatus halAdcCalibrate(ADCUser id)
ADC_SOURCE_VREF_VREF2,
ADC_CONVERSION_TIME_US_4096);
stat = halReadAdcBlocking(id, (int16u *)(&Nvref));
stat = halReadAdcBlocking(id, (uint16_t *)(&Nvref));
if (stat == ST_ADC_CONVERSION_DONE) {
halStartAdcConversion(id,
ADC_REF_INT,
ADC_SOURCE_VREF2_VREF2,
ADC_CONVERSION_TIME_US_4096);
stat = halReadAdcBlocking(id, (int16u *)(&Nvref2));
stat = halReadAdcBlocking(id, (uint16_t *)(&Nvref2));
}
if (stat == ST_ADC_CONVERSION_DONE) {
adcCalibrated = TRUE;
@ -272,13 +272,13 @@ StStatus halAdcCalibrate(ADCUser id)
ADC_REF_INT,
ADC_SOURCE_GND_VREF2,
ADC_CONVERSION_TIME_US_4096);
stat = halReadAdcBlocking(id, (int16u *)(&Nvss));
stat = halReadAdcBlocking(id, (uint16_t *)(&Nvss));
if (stat == ST_ADC_CONVERSION_DONE) {
halStartAdcConversion(id,
ADC_REF_INT,
ADC_SOURCE_VREG2_VREF2,
ADC_CONVERSION_TIME_US_4096);
stat = halReadAdcBlocking(id, (int16u *)(&Nvdd));
stat = halReadAdcBlocking(id, (uint16_t *)(&Nvdd));
}
if (stat == ST_ADC_CONVERSION_DONE) {
Nvdd -= Nvss;
@ -297,11 +297,11 @@ StStatus halAdcCalibrate(ADCUser id)
// FIXME: support high voltage range
// use Vref-Vref/2 to calibrate
// FIXME: check for mfg token specifying measured VDD_PADSA
int16s halConvertValueToVolts(int16u value)
int16_t halConvertValueToVolts(uint16_t value)
{
int32s N;
int16s V;
int32s nvalue;
int32_t N;
int16_t V;
int32_t nvalue;
if (!adcCalibrated) {
halAdcCalibrate(ADC_USER_LQI);
@ -317,10 +317,10 @@ int16s halConvertValueToVolts(int16u value)
#ifdef ENABLE_ADC_EXTENDED_RANGE_BROKEN
if(halAdcGetRange()){ // High range.
N = (((int32s)value + Nvref - 2*Nvref2) << 16)/(2*(Nvref-Nvref2));
N = (((int32_t)value + Nvref - 2*Nvref2) << 16)/(2*(Nvref-Nvref2));
// Calculate voltage with: V = (N * VREF) / (2^16) where VDD = 1.2 volts
// Mutiplying by 1.2*10000 makes the result of this equation 100 uVolts
V = (int16s)((N*12000L) >> 16);
V = (int16_t)((N*12000L) >> 16);
if (V > 21000) { // VDD_PADS ?
V = 21000;
}
@ -336,7 +336,7 @@ int16s halConvertValueToVolts(int16u value)
// Mutiplying by0.9*10000 makes the result of this equation 100 uVolts
// (in fixed point E-4 which allows for 13.5 bits vs millivolts
// which is only 10.2 bits).
V = (int16s)((N*9000L) >> 16);
V = (int16_t)((N*9000L) >> 16);
if (V > 12000) {
V = 12000;
}
@ -349,7 +349,7 @@ int16s halConvertValueToVolts(int16u value)
return V;
}
int8u halGetADCChannelFromGPIO(int32u io)
uint8_t halGetADCChannelFromGPIO(uint32_t io)
{
switch(io)
{

12
cpu/stm32w108/hal/micro/cortexm3/board.c
View file

@ -250,7 +250,7 @@ BoardResourcesType const *boardDescription = NULL;
void halBoardInit(void)
{
char boardName[16];
int8s i;
int8_t i;
boardDescription = NULL;
#ifdef EMBERZNET_HAL
halCommonGetToken(boardName, TOKEN_MFG_BOARD_NAME);
@ -318,7 +318,7 @@ void halBoardPowerDown(void)
/* Configure GPIO for BUTTONSs */
{
ButtonResourceType *buttons = (ButtonResourceType *) boardDescription->io->buttons;
int8u i;
uint8_t i;
for (i = 0; i < boardDescription->buttons; i++) {
halGpioConfig(PORTx_PIN(buttons[i].gpioPort, buttons[i].gpioPin), GPIOCFG_IN_PUD);
halGpioSet(PORTx_PIN(buttons[i].gpioPort, buttons[i].gpioPin), GPIOOUT_PULLUP);
@ -328,7 +328,7 @@ void halBoardPowerDown(void)
/* Configure GPIO for LEDs */
{
LedResourceType *leds = (LedResourceType *) boardDescription->io->leds;
int8u i;
uint8_t i;
for (i = 0; i < boardDescription->leds; i++) {
/* LED default off */
halGpioConfig(PORTx_PIN(leds[i].gpioPort, leds[i].gpioPin), GPIOCFG_OUT);
@ -394,7 +394,7 @@ void halBoardPowerUp(void)
/* Configure GPIO for LEDs */
{
LedResourceType *leds = (LedResourceType *) boardDescription->io->leds;
int8u i;
uint8_t i;
for (i = 0; i < boardDescription->leds; i++) {
/* LED default off */
halGpioConfig(PORTx_PIN(leds[i].gpioPort, leds[i].gpioPin), GPIOCFG_OUT);
@ -404,7 +404,7 @@ void halBoardPowerUp(void)
/* Configure GPIO for BUTTONSs */
{
ButtonResourceType *buttons = (ButtonResourceType *) boardDescription->io->buttons;
int8u i;
uint8_t i;
for (i = 0; i < boardDescription->buttons; i++) {
halGpioConfig(PORTx_PIN(buttons[i].gpioPort, buttons[i].gpioPin), GPIOCFG_IN_PUD);
halGpioSet(PORTx_PIN(buttons[i].gpioPort, buttons[i].gpioPin), GPIOOUT_PULLUP);
@ -448,7 +448,7 @@ void printButtons (ButtonResourceType *buttons)
void boardPrintStringDescription(void)
{
int8u i = 0;
uint8_t i = 0;
while (boardList[i] != NULL) {
if ((boardDescription == boardList[i]) || (boardDescription == NULL)) {

10
cpu/stm32w108/hal/micro/cortexm3/bootloader/fib-bootloader.h
View file

@ -22,7 +22,7 @@
//------------------------------------------------------------------------------
// Status values.
typedef int32u FibStatus;
typedef uint32_t FibStatus;
#define FIB_SUCCESS 0
#define FIB_ERR_UNALIGNED 1
@ -36,7 +36,7 @@ typedef int32u FibStatus;
//------------------------------------------------------------------------------
// Erase types.
typedef int32u FibEraseType;
typedef uint32_t FibEraseType;
#define MFB_MASS_ERASE 0x01
#define MFB_PAGE_ERASE 0x02
@ -48,9 +48,9 @@ typedef int32u FibEraseType;
//------------------------------------------------------------------------------
// Shared flash functions.
FibStatus fibFlashWrite(int32u address, int8u *data,
int32u writeLength, int32u verifyLength);
FibStatus fibFlashWrite(uint32_t address, uint8_t *data,
uint32_t writeLength, uint32_t verifyLength);
FibStatus fibFlashErase(FibEraseType eraseType, int32u address);
FibStatus fibFlashErase(FibEraseType eraseType, uint32_t address);
#endif //__FIB_BOOTLOADER_H__

8
cpu/stm32w108/hal/micro/cortexm3/button.c
View file

@ -12,7 +12,7 @@
void halInitButton(void)
{
int8u i;
uint8_t i;
/* Configure GPIO for BUTTONSs */
ButtonResourceType *buttons = (ButtonResourceType *) boardDescription->io->buttons;
for (i = 0; i < boardDescription->buttons; i++) {
@ -22,10 +22,10 @@ void halInitButton(void)
}/* end halInitButton() */
int8u halGetButtonStatus(HalBoardButton button)
uint8_t halGetButtonStatus(HalBoardButton button)
{
int8u port = (button >> 3) & 0xf;
int8u pin = button & 0x7;
uint8_t port = (button >> 3) & 0xf;
uint8_t pin = button & 0x7;
if (button != DUMMY_BUTTON)
{

24
cpu/stm32w108/hal/micro/cortexm3/clocks.c
View file

@ -59,10 +59,10 @@
#define CLK1K_NUMERATOR 384000000
void halInternalCalibrateSlowRc( void )
{
int8u i;
int32u average=0;
int16s delta;
int32u period;
uint8_t i;
uint32_t average=0;
int16_t delta;
uint32_t period;
CALDBG(
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "halInternalCalibrateSlowRc:\r\n");
@ -85,7 +85,7 @@ void halInternalCalibrateSlowRc( void )
stSerialPrintf(ST_ASSERT_SERIAL_PORT,
"period: %u, ", CLK_PERIOD);
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "%u Hz\r\n",
((int16u)(((int32u)192000000)/((int32u)CLK_PERIOD))));
((uint16_t)(((uint32_t)192000000)/((uint32_t)CLK_PERIOD))));
)
//For 10kHz, the ideal CLK_PERIOD is 19200. Calculate the PERIOD delta.
//It's possible for a chip's 10kHz source RC to be too far out of range
@ -120,7 +120,7 @@ void halInternalCalibrateSlowRc( void )
stSerialPrintf(ST_ASSERT_SERIAL_PORT,
"period: %u, ", CLK_PERIOD);
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "%u Hz\r\n",
((int16u)(((int32u)192000000)/((int32u)CLK_PERIOD))));
((uint16_t)(((uint32_t)192000000)/((uint32_t)CLK_PERIOD))));
)
//The analog section should now be producing an output of ~10kHz
@ -138,11 +138,11 @@ void halInternalCalibrateSlowRc( void )
average = (average+(SLOWRC_PERIOD_SAMPLES/2))/SLOWRC_PERIOD_SAMPLES;
CALDBG(
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "average: %u, %u Hz\r\n",
((int16u)average), ((int16u)(((int32u)192000000)/((int32u)average))));
((uint16_t)average), ((uint16_t)(((uint32_t)192000000)/((uint32_t)average))));
)
//using an average period sample, calculate the clk1k divisor
CLK1K_CAL = (int16u)(CLK1K_NUMERATOR/average);
CLK1K_CAL = (uint16_t)(CLK1K_NUMERATOR/average);
CALDBG(
stSerialPrintf(ST_ASSERT_SERIAL_PORT,"CLK1K_CAL=%2X\r\n",CLK1K_CAL);
)
@ -167,7 +167,7 @@ void halInternalCalibrateSlowRc( void )
// CLK_PERIOD
void halInternalCalibrateFastRc(void)
{
int32s newTune = -16;
int32_t newTune = -16;
CALDBG(
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "halInternalCalibrateFastRc:\r\n");
@ -188,7 +188,7 @@ void halInternalCalibrateFastRc(void)
stSerialPrintf(ST_ASSERT_SERIAL_PORT,
"period: %u, ", CLK_PERIOD);
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "%u kHz\r\n",
((int16u)((((int32u)3072000000)/((int32u)CLK_PERIOD))/1000)));
((uint16_t)((((uint32_t)3072000000)/((uint32_t)CLK_PERIOD))/1000)));
)
//For 12MHz, the ideal CLK_PERIOD is 256. Tune the frequency down until
//the period is <= 256, which says the frequency is as close to 12MHz as
@ -211,7 +211,7 @@ void halInternalCalibrateFastRc(void)
stSerialPrintf(ST_ASSERT_SERIAL_PORT,
"period: %u, ", CLK_PERIOD);
stSerialPrintf(ST_ASSERT_SERIAL_PORT, "%u kHz\r\n",
((int16u)((((int32u)3072000000)/((int32u)CLK_PERIOD))/1000)));
((uint16_t)((((uint32_t)3072000000)/((uint32_t)CLK_PERIOD))/1000)));
)
//The analog section should now be producing an output of 11.5MHz - 12.0MHz
@ -337,7 +337,7 @@ static boolean setBiasCheckLow(void)
void halInternalSearchForBiasTrim(void)
{
int8u bit;
uint8_t bit;
//Enable the XTAL so we can search for the proper bias trim (NOTE: This
//will also forcefully ensure we're on the OSCHF so that we don't

25
cpu/stm32w108/hal/micro/cortexm3/compiler/gnu.h
View file

@ -18,6 +18,9 @@
#ifndef __GNU_H__
#define __GNU_H__
#include <stdint.h>
#ifndef __GNUC__
#error Improper PLATFORM_HEADER
#endif
@ -40,7 +43,7 @@
#include <stdarg.h>
#if defined (CORTEXM3_STM32W108)
#include "micro/cortexm3/stm32w108/regs.h"
#include "micro/cortexm3/stm32w108/stm32w108_type.h"
#include "micro/cortexm3/stm32w108/stm32w108-type.h"
#else
#error Unknown CORTEXM3 micro
#endif
@ -90,12 +93,12 @@
* @brief A typedef to make the size of the variable explicitly known.
*/
typedef unsigned char boolean;
typedef unsigned char int8u;
typedef signed char int8s;
typedef unsigned short int16u;
typedef signed short int16s;
typedef unsigned int int32u;
typedef signed int int32s;
//typedef unsigned char uint8_t;
//typedef signed char int8_t;
//typedef unsigned short uint16_t;
//typedef signed short int16_t;
//typedef unsigned int uint32_t;
//typedef signed int int32_t;
typedef unsigned int PointerType;
//@} \\END MASTER VARIABLE TYPES
@ -363,7 +366,7 @@ void _executeBarrierInstructions(void);
* declarations section of any function which calls DISABLE_INTERRUPTS()
* or RESTORE_INTERRUPTS().
*/
#define DECLARE_INTERRUPT_STATE int8u _emIsrState
#define DECLARE_INTERRUPT_STATE uint8_t _emIsrState
// Prototypes for the BASEPRI and PRIMASK access functions. They are very
// basic and instantiated in assembly code in the file spmr.s37 (since
@ -372,13 +375,13 @@ void _executeBarrierInstructions(void);
// with a priority equal to or less than the BASEPRI value.
// Note that the priority values used by these functions are 5 bits and
// right-aligned
extern int8u _readBasePri(void);
extern void _writeBasePri(int8u priority);
extern uint8_t _readBasePri(void);
extern void _writeBasePri(uint8_t priority);
// Prototypes for BASEPRI functions used to disable and enable interrupts
// while still allowing enabled faults to trigger.
extern void _enableBasePri(void);
extern int8u _disableBasePri(void);
extern uint8_t _disableBasePri(void);
extern boolean _basePriIsDisabled(void);
// Prototypes for setting and clearing PRIMASK for global interrupt

22
cpu/stm32w108/hal/micro/cortexm3/compiler/iar.h
View file

@ -33,7 +33,7 @@
#include <stdarg.h>
#if defined (CORTEXM3_STM32W108)
#include "micro/cortexm3/stm32w108/regs.h"
#include "micro/cortexm3/stm32w108/stm32w108_type.h"
#include "micro/cortexm3/stm32w108/stm32w108-type.h"
#elif defined (CORTEXM3_STM32F103)
#include "stm32f10x.h"
#else
@ -87,12 +87,12 @@
* @brief A typedef to make the size of the variable explicitly known.
*/
typedef unsigned char boolean;
typedef unsigned char int8u;
typedef signed char int8s;
typedef unsigned short int16u;
typedef signed short int16s;
typedef unsigned int int32u;
typedef signed int int32s;
typedef unsigned char uint8_t;
typedef signed char int8_t;
typedef unsigned short uint16_t;
typedef signed short int16_t;
typedef unsigned int uint32_t;
typedef signed int int32_t;
typedef unsigned int PointerType;
//@} \\END MASTER VARIABLE TYPES
@ -359,7 +359,7 @@ void _executeBarrierInstructions(void);
* declarations section of any function which calls DISABLE_INTERRUPTS()
* or RESTORE_INTERRUPTS().
*/
#define DECLARE_INTERRUPT_STATE int8u _emIsrState
#define DECLARE_INTERRUPT_STATE uint8_t _emIsrState
// Prototypes for the BASEPRI and PRIMASK access functions. They are very
// basic and instantiated in assembly code in the file spmr.s37 (since
@ -368,13 +368,13 @@ void _executeBarrierInstructions(void);
// with a priority equal to or less than the BASEPRI value.
// Note that the priority values used by these functions are 5 bits and
// right-aligned
extern int8u _readBasePri(void);
extern void _writeBasePri(int8u priority);
extern uint8_t _readBasePri(void);
extern void _writeBasePri(uint8_t priority);
// Prototypes for BASEPRI functions used to disable and enable interrupts
// while still allowing enabled faults to trigger.
extern void _enableBasePri(void);
extern int8u _disableBasePri(void);
extern uint8_t _disableBasePri(void);
extern boolean _basePriIsDisabled(void);
// Prototypes for setting and clearing PRIMASK for global interrupt

2
cpu/stm32w108/hal/micro/cortexm3/context-switch.s79
View file

@ -53,7 +53,7 @@ halPendSvSaveContext:
//------------------------------------------------------------------------------
// int32u savedMSP
// uint32_t savedMSP
//
// Private storage to hold the saved stack pointer. This variable is only used
// in this file and should not be extern'ed. In our current design we

149
cpu/stm32w108/hal/micro/cortexm3/cstartup_M.s
View file

@ -1,149 +0,0 @@
/**************************************************
*
* Part one of the system initialization code, contains low-level
* initialization, plain thumb variant.
*
* Customized by St Corporation for STM32W
*<!--(C) COPYRIGHT 2010 STMicroelectronics. All rights reserved. -->
*
**************************************************/
;
; The modules in this file are included in the libraries, and may be replaced
; by any user-defined modules that define the PUBLIC symbol _program_start or
; a user defined start symbol.
; To override the cstartup defined in the library, simply add your modified
; version to the workbench project.
;
; The vector table is normally located at address 0.
; When debugging in RAM, it can be located in RAM, aligned to at least 2^6.
; The name "__vector_table" has special meaning for C-SPY:
; it is where the SP start value is found, and the NVIC vector
; table register (VTOR) is initialized to this address if != 0.
;
; Cortex-M version
;
MODULE ?cstartup
;; Forward declaration of sections.
SECTION CSTACK:DATA:NOROOT(3)
SECTION .intvec:CODE:NOROOT(2)
EXTERN __iar_program_start
PUBLIC __vector_table
DATA
__vector_table
DCD sfe(CSTACK)
DCD __iar_program_start
;; Standard Cortex-M3 Vectors
DCD NMI_Handler ;;NMI Handler
DCD HardFault_Handler ;;Hard Fault Handler
DCD MemManage_Handler ;;Memory Fault Handler
DCD BusFault_Handler ;;Bus Fault Handler
DCD UsageFault_Handler ;;Usage Fault Handler
DCD 0 ;;Reserved
DCD 0 ;;Reserved
DCD 0 ;;Reserved
DCD 0 ;;Reserved
DCD SVC_Handler ;;SVCall Handler
DCD DebugMon_Handler ;;Debug Monitor Handler
DCD 0 ;;Reserved
DCD PendSV_Handler ;;PendSV Handler
DCD SysTick_Handler ;;SysTick Handler
;; STM32W Vectors
DCD halTimer1Isr ;;Timer 1 Handler
DCD halTimer2Isr ;;Timer 2 Handler
DCD halManagementIsr ;;Management Handler
DCD halBaseBandIsr ;;BaseBand Handler
DCD halSleepTimerIsr ;;Sleep Timer Handler
DCD halSc1Isr ;;SC1 Handler
DCD halSc2Isr ;;SC2 Handler
DCD halSecurityIsr ;;Security Handler
DCD halStackMacTimerIsr ;;MAC Timer Handler
DCD stmRadioTransmitIsr ;;MAC TX Handler
DCD stmRadioReceiveIsr ;;MAC RX Handler
DCD halAdcIsr ;;ADC Handler
DCD halIrqAIsr ;;GPIO IRQA Handler
DCD halIrqBIsr ;;GPIO IRQB Handler
DCD halIrqCIsr ;;GPIO IRQC Handler
DCD halIrqDIsr ;;GPIO IRQD Handler
DCD halDebugIsr ;;Debug Handler
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Default interrupt handlers.
;;
PUBWEAK NMI_Handler
PUBWEAK HardFault_Handler
PUBWEAK MemManage_Handler
PUBWEAK BusFault_Handler
PUBWEAK UsageFault_Handler
PUBWEAK SVC_Handler
PUBWEAK DebugMon_Handler
PUBWEAK PendSV_Handler
PUBWEAK SysTick_Handler
PUBWEAK halTimer1Isr
PUBWEAK halTimer2Isr
PUBWEAK halManagementIsr
PUBWEAK halBaseBandIsr
PUBWEAK halSleepTimerIsr
PUBWEAK halSc1Isr
PUBWEAK halSc2Isr
PUBWEAK halSecurityIsr
PUBWEAK halStackMacTimerIsr
PUBWEAK stmRadioTransmitIsr
PUBWEAK stmRadioReceiveIsr
PUBWEAK halAdcIsr
PUBWEAK halIrqAIsr
PUBWEAK halIrqBIsr
PUBWEAK halIrqCIsr
PUBWEAK halIrqDIsr
PUBWEAK halDebugIsr
SECTION .text:CODE:REORDER(1)
THUMB
NMI_Handler
HardFault_Handler
MemManage_Handler
BusFault_Handler
UsageFault_Handler
SVC_Handler
DebugMon_Handler
PendSV_Handler
SysTick_Handler
halTimer1Isr
halTimer2Isr
halManagementIsr
halBaseBandIsr
halSleepTimerIsr
halSc1Isr
halSc2Isr
halSecurityIsr
halStackMacTimerIsr
stmRadioTransmitIsr
stmRadioReceiveIsr
halAdcIsr
halIrqAIsr
halIrqBIsr
halIrqCIsr
halIrqDIsr
halDebugIsr
Default_Handler
B Default_Handler
END

68
cpu/stm32w108/hal/micro/cortexm3/flash.c
View file

@ -85,10 +85,10 @@ static void disableFlitf(void)
FLASH_CTRL = FLASH_CTRL_LOCK; //lock the flash from further accesses
}
static FibStatus fibFlashWrite(int32u address, int8u *data, int32u length, int32u dummy)
static FibStatus fibFlashWrite(uint32_t address, uint8_t *data, uint32_t length, uint32_t dummy)
{
int32u i;
int16u *ptr;
uint32_t i;
uint16_t *ptr;
FibStatus status = FIB_SUCCESS;
// Address and length must be half-word aligned.
if ((address & 1) || (length & 1)) {
@ -100,10 +100,10 @@ static FibStatus fibFlashWrite(int32u address, int8u *data, int32u length, int32
return FIB_ERR_INVALID_ADDRESS;
}
enableFlitf();
ptr = (int16u *)address;
ptr = (uint16_t *)address;
for (i = 0; i < length; i += 2) {
int16u currentData = *ptr;
int16u newData = HIGH_LOW_TO_INT(data[i + 1], data[i]);
uint16_t currentData = *ptr;
uint16_t newData = HIGH_LOW_TO_INT(data[i + 1], data[i]);
// Only program the data if it makes sense to do so.
if (currentData == newData) {
// If the new data matches the flash, don't bother doing anything.
@ -111,7 +111,7 @@ static FibStatus fibFlashWrite(int32u address, int8u *data, int32u length, int32
// If the flash is 0xFFFF we're allowed to write anything.
// If the new data is 0x0000 it doesn't matter what the flash is.
// OPTWREN must stay set to keep CIB unlocked.
if ((CIB_OB_BOTTOM <= (int32u)ptr) && ((int32u)ptr <= CIB_OB_TOP)) {
if ((CIB_OB_BOTTOM <= (uint32_t)ptr) && ((uint32_t)ptr <= CIB_OB_TOP)) {
FLASH_CTRL = (FLASH_CTRL_OPTWREN | FLASH_CTRL_OPTPROG);
} else {
FLASH_CTRL = (FLASH_CTRL_OPTWREN | FLASH_CTRL_PROG);
@ -144,10 +144,10 @@ static FibStatus fibFlashWrite(int32u address, int8u *data, int32u length, int32
return status;
}
static FibStatus fibFlashWriteVerify(int32u address, int8u *data, int32u length)
static FibStatus fibFlashWriteVerify(uint32_t address, uint8_t *data, uint32_t length)
{
int32u i;
int8u *ptr = (int8u *)address;
uint32_t i;
uint8_t *ptr = (uint8_t *)address;
for (i = 0; i < length; i++) {
if (*ptr != data[i]) {
return FIB_ERR_VERIFY_FAILED;
@ -157,26 +157,26 @@ static FibStatus fibFlashWriteVerify(int32u address, int8u *data, int32u length)
return FIB_SUCCESS;
}
static FibStatus fibFlashErase(FibEraseType eraseType, int32u address)
static FibStatus fibFlashErase(FibEraseType eraseType, uint32_t address)
{
int32u eraseOp;
int32u *ptr;
int32u length;
uint32_t eraseOp;
uint32_t *ptr;
uint32_t length;
FibStatus status = FIB_SUCCESS;
if (BYTE_0(eraseType) == MFB_MASS_ERASE) {
eraseOp = FLASH_CTRL_MASSERASE;
ptr = (int32u *)MFB_BOTTOM;
ptr = (uint32_t *)MFB_BOTTOM;
length = MFB_SIZE_W;
} else if (BYTE_0(eraseType) == MFB_PAGE_ERASE) {
if (address < MFB_BOTTOM || address > MFB_TOP) {
return FIB_ERR_INVALID_ADDRESS;
}
eraseOp = FLASH_CTRL_PAGEERASE;
ptr = (int32u *)(address & MFB_PAGE_MASK_B);
ptr = (uint32_t *)(address & MFB_PAGE_MASK_B);
length = MFB_PAGE_SIZE_W;
} else if (BYTE_0(eraseType) == CIB_ERASE) {
eraseOp = FLASH_CTRL_OPTWREN | FLASH_CTRL_OPTERASE;
ptr = (int32u *)CIB_BOTTOM;
ptr = (uint32_t *)CIB_BOTTOM;
length = CIB_SIZE_W;
} else {
return FIB_ERR_INVALID_TYPE;
@ -203,7 +203,7 @@ static FibStatus fibFlashErase(FibEraseType eraseType, int32u address)
}
if (status == FIB_SUCCESS
&& (eraseType & DO_VERIFY) != 0) {
int32u i;
uint32_t i;
for (i = 0; i < length; i++) {
if (*ptr != 0xFFFFFFFF) {
return FIB_ERR_VERIFY_FAILED;
@ -228,7 +228,7 @@ static boolean verifyFib(void)
//The parameter 'eraseType' chooses which erasure will be performed while
//the 'address' parameter chooses the page to be erased during MFB page erase.
StStatus halInternalFlashErase(int8u eraseType, int32u address)
StStatus halInternalFlashErase(uint8_t eraseType, uint32_t address)
{
FibStatus status;
@ -239,10 +239,10 @@ StStatus halInternalFlashErase(int8u eraseType, int32u address)
// Always try to use the FIB bootloader if its present
if(verifyFib()) {
status = halFixedAddressTable.fibFlashErase(
(((int32u)eraseType) | DO_ERASE),
(((uint32_t)eraseType) | DO_ERASE),
address);
} else {
status = fibFlashErase((((int32u)eraseType) | DO_ERASE), address);
status = fibFlashErase((((uint32_t)eraseType) | DO_ERASE), address);
}
#else
@ -250,7 +250,7 @@ StStatus halInternalFlashErase(int8u eraseType, int32u address)
assert(verifyFib());
status = halFixedAddressTable.fibFlashErase(
(((int32u)eraseType) | DO_ERASE),
(((uint32_t)eraseType) | DO_ERASE),
address);
#endif
)
@ -270,14 +270,14 @@ StStatus halInternalFlashErase(int8u eraseType, int32u address)
// Always try to use the FIB bootloader if its present
if(verifyFib()) {
status = halFixedAddressTable.fibFlashErase(
(((int32u)eraseType) | DO_VERIFY),
(((uint32_t)eraseType) | DO_VERIFY),
address);
} else {
status = fibFlashErase((((int32u)eraseType) | DO_VERIFY), address);
status = fibFlashErase((((uint32_t)eraseType) | DO_VERIFY), address);
}
#else
status = halFixedAddressTable.fibFlashErase(
(((int32u)eraseType) | DO_VERIFY),
(((uint32_t)eraseType) | DO_VERIFY),
address);
#endif
return fibToStStatus[status];
@ -291,7 +291,7 @@ StStatus halInternalFlashErase(int8u eraseType, int32u address)
//half-words contained in 'data' to be written to flash.
//NOTE: This function can NOT write the option bytes and will throw an error
//if that is attempted.
StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length)
StStatus halInternalFlashWrite(uint32_t address, uint16_t * data, uint32_t length)
{
FibStatus status;
@ -303,11 +303,11 @@ StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length)
// Always try to use the FIB bootloader if its present
if(verifyFib()) {
status = halFixedAddressTable.fibFlashWrite(address,
(int8u *)data,
(uint8_t *)data,
length,
0);
} else {
status = fibFlashWrite(address, (int8u *)data, length, 0);
status = fibFlashWrite(address, (uint8_t *)data, length, 0);
}
#else
@ -316,7 +316,7 @@ StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length)
// Ensure that a programmed FIB of a proper version is present
assert(verifyFib());
status = halFixedAddressTable.fibFlashWrite(address,
(int8u *)data,
(uint8_t *)data,
length,
0);
#endif
@ -331,15 +331,15 @@ StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length)
// Always try to use the FIB bootloader if its present
if(verifyFib()) {
status = halFixedAddressTable.fibFlashWrite(address,
(int8u *)data,
(uint8_t *)data,
0,
length);
} else {
status = fibFlashWriteVerify(address, (int8u *)data, length);
status = fibFlashWriteVerify(address, (uint8_t *)data, length);
}
#else
status = halFixedAddressTable.fibFlashWrite(address,
(int8u *)data,
(uint8_t *)data,
0,
length);
#endif
@ -352,9 +352,9 @@ StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length)
//parameter can have a value of 0 through 7. 'data' is the 8bit value to be
//programmed into the option byte since the hardware will calculate the
//compliment and program the full 16bit option byte.
StStatus halInternalCibOptionByteWrite(int8u byte, int8u data)
StStatus halInternalCibOptionByteWrite(uint8_t byte, uint8_t data)
{
int16u dataAndInverse = HIGH_LOW_TO_INT(~data, data);
uint16_t dataAndInverse = HIGH_LOW_TO_INT(~data, data);
// There are only 8 option bytes, don't try to program more than that.
if (byte > 7) {
return ST_ERR_FLASH_PROG_FAIL;

6
cpu/stm32w108/hal/micro/cortexm3/flash.h
View file

@ -65,7 +65,7 @@ boolean halFlashEraseIsActive(void);
* - ST_ERR_FLASH_VERIFY_FAILED if erase verification failed
* - ST_SUCCESS if erasure completed and verified properly
*/
StStatus halInternalFlashErase(int8u eraseType, int32u address);
StStatus halInternalFlashErase(uint8_t eraseType, uint32_t address);
/** @brief Writes a block of words to flash. A page is erased
* to 0xFFFF at every address. Only two writes can be performed to the same
@ -96,7 +96,7 @@ StStatus halInternalFlashErase(int8u eraseType, int32u address);
* - ST_ERR_FLASH_VERIFY_FAILED if write verification failed
* - ST_SUCCESS if writing completed and verified properly
*/
StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length);
StStatus halInternalFlashWrite(uint32_t address, uint16_t * data, uint32_t length);
/** @brief Writes an option byte to the customer information block. Only
* two writes can be performed to the same address between erasures and this
@ -116,7 +116,7 @@ StStatus halInternalFlashWrite(int32u address, int16u * data, int32u length);
* - ST_ERR_FLASH_VERIFY_FAILED if write verification failed
* - ST_SUCCESS if writing completed and verified properly
*/
StStatus halInternalCibOptionByteWrite(int8u byte, int8u data);
StStatus halInternalCibOptionByteWrite(uint8_t byte, uint8_t data);
#endif //DOXYGEN_SHOULD_SKIP_THIS

2
cpu/stm32w108/hal/micro/cortexm3/led.c
View file

@ -36,7 +36,7 @@ void halToggleLed(HalBoardLed led)
//purposes, we disable interrupts since this is a read-modify-write
ATOMIC(
if(led/8 < 3) {
*((volatile int32u *)(GPIO_PxOUT_BASE+(GPIO_Px_OFFSET*(led/8)))) ^= BIT(led&7);
*((volatile uint32_t *)(GPIO_PxOUT_BASE+(GPIO_Px_OFFSET*(led/8)))) ^= BIT(led&7);
}
)
}

6
cpu/stm32w108/hal/micro/cortexm3/memmap-fat.h
View file

@ -29,9 +29,9 @@ typedef struct {
HalBootloaderAddressTableType *bootloaderAddressTable;
void *startOfUnusedRam;
// ** pointers to shared functions **
FibStatus (* fibFlashWrite)(int32u address, int8u *data,
int32u writeLength, int32u verifyLength);
FibStatus (* fibFlashErase)(FibEraseType eraseType, int32u address);
FibStatus (* fibFlashWrite)(uint32_t address, uint8_t *data,
uint32_t writeLength, uint32_t verifyLength);
FibStatus (* fibFlashErase)(FibEraseType eraseType, uint32_t address);
} HalFixedAddressTableType;
extern const HalFixedAddressTableType halFixedAddressTable;

4
cpu/stm32w108/hal/micro/cortexm3/memmap.h
View file

@ -53,8 +53,8 @@ typedef struct {
void (*resetVector)(void);
void (*nmiHandler)(void);
void (*hardFaultHandler)(void);
int16u type;
int16u version;
uint16_t type;
uint16_t version;
const HalVectorTableType *vectorTable;
// Followed by more fields depending on the specific address table type
} HalBaseAddressTableType;

44
cpu/stm32w108/hal/micro/cortexm3/mems.c
View file

@ -19,19 +19,19 @@
#define WAIT_TX_FIN() do{}while((SC2_TWISTAT&SC_TWITXFIN)!=SC_TWITXFIN)
#define WAIT_RX_FIN() do{}while((SC2_TWISTAT&SC_TWIRXFIN)!=SC_TWIRXFIN)
static int8u i2c_MEMS_Init (void);
static int8u i2c_MEMS_Read (t_mems_data *mems_data);
static uint8_t i2c_MEMS_Init (void);
static uint8_t i2c_MEMS_Read (t_mems_data *mems_data);
//extern void halInternalResetWatchDog(void);
static int8u i2c_Send_Frame (int8u DeviceAddress, int8u *pBuffer, int8u NoOfBytes);
static int8u i2c_Send_Frame (int8u DeviceAddress, int8u *pBuffer, int8u NoOfBytes);
int8u i2c_write_reg (int8u slave_addr, int8u reg_addr, int8u reg_value);
static int8u i2c_MEMS_Init (void);
static int8u i2c_MEMS_Read (t_mems_data *mems_data);
static uint8_t i2c_Send_Frame (uint8_t DeviceAddress, uint8_t *pBuffer, uint8_t NoOfBytes);
static uint8_t i2c_Send_Frame (uint8_t DeviceAddress, uint8_t *pBuffer, uint8_t NoOfBytes);
uint8_t i2c_write_reg (uint8_t slave_addr, uint8_t reg_addr, uint8_t reg_value);
static uint8_t i2c_MEMS_Init (void);
static uint8_t i2c_MEMS_Read (t_mems_data *mems_data);
/* Functions -----------------------------------------------------------------*/
int8u mems_Init(void)
uint8_t mems_Init(void)
{
int8u ret = 0;
uint8_t ret = 0;
// GPIO assignments
// PA1: SC2SDA (Serial Data)
@ -60,9 +60,9 @@ int8u mems_Init(void)
return ret;
}/* end mems_Init */
int8u mems_GetValue(t_mems_data *mems_data)
uint8_t mems_GetValue(t_mems_data *mems_data)
{
int8u i;
uint8_t i;
i = i2c_MEMS_Read(mems_data);
return i;
}/* end mems_GetValue() */
@ -79,9 +79,9 @@ int8u mems_GetValue(t_mems_data *mems_data)
* Output : None
* Return : status
*******************************************************************************/
static int8u i2c_Send_Frame (int8u DeviceAddress, int8u *pBuffer, int8u NoOfBytes)
static uint8_t i2c_Send_Frame (uint8_t DeviceAddress, uint8_t *pBuffer, uint8_t NoOfBytes)
{
int8u i, data;
uint8_t i, data;
SC2_TWICTRL1 |= SC_TWISTART; // send start
WAIT_CMD_FIN();
@ -115,9 +115,9 @@ static int8u i2c_Send_Frame (int8u DeviceAddress, int8u *pBuffer, int8u NoOfByte
* Output : buffer
* Return : status
*******************************************************************************/
static int8u i2c_Receive_Frame (int8u slave_addr, int8u reg_addr, int8u *pBuffer, int8u NoOfBytes)
static uint8_t i2c_Receive_Frame (uint8_t slave_addr, uint8_t reg_addr, uint8_t *pBuffer, uint8_t NoOfBytes)
{
int8u i, addr = reg_addr;
uint8_t i, addr = reg_addr;
if (NoOfBytes > 1)
addr += REPETIR;
@ -168,9 +168,9 @@ static int8u i2c_Receive_Frame (int8u slave_addr, int8u reg_addr, int8u *pBuffer
* Output : None
* Return : I2C frame
*******************************************************************************/
int8u i2c_write_reg (int8u slave_addr, int8u reg_addr, int8u reg_value)
uint8_t i2c_write_reg (uint8_t slave_addr, uint8_t reg_addr, uint8_t reg_value)
{
int8u i2c_buffer[2];
uint8_t i2c_buffer[2];
i2c_buffer[0] = reg_addr;
i2c_buffer[1] = reg_value;
@ -188,7 +188,7 @@ int8u i2c_write_reg (int8u slave_addr, int8u reg_addr, int8u reg_value)
* Output : None
* Return : I2C frame
*******************************************************************************/
int8u i2c_read_reg (int8u slave_addr, int8u reg_addr, int8u *pBuffer, int8u NoOfBytes)
uint8_t i2c_read_reg (uint8_t slave_addr, uint8_t reg_addr, uint8_t *pBuffer, uint8_t NoOfBytes)
{
return i2c_Receive_Frame (slave_addr, reg_addr, pBuffer, NoOfBytes);
}/* end i2c_read_reg() */
@ -201,9 +201,9 @@ int8u i2c_read_reg (int8u slave_addr, int8u reg_addr, int8u *pBuffer, int8u NoOf
* Output : None
* Return : status
*******************************************************************************/
static int8u i2c_MEMS_Init (void)
static uint8_t i2c_MEMS_Init (void)
{
int8u i = 0;
uint8_t i = 0;
i += i2c_write_reg (kLIS3L02DQ_SLAVE_ADDR, STATUS_REG, 0x00); //no flag
i += i2c_write_reg (kLIS3L02DQ_SLAVE_ADDR, FF_WU_CFG, 0x00); // all off
@ -224,9 +224,9 @@ static int8u i2c_MEMS_Init (void)
* Output : mems_data
* Return : I2C frame
*******************************************************************************/
static int8u i2c_MEMS_Read (t_mems_data *mems_data)
static uint8_t i2c_MEMS_Read (t_mems_data *mems_data)
{
int8u i, i2c_buffer[8];
uint8_t i, i2c_buffer[8];
/* Wait for new set of data to be available */
while (1) {

20
cpu/stm32w108/hal/micro/cortexm3/mfg-token.c
View file

@ -13,7 +13,7 @@
#define DEFINETOKENS
#define TOKEN_MFG(name,creator,iscnt,isidx,type,arraysize,...) \
const int16u TOKEN_##name = TOKEN_##name##_ADDRESS;
const uint16_t TOKEN_##name = TOKEN_##name##_ADDRESS;
#include "hal/micro/cortexm3/token-manufacturing.h"
#undef TOKEN_DEF
#undef TOKEN_MFG
@ -26,12 +26,12 @@
static const int8u nullEui[] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF };
static const uint8_t nullEui[] = { 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF };
void halInternalGetMfgTokenData(void *data, int16u ID, int8u index, int8u len)
void halInternalGetMfgTokenData(void *data, uint16_t ID, uint8_t index, uint8_t len)
{
int8u *ram = (int8u*)data;
uint8_t *ram = (uint8_t*)data;
//0x7F is a non-indexed token. Remap to 0 for the address calculation
index = (index==0x7F) ? 0 : index;
@ -53,8 +53,8 @@ void halInternalGetMfgTokenData(void *data, int16u ID, int8u index, int8u len)
//bottom 16bits of the token's actual address. Since the info blocks
//exist in the range DATA_BIG_INFO_BASE-DATA_BIG_INFO_END, we need
//to OR the ID with DATA_BIG_INFO_BASE to get the real address.
int32u realAddress = (DATA_BIG_INFO_BASE|ID) + (len*index);
int8u *flash = (int8u *)realAddress;
uint32_t realAddress = (DATA_BIG_INFO_BASE|ID) + (len*index);
uint8_t *flash = (uint8_t *)realAddress;
@ -74,12 +74,12 @@ void halInternalGetMfgTokenData(void *data, int16u ID, int8u index, int8u len)
}
void halInternalSetMfgTokenData(int16u token, void *data, int8u len)
void halInternalSetMfgTokenData(uint16_t token, void *data, uint8_t len)
{
StStatus flashStatus;
int32u realAddress = (DATA_BIG_INFO_BASE|token);
int8u * flash = (int8u *)realAddress;
int32u i;
uint32_t realAddress = (DATA_BIG_INFO_BASE|token);
uint8_t * flash = (uint8_t *)realAddress;
uint32_t i;
//The flash library (and hardware) requires the address and length to both
//be multiples of 16bits. Since this API is only valid for writing to

6
cpu/stm32w108/hal/micro/cortexm3/mfg-token.h
View file

@ -26,7 +26,7 @@
* will be stored. This parameter is generated with a macro above.
*/
#define TOKEN_MFG(name,creator,iscnt,isidx,type,arraysize,...) \
extern const int16u TOKEN_##name;
extern const uint16_t TOKEN_##name;
#include "hal/micro/cortexm3/token-manufacturing.h"
#undef TOKEN_MFG
@ -125,7 +125,7 @@ enum {
* @param len: The length of the token being worked on. This value is
* automatically set by the API to be the size of the token.
*/
void halInternalGetMfgTokenData(void *data, int16u token, int8u index, int8u len);
void halInternalGetMfgTokenData(void *data, uint16_t token, uint8_t index, uint8_t len);
/**
* @description Sets the value of a token in non-volatile storage. This is
@ -147,7 +147,7 @@ void halInternalGetMfgTokenData(void *data, int16u token, int8u index, int8u len
* @param len: The length of the token being worked on. This value is
* automatically set by the API to be the size of the token.
*/
void halInternalSetMfgTokenData(int16u token, void *data, int8u len);
void halInternalSetMfgTokenData(uint16_t token, void *data, uint8_t len);
#define halCommonGetMfgToken( data, token ) \
halInternalGetMfgTokenData(data, token, 0x7F, token##_SIZE)

46
cpu/stm32w108/hal/micro/cortexm3/micro-common-internal.c
View file

@ -54,8 +54,8 @@ void stCalibrateVref(void)
assert(FALSE);
} else {
//The bias trim token is set, so use the trim directly
int16u temp_value;
int16u mask = 0xFFFF;
uint16_t temp_value;
uint16_t mask = 0xFFFF;
// halClearLed(BOARDLED3);
@ -95,11 +95,11 @@ void calDisableAdc(void) {
// These routines maintain the same signature as their hal- counterparts to
// facilitate simple support between phys.
// It is assumed (hoped?) that the compiler will optimize out unused arguments.
StStatus calStartAdcConversion(int8u dummy1, // Not used.
int8u dummy2, // Not used.
int8u channel,
int8u rate,
int8u clock) {
StStatus calStartAdcConversion(uint8_t dummy1, // Not used.
uint8_t dummy2, // Not used.
uint8_t channel,
uint8_t rate,
uint8_t clock) {
// Disable the Calibration ADC interrupt so that we can poll it.
INT_MGMTCFG &= ~INT_MGMTCALADC;
@ -118,14 +118,14 @@ StStatus calStartAdcConversion(int8u dummy1, // Not used.
}
StStatus calReadAdcBlocking(int8u dummy,
int16u *value) {
StStatus calReadAdcBlocking(uint8_t dummy,
uint16_t *value) {
// Wait for conversion to complete.
while ( ! (INT_MGMTFLAG & INT_MGMTCALADC) );
// Clear the interrupt for this conversion.
INT_MGMTFLAG = INT_MGMTCALADC;
// Get the result.
*value = (int16u)CAL_ADC_DATA;
*value = (uint16_t)CAL_ADC_DATA;
return ST_SUCCESS;
}
@ -137,12 +137,12 @@ StStatus calReadAdcBlocking(int8u dummy,
//the fastest conversions with the greatest reasonable accuracy. Variation
//across successive conversions appears to be +/-20mv of the average
//conversion. Overall function time is <150us.
int16u stMeasureVddFast(void)
uint16_t stMeasureVddFast(void)
{
int16u value;
int32u Ngnd;
int32u Nreg;
int32u Nvdd;
uint16_t value;
uint32_t Ngnd;
uint32_t Nreg;
uint32_t Nvdd;
tokTypeMfgRegVoltage1V8 vregOutTok;
halCommonGetMfgToken(&vregOutTok, TOKEN_MFG_1V8_REG_VOLTAGE);
@ -153,7 +153,7 @@ int16u stMeasureVddFast(void)
ADC_SAMPLE_CLOCKS_128,
ADC_6MHZ_CLOCK);
calReadAdcBlocking(DUMMY, &value);
Ngnd = (int32u)value;
Ngnd = (uint32_t)value;
//Measure VREG_OUT/2
calStartAdcConversion(DUMMY,
@ -162,7 +162,7 @@ int16u stMeasureVddFast(void)
ADC_SAMPLE_CLOCKS_128,
ADC_6MHZ_CLOCK);
calReadAdcBlocking(DUMMY, &value);
Nreg = (int32u)value;
Nreg = (uint32_t)value;
//Measure VDD_PADS/4
calStartAdcConversion(DUMMY,
@ -171,7 +171,7 @@ int16u stMeasureVddFast(void)
ADC_SAMPLE_CLOCKS_128,
ADC_6MHZ_CLOCK);
calReadAdcBlocking(DUMMY, &value);
Nvdd = (int32u)value;
Nvdd = (uint32_t)value;
calDisableAdc();
@ -202,8 +202,8 @@ void halCommonCalibratePads(void)
void halInternalSetRegTrim(boolean boostMode)
{
tokTypeMfgRegTrim regTrim;
int8u trim1V2;
int8u trim1V8;
uint8_t trim1V2;
uint8_t trim1V8;
halCommonGetMfgToken(&regTrim, TOKEN_MFG_REG_TRIM);
// The compiler can optimize this function a bit more and keep the
@ -247,9 +247,9 @@ void halInternalSetRegTrim(boolean boostMode)
// OSCHF, though, the clock speed is cut in half, so the input parameter
// is divided by two. With respect to accuracy, we're now limited by
// the accuracy of OSCHF (much lower than XTAL).
void halCommonDelayMicroseconds(int16u us)
void halCommonDelayMicroseconds(uint16_t us)
{
int32u beginTime = ReadRegister(MAC_TIMER);
uint32_t beginTime = ReadRegister(MAC_TIMER);
//If we're not using the XTAL, the MAC Timer is running off OSCHF,
//that means the clock is half speed, 6MHz. We need to halve our delay
@ -281,7 +281,7 @@ void halCommonDelayMicroseconds(int16u us)
//necessary in some situations. If you have to burn more than 65ms of time,
//the halCommonDelayMicroseconds function becomes cumbersome, so this
//function gives you millisecond granularity.
void halCommonDelayMilliseconds(int16u ms)
void halCommonDelayMilliseconds(uint16_t ms)
{
if(ms==0) {
return;

28
cpu/stm32w108/hal/micro/cortexm3/micro-common.c
View file

@ -28,7 +28,7 @@ void halInternalResetWatchDog(void)
WDOG_RESET = 1;
}
void halInternalDisableWatchDog(int8u magicKey)
void halInternalDisableWatchDog(uint8_t magicKey)
{
if (magicKey == MICRO_DISABLE_WATCH_DOG_KEY) {
WDOG_KEY = 0xDEAD;
@ -45,33 +45,33 @@ boolean halInternalWatchDogEnabled(void)
}
}
void halGpioConfig(int32u io, int32u config)
void halGpioConfig(uint32_t io, uint32_t config)
{
static volatile int32u *const configRegs[] =
{ (volatile int32u *)GPIO_PACFGL_ADDR,
(volatile int32u *)GPIO_PACFGH_ADDR,
(volatile int32u *)GPIO_PBCFGL_ADDR,
(volatile int32u *)GPIO_PBCFGH_ADDR,
(volatile int32u *)GPIO_PCCFGL_ADDR,
(volatile int32u *)GPIO_PCCFGH_ADDR };
int32u portcfg;
static volatile uint32_t *const configRegs[] =
{ (volatile uint32_t *)GPIO_PACFGL_ADDR,
(volatile uint32_t *)GPIO_PACFGH_ADDR,
(volatile uint32_t *)GPIO_PBCFGL_ADDR,
(volatile uint32_t *)GPIO_PBCFGH_ADDR,
(volatile uint32_t *)GPIO_PCCFGL_ADDR,
(volatile uint32_t *)GPIO_PCCFGH_ADDR };
uint32_t portcfg;
portcfg = *configRegs[io/4]; // get current config
portcfg = portcfg & ~((0xF)<<((io&3)*4)); // mask out config of this pin
*configRegs[io/4] = portcfg | (config <<((io&3)*4));
}
void halGpioSet(int32u gpio, boolean value)
void halGpioSet(uint32_t gpio, boolean value)
{
if(gpio/8 < 3) {
if (value) {
*((volatile int32u *)(GPIO_PxSET_BASE+(GPIO_Px_OFFSET*(gpio/8)))) = BIT(gpio&7);
*((volatile uint32_t *)(GPIO_PxSET_BASE+(GPIO_Px_OFFSET*(gpio/8)))) = BIT(gpio&7);
} else {
*((volatile int32u *)(GPIO_PxCLR_BASE+(GPIO_Px_OFFSET*(gpio/8)))) = BIT(gpio&7);
*((volatile uint32_t *)(GPIO_PxCLR_BASE+(GPIO_Px_OFFSET*(gpio/8)))) = BIT(gpio&7);
}
}
}
int16u halInternalStartSystemTimer(void)
uint16_t halInternalStartSystemTimer(void)
{
//Since the SleepTMR is the only timer maintained during deep sleep, it is
//used as the System Timer (RTC). We maintain a 32 bit hardware timer

22
cpu/stm32w108/hal/micro/cortexm3/micro-common.h
View file

@ -20,7 +20,7 @@
//This is necessary here because halSleepForQsWithOptions returns an
//StStatus and not adding this typedef to this file breaks a
//whole lot of builds.
typedef int8u StStatus;
typedef uint8_t StStatus;
#endif //__STSTATUS_TYPE__
#endif // DOXYGEN_SHOULD_SKIP_THIS
@ -71,7 +71,7 @@ void halInternalResetWatchDog( void );
* @param config The configuration mode to use.
*
*/
void halGpioConfig(int32u io, int32u config);
void halGpioConfig(uint32_t io, uint32_t config);
/**
* @brief Set/Clear single GPIO bit
@ -81,7 +81,7 @@ void halGpioConfig(int32u io, int32u config);
* @param value A flag indicating whether to set or clear the io.
*
*/
void halGpioSet(int32u io, boolean value);
void halGpioSet(uint32_t io, boolean value);
/**
@ -111,7 +111,7 @@ void halInternalSetRegTrim(boolean boostMode);
*
* @return A slow measurement of VDD_PADS in millivolts.
*/
int16u stMeasureVddSlow(void);
uint16_t stMeasureVddSlow(void);
/** @brief Takes a fast ADC measurement of VDD_PADS in millivolts.
@ -121,7 +121,7 @@ int16u stMeasureVddSlow(void);
*
* @return A fast measurement of VDD_PADS in millivolts.
*/
int16u stMeasureVddFast(void);
uint16_t stMeasureVddFast(void);
/**
@ -164,7 +164,7 @@ void halInternalSearchForBiasTrim(void);
*
* @param ms The specified time, in milliseconds.
*/
void halCommonDelayMilliseconds(int16u ms);
void halCommonDelayMilliseconds(uint16_t ms);
/** @brief Puts the microcontroller to sleep in a specified mode, allows
@ -183,7 +183,7 @@ void halCommonDelayMilliseconds(int16u ms);
*
* @sa ::SleepModes
*/
void halSleepWithOptions(SleepModes sleepMode, int32u gpioWakeBitMask);
void halSleepWithOptions(SleepModes sleepMode, uint32_t gpioWakeBitMask);
/**
@ -218,7 +218,7 @@ void halSleepWithOptions(SleepModes sleepMode, int32u gpioWakeBitMask);
* @return An StStatus value indicating the success or
* failure of the command.
*/
StStatus halSleepForQsWithOptions(int32u *duration, int32u gpioWakeBitMask);
StStatus halSleepForQsWithOptions(uint32_t *duration, uint32_t gpioWakeBitMask);
/**
* @brief Provides access to assembly code which triggers idle sleep.
@ -262,7 +262,7 @@ void halInternalSleep(SleepModes sleepMode);
*
* @return The events that caused the last wake from sleep.
*/
int32u halGetWakeInfo(void);
uint32_t halGetWakeInfo(void);
/** @brief Seeds the ::halCommonGetRandom() pseudorandom number
@ -273,7 +273,7 @@ int32u halGetWakeInfo(void);
*
* @param seed A seed for the pseudorandom number generator.
*/
void halCommonSeedRandom(int32u seed);
void halCommonSeedRandom(uint32_t seed);
/** @brief Runs a standard LFSR to generate pseudorandom numbers.
*
@ -283,7 +283,7 @@ void halCommonSeedRandom(int32u seed);
* ability to avoid collisions in large networks, but it is \b critical to
* implement this function to return quickly.
*/
int16u halCommonGetRandom(void);
uint16_t halCommonGetRandom(void);
#endif //__STM32W108XX_MICRO_COMMON_H__

38
cpu/stm32w108/hal/micro/cortexm3/micro.c
View file

@ -70,22 +70,22 @@ void halPowerUp(void)
halBoardPowerUp();
}
static int16u seed0 = 0xbeef;
static int16u seed1 = 0xface;
static uint16_t seed0 = 0xbeef;
static uint16_t seed1 = 0xface;
void halCommonSeedRandom(int32u seed)
void halCommonSeedRandom(uint32_t seed)
{
seed0 = (int16u) seed;
seed0 = (uint16_t) seed;
if (seed0 == 0)
seed0 = 0xbeef;
seed1 = (int16u) (seed >> 16);
seed1 = (uint16_t) (seed >> 16);
if (seed1 == 0)
seed1 = 0xface;
}
static int16u shift(int16u *val, int16u taps)
static uint16_t shift(uint16_t *val, uint16_t taps)
{
int16u newVal = *val;
uint16_t newVal = *val;
if (newVal & 0x8000)
newVal ^= taps;
@ -93,44 +93,44 @@ static int16u shift(int16u *val, int16u taps)
return newVal;
}
int16u halCommonGetRandom(void)
uint16_t halCommonGetRandom(void)
{
return (shift(&seed0, 0x0062)
^ shift(&seed1, 0x100B));
}
void halCommonMemCopy(void *dest, const void *source, int8u bytes)
void halCommonMemCopy(void *dest, const void *source, uint8_t bytes)
{
memcpy(dest, source, bytes);
}
int8s halCommonMemCompare(const void *source0, const void *source1, int8u bytes)
int8_t halCommonMemCompare(const void *source0, const void *source1, uint8_t bytes)
{
return memcmp(source0, source1, bytes);
}
void halCommonMemSet(void *dest, int8u val, int16u bytes)
void halCommonMemSet(void *dest, uint8_t val, uint16_t bytes)
{
memset(dest, val, bytes);
}
#pragma pack(1)
typedef struct appSwitchStruct {
int32u signature;
int8u mode;
int8u channel;
uint32_t signature;
uint8_t mode;
uint8_t channel;
union {
int16u panID;
int16u offset;
uint16_t panID;
uint16_t offset;
} param;
} appSwitchStructType;
#pragma pack()
static appSwitchStructType *appSwitch = (appSwitchStructType *) RAM_BOTTOM;
StStatus halBootloaderStart(int8u mode, int8u channel, int16u panID)
StStatus halBootloaderStart(uint8_t mode, uint8_t channel, uint16_t panID)
{
if (mode == IAP_BOOTLOADER_MODE_UART) {
int8u cut = *(volatile int8u *) 0x08040798;
uint8_t cut = *(volatile uint8_t *) 0x08040798;
if (!( (halFixedAddressTable.baseTable.type == FIXED_ADDRESS_TABLE_TYPE) &&
( ( (halFixedAddressTable.baseTable.version & FAT_MAJOR_VERSION_MASK)
== 0x0000 ) &&
@ -140,7 +140,7 @@ StStatus halBootloaderStart(int8u mode, int8u channel, int16u panID)
return ST_ERR_FATAL;
} else {
/* Check that OTA bootloader is at the base of the flash */
if (*((int32u *) (MFB_BOTTOM + 28)) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) {
if (*((uint32_t *) (MFB_BOTTOM + 28)) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) {
appSwitch->channel = ((channel >= 11) && (channel <= 26)) ? channel :IAP_BOOTLOADER_DEFAULT_CHANNEL;
appSwitch->param.panID = panID;
} else {

72
cpu/stm32w108/hal/micro/cortexm3/nvm.c
View file

@ -13,7 +13,7 @@
#ifdef NVM_RAM_EMULATION
static int16u calibrationData[32+2]={
static uint16_t calibrationData[32+2]={
0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
@ -21,14 +21,14 @@ static int16u calibrationData[32+2]={
0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
};
int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
uint8_t halCommonReadFromNvm(void *data, uint32_t offset, uint16_t length)
{
halCommonMemCopy(data, ((int8u *) calibrationData) + offset, length);
halCommonMemCopy(data, ((uint8_t *) calibrationData) + offset, length);
return ST_SUCCESS;
}
int8u halCommonWriteToNvm(const void *data, int32u offset, int16u length)
uint8_t halCommonWriteToNvm(const void *data, uint32_t offset, uint16_t length)
{
halCommonMemCopy(((int8u *) calibrationData) + offset, data, length);
halCommonMemCopy(((uint8_t *) calibrationData) + offset, data, length);
return ST_SUCCESS;
}
@ -50,14 +50,14 @@ int8u halCommonWriteToNvm(const void *data, int32u offset, int16u length)
//are not required to be continuous memory blocks so they can be define
//separately. The linker is responsible for placing these storage containers
//on flash page boundaries.
NO_STRIPPING __no_init VAR_AT_SEGMENT (const int8u nvmStorageLeft[NVM_DATA_SIZE_B], __NVM__);
NO_STRIPPING __no_init VAR_AT_SEGMENT (const int8u nvmStorageRight[NVM_DATA_SIZE_B], __NVM__);
NO_STRIPPING __no_init VAR_AT_SEGMENT (const uint8_t nvmStorageLeft[NVM_DATA_SIZE_B], __NVM__);
NO_STRIPPING __no_init VAR_AT_SEGMENT (const uint8_t nvmStorageRight[NVM_DATA_SIZE_B], __NVM__);
static int8u determineState(void)
static uint8_t determineState(void)
{
int32u leftMgmt = *(int32u *)NVM_LEFT_PAGE;
int32u rightMgmt = *(int32u *)NVM_RIGHT_PAGE;
int8u state=0;
uint32_t leftMgmt = *(uint32_t *)NVM_LEFT_PAGE;
uint32_t rightMgmt = *(uint32_t *)NVM_RIGHT_PAGE;
uint8_t state=0;
if((leftMgmt==0xFFFF0000) && (rightMgmt==0xFFFFFFFF)) {
//State 1 and state 4 use identical mgmt words. The function
@ -95,12 +95,12 @@ static int8u determineState(void)
}
int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
uint8_t halCommonReadFromNvm(void *data, uint32_t offset, uint16_t length)
{
int16u i;
int16u *flash;
uint16_t i;
uint16_t *flash;
//Remember: all flash writes are 16bits.
int16u *ram = (int16u*)data;
uint16_t *ram = (uint16_t*)data;
//The NVM data storage system cannot function if the LEFT and RIGHT
//storage are not aligned to physical flash pages.
@ -121,7 +121,7 @@ int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
case 4:
case 9:
case 10:
flash = (int16u *)(NVM_LEFT_PAGE+offset);
flash = (uint16_t *)(NVM_LEFT_PAGE+offset);
for(i=0;i<(length/2);i++) {
ram[i] = flash[i];
}
@ -130,7 +130,7 @@ int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
case 6:
case 7:
case 8:
flash = (int16u *)(NVM_RIGHT_PAGE+offset);
flash = (uint16_t *)(NVM_RIGHT_PAGE+offset);
for(i=0;i<(length/2);i++) {
ram[i] = flash[i];
}
@ -155,9 +155,9 @@ int8u halCommonReadFromNvm(void *data, int32u offset, int16u length)
return ST_SUCCESS;
}
int16u *halCommonGetAddressFromNvm(int32u offset)
uint16_t *halCommonGetAddressFromNvm(uint32_t offset)
{
int16u *flash;
uint16_t *flash;
//The NVM data storage system cannot function if the LEFT and RIGHT
//storage are not aligned to physical flash pages.
@ -174,22 +174,22 @@ int16u *halCommonGetAddressFromNvm(int32u offset)
case 4:
case 9:
case 10:
flash = (int16u *)(NVM_LEFT_PAGE+offset);
flash = (uint16_t *)(NVM_LEFT_PAGE+offset);
break;
case 5:
case 6:
case 7:
case 8:
flash = (int16u *)(NVM_RIGHT_PAGE+offset);
flash = (uint16_t *)(NVM_RIGHT_PAGE+offset);
break;
case 0:
default:
// Flash is in an invalid state
// Fix it with a dummy write and then return the flash page left
{
int16u dummy = 0xFFFF;
uint16_t dummy = 0xFFFF;
halCommonWriteToNvm(&dummy, 0, 2);
flash = (int16u *)(NVM_LEFT_PAGE+offset);
flash = (uint16_t *)(NVM_LEFT_PAGE+offset);
}
}
@ -197,12 +197,12 @@ int16u *halCommonGetAddressFromNvm(int32u offset)
}
static int8u erasePage(int32u page)
static uint8_t erasePage(uint32_t page)
{
StStatus status;
int32u i, k;
int32u address;
int8u *flash;
uint32_t i, k;
uint32_t address;
uint8_t *flash;
//Erasing a LEFT or RIGHT page requires erasing all of the flash pages.
//Since the mgmt bytes are stored at the bottom of a page, the flash pages
@ -211,7 +211,7 @@ static int8u erasePage(int32u page)
//words are still valid the next time determineState() is called.
for(i=NVM_FLASH_PAGE_COUNT;i>0;i--) {
address = (page+((i-1)*MFB_PAGE_SIZE_B));
flash = (int8u *)address;
flash = (uint8_t *)address;
//Scan the page to determine if it is fully erased already.
//If the flash is not erased, erase it. The purpose of scanning
//first is to save a little time if erasing is not required.
@ -248,7 +248,7 @@ static int8u erasePage(int32u page)
do { \
/*Copy all data below the new data from the srcPage to the destPage*/ \
status = halInternalFlashWrite(destPage+NVM_MGMT_SIZE_B, \
(int16u *)(srcPage+NVM_MGMT_SIZE_B), \
(uint16_t *)(srcPage+NVM_MGMT_SIZE_B), \
(offset-NVM_MGMT_SIZE_B)/2); \
if(status != ST_SUCCESS) { return status; } \
/*Write the new data*/ \
@ -258,7 +258,7 @@ static int8u erasePage(int32u page)
if(status != ST_SUCCESS) { return status; } \
/*Copy all data above the new data from the srcPage to the destPage*/ \
status = halInternalFlashWrite(destPage+offset+length, \
(int16u *)(srcPage+offset+length), \
(uint16_t *)(srcPage+offset+length), \
(NVM_DATA_SIZE_B- \
length-offset- \
NVM_MGMT_SIZE_B)/2); \
@ -269,7 +269,7 @@ static int8u erasePage(int32u page)
//the proper management address.
#define WRITE_MGMT_16BITS(address, data) \
do{ \
int16u value = data; \
uint16_t value = data; \
status = halInternalFlashWrite((address), &value, 1); \
if(status != ST_SUCCESS) { \
return status; \
@ -277,14 +277,14 @@ static int8u erasePage(int32u page)
} while(0)
int8u halCommonWriteToNvm(const void *data, int32u offset, int16u length)
uint8_t halCommonWriteToNvm(const void *data, uint32_t offset, uint16_t length)
{
StStatus status;
int8u state, exitState;
int32u srcPage;
int32u destPage;
uint8_t state, exitState;
uint32_t srcPage;
uint32_t destPage;
//Remember: NVM data storage works on 16bit quantities.
int16u *ram = (int16u*)data;
uint16_t *ram = (uint16_t*)data;
//The NVM data storage system cannot function if the LEFT and RIGHT
//storage are not aligned to physical flash pages.

12
cpu/stm32w108/hal/micro/cortexm3/nvm.h
View file

@ -137,7 +137,7 @@
* - Refer to nvm-def.h for a list of offset/length that define the data
* stored in NVM storage space.
* - All writes to flash are 16bit granularity and therefore the internal
* flash writes cast the data to int16u. Length is also required to be
* flash writes cast the data to uint16_t. Length is also required to be
* a multiple of 16bits.
* - Flash page erase uses a granularity of a single flash page. The size
* of a flash page depends on the chip and is defined in memmap.h with
@ -198,7 +198,7 @@
* - ST_ERR_FATAL if the NVM storage management indicated an invalid
* state. The function will return entirely 0xFF in the data parameter.
*/
StStatus halCommonReadFromNvm(void *data, int32u offset, int16u length);
StStatus halCommonReadFromNvm(void *data, uint32_t offset, uint16_t length);
/**
* @brief Return the address of the token in NVM
@ -208,7 +208,7 @@ StStatus halCommonReadFromNvm(void *data, int32u offset, int16u length);
*
* @return The address requested
*/
int16u *halCommonGetAddressFromNvm(int32u offset);
uint16_t *halCommonGetAddressFromNvm(uint32_t offset);
/**
* @brief Write the NVM data from the provided location RAM into flash.
@ -226,7 +226,7 @@ int16u *halCommonGetAddressFromNvm(int32u offset);
* - Any other status value is an error code generated by the low level
* flash erase and write API. Refer to flash.h for details.
*/
StStatus halCommonWriteToNvm(const void *data, int32u offset, int16u length);
StStatus halCommonWriteToNvm(const void *data, uint32_t offset, uint16_t length);
/**
* @brief Define the number of physical flash pages that comprise a NVM page.
@ -256,14 +256,14 @@ StStatus halCommonWriteToNvm(const void *data, int32u offset, int16u length);
* is defined by nvmStorageLeft[NVM_DATA_SIZE_B] and placed by the linker
* using the segment "NVM".
*/
#define NVM_LEFT_PAGE ((int32u)nvmStorageLeft)
#define NVM_LEFT_PAGE ((uint32_t)nvmStorageLeft)
/**
* @brief Define the absolute address of the RIGHT page. RIGHT page storage
* is defined by nvmStorageRight[NVM_DATA_SIZE_B] and placed by the linker
* using the segment "NVM".
*/
#define NVM_RIGHT_PAGE ((int32u)nvmStorageRight)
#define NVM_RIGHT_PAGE ((uint32_t)nvmStorageRight)
/**
* @brief Define the number of bytes that comprise the NVM management bytes.

62
cpu/stm32w108/hal/micro/cortexm3/sleep.c
View file

@ -117,9 +117,9 @@
//place in the halInternalWakeEvent variable
#define INTERNAL_WAKE_EVENT_BIT_SHIFT 20
static int32u halInternalWakeEvent=0;
static uint32_t halInternalWakeEvent=0;
int32u halGetWakeInfo(void)
uint32_t halGetWakeInfo(void)
{
return halInternalWakeEvent;
}
@ -129,7 +129,7 @@ void halInternalSleep(SleepModes sleepMode)
//Timer restoring always takes place during the wakeup sequence. We save
//the state here in case SLEEPMODE_NOTIMER is invoked, which would disable
//the clocks.
int32u SLEEPTMR_CLKEN_SAVED = SLEEPTMR_CLKEN;
uint32_t SLEEPTMR_CLKEN_SAVED = SLEEPTMR_CLKEN;
//This code assumes all wake source registers are properly configured.
//As such, it should be called from halSleepWithOptions() or from
@ -138,7 +138,7 @@ void halInternalSleep(SleepModes sleepMode)
//The parameter gpioWakeSel is a bitfield composite of the GPIO wake
//sources derived from the 3 ports, indicating which of the 24 GPIO
//are configured as a wake source.
int32u gpioWakeSel = (GPIO_PAWAKE<<0);
uint32_t gpioWakeSel = (GPIO_PAWAKE<<0);
gpioWakeSel |= (GPIO_PBWAKE<<8);
gpioWakeSel |= (GPIO_PCWAKE<<16);
@ -248,38 +248,38 @@ deepSleepCore:
//MAC_TIMER_INT_MASK - reinitialized by stStackPowerUp()
//BB_INT_MASK - reinitialized by stStackPowerUp()
//SEC_INT_MASK - reinitialized by stStackPowerUp()
int32u INT_SLEEPTMRCFG_SAVED = INT_SLEEPTMRCFG_REG;
int32u INT_MGMTCFG_SAVED = INT_MGMTCFG_REG;
uint32_t INT_SLEEPTMRCFG_SAVED = INT_SLEEPTMRCFG_REG;
uint32_t INT_MGMTCFG_SAVED = INT_MGMTCFG_REG;
//INT_TIM1CFG - reinitialized by halPowerUp() or similar
//INT_TIM2CFG - reinitialized by halPowerUp() or similar
//INT_SC1CFG - reinitialized by halPowerUp() or similar
//INT_SC2CFG - reinitialized by halPowerUp() or similar
//INT_ADCCFG - reinitialized by halPowerUp() or similar
int32u GPIO_INTCFGA_SAVED = GPIO_INTCFGA_REG;
int32u GPIO_INTCFGB_SAVED = GPIO_INTCFGB_REG;
int32u GPIO_INTCFGC_SAVED = GPIO_INTCFGC_REG;
int32u GPIO_INTCFGD_SAVED = GPIO_INTCFGD_REG;
uint32_t GPIO_INTCFGA_SAVED = GPIO_INTCFGA_REG;
uint32_t GPIO_INTCFGB_SAVED = GPIO_INTCFGB_REG;
uint32_t GPIO_INTCFGC_SAVED = GPIO_INTCFGC_REG;
uint32_t GPIO_INTCFGD_SAVED = GPIO_INTCFGD_REG;
//SC1_INTMODE - reinitialized by halPowerUp() or similar
//SC2_INTMODE - reinitialized by halPowerUp() or similar
//----CM_LV
int32u OSC24M_BIASTRIM_SAVED = OSC24M_BIASTRIM_REG;
int32u OSCHF_TUNE_SAVED = OSCHF_TUNE_REG;
int32u DITHER_DIS_SAVED = DITHER_DIS_REG;
uint32_t OSC24M_BIASTRIM_SAVED = OSC24M_BIASTRIM_REG;
uint32_t OSCHF_TUNE_SAVED = OSCHF_TUNE_REG;
uint32_t DITHER_DIS_SAVED = DITHER_DIS_REG;
//OSC24M_CTRL - reinitialized by halPowerUp() or similar
//CPU_CLKSEL - reinitialized by halPowerUp() or similar
//TMR1_CLK_SEL - reinitialized by halPowerUp() or similar
//TMR2_CLK_SEL - reinitialized by halPowerUp() or similar
int32u PCTRACE_SEL_SAVED = PCTRACE_SEL_REG;
uint32_t PCTRACE_SEL_SAVED = PCTRACE_SEL_REG;
//----RAM_CTRL
int32u MEM_PROT_0_SAVED = MEM_PROT_0_REG;
int32u MEM_PROT_1_SAVED = MEM_PROT_1_REG;
int32u MEM_PROT_2_SAVED = MEM_PROT_2_REG;
int32u MEM_PROT_3_SAVED = MEM_PROT_3_REG;
int32u MEM_PROT_4_SAVED = MEM_PROT_4_REG;
int32u MEM_PROT_5_SAVED = MEM_PROT_5_REG;
int32u MEM_PROT_6_SAVED = MEM_PROT_6_REG;
int32u MEM_PROT_7_SAVED = MEM_PROT_7_REG;
int32u MEM_PROT_EN_SAVED = MEM_PROT_EN_REG;
uint32_t MEM_PROT_0_SAVED = MEM_PROT_0_REG;
uint32_t MEM_PROT_1_SAVED = MEM_PROT_1_REG;
uint32_t MEM_PROT_2_SAVED = MEM_PROT_2_REG;
uint32_t MEM_PROT_3_SAVED = MEM_PROT_3_REG;
uint32_t MEM_PROT_4_SAVED = MEM_PROT_4_REG;
uint32_t MEM_PROT_5_SAVED = MEM_PROT_5_REG;
uint32_t MEM_PROT_6_SAVED = MEM_PROT_6_REG;
uint32_t MEM_PROT_7_SAVED = MEM_PROT_7_REG;
uint32_t MEM_PROT_EN_SAVED = MEM_PROT_EN_REG;
//----AUX_ADC
// reinitialized by halPowerUp() or similar
//----CAL_ADC
@ -295,14 +295,14 @@ deepSleepCore:
//----NVIC
//ST_CSR - fixed, restored by cstartup when exiting deep sleep
//ST_RVR - fixed, restored by cstartup when exiting deep sleep
int32u INT_CFGSET_SAVED = INT_CFGSET_REG; //mask against wake sources
uint32_t INT_CFGSET_SAVED = INT_CFGSET_REG; //mask against wake sources
//INT_PENDSET - used below when overlapping interrupts and wake sources
//NVIC_IPR_3to0 - fixed, restored by cstartup when exiting deep sleep
//NVIC_IPR_7to4 - fixed, restored by cstartup when exiting deep sleep
//NVIC_IPR_11to8 - fixed, restored by cstartup when exiting deep sleep
//NVIC_IPR_15to12 - fixed, restored by cstartup when exiting deep sleep
//NVIC_IPR_19to16 - fixed, restored by cstartup when exiting deep sleep
int32u SCS_VTOR_SAVED = SCS_VTOR_REG;
uint32_t SCS_VTOR_SAVED = SCS_VTOR_REG;
//SCS_CCR - fixed, restored by cstartup when exiting deep sleep
//SCS_SHPR_7to4 - fixed, restored by cstartup when exiting deep sleep
//SCS_SHPR_11to8 - fixed, restored by cstartup when exiting deep sleep
@ -320,7 +320,7 @@ deepSleepCore:
//up exactly which GPIO could have woken us up.
//Reading the three IN registers is done separately to avoid warnings
//about undefined order of volatile access.
int32u GPIO_IN_SAVED = GPIO_PAIN;
uint32_t GPIO_IN_SAVED = GPIO_PAIN;
GPIO_IN_SAVED |= (GPIO_PBIN<<8);
GPIO_IN_SAVED |= (GPIO_PCIN<<16);
//reset the power up events by writing 1 to all bits.
@ -425,7 +425,7 @@ deepSleepCore:
//only propagate across deep sleep the interrupts that are both
//enabled and possible wake sources
{
int32u wakeSourceInterruptMask = 0;
uint32_t wakeSourceInterruptMask = 0;
if(GPIO_PBWAKE&PB0) {
wakeSourceInterruptMask |= INT_IRQA;
@ -513,7 +513,7 @@ deepSleepCore:
{
//Use a local copy of WAKE_SEL to avoid warnings from the compiler
//about order of volatile accesses
int32u wakeSel = WAKE_SEL;
uint32_t wakeSel = WAKE_SEL;
//stall until a wake event or CSYSPWRUPREQ/ACK clears
while( (CSYSPWRUPACK_STATUS) && (!(PWRUP_EVENT&wakeSel)) ) {}
//if there was a wake event, allow CSYSPWRUPACK and skip sleep
@ -630,14 +630,14 @@ deepSleepCore:
//Now that we're awake, normal interrupts are operational again
//Take a snapshot of the new GPIO state and the EVENT register to
//record our wake event
int32u GPIO_IN_NEW = GPIO_PAIN;
uint32_t GPIO_IN_NEW = GPIO_PAIN;
GPIO_IN_NEW |= (GPIO_PBIN<<8);
GPIO_IN_NEW |= (GPIO_PCIN<<16);
//Only operate on power up events that are also wake events. Power
//up events will always trigger like an interrupt flag, so we have
//to check them against events that are enabled for waking. (This is
//a two step process because we're accessing two volatile values.)
int32u powerUpEvents = PWRUP_EVENT;
uint32_t powerUpEvents = PWRUP_EVENT;
powerUpEvents &= WAKE_SEL;
halInternalWakeEvent |= ((GPIO_IN_SAVED^GPIO_IN_NEW)&gpioWakeSel);
//PWRUP_SC1 is PB2 which is bit 10
@ -845,7 +845,7 @@ deepSleepCore:
}
void halSleepWithOptions(SleepModes sleepMode, int32u gpioWakeBitMask)
void halSleepWithOptions(SleepModes sleepMode, uint32_t gpioWakeBitMask)
{
//configure all GPIO wake sources
GPIO_PAWAKE = (gpioWakeBitMask>>0)&0xFF;

6
cpu/stm32w108/hal/micro/cortexm3/spmr.s79
View file

@ -35,7 +35,7 @@
__EXPORT__ _executeBarrierInstructions
//------------------------------------------------------------------------------
// int8u _readBasePri(void)
// uint8_t _readBasePri(void)
//
// Read and return the BASEPRI value.
//
@ -50,7 +50,7 @@ _readBasePri:
__CFI__(EndBlock cfiBlock0)
//------------------------------------------------------------------------------
// void _writeBasePri(int8u priority)
// void _writeBasePri(uint8_t priority)
//
// Write BASEPRI with the passed value to obtain the proper preemptive priority
// group masking. Note that the value passed must have been left shifted by 3
@ -68,7 +68,7 @@ _writeBasePri:
__CFI__(EndBlock cfiBlock1)
//------------------------------------------------------------------------------
// int8u _disableBasePri(void)
// uint8_t _disableBasePri(void)
//
// Set BASEPRI to mask out interrupts but allow faults. It returns the value
// BASEPRI had when it was called.

22
cpu/stm32w108/hal/micro/cortexm3/stm32w108/board.h
View file

@ -84,9 +84,9 @@ typedef struct LedResourceStruct {
/** Name of the LED as printed in the board */
char *name;
/** GPIO port associated with the LED */
int8u gpioPort;
uint8_t gpioPort;
/** GPIO pin associated with the LED */
int8u gpioPin;
uint8_t gpioPin;
} LedResourceType;
typedef LedResourceType InfraRedLedResourceType;
@ -98,9 +98,9 @@ typedef struct ButtonResourceStruct {
/** Name of the button as printed in the board */
char *name;
/** GPIO port associated with the button */
int8u gpioPort;
uint8_t gpioPort;
/** GPIO pin associated with the button */
int8u gpioPin;
uint8_t gpioPin;
} ButtonResourceType;
/**
@ -110,7 +110,7 @@ typedef struct MemsResourceStruct {
/** Name of the MEMS device */
char *name;
/** Serial communication port associated with the MEMS */
int8u scPort;
uint8_t scPort;
} MemsResourceType;
/**
@ -120,9 +120,9 @@ typedef struct TempSensorResourceStruct {
/** Name of the temperature sensor device */
char *name;
/** GPIO port associated with the sensor */
int8u gpioPort;
uint8_t gpioPort;
/** GPIO pin associated with the sensor */
int8u gpioPin;
uint8_t gpioPin;
/** Flag to indicate whether the ADC range extension bug fix is implemented */
boolean adcFix;
} TempSensorResourceType;
@ -167,11 +167,11 @@ typedef struct BoardIOStruct {
*/
typedef struct BoardResourcesStruct {
const char *name;
const int32u flags;
const uint32_t flags;
/** Number of buttons */
int8u buttons;
uint8_t buttons;
/** Number of leds */
int8u leds;
uint8_t leds;
/** Board I/O description */
const BoardIOType *io;
/** Board infrared led description */
@ -202,7 +202,7 @@ extern BoardResourcesType const *boardDescription;
/** Description buttons definition */
#define BUTTON_Sn(n) (PORTx_PIN(boardDescription->io->buttons[n].gpioPort, boardDescription->io->buttons[n].gpioPin))
#define BUTTON_Sn_WAKE_SOURCE(n) (1 << ((boardDescription->io->buttons[n].gpioPin) + (8 * (boardDescription->io->buttons[n].gpioPort >> 3))))
#define BUTTON_INPUT_GPIO(port) *((volatile int32u *) (GPIO_PxIN_BASE + GPIO_Px_OFFSET * port))
#define BUTTON_INPUT_GPIO(port) *((volatile uint32_t *) (GPIO_PxIN_BASE + GPIO_Px_OFFSET * port))
#define DUMMY_BUTTON 0xff
#define BUTTON_S1 (boardDescription->buttons>0 ? BUTTON_Sn(0): DUMMY_BUTTON)

18
cpu/stm32w108/hal/micro/cortexm3/stm32w108/crt_stm32w108.c → cpu/stm32w108/hal/micro/cortexm3/stm32w108/crt-stm32w108.c
View file

@ -139,8 +139,8 @@ void (* const g_pfnVectors[])(void) =
halDebugIsr, // 32
};
static void setStackPointer(int32u address) __attribute__((noinline));
static void setStackPointer(int32u address)
static void setStackPointer(uint32_t address) __attribute__((noinline));
static void setStackPointer(uint32_t address)
{
// This code is needed to generate the instruction below
// that GNU ASM is refusing to add
@ -148,7 +148,7 @@ static void setStackPointer(int32u address)
asm(".short 0x4685");
}
static const int16u blOffset[] = {
static const uint16_t blOffset[] = {
0x0715 - 0x03ad - 0x68,
0x0719 - 0x03ad - 0x6C
};
@ -277,17 +277,17 @@ void Reset_Handler(void)
}
//USART bootloader software activation check
if ((*((int32u *)RAM_BOTTOM) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) && (*((int8u *)(RAM_BOTTOM+4)) == IAP_BOOTLOADER_MODE_UART)){
int8u cut = *(volatile int8u *) 0x08040798;
int16u offset = 0;
if ((*((uint32_t *)RAM_BOTTOM) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) && (*((uint8_t *)(RAM_BOTTOM+4)) == IAP_BOOTLOADER_MODE_UART)){
uint8_t cut = *(volatile uint8_t *) 0x08040798;
uint16_t offset = 0;
typedef void (*EntryPoint)(void);
offset = (halFixedAddressTable.baseTable.version == 3) ? blOffset[cut - 2] : 0;
*((int32u *)RAM_BOTTOM) = 0;
*((uint32_t *)RAM_BOTTOM) = 0;
if (offset) {
halInternalSwitchToXtal();
}
EntryPoint entryPoint = (EntryPoint)(*(int32u *)(FIB_BOTTOM+4) - offset);
setStackPointer(*(int32u *)FIB_BOTTOM);
EntryPoint entryPoint = (EntryPoint)(*(uint32_t *)(FIB_BOTTOM+4) - offset);
setStackPointer(*(uint32_t *)FIB_BOTTOM);
entryPoint();
}

18
cpu/stm32w108/hal/micro/cortexm3/stm32w108/low_level_init.c → cpu/stm32w108/hal/micro/cortexm3/stm32w108/low-level-init.c
View file

@ -38,12 +38,12 @@ extern void halInternalSwitchToXtal(void);
__interwork int __low_level_init(void);
static void setStackPointer(int32u address)
static void setStackPointer(uint32_t address)
{
asm("MOVS SP, r0");
}
static const int16u blOffset[] = {
static const uint16_t blOffset[] = {
0x0715 - 0x03ad - 0x68,
0x0719 - 0x03ad - 0x6C
};
@ -79,7 +79,7 @@ __interwork int __low_level_init(void)
////---- Always remap the vector table ----////
// We might be coming from a bootloader at the base of flash, or even in the
// NULL_BTL case, the BAT/AAT will be at the beginning of the image
SCS_VTOR = (int32u)__vector_table;
SCS_VTOR = (uint32_t)__vector_table;
////---- Always Configure Interrupt Priorities ----////
//The STM32W support 5 bits of priority configuration.
@ -169,17 +169,17 @@ __interwork int __low_level_init(void)
}
//USART bootloader software activation check
if ((*((int32u *)RAM_BOTTOM) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) && (*((int8u *)(RAM_BOTTOM+4)) == IAP_BOOTLOADER_MODE_UART)){
int8u cut = *(volatile int8u *) 0x08040798;
int16u offset = 0;
if ((*((uint32_t *)RAM_BOTTOM) == IAP_BOOTLOADER_APP_SWITCH_SIGNATURE) && (*((uint8_t *)(RAM_BOTTOM+4)) == IAP_BOOTLOADER_MODE_UART)){
uint8_t cut = *(volatile uint8_t *) 0x08040798;
uint16_t offset = 0;
typedef void (*EntryPoint)(void);
offset = (halFixedAddressTable.baseTable.version == 3) ? blOffset[cut - 2] : 0;
*((int32u *)RAM_BOTTOM) = 0;
*((uint32_t *)RAM_BOTTOM) = 0;
if (offset) {
halInternalSwitchToXtal();
}
EntryPoint entryPoint = (EntryPoint)(*(int32u *)(FIB_BOTTOM+4) - offset);
setStackPointer(*(int32u *)FIB_BOTTOM);
EntryPoint entryPoint = (EntryPoint)(*(uint32_t *)(FIB_BOTTOM+4) - offset);
setStackPointer(*(uint32_t *)FIB_BOTTOM);
entryPoint();
}

8
cpu/stm32w108/hal/micro/cortexm3/stm32w108/memmap.h
View file

@ -46,12 +46,12 @@
#define FPEC_KEY2 0xCDEF89AB //magic key defined in hardware
//Translation between page number and simee (word based) address
#define SIMEE_ADDR_TO_PAGE(x) ((int8u)(((int16u)(x)) >> 9))
#define PAGE_TO_SIMEE_ADDR(x) (((int16u)(x)) << 9)
#define SIMEE_ADDR_TO_PAGE(x) ((uint8_t)(((uint16_t)(x)) >> 9))
#define PAGE_TO_SIMEE_ADDR(x) (((uint16_t)(x)) << 9)
//Translation between page number and code addresses, used by bootloaders
#define PROG_ADDR_TO_PAGE(x) ((int8u)((((int32u)(x))&MFB_ADDR_MASK) >> 10))
#define PAGE_TO_PROG_ADDR(x) ((((int32u)(x)) << 10)|MFB_BOTTOM)
#define PROG_ADDR_TO_PAGE(x) ((uint8_t)((((uint32_t)(x))&MFB_ADDR_MASK) >> 10))
#define PAGE_TO_PROG_ADDR(x) ((((uint32_t)(x)) << 10)|MFB_BOTTOM)
#endif //__STM32W108_MEMMAP_H__

2260
cpu/stm32w108/hal/micro/cortexm3/stm32w108/regs.h
View file

File diff suppressed because it is too large Load diff

2
cpu/stm32w108/hal/micro/cortexm3/stm32w108/stm32w108_type.h → cpu/stm32w108/hal/micro/cortexm3/stm32w108/stm32w108-type.h
View file

@ -1,5 +1,5 @@
/******************** (C) COPYRIGHT 2007 STMicroelectronics ********************
* File Name : stm32w108_type.h
* File Name : stm32w108-type.h
* Author : MCD Application Team
* Version : V1.0
* Date : 10/08/2009

24
cpu/stm32w108/hal/micro/cortexm3/system-timer.c
View file

@ -32,14 +32,14 @@ static boolean sleepTimerInterruptOccurred = FALSE;
* a single clock tick occurs every 0.9769625 milliseconds, and a rollover
* of the 16-bit timer occurs every 64 seconds.
*/
int16u halCommonGetInt16uMillisecondTick(void)
uint16_t halCommonGetInt16uMillisecondTick(void)
{
return (int16u)halCommonGetInt32uMillisecondTick();
return (uint16_t)halCommonGetInt32uMillisecondTick();
}
int16u halCommonGetInt16uQuarterSecondTick(void)
uint16_t halCommonGetInt16uQuarterSecondTick(void)
{
return (int16u)(halCommonGetInt32uMillisecondTick() >> 8);
return (uint16_t)(halCommonGetInt32uMillisecondTick() >> 8);
}
/**
@ -47,9 +47,9 @@ int16u halCommonGetInt16uQuarterSecondTick(void)
* a single clock tick occurs every 0.9769625 milliseconds, and a rollover
* of the 32-bit timer occurs approximately every 48.5 days.
*/
int32u halCommonGetInt32uMillisecondTick(void)
uint32_t halCommonGetInt32uMillisecondTick(void)
{
int32u time;
uint32_t time;
time = SLEEPTMR_CNTH<<16;
time |= SLEEPTMR_CNTL;
@ -71,13 +71,13 @@ void halSleepTimerIsr(void)
#define CONVERT_TICKS_TO_QS(x) ((x) >> 8)
#define TIMER_MAX_QS 0x1000000 // = 4194304 seconds * 4 = 16777216
static StStatus internalSleepForQs(boolean useGpioWakeMask,
int32u *duration,
int32u gpioWakeBitMask)
uint32_t *duration,
uint32_t gpioWakeBitMask)
{
StStatus status = ST_SUCCESS;
int32u sleepOverflowCount;
int32u remainder;
int32u startCount;
uint32_t sleepOverflowCount;
uint32_t remainder;
uint32_t startCount;
//There is really no reason to bother with a duration of 0qs
if(*duration==0) {
@ -165,7 +165,7 @@ static StStatus internalSleepForQs(boolean useGpioWakeMask,
return status;
}
StStatus halSleepForQsWithOptions(int32u *duration, int32u gpioWakeBitMask)
StStatus halSleepForQsWithOptions(uint32_t *duration, uint32_t gpioWakeBitMask)
{
return internalSleepForQs(TRUE, duration, gpioWakeBitMask);
}

12
cpu/stm32w108/hal/micro/cortexm3/temperature_sensor.c → cpu/stm32w108/hal/micro/cortexm3/temperature-sensor.c
View file

@ -1,4 +1,4 @@
/**@file temperature_sensor.c
/**@file temperature-sensor.c
* @brief MB851 temperature sensor APIS
*
*
@ -8,7 +8,7 @@
#include BOARD_HEADER
#include "hal/hal.h"
#include "hal/error.h"
#include "hal/micro/temperature_sensor.h"
#include "hal/micro/temperature-sensor.h"
#include "hal/micro/adc.h"
void temperatureSensor_Init(void)
@ -29,10 +29,10 @@ void temperatureSensor_Init(void)
#endif /* ENABLE_ADC_EXTENDED_RANGE_BROKEN */
}/* end temperatureSensor_Init() */
int32u temperatureSensor_GetValue(void)
uint32_t temperatureSensor_GetValue(void)
{
static int16u ADCvalue;
static int16s volts;
static uint16_t ADCvalue;
static int16_t volts;
/*
NOTE:
@ -47,6 +47,6 @@ int32u temperatureSensor_GetValue(void)
// 100 uVolts
volts = halConvertValueToVolts(ADCvalue);
return ((18641 - (int32s)volts)*100)/1171;
return ((18641 - (int32_t)volts)*100)/1171;
}/* end temperatureSensor_GetValue() */

112
cpu/stm32w108/hal/micro/cortexm3/token-manufacturing.h
View file

@ -83,72 +83,72 @@
#ifndef __MFG_TYPES_DEFINED__
#define __MFG_TYPES_DEFINED__
//--- Fixed Information Block ---
typedef int8u tokTypeMfgChipData[24];
typedef int8u tokTypeMfgPartData[6];
typedef int8u tokTypeMfgTesterData[6];
typedef int8u tokTypeMfgStEui64[8];
typedef uint8_t tokTypeMfgChipData[24];
typedef uint8_t tokTypeMfgPartData[6];
typedef uint8_t tokTypeMfgTesterData[6];
typedef uint8_t tokTypeMfgStEui64[8];
typedef struct {
int16u iffilterL;
int16u lna;
int16u ifamp;
int16u rxadcH;
int16u prescalar;
int16u phdet;
int16u vco;
int16u loopfilter;
int16u pa;
int16u iqmixer;
uint16_t iffilterL;
uint16_t lna;
uint16_t ifamp;
uint16_t rxadcH;
uint16_t prescalar;
uint16_t phdet;
uint16_t vco;
uint16_t loopfilter;
uint16_t pa;
uint16_t iqmixer;
} tokTypeMfgAnalogueTrim;
typedef struct {
int16u iffilterH;
int16u biasmaster;
int16u moddac;
int16u auxadc;
int16u caladc;
uint16_t iffilterH;
uint16_t biasmaster;
uint16_t moddac;
uint16_t auxadc;
uint16_t caladc;
} tokTypeMfgAnalogueTrimBoth;
typedef struct {
int8u regTrim1V2;
int8u regTrim1V8;
uint8_t regTrim1V2;
uint8_t regTrim1V8;
} tokTypeMfgRegTrim;
typedef int16u tokTypeMfgRegVoltage1V8;
typedef int16u tokTypeMfgAdcVrefVoltage;
typedef int16u tokTypeMfgTempCal;
typedef int16u tokTypeMfgFibVersion;
typedef int16u tokTypeMfgFibChecksum;
typedef uint16_t tokTypeMfgRegVoltage1V8;
typedef uint16_t tokTypeMfgAdcVrefVoltage;
typedef uint16_t tokTypeMfgTempCal;
typedef uint16_t tokTypeMfgFibVersion;
typedef uint16_t tokTypeMfgFibChecksum;
typedef struct {
int16u ob2;
int16u ob3;
int16u ob0;
int16u ob1;
uint16_t ob2;
uint16_t ob3;
uint16_t ob0;
uint16_t ob1;
} tokTypeMfgFibObs;
//--- Customer Information Block ---
typedef struct {
int16u ob0;
int16u ob1;
int16u ob2;
int16u ob3;
int16u ob4;
int16u ob5;
int16u ob6;
int16u ob7;
uint16_t ob0;
uint16_t ob1;
uint16_t ob2;
uint16_t ob3;
uint16_t ob4;
uint16_t ob5;
uint16_t ob6;
uint16_t ob7;
} tokTypeMfgCibObs;
typedef int16u tokTypeMfgCustomVersion;
typedef int8u tokTypeMfgCustomEui64[8];
typedef int8u tokTypeMfgString[16];
typedef int8u tokTypeMfgBoardName[16];
typedef int16u tokTypeMfgManufId;
typedef int16u tokTypeMfgPhyConfig;
typedef int8u tokTypeMfgBootloadAesKey[16];
typedef int8u tokTypeMfgEui64[8];
typedef int8u tokTypeMfgEzspStorage[8];
typedef int16u tokTypeMfgAshConfig;
typedef uint16_t tokTypeMfgCustomVersion;
typedef uint8_t tokTypeMfgCustomEui64[8];
typedef uint8_t tokTypeMfgString[16];
typedef uint8_t tokTypeMfgBoardName[16];
typedef uint16_t tokTypeMfgManufId;
typedef uint16_t tokTypeMfgPhyConfig;
typedef uint8_t tokTypeMfgBootloadAesKey[16];
typedef uint8_t tokTypeMfgEui64[8];
typedef uint8_t tokTypeMfgEzspStorage[8];
typedef uint16_t tokTypeMfgAshConfig;
typedef struct {
int8u certificate[48];
int8u caPublicKey[22];
int8u privateKey[21];
uint8_t certificate[48];
uint8_t caPublicKey[22];
uint8_t privateKey[21];
// The bottom flag bit is 1 for uninitialized, 0 for initialized.
// The other flag bits should be set to 0 at initialization.
int8u flags;
uint8_t flags;
} tokTypeMfgCbkeData;
typedef struct {
// The bottom flag bit is 1 for uninitialized, 0 for initialized.
@ -158,11 +158,11 @@ typedef struct {
// Special flags support. Due to a bug in the way some customers
// had programmed the flags field, we will also examine the upper
// bits 9 and 10 for the size field. Those bits are also reserved.
int16u flags;
int8u value[16];
int16u crc;
uint16_t flags;
uint8_t value[16];
uint16_t crc;
} tokTypeMfgInstallationCode;
typedef int16u tokTypeMfgOsc24mBiasTrim;
typedef uint16_t tokTypeMfgOsc24mBiasTrim;
#endif //__MFG_TYPES_DEFINED__

22
cpu/stm32w108/hal/micro/cortexm3/uart.c
View file

@ -28,18 +28,18 @@ int putchar (int c)
#endif
#define RECEIVE_QUEUE_SIZE (128)
int8u rxQ[RECEIVE_QUEUE_SIZE];
int16u rxHead;
int16u rxTail;
int16u rxUsed;
uint8_t rxQ[RECEIVE_QUEUE_SIZE];
uint16_t rxHead;
uint16_t rxTail;
uint16_t rxUsed;
//////////////////////////////////////////////////////////////////////////////
// Initialization
void uartInit(int32u baudrate, int8u databits, SerialParity parity, int8u stopbits)
void uartInit(uint32_t baudrate, uint8_t databits, SerialParity parity, uint8_t stopbits)
{
int32u tempcfg;
int32u tmp;
uint32_t tempcfg;
uint32_t tmp;
assert( (baudrate >= 300) && (baudrate <=921600) );
@ -171,10 +171,10 @@ static void halInternalUart1RxIsr(void)
// data, processing any errors noted
// along the way.
while ( SC1_UARTSTAT & SC_UARTRXVAL ) {
int8u errors = SC1_UARTSTAT & (SC_UARTFRMERR |
uint8_t errors = SC1_UARTSTAT & (SC_UARTFRMERR |
SC_UARTRXOVF |
SC_UARTPARERR );
int8u incoming = (int8u) SC1_DATA;
uint8_t incoming = (uint8_t) SC1_DATA;
if ( (errors == 0) && (rxUsed < (RECEIVE_QUEUE_SIZE-1)) ) {
rxQ[rxHead] = incoming;
@ -194,7 +194,7 @@ static void halInternalUart1RxIsr(void)
void halSc1Isr(void)
{
int32u interrupt;
uint32_t interrupt;
//this read and mask is performed in two steps otherwise the compiler
//will complain about undefined order of volatile access
@ -233,7 +233,7 @@ void halSc1Isr(void)
* Output : dataByte: buffer containing the read byte if any
* Return : TRUE if there is a data, FALSE otherwise
*******************************************************************************/
boolean __io_getcharNonBlocking(int8u *data)
boolean __io_getcharNonBlocking(uint8_t *data)
{
if (__read(_LLIO_STDIN,data,1))
return TRUE;

4
cpu/stm32w108/hal/micro/cortexm3/uart.h
View file

@ -36,7 +36,7 @@ typedef enum
* @return stopbits The number of stop bits used for communication.
* Valid values are 1 or 2
*/
void uartInit(int32u baudrate, int8u databits, SerialParity parity, int8u stopbits);
void uartInit(uint32_t baudrate, uint8_t databits, SerialParity parity, uint8_t stopbits);
#ifdef __ICCARM__
/**
@ -63,7 +63,7 @@ size_t fflush(int handle);
/**
* @brief Read the input byte if any.
*/
boolean __io_getcharNonBlocking(int8u *data);
boolean __io_getcharNonBlocking(uint8_t *data);
void __io_putchar( char c );
int __io_getchar(void);
void __io_flush( void );

127
cpu/stm32w108/hal/micro/generic/compiler/platform-common.h
View file

@ -1,11 +1,5 @@
/** @file hal/micro/generic/compiler/platform-common.h
* See @ref platform_common for detailed documentation.
*
* <!--(C) COPYRIGHT 2010 STMicroelectronics. All rights reserved. -->
*/
/** @addtogroup platform_common
* @brief Compiler and Platform specific definitions and typedefs common to
/** \addtogroup platform_common
* \brief Compiler and Platform specific definitions and typedefs common to
* all platforms.
*
* platform-common.h provides PLATFORM_HEADER defaults and common definitions.
@ -16,6 +10,13 @@
*@{
*/
/** \file hal/micro/generic/compiler/platform-common.h
* See \ref platform_common for detailed documentation.
*
* <!--(C) COPYRIGHT 2010 STMicroelectronics. All rights reserved. -->
*/
#ifndef PLATCOMMONOKTOINCLUDE
// This header should only be included by a PLATFORM_HEADER
#error platform-common.h should not be included directly
@ -36,23 +37,23 @@
*/
//@{
/**
* @brief Standard program memory delcaration.
* \brief Standard program memory delcaration.
*/
#define PGM const
/**
* @brief Char pointer to program memory declaration.
* \brief Char pointer to program memory declaration.
*/
#define PGM_P const char *
/**
* @brief Unsigned char pointer to program memory declaration.
* \brief Unsigned char pointer to program memory declaration.
*/
#define PGM_PU const unsigned char *
/**
* @brief Sometimes a second PGM is needed in a declaration. Having two
* \brief Sometimes a second PGM is needed in a declaration. Having two
* 'const' declarations generates a warning so we have a second PGM that turns
* into nothing under gcc.
*/
@ -72,32 +73,32 @@
*/
//@{
/**
* @brief Provide a portable name for the int32u by int16u division
* \brief Provide a portable name for the uint32_t by uint16_t division
* library function (which can perform the division with only a single
* assembly instruction on some platforms)
*/
#define halCommonUDiv32By16(x, y) ((int16u) (((int32u) (x)) / ((int16u) (y))))
#define halCommonUDiv32By16(x, y) ((uint16_t) (((uint32_t) (x)) / ((uint16_t) (y))))
/**
* @brief Provide a portable name for the int32s by int16s division
* \brief Provide a portable name for the int32_t by int16_t division
* library function (which can perform the division with only a single
* assembly instruction on some platforms)
*/
#define halCommonSDiv32By16(x, y) ((int16s) (((int32s) (x)) / ((int16s) (y))))
#define halCommonSDiv32By16(x, y) ((int16_t) (((int32_t) (x)) / ((int16_t) (y))))
/**
* @brief Provide a portable name for the int32u by int16u modulo
* \brief Provide a portable name for the uint32_t by uint16_t modulo
* library function (which can perform the division with only a single
* assembly instruction on some platforms)
*/
#define halCommonUMod32By16(x, y) ((int16u) (((int32u) (x)) % ((int16u) (y))))
#define halCommonUMod32By16(x, y) ((uint16_t) (((uint32_t) (x)) % ((uint16_t) (y))))
/**
* @brief Provide a portable name for the int32s by int16s modulo
* \brief Provide a portable name for the int32_t by int16_t modulo
* library function (which can perform the division with only a single
* assembly instruction on some platforms)
*/
#define halCommonSMod32By16(x, y) ((int16s) (((int32s) (x)) % ((int16s) (y))))
#define halCommonSMod32By16(x, y) ((int16_t) (((int32_t) (x)) % ((int16_t) (y))))
//@} \\END DIVIDE and MODULUS OPERATIONS
#endif //_HAL_USE_COMMON_DIVMOD_
@ -118,25 +119,25 @@
//@{
/**
* @brief Refer to the C stdlib memcpy().
* \brief Refer to the C stdlib memcpy().
*/
void halCommonMemCopy(void *dest, const void *src, int8u bytes);
void halCommonMemCopy(void *dest, const void *src, uint8_t bytes);
/**
* @brief Refer to the C stdlib memset().
* \brief Refer to the C stdlib memset().
*/
void halCommonMemSet(void *dest, int8u val, int16u bytes);
void halCommonMemSet(void *dest, uint8_t val, uint16_t bytes);
/**
* @brief Refer to the C stdlib memcmp().
* \brief Refer to the C stdlib memcmp().
*/
int8s halCommonMemCompare(const void *source0, const void *source1, int8u bytes);
int8_t halCommonMemCompare(const void *source0, const void *source1, uint8_t bytes);
/**
* @brief Friendly convenience macro pointing to the full HAL function.
* \brief Friendly convenience macro pointing to the full HAL function.
*/
#define MEMSET(d,v,l) halCommonMemSet(d,v,l)
#define MEMCOPY(d,s,l) halCommonMemCopy(d,s,l)
@ -165,18 +166,18 @@
*/
/**
* @brief An alias for one, used for clarity.
* \brief An alias for one, used for clarity.
*/
#define TRUE 1
/**
* @brief An alias for zero, used for clarity.
* \brief An alias for zero, used for clarity.
*/
#define FALSE 0
#ifndef NULL
/**
* @brief The null pointer.
* \brief The null pointer.
*/
#define NULL ((void *)0)
#endif
@ -190,50 +191,50 @@
//@{
/**
* @brief Useful to reference a single bit of a byte.
* \brief Useful to reference a single bit of a byte.
*/
#define BIT(x) (1U << (x)) // Unsigned avoids compiler warnings re BIT(15)
/**
* @brief Useful to reference a single bit of an int32u type.
* \brief Useful to reference a single bit of an uint32_t type.
*/
#define BIT32(x) (((int32u) 1) << (x))
#define BIT32(x) (((uint32_t) 1) << (x))
/**
* @brief Sets \c bit in the \c reg register or byte.
* \brief Sets \c bit in the \c reg register or byte.
* @note Assuming \c reg is an IO register, some platforms
* can implement this in a single atomic operation.
*/
#define SETBIT(reg, bit) reg |= BIT(bit)
/**
* @brief Sets the bits in the \c reg register or the byte
* \brief Sets the bits in the \c reg register or the byte
* as specified in the bitmask \c bits.
* @note This is never a single atomic operation.
*/
#define SETBITS(reg, bits) reg |= (bits)
/**
* @brief Clears a bit in the \c reg register or byte.
* \brief Clears a bit in the \c reg register or byte.
* @note Assuming \c reg is an IO register, some platforms (such as the AVR)
* can implement this in a single atomic operation.
*/
#define CLEARBIT(reg, bit) reg &= ~(BIT(bit))
/**
* @brief Clears the bits in the \c reg register or byte
* \brief Clears the bits in the \c reg register or byte
* as specified in the bitmask \c bits.
* @note This is never a single atomic operation.
*/
#define CLEARBITS(reg, bits) reg &= ~(bits)
/**
* @brief Returns the value of \c bit within the register or byte \c reg.
* \brief Returns the value of \c bit within the register or byte \c reg.
*/
#define READBIT(reg, bit) (reg & (BIT(bit)))
/**
* @brief Returns the value of the bitmask \c bits within
* \brief Returns the value of the bitmask \c bits within
* the register or byte \c reg.
*/
#define READBITS(reg, bits) (reg & (bits))
@ -248,43 +249,43 @@
//@{
/**
* @brief Returns the low byte of the 16-bit value \c n as an \c int8u.
* \brief Returns the low byte of the 16-bit value \c n as an \c uint8_t.
*/
#define LOW_BYTE(n) ((int8u)((n) & 0xFF))
#define LOW_BYTE(n) ((uint8_t)((n) & 0xFF))
/**
* @brief Returns the high byte of the 16-bit value \c n as an \c int8u.
* \brief Returns the high byte of the 16-bit value \c n as an \c uint8_t.
*/
#define HIGH_BYTE(n) ((int8u)(LOW_BYTE((n) >> 8)))
#define HIGH_BYTE(n) ((uint8_t)(LOW_BYTE((n) >> 8)))
/**
* @brief Returns the value built from the two \c int8u
* \brief Returns the value built from the two \c uint8_t
* values \c high and \c low.
*/
#define HIGH_LOW_TO_INT(high, low) ( \
(( (int16u) (high) ) << 8) + \
( (int16u) ( (low) & 0xFF)) \
(( (uint16_t) (high) ) << 8) + \
( (uint16_t) ( (low) & 0xFF)) \
)
/**
* @brief Returns the low byte of the 32-bit value \c n as an \c int8u.
* \brief Returns the low byte of the 32-bit value \c n as an \c uint8_t.
*/
#define BYTE_0(n) ((int8u)((n) & 0xFF))
#define BYTE_0(n) ((uint8_t)((n) & 0xFF))
/**
* @brief Returns the second byte of the 32-bit value \c n as an \c int8u.
* \brief Returns the second byte of the 32-bit value \c n as an \c uint8_t.
*/
#define BYTE_1(n) ((int8u)(BYTE_0((n) >> 8)))
#define BYTE_1(n) ((uint8_t)(BYTE_0((n) >> 8)))
/**
* @brief Returns the third byte of the 32-bit value \c n as an \c int8u.
* \brief Returns the third byte of the 32-bit value \c n as an \c uint8_t.
*/
#define BYTE_2(n) ((int8u)(BYTE_0((n) >> 16)))
#define BYTE_2(n) ((uint8_t)(BYTE_0((n) >> 16)))
/**
* @brief Returns the high byte of the 32-bit value \c n as an \c int8u.
* \brief Returns the high byte of the 32-bit value \c n as an \c uint8_t.
*/
#define BYTE_3(n) ((int8u)(BYTE_0((n) >> 24)))
#define BYTE_3(n) ((uint8_t)(BYTE_0((n) >> 24)))
//@} \\END Byte manipulation macros
@ -296,28 +297,28 @@
//@{
/**
* @brief Returns the elapsed time between two 8 bit values.
* \brief Returns the elapsed time between two 8 bit values.
* Result may not be valid if the time samples differ by more than 127
*/
#define elapsedTimeInt8u(oldTime, newTime) \
((int8u) ((int8u)(newTime) - (int8u)(oldTime)))
((uint8_t) ((uint8_t)(newTime) - (uint8_t)(oldTime)))
/**
* @brief Returns the elapsed time between two 16 bit values.
* \brief Returns the elapsed time between two 16 bit values.
* Result may not be valid if the time samples differ by more than 32767
*/
#define elapsedTimeInt16u(oldTime, newTime) \
((int16u) ((int16u)(newTime) - (int16u)(oldTime)))
((uint16_t) ((uint16_t)(newTime) - (uint16_t)(oldTime)))
/**
* @brief Returns the elapsed time between two 32 bit values.
* \brief Returns the elapsed time between two 32 bit values.
* Result may not be valid if the time samples differ by more than 2147483647
*/
#define elapsedTimeInt32u(oldTime, newTime) \
((int32u) ((int32u)(newTime) - (int32u)(oldTime)))
((uint32_t) ((uint32_t)(newTime) - (uint32_t)(oldTime)))
/**
* @brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* \brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* around of the variable before it is wrong.
*/
#define MAX_INT8U_VALUE 0xFF
@ -325,7 +326,7 @@
(elapsedTimeInt8u(t2, t1) <= ((MAX_INT8U_VALUE + 1) / 2))
/**
* @brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* \brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* around of the variable before it is wrong.
*/
#define MAX_INT16U_VALUE 0xFFFF
@ -333,7 +334,7 @@
(elapsedTimeInt16u(t2, t1) <= ((MAX_INT16U_VALUE + 1) / 2))
/**
* @brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* \brief Returns TRUE if t1 is greater than t2. Can only account for 1 wrap
* around of the variable before it is wrong.
*/
#define MAX_INT32U_VALUE 0xFFFFFFFF

2
cpu/stm32w108/hal/micro/led.h
View file

@ -22,7 +22,7 @@ void halInitLed(void);
/** @brief Ensures that the definitions from the BOARD_HEADER
* are always used as parameters to the LED functions.
*/
typedef int8u HalBoardLed;
typedef uint8_t HalBoardLed;
// Note: Even though many compilers will use 16 bits for an enum instead of 8,
// we choose to use an enum here. The possible compiler inefficiency does not
// affect stack-based parameters and local variables, which is the

6
cpu/stm32w108/hal/micro/mems_regs.h → cpu/stm32w108/hal/micro/mems-regs.h
View file

@ -1,4 +1,4 @@
/** @file hal/micro/mems_regs.h
/** @file hal/micro/mems-regs.h
* @brief stm32w108 mems registers
*
* <!--(C) COPYRIGHT 2010 STMicroelectronics. All rights reserved. -->
@ -112,14 +112,14 @@
//-reg_addr is the address of the register to be written--//
//-pBuffer is the storage destination for the read data---//
//-NoOfBytes is the amount of data to read----------------//
int8u i2c_read_reg (int8u slave_addr, int8u reg_addr, int8u *pBuffer, int8u NoOfBytes);
uint8_t i2c_read_reg (uint8_t slave_addr, uint8_t reg_addr, uint8_t *pBuffer, uint8_t NoOfBytes);
//*********************i2c_write_reg**********************//
//----------Writes a register on the I2C target-----------//
//------slave addr is the is the I2C target device--------//
//-reg_addr is the address of the register to be written--//
//-reg_value is the value of the register to be written---//
int8u i2c_write_reg (int8u slave_addr, int8u reg_addr, int8u reg_value);
uint8_t i2c_write_reg (uint8_t slave_addr, uint8_t reg_addr, uint8_t reg_value);
#endif /* _MEMS_REGS_H_ */

18
cpu/stm32w108/hal/micro/mems.h
View file

@ -8,29 +8,29 @@
#ifndef _MEMS_H_
#define _MEMS_H_
#include "hal/micro/mems_regs.h"
#include "hal/micro/mems-regs.h"
/** @brief Mems data type: three acceleration values each related to a specific direction
Watch out: only lower data values (e.g. those terminated by the _l) are
currently used by the device */
typedef struct {
int8u outx_l;
int8u outx_h;
int8u outy_l;
int8u outy_h;
int8u outz_l;
int8u outz_h;
uint8_t outx_l;
uint8_t outx_h;
uint8_t outy_l;
uint8_t outy_h;
uint8_t outz_l;
uint8_t outz_h;
} t_mems_data;
/** @brief Mems Initialization function
*/
int8u mems_Init(void);
uint8_t mems_Init(void);
/** @brief Get mems acceleration values
*/
int8u mems_GetValue(t_mems_data *mems_data);
uint8_t mems_GetValue(t_mems_data *mems_data);
#endif /* _MEMS_H_ */

10
cpu/stm32w108/hal/micro/micro-common.h
View file

@ -21,7 +21,7 @@
//This is necessary here because halSleepForQsWithOptions returns an
//StStatus and not adding this typedef to this file breaks a
//whole lot of builds.
typedef int8u StStatus;
typedef uint8_t StStatus;
#endif //__STSTATUS_TYPE__
#endif // DOXYGEN_SHOULD_SKIP_THIS
@ -58,7 +58,7 @@ void halInternalEnableWatchDog(void);
*
* @param magicKey A value (::MICRO_DISABLE_WATCH_DOG_KEY) that enables the function.
*/
void halInternalDisableWatchDog(int8u magicKey);
void halInternalDisableWatchDog(uint8_t magicKey);
/** @brief Determines whether the watchdog has been enabled or disabled.
*
@ -90,7 +90,7 @@ boolean halInternalWatchDogEnabled( void );
*/
enum SleepModes
#else
typedef int8u SleepModes;
typedef uint8_t SleepModes;
enum
#endif
{
@ -116,7 +116,7 @@ enum
* @param us The specified time, in microseconds.
Values should be between 1 and 65535 microseconds.
*/
void halCommonDelayMicroseconds(int16u us);
void halCommonDelayMicroseconds(uint16_t us);
/** @brief Request the appplication to enter in bootloader mode
*
@ -132,7 +132,7 @@ void halCommonDelayMicroseconds(int16u us);
* default panID (only vaild for RF mode).
* @return An error code or it will never return.
*/
StStatus halBootloaderStart(int8u mode, int8u channel, int16u panId);
StStatus halBootloaderStart(uint8_t mode, uint8_t channel, uint16_t panId);
#ifdef CORTEXM3_STM32F103
#include "micro/cortexm3/stm32f103ret/micro-specific.h"

8
cpu/stm32w108/hal/micro/system-timer.h
View file

@ -38,7 +38,7 @@
* @return Time to update the async registers after RTC is started (units of 100
* microseconds).
*/
int16u halInternalStartSystemTimer(void);
uint16_t halInternalStartSystemTimer(void);
/**
@ -48,7 +48,7 @@ int16u halInternalStartSystemTimer(void);
* @return The least significant 16 bits of the current system time, in system
* ticks.
*/
int16u halCommonGetInt16uMillisecondTick(void);
uint16_t halCommonGetInt16uMillisecondTick(void);
/**
* @brief Returns the current system time in system ticks, as a 32-bit
@ -59,7 +59,7 @@ int16u halCommonGetInt16uMillisecondTick(void);
* @return The least significant 32 bits of the current system time, in
* system ticks.
*/
int32u halCommonGetInt32uMillisecondTick(void);
uint32_t halCommonGetInt32uMillisecondTick(void);
/**
* @brief Returns the current system time in quarter second ticks, as a
@ -70,7 +70,7 @@ int32u halCommonGetInt32uMillisecondTick(void);
* @return The least significant 16 bits of the current system time, in system
* ticks multiplied by 256.
*/
int16u halCommonGetInt16uQuarterSecondTick(void);
uint16_t halCommonGetInt16uQuarterSecondTick(void);
#endif //__SYSTEM_TIMER_H__

4
cpu/stm32w108/hal/micro/temperature_sensor.h → cpu/stm32w108/hal/micro/temperature-sensor.h
View file

@ -1,4 +1,4 @@
/** @file temperature_sensor.h
/** @file temperature-sensor.h
* @brief Header for temperature sensor driver
*
*
@ -21,7 +21,7 @@ void temperatureSensor_Init(void);
/** @brief Get temperature sensor value
*/
int32u temperatureSensor_GetValue(void);
uint32_t temperatureSensor_GetValue(void);
#endif /* _TEMP_SENSOR_H_ */

8
cpu/stm32w108/hal/token-phy.h
View file

@ -18,10 +18,10 @@
#ifdef DEFINETYPES
typedef struct {
int8u vcoAtLna; // the VCO tune value at the time LNA value was calculated.
int8u modDac; // msb : cal needed , bit 0-5 : value
int8u filter; // msb : cal needed , bit 0-4 : value
int8u lna; // msb : cal needed , bit 0-5 : value
uint8_t vcoAtLna; // the VCO tune value at the time LNA value was calculated.
uint8_t modDac; // msb : cal needed , bit 0-5 : value
uint8_t filter; // msb : cal needed , bit 0-4 : value
uint8_t lna; // msb : cal needed , bit 0-5 : value
} tokTypeStackCalData;
#endif

31
cpu/stm32w108/leds-arch.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,17 +33,14 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Leds.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include PLATFORM_HEADER
#include BOARD_HEADER
@ -46,32 +49,30 @@
#include "hal/micro/micro-common.h"
#include "hal/micro/cortexm3/micro-common.h"
#define LEDS_PORT *((volatile int32u *)(GPIO_PxOUT_BASE+(GPIO_Px_OFFSET*(LEDS_CONF_PORT/8))))
#define LEDS_PORT *((volatile uint32_t *)(GPIO_PxOUT_BASE+(GPIO_Px_OFFSET*(LEDS_CONF_PORT/8))))
/*---------------------------------------------------------------------------*/
void
leds_arch_init(void)
{
halGpioConfig(PORTx_PIN(LEDS_CONF_PORT,LEDS_CONF_RED_PIN),GPIOCFG_OUT);
halGpioConfig(PORTx_PIN(LEDS_CONF_PORT,LEDS_CONF_GREEN_PIN),GPIOCFG_OUT);
halGpioConfig(PORTx_PIN(LEDS_CONF_PORT, LEDS_CONF_RED_PIN), GPIOCFG_OUT);
halGpioConfig(PORTx_PIN(LEDS_CONF_PORT, LEDS_CONF_GREEN_PIN), GPIOCFG_OUT);
LEDS_PORT |= (LEDS_CONF_RED | LEDS_CONF_GREEN);
}
/*---------------------------------------------------------------------------*/
unsigned char
leds_arch_get(void)
{
return ((LEDS_PORT & LEDS_CONF_RED) ? 0 : LEDS_RED)
| ((LEDS_PORT & LEDS_CONF_GREEN) ? 0 : LEDS_GREEN);
return ((LEDS_PORT & LEDS_CONF_RED) ? 0 : LEDS_RED) |
((LEDS_PORT & LEDS_CONF_GREEN) ? 0 : LEDS_GREEN);
}
/*---------------------------------------------------------------------------*/
void
leds_arch_set(unsigned char leds)
{
LEDS_PORT = (LEDS_PORT & ~(LEDS_CONF_RED|LEDS_CONF_GREEN))
| ((leds & LEDS_RED) ? 0 : LEDS_CONF_RED)
| ((leds & LEDS_GREEN) ? 0 : LEDS_CONF_GREEN);
LEDS_PORT = (LEDS_PORT & ~(LEDS_CONF_RED | LEDS_CONF_GREEN)) |
((leds & LEDS_RED) ? 0 : LEDS_CONF_RED) |
((leds & LEDS_GREEN) ? 0 : LEDS_CONF_GREEN);
}
/*---------------------------------------------------------------------------*/
/** @} */

40
cpu/stm32w108/mtarch.h
View file

@ -1,5 +1,42 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Implementation of multithreading in ARM Cortex-M3. To be done.
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* 3. The name of the author may not be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
* Implementation of multithreading in ARM Cortex-M3. To do.
*/
@ -11,3 +48,4 @@ struct mtarch_thread {
};
#endif /* __MTARCH_H__ */
/** @} */

29
cpu/stm32w108/rand.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,17 +33,14 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Random number functions for STM32W.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include "dev/stm32w-radio.h"
#include "lib/random.h"
@ -46,18 +49,20 @@
#warning "RANDOM_RAND_MAX is not defined as 65535."
#endif
int rand(void)
/*--------------------------------------------------------------------------*/
int
rand(void)
{
uint16_t rand_num;
ST_RadioGetRandomNumbers(&rand_num, 1);
return (int)rand_num;
uint16_t rand_num;
ST_RadioGetRandomNumbers(&rand_num, 1);
return (int)rand_num;
}
/*--------------------------------------------------------------------------*/
/*
* It does nothing, since the rand already generates true random numbers.
*/
void srand(unsigned int seed)
void
srand(unsigned int seed)
{
}
/** @} */

150
cpu/stm32w108/rtimer-arch.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,23 +33,18 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Real-timer specific implementation for STM32W.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include "sys/energest.h"
#include "sys/rtimer.h"
#define DEBUG 0
#if DEBUG
#include <stdio.h>
@ -52,123 +53,116 @@
#define PRINTF(...)
#endif
static uint16_t saved_TIM1CFG;
static uint32_t time_msb = 0; /* Most significant bits of the current time. */
static uint32_t time_msb = 0; // Most significant bits of the current time.
// time of the next rtimer event. Initially is set to the max value.
/* time of the next rtimer event. Initially is set to the max
value. */
static rtimer_clock_t next_rtimer_time = 0;
static uint16_t saved_TIM1CFG;
/*---------------------------------------------------------------------------*/
void halTimer1Isr(void){
if(INT_TIM1FLAG & INT_TIMUIF){ // Overflow event.
//PRINTF("O %4x.\r\n", TIM1_CNT);
//printf("OV ");
void
halTimer1Isr(void)
{
if(INT_TIM1FLAG & INT_TIMUIF) {
rtimer_clock_t now, clock_to_wait;
/* Overflow event. */
/* PRINTF("O %4x.\r\n", TIM1_CNT); */
/* printf("OV "); */
time_msb++;
rtimer_clock_t now = ((rtimer_clock_t)time_msb << 16)|TIM1_CNT;
now = ((rtimer_clock_t) time_msb << 16) | TIM1_CNT;
clock_to_wait = next_rtimer_time - now;
rtimer_clock_t clock_to_wait = next_rtimer_time - now;
if(clock_to_wait <= 0x10000 && clock_to_wait > 0){ // We must set now the Timer Compare Register.
TIM1_CCR1 = (int16u)clock_to_wait;
if(clock_to_wait <= 0x10000 && clock_to_wait > 0) {
/* We must now set the Timer Compare Register. */
TIM1_CCR1 = (uint16_t) clock_to_wait;
INT_TIM1FLAG = INT_TIMCC1IF;
INT_TIM1CFG |= INT_TIMCC1IF; // Compare 1 interrupt enable.
INT_TIM1CFG |= INT_TIMCC1IF; /* Compare 1 interrupt enable. */
}
INT_TIM1FLAG = INT_TIMUIF;
} else {
if(INT_TIM1FLAG & INT_TIMCC1IF) {
/* Compare event. */
INT_TIM1CFG &= ~INT_TIMCC1IF; /* Disable the next compare interrupt */
PRINTF("\nCompare event %4x\r\n", TIM1_CNT);
PRINTF("INT_TIM1FLAG %2x\r\n", INT_TIM1FLAG);
ENERGEST_ON(ENERGEST_TYPE_IRQ);
rtimer_run_next();
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
INT_TIM1FLAG = INT_TIMCC1IF;
}
}
else if(INT_TIM1FLAG & INT_TIMCC1IF){ // Compare event.
INT_TIM1CFG &= ~INT_TIMCC1IF; // Disable the next compare interrupt
PRINTF("\nCompare event %4x\r\n", TIM1_CNT);
PRINTF("INT_TIM1FLAG %2x\r\n", INT_TIM1FLAG);
ENERGEST_ON(ENERGEST_TYPE_IRQ);
rtimer_run_next();
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
INT_TIM1FLAG = INT_TIMCC1IF;
}
}
/*---------------------------------------------------------------------------*/
void
rtimer_arch_init(void)
{
TIM1_CR1 = 0;
TIM1_PSC = RTIMER_ARCH_PRESCALER;
TIM1_PSC = RT_PRESCALER;
TIM1_ARR = 0xffff; // Counting from 0 to the maximum value.
// Bits of TIMx_CCMR1 as default.
TIM1_EGR = TIM_UG; // Update Generation.
/* Counting from 0 to the maximum value. */
TIM1_ARR = 0xffff;
/* Bits of TIMx_CCMR1 as default. */
/* Update Generation. */
TIM1_EGR = TIM_UG;
INT_TIM1FLAG = 0xffff;
INT_TIM1CFG = INT_TIMUIF; // Update interrupt enable (interrupt on overflow).
/* Update interrupt enable (interrupt on overflow).*/
INT_TIM1CFG = INT_TIMUIF;
TIM1_CR1 = TIM_CEN; // Counter enable.
/* Counter enable. */
TIM1_CR1 = TIM_CEN;
INT_CFGSET = INT_TIM1; // Enable top level interrupt.
/* Enable top level interrupt. */
INT_CFGSET = INT_TIM1;
}
/*---------------------------------------------------------------------------*/
void rtimer_arch_disable_irq(void)
void
rtimer_arch_disable_irq(void)
{
ATOMIC(
saved_TIM1CFG = INT_TIM1CFG;
INT_TIM1CFG = 0;
)
ATOMIC(saved_TIM1CFG = INT_TIM1CFG; INT_TIM1CFG = 0;)
}
/*---------------------------------------------------------------------------*/
void rtimer_arch_enable_irq(void)
void
rtimer_arch_enable_irq(void)
{
INT_TIM1CFG = saved_TIM1CFG;
}
/*---------------------------------------------------------------------------*/
rtimer_clock_t rtimer_arch_now(void)
rtimer_clock_t
rtimer_arch_now(void)
{
return ((rtimer_clock_t)time_msb << 16)|TIM1_CNT;
rtimer_clock_t t;
ATOMIC(t = ((rtimer_clock_t) time_msb << 16) | TIM1_CNT;)
return t;
}
/*---------------------------------------------------------------------------*/
void
rtimer_arch_schedule(rtimer_clock_t t)
{
PRINTF("rtimer_arch_schedule time %4x\r\n", /*((uint32_t*)&t)+1,*/(uint32_t)t);
rtimer_clock_t now, clock_to_wait;
PRINTF("rtimer_arch_schedule time %4x\r\n", /*((uint32_t*)&t)+1, */
(uint32_t)t);
next_rtimer_time = t;
rtimer_clock_t now = rtimer_arch_now();
rtimer_clock_t clock_to_wait = t - now;
now = rtimer_arch_now();
clock_to_wait = t - now;
PRINTF("now %2x\r\n", TIM1_CNT);
PRINTF("clock_to_wait %4x\r\n", clock_to_wait);
if(clock_to_wait <= 0x10000){ // We must set now the Timer Compare Register.
TIM1_CCR1 = (int16u)now + (int16u)clock_to_wait;
if(clock_to_wait <= 0x10000) {
/* We must now set the Timer Compare Register. */
TIM1_CCR1 = (uint16_t)now + (uint16_t)clock_to_wait;
INT_TIM1FLAG = INT_TIMCC1IF;
INT_TIM1CFG |= INT_TIMCC1IF; // Compare 1 interrupt enable.
INT_TIM1CFG |= INT_TIMCC1IF; /* Compare 1 interrupt enable. */
PRINTF("2-INT_TIM1FLAG %2x\r\n", INT_TIM1FLAG);
}
// else compare register will be set at overflow interrupt closer to the rtimer event.
/* else compare register will be set at overflow interrupt closer to
the rtimer event. */
}
/*---------------------------------------------------------------------------*/
/** @} */

72
cpu/stm32w108/rtimer-arch.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,8 +33,6 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/**
@ -41,43 +45,53 @@
#ifndef __RTIMER_ARCH_H__
#define __RTIMER_ARCH_H__
#define RTIMER_ARCH_RES_341US 0
#define RTIMER_ARCH_RES_171US 1
#define RTIMER_ARCH_RES_85US 2
#include "contiki-conf.h"
#include "sys/clock.h"
#ifdef RTIMER_ARCH_CONF_RESOLUTION
#define RTIMER_ARCH_RESOLUTION RTIMER_ARCH_CONF_RESOLUTION
#else /* RTIMER_ARCH_CONF_RESOLUTION */
#define RTIMER_ARCH_RESOLUTION RTIMER_ARCH_RES_171US
#endif /* RTIMER_ARCH_CONF_RESOLUTION */
//#define RT_RESOLUTION RES_85US
#ifdef RT_CONF_RESOLUTION
#define RT_RESOLUTION RT_CONF_RESOLUTION
#else
#define RT_RESOLUTION RES_171US
#endif
/*
* If it was possible to define a custom size for the rtimer_clock_t
* type: typedef unsigned long long rtimer_clock_t; Only 48 bit are
* used. It's enough for hundreds of years.
*/
#if RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_341US
/* CK_CNT = PCLK/4096 = 12 MHz/4096 = 2929.6875 Hz */
#define RTIMER_ARCH_PRESCALER 12
/* One tick: 341.33 us. Using this value we will delay about 9.22 sec
after a day. */
#define RTIMER_ARCH_SECOND 2930
#endif /* RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_341US */
#define RES_341US 0
#define RES_171US 1
#define RES_85US 2
#if RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_171US
/* CK_CNT = PCLK/2048 = 12 MHz/2048 = 5859.375 Hz */
#define RTIMER_ARCH_PRESCALER 11
/* One tick: 170.66 us. Using this value we will advance about 5.53
sec after a day. */
#define RTIMER_ARCH_SECOND 5859
#endif /* RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_171US */
// If it was possible to define a custom size for the rtimer_clock_t type:
//typedef unsigned long long rtimer_clock_t; // Only 48 bit are used. It's enough for hundreds of years.
#if RT_RESOLUTION == RES_341US
#define RT_PRESCALER 12 // CK_CNT = PCLK/4096 = 12 MHz/4096 = 2929.6875 Hz
#define RTIMER_ARCH_SECOND 2930 // One tick: 341.33 us. Using this value we will delay about 9.22 sec after a day.
#endif /* RT_RESOLUTION == RES_341US */
#if RT_RESOLUTION == RES_171US
#define RT_PRESCALER 11 // CK_CNT = PCLK/2048 = 12 MHz/2048 = 5859.375 Hz
#define RTIMER_ARCH_SECOND 5859 // One tick: 170.66 us. Using this value we will advance about 5.53 sec after a day.
#endif /* RT_RESOLUTION == RES_171US */
#if RT_RESOLUTION == RES_85US
#define RT_PRESCALER 10 // CK_CNT = PCLK/2048 = 12 MHz/2048 = 5859.375 Hz
#define RTIMER_ARCH_SECOND 11719 // One tick: 85.33 us. Using this value we will delay about 1.84 sec after a day.
#endif /* RT_RESOLUTION == RES_85US */
#if RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_85US
/* CK_CNT = PCLK/2048 = 12 MHz/2048 = 5859.375 Hz */
#define RTIMER_ARCH__PRESCALER 10
/* One tick: 85.33 us. Using this value we will delay about 1.84 sec
after a day. */
#define RTIMER_ARCH_SECOND 11719
#endif /* RTIMER_ARCH_RESOLUTION == RTIMER_ARCH_RES_85US */
rtimer_clock_t rtimer_arch_now(void);
//#define rtimer_arch_now() clock_time()
void rtimer_arch_disable_irq(void);
void rtimer_arch_enable_irq(void);
#endif /* __RTIMER_ARCH_H__ */
/** @} */

10
cpu/stm32w108/sleep.h
View file

@ -1,10 +0,0 @@
/* Enter system in deep sleep 1 (core power domain is fully
* powered down and sleep timer is active).
* Execution is suspended for a given number of seconds.
*
* Pay attention! All system peripherals (including sensors) have
* to be reinitialized before being used again. UART, LEDs and
* real timers are automatically reinitialized. */
void sleep_seconds(int seconds);

19
cpu/stm32w108/slip_uart1.c → cpu/stm32w108/slip-uart1.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,35 +33,30 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Machine dependent STM32W SLIP routines for UART1.
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include <stdio.h>
#include "contiki.h"
#include "dev/slip.h"
#include "dev/uart1.h"
/*--------------------------------------------------------------------------*/
void
slip_arch_init(unsigned long ubr)
{
uart1_set_input(slip_input_byte);
}
/*--------------------------------------------------------------------------*/
void
slip_arch_writeb(unsigned char c)
{
uart1_writeb(c);
}
/** @} */

15
cpu/stm32w108/small_printf/Makefile → cpu/stm32w108/small-printf/Makefile
View file

@ -1,33 +1,20 @@
CC = arm-none-eabi-gcc
AR = arm-none-eabi-ar
CFLAGS = -mthumb -mcpu=cortex-m3 -I "." -I "C:/Program\ Files/Raisonance/Ride/Lib/ARM/include" \
-fsigned-char -D _SMALL_PRINTF -D INTEGER_ONLY -Os -ffunction-sections -mlittle-endian
AROPTS = cq
SOURCE_FILES = _SP_printf.c _SP_puts.c _SP_sprintf.c _SP_snprintf.c _SP_vfprintf.c
SOURCE_FILES = sp-printf.c sp-puts.c sp-sprintf.c sp-snprintf.c sp-vfprintf.c
SOURCE_OBJS = ${patsubst %.c,%.o,$(SOURCE_FILES)}
LIB = smallprintf_thumb2.a
all: clean $(LIB)
clean:
rm -f $(LIB)
%.a: $(SOURCE_OBJS)
$(AR) $(AROPTS) $@ $^
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@

84
cpu/stm32w108/small-printf/sp-printf.c Normal file
View file

@ -0,0 +1,84 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
#ifdef INTEGER_ONLY
#define _vfprintf_r _vfiprintf_r
#define _vfprintf _vfiprintf
#define vfprintf vfiprintf
#endif /* INTEGER_ONLY */
#include <_ansi.h>
#include <stdio.h>
#ifndef _SMALL_PRINTF
#include "local.h"
#endif /* _SMALL_PRINTF */
#ifdef _HAVE_STDC
#include <stdarg.h>
#else /* _HAVE_STDC */
#include <varargs.h>
#endif /* _HAVE_STDC */
/*--------------------------------------------------------------------------*/
#ifndef _SMALL_PRINTF
#ifdef _HAVE_STDC
int
_printf_r (struct _reent *ptr, const char *fmt, ...)
#else /* _HAVE_STDC */
int
_printf_r (ptr, fmt, va_alist)
struct _reent *ptr;
char *fmt;
va_dcl
#endif /* _HAVE_STDC */
{
int ret;
va_list ap;
//_REENT_SMALL_CHECK_INIT(_stdout_r (ptr));
#ifdef _HAVE_STDC
va_start (ap, fmt);
#else /* _HAVE_STDC */
va_start (ap);
#endif /* _HAVE_STDC */
ret = _vfprintf_r (ptr, _stdout_r (ptr), fmt, ap);
va_end (ap);
return ret;
}
#endif /* _SMALL_PRINTF */
/*--------------------------------------------------------------------------*/
#ifndef _REENT_ONLY
#ifdef _HAVE_STDC
int
printf (const char *fmt, ...)
#else /* _HAVE_STDC */
int
printf (fmt, va_alist)
char *fmt;
va_dcl
#endif /* _HAVE_STDC */
{
int ret;
va_list ap;
//_REENT_SMALL_CHECK_INIT(_stdout_r (_REENT));
#ifdef _HAVE_STDC
va_start (ap, fmt);
#else /* _HAVE_STDC */
va_start (ap);
#endif /* _HAVE_STDC */
#ifndef _SMALL_PRINTF
ret = vfprintf (_stdout_r (_REENT), fmt, ap);
#else /* _SMALL_PRINTF */
ret = vfprintf (0, fmt, ap);
#endif /* _SMALL_PRINTF */
va_end (ap);
return ret;
}
#endif /* _REENT_ONLY */
/** @} */

39
cpu/stm32w108/small-printf/sp-puts.c Normal file
View file

@ -0,0 +1,39 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
#include <stdio.h>
#include <string.h>
void __io_putchar (char);
/*--------------------------------------------------------------------------*/
void
_SMALL_PRINTF_puts(const char *ptr, int len, FILE *fp)
{
/* No file => sprintf */
if (fp && (fp->_file == -1) && (fp->_flags & (__SWR | __SSTR))) {
char *str = fp->_p;
for (; len ; len--) {
*str ++ = *ptr++;
}
fp->_p = str;
} else {
/* file => printf */
for (; len ; len--) {
__io_putchar (*ptr++);
}
}
}
/*--------------------------------------------------------------------------*/
int
puts(const char *str)
{
int len = strlen (str);
_SMALL_PRINTF_puts(str, len, 0) ;
__io_putchar ('\n');
return len;
}
/** @} */

13
cpu/stm32w108/small_printf/_SP_snprintf.c → cpu/stm32w108/small-printf/sp-snprintf.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
@ -14,8 +20,9 @@
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
/* doc in _SP_sprintf.c */
/* This code created by modifying _SP_sprintf.c so copyright inherited. */
/* doc in sp-sprintf.c */
/* This code created by modifying sp-sprintf.c so copyright inherited. */
#include <stdio.h>
#ifdef _HAVE_STDC
@ -121,4 +128,4 @@ snprintf (str, size, fmt, va_alist)
}
#endif
/** @} */

8
cpu/stm32w108/small_printf/_SP_sprintf.c → cpu/stm32w108/small-printf/sp-sprintf.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
* Copyright (c) 1990 The Regents of the University of California.
* All rights reserved.
@ -386,4 +392,4 @@ sprintf (str, fmt, va_alist)
}
#endif
/** @} */

14
cpu/stm32w108/small_printf/_SP_vfprintf.c → cpu/stm32w108/small-printf/sp-vfprintf.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/*
FUNCTION
<<vprintf>>, <<vfprintf>>, <<vsprintf>>---format argument list
@ -1765,10 +1771,14 @@ get_arg (struct _reent *data, int n, char *fmt, va_list *ap,
}
}
/* alter the global numargs value and keep a reference to the last bit of the fmt
string we processed here because the caller will continue processing where we started */
/*
* alter the global numargs value and keep a reference to the last bit of the
* fmt string we processed here because the caller will continue processing
* where we started
*/
*numargs_p = numargs;
*last_fmt = fmt;
return &args[n];
}
#endif /* !_NO_POS_ARGS */
/** @} */

39
cpu/stm32w108/small_printf/vfieeefp.h → cpu/stm32w108/small-printf/vfieeefp.h
View file

@ -1,3 +1,9 @@
/**
* \addtogroup stm32w-cpu
*
* @{
*/
/****************************************************************
*
* The author of this software is David M. Gay.
@ -26,8 +32,13 @@
dmg@research.att.com or research!dmg
*/
/* This header file is a modification of mprec.h that only contains floating
point union code. */
#ifndef __VFIEEEFP_H__
#define __VFIEEEFP_H__
/*
* This header file is a modification of mprec.h that only contains floating
* point union code.
*/
#include <ieeefp.h>
#include <math.h>
@ -58,11 +69,12 @@ Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
#endif
#ifdef WANT_IO_LONG_DBL
/* If we are going to examine or modify specific bits in a long double using
the lword0 or lwordx macros, then we must wrap the long double inside
a union. This is necessary to avoid undefined behavior according to
the ANSI C spec. */
/*
* If we are going to examine or modify specific bits in a long double using
* the lword0 or lwordx macros, then we must wrap the long double inside
* a union. This is necessary to avoid undefined behavior according to
* the ANSI C spec.
*/
#ifdef IEEE_8087
#if LDBL_MANT_DIG == 24
struct ldieee
@ -136,10 +148,12 @@ struct ldieee
#endif /* !IEEE_8087 */
#endif /* WANT_IO_LONG_DBL */
/* If we are going to examine or modify specific bits in a double using
the word0 and/or word1 macros, then we must wrap the double inside
a union. This is necessary to avoid undefined behavior according to
the ANSI C spec. */
/*
* If we are going to examine or modify specific bits in a double using
* the word0 and/or word1 macros, then we must wrap the double inside
* a union. This is necessary to avoid undefined behavior according to
* the ANSI C spec.
*/
union double_union
{
double d;
@ -281,4 +295,5 @@ union double_union
#endif
#endif
#endif /* __VFIEEEFP_H__ */
/** @} */

78
cpu/stm32w108/small_printf/_SP_printf.c
View file

@ -1,78 +0,0 @@
#ifdef INTEGER_ONLY
#define _vfprintf_r _vfiprintf_r
#define _vfprintf _vfiprintf
#define vfprintf vfiprintf
#endif
#include <_ansi.h>
#include <stdio.h>
#ifndef _SMALL_PRINTF
#include "local.h"
#endif
#ifdef _HAVE_STDC
#include <stdarg.h>
#else
#include <varargs.h>
#endif
#ifndef _SMALL_PRINTF
#ifdef _HAVE_STDC
int
_printf_r (struct _reent *ptr, const char *fmt, ...)
#else
int
_printf_r (ptr, fmt, va_alist)
struct _reent *ptr;
char *fmt;
va_dcl
#endif
{
int ret;
va_list ap;
//_REENT_SMALL_CHECK_INIT(_stdout_r (ptr));
#ifdef _HAVE_STDC
va_start (ap, fmt);
#else
va_start (ap);
#endif
ret = _vfprintf_r (ptr, _stdout_r (ptr), fmt, ap);
va_end (ap);
return ret;
}
#endif
#ifndef _REENT_ONLY
#ifdef _HAVE_STDC
int
printf (const char *fmt, ...)
#else
int
printf (fmt, va_alist)
char *fmt;
va_dcl
#endif
{
int ret;
va_list ap;
//_REENT_SMALL_CHECK_INIT(_stdout_r (_REENT));
#ifdef _HAVE_STDC
va_start (ap, fmt);
#else
va_start (ap);
#endif
#ifndef _SMALL_PRINTF
ret = vfprintf (_stdout_r (_REENT), fmt, ap);
#else
ret = vfprintf (0, fmt, ap);
#endif
va_end (ap);
return ret;
}
#endif /* ! _REENT_ONLY */

34
cpu/stm32w108/small_printf/_SP_puts.c
View file

@ -1,34 +0,0 @@
#include <stdio.h>
#include <string.h>
void __io_putchar ( char );
void _SMALL_PRINTF_puts(const char *ptr, int len, FILE *fp)
{
if ( fp && ( fp->_file == -1 ) /* No file => sprintf */
&& (fp->_flags & (__SWR | __SSTR) ) )
{
char *str = fp->_p;
for ( ; len ; len-- )
{
*str ++ = *ptr++;
}
fp->_p = str;
}
else /* file => printf */
{
for ( ; len ; len-- )
__io_putchar ( *ptr++ );
}
}
int puts(const char *str)
{
int len = strlen ( str );
_SMALL_PRINTF_puts(str, len, 0) ;
__io_putchar ( '\n' );
return len;
}

32
cpu/stm32w108/uip_arch.c → cpu/stm32w108/uip-arch.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,40 +33,34 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the uIP TCP/IP stack.
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* uip_arch.c
* uip-arch.c
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include "net/uip.h"
#include "net/uip_arch.h"
/*-----------------------------------------------------------------------------------*/
#if UIP_TCP
void
uip_add32(uint8_t *op32, uint16_t op16)
uip_add32(uint8_t * op32, uint16_t op16)
{
uint32_t op32_align, uip_acc32_align;
op32_align = ((uint32_t)op32[0])<<24 | ((uint32_t)op32[1])<<16 | ((uint16_t)op32[2])<<8 | op32[3];
op32_align =
((uint32_t) op32[0]) << 24 | ((uint32_t) op32[1]) << 16 |
((uint16_t) op32[2]) << 8 | op32[3];
uip_acc32_align = op32_align + op16;
uip_acc32[3] = uip_acc32_align;
uip_acc32[2] = uip_acc32_align>>8;
uip_acc32[1] = uip_acc32_align>>16;
uip_acc32[0] = uip_acc32_align>>24;
uip_acc32[2] = uip_acc32_align >> 8;
uip_acc32[1] = uip_acc32_align >> 16;
uip_acc32[0] = uip_acc32_align >> 24;
}
#endif
/*-----------------------------------------------------------------------------------*/
/** @} */

24
cpu/stm32w108/watchdog.c
View file

@ -1,3 +1,9 @@
/**
* \addtogroup mb851-platform
*
* @{
*/
/*
* Copyright (c) 2010, STMicroelectronics.
* All rights reserved.
@ -27,27 +33,21 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* This file is part of the Contiki OS
*
*/
/*---------------------------------------------------------------------------*/
/**
* \file
* Watchdog
* \author
* Salvatore Pitrulli <salvopitru@users.sourceforge.net>
*/
/*---------------------------------------------------------------------------*/
#include <stdio.h>
#include "dev/watchdog.h"
#include PLATFORM_HEADER
#include "hal/error.h"
#include "hal/hal.h"
/*---------------------------------------------------------------------------*/
void
watchdog_init(void)
@ -58,16 +58,17 @@ watchdog_init(void)
void
watchdog_start(void)
{
/* We setup the watchdog to reset the device after 2.048 seconds,
unless watchdog_periodic() is called. */
/*
* We setup the watchdog to reset the device after 2.048 seconds,
* unless watchdog_periodic() is called.
*/
halInternalEnableWatchDog();
}
/*---------------------------------------------------------------------------*/
void
watchdog_periodic(void)
{
/* This function is called periodically to restart the watchdog
timer. */
/* This function is called periodically to restart the watchdog timer. */
halResetWatchdog();
}
/*---------------------------------------------------------------------------*/
@ -83,3 +84,4 @@ watchdog_reboot(void)
halReboot();
}
/*---------------------------------------------------------------------------*/
/** @} */

3
platform/mb851/Makefile.mb851
View file

@ -1,6 +1,3 @@
# $Id: Makefile.mb851,v 1.2 2010/12/15 11:18:09 salvopitru Exp $
ARCH= irq.c sensors.c acc-sensor.c button-sensor.c temperature-sensor.c mems.c
CONTIKI_TARGET_DIRS = . dev

Some files were not shown because too many files have changed in this diff Show more