1 the GCC
1.1 built-in function
int __builtin_constant_p (exp)
built-in function __builtin_constant_p GCC for determining whether or not a compile-time constant value, if the value of exp is a constant parameter, the function returns a 0 otherwise.
Weak function
__attribute __ ((weak)) var_type function (var_type)
{
}
or:
extern var_type function (var_type) __attribute __ ((weak));
var_type function (var_type)
{
}
1.2 the FreeRTOS customize the GCC sectionTop
@ flash.ld
a SECTIONS
{
[ ...]
.text:
{
[...]
. the ALIGN = (. 4);
The PROVIDE; (= __core_initcall.)
the KEEP (* (core.initcall).)
The PROVIDE; (= __core_initcall_end.)
. = ALIGN(4);
PROVIDE (__module_initcall = .);
KEEP(*(.module.initcall))
PROVIDE (__module_initcall_end = .);
. = ALIGN(4);
PROVIDE (__late_initcall = .);
KEEP(*(.late.initcall))
PROVIDE (__late_initcall_end = .);
. = ALIGN(4);
PROVIDE (__atcmds_section = .);
KEEP(*(.oem_atcmds))
PROVIDE (__atcmds_section_end = .);
[…]
}
[…]
}
@cutils.h
typedef void (*initcall_t)(void);
extern initcall_t __core_initcall[];
extern initcall_t __core_initcall_end[];
extern initcall_t __module_initcall[];
extern initcall_t __module_initcall_end[];
extern initcall_t __late_initcall[];
extern initcall_t __late_initcall_end[];
#if 1
#define core_initcall(fn) \
static initcall_t __initcall_##fn \
__attribute__((used,section(".core.initcall"))) = fn
#define module_init(fn) \
static initcall_t __initcall_##fn \
__attribute__((used,section(".module.initcall"))) = fn
#define late_initcall(fn) \
static initcall_t __initcall_##fn \
__attribute__((used,section(".late.initcall"))) = fn
#else
#define core_initcall(fn) \
void fn(void) __attribute__((unused))
#define module_init(fn) \
void fn(void) __attribute__((unused))
#define late_initcall(fn) \
void fn(void) __attribute__((unused))
#endif
extern const atci_cmd_hdlr_item_t __atcmds_section[];
extern const atci_cmd_hdlr_item_t __atcmds_section_end[];
#if 1
#define DECLARE_AT_COMMAND(NAME, ROUTINE) \
static const char __atcmd_label_##NAME[] = "AT+"#NAME; \
static const atci_cmd_hdlr_item_t __atcmd_##NAME \
__attribute__((used,section(".oem_atcmds"))) = \
{ \
.command_head = __atcmd_label_##NAME, \
.command_hdlr = ROUTINE, \
}
#else
#define DECLARE_AT_COMMAND(NAME, ROUTINE) \
atci_status_t (ROUTINE)(atci_parse_cmd_param_t *parse_cmd) __attribute__((unused))
#endif
@main.c
static void section_core_init(void)
{
initcall_t *initcall;
for (initcall = __core_initcall;
initcall < __core_initcall_end;
initcall++) {
(*initcall)();
}
}
static void section_module_init(void)
{
initcall_t *initcall;
for (initcall = __module_initcall;
initcall < __module_initcall_end;
initcall++) {
(*initcall)();
}
}
static void section_late_init(void)
{
initcall_t *initcall;
for (initcall = __late_initcall;
initcall < __late_initcall_end;
initcall++) {
(*initcall)();
}
}
static bool atcmds_section_cb(atci_parse_cmd_param_ex_t *parse_cmd)
{
atci_cmd_hdlr_item_t *handler;
for (handler = __atcmds_section;
handler < __atcmds_section_end;
handler++) {
LOGE("command_head: %s; "
"parse_cmd->string_ptr: %s, parse_cmd->hash_value1: 0x%08x, "
"parse_cmd->hash_value2: 0x%08x\r\n",
handler->command_head,
parse_cmd->string_ptr, parse_cmd->hash_value1, parse_cmd->hash_value2);
if (!strncmp((char *)parse_cmd->string_ptr,
handler->command_head,
strlen(handler->command_head))) {
handler->command_hdlr((atci_parse_cmd_param_t*)parse_cmd);
return true;
}
}
return false;
}
2 IAR
2.URLs. 1
the IAR program acquires stack pointer and stack pointer
http://blog.csdn.net/sunheshan/article/details/48548103
3 MCU链表操作头文件-porting from Linux
@ utils.h
#if !defined(__UTILS_H)
#define __UTILS_H
#ifdef __cplusplus
extern "C" {
#endif
#include <ctype.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#ifndef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
struct list_head {
struct list_head *next, *prev;
};
#define LIST_HEAD(name) \
struct list_head name = { \
.next = &(name), \
.prev = &(name), \
}
#define LEGACY_LIST_HEAD(type, name) \
type name = { \
.next = &(name), \
.prev = &(name), \
}
#define list_empty(head) ((head) == (head)->next)
#define list_for_each(node, head) \
for (node = (head)->next; node != (head); node = node->next)
#define list_for_each_safe(node, n, head) \
for (node = (head)->next, n = node->next; \
node != (head); \
node = n, n = node->next)
#define list_init(head) do { \
(head)->next = (head); \
(head)->prev = (head); \
} while (0)
#define list_add_head(node, head) do { \
(node)->next = (head)->next; \
(node)->prev = (head); \
(head)->next->prev = (node); \
(head)->next = (node); \
} while (0)
#define list_add_tail(node, head) do { \
(node)->next = (head); \
(node)->prev = (head)->prev; \
(head)->prev->next = (node); \
(head)->prev = (node); \
} while (0)
#define list_del(node) do { \
(node)->next->prev = (node)->prev; \
(node)->prev->next = (node)->next; \
(node)->next = NULL; \
(node)->prev = NULL; \
} while (0)
#ifdef __cplusplus
}
#endif
#endif
4 AT Command Parser
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int int32;
static char *at_tok_next_int(char *str, int32 *tok)
{
char *p, *end;
if (!str || !tok) {
return NULL;
}
p = str;
while (*p != '\0' && *p != '\r' && *p != '\n' && isspace(*p)) p++;
if (*p == '\0') {
goto err;
}
if (strchr(p, ',')) {
end = strchr(p, ',');
*end = '\0';
end++;
} else {
end = p + strlen(p);
}
*tok = strtoul(p, NULL, 0);
return end;
err:
return NULL;
}
static char *at_tok_next_str(char *str, char *tok)
{
char *p, *end;
unsigned int i;
if (!str || !tok) {
return NULL; P = str;
}
while (*p != '\0' && *p != '\r' && *p != '\n' && isspace(*p)) p++;
if (*p == '\0') {
goto err;
}
if (strchr(p, ',')) {
end = strchr(p, ',');
*end = '\0';
end++;
} else {
end = p + strlen(p);
}
strcpy(tok, p);
for (i = strlen(tok); i >= 0; i--) {
if (isalpha(tok[i]) || isdigit(tok[i])) {
break;
} else if (isspace(tok[i]) || tok[i] == '\r' || tok[i] == '\n') {
tok[i] = '\0';
}
}
return end;
err:
return NULL;
}
int main(int argc, char **argv)
{
char at[] = {"AT+TEST=5,1,HELLO\r\n"};
int prx_len = strlen("AT+TEST=");
char *p = at + prx_len;
int v1;
int v2;
char v3[16];
p = at_tok_next_int(p, &v1);
if (p) {
p = at_tok_next_int(p, &v2);
}
if (p) {
p = at_tok_next_str(p, v3);
}
fprintf(stdout, "%d %d %s\n", v1, v2, v3);
return 0;
}
5 JSON
#define __api
#define ACTION_SZ 64
#define AUTH_SZ 32
#define UUID_SZ 32
#define PARAMS_SZ 256
#define MSG_SZ 64
#define STATUS_SZ 32
#define RESULT_SZ 256
typedef unsigned int u32;
typedef struct req_arg {
char action[ACTION_SZ];
char auth[AUTH_SZ];
char uuid[UUID_SZ];
char params[PARAMS_SZ];
} req_arg_t;
typedef struct rsp_arg {
char msg[MSG_SZ];
char uuid[UUID_SZ];
char status[STATUS_SZ];
char result[RESULT_SZ];
} rsp_arg_t;
void __api u_json_clr_qm(char *json)
{
int i;
for (i = 0; i < strlen(json); i++) {
if (json[i] == '\"') {
json[i] = ' ';
}
}
}
int __api u_json_get_value(const char *json, int json_len, const char *key,
char *value, int value_len)
{
char *p, *p2, *end;
unsigned int nleft = 0, nright = 0;
unsigned int i, len;
if (!json || !key || !value) {
goto err;
}
p = strstr(json, key);
if (!p) {
printf("Oops\n");
goto err;
}
p += strlen(key);
while (*p != '\0' && *p != ':') p++;
if (*p != ':') {
printf("err1, invalid json string: %s\n", json);
goto err;
}
p++;
while (*p != '\0' && isspace(*p)) p++;
//printf("DEBUG:%s-\n", p);
if (*p == '{') {
p++;
end = p;
while (*end != '\0' && *end != '}') end++;
if (*end != '}') {
printf("err2, invalid json string: %s\n", json);
goto err;
}
p2 = p;
// In 64bit machine, this will show a warning message,
// because of sizeof(char *) = 8, but sizeof(u32) = 4
//while ((u32)p2 != (u32)end) {
while ((u32)p2 < (u32)end) {
if (*p2 == '{') {
nleft++;
}
p2++;
}
if (nleft > 0) {
end++;
while (*end != '\0') {
if (*end == '}') {
nright++;
}
if (nleft == nright) {
break;
}
end++;
}
}
} else {
end = p;
while (*end != '\0' && *end != ',' && *end != '}') end++;
// TODO: Need check error?
}
len = (u32)(end - p);
value_len = len < (value_len - 1) ? len : (value_len - 1);
memcpy(value, p, value_len);
value[value_len] = '\0';
for (i = value_len; i >= 0; i--) {
if (isalpha(value[i]) || isdigit(value[i])) {
break;
} else if (isspace(value[i])) {
value[i] = '\0';
}
}
return 0;
err:
return -1;
}
6 Customized Print Function
#include <stdarg.h>
static int format_xxx_data(unsigned char *buf, unsigned int buf_len, const char *fmt,...)
{
va_list ap;
int n;
if (NULL == buf) {
return -1;
}
va_start(ap, fmt);
n = vsnprintf(buf, buf_len, fmt, ap);
va_end(ap);
return n;
}
7 ringbuf（num_of_msgs是2的N次方，siz_of_msg > 0）
typedef struct {
uint8_t *buf;
uint16_t num_of_msgs;
uint16_t siz_of_msg;
uint32_t write_seq;
uint32_t read_seq;
#define AVAIL_BIT 0x01
EventGroupHandle_t event_group;
SemaphoreHandle_t sem;
} ringbuf_t;
static bool ringbuf_popback(ringbuf_t *handle, void *msg)
{
uint32_t offset;
if (!handle || !msg) {
return false;
}
if (NULL != handle->sem) {
xSemaphoreTake(handle->sem, portMAX_DELAY);
}
if (handle->read_seq == handle->write_seq) {
goto out;
}
offset = (handle->read_seq & (handle->num_of_msgs - 1)) * handle->siz_of_msg;
memcpy(msg, &(handle->buf[offset]), handle->siz_of_msg);
handle->read_seq++;
if (NULL != handle->sem) {
xSemaphoreGive(handle->sem);
}
return true;
out:
if (NULL != handle->sem) {
xSemaphoreGive(handle->sem);
}
return false;
}
static void ringbuf_push(ringbuf_t *handle, void *msg)
{
uint32_t offset;
if (!handle || !msg) {
return;
}
if (NULL != handle->sem) {
xSemaphoreTake(handle->sem, portMAX_DELAY);
}
offset = (handle->write_seq & (handle->num_of_msgs - 1)) * handle->siz_of_msg;
memcpy(&(handle->buf[offset]), msg, handle->siz_of_msg);
handle->write_seq++;
if ((handle->write_seq - handle->read_seq) > handle->num_of_msgs) {
handle->read_seq = handle->write_seq - handle->num_of_msgs;
}
if (NULL != handle->sem) {
xSemaphoreGive(handle->sem);
}
xEventGroupSetBits(handle->event_group, AVAIL_BIT);
}
static bool ringbuf_empty(ringbuf_t *handle)
{
bool ret = false;
if (!handle) {
return true;
}
if (NULL != handle->sem) {
xSemaphoreTake(handle->sem, portMAX_DELAY);
}
if (handle->read_seq == handle->write_seq) {
ret = true;
}
if (NULL != handle->sem) {
xSemaphoreGive(handle->sem);
}
return ret;
}
static ringbuf_t *ringbuf_create(uint16_t num_of_msgs, uint16_t siz_of_msg)
{
ringbuf_t *rb;
rb = pvPortMalloc(sizeof(ringbuf_t));
if (!rb) {
goto out;
}
rb->num_of_msgs = num_of_msgs;
rb->siz_of_msg = siz_of_msg;
rb->buf = pvPortMalloc(num_of_msgs * siz_of_msg);
if (!rb->buf) {
goto free_rb;
}
rb->sem = xSemaphoreCreateBinary();
if(!rb->sem) {
goto free_buf;
}
xSemaphoreGive(rb->sem);
rb->event_group = xEventGroupCreate();
if (!rb->event_group) {
goto del_sem;
}
return rb;
del_sem:
vSemaphoreDelete(rb->sem);
rb->sem = NULL;
free_buf:
if (rb->buf) {
vPortFree(rb->buf);
rb->buf = NULL;
}
free_rb:
if (rb) {
vPortFree(rb);
rb = NULL;
}
out:
return NULL;
}
static void ringbuf_delete(ringbuf_t *handle)
{
if (!handle) {
return;
}
vEventGroupDelete(handle->event_group);
vSemaphoreDelete(handle->sem);
vPortFree(handle->buf);
vPortFree(handle);
}
static void ringbuf_reset(ringbuf_t *handle)
{
if (!handle) {
return;
}
if (NULL != handle->sem) {
xSemaphoreTake(handle->sem, portMAX_DELAY);
}
handle->read_seq = 0;
handle->write_seq = 0;
if (NULL != handle->sem) {
xSemaphoreGive(handle->sem);
}
}
static void ringbuf_wait(ringbuf_t *handle)
{
if (!handle) {
return;
}
xEventGroupWaitBits(handle->event_group,
AVAIL_BIT,
pdTRUE,
pdFALSE,
portMAX_DELAY);
}
8 用sscanf解析文本
/*
* #FLAG LENGTH PAYLOAD
* 12 04 11 22 33 44
* 21 04 44 33 22 11
* 55 06 44 33 22 11 00 71
* 66 05 44 33 22 11 81
* 33 00
* 44
*/
#define UT_FILE "./config.txt"
int main(int argc, char **argv)
{
FILE *fp;
char buf[128];
char trash_buf[128];
char *ptr;
int flag, length, val;
int i, buf_len;
fp = fopen(UT_FILE, "r");
if (fp != NULL) {
while (fgets(buf, 127, fp)) {
ptr = (char *)buf;
if (strchr(ptr, '#')) {
continue;
}
while (ptr && (*ptr != '\0') && isspace(*ptr)) ptr++;
if (!ptr) {
continue;
}
buf_len = strlen(ptr);
if (buf_len <= 6) {
/* "xx xx\n" */
if ((buf_len == 6) && 2 == sscanf(ptr, "%02x %02x\n", &flag, &length)) {
printf("%02x %02x\n", flag, length);
}
continue;
}
if (3 == sscanf(ptr, "%02x %02x %s\n", &flag, &length, trash_buf)) {
printf("%02x %02x", flag, length);
ptr += 6;
for (i = length; i--; i >= 0) {
if (i == 0) {
if (1 == sscanf(ptr, "%02x\n", &val)) {
printf(" %02x", val);
}
} else if (2 == sscanf(ptr, "%02x %s\n", &val, trash_buf)) {
printf(" %02x", val);
}
if (0 != i) {
ptr += 3;
}
}
printf("\n");
}
}
fclose (fp);
}
return 0;
}
9 both the abbreviation
IAR: After two letters taken from the first letter of the name Anders Rundgren's founder, Swedish Ingenjörsfirman Anders Rundgren, meaning Anders Rundgren Engineering
Linux FFS: the Find First the SET bit
Linux fls: find last (most-significant ) set bit
