void msgqueue_init(MsgQueue *que, tlsf_memory_heap_t *heap,
msg_t *mb_buf, const cnt_t mb_size)
{
chMBObjectInit(&que->mb, mb_buf, mb_size);
memset(mb_buf, 0, mb_size * sizeof(msg_t));
que->heap = heap;
}
int wconfInit(void)
{
thread_t *listener;
palSetPadMode(GPIOB, 10, PAL_MODE_ALTERNATE(7)); // used function : USART3_TX
palSetPadMode(GPIOB, 11, PAL_MODE_ALTERNATE(7)); // used function : USART3_RX
/* Start the serial driver(change it's state to ready) pointed by arg1 with configurations in arg2
* if arg2 is NULL then use default configuration in halconf.h*/
sdStart(&SD3, &uartCfg);
/*Initialize mailbox object pointed by arg1, which uses buffer pointed by arg2 and have
* arg3 objects*/
chMBObjectInit(&serialMbox, txMailboxArea, MAILBOXSIZE);
/* Create a thread uses arg2 of area arg1 with priority of
* arg3(LOWPRIO,NORMALPRIO,HIGHPRIO or any value between 0-255), thread function is arg4
*
* Returns pointer to thread object*/
listener = chThdCreateStatic(serialListen, sizeof(serialListen), LOWPRIO, rxListen, NULL);
chThdCreateStatic(serialTalk, sizeof(serialTalk), LOWPRIO, txWrite, NULL);
/*Wait until thread pointed in arg1 finish*/
//chThdWait(listener);
}
/**
* @brief Initializes the SensorReadDriver object.
* @note This in done explicitly in SensorsInit.
*
* @param[in] srdp Pointer to the SensorReadDriver object.
*
* @init
*/
void SensorReadObjectInit(SensorReadDriver *srdp)
{
srdp->state = SRD_UNINITIALIZED;
srdp->interrupt_sensor_ptr = NULL;
srdp->polled_sensor_ptr = NULL;
srdp->interrupt_sensor_cnt = 0;
srdp->polled_sensor_cnt = 0;
chMBObjectInit(&srdp->srd_mailbox, srdp->messages, SRD_MAILBOX_SIZE);
#if SRD_DEBUG
SRD1.dbg_mailbox_overflow = false;
#endif
}
err_t sys_mbox_new(sys_mbox_t *mbox, int size) {
*mbox = chHeapAlloc(NULL, sizeof(mailbox_t) + sizeof(msg_t) * size);
if (*mbox == 0) {
SYS_STATS_INC(mbox.err);
return ERR_MEM;
}
else {
chMBObjectInit(*mbox, (void *)(((uint8_t *)*mbox) + sizeof(mailbox_t)), size);
SYS_STATS_INC(mbox.used);
return ERR_OK;
}
}
/**
* @brief Initialize the Data Link Layer object.
* @details The function starts the DataLinkLayer serial driver
* - Check the actual state of the driver
* - Configure and start the sdSerial driver
* - Init the mutex variable used by the 'DLLSendSingleFrameSerial' function
* - Init the mailboxes which are work like a buffer
* - Creates a SyncFrame
* - Starts the 'SDReceiving' and 'SDSending' threads which are provide
* the whole DLL functionality
* - Set the DLL state to ACTIVE
*
* @param[in] dllp DataLinkLayer driver structure
* @param[in] config The config contains the speed and the ID of the serial driver
*/
void DLLStart(DLLDriver *dllp, DLLSerialConfig *config){
osalDbgCheck((dllp != NULL) && (config != NULL));
osalDbgAssert((dllp->state == DLL_UNINIT) || (dllp->state == DLL_ACTIVE),
"DLLInit(), invalid state");
dllp->config = config;
SerialDCfg.speed = dllp->config->baudrate; //Set the data rate to the given rate
sdStart(dllp->config->SDriver, &SerialDCfg); //Start the serial driver for the ESP8266
chMtxObjectInit(&dllp->DLLSerialSendMutex);
chMBObjectInit(&dllp->DLLBuffers.DLLFilledOutputBuffer,
dllp->DLLBuffers.DLLFilledOutputBufferQueue, OUTPUT_FRAME_BUFFER);
chMBObjectInit(&dllp->DLLBuffers.DLLFreeOutputBuffer,
dllp->DLLBuffers.DLLFreeOutputBufferQueue, OUTPUT_FRAME_BUFFER);
int i;
for (i = 0; i < OUTPUT_FRAME_BUFFER; i++)
(void)chMBPost(&dllp->DLLBuffers.DLLFreeOutputBuffer,
(msg_t)&dllp->DLLBuffers.DLLOutputBuffer[i], TIME_INFINITE);
DLLCreateSyncFrame(dllp);
dllp->SendingThread = chThdCreateFromHeap(NULL, THD_WORKING_AREA_SIZE(128), NORMALPRIO+1, SDSending, (void *)dllp);
if (dllp->SendingThread == NULL)
chSysHalt("DualFramework: Starting 'SendingThread' failed - out of memory");
dllp->ReceivingThread = chThdCreateFromHeap(NULL, THD_WORKING_AREA_SIZE(128), NORMALPRIO+1, SDReceiving, (void *)dllp);
if (dllp->ReceivingThread == NULL)
chSysHalt("DualFramework: Starting 'ReceivingThread' failed - out of memory");
dllp->state = DLL_ACTIVE;
}
/**
* @brief Create a message queue.
* @note The queue is not really created because it is allocated statically,
* this function just re-initializes it.
*/
osMessageQId osMessageCreate(const osMessageQDef_t *queue_def,
osThreadId thread_id) {
/* Ignoring this parameter for now.*/
(void)thread_id;
if (queue_def->item_sz > sizeof (msg_t))
return NULL;
chMBObjectInit(queue_def->mailbox,
queue_def->items,
(size_t)queue_def->queue_sz);
return osOK;
}
/**
* @brief Creates a dynamic mailbox object.
* @post A reference to the dynamic mailbox object is returned and the
* reference counter is initialized to one.
* @post The dynamic mailbox object is initialized and ready to use.
*
* @param[in] name name to be assigned to the new dynamic mailbox object
* @param[in] n mailbox buffer size as number of messages
*
* @return The reference to the created dynamic mailbox object.
* @retval NULL if the dynamic mailbox object cannot be allocated or
* a dynamic mailbox object with the same name exists.
*
* @api
*/
dyn_mailbox_t *chFactoryCreateMailbox(const char *name, size_t n) {
dyn_mailbox_t *dmp;
F_LOCK();
dmp = (dyn_mailbox_t *)dyn_create_object_heap(name,
&ch_factory.mbx_list,
sizeof (dyn_mailbox_t) +
(n * sizeof (msg_t)));
if (dmp != NULL) {
/* Initializing mailbox object data.*/
chMBObjectInit(&dmp->mbx, dmp->msgbuf, n);
}
F_UNLOCK();
return dmp;
}
/*
* Application entry point.
*/
int main(void) {
unsigned i;
gptcnt_t interval, threshold, worst;
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Prepares the Serial driver 2 and GPT drivers 2 and 3.
*/
sdStart(&SD2, NULL); /* Default is 38400-8-N-1.*/
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
gptStart(&GPTD4, &gpt4cfg);
gptStart(&GPTD3, &gpt3cfg);
/*
* Initializes the mailboxes and creates the worker threads.
*/
for (i = 0; i < NUM_THREADS; i++) {
chMBObjectInit(&mb[i], b[i], MAILBOX_SIZE);
chThdCreateStatic(waWorkerThread[i], sizeof waWorkerThread[i],
NORMALPRIO - 20, WorkerThread, (void *)i);
}
/*
* Test procedure.
*/
println("");
println("*** ChibiOS/RT IRQ-STORM long duration test");
println("***");
print("*** Kernel: ");
println(CH_KERNEL_VERSION);
print("*** Compiled: ");
println(__DATE__ " - " __TIME__);
#ifdef PORT_COMPILER_NAME
print("*** Compiler: ");
println(PORT_COMPILER_NAME);
#endif
print("*** Architecture: ");
println(PORT_ARCHITECTURE_NAME);
#ifdef PORT_CORE_VARIANT_NAME
print("*** Core Variant: ");
println(PORT_CORE_VARIANT_NAME);
#endif
#ifdef PORT_INFO
print("*** Port Info: ");
println(PORT_INFO);
#endif
#ifdef PLATFORM_NAME
print("*** Platform: ");
println(PLATFORM_NAME);
#endif
#ifdef BOARD_NAME
print("*** Test Board: ");
println(BOARD_NAME);
#endif
println("***");
print("*** System Clock: ");
printn(STM32_SYSCLK);
println("");
print("*** Iterations: ");
printn(ITERATIONS);
println("");
print("*** Randomize: ");
printn(RANDOMIZE);
println("");
print("*** Threads: ");
printn(NUM_THREADS);
println("");
print("*** Mailbox size: ");
printn(MAILBOX_SIZE);
println("");
println("");
worst = 0;
for (i = 1; i <= ITERATIONS; i++){
print("Iteration ");
printn(i);
println("");
saturated = FALSE;
threshold = 0;
for (interval = 2000;
interval >= 2;
interval -= (interval + 9) / 10) {
gptStartContinuous(&GPTD4, interval - 1); /* Slightly out of phase.*/
gptStartContinuous(&GPTD3, interval + 1); /* Slightly out of phase.*/
chThdSleepMilliseconds(1000);
gptStopTimer(&GPTD4);
gptStopTimer(&GPTD3);
if (!saturated)
print(".");
else {
print("#");
if (threshold == 0)
threshold = interval;
break;
}
}
/* Gives the worker threads a chance to empty the mailboxes before next
cycle.*/
chThdSleepMilliseconds(20);
println("");
print("Saturated at ");
printn(threshold);
println(" uS");
println("");
if (threshold > worst)
worst = threshold;
}
gptStopTimer(&GPTD4);
gptStopTimer(&GPTD3);
print("Worst case at ");
printn(worst);
println(" uS");
println("");
println("Test Complete");
/*
* Normal main() thread activity, nothing in this test.
*/
while (TRUE) {
chThdSleepMilliseconds(5000);
}
}
static void mbox1_setup(void) {
chMBObjectInit(&mb1, (msg_t *)test.wa.T0, MB_SIZE);
}
/**
* @brief IRQ storm execution.
*
* @param[in] cfg pointer to the test configuration structure
*
* @api
*/
void irq_storm_execute(const irq_storm_config_t *cfg) {
unsigned i;
gptcnt_t interval, threshold, worst;
/* Global configuration pointer.*/
config = cfg;
/* Starting timers using the stored configurations.*/
gptStart(cfg->gpt1p, cfg->gptcfg1p);
gptStart(cfg->gpt2p, cfg->gptcfg2p);
/*
* Initializes the mailboxes and creates the worker threads.
*/
for (i = 0; i < IRQ_STORM_CFG_NUM_THREADS; i++) {
chMBObjectInit(&mb[i], b[i], IRQ_STORM_CFG_MAILBOX_SIZE);
threads[i] = chThdCreateStatic(irq_storm_thread_wa[i],
sizeof irq_storm_thread_wa[i],
IRQ_STORM_CFG_THREADS_PRIORITY,
irq_storm_thread,
(void *)i);
}
/* Printing environment information.*/
chprintf(cfg->out, "");
chprintf(cfg->out, "\r\n*** ChibiOS/RT IRQ-STORM long duration test\r\n***\r\n");
chprintf(cfg->out, "*** Kernel: %s\r\n", CH_KERNEL_VERSION);
chprintf(cfg->out, "*** Compiled: %s\r\n", __DATE__ " - " __TIME__);
#ifdef PORT_COMPILER_NAME
chprintf(cfg->out, "*** Compiler: %s\r\n", PORT_COMPILER_NAME);
#endif
chprintf(cfg->out, "*** Architecture: %s\r\n", PORT_ARCHITECTURE_NAME);
#ifdef PORT_CORE_VARIANT_NAME
chprintf(cfg->out, "*** Core Variant: %s\r\n", PORT_CORE_VARIANT_NAME);
#endif
chprintf(cfg->out, "*** System Clock: %d\r\n", cfg->sysclk);
#ifdef PORT_INFO
chprintf(cfg->out, "*** Port Info: %s\r\n", PORT_INFO);
#endif
#ifdef PLATFORM_NAME
chprintf(cfg->out, "*** Platform: %s\r\n", PLATFORM_NAME);
#endif
#ifdef BOARD_NAME
chprintf(cfg->out, "*** Test Board: %s\r\n", BOARD_NAME);
#endif
chprintf(cfg->out, "***\r\n");
chprintf(cfg->out, "*** Iterations: %d\r\n", IRQ_STORM_CFG_ITERATIONS);
chprintf(cfg->out, "*** Randomize: %d\r\n", IRQ_STORM_CFG_RANDOMIZE);
chprintf(cfg->out, "*** Threads: %d\r\n", IRQ_STORM_CFG_NUM_THREADS);
chprintf(cfg->out, "*** Mailbox size: %d\r\n\r\n", IRQ_STORM_CFG_MAILBOX_SIZE);
/* Test loop.*/
worst = 0;
for (i = 1; i <= IRQ_STORM_CFG_ITERATIONS; i++){
chprintf(cfg->out, "Iteration %d\r\n", i);
saturated = false;
threshold = 0;
/* Timer intervals starting at 2mS then decreased by 10% after each
cycle.*/
for (interval = 2000; interval >= 2; interval -= (interval + 9) / 10) {
/* Timers programmed slightly out of phase each other.*/
gptStartContinuous(cfg->gpt1p, interval - 1); /* Slightly out of phase.*/
gptStartContinuous(cfg->gpt2p, interval + 1); /* Slightly out of phase.*/
/* Storming for one second.*/
chThdSleepMilliseconds(1000);
/* Timers stopped.*/
gptStopTimer(cfg->gpt1p);
gptStopTimer(cfg->gpt2p);
/* Did the storm saturate the threads chain?*/
if (!saturated)
chprintf(cfg->out, ".");
else {
chprintf(cfg->out, "#");
if (threshold == 0)
threshold = interval;
break;
}
}
/* Gives threads a chance to empty the mailboxes before next cycle.*/
chThdSleepMilliseconds(20);
chprintf(cfg->out, "\r\nSaturated at %d uS\r\n\r\n", threshold);
if (threshold > worst)
worst = threshold;
}
gptStopTimer(cfg->gpt1p);
gptStopTimer(cfg->gpt2p);
chprintf(cfg->out, "Worst case at %d uS\r\n", worst);
chprintf(cfg->out, "\r\nTest Complete\r\n");
/* Terminating threads and cleaning up.*/
for (i = 0; i < IRQ_STORM_CFG_NUM_THREADS; i++) {
chThdTerminate(threads[i]);
chThdWait(threads[i]);
threads[i] = NULL;
}
}
static void test_008_001_setup(void) {
chMBObjectInit(&mb1, mb_buffer, MB_SIZE);
}
