/**
* @brief Sends the current thread sleeping and sets a reference variable.
* @note This function must reschedule, it can only be called from thread
* context.
*
* @param[in] trp a pointer to a thread reference object
* @return The wake up message.
*
* @sclass
*/
msg_t chThdSuspendS(thread_reference_t *trp) {
thread_t *tp = chThdGetSelfX();
chDbgAssert(*trp == NULL, "not NULL");
*trp = tp;
tp->p_u.wtobjp = &trp;
chSchGoSleepS(CH_STATE_SUSPENDED);
return chThdGetSelfX()->p_u.rdymsg;
}
/**
* @brief CPU pulse.
* @note The current implementation is not totally reliable.
*
* @param[in] duration CPU pulse duration in milliseconds
*/
void test_cpu_pulse(unsigned duration) {
systime_t start, end, now;
start = chThdGetTicksX(chThdGetSelfX());
end = start + MS2ST(duration);
do {
now = chThdGetTicksX(chThdGetSelfX());
#if defined(SIMULATOR)
_sim_check_for_interrupts();
#endif
}
while (chVTIsTimeWithinX(now, start, end));
}
/**
* @brief CPU pulse.
* @note The current implementation is not totally reliable.
*
* @param[in] duration CPU pulse duration in milliseconds
*/
void test_cpu_pulse(unsigned duration) {
systime_t start, end, now;
start = chThdGetTicksX(chThdGetSelfX());
end = start + MS2ST(duration);
do {
now = chThdGetTicksX(chThdGetSelfX());
#if defined(SIMULATOR)
_sim_check_for_interrupts();
#endif
}
while (end > start ? (now >= start) && (now < end) :
(now >= start) || (now < end));
}
static void test_002_005_execute(void) {
systime_t time;
eventmask_t events;
/* A set of event flags are set on the current thread then the
function chVTGetSystemTimeX() is invoked, the function is supposed to
return immediately because the event flags are already pending,
after return the events mask is tested.*/
test_set_step(1);
{
time = chVTGetSystemTimeX();
chEvtSignalI(chThdGetSelfX(), 0x55);
events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));
test_assert((eventmask_t)0 != events,
"timed out");
test_assert((eventmask_t)0x55 == events,
"wrong events mask");
}
/* The pending event flags mask is cleared then the function
chVTGetSystemTimeX() is invoked, after return the events
mask is tested. The thread is signaled by another thread.*/
test_set_step(2);
{
time = chVTGetSystemTimeX();
chThdGetSelfX()->epmask = 0;
events = chEvtWaitAnyTimeout(ALL_EVENTS, MS2ST(1000));
test_assert((eventmask_t)0 != events,
"timed out");
test_assert((eventmask_t)0x55 == events,
"wrong events mask");
}
/* The function chVTGetSystemTimeX() is invoked, no event can
wakeup the thread, the function must return because timeout.*/
test_set_step(3);
{
chSysLock();
time = chVTGetSystemTimeX();
events = chEvtWaitAnyTimeoutS(0, MS2ST(1000));
chSysUnlock();
test_assert_time_window(time + MS2ST(1000),
time + MS2ST(1000) + 1,
"out of time window");
test_assert((eventmask_t)0 == events,
"wrong events mask");
}
}
static THD_FUNCTION(detect_thread, arg) {
(void)arg;
chRegSetThreadName("Detect");
detect_tp = chThdGetSelfX();
for(;;) {
chEvtWaitAny((eventmask_t) 1);
if (!conf_general_detect_motor_param(detect_current, detect_min_rpm,
detect_low_duty, &detect_cycle_int_limit, &detect_coupling_k,
detect_hall_table, &detect_hall_res)) {
detect_cycle_int_limit = 0.0;
detect_coupling_k = 0.0;
}
int32_t ind = 0;
send_buffer[ind++] = COMM_DETECT_MOTOR_PARAM;
buffer_append_int32(send_buffer, (int32_t)(detect_cycle_int_limit * 1000.0), &ind);
buffer_append_int32(send_buffer, (int32_t)(detect_coupling_k * 1000.0), &ind);
memcpy(send_buffer + ind, detect_hall_table, 8);
ind += 8;
send_buffer[ind++] = detect_hall_res;
commands_send_packet(send_buffer, ind);
}
}
void doSlowAdc(void) {
efiAssertVoid(CUSTOM_ERR_6658, getRemainingStack(chThdGetSelfX())> 32, "lwStAdcSlow");
#if EFI_INTERNAL_ADC
/* Starts an asynchronous ADC conversion operation, the conversion
will be executed in parallel to the current PWM cycle and will
terminate before the next PWM cycle.*/
slowAdc.conversionCount++;
chSysLockFromISR()
;
if (ADC_SLOW_DEVICE.state != ADC_READY &&
ADC_SLOW_DEVICE.state != ADC_COMPLETE &&
ADC_SLOW_DEVICE.state != ADC_ERROR) {
// todo: why and when does this happen? firmwareError(OBD_PCM_Processor_Fault, "ADC slow not ready?");
slowAdc.errorsCount++;
chSysUnlockFromISR()
;
return;
}
adcStartConversionI(&ADC_SLOW_DEVICE, &adcgrpcfgSlow, slowAdc.samples, ADC_BUF_DEPTH_SLOW);
chSysUnlockFromISR()
;
#endif /* EFI_INTERNAL_ADC */
}
static THD_FUNCTION(txWrite, arg)
{
(void)(arg);
while(!0){
chSysLock();
tp_W = chThdGetSelfX();
chSchGoSleepS(CH_STATE_SUSPENDED);
chSysUnlock();
sdWrite(&SD3, &temda, strlen(temda));
/* Get contents of next mail in mailbox pointed by arg1 to arg2
* and wait mail arg3 mSeconds if there is no message is present.
*
* Returns MSG_OK if succesfully a mail fetched from mailbox*/
//if(chMBFetch(&serialMbox, (msg_t *)&toSend, TIME_INFINITE) == MSG_OK)
// {
/* Write arg3 bytes from arg2 to device pointed by arg1(SD3 for this example).
* Type of arg2 should be (uint8_t *) otherwise only first 8 bit will be send.*/
// sdWrite(&SD3, &toSend,1);
//}
//wifiInit();
chThdSleepMilliseconds(1000);
}
}
static void test_006_001_execute(void) {
thread_t *tp;
msg_t msg;
/* [6.1.1] Starting the messenger thread.*/
test_set_step(1);
{
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1,
msg_thread1, chThdGetSelfX());
}
/* [6.1.2] Waiting for four messages then testing the receive
order.*/
test_set_step(2);
{
unsigned i;
for (i = 0; i < 4; i++) {
tp = chMsgWait();
msg = chMsgGet(tp);
chMsgRelease(tp, msg);
test_emit_token(msg);
}
test_wait_threads();
test_assert_sequence("ABCD", "invalid sequence");
}
}
static void pwmpcb_fast(PWMDriver *pwmp) {
efiAssertVoid(CUSTOM_ERR_6659, getRemainingStack(chThdGetSelfX())> 32, "lwStAdcFast");
#if EFI_INTERNAL_ADC
(void) pwmp;
/*
* Starts an asynchronous ADC conversion operation, the conversion
* will be executed in parallel to the current PWM cycle and will
* terminate before the next PWM cycle.
*/
chSysLockFromISR()
;
if (ADC_FAST_DEVICE.state != ADC_READY &&
ADC_FAST_DEVICE.state != ADC_COMPLETE &&
ADC_FAST_DEVICE.state != ADC_ERROR) {
fastAdc.errorsCount++;
// todo: when? why? firmwareError(OBD_PCM_Processor_Fault, "ADC fast not ready?");
chSysUnlockFromISR()
;
return;
}
adcStartConversionI(&ADC_FAST_DEVICE, &adcgrpcfg_fast, fastAdc.samples, ADC_BUF_DEPTH_FAST);
chSysUnlockFromISR()
;
fastAdc.conversionCount++;
#endif /* EFI_INTERNAL_ADC */
}
/**
* This method is not in the adc* lower-level file because it is more business logic then hardware.
*/
void adc_callback_fast(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
(void) buffer;
(void) n;
/**
* Note, only in the ADC_COMPLETE state because the ADC driver fires an
* intermediate callback when the buffer is half full.
* */
if (adcp->state == ADC_COMPLETE) {
/**
* this callback is executed 10 000 times a second, it needs to be as fast as possible
*/
efiAssertVoid(CUSTOM_ERR_6676, getRemainingStack(chThdGetSelfX()) > 128, "lowstck#9b");
#if EFI_MAP_AVERAGING
mapAveragingAdcCallback(fastAdc.samples[fastMapSampleIndex]);
#endif /* EFI_MAP_AVERAGING */
#if EFI_HIP_9011 || defined(__DOXYGEN__)
if (CONFIGB(isHip9011Enabled)) {
hipAdcCallback(fastAdc.samples[hipSampleIndex]);
}
#endif
// if (tpsSampleIndex != TPS_IS_SLOW) {
// tpsFastAdc = fastAdc.samples[tpsSampleIndex];
// }
}
}
void runConsoleLoop(ts_channel_s *console) {
if (boardConfiguration->startConsoleInBinaryMode) {
// switch to binary protocol
consoleInBinaryMode = true;
runBinaryProtocolLoop(console, true);
}
while (true) {
efiAssertVoid(getRemainingStack(chThdGetSelfX()) > 256, "lowstck#9e");
bool end = getConsoleLine((BaseSequentialStream*) console->channel, console->crcReadBuffer, sizeof(console->crcReadBuffer) - 3);
if (end) {
// firmware simulator is the only case when this happens
continue;
}
char *trimmed = efiTrim(console->crcReadBuffer);
(console_line_callback)(trimmed);
if (consoleInBinaryMode) {
#if EFI_SIMULATOR || defined(__DOXYGEN__)
logMsg("Switching to binary mode\r\n");
#endif
// switch to binary protocol
runBinaryProtocolLoop(console, true);
}
}
}
msg_t ThreadReference::suspendS(void) {
chDbgAssert(thread_ref == NULL,
"already referenced");
thread_ref = chThdGetSelfX();
chSchGoSleepS(CH_STATE_SUSPENDED);
return thread_ref->p_u.rdymsg;
}
static THD_FUNCTION(thEDisplay, arg)
{
(void)arg;
chRegSetThreadName("eDisplay");
kbb_display.header.preamble = KBB_PREAMBLE;
kbb_display.header.msg_class = KBB_CLASS_EXTERNAL;
kbb_display.header.msg_subclass = KBB_SUBCLASS_EXTERNAL_01;
kbb_display.header.msg_size = KBB_DISPLAY_SIZE;
while( !chThdShouldTerminateX() )
{
chSysLock();
eDisplayThreadForSleep = chThdGetSelfX();
chSchGoSleepS(CH_STATE_SUSPENDED);
chSysUnlock();
if ( !ed_serialPort )
continue;
if ( ed_serialPort == &Serial1 )
if ( kbse_getBaudSerial1() < 115200 )
continue;
if ( ed_serialPort == &Serial2 )
if ( kbse_getBaudSerial2() < 115200 )
continue;
const kbb_current_msg_t * msg = kbw_getCurrentMsg();
memcpy(&kbb_display.ltc_frame, &msg->ltc_frame, sizeof(kbb_display.ltc_frame));
memcpy(&kbb_display.smpte_time, &msg->smpte_time, sizeof(kbb_display.smpte_time));
kbb_display.ecef[0] = msg->nav_sol.ecefX;
kbb_display.ecef[1] = msg->nav_sol.ecefY;
kbb_display.ecef[2] = msg->nav_sol.ecefZ;
memcpy(&kbb_display.vnav, &msg->vnav, sizeof(kbb_display.vnav));
kbb_display.temperature = msg->temperature;
int32_t * i32buf = (int32_t*)kbb_display.__pad;
i32buf[0] = AA;
i32buf[1] = BB;
i32buf[2] = CC;
uint8_t * buf = (uint8_t*) &kbb_display;
kbb_display.header.checksum = calc_checksum_16(buf+KBB_CHECKSUM_START,
KBB_DISPLAY_SIZE-KBB_CHECKSUM_START);
// display!!!
int size_written = sdWrite(ed_serialPort, buf, KBB_DISPLAY_SIZE);
if ( size_written != KBB_DISPLAY_SIZE )
{
kbg_toggleLED3();
ASSERT(size_written==KBB_DISPLAY_SIZE,"thEDisplay", "Wrong sent data!!");
}
}
return;
}
void AP_IOMCU_FW::init()
{
thread_ctx = chThdGetSelfX();
if (palReadLine(HAL_GPIO_PIN_IO_HW_DETECT1) == 1 && palReadLine(HAL_GPIO_PIN_IO_HW_DETECT2) == 0) {
has_heater = true;
}
adc_init();
sbus_out_init();
}
static msg_t Thread2(void *arg) {
BaseSequentialStream *serp = (BaseSequentialStream *) &SD1;
thread2 = chThdGetSelfX();
while (TRUE) {
chEvtWaitAny((eventmask_t) 1);
chprintf(serp, "OVERFLOW\r\n");
chEvtSignal(thread_main, (eventmask_t) 2);
}
return 0;
}
/**
* @brief Sends the current thread sleeping and sets a reference variable.
* @note This function must reschedule, it can only be called from thread
* context.
*
* @param[in] trp a pointer to a thread reference object
* @param[in] timeout the timeout in system ticks, the special values are
* handled as follow:
* - @a TIME_INFINITE the thread enters an infinite sleep
* state.
* - @a TIME_IMMEDIATE the thread is not enqueued and
* the function returns @p MSG_TIMEOUT as if a timeout
* occurred.
* .
* @return The wake up message.
* @retval MSG_TIMEOUT if the operation timed out.
*
* @sclass
*/
msg_t chThdSuspendTimeoutS(thread_reference_t *trp, systime_t timeout) {
thread_t *tp = chThdGetSelfX();
chDbgAssert(*trp == NULL, "not NULL");
if (TIME_IMMEDIATE == timeout)
return MSG_TIMEOUT;
*trp = tp;
tp->p_u.wtobjp = &trp;
return chSchGoSleepTimeoutS(CH_STATE_SUSPENDED, timeout);
}
int main(void) {
halInit();
static ICUConfig icu3cfg = {
ICU_INPUT_ACTIVE_HIGH,
0, /* bogus frequency */
width_cb,
period_cb,
overflow_cb,
};
palSetPadMode(IOPORT2, LED, PAL_MODE_OUTPUT_PUSHPULL);
palSetPadMode(IOPORT4, 4, PAL_MODE_OUTPUT_PUSHPULL);
palClearPad(IOPORT2, LED);
palClearPad(IOPORT4, 4);
sdStart(&SD1, NULL);
icuStart(&ICUD3, &icu3cfg);
chSysInit();
thread_main = chThdGetSelfX();
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, NULL);
while (1) {
BaseSequentialStream *serp = (BaseSequentialStream *) &SD1;
chprintf(serp, "Testing 50 duty cycle\r\n");
icuEnable(&ICUD3);
output_single_cycle(500, 500);
icuDisable(&ICUD3);
chEvtWaitAny((eventmask_t) 3);
chprintf(serp, "Testing 25 duty cycle\r\n");
icuEnable(&ICUD3);
output_single_cycle(250, 750);
icuDisable(&ICUD3);
chEvtWaitAny((eventmask_t) 3);
chprintf(serp, "Testing 75 duty cycle\r\n");
icuEnable(&ICUD3);
output_single_cycle(750, 250);
icuDisable(&ICUD3);
chEvtWaitAny((eventmask_t) 3);
chprintf(serp, "Testing overflow\r\n");
icuEnable(&ICUD3);
chEvtWaitAny((eventmask_t) 3);
icuDisable(&ICUD3);
}
}
static msg_t Thread1(void *arg) {
BaseSequentialStream *serp = (BaseSequentialStream *) &SD1;
thread1 = chThdGetSelfX();
while (TRUE) {
chEvtWaitAny((eventmask_t) 1);
chprintf(serp, "WIDTH[%lu ms, %u ticks] PERIOD[%lu ms, %u ticks]\r\n",
((uint32_t) width * 1000) / ICU_CLK,
width,
((uint32_t) period * 1000) / ICU_CLK,
period);
chEvtSignal(thread_main, (eventmask_t) 1);
}
return 0;
}
msg_t ThreadReference::suspend(void) {
msg_t msg;
chSysLock();
chDbgAssert(thread_ref != NULL,
"already referenced");
thread_ref = chThdGetSelfX();
chSchGoSleepS(CH_STATE_SUSPENDED);
msg = thread_ref->p_u.rdymsg;
chSysUnlock();
return msg;
}
void _gosInit(void)
{
#if !GFX_NO_OS_INIT
/* Don't Initialize if the user already has */
#if CH_KERNEL_MAJOR == 2
if (!chThdSelf()) {
halInit();
chSysInit();
}
#elif CH_KERNEL_MAJOR == 3
if (!chThdGetSelfX()) {
halInit();
chSysInit();
}
#endif
#else
#warning "GOS: Operating System initialization has been turned off. Make sure you call halInit() and chSysInit() before gfxInit() in your application!"
#endif
}
static THD_FUNCTION(serial_process_thread, arg) {
(void)arg;
chRegSetThreadName("USB-Serial process");
process_tp = chThdGetSelfX();
for(;;) {
chEvtWaitAny((eventmask_t) 1);
while (serial_rx_read_pos != serial_rx_write_pos) {
packet_process_byte(serial_rx_buffer[serial_rx_read_pos++], PACKET_HANDLER);
if (serial_rx_read_pos == SERIAL_RX_BUFFER_SIZE) {
serial_rx_read_pos = 0;
}
}
}
}
static THD_FUNCTION(tx_thread, arg) {
(void)arg;
chRegSetThreadName("CC2520 Tx");
tx_tp = chThdGetSelfX();
for(;;) {
chEvtWaitAny((eventmask_t) 1);
while(tx_slot_read != tx_slot_write) {
basicRfSendPacket(CC2520_DEST_ADDRESS, tx_buffer[tx_slot_read], tx_slot_len[tx_slot_read]);
led_toggle(LED_GREEN);
tx_slot_read++;
if (tx_slot_read >= TX_BUFFER_SLOTS) {
tx_slot_read = 0;
}
}
}
}
void sr5WriteData(ts_channel_s *tsChannel, const uint8_t * buffer, int size) {
efiAssertVoid(CUSTOM_ERR_6570, getRemainingStack(chThdGetSelfX()) > 64, "tunerStudioWriteData");
#if EFI_SIMULATOR || defined(__DOXYGEN__)
logMsg("chSequentialStreamWrite [%d]\r\n", size);
#endif
#if TS_UART_DMA_MODE && EFI_PROD_CODE
UNUSED(tsChannel);
int transferred = size;
uartSendTimeout(TS_DMA_UART_DEVICE, (size_t *)&transferred, buffer, BINARY_IO_TIMEOUT);
#else
if (tsChannel->channel == NULL)
return;
// int transferred = chnWriteTimeout(tsChannel->channel, buffer, size, BINARY_IO_TIMEOUT);
// temporary attempt to work around #553
// instead of one huge packet let's try sending a few smaller packets
int transferred = 0;
int stillToTransfer = size;
while (stillToTransfer > 0) {
int thisTransferSize = minI(stillToTransfer, 768);
transferred += chnWriteTimeout(tsChannel->channel, buffer, thisTransferSize, BINARY_IO_TIMEOUT);
buffer += thisTransferSize;
stillToTransfer -= thisTransferSize;
}
#endif
#if EFI_SIMULATOR || defined(__DOXYGEN__)
logMsg("transferred [%d]\r\n", transferred);
#endif
if (transferred != size) {
#if EFI_SIMULATOR || defined(__DOXYGEN__)
logMsg("!!! NOT ACCEPTED %d out of %d !!!", transferred, size);
#endif /* EFI_SIMULATOR */
scheduleMsg(&tsLogger, "!!! NOT ACCEPTED %d out of %d !!!", transferred, size);
}
}
static void adc_callback_slow(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
(void) buffer;
(void) n;
efiAssertVoid(CUSTOM_ERR_6671, getRemainingStack(chThdGetSelfX()) > 128, "lowstck#9c");
/* Note, only in the ADC_COMPLETE state because the ADC driver fires
* an intermediate callback when the buffer is half full. */
if (adcp->state == ADC_COMPLETE) {
/* Calculates the average values from the ADC samples.*/
for (int i = 0; i < slowAdc.size(); i++) {
int value = getAvgAdcValue(i, slowAdc.samples, ADC_BUF_DEPTH_SLOW, slowAdc.size());
adcsample_t prev = slowAdc.values.adc_data[i];
float result = (slowAdcCounter == 0) ? value :
CONFIG(slowAdcAlpha) * value + (1 - CONFIG(slowAdcAlpha)) * prev;
// if (slowAdcCounter == 0) {
// biq[i].initValue(value);
// }
// float result = biq[i].getValue(value);
slowAdc.values.adc_data[i] = (int)result;
}
slowAdcCounter++;
}
}
static THD_FUNCTION(packet_process_thread, arg) {
(void)arg;
chRegSetThreadName("comm_uart");
process_tp = chThdGetSelfX();
for(;;) {
chEvtWaitAny((eventmask_t) 1);
/*
* Wait for data to become available and process it as long as there is data.
*/
while (serial_rx_read_pos != serial_rx_write_pos) {
bldc_interface_uart_process_byte(serial_rx_buffer[serial_rx_read_pos++]);
if (serial_rx_read_pos == SERIAL_RX_BUFFER_SIZE) {
serial_rx_read_pos = 0;
}
}
}
}
static void msg1_execute(void) {
thread_t *tp;
msg_t msg;
/*
* Testing the whole messages loop.
*/
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() + 1,
thread, chThdGetSelfX());
tp = chMsgWait();
msg = chMsgGet(tp);
chMsgRelease(tp, msg);
test_emit_token(msg);
tp = chMsgWait();
msg = chMsgGet(tp);
chMsgRelease(tp, msg);
test_emit_token(msg);
tp = chMsgWait();
msg = chMsgGet(tp);
chMsgRelease(tp, msg);
test_emit_token(msg);
test_assert_sequence(1, "ABC");
}
static void test_002_004_execute(void) {
tprio_t prio, p1;
/* [2.4.1] Simulating a priority boost situation (prio > realprio).*/
test_set_step(1);
{
prio = chThdGetPriorityX();
chThdGetSelfX()->prio += 2;
test_assert(chThdGetPriorityX() == prio + 2, "unexpected priority level");
}
/* [2.4.2] Raising thread priority above original priority but below
the boosted level.*/
test_set_step(2);
{
p1 = chThdSetPriority(prio + 1);
test_assert(p1 == prio, "unexpected returned priority level");
test_assert(chThdGetSelfX()->prio == prio + 2, "unexpected priority level");
test_assert(chThdGetSelfX()->realprio == prio + 1, "unexpected returned real priority level");
}
/* [2.4.3] Raising thread priority above the boosted level.*/
test_set_step(3);
{
p1 = chThdSetPriority(prio + 3);
test_assert(p1 == prio + 1, "unexpected returned priority level");
test_assert(chThdGetSelfX()->prio == prio + 3, "unexpected priority level");
test_assert(chThdGetSelfX()->realprio == prio + 3, "unexpected real priority level");
}
/* [2.4.4] Restoring original conditions.*/
test_set_step(4);
{
chSysLock();
chThdGetSelfX()->prio = prio;
chThdGetSelfX()->realprio = prio;
chSysUnlock();
}
}
static THD_FUNCTION(sample_send_thread, arg) {
(void)arg;
chRegSetThreadName("Main sample");
sample_send_tp = chThdGetSelfX();
for(;;) {
chEvtWaitAny((eventmask_t) 1);
for (int i = 0; i < sample_len; i++) {
uint8_t buffer[20];
int index = 0;
buffer[index++] = curr0_samples[i] >> 8;
buffer[index++] = curr0_samples[i];
buffer[index++] = curr1_samples[i] >> 8;
buffer[index++] = curr1_samples[i];
buffer[index++] = ph1_samples[i] >> 8;
buffer[index++] = ph1_samples[i];
buffer[index++] = ph2_samples[i] >> 8;
buffer[index++] = ph2_samples[i];
buffer[index++] = ph3_samples[i] >> 8;
buffer[index++] = ph3_samples[i];
buffer[index++] = vzero_samples[i] >> 8;
buffer[index++] = vzero_samples[i];
buffer[index++] = status_samples[i];
buffer[index++] = curr_fir_samples[i] >> 8;
buffer[index++] = curr_fir_samples[i];
buffer[index++] = f_sw_samples[i] >> 8;
buffer[index++] = f_sw_samples[i];
commands_send_samples(buffer, index);
}
}
}
static void evt2_execute(void) {
eventmask_t m;
event_listener_t el1, el2;
systime_t target_time;
/*
* Test on chEvtWaitOne() without wait.
*/
chEvtAddEvents(5);
m = chEvtWaitOne(ALL_EVENTS);
test_assert(1, m == 1, "single event error");
m = chEvtWaitOne(ALL_EVENTS);
test_assert(2, m == 4, "single event error");
m = chEvtGetAndClearEvents(ALL_EVENTS);
test_assert(3, m == 0, "stuck event");
/*
* Test on chEvtWaitOne() with wait.
*/
test_wait_tick();
target_time = chVTGetSystemTime() + MS2ST(50);
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
thread1, chThdGetSelfX());
m = chEvtWaitOne(ALL_EVENTS);
test_assert_time_window(4, target_time, target_time + ALLOWED_DELAY);
test_assert(5, m == 1, "single event error");
m = chEvtGetAndClearEvents(ALL_EVENTS);
test_assert(6, m == 0, "stuck event");
test_wait_threads();
/*
* Test on chEvtWaitAny() without wait.
*/
chEvtAddEvents(5);
m = chEvtWaitAny(ALL_EVENTS);
test_assert(7, m == 5, "unexpected pending bit");
m = chEvtGetAndClearEvents(ALL_EVENTS);
test_assert(8, m == 0, "stuck event");
/*
* Test on chEvtWaitAny() with wait.
*/
test_wait_tick();
target_time = chVTGetSystemTime() + MS2ST(50);
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
thread1, chThdGetSelfX());
m = chEvtWaitAny(ALL_EVENTS);
test_assert_time_window(9, target_time, target_time + ALLOWED_DELAY);
test_assert(10, m == 1, "single event error");
m = chEvtGetAndClearEvents(ALL_EVENTS);
test_assert(11, m == 0, "stuck event");
test_wait_threads();
/*
* Test on chEvtWaitAll().
*/
chEvtObjectInit(&es1);
chEvtObjectInit(&es2);
chEvtRegisterMask(&es1, &el1, 1);
chEvtRegisterMask(&es2, &el2, 4);
test_wait_tick();
target_time = chVTGetSystemTime() + MS2ST(50);
threads[0] = chThdCreateStatic(wa[0], WA_SIZE, chThdGetPriorityX() - 1,
thread2, "A");
m = chEvtWaitAll(5);
test_assert_time_window(12, target_time, target_time + ALLOWED_DELAY);
m = chEvtGetAndClearEvents(ALL_EVENTS);
test_assert(13, m == 0, "stuck event");
test_wait_threads();
chEvtUnregister(&es1, &el1);
chEvtUnregister(&es2, &el2);
test_assert(14, !chEvtIsListeningI(&es1), "stuck listener");
test_assert(15, !chEvtIsListeningI(&es2), "stuck listener");
}
void PrintStackSz() {
thread_t *PThd = chThdGetSelfX();
port_intctx *r13 = (port_intctx *)__get_PSP();
int32_t StkSz = PThd->p_stklimit - (stkalign_t *)(r13-1);
Uart.PrintfI("StackSz=%d\r", StkSz);
}
