zcy
/
tinySA
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@215 35acf78f-673a-0410-8e92-d51de3d6d3f4

master
gdisirio 2008-03-05 10:59:11 +00:00
parent 0778745ee1
commit 5e64a9fec2
47 changed files with 343 additions and 332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
demos/ARM7-AT91SAM7X-GCC/main.c
View File

@ -23,7 +23,7 @@
#include "sam7x_serial.h"
static WorkingArea(waThread1, 64);
static t_msg Thread1(void *arg) {
static msg_t Thread1(void *arg) {
while (TRUE) {
AT91C_BASE_PIOB->PIO_SODR = PIOB_LCD_BL; // LCD on.
@ -38,7 +38,7 @@ static t_msg Thread1(void *arg) {
* Entry point, the interrupts are disabled on entry.
*/
int main(int argc, char **argv) {
t_msg TestThread(void *p);
msg_t TestThread(void *p);
/*
* The main() function becomes a thread here then the interrupts are

4
demos/ARM7-LPC214x-GCC-minimal/main.c
View File

@ -25,7 +25,7 @@
* Red LEDs blinker thread, times are in milliseconds.
*/
static WorkingArea(waThread1, 64);
static t_msg Thread1(void *arg) {
static msg_t Thread1(void *arg) {
while (TRUE) {
IO0CLR = 0x00000800;
@ -44,7 +44,7 @@ static t_msg Thread1(void *arg) {
* Yellow LED blinker thread, times are in milliseconds.
*/
static WorkingArea(waThread2, 64);
static t_msg Thread2(void *arg) {
static msg_t Thread2(void *arg) {
while (TRUE) {
IO0CLR = 0x80000000;

4
demos/ARM7-LPC214x-GCC/buzzer.c
View File

@ -64,7 +64,7 @@ static void stop(void *p) {
chEvtSendI(&BuzzerSilentEventSource);
}
void PlaySound(int freq, t_time duration) {
void PlaySound(int freq, systime_t duration) {
static VirtualTimer bvt;
TC *tc = T1Base;
@ -82,7 +82,7 @@ void PlaySound(int freq, t_time duration) {
chSysUnlock();
}
void PlaySoundWait(int freq, t_time duration) {
void PlaySoundWait(int freq, systime_t duration) {
TC *tc = T1Base;
StopCounter(tc);

4
demos/ARM7-LPC214x-GCC/buzzer.h
View File

@ -24,8 +24,8 @@
extern "C" {
#endif
void InitBuzzer(void);
void PlaySound(int freq, t_time duration);
void PlaySoundWait(int freq, t_time duration);
void PlaySound(int freq, systime_t duration);
void PlaySoundWait(int freq, systime_t duration);
#ifdef __cplusplus
}
#endif

14
demos/ARM7-LPC214x-GCC/main.c
View File

@ -29,7 +29,7 @@
* Red LEDs blinker thread, times are in milliseconds.
*/
static WorkingArea(waThread1, 64);
static t_msg Thread1(void *arg) {
static msg_t Thread1(void *arg) {
while (TRUE) {
IO0CLR = 0x00000800;
@ -48,7 +48,7 @@ static t_msg Thread1(void *arg) {
* Yellow LED blinker thread, times are in milliseconds.
*/
static WorkingArea(waThread2, 64);
static t_msg Thread2(void *arg) {
static msg_t Thread2(void *arg) {
while (TRUE) {
IO0CLR = 0x80000000;
@ -62,8 +62,8 @@ static t_msg Thread2(void *arg) {
/*
* Executed as event handler at 500mS intervals.
*/
static void TimerHandler(t_eventid id) {
t_msg TestThread(void *p);
static void TimerHandler(eventid_t id) {
msg_t TestThread(void *p);
if (!(IO0PIN & 0x00018000)) { // Both buttons
TestThread(&COM1);
@ -83,7 +83,7 @@ static void TimerHandler(t_eventid id) {
* Plays sounds when a MMC/SD card is inserted, then initializes the MMC
* driver and reads a sector.
*/
static void InsertHandler(t_eventid id) {
static void InsertHandler(eventid_t id) {
static uint8_t rwbuf[512];
MMCCSD data;
@ -102,7 +102,7 @@ static void InsertHandler(t_eventid id) {
/*
* Plays sounds when a MMC/SD card is removed.
*/
static void RemoveHandler(t_eventid id) {
static void RemoveHandler(eventid_t id) {
PlaySoundWait(2000, 100);
PlaySoundWait(1000, 100);
@ -112,7 +112,7 @@ static void RemoveHandler(t_eventid id) {
* Entry point, the interrupts are disabled on entry.
*/
int main(int argc, char **argv) {
static const t_evhandler evhndl[] = {
static const evhandler_t evhndl[] = {
TimerHandler,
InsertHandler,
RemoveHandler

16
demos/ARM7-LPC214x-GCC/mmcsd.c
View File

@ -91,7 +91,7 @@ void mmcStopPolling(void) {
/*
* Returns TRUE if the card is safely inserted in the reader.
*/
t_bool mmcCardInserted (void) {
bool_t mmcCardInserted (void) {
return cnt == 0;
}
@ -145,7 +145,7 @@ static uint8_t recvr1(void) {
return 0xFF; /* Timeout.*/
}
static t_bool getdata(uint8_t *buf, uint32_t n) {
static bool_t getdata(uint8_t *buf, uint32_t n) {
int i;
for (i = 0; i < MMC_WAIT_DATA; i++) {
@ -162,7 +162,7 @@ static t_bool getdata(uint8_t *buf, uint32_t n) {
/*
* Initializes a card after the power up by selecting the SPI mode.
*/
t_bool mmcInit(void) {
bool_t mmcInit(void) {
/*
* Starting initialization with slow clock mode.
@ -222,7 +222,7 @@ uint8_t mmcSendCommand(uint8_t cmd, uint32_t arg) {
* @param data the pointer to a \p MMCCSD structure
* @return \p TRUE if an error happened
*/
t_bool mmcGetSize(MMCCSD *data) {
bool_t mmcGetSize(MMCCSD *data) {
uint8_t buf[16];
sspAcquireBus();
@ -250,7 +250,7 @@ t_bool mmcGetSize(MMCCSD *data) {
* @param buf the pointer to the read buffer
* @return \p TRUE if an error happened
*/
t_bool mmcRead(uint8_t *buf, uint32_t blknum) {
bool_t mmcRead(uint8_t *buf, uint32_t blknum) {
sspAcquireBus();
sendhdr(CMDREAD, blknum << 8);
@ -273,7 +273,7 @@ t_bool mmcRead(uint8_t *buf, uint32_t blknum) {
* @param buf the pointer to the read buffer
* @return \p TRUE if an error happened
*/
t_bool mmcReadMultiple(uint8_t *buf, uint32_t blknum, uint32_t n) {
bool_t mmcReadMultiple(uint8_t *buf, uint32_t blknum, uint32_t n) {
static const uint8_t stopcmd[] = {0x40 | CMDSTOP, 0, 0, 0, 0, 1, 0xFF};
sspAcquireBus();
@ -309,7 +309,7 @@ t_bool mmcReadMultiple(uint8_t *buf, uint32_t blknum, uint32_t n) {
* the card, this allows to not make useless busy waiting. The invoking
* thread can do other things while the data is being written.
*/
t_bool mmcWrite(uint8_t *buf, uint32_t blknum) {
bool_t mmcWrite(uint8_t *buf, uint32_t blknum) {
static const uint8_t start[] = {0xFF, 0xFE};
uint8_t b[4];
@ -340,7 +340,7 @@ t_bool mmcWrite(uint8_t *buf, uint32_t blknum) {
* the card, this allows to not make useless busy waiting. The invoking
* thread can do other things while the data is being written.
*/
t_bool mmcWriteMultiple(uint8_t *buf, uint32_t blknum, uint32_t n) {
bool_t mmcWriteMultiple(uint8_t *buf, uint32_t blknum, uint32_t n) {
static const uint8_t start[] = {0xFF, 0xFC},
stop[] = {0xFD, 0xFF};
uint8_t b[4];

14
demos/ARM7-LPC214x-GCC/mmcsd.h
View File

@ -48,16 +48,16 @@ extern EventSource MMCInsertEventSource, MMCRemoveEventSource;
#endif
void InitMMC(void);
t_bool mmcInit(void);
bool_t mmcInit(void);
void mmcStartPolling(void);
void mmcStopPolling(void);
t_bool mmcCardInserted (void);
bool_t mmcCardInserted (void);
uint8_t mmcSendCommand(uint8_t cmd, uint32_t arg);
t_bool mmcGetSize(MMCCSD *data);
t_bool mmcRead(uint8_t *buf, uint32_t blknum);
t_bool mmcReadMultiple(uint8_t *buf, uint32_t blknum, uint32_t n);
t_bool mmcWrite(uint8_t *buf, uint32_t blknum);
t_bool mmcWriteMultiple(uint8_t *buf, uint32_t blknum, uint32_t n);
bool_t mmcGetSize(MMCCSD *data);
bool_t mmcRead(uint8_t *buf, uint32_t blknum);
bool_t mmcReadMultiple(uint8_t *buf, uint32_t blknum, uint32_t n);
bool_t mmcWrite(uint8_t *buf, uint32_t blknum);
bool_t mmcWriteMultiple(uint8_t *buf, uint32_t blknum, uint32_t n);
void mmcSynch(void);
#ifdef __cplusplus
}

2
demos/AVR-ATmega128-GCC/main.c
View File

@ -26,7 +26,7 @@
void hwinit(void);
static WorkingArea(waThread1, 32);
static t_msg Thread1(void *arg) {
static msg_t Thread1(void *arg) {
while (TRUE) {
PORTA ^= PORTA_RELAY;

2
demos/Win32-MinGW/chcore.c
View File

@ -91,7 +91,7 @@ void ChkIntSources(void) {
}
}
t_msg _IdleThread(void *p) {
msg_t _IdleThread(void *p) {
while (TRUE) {

2
demos/Win32-MinGW/chcore.h
View File

@ -73,7 +73,7 @@ typedef struct {
#define WorkingArea(s, n) uint32_t s[UserStackSize(n) >> 2];
#define IDLE_THREAD_STACK_SIZE 16384
t_msg _IdleThread(void *p);
msg_t _IdleThread(void *p);
__attribute__((fastcall)) void chSysHalt(void);
__attribute__((fastcall)) void chSysSwitchI(Thread *otp, Thread *ntp);

25
demos/Win32-MinGW/chtypes.h
View File

@ -20,21 +20,24 @@
#ifndef _CHTYPES_H_
#define _CHTYPES_H_
#define __need_NULL
#define __need_size_t
#include <stddef.h>
#if !defined(_STDINT_H) && !defined(__STDINT_H_)
#include <stdint.h>
#endif
typedef int8_t t_bool;
typedef uint8_t t_tmode;
typedef uint8_t t_tstate;
typedef uint16_t t_tid;
typedef uint32_t t_prio;
typedef int32_t t_msg;
typedef int32_t t_eventid;
typedef uint32_t t_eventmask;
typedef uint32_t t_time;
typedef int32_t t_cnt;
typedef uint32_t t_size;
typedef int8_t bool_t;
typedef uint8_t tmode_t;
typedef uint8_t tstate_t;
typedef uint16_t tid_t;
typedef uint32_t tprio_t;
typedef int32_t msg_t;
typedef int32_t eventid_t;
typedef uint32_t eventmask_t;
typedef uint32_t systime_t;
typedef int32_t cnt_t;
#define INLINE inline

30
demos/Win32-MinGW/demo.c
View File

@ -29,21 +29,21 @@ static uint32_t cdguard;
static WorkingArea(cdarea, 2048);
static Thread *cdtp;
static t_msg WatchdogThread(void *arg);
static t_msg ConsoleThread(void *arg);
static msg_t WatchdogThread(void *arg);
static msg_t ConsoleThread(void *arg);
t_msg TestThread(void *p);
msg_t TestThread(void *p);
void InitCore(void);
extern FullDuplexDriver COM1, COM2;
#define cprint(msg) chMsgSend(cdtp, (t_msg)msg)
#define cprint(msg) chMsgSend(cdtp, (msg_t)msg)
/*
* Watchdog thread, it checks magic values located under the various stack
* areas. The system is halted if something is wrong.
*/
static t_msg WatchdogThread(void *arg) {
static msg_t WatchdogThread(void *arg) {
wdguard = 0xA51F2E3D;
cdguard = 0xA51F2E3D;
while (TRUE) {
@ -63,7 +63,7 @@ static t_msg WatchdogThread(void *arg) {
* to the C printf() thread safe and the print operation atomic among threads.
* In this example the message is the zero termitated string itself.
*/
static t_msg ConsoleThread(void *arg) {
static msg_t ConsoleThread(void *arg) {
while (!chThdShouldTerminate()) {
printf((char *)chMsgWait());
@ -78,7 +78,7 @@ static void PrintLineFDD(FullDuplexDriver *sd, char *msg) {
chFDDPut(sd, *msg++);
}
static t_bool GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
static bool_t GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
char *p = line;
while (TRUE) {
@ -116,7 +116,7 @@ static t_bool GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
* Example thread, not much to see here. It simulates the CTRL-C but there
* are no real signals involved.
*/
static t_msg HelloWorldThread(void *arg) {
static msg_t HelloWorldThread(void *arg) {
int i;
short c;
FullDuplexDriver *sd = (FullDuplexDriver *)arg;
@ -140,7 +140,7 @@ static t_msg HelloWorldThread(void *arg) {
return 0;
}
static t_bool checkend(FullDuplexDriver *sd) {
static bool_t checkend(FullDuplexDriver *sd) {
char * lp = strtok(NULL, " \009"); /* It is not thread safe but this is a demo.*/
if (lp) {
@ -155,7 +155,7 @@ static t_bool checkend(FullDuplexDriver *sd) {
* Simple command shell thread, the argument is the serial line for the
* standard input and output. It recognizes few simple commands.
*/
static t_msg ShellThread(void *arg) {
static msg_t ShellThread(void *arg) {
FullDuplexDriver *sd = (FullDuplexDriver *)arg;
char *lp, line[64];
Thread *tp;
@ -225,8 +225,8 @@ static WorkingArea(s1area, 4096);
static Thread *s1;
EventListener s1tel;
static void COM1Handler(t_eventid id) {
t_dflags flags;
static void COM1Handler(eventid_t id) {
dflags_t flags;
if (s1 && chThdTerminated(s1)) {
s1 = NULL;
@ -248,8 +248,8 @@ static WorkingArea(s2area, 4096);
static Thread *s2;
EventListener s2tel;
static void COM2Handler(t_eventid id) {
t_dflags flags;
static void COM2Handler(eventid_t id) {
dflags_t flags;
if (s2 && chThdTerminated(s2)) {
s2 = NULL;
@ -267,7 +267,7 @@ static void COM2Handler(t_eventid id) {
chIQReset(&COM2.sd_iqueue);
}
static t_evhandler fhandlers[2] = {
static evhandler_t fhandlers[2] = {
COM1Handler,
COM2Handler
};

4
ports/ARM7-AT91SAM7X/sam7x_serial.c
View File

@ -32,7 +32,7 @@ static uint8_t ib2[SERIAL_BUFFERS_SIZE];
static uint8_t ob2[SERIAL_BUFFERS_SIZE];
static void SetError(AT91_REG csr, FullDuplexDriver *com) {
uint16_t sts = 0;
dflags_t sts = 0;
if (csr & AT91C_US_OVRE)
sts |= SD_OVERRUN_ERROR;
@ -53,7 +53,7 @@ static void ServeInterrupt(AT91PS_USART u, FullDuplexDriver *com) {
if (u->US_CSR & AT91C_US_RXRDY)
chFDDIncomingDataI(com, u->US_RHR);
if (u->US_CSR & AT91C_US_TXRDY) {
t_msg b = chFDDRequestDataI(com);
msg_t b = chFDDRequestDataI(com);
if (b < Q_OK)
u->US_IDR = AT91C_US_TXRDY;
else

8
ports/ARM7-LPC214x/lpc214x_serial.c
View File

@ -33,7 +33,7 @@ static uint8_t ib2[SERIAL_BUFFERS_SIZE];
static uint8_t ob2[SERIAL_BUFFERS_SIZE];
static void SetError(IOREG32 err, FullDuplexDriver *com) {
uint16_t sts = 0;
dflags_t sts = 0;
if (err & LSR_OVERRUN)
sts |= SD_OVERRUN_ERROR;
@ -72,7 +72,7 @@ static void ServeInterrupt(UART *u, FullDuplexDriver *com) {
#ifdef FIFO_PRELOAD
int i = FIFO_PRELOAD;
do {
t_msg b = chOQGetI(&com->sd_oqueue);
msg_t b = chOQGetI(&com->sd_oqueue);
if (b < Q_OK) {
u->UART_IER &= ~IER_THRE;
chEvtSendI(&com->sd_oevent);
@ -81,7 +81,7 @@ static void ServeInterrupt(UART *u, FullDuplexDriver *com) {
u->UART_THR = b;
} while (--i);
#else
t_msg b = chFDDRequestDataI(com);
msg_t b = chFDDRequestDataI(com);
if (b < Q_OK)
u->UART_IER &= ~IER_THRE;
else
@ -123,7 +123,7 @@ static void preload(UART *u, FullDuplexDriver *com) {
if (u->UART_LSR & LSR_THRE) {
int i = FIFO_PRELOAD;
do {
t_msg b = chOQGetI(&com->sd_oqueue);
msg_t b = chOQGetI(&com->sd_oqueue);
if (b < Q_OK) {
chEvtSendI(&com->sd_oevent);
return;

2
ports/ARM7-LPC214x/lpc214x_ssp.c
View File

@ -55,7 +55,7 @@ void sspReleaseBus(void) {
* rest of the system. This kind of peripheral would really need a
* dedicated DMA channel.
*/
void sspRW(uint8_t *in, uint8_t *out, t_size n) {
void sspRW(uint8_t *in, uint8_t *out, size_t n) {
int icnt, ocnt;
SSP *ssp = SSPBase;

2
ports/ARM7-LPC214x/lpc214x_ssp.h
View File

@ -34,7 +34,7 @@
void sspAcquireBus(void);
void sspReleaseBus(void);
void sspRW(uint8_t *in, uint8_t *out, t_size n);
void sspRW(uint8_t *in, uint8_t *out, size_t n);
#ifdef __cplusplus
}
#endif

25
ports/ARM7/chtypes.h
View File

@ -20,21 +20,24 @@
#ifndef _CHTYPES_H_
#define _CHTYPES_H_
#define __need_NULL
#define __need_size_t
#include <stddef.h>
#if !defined(_STDINT_H) && !defined(__STDINT_H_)
#include <stdint.h>
#endif
typedef int8_t t_bool;
typedef uint8_t t_tmode;
typedef uint8_t t_tstate;
typedef uint16_t t_tid;
typedef uint32_t t_prio;
typedef int32_t t_msg;
typedef int32_t t_eventid;
typedef uint32_t t_eventmask;
typedef uint32_t t_time;
typedef int32_t t_cnt;
typedef uint32_t t_size;
typedef int8_t bool_t;
typedef uint8_t tmode_t;
typedef uint8_t tstate_t;
typedef uint16_t tid_t;
typedef uint32_t tprio_t;
typedef int32_t msg_t;
typedef int32_t eventid_t;
typedef uint32_t eventmask_t;
typedef uint32_t systime_t;
typedef int32_t cnt_t;
#define INLINE inline

6
ports/AVR/avr_serial.c
View File

@ -25,7 +25,7 @@
#include "avr_serial.h"
static void SetError(uint8_t sra, FullDuplexDriver *com) {
uint16_t sts = 0;
dflags_t sts = 0;
if (sra & (1 << DOR))
sts |= SD_OVERRUN_ERROR;
@ -54,7 +54,7 @@ ISR(USART0_RX_vect) {
}
ISR(USART0_UDRE_vect) {
t_msg b;
msg_t b;
chSysIRQEnterI();
@ -109,7 +109,7 @@ ISR(USART1_RX_vect) {
}
ISR(USART1_UDRE_vect) {
t_msg b;
msg_t b;
chSysIRQEnterI();

25
ports/AVR/chtypes.h
View File

@ -20,21 +20,24 @@
#ifndef _CHTYPES_H_
#define _CHTYPES_H_
#define __need_NULL
#define __need_size_t
#include <stddef.h>
#if !defined(_STDINT_H) && !defined(__STDINT_H_)
#include <stdint.h>
#endif
typedef int8_t t_bool;
typedef uint8_t t_tmode;
typedef uint8_t t_tstate;
typedef uint8_t t_tid;
typedef uint8_t t_prio;
typedef int16_t t_msg;
typedef uint8_t t_eventid;
typedef uint8_t t_eventmask;
typedef uint16_t t_time;
typedef int8_t t_cnt;
typedef uint16_t t_size;
typedef int8_t bool_t;
typedef uint8_t tmode_t;
typedef uint8_t tstate_t;
typedef uint8_t tid_t;
typedef uint8_t tprio_t;
typedef int16_t msg_t;
typedef uint8_t eventid_t;
typedef uint8_t eventmask_t;
typedef uint16_t systime_t;
typedef int8_t cnt_t;
#define INLINE inline

18
ports/Win32/simcom.c
View File

@ -108,7 +108,7 @@ void InitSimCom2(void) {
init("COM2", &COM2, &sc2, COM2PORT);
}
static t_bool connint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
static bool_t connint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
if (sc->com_data == INVALID_SOCKET) {
struct sockaddr addr;
@ -134,17 +134,17 @@ abort:
exit(1);
}
t_bool Com1ConnInterruptSimCom(void) {
bool_t Com1ConnInterruptSimCom(void) {
return connint("COM1", &COM1, &sc1);
}
t_bool Com2ConnInterruptSimCom(void) {
bool_t Com2ConnInterruptSimCom(void) {
return connint("COM2", &COM2, &sc2);
}
static t_bool inint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
static bool_t inint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
if (sc->com_data != INVALID_SOCKET) {
int i;
@ -174,17 +174,17 @@ static t_bool inint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
return FALSE;
}
t_bool Com1InInterruptSimCom(void) {
bool_t Com1InInterruptSimCom(void) {
return inint("COM1", &COM1, &sc1);
}
t_bool Com2InInterruptSimCom(void) {
bool_t Com2InInterruptSimCom(void) {
return inint("COM2", &COM2, &sc2);
}
static t_bool outint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
static bool_t outint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
if (sc->com_data != INVALID_SOCKET) {
int n;
@ -216,12 +216,12 @@ static t_bool outint(char *name, FullDuplexDriver *sd, struct simcom *sc) {
return FALSE;
}
t_bool Com1OutInterruptSimCom(void) {
bool_t Com1OutInterruptSimCom(void) {
return outint("COM1", &COM1, &sc1);
}
t_bool Com2OutInterruptSimCom(void) {
bool_t Com2OutInterruptSimCom(void) {
return outint("COM2", &COM2, &sc2);
}

14
readme.txt
View File

@ -63,12 +63,18 @@ AVR-AT90CANx-GCC - Port on AVR AT90CAN128, not complete yet, scheduled
*** Releases ***
*****************************************************************************
*** 0.5.6 ***
- Implemented a serial driver in the AVR port.
*** 0.6.0 ***
- Code refactory, all the old sized-integer definitions like LONG32, UWORD16
etc are now replaced by the proper definitions provided by the compiler
into stdint.h. This has an impact on some API prototypes but we can't
help it.
into stdint.h.
- Code refactory, the previous system types style using a t_ in front of the
name has been replaced with the standard trailing _t. The system now uses
the size_t type defined into stddef.h. Some type names were modified in
order to not match commonly used type names.
- The above changes have an impact on some API prototypes but we can't help
it, the change was required because the type names were the main concern of
some users.
- Implemented a serial driver in the AVR port.
- MSVC demo dropped, it is still possible to use the MinGW demo as simulator
in Win32.
- Fixed a minor error in sam7x_serial.h and lpc214x_serial.h.

4
src/chdelta.c
View File

@ -33,7 +33,7 @@ DeltaList dlist;
void chVTInit(void) {
dlist.dl_next = dlist.dl_prev = (VirtualTimer *)&dlist;
dlist.dl_dtime = (t_time)-1;
dlist.dl_dtime = (systime_t)-1;
}
/**
@ -50,7 +50,7 @@ void chVTInit(void) {
* @note Must be called with the interrupts disabled.
* @note The associated function is invoked by an interrupt handler.
*/
void chVTSetI(VirtualTimer *vtp, t_time time, t_vtfunc vtfunc, void *par) {
void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
vtp->vt_par = par;
vtp->vt_func = vtfunc;

32
src/chevents.c
View File

@ -31,11 +31,11 @@
* @param eid numeric identifier assigned to the Event Listener. The identifier
* is used as index for the event callback function.
* The value must range between zero and the size, in bit, of the
* \p t_eventid type minus one.
* \p eventid_t type minus one.
* @note Multiple Event Listeners can use the same event identifier, the
* listener will share the callback function.
*/
void chEvtRegister(EventSource *esp, EventListener *elp, t_eventid eid) {
void chEvtRegister(EventSource *esp, EventListener *elp, eventid_t eid) {
chSysLock();
@ -77,7 +77,7 @@ void chEvtUnregister(EventSource *esp, EventListener *elp) {
* Clears the pending events specified in the mask.
* @param mask the events to be cleared
*/
void chEvtClear(t_eventmask mask) {
void chEvtClear(eventmask_t mask) {
chSysLock();
@ -125,7 +125,7 @@ void chEvtSendI(EventSource *esp) {
* event handler is specified then the handler is executed before returning.
* @param ewmask mask of the events that should be served by the function,
* \p ALL_EVENTS enables all the sources
* @param handlers an array of \p t_evhandler. The array must be
* @param handlers an array of \p evhandler_t. The array must be
* have indexes from zero up the higher registered event
* identifier. The array can be \p NULL or contain \p NULL
* elements (no callbacks specified).
@ -136,8 +136,8 @@ void chEvtSendI(EventSource *esp) {
* This means that Event Listeners with a lower event identifier have
* an higher priority.
*/
t_eventid chEvtWait(t_eventmask ewmask,
const t_evhandler handlers[]) {
eventid_t chEvtWait(eventmask_t ewmask,
const evhandler_t handlers[]) {
return chEvtWaitTimeout(ewmask, handlers, TIME_INFINITE);
}
@ -148,7 +148,7 @@ t_eventid chEvtWait(t_eventmask ewmask,
* executed before returning.
* @param ewmask mask of the events that should be served by the function,
* \p ALL_EVENTS enables all the sources
* @param handlers an array of \p t_evhandler. The array must be
* @param handlers an array of \p evhandler_t. The array must be
* have indexes from zero up the higher registered event
* identifier. The array can be NULL or contain NULL elements
* (no callback specified).
@ -162,11 +162,11 @@ t_eventid chEvtWait(t_eventmask ewmask,
* @note The function is available only if the \p CH_USE_EVENTS_TIMEOUT
* option is enabled in \p chconf.h.
*/
t_eventid chEvtWaitTimeout(t_eventmask ewmask,
const t_evhandler handlers[],
t_time time) {
t_eventid i;
t_eventmask m;
eventid_t chEvtWaitTimeout(eventmask_t ewmask,
const evhandler_t handlers[],
systime_t time) {
eventid_t i;
eventmask_t m;
chSysLock();
@ -189,10 +189,10 @@ t_eventid chEvtWaitTimeout(t_eventmask ewmask,
}
#else /* !CH_USE_EVENTS_TIMEOUT */
t_eventid chEvtWait(t_eventmask ewmask,
const t_evhandler handlers[]) {
t_eventid i;
t_eventmask m;
eventid_t chEvtWait(eventmask_t ewmask,
const evhandler_t handlers[]) {
eventid_t i;
eventmask_t m;
chSysLock();

2
src/chinit.c
View File

@ -55,7 +55,7 @@ void chSysInit(void) {
* serve interrupts in its context while keeping the lowest energy saving
* mode compatible with the system status.
*/
chThdCreate(IDLEPRIO, 0, waIdleThread, sizeof(waIdleThread), (t_tfunc)_IdleThread, NULL);
chThdCreate(IDLEPRIO, 0, waIdleThread, sizeof(waIdleThread), (tfunc_t)_IdleThread, NULL);
}
/**

16
src/chmsg.c
View File

@ -32,7 +32,7 @@
* @param msg the message, it can be a pointer to a complex structure
* @return the return message from \p chMsgRelease()
*/
t_msg chMsgSend(Thread *tp, t_msg msg) {
msg_t chMsgSend(Thread *tp, msg_t msg) {
chSysLock();
@ -70,7 +70,7 @@ t_msg chMsgSend(Thread *tp, t_msg msg) {
* a \p chMsgWait(). The use case is that the server thread is waiting
* for both messages AND events while waiting into \p chEvtWait().
*/
t_msg chMsgSendWithEvent(Thread *tp, t_msg msg, EventSource *esp) {
msg_t chMsgSendWithEvent(Thread *tp, msg_t msg, EventSource *esp) {
chSysLock();
@ -103,8 +103,8 @@ t_msg chMsgSendWithEvent(Thread *tp, t_msg msg, EventSource *esp) {
* you invoke \p chMsgRelease() because the sending thread is
* suspended until then.
*/
t_msg chMsgWait(void) {
t_msg msg;
msg_t chMsgWait(void) {
msg_t msg;
chSysLock();
@ -127,12 +127,12 @@ t_msg chMsgWait(void) {
* suspended until then. Always remember that the message data is not
* copied between the sender and the receiver, just a pointer is passed.
*/
t_msg chMsgGet(void) {
t_msg msg;
msg_t chMsgGet(void) {
msg_t msg;
chSysLock();
msg = chMsgIsPendingI(currp) ? chMsgGetI(currp) : NULL;
msg = chMsgIsPendingI(currp) ? chMsgGetI(currp) : (msg_t)NULL;
chSysUnlock();
return msg;
@ -149,7 +149,7 @@ t_msg chMsgGet(void) {
* The condition is not checked in order to make this code as fast as
* possible.
*/
void chMsgRelease(t_msg msg) {
void chMsgRelease(msg_t msg) {
chSysLock();

10
src/chmtx.c
View File

@ -106,8 +106,8 @@ void chMtxLockS(Mutex *mp) {
* @param mp pointer to the \p Mutex structure
* @return \p TRUE if the mutex was successfully acquired else \p FALSE
*/
t_bool chMtxTryLock(Mutex *mp) {
t_bool b;
bool_t chMtxTryLock(Mutex *mp) {
bool_t b;
chSysLock();
@ -126,7 +126,7 @@ t_bool chMtxTryLock(Mutex *mp) {
* @note This function must be called within a \p chSysLock() / \p chSysUnlock()
* block.
*/
t_bool chMtxTryLockS(Mutex *mp) {
bool_t chMtxTryLockS(Mutex *mp) {
if (mp->m_owner != NULL)
return FALSE;
@ -161,7 +161,7 @@ void chMtxUnlock(void) {
/*
* Recalculates the optimal thread priority by scanning the owned mutexes list.
*/
t_prio newprio = currp->p_realprio;
tprio_t newprio = currp->p_realprio;
mp = currp->p_mtxlist;
while (mp != NULL) {
if (chMtxQueueNotEmptyS(mp) && (mp->m_queue.p_next->p_prio > newprio))
@ -201,7 +201,7 @@ void chMtxUnlockS(void) {
/*
* Recalculates the optimal thread priority by scanning the owned mutexes list.
*/
t_prio newprio = currp->p_realprio;
tprio_t newprio = currp->p_realprio;
mp = currp->p_mtxlist;
while (mp != NULL) {
if (chMtxQueueNotEmptyS(mp) && (mp->m_queue.p_next->p_prio > newprio))

38
src/chqueues.c
View File

@ -35,7 +35,7 @@
* @param inotify pointer to a callback function that is invoked when
* some data is read from the Queue. The value can be \p NULL.
*/
void chIQInit(Queue *qp, uint8_t *buffer, t_size size, t_qnotify inotify) {
void chIQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t inotify) {
qp->q_buffer = qp->q_rdptr = qp->q_wrptr = buffer;
qp->q_top = buffer + size;
@ -68,7 +68,7 @@ void chIQReset(Queue *qp) {
* @note This function must be called with interrupts disabled or from an
* interrupt handler.
*/
t_msg chIQPutI(Queue *qp, uint8_t b) {
msg_t chIQPutI(Queue *qp, uint8_t b) {
if (chIQIsFull(qp))
return Q_FULL;
@ -86,7 +86,7 @@ t_msg chIQPutI(Queue *qp, uint8_t b) {
* @param qp pointer to a \p Queue structure
* @return a byte from the queue or \p Q_RESET if the queue was reset
*/
t_msg chIQGet(Queue *qp) {
msg_t chIQGet(Queue *qp) {
uint8_t b;
chSysLock();
@ -119,9 +119,9 @@ t_msg chIQGet(Queue *qp) {
* @note The function is available only if the \p CH_USE_QUEUES_TIMEOUT
* option is enabled in \p chconf.h.
*/
t_msg chIQGetTimeout(Queue *qp, t_time time) {
msg_t chIQGetTimeout(Queue *qp, systime_t time) {
uint8_t b;
t_msg msg;
msg_t msg;
chSysLock();
@ -153,9 +153,9 @@ t_msg chIQGetTimeout(Queue *qp, t_time time) {
* @note The function is not atomic, if you need atomicity it is suggested
* to use a semaphore for mutual exclusion.
*/
t_size chIQRead(Queue *qp, uint8_t *buffer, t_size n) {
size_t chIQRead(Queue *qp, uint8_t *buffer, size_t n) {
t_size r = 0;
size_t r = 0;
while (n--) {
chSysLock();
@ -193,7 +193,7 @@ t_size chIQRead(Queue *qp, uint8_t *buffer, t_size n) {
* @param onotify pointer to a callback function that is invoked when
* some data is written in the Queue. The value can be \p NULL.
*/
void chOQInit(Queue *qp, uint8_t *buffer, t_size size, t_qnotify onotify) {
void chOQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t onotify) {
qp->q_buffer = qp->q_rdptr = qp->q_wrptr = buffer;
qp->q_top = buffer + size;
@ -211,7 +211,7 @@ void chOQReset(Queue *qp) {
chSysLock();
qp->q_rdptr = qp->q_wrptr = qp->q_buffer;
chSemResetI(&qp->q_sem, (t_cnt)(qp->q_top - qp->q_buffer));
chSemResetI(&qp->q_sem, (cnt_t)(qp->q_top - qp->q_buffer));
chSysUnlock();
}
@ -245,7 +245,7 @@ void chOQPut(Queue *qp, uint8_t b) {
* @note This function must be called with interrupts disabled or from an
* interrupt handler.
*/
t_msg chOQGetI(Queue *qp) {
msg_t chOQGetI(Queue *qp) {
uint8_t b;
if (chOQIsEmpty(qp))
@ -268,9 +268,9 @@ t_msg chOQGetI(Queue *qp) {
* @note The function is not atomic, if you need atomicity it is suggested
* to use a semaphore for mutual exclusion.
*/
t_size chOQWrite(Queue *qp, uint8_t *buffer, t_size n) {
size_t chOQWrite(Queue *qp, uint8_t *buffer, size_t n) {
t_size w = 0;
size_t w = 0;
while (n--) {
chSysLock();
@ -311,8 +311,8 @@ t_size chOQWrite(Queue *qp, uint8_t *buffer, t_size n) {
* @param onotify pointer to a callback function that is invoked when
* some data is written to the queue. The value can be \p NULL.
*/
void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, t_size size,
t_qnotify inotify, t_qnotify onotify) {
void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, size_t size,
qnotify_t inotify, qnotify_t onotify) {
qp->hdq_buffer = qp->hdq_rdptr = qp->hdq_wrptr = buffer;
qp->hdq_top = buffer + size;
@ -328,7 +328,7 @@ void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, t_size size,
* @param qp pointer to a \p HalfDuplexQueue structure
* @return the byte value or \p Q_RESET if the queue was reset
*/
t_msg chHDQGetReceive(HalfDuplexQueue *qp) {
msg_t chHDQGetReceive(HalfDuplexQueue *qp) {
uint8_t b;
chSysLock();
@ -363,9 +363,9 @@ t_msg chHDQGetReceive(HalfDuplexQueue *qp) {
* @note The function is available only if the \p CH_USE_QUEUES_TIMEOUT
* option is enabled in \p chconf.h.
*/
t_msg chHDQGetReceiveTimeout(HalfDuplexQueue *qp, t_time time) {
msg_t chHDQGetReceiveTimeout(HalfDuplexQueue *qp, systime_t time) {
uint8_t b;
t_msg msg;
msg_t msg;
chSysLock();
@ -431,7 +431,7 @@ void chHDQPutTransmit(HalfDuplexQueue *qp, uint8_t b) {
* @note This function must be called with interrupts disabled or from an
* interrupt handler.
*/
t_msg chHDQGetTransmitI(HalfDuplexQueue *qp) {
msg_t chHDQGetTransmitI(HalfDuplexQueue *qp) {
uint8_t b;
if (!chHDQIsTransmitting(qp))
@ -454,7 +454,7 @@ t_msg chHDQGetTransmitI(HalfDuplexQueue *qp) {
* @note This function must be called with interrupts disabled or from an
* interrupt handler.
*/
t_msg chHDQPutReceiveI(HalfDuplexQueue *qp, uint8_t b) {
msg_t chHDQPutReceiveI(HalfDuplexQueue *qp, uint8_t b) {
if (chHDQIsTransmitting(qp))
return Q_FULL;

12
src/chschd.c
View File

@ -54,9 +54,9 @@ void chSchInit(void) {
*/
#ifdef CH_OPTIMIZE_SPEED
/* NOTE: it is inlined in this module only.*/
INLINE void chSchReadyI(Thread *tp, t_msg msg) {
INLINE void chSchReadyI(Thread *tp, msg_t msg) {
#else
void chSchReadyI(Thread *tp, t_msg msg) {
void chSchReadyI(Thread *tp, msg_t msg) {
#endif
Thread *cp = rlist.r_queue.p_next;
@ -78,7 +78,7 @@ void chSchReadyI(Thread *tp, t_msg msg) {
* @note The function must be called in the system mutex zone.
* @note The function is not meant to be used in the user code directly.
*/
void chSchGoSleepS(t_tstate newstate) {
void chSchGoSleepS(tstate_t newstate) {
Thread *otp;
(otp = currp)->p_state = newstate;
@ -108,7 +108,7 @@ static void wakeup(void *p) {
* @note The function must be called in the system mutex zone.
* @note The function is not meant to be used in the user code directly.
*/
t_msg chSchGoSleepTimeoutS(t_tstate newstate, t_time time) {
msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
VirtualTimer vt;
chVTSetI(&vt, time, wakeup, currp);
@ -130,7 +130,7 @@ t_msg chSchGoSleepTimeoutS(t_tstate newstate, t_time time) {
* @note It is equivalent to a \p chSchReadyI() followed by a
* \p chSchRescheduleS() but much more efficient.
*/
void chSchWakeupS(Thread *ntp, t_msg msg) {
void chSchWakeupS(Thread *ntp, msg_t msg) {
if (ntp->p_prio <= currp->p_prio)
chSchReadyI(ntp, msg);
@ -181,7 +181,7 @@ void chSchRescheduleS(void) {
* @return \p TRUE if there is a thread that should go in running state
* immediatly else \p FALSE.
*/
t_bool chSchRescRequiredI(void) {
bool_t chSchRescRequiredI(void) {
if (isempty(&rlist.r_queue))
return FALSE;

20
src/chsem.c
View File

@ -31,7 +31,7 @@
* @param n initial value of the semaphore counter. Must be non-negative.
* @note Can be called with interrupts disabled or enabled.
*/
void chSemInit(Semaphore *sp, t_cnt n) {
void chSemInit(Semaphore *sp, cnt_t n) {
chDbgAssert(n >= 0, "chsem.c, chSemInit()");
fifo_init(&sp->s_queue);
@ -46,7 +46,7 @@ void chSemInit(Semaphore *sp, t_cnt n) {
* instead than a signal because the \p chSemWait() will return
* \p RDY_RESET instead of \p RDY_OK.
*/
void chSemReset(Semaphore *sp, t_cnt n) {
void chSemReset(Semaphore *sp, cnt_t n) {
chSysLock();
@ -65,8 +65,8 @@ void chSemReset(Semaphore *sp, t_cnt n) {
* \p RDY_RESET instead of \p RDY_OK.
* @note This function does not reschedule.
*/
void chSemResetI(Semaphore *sp, t_cnt n) {
t_cnt cnt;
void chSemResetI(Semaphore *sp, cnt_t n) {
cnt_t cnt;
chDbgAssert(n >= 0, "chsem.c, chSemResetI()");
cnt = sp->s_cnt;
@ -80,8 +80,8 @@ void chSemResetI(Semaphore *sp, t_cnt n) {
* @param sp pointer to a \p Semaphore structure
* @return the function can return \p RDY_OK or \p RDY_RESET.
*/
t_msg chSemWait(Semaphore *sp) {
t_msg msg;
msg_t chSemWait(Semaphore *sp) {
msg_t msg;
chSysLock();
@ -98,7 +98,7 @@ t_msg chSemWait(Semaphore *sp) {
* @note This function must be called with interrupts disabled.
* @note This function cannot be called by an interrupt handler.
*/
t_msg chSemWaitS(Semaphore *sp) {
msg_t chSemWaitS(Semaphore *sp) {
if (--sp->s_cnt < 0) {
fifo_insert(currp, &sp->s_queue);
@ -116,8 +116,8 @@ t_msg chSemWaitS(Semaphore *sp) {
* @param time the number of ticks before the operation fails
* @return the function can return \p RDY_OK, \p RDY_TIMEOUT or \p RDY_RESET.
*/
t_msg chSemWaitTimeout(Semaphore *sp, t_time time) {
t_msg msg;
msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {
msg_t msg;
chSysLock();
@ -137,7 +137,7 @@ t_msg chSemWaitTimeout(Semaphore *sp, t_time time) {
* @note The function is available only if the \p CH_USE_SEMAPHORES_TIMEOUT
* option is enabled in \p chconf.h.
*/
t_msg chSemWaitTimeoutS(Semaphore *sp, t_time time) {
msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
if (--sp->s_cnt < 0) {
fifo_insert(currp, &sp->s_queue);

28
src/chserial.c
View File

@ -40,8 +40,8 @@
* some data is written in the Queue. The value can be \p NULL.
*/
void chFDDInit(FullDuplexDriver *sd,
uint8_t *ib, t_size isize, t_qnotify inotify,
uint8_t *ob, t_size osize, t_qnotify onotify) {
uint8_t *ib, size_t isize, qnotify_t inotify,
uint8_t *ob, size_t osize, qnotify_t onotify) {
chIQInit(&sd->sd_iqueue, ib, isize, inotify);
chEvtInit(&sd->sd_ievent);
@ -74,9 +74,9 @@ void chFDDIncomingDataI(FullDuplexDriver *sd, uint8_t b) {
* queue is empty (the lower driver usually disables the interrupt
* source when this happens).
*/
t_msg chFDDRequestDataI(FullDuplexDriver *sd) {
msg_t chFDDRequestDataI(FullDuplexDriver *sd) {
t_msg b = chOQGetI(&sd->sd_oqueue);
msg_t b = chOQGetI(&sd->sd_oqueue);
if (b < Q_OK)
chEvtSendI(&sd->sd_oevent);
return b;
@ -88,7 +88,7 @@ t_msg chFDDRequestDataI(FullDuplexDriver *sd) {
* @param sd pointer to a \p FullDuplexDriver structure
* @param mask condition flags to be added to the mask
*/
void chFDDAddFlagsI(FullDuplexDriver *sd, t_dflags mask) {
void chFDDAddFlagsI(FullDuplexDriver *sd, dflags_t mask) {
sd->sd_flags |= mask;
chEvtSendI(&sd->sd_sevent);
@ -100,8 +100,8 @@ void chFDDAddFlagsI(FullDuplexDriver *sd, t_dflags mask) {
* @return the condition flags modified since last time this function was
* invoked
*/
t_dflags chFDDGetAndClearFlags(FullDuplexDriver *sd) {
t_dflags mask;
dflags_t chFDDGetAndClearFlags(FullDuplexDriver *sd) {
dflags_t mask;
mask = sd->sd_flags;
sd->sd_flags = SD_NO_ERROR;
@ -122,8 +122,8 @@ t_dflags chFDDGetAndClearFlags(FullDuplexDriver *sd) {
* @param onotify pointer to a callback function that is invoked when
* some data is written in the queue. The value can be \p NULL.
*/
void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, t_size size,
t_qnotify inotify, t_qnotify onotify) {
void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, size_t size,
qnotify_t inotify, qnotify_t onotify) {
chHDQInit(&sd->sd_queue, b, size, inotify, onotify);
chEvtInit(&sd->sd_ievent);
@ -155,9 +155,9 @@ void chHDDIncomingDataI(HalfDuplexDriver *sd, uint8_t b) {
* queue is empty (the lower driver usually disables the interrupt
* source when this happens).
*/
t_msg chHDDRequestDataI(HalfDuplexDriver *sd) {
msg_t chHDDRequestDataI(HalfDuplexDriver *sd) {
t_msg b = chHDQGetTransmitI(&sd->sd_queue);
msg_t b = chHDQGetTransmitI(&sd->sd_queue);
if (b < Q_OK)
chEvtSendI(&sd->sd_oevent);
return b;
@ -169,7 +169,7 @@ t_msg chHDDRequestDataI(HalfDuplexDriver *sd) {
* @param sd pointer to a \p HalfDuplexDriver structure
* @param mask condition flags to be added to the mask
*/
void chHDDAddFlagsI(HalfDuplexDriver *sd, t_dflags mask) {
void chHDDAddFlagsI(HalfDuplexDriver *sd, dflags_t mask) {
sd->sd_flags |= mask;
chEvtSendI(&sd->sd_sevent);
@ -181,8 +181,8 @@ void chHDDAddFlagsI(HalfDuplexDriver *sd, t_dflags mask) {
* @return the condition flags modified since last time this function was
* invoked
*/
t_dflags chHDDGetAndClearFlags(HalfDuplexDriver *sd) {
t_dflags mask;
dflags_t chHDDGetAndClearFlags(HalfDuplexDriver *sd) {
dflags_t mask;
mask = sd->sd_flags;
sd->sd_flags = SD_NO_ERROR;

2
src/chsleep.c
View File

@ -29,7 +29,7 @@
* Suspends the invoking thread for the specified time.
* @param time the system ticks number
*/
void chThdSleep(t_time time) {
void chThdSleep(systime_t time) {
chSysLock();

16
src/chthreads.c
View File

@ -27,8 +27,8 @@
/*
* Initializes a thread structure.
*/
void _InitThread(t_prio prio, t_tmode mode, Thread *tp) {
static t_tid nextid = 0;
void _InitThread(tprio_t prio, tmode_t mode, Thread *tp) {
static tid_t nextid = 0;
tp->p_tid = nextid++;
tp->p_flags = mode;
@ -89,8 +89,8 @@ static void memfill(uint8_t *p, uint32_t n, uint8_t v) {
* @note A thread can terminate by calling \p chThdExit() or by simply
* returning from its main function.
*/
Thread *chThdCreate(t_prio prio, t_tmode mode, void *workspace,
t_size wsize, t_tfunc pf, void *arg) {
Thread *chThdCreate(tprio_t prio, tmode_t mode, void *workspace,
size_t wsize, tfunc_t pf, void *arg) {
Thread *tp = workspace;
chDbgAssert((wsize > UserStackSize(0)) && (prio <= HIGHPRIO) &&
@ -121,7 +121,7 @@ Thread *chThdCreate(t_prio prio, t_tmode mode, void *workspace,
* Changes the thread priority, reschedules if necessary.
* @param newprio the new priority of the invoking thread
*/
void chThdSetPriority(t_prio newprio) {
void chThdSetPriority(tprio_t newprio) {
chDbgAssert(newprio <= HIGHPRIO, "chthreads.c, chThdSetPriority()")
chSysLock();
@ -211,7 +211,7 @@ void chThdTerminate(Thread *tp) {
* @param msg the thread exit code. The code can be retrieved by using
* \p chThdWait().
*/
void chThdExit(t_msg msg) {
void chThdExit(msg_t msg) {
chSysLock();
@ -235,8 +235,8 @@ void chThdExit(t_msg msg) {
* @note The function is available only if the \p CH_USE_WAITEXIT
* option is enabled in \p chconf.h.
*/
t_msg chThdWait(Thread *tp) {
t_msg msg;
msg_t chThdWait(Thread *tp) {
msg_t msg;
chSysLock();

3
src/include/ch.h
View File

@ -100,9 +100,6 @@
#ifndef TRUE
#define TRUE 1
#endif
#ifndef NULL
#define NULL 0
#endif
#ifdef __cplusplus
extern "C" {

8
src/include/debug.h
View File

@ -38,13 +38,13 @@
typedef struct {
void *cse_wtobjp;
t_time cse_time;
UWORD16 cse_state: 4;
UWORD16 cse_tid: 12;
systime_t cse_time;
uint16_t cse_state: 4;
uint16_t cse_tid: 12;
} CtxSwcEvent;
typedef struct {
t_size tb_size;
size_t tb_size;
CtxSwcEvent *tb_ptr;
CtxSwcEvent tb_buffer[TRACE_BUFFER_SIZE];
} TraceBuffer;

12
src/include/delta.h
View File

@ -28,7 +28,7 @@
#ifdef CH_USE_VIRTUAL_TIMERS
/** Virtual Timer callback function.*/
typedef void (*t_vtfunc)(void *);
typedef void (*vtfunc_t)(void *);
typedef struct VirtualTimer VirtualTimer;
@ -41,10 +41,10 @@ struct VirtualTimer {
/** Previous timer in the delta list.*/
VirtualTimer *vt_prev;
/** Time delta before timeout.*/
t_time vt_dtime;
systime_t vt_dtime;
/** Timer callback function pointer. The pointer is reset to zero after
the callback is invoked.*/
t_vtfunc vt_func;
vtfunc_t vt_func;
/** Timer callback function parameter.*/
void *vt_par;
};
@ -63,7 +63,7 @@ typedef struct {
/** Last timer in the list.*/
VirtualTimer *dl_prev;
/** Not used but it must be set to /p MAXDELTA.*/
t_time dl_dtime;
systime_t dl_dtime;
} DeltaList;
extern DeltaList dlist;
@ -74,7 +74,7 @@ extern DeltaList dlist;
\
--dlist.dl_next->vt_dtime; \
while (!(vtp = dlist.dl_next)->vt_dtime) { \
t_vtfunc fn = vtp->vt_func; \
vtfunc_t fn = vtp->vt_func; \
vtp->vt_func = 0; \
(vtp->vt_next->vt_prev = (VirtualTimer *)&dlist)->vt_next = vtp->vt_next; \
fn(vtp->vt_par); \
@ -91,7 +91,7 @@ extern DeltaList dlist;
extern "C" {
#endif
void chVTInit(void);
void chVTSetI(VirtualTimer *vtp, t_time time, t_vtfunc vtfunc, void *par);
void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par);
void chVTResetI(VirtualTimer *vtp);
#ifdef __cplusplus
}

18
src/include/events.h
View File

@ -41,7 +41,7 @@ struct EventListener {
/** Thread interested in the Event Source.*/
Thread *el_listener;
/** Event identifier associated by the thread to the Event Source.*/
t_eventid el_id;
eventid_t el_id;
};
/**
@ -74,22 +74,22 @@ typedef struct EventSource {
/** Event Handler callback function.*/
typedef void (*t_evhandler)(t_eventid);
typedef void (*evhandler_t)(eventid_t);
#ifdef __cplusplus
extern "C" {
#endif
void chEvtRegister(EventSource *esp, EventListener *elp, t_eventid eid);
void chEvtRegister(EventSource *esp, EventListener *elp, eventid_t eid);
void chEvtUnregister(EventSource *esp, EventListener *elp);
void chEvtClear(t_eventmask mask);
void chEvtClear(eventmask_t mask);
void chEvtSend(EventSource *esp);
void chEvtSendI(EventSource *esp);
t_eventid chEvtWait(t_eventmask ewmask,
const t_evhandler handlers[]);
eventid_t chEvtWait(eventmask_t ewmask,
const evhandler_t handlers[]);
#ifdef CH_USE_EVENTS_TIMEOUT
t_eventid chEvtWaitTimeout(t_eventmask ewmask,
const t_evhandler handlers[],
t_time time);
eventid_t chEvtWaitTimeout(eventmask_t ewmask,
const evhandler_t handlers[],
systime_t time);
#endif
#ifdef __cplusplus
}

14
src/include/messages.h
View File

@ -42,17 +42,13 @@
#ifdef __cplusplus
extern "C" {
#endif
t_msg chMsgSend(Thread *tp, t_msg msg);
t_msg chMsgWait(void);
t_msg chMsgGet(void);
void chMsgRelease(t_msg msg);
msg_t chMsgSend(Thread *tp, msg_t msg);
msg_t chMsgWait(void);
msg_t chMsgGet(void);
void chMsgRelease(msg_t msg);
#ifdef CH_USE_MESSAGES_EVENT
t_msg chMsgSendWithEvent(Thread *tp, t_msg msg, EventSource *esp);
#endif
#ifdef CH_USE_MESSAGES_TIMEOUT
t_msg chMsgSendTimeout(Thread *tp, t_msg msg, t_time time);
msg_t chMsgSendWithEvent(Thread *tp, msg_t msg, EventSource *esp);
#endif
#ifdef __cplusplus
}

4
src/include/mutexes.h
View File

@ -44,8 +44,8 @@ extern "C" {
void chMtxInit(Mutex *mp);
void chMtxLock(Mutex *mp);
void chMtxLockS(Mutex *mp);
t_bool chMtxTryLock(Mutex *mp);
t_bool chMtxTryLockS(Mutex *mp);
bool_t chMtxTryLock(Mutex *mp);
bool_t chMtxTryLockS(Mutex *mp);
void chMtxUnlock(void);
void chMtxUnlockS(void);
void chMtxUnlockAll(void);

36
src/include/queues.h
View File

@ -26,7 +26,7 @@
#define _QUEUES_H_
/** Queue notification callback type.*/
typedef void (*t_qnotify)(void);
typedef void (*qnotify_t)(void);
/** Returned by the queue functions if the operation is successful.*/
#define Q_OK RDY_OK
@ -56,7 +56,7 @@ typedef struct {
/** Counter semaphore.*/
Semaphore q_sem;
/** Data notification callback.*/
t_qnotify q_notify;
qnotify_t q_notify;
} Queue;
/** Returns the queue's buffer size.*/
@ -91,24 +91,24 @@ extern "C" {
* Input Queues functions. An Input Queue is usually written into by an
* interrupt handler and read from a thread.
*/
void chIQInit(Queue *qp, uint8_t *buffer, t_size size, t_qnotify inotify);
void chIQInit(Queue *qp, uint8_t *buffer, size_t size, qnotify_t inotify);
void chIQReset(Queue *qp);
t_msg chIQPutI(Queue *qp, uint8_t b);
t_msg chIQGet(Queue *qp);
t_size chIQRead(Queue *qp, uint8_t *buffer, t_size n);
msg_t chIQPutI(Queue *qp, uint8_t b);
msg_t chIQGet(Queue *qp);
size_t chIQRead(Queue *qp, uint8_t *buffer, size_t n);
#ifdef CH_USE_QUEUES_TIMEOUT
t_msg chIQGetTimeout(Queue *qp, t_time time);
msg_t chIQGetTimeout(Queue *qp, systime_t time);
#endif
/*
* Output Queues functions. An Output Queue is usually written into by a
* thread and read from an interrupt handler.
*/
void chOQInit(Queue *queue, uint8_t *buffer, t_size size, t_qnotify onotify);
void chOQInit(Queue *queue, uint8_t *buffer, size_t size, qnotify_t onotify);
void chOQReset(Queue *queue);
void chOQPut(Queue *queue, uint8_t b);
t_msg chOQGetI(Queue *queue);
t_size chOQWrite(Queue *queue, uint8_t *buffer, t_size n);
msg_t chOQGetI(Queue *queue);
size_t chOQWrite(Queue *queue, uint8_t *buffer, size_t n);
#ifdef __cplusplus
}
#endif
@ -132,9 +132,9 @@ typedef struct {
/** Output counter semaphore.*/
Semaphore hdq_osem;
/** Input data notification callback.*/
t_qnotify hdq_inotify;
qnotify_t hdq_inotify;
/** Output data notification callback.*/
t_qnotify hdq_onotify;
qnotify_t hdq_onotify;
} HalfDuplexQueue;
/** Returns the queue's buffer size.*/
@ -164,14 +164,14 @@ typedef struct {
#ifdef __cplusplus
extern "C" {
#endif
void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, t_size size,
t_qnotify inotify, t_qnotify onotify);
t_msg chHDQGetReceive(HalfDuplexQueue *qp);
void chHDQInit(HalfDuplexQueue *qp, uint8_t *buffer, size_t size,
qnotify_t inotify, qnotify_t onotify);
msg_t chHDQGetReceive(HalfDuplexQueue *qp);
void chHDQPutTransmit(HalfDuplexQueue *qp, uint8_t b);
t_msg chHDQGetTransmitI(HalfDuplexQueue *qp);
t_msg chHDQPutReceiveI(HalfDuplexQueue *qp, uint8_t b);
msg_t chHDQGetTransmitI(HalfDuplexQueue *qp);
msg_t chHDQPutReceiveI(HalfDuplexQueue *qp, uint8_t b);
#ifdef CH_USE_QUEUES_TIMEOUT
t_msg chHDQGetReceiveTimeout(HalfDuplexQueue *qp, t_time time);
msg_t chHDQGetReceiveTimeout(HalfDuplexQueue *qp, systime_t time);
#endif
#ifdef __cplusplus
}

16
src/include/scheduler.h
View File

@ -39,13 +39,13 @@
*/
typedef struct {
ThreadsQueue r_queue;
t_prio r_prio;
t_cnt r_preempt;
tprio_t r_prio;
cnt_t r_preempt;
#ifndef CH_CURRP_REGISTER_CACHE
Thread *r_current;
#endif
#ifdef CH_USE_SYSTEMTIME
volatile t_time r_stime;
volatile systime_t r_stime;
#endif
} ReadyList;
@ -58,13 +58,13 @@ extern ReadyList rlist;
extern "C" {
#endif
void chSchInit(void);
void chSchReadyI(Thread *tp, t_msg msg);
void chSchGoSleepS(t_tstate newstate);
t_msg chSchGoSleepTimeoutS(t_tstate newstate, t_time time);
void chSchWakeupS(Thread *tp, t_msg msg);
void chSchReadyI(Thread *tp, msg_t msg);
void chSchGoSleepS(tstate_t newstate);
msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time);
void chSchWakeupS(Thread *tp, msg_t msg);
void chSchDoRescheduleI(void);
void chSchRescheduleS(void);
t_bool chSchRescRequiredI(void);
bool_t chSchRescRequiredI(void);
#ifdef __cplusplus
}
#endif

16
src/include/semaphores.h
View File

@ -34,20 +34,20 @@ typedef struct {
/** Queue of the threads sleeping on this Semaphore.*/
ThreadsQueue s_queue;
/** The Semaphore counter.*/
t_cnt s_cnt;
cnt_t s_cnt;
} Semaphore;
#ifdef __cplusplus
extern "C" {
#endif
void chSemInit(Semaphore *sp, t_cnt n);
void chSemReset(Semaphore *sp, t_cnt n);
void chSemResetI(Semaphore *sp, t_cnt n);
t_msg chSemWait(Semaphore *sp);
t_msg chSemWaitS(Semaphore *sp);
void chSemInit(Semaphore *sp, cnt_t n);
void chSemReset(Semaphore *sp, cnt_t n);
void chSemResetI(Semaphore *sp, cnt_t n);
msg_t chSemWait(Semaphore *sp);
msg_t chSemWaitS(Semaphore *sp);
#ifdef CH_USE_SEMAPHORES_TIMEOUT
t_msg chSemWaitTimeout(Semaphore *sp, t_time time);
t_msg chSemWaitTimeoutS(Semaphore *sp, t_time time);
msg_t chSemWaitTimeout(Semaphore *sp, systime_t time);
msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time);
#endif
void chSemSignal(Semaphore *sp);
void chSemSignalI(Semaphore *sp);

26
src/include/serial.h
View File

@ -41,7 +41,7 @@
#define SD_BREAK_DETECTED 32
/** Serial Driver condition flags type.*/
typedef uint16_t t_dflags;
typedef uint16_t dflags_t;
#ifdef CH_USE_SERIAL_FULLDUPLEX
@ -66,7 +66,7 @@ typedef struct {
/** I/O driver status flags. This field should not be read directly but
* the \p chFDDGetAndClearFlags() funtion should be used instead.*/
t_dflags sd_flags;
dflags_t sd_flags;
/** Status Change \p EventSource. This event is generated when a
* condition flag was changed.*/
EventSource sd_sevent;
@ -76,12 +76,12 @@ typedef struct {
extern "C" {
#endif
void chFDDInit(FullDuplexDriver *sd,
uint8_t *ib, t_size isize, t_qnotify inotify,
uint8_t *ob, t_size osize, t_qnotify onotify);
uint8_t *ib, size_t isize, qnotify_t inotify,
uint8_t *ob, size_t osize, qnotify_t onotify);
void chFDDIncomingDataI(FullDuplexDriver *sd, uint8_t b);
t_msg chFDDRequestDataI(FullDuplexDriver *sd);
void chFDDAddFlagsI(FullDuplexDriver *sd, t_dflags mask);
t_dflags chFDDGetAndClearFlags(FullDuplexDriver *sd);
msg_t chFDDRequestDataI(FullDuplexDriver *sd);
void chFDDAddFlagsI(FullDuplexDriver *sd, dflags_t mask);
dflags_t chFDDGetAndClearFlags(FullDuplexDriver *sd);
#ifdef __cplusplus
}
#endif
@ -128,7 +128,7 @@ typedef struct {
/** I/O driver status flags. This field should not be read directly but
* the \p chHDDGetAndClearFlags() funtion should be used
* instead.*/
t_dflags sd_flags;
dflags_t sd_flags;
/** Status Change Event Source. This event is generated when a condition
* flag was changed.*/
EventSource sd_sevent;
@ -137,12 +137,12 @@ typedef struct {
#ifdef __cplusplus
extern "C" {
#endif
void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, t_size size,
t_qnotify inotify, t_qnotify onotify);
void chHDDInit(HalfDuplexDriver *sd, uint8_t *b, size_t size,
qnotify_t inotify, qnotify_t onotify);
void chHDDIncomingDataI(HalfDuplexDriver *sd, uint8_t b);
t_msg chHDDRequestDataI(HalfDuplexDriver *sd);
void chHDDAddFlagsI(HalfDuplexDriver *sd, t_dflags mask);
t_dflags chHDDGetAndClearFlags(HalfDuplexDriver *sd);
msg_t chHDDRequestDataI(HalfDuplexDriver *sd);
void chHDDAddFlagsI(HalfDuplexDriver *sd, dflags_t mask);
dflags_t chHDDGetAndClearFlags(HalfDuplexDriver *sd);
#ifdef __cplusplus
}
#endif

4
src/include/sleep.h
View File

@ -29,7 +29,7 @@
extern "C" {
#endif
#ifdef CH_USE_SLEEP
void chThdSleep(t_time time);
void chThdSleep(systime_t time);
#endif /* CH_USE_SLEEP */
#ifdef __cplusplus
}
@ -55,7 +55,7 @@ extern "C" {
#define chThdSleepUntil(t) { \
chSysLock(); \
chSchGoSleepTimeoutS(PRSLEEP, \
(t_time)((t) - chSysGetTime())) \
(systime_t)((t) - chSysGetTime())) \
chSysUnlock(); \
}
#endif /* CH_USE_SYSTEMTIME */

34
src/include/threads.h
View File

@ -39,14 +39,14 @@ struct Thread {
Thread *p_prev;
/* End of the fields shared with the ThreadsQueue structure. */
/** The thread priority.*/
t_prio p_prio;
tprio_t p_prio;
/* End of the fields shared with the ReadyList structure. */
/** Thread identifier. */
t_tid p_tid;
tid_t p_tid;
/** Current thread state.*/
t_tstate p_state;
tstate_t p_state;
/** Mode flags.*/
t_tmode p_flags;
tmode_t p_flags;
/** Machine dependent processor context.*/
Context p_ctx;
/*
@ -56,9 +56,9 @@ struct Thread {
*/
union {
/** Thread wakeup code (only valid when exiting the \p PRREADY state).*/
t_msg p_rdymsg;
msg_t p_rdymsg;
/** The thread exit code (only while in \p PREXIT state).*/
t_msg p_exitcode;
msg_t p_exitcode;
#ifdef CH_USE_SEMAPHORES
/** Semaphore where the thread is waiting on (only in \p PRWTSEM state).*/
Semaphore *p_wtsemp;
@ -73,7 +73,7 @@ struct Thread {
#endif
#ifdef CH_USE_EVENTS
/** Enabled events mask (only while in \p PRWTEVENT state).*/
t_eventmask p_ewmask;
eventmask_t p_ewmask;
#endif
#ifdef CH_USE_TRACE
/** Kernel object where the thread is waiting on. It is only valid when
@ -94,16 +94,16 @@ struct Thread {
#endif
#ifdef CH_USE_MESSAGES
ThreadsQueue p_msgqueue;
t_msg p_msg;
msg_t p_msg;
#endif
#ifdef CH_USE_EVENTS
/** Pending events mask.*/
t_eventmask p_epending;
eventmask_t p_epending;
#endif
#ifdef CH_USE_MUTEXES
/** Owner mutexes list, \p NULL terminated.*/
Mutex *p_mtxlist;
t_prio p_realprio;
tprio_t p_realprio;
#endif
};
@ -159,10 +159,10 @@ struct Thread {
#define ABSPRIO 255
/* Not an API, don't use into the application code.*/
void _InitThread(t_prio prio, t_tmode mode, Thread *tp);
void _InitThread(tprio_t prio, tmode_t mode, Thread *tp);
/** Thread function.*/
typedef t_msg (*t_tfunc)(void *);
typedef msg_t (*tfunc_t)(void *);
/*
* Threads APIs.
@ -170,10 +170,10 @@ typedef t_msg (*t_tfunc)(void *);
#ifdef __cplusplus
extern "C" {
#endif
Thread *chThdCreate(t_prio prio, t_tmode mode, void *workspace,
t_size wsize, t_tfunc pf, void *arg);
void chThdSetPriority(t_prio newprio);
void chThdExit(t_msg msg);
Thread *chThdCreate(tprio_t prio, tmode_t mode, void *workspace,
size_t wsize, tfunc_t pf, void *arg);
void chThdSetPriority(tprio_t newprio);
void chThdExit(msg_t msg);
#ifdef CH_USE_RESUME
void chThdResume(Thread *tp);
#endif
@ -184,7 +184,7 @@ extern "C" {
void chThdTerminate(Thread *tp);
#endif
#ifdef CH_USE_WAITEXIT
t_msg chThdWait(Thread *tp);
msg_t chThdWait(Thread *tp);
#endif
#ifdef __cplusplus
}

2
src/lib/evtimer.h
View File

@ -31,7 +31,7 @@
typedef struct {
VirtualTimer et_vt;
EventSource et_es;
t_time et_interval;
systime_t et_interval;
} EvTimer;
#ifdef __cplusplus

25
src/templates/chtypes.h
View File

@ -25,21 +25,24 @@
#ifndef _CHTYPES_H_
#define _CHTYPES_H_
#define __need_NULL
#define __need_size_t
#include <stddef.h>
#if !defined(_STDINT_H) && !defined(__STDINT_H_)
#include <stdint.h>
#endif
typedef int8_t bool_t;
typedef uint8_t t_tmode; /* Thread mode flags, BYTE8 is ok. */
typedef uint8_t t_tstate; /* Thread state, BYTE8 is ok. */
typedef uint16_t t_tid; /* Thread id. */
typedef uint32_t t_prio; /* Priority, use the fastest unsigned type. */
typedef int32_t t_msg; /* Message, use signed pointer equivalent.*/
typedef int32_t t_eventid; /* Event Id, use fastest signed.*/
typedef uint32_t t_eventmask;/* Event Mask, recommended fastest unsigned.*/
typedef uint32_t t_time; /* Time, recommended fastest unsigned.*/
typedef int32_t t_cnt; /* Counter, recommended fastest signed.*/
typedef uint32_t t_size; /* Size, use unsigned pointer equivalent.*/
typedef int8_t bool_t; /* Signed byte boolean. */
typedef uint8_t tmode_t; /* Thread mode flags, BYTE8 is ok. */
typedef uint8_t tstate_t; /* Thread state, BYTE8 is ok. */
typedef uint16_t tid_t; /* Thread id. */
typedef uint32_t tprio_t; /* Priority, use the fastest unsigned type. */
typedef int32_t msg_t; /* Message, use signed pointer equivalent.*/
typedef int32_t eventid_t; /* Event Id, use fastest signed.*/
typedef uint32_t eventmask_t;/* Event Mask, recommended fastest unsigned.*/
typedef uint32_t systime_t; /* System Time, recommended fastest unsigned.*/
typedef int32_t cnt_t; /* Counter, recommended fastest signed.*/
#define INLINE inline

52
test/test.c
View File

@ -79,9 +79,9 @@ static void println(char *msgp) {
}
__attribute__((noinline))
void CPU(t_time ms) {
void CPU(systime_t ms) {
t_time time = chSysGetTime() + ms;
systime_t time = chSysGetTime() + ms;
while (chSysGetTime() != time) {
#if defined(WIN32)
ChkIntSources();
@ -90,9 +90,9 @@ void CPU(t_time ms) {
}
__attribute__((noinline))
t_time wait_tick(void) {
systime_t wait_tick(void) {
t_time time = chSysGetTime() + 1;
systime_t time = chSysGetTime() + 1;
while (chSysGetTime() < time) {
#if defined(WIN32)
ChkIntSources();
@ -101,20 +101,20 @@ t_time wait_tick(void) {
return time;
}
t_msg Thread1(void *p) {
msg_t Thread1(void *p) {
chFDDPut(comp, *(uint8_t *)p);
return 0;
}
t_msg Thread2(void *p) {
msg_t Thread2(void *p) {
chSemWait(&sem1);
chFDDPut(comp, *(uint8_t *)p);
return 0;
}
t_msg Thread3(void *p) {
msg_t Thread3(void *p) {
chMtxLock(&m1);
chFDDPut(comp, *(uint8_t *)p);
@ -122,8 +122,8 @@ t_msg Thread3(void *p) {
return 0;
}
t_msg Thread4(void *p) {
t_msg msg;
msg_t Thread4(void *p) {
msg_t msg;
int i;
for (i = 0; i < 5; i++) {
@ -134,14 +134,14 @@ t_msg Thread4(void *p) {
return 0;
}
t_msg Thread6(void *p) {
msg_t Thread6(void *p) {
while (!chThdShouldTerminate())
chMsgRelease(chMsgWait() + 1);
return 0;
}
t_msg Thread7(void *p) {
msg_t Thread7(void *p) {
return (unsigned int)p + 1;
}
@ -215,7 +215,7 @@ void testmtx1(void) {
println("");
}
t_msg Thread8(void *p) {
msg_t Thread8(void *p) {
chThdSleep(5);
chMtxLock(&m1);
@ -224,7 +224,7 @@ t_msg Thread8(void *p) {
return 0;
}
t_msg Thread9(void *p) {
msg_t Thread9(void *p) {
chMtxLock(&m1);
chThdSleep(20);
@ -233,7 +233,7 @@ t_msg Thread9(void *p) {
return 0;
}
t_msg Thread10(void *p) {
msg_t Thread10(void *p) {
chThdSleep(10);
CPU(50);
@ -241,7 +241,7 @@ t_msg Thread10(void *p) {
return 0;
}
t_msg Thread11(void *p) {
msg_t Thread11(void *p) {
chThdSleep(5);
chSemWait(&sem1);
@ -250,7 +250,7 @@ t_msg Thread11(void *p) {
return 0;
}
t_msg Thread12(void *p) {
msg_t Thread12(void *p) {
chSemWait(&sem1);
chThdSleep(20);
@ -291,7 +291,7 @@ void testmtx3(void) {
println("");
}
t_msg Thread13(void *p) {
msg_t Thread13(void *p) {
chMtxLock(&m1);
CPU(50);
@ -300,7 +300,7 @@ t_msg Thread13(void *p) {
return 0;
}
t_msg Thread14(void *p) {
msg_t Thread14(void *p) {
chThdSleep(10);
chMtxLock(&m2);
@ -314,7 +314,7 @@ t_msg Thread14(void *p) {
return 0;
}
t_msg Thread15(void *p) {
msg_t Thread15(void *p) {
chThdSleep(20);
chMtxLock(&m2);
@ -324,7 +324,7 @@ t_msg Thread15(void *p) {
return 0;
}
t_msg Thread16(void *p) {
msg_t Thread16(void *p) {
chThdSleep(40);
CPU(200);
@ -332,7 +332,7 @@ t_msg Thread16(void *p) {
return 0;
}
t_msg Thread17(void *p) {
msg_t Thread17(void *p) {
chThdSleep(50);
chMtxLock(&m2);
@ -365,7 +365,7 @@ void testmtx4(void) {
}
void testmsg1(void) {
t_msg msg;
msg_t msg;
println("*** Messages, dispatch test, you should read AABBCCDDEE:");
t1 = chThdCreate(chThdGetPriority()-1, 0, wsT1, sizeof(wsT1), Thread4, chThdSelf());
@ -382,7 +382,7 @@ __attribute__((noinline))
unsigned int msg_loop_test(Thread *tp) {
unsigned int i;
t_time time = wait_tick() + 1000;
systime_t time = wait_tick() + 1000;
i = 0;
while (chSysGetTime() < time) {
i = chMsgSend(tp, i);
@ -461,7 +461,7 @@ chMsgSend(t1, 0);
__attribute__((noinline))
void bench4(void) {
unsigned int i;
t_time time;
systime_t time;
println("*** Kernel Benchmark, threads creation/termination:");
time = wait_tick() + 1000;
@ -483,7 +483,7 @@ void bench5(void) {
static uint8_t ib[16];
static Queue iq;
unsigned int i;
t_time time;
systime_t time;
println("*** Kernel Benchmark, I/O Queues throughput:");
chIQInit(&iq, ib, sizeof(ib), NULL);
@ -511,7 +511,7 @@ void bench5(void) {
/**
* Tester thread, this thread must be created with priority \p NORMALPRIO.
*/
t_msg TestThread(void *p) {
msg_t TestThread(void *p) {
comp = p;
println("*****************************");