Mirrors_Framework/stmbl
1
0
Fork 0
mirror of https://github.com/rene-dev/stmbl.git synced 2026-02-05 18:01:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'bootloader'

Browse Source 
* bootloader:
  boot loader checks crc
  cry script, 16 and 32 bit cry
  moved shared stuff to shared, sections in linker script
  linker script
  f1 firmware in f4
  f1 sv2 output
  step/dir idea from stackoverflow
  f1 operate adc in spec
  f1 interrupt priority
This commit is contained in:
Rene Hopf
2015-12-03 11:34:38 +01:00
parent 9d048cc07c 4f320baec8
commit 87e78ae8c6
23 changed files with 607 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -19,6 +19,7 @@ term/win32/bin
*.list
*.out
*.pyc
tools/pycrc*
sim/sim
sim/plot
@@ -31,6 +32,7 @@ stmblx
*.s#?
*.b#?
*.l#?
*.lck
# Eagle project file
# It contains a serial number and references to the file structure

19
Makefile
View File

@@ -4,7 +4,7 @@
#ld gcollection
#komische flags
SRCS = main.c stm32f4xx_it.c system_stm32f4xx.c printf.c scanf.c setup.c hal.c misc.c eeprom.c link.c crc.c stm32f103/src/common.c version.c syscalls.c
SRCS = main.c stm32f4xx_it.c system_stm32f4xx.c printf.c scanf.c setup.c hal.c misc.c eeprom.c link.c version.c syscalls.c shared/crc8.c shared/crc32.c shared/common.c
#USB
SRCS += ub_lib/stm32_ub_usb_cdc.c ub_lib/usb_cdc_lolevel/usb_core.c ub_lib/usb_cdc_lolevel/usb_dcd_int.c ub_lib/usb_cdc_lolevel/usbd_req.c ub_lib/usb_cdc_lolevel/usbd_cdc_core.c ub_lib/usb_cdc_lolevel/usbd_core.c ub_lib/usb_cdc_lolevel/usb_dcd.c ub_lib/usb_cdc_lolevel/usbd_cdc_vcp.c ub_lib/usb_cdc_lolevel/usbd_desc.c ub_lib/usb_cdc_lolevel/usbd_ioreq.c ub_lib/usb_cdc_lolevel/usb_bsp.c ub_lib/usb_cdc_lolevel/usbd_usr.c
#SRCS = main.c system.c
@@ -40,7 +40,7 @@ vpath %.a lib
ROOT=$(shell pwd)
CFLAGS += -Iinc -Ilib -Ilib/inc -Istm32f103/inc
CFLAGS += -Iinc -Ilib -Ilib/inc -Ishared
CFLAGS += -Ilib/inc/core -Ilib/inc/peripherals
SRCS += lib/startup_stm32f4xx.s # add startup file to build
@@ -74,14 +74,19 @@ lib:
$(MAKE) -C lib
proj: $(PROJ_NAME).elf
hv_firmware.o: stm32f103/main.bin
arm-none-eabi-objcopy --rename-section .data=.hv_firmware -I binary stm32f103/main.bin -B arm -O elf32-littlearm hv_firmware.o
stm32f103/main.bin:
make -C stm32f103/ all
$(PROJ_NAME).elf: $(SRCS)
$(PROJ_NAME).elf: $(SRCS) hv_firmware.o
$(CC) $(CFLAGS) $^ -o $@ -Llib -lstm32f4 -Wl,--gc-sections -Wl,-Map -Wl,$(PROJ_NAME).map
tools/add_version_info.py main.elf
$(OBJCOPY) -O ihex $(PROJ_NAME).elf $(PROJ_NAME).hex
$(OBJCOPY) -O binary $(PROJ_NAME).elf $(PROJ_NAME).bin
arm-none-eabi-size main.elf
tools/add_version_info.py $(PROJ_NAME).elf
$(OBJCOPY) -O binary --gap-fill 0xFF $(PROJ_NAME).elf $(PROJ_NAME).bin
tools/checkcrc.py $(PROJ_NAME).bin
arm-none-eabi-size $(PROJ_NAME).elf
clean:
rm -f *.o *.i

10
bootloader/Makefile
View File

@@ -4,7 +4,7 @@
#ld gcollection
#komische flags
SRCS = main.c stm32f4xx_it.c system_stm32f4xx.c version.c
SRCS = main.c stm32f4xx_it.c system_stm32f4xx.c version.c ../shared/crc32.c
# all the files will be generated with this name (main.elf, main.bin, main.hex, etc)
@@ -27,7 +27,7 @@ CFLAGS += -mlittle-endian -mthumb -mcpu=cortex-m4 -mthumb-interwork -nostartfile
CFLAGS += -mfloat-abi=hard -mfpu=fpv4-sp-d16 -nostartfiles -fsingle-precision-constant
CFLAGS += -ffunction-sections -fdata-sections -O1
CFLAGS += -I../lib/inc/core -I../lib/inc/peripherals
CFLAGS += -I../lib/inc/core -I../lib/inc/peripherals -I../shared
###################################################
@@ -74,9 +74,9 @@ proj: $(PROJ_NAME).elf
$(PROJ_NAME).elf: $(SRCS)
$(CC) $(CFLAGS) $^ -o $@ -L../lib -lstm32f4 -Wl,--gc-sections -Wl,-Map -Wl,$(PROJ_NAME).map
../tools/add_version_info.py main.elf
$(OBJCOPY) -O ihex $(PROJ_NAME).elf $(PROJ_NAME).hex
$(OBJCOPY) -O binary $(PROJ_NAME).elf $(PROJ_NAME).bin
../tools/add_version_info.py $(PROJ_NAME).elf
$(OBJCOPY) -O binary --gap-fill 0xFF $(PROJ_NAME).elf $(PROJ_NAME).bin
../tools/checkcrc.py $(PROJ_NAME).bin
arm-none-eabi-size main.elf
clean:

24
bootloader/src/main.c
View File

@@ -20,12 +20,30 @@
#include "stm32f4xx_conf.h"
#include "version.h"
#include "crc32.h"
#define APP_START 0x08010000
#define APP_END 0x08100000
#define APP_RANGE_VALID(a, s) (!(((a) | (s)) & 3) && (a) >= APP_START && ((a) + (s)) <= APP_END)
#define VERSION_INFO_OFFSET 0x188
static volatile const struct version_info *app_info = (void*)(APP_START + VERSION_INFO_OFFSET);
int app_ok(){
if (!APP_RANGE_VALID(APP_START, app_info->image_size)) {
return 0;
}
uint32_t crc = crc32_init();
crc = crc32_update(crc, (void*)APP_START, app_info->image_size);
crc = crc32_finalize(crc);
if (crc != 0) {
return 0;
}
return 1;
}
int main(void){
GPIO_InitTypeDef GPIO_InitDef;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
@@ -35,15 +53,13 @@ int main(void){
GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitDef.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &GPIO_InitDef);
uint32_t pin = !GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_13);
GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &GPIO_InitDef);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, DISABLE);
void (*SysMemBootJump)(void);
if ( (*((unsigned long *)0x2001C000) == 0xDEADBEEF) || pin) {//Memory map, datasheet
if ( (*((unsigned long *)0x2001C000) == 0xDEADBEEF) || pin || !app_ok()) {//Memory map, datasheet
*((unsigned long *)0x2001C000) = 0xCAFEFEED; //Reset bootloader trigger
__set_MSP(0x20001000);
//Point the PC to the System Memory reset vector (+4)

0
stm32f103/src/common.c → shared/common.c
View File

0
stm32f103/inc/common.h → shared/common.h
View File

12
shared/crc.sh Executable file
View File

@@ -0,0 +1,12 @@
#!/bin/bash
CRC="python ../Tools/pycrc-0.8.3/pycrc.py"
rm -rf crc8.h crc8.c crc16.h crc16.c crc32.h crc32.c
#1wire crc, for smartserial and hv packets
$CRC --model dallas-1-wire --algorithm table-driven --table-idx-width 8 --symbol-prefix crc8_ --generate c -o crc8.c
$CRC --model dallas-1-wire --algorithm table-driven --table-idx-width 8 --symbol-prefix crc8_ --generate h -o crc8.h
#16bit crc, for config in flash
$CRC --model crc-16 --algorithm table-driven --table-idx-width 8 --symbol-prefix crc16_ --generate c -o crc16.c
$CRC --model crc-16 --algorithm table-driven --table-idx-width 8 --symbol-prefix crc16_ --generate h -o crc16.h
#32bit crc for firmware
$CRC --model crc-32 --algorithm table-driven --table-idx-width 8 --symbol-prefix crc32_ --generate c -o crc32.c
$CRC --model crc-32 --algorithm table-driven --table-idx-width 8 --symbol-prefix crc32_ --generate h -o crc32.h

101
shared/crc16.c Normal file
View File

@@ -0,0 +1,101 @@
/**
* \file crc16.c
* Functions and types for CRC checks.
*
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 16
* Poly = 0x8005
* XorIn = 0x0000
* ReflectIn = True
* XorOut = 0x0000
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#include "crc16.h" /* include the header file generated with pycrc */
#include <stdlib.h>
#include <stdint.h>
/**
* Static table used for the table_driven implementation.
*****************************************************************************/
static const crc16_t crc_table[256] = {
0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40,
0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841,
0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41,
0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641,
0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040,
0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240,
0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441,
0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41,
0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840,
0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41,
0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40,
0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640,
0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041,
0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240,
0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441,
0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41,
0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840,
0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41,
0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40,
0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640,
0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041,
0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241,
0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440,
0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40,
0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841,
0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40,
0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
};
/**
* Reflect all bits of a \a data word of \a data_len bytes.
*
* \param data The data word to be reflected.
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc16_t crc16_reflect(crc16_t data, size_t data_len)
{
unsigned int i;
crc16_t ret;
ret = data & 0x01;
for (i = 1; i < data_len; i++) {
data >>= 1;
ret = (ret << 1) | (data & 0x01);
}
return ret;
}
/**
* Update the crc value with new data.
*
* \param crc The current crc value.
* \param data Pointer to a buffer of \a data_len bytes.
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc16_t crc16_update(crc16_t crc, const void *data, size_t data_len)
{
const unsigned char *d = (const unsigned char *)data;
unsigned int tbl_idx;
while (data_len--) {
tbl_idx = (crc ^ *d) & 0xff;
crc = (crc_table[tbl_idx] ^ (crc >> 8)) & 0xffff;
d++;
}
return crc & 0xffff;
}

92
shared/crc16.h Normal file
View File

@@ -0,0 +1,92 @@
/**
* \file crc16.h
* Functions and types for CRC checks.
*
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 16
* Poly = 0x8005
* XorIn = 0x0000
* ReflectIn = True
* XorOut = 0x0000
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#ifndef __CRC16_H__
#define __CRC16_H__
#include <stdlib.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* The definition of the used algorithm.
*
* This is not used anywhere in the generated code, but it may be used by the
* application code to call algoritm-specific code, is desired.
*****************************************************************************/
#define CRC_ALGO_TABLE_DRIVEN 1
/**
* The type of the CRC values.
*
* This type must be big enough to contain at least 16 bits.
*****************************************************************************/
typedef uint_fast16_t crc16_t;
/**
* Reflect all bits of a \a data word of \a data_len bytes.
*
* \param data The data word to be reflected.
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc16_t crc16_reflect(crc16_t data, size_t data_len);
/**
* Calculate the initial crc value.
*
* \return The initial crc value.
*****************************************************************************/
static inline crc16_t crc16_init(void)
{
return 0x0000;
}
/**
* Update the crc value with new data.
*
* \param crc The current crc value.
* \param data Pointer to a buffer of \a data_len bytes.
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc16_t crc16_update(crc16_t crc, const void *data, size_t data_len);
/**
* Calculate the final crc value.
*
* \param crc The current crc value.
* \return The final crc value.
*****************************************************************************/
static inline crc16_t crc16_finalize(crc16_t crc)
{
return crc ^ 0x0000;
}
#ifdef __cplusplus
} /* closing brace for extern "C" */
#endif
#endif /* __CRC16_H__ */

133
shared/crc32.c Normal file
View File

@@ -0,0 +1,133 @@
/**
* \file crc32.c
* Functions and types for CRC checks.
*
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 32
* Poly = 0x04c11db7
* XorIn = 0xffffffff
* ReflectIn = True
* XorOut = 0xffffffff
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#include "crc32.h" /* include the header file generated with pycrc */
#include <stdlib.h>
#include <stdint.h>
/**
* Static table used for the table_driven implementation.
*****************************************************************************/
static const crc32_t crc_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
/**
* Reflect all bits of a \a data word of \a data_len bytes.
*
* \param data The data word to be reflected.
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc32_t crc32_reflect(crc32_t data, size_t data_len)
{
unsigned int i;
crc32_t ret;
ret = data & 0x01;
for (i = 1; i < data_len; i++) {
data >>= 1;
ret = (ret << 1) | (data & 0x01);
}
return ret;
}
/**
* Update the crc value with new data.
*
* \param crc The current crc value.
* \param data Pointer to a buffer of \a data_len bytes.
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc32_t crc32_update(crc32_t crc, const void *data, size_t data_len)
{
const unsigned char *d = (const unsigned char *)data;
unsigned int tbl_idx;
while (data_len--) {
tbl_idx = (crc ^ *d) & 0xff;
crc = (crc_table[tbl_idx] ^ (crc >> 8)) & 0xffffffff;
d++;
}
return crc & 0xffffffff;
}

92
shared/crc32.h Normal file
View File

@@ -0,0 +1,92 @@
/**
* \file crc32.h
* Functions and types for CRC checks.
*
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 32
* Poly = 0x04c11db7
* XorIn = 0xffffffff
* ReflectIn = True
* XorOut = 0xffffffff
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#ifndef __CRC32_H__
#define __CRC32_H__
#include <stdlib.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* The definition of the used algorithm.
*
* This is not used anywhere in the generated code, but it may be used by the
* application code to call algoritm-specific code, is desired.
*****************************************************************************/
#define CRC_ALGO_TABLE_DRIVEN 1
/**
* The type of the CRC values.
*
* This type must be big enough to contain at least 32 bits.
*****************************************************************************/
typedef uint_fast32_t crc32_t;
/**
* Reflect all bits of a \a data word of \a data_len bytes.
*
* \param data The data word to be reflected.
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc32_t crc32_reflect(crc32_t data, size_t data_len);
/**
* Calculate the initial crc value.
*
* \return The initial crc value.
*****************************************************************************/
static inline crc32_t crc32_init(void)
{
return 0xffffffff;
}
/**
* Update the crc value with new data.
*
* \param crc The current crc value.
* \param data Pointer to a buffer of \a data_len bytes.
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc32_t crc32_update(crc32_t crc, const void *data, size_t data_len);
/**
* Calculate the final crc value.
*
* \param crc The current crc value.
* \return The final crc value.
*****************************************************************************/
static inline crc32_t crc32_finalize(crc32_t crc)
{
return crc ^ 0xffffffff;
}
#ifdef __cplusplus
} /* closing brace for extern "C" */
#endif
#endif /* __CRC32_H__ */

16
src/crc.c → shared/crc8.c
View File

@@ -1,8 +1,8 @@
/**
* \file crc.c
* \file crc8.c
* Functions and types for CRC checks.
*
* Generated on Mon Nov 9 07:24:01 2015,
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 8
@@ -13,14 +13,14 @@
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#include "crc.h" /* include the header file generated with pycrc */
//#include <stdlib.h>
#include "crc8.h" /* include the header file generated with pycrc */
#include <stdlib.h>
#include <stdint.h>
/**
* Static table used for the table_driven implementation.
*****************************************************************************/
static const crc_t crc_table[256] = {
static const crc8_t crc_table[256] = {
0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc,
0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62,
@@ -46,10 +46,10 @@ static const crc_t crc_table[256] = {
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc_t crc_reflect(crc_t data, uint8_t data_len)
crc8_t crc8_reflect(crc8_t data, size_t data_len)
{
unsigned int i;
crc_t ret;
crc8_t ret;
ret = data & 0x01;
for (i = 1; i < data_len; i++) {
@@ -68,7 +68,7 @@ crc_t crc_reflect(crc_t data, uint8_t data_len)
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc_t crc_update(crc_t crc, const void *data, uint8_t data_len)
crc8_t crc8_update(crc8_t crc, const void *data, size_t data_len)
{
const unsigned char *d = (const unsigned char *)data;
unsigned int tbl_idx;

22
src/crc.h → shared/crc8.h
View File

@@ -1,8 +1,8 @@
/**
* \file crc.h
* \file crc8.h
* Functions and types for CRC checks.
*
* Generated on Mon Nov 9 07:24:11 2015,
* Generated on Wed Dec 2 02:28:13 2015,
* by pycrc v0.8.3, https://pycrc.org
* using the configuration:
* Width = 8
@@ -13,10 +13,10 @@
* ReflectOut = True
* Algorithm = table-driven
*****************************************************************************/
#ifndef __CRC_H__
#define __CRC_H__
#ifndef __CRC8_H__
#define __CRC8_H__
//#include <stdlib.h>
#include <stdlib.h>
#include <stdint.h>
#ifdef __cplusplus
@@ -38,7 +38,7 @@ extern "C" {
*
* This type must be big enough to contain at least 8 bits.
*****************************************************************************/
typedef uint_fast8_t crc_t;
typedef uint_fast8_t crc8_t;
/**
@@ -48,7 +48,7 @@ typedef uint_fast8_t crc_t;
* \param data_len The width of \a data expressed in number of bits.
* \return The reflected data.
*****************************************************************************/
crc_t crc_reflect(crc_t data, uint8_t data_len);
crc8_t crc8_reflect(crc8_t data, size_t data_len);
/**
@@ -56,7 +56,7 @@ crc_t crc_reflect(crc_t data, uint8_t data_len);
*
* \return The initial crc value.
*****************************************************************************/
static inline crc_t crc_init(void)
static inline crc8_t crc8_init(void)
{
return 0x00;
}
@@ -70,7 +70,7 @@ static inline crc_t crc_init(void)
* \param data_len Number of bytes in the \a data buffer.
* \return The updated crc value.
*****************************************************************************/
crc_t crc_update(crc_t crc, const void *data, uint8_t data_len);
crc8_t crc8_update(crc8_t crc, const void *data, size_t data_len);
/**
@@ -79,7 +79,7 @@ crc_t crc_update(crc_t crc, const void *data, uint8_t data_len);
* \param crc The current crc value.
* \return The final crc value.
*****************************************************************************/
static inline crc_t crc_finalize(crc_t crc)
static inline crc8_t crc8_finalize(crc8_t crc)
{
return crc ^ 0x00;
}
@@ -89,4 +89,4 @@ static inline crc_t crc_finalize(crc_t crc)
} /* closing brace for extern "C" */
#endif
#endif /* __CRC_H__ */
#endif /* __CRC8_H__ */

57
src/comps/enc_cmd.comp
View File

@@ -79,3 +79,60 @@ RT(
);
ENDCOMP;
//http://stackoverflow.com/questions/32947972/stm32-how-to-make-pulse-count-up-down-with-timer
// #include "mbed.h"
// #include "stm32f4xx.h"
// #include "stm32f4xx_hal_tim_ex.h"
//
// TIM_HandleTypeDef timer;
// TIM_Encoder_InitTypeDef encoder;
//
// //direction to PA_9 -- step to PA_8
//
// int main(){
// GPIO_InitTypeDef GPIO_InitStruct;
// __TIM1_CLK_ENABLE();
// __GPIOA_CLK_ENABLE();
// GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9;
// GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
// GPIO_InitStruct.Pull = GPIO_PULLDOWN;
// GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
// GPIO_InitStruct.Alternate = GPIO_AF1_TIM1;
// HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
//
// timer.Instance = TIM1;
// timer.Init.Period = 0xffff;
// timer.Init.Prescaler = 1;
// timer.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
// timer.Init.CounterMode = TIM_COUNTERMODE_UP;
//
//
// encoder.EncoderMode = TIM_ENCODERMODE_TI1;
// encoder.IC1Filter = 0x0f;
// encoder.IC1Polarity = TIM_INPUTCHANNELPOLARITY_RISING; //step signal
// encoder.IC1Prescaler = TIM_ICPSC_DIV1;
// encoder.IC1Selection = TIM_ICSELECTION_DIRECTTI;
//
// encoder.IC2Filter = 0x0f;
// encoder.IC2Polarity = TIM_INPUTCHANNELPOLARITY_BOTHEDGE; //check direction
// encoder.IC2Prescaler = TIM_ICPSC_DIV1;
// encoder.IC2Selection = TIM_ICSELECTION_INDIRECTTI;
//
// HAL_TIM_Encoder_Init(&timer, &encoder);
// HAL_TIM_Encoder_Start(&timer,TIM_CHANNEL_1);
//
//
// TIM1->EGR = 1; // Generate an update event
// TIM1->CR1 = 1; // Enable the counter
//
//
// while (1) {
// int16_t count1;
// count1=TIM1->CNT;
//
// printf("%d\r\n", count1);
// wait(1.0);
//
// };
// }

12
src/comps/sserial.comp
View File

@@ -416,18 +416,18 @@ RT_INIT(
);
uint8_t crc_reuest(uint8_t len) {
uint8_t crc = crc_init();
uint8_t crc = crc8_init();
for(int i = rxpos; i < rxpos+len; i++){
crc = crc_update(crc, (void*)&(rxbuf[i%sizeof(rxbuf)]), 1);
crc = crc8_update(crc, (void*)&(rxbuf[i%sizeof(rxbuf)]), 1);
}
crc_finalize(crc);
crc8_finalize(crc);
return crc == rxbuf[(rxpos+len)%sizeof(rxbuf)];
}
uint8_t crc8( uint8_t *addr, uint8_t len) {
uint8_t crc = crc_init();
crc = crc_update(crc, addr, len);
return crc_finalize(crc);
uint8_t crc = crc8_init();
crc = crc8_update(crc, addr, len);
return crc8_finalize(crc);
}
void send(uint8_t len, uint8_t docrc){

11
src/comps/term.comp
View File

@@ -300,6 +300,15 @@ NRT(
printf_("newlib %s\n",_NEWLIB_VERSION);
printf_("CMSIS %i.%i\n",__CM4_CMSIS_VERSION_MAIN,__CM4_CMSIS_VERSION_SUB);
printf_("StdPeriph %i.%i.%i\n",__STM32F4XX_STDPERIPH_VERSION_MAIN,__STM32F4XX_STDPERIPH_VERSION_SUB1,__STM32F4XX_STDPERIPH_VERSION_SUB2);
uint32_t crc = crc32_init();
crc = crc32_update(crc, (void*)0x08010000, version_info.image_size);
crc = crc32_finalize(crc);
printf_("size: %u crc:%x\n",version_info.image_size,version_info.image_crc);
if(crc == 0)
printf_("crc ok!\n");
else
printf_("crc error!:%x\n",crc);
printf_("######## Bootloader info ########\n");
printf_(
"%s v%i.%i.%i %s\n",
@@ -312,6 +321,8 @@ NRT(
printf_("Branch %s\n",bt_version_info->git_branch);
printf_("Compiled %s %s ",bt_version_info->build_date, bt_version_info->build_time);
printf_("by %s on %s\n",bt_version_info->build_user, bt_version_info->build_host);
printf_("start:%p ,size:%p ,end%p \n",&_binary_stm32f103_main_bin_start,&_binary_stm32f103_main_bin_size,&_binary_stm32f103_main_bin_end);
}
void start(){

7
src/main.c
View File

@@ -25,7 +25,8 @@
#include "setup.h"
#include "eeprom.h"
#include "link.h"
#include "crc.h"
#include "crc8.h"
#include "crc32.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
@@ -55,6 +56,10 @@ void disable_frt(){
TIM_ITConfig(TIM2, TIM_IT_Update, DISABLE);
}
extern char _binary_stm32f103_main_bin_start;
extern char _binary_stm32f103_main_bin_size;
extern char _binary_stm32f103_main_bin_end;
//20kHz
void TIM2_IRQHandler(void){
TIM_ClearITPendingBit(TIM2,TIM_IT_Update);

2
src/setup.h
View File

@@ -13,7 +13,7 @@
#include "stm32f4xx_conf.h"
#include "misc.h"
#include "version.h"
#include "../../stm32f103/inc/common.h"
#include "common.h"
#include "defines_res.h"
#include "stm32_ub_usb_cdc.h"

12
stm32_flash.ld
View File

@@ -47,7 +47,10 @@ MEMORY
PARAM0 (rx) : ORIGIN = 0x08008000, LENGTH = 16K/* sector 2 */
PARAM1 (rx) : ORIGIN = 0x0800C000, LENGTH = 16K/* sector 3 */
FLASH (rx) : ORIGIN = 0x08010000, LENGTH = 960K/* sector 4-11 */
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 192K
CCM (xrw) : ORIGIN = 0x10000000, LENGTH = 64k
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 112K/*SRAM1*/
RAM2(xrw) : ORIGIN = 0x2001C000, LENGTH = 16K/*SRAM2*/
BKP(xrw) : ORIGIN = 0x40024000, LENGTH = 4K/*backup bkp sram*/
MEMORY_B1 (rx) : ORIGIN = 0x60000000, LENGTH = 0K
}
@@ -69,6 +72,13 @@ SECTIONS
KEEP(*(.version_info))
. = ALIGN(4);
} >FLASH
.hv_firmware :
{
. = ALIGN(4);
KEEP(*(.hv_firmware))
. = ALIGN(4);
} >FLASH
/* The program code and other data goes into FLASH */
.text :

5
stm32f103/Makefile
View File

@@ -38,7 +38,7 @@ GDB = $(SYSTEM)-gdb
SIZE = $(SYSTEM)-size
# INCLUDES = -I$(SRCDIR) $(LIBINC)
INCLUDES = $(LIBINC)
INCLUDES = $(LIBINC) -I../shared
CFLAGS = $(CPU) $(CMSIS_OPT) $(OTHER_OPT) -Wall -fno-common -fno-strict-aliasing -O2 $(INCLUDES) -g -Wfatal-errors -g -std=c99 -fdiagnostics-color=always
ASFLAGS = $(CFLAGS) -x assembler-with-cpp
LDFLAGS = -Wl,--gc-sections,-Map=$*.map,-cref -T $(LDSCRIPT) $(CPU)
@@ -55,7 +55,8 @@ OBJS = $(sort \
$(patsubst %.c,%.o,$(wildcard src/*.c)) \
$(patsubst %.s,%.o,$(wildcard src/*.s)) \
$(STARTUP_OBJ) \
$(SYSTEM_OBJ))
$(SYSTEM_OBJ) \
../shared/common.o)
all: $(BIN)

13
stm32f103/src/main.c
View File

@@ -153,6 +153,12 @@ void GPIO_Configuration(void)
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
#endif
//PA5,6,7 sv2
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void tim1_init(){
@@ -250,7 +256,7 @@ void usart_init(){
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//Enable USART RX not empty interrupt
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
@@ -260,7 +266,7 @@ void usart_init(){
// Setup ADC
void setup_adc(){
RCC_ADCCLKConfig(RCC_PCLK2_Div4);
RCC_ADCCLKConfig(RCC_PCLK2_Div6); // 12MHz
/* Enable DMA1 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
/* Enable ADC1 and GPIOC clock */
@@ -306,7 +312,7 @@ void setup_adc(){
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
@@ -456,6 +462,7 @@ void USART2_IRQHandler(){
int main(void)
{
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
RCC_Configuration();
GPIO_Configuration();

3
stm32f103/stm32_flash.ld
View File

@@ -38,7 +38,8 @@ _estack = 0x20002800; /* end of 4K RAM */
/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0; /* required amount of heap */
_Min_Stack_Size = 0x100; /* required amount of stack */
/* STM32F103R6T Low-density performance line 32kb flash 10kb ram */
/* flash layout: 32x1 */
/* Specify the memory areas */
MEMORY
{

12
tools/checkcrc.py Executable file
View File

@@ -0,0 +1,12 @@
#!/usr/bin/env python
import binascii
import sys
buf = open(sys.argv[1],'rb').read()
buf = (binascii.crc32(buf) & 0xFFFFFFFF)
if buf == 0:
print "crc ok!"
sys.exit(0)
else:
print "This should not happen. Please report a bug."
sys.exit(-1)