void pwm_init(void) { /* Configure Timer1 in PWM Fast mode */ TCCR1B = (0<<WGM13)|(1<<WGM12)| /*< Mode: Fast PWM, 8 bit */ (0<<CS12)|(1<<CS11)|(1<<CS10)| /* Prescaler: 64 */ (0<< ICNC1)|(0<< ICES1); /*< No extra flags */ TCCR1A = (0<<WGM11)|(1<<WGM10)| /*< Mode: Fast PWM, 8 bit */ (1<<COM1A1)|(0<<COM1A0)| /*< Compare output mode OC1A: non-inverting */ (1<<COM1B1)|(0<<COM1B0)| /*< Compare output mode OC1B: non-inverting */ (0<<FOC1A)|(0<<FOC1B); /*< No forced output */ OCR1A = UINT16_C(0); OCR1B = UINT16_C(0); TCNT1 = UINT16_C(0); DDRD |= ((1U << DDD4)|(1U << DDD5)|(1U << DDD7)); /* Configure Timer2 in PWM fast mode */ /* Reset the Timer2 counter */ TCNT2 = UINT8_C(0); /* Timer2 compare register: 1001.73913Hz */ OCR2 = UINT8_C(0); /* Set the control register */ TCCR2 = (1<<WGM21)|(1<<WGM20)| /*< Mode: Fast PWM */ (1<<COM21)|(0<<COM21)| /*< Compare output mode OC2: non-inverting */ (1<<CS22)|(0<<CS21)|(0<<CS20); /* Prescaler: 64 */ }
IRIRef *IRIRef::urify() throw(BadAllocException) { if (this->urified) { return this; } const uint8_t *begin = this->utf8str->dptr(); const uint8_t *end = begin + this->utf8str->size(); const uint8_t *mark = begin; const uint8_t *next = NULL; uint32_t codepoint; while (mark != end) { codepoint = utf8char(mark, &next); if (IRIRef::isIPrivate(codepoint) || IRIRef::isUCSChar(codepoint)) { break; } mark = next; } if (mark == end) { this->urified = true; return this; } vector<uint8_t> urivec; urivec.reserve(this->utf8str->size() + 2); do { urivec.insert(urivec.end(), begin, mark); for (; mark != next; ++mark) { urivec.push_back(to_ascii('%')); uint8_t hi4 = (*mark) >> 4; uint8_t lo4 = (*mark) & UINT8_C(0x0F); urivec.push_back(hi4 <= UINT8_C(9) ? to_ascii('0') + hi4 : to_ascii('A') + (hi4 - 10)); urivec.push_back(lo4 <= UINT8_C(9) ? to_ascii('0') + lo4 : to_ascii('A') + (lo4 - 10)); } begin = mark; while (mark != end) { codepoint = utf8char(mark, &next); if (IRIRef::isIPrivate(codepoint) || IRIRef::isUCSChar(codepoint)) { break; } mark = next; } } while(mark != end); urivec.insert(urivec.end(), begin, mark); MPtr<uint8_t> *uristr; try { NEW(uristr, MPtr<uint8_t>, urivec.size()); } RETHROW_BAD_ALLOC copy(urivec.begin(), urivec.end(), uristr->dptr()); this->utf8str->drop(); this->utf8str = uristr; this->urified = true; return this; }
EXTERN_C void Pwm_SetDutyCycle(Pwm_ChannelType ChannelNumber, uint16 DutyCycle) { std::uint8_t duty_cycle_reg_value; // Calculate the scaled duty cycle. duty_cycle_reg_value = static_cast<std::uint8_t>(DutyCycle / UINT8_C(0x80)); switch(ChannelNumber) { case PWM_CHANNEL_B_5: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr1al, duty_cycle_reg_value); break; case PWM_CHANNEL_B_6: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr1bl, duty_cycle_reg_value); break; case PWM_CHANNEL_B_7: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr0a, duty_cycle_reg_value); break; case PWM_CHANNEL_C_6: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr3al, duty_cycle_reg_value); break; /* case PWM_CHANNEL_C_7: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr4a, LOBYTE(DutyCycle)); break; case PWM_CHANNEL_D_0: util::dma<uint8, uint8>::reg_set(mcal::reg::ocr0b, LOBYTE(DutyCycle)); break; case PWM_SW_CHANNEL: // code; break; */ /* case PWM_CHANNEL_D_6: // code; break; case PWM_CHANNEL_D_7: // code; break; default: // return error; break; */ } }
int main(void) { char buf[64]; int8_t i8; uint8_t u8; int16_t i16; uint16_t u16; #if defined(__SMALLER_C_32__) || !defined(__SMALLER_C__) int32_t i32; uint32_t u32; #endif intmax_t imax; uintmax_t umax; TEST_PRINT(buf, PRId8, INT8_C(-128), "-128"); TEST_PRINT(buf, PRIi8, INT8_C(-128), "-128"); TEST_PRINT(buf, PRIo8, UINT8_C(255), "377"); TEST_PRINT(buf, PRIu8, UINT8_C(255), "255"); TEST_PRINT(buf, PRIx8, UINT8_C(255), "ff"); TEST_PRINT(buf, PRIX8, UINT8_C(255), "FF"); TEST_PRINT(buf, PRId16, INT16_C(-32767), "-32767"); TEST_PRINT(buf, PRIi16, INT16_C(-32767), "-32767"); TEST_PRINT(buf, PRIo16, UINT16_C(65535), "177777"); TEST_PRINT(buf, PRIu16, UINT16_C(65535), "65535"); TEST_PRINT(buf, PRIx16, UINT16_C(65535), "ffff"); TEST_PRINT(buf, PRIX16, UINT16_C(65535), "FFFF"); TEST_PRINT(buf, PRIdMAX, INTMAX_C(-32767), "-32767"); TEST_PRINT(buf, PRIuMAX, UINTMAX_C(65535), "65535"); #if defined(__SMALLER_C_32__) || !defined(__SMALLER_C__) TEST_PRINT(buf, PRId32, INT32_C(-2147483647), "-2147483647"); TEST_PRINT(buf, PRIi32, INT32_C(-2147483647), "-2147483647"); TEST_PRINT(buf, PRIo32, UINT32_C(4294967295), "37777777777"); TEST_PRINT(buf, PRIu32, UINT32_C(4294967295), "4294967295"); TEST_PRINT(buf, PRIx32, UINT32_C(4294967295), "ffffffff"); TEST_PRINT(buf, PRIX32, UINT32_C(4294967295), "FFFFFFFF"); TEST_PRINT(buf, PRIdMAX, INTMAX_C(-2147483647), "-2147483647"); TEST_PRINT(buf, PRIuMAX, UINTMAX_C(4294967295), "4294967295"); #endif TEST_SCAN("-128", SCNd8, i8, INT8_C(-128)); TEST_SCAN("-128", SCNi8, i8, INT8_C(-128)); TEST_SCAN("377", SCNo8, u8, UINT8_C(255)); TEST_SCAN("255", SCNu8, u8, UINT8_C(255)); TEST_SCAN("Ff", SCNx8, u8, UINT8_C(255)); TEST_SCAN("-32767", SCNd16, i16, INT16_C(-32767)); TEST_SCAN("-32767", SCNi16, i16, INT16_C(-32767)); TEST_SCAN("177777", SCNo16, u16, UINT16_C(65535)); TEST_SCAN("65535", SCNu16, u16, UINT16_C(65535)); TEST_SCAN("FffF", SCNx16, u16, UINT16_C(65535)); TEST_SCAN("-32767", SCNdMAX, imax, INTMAX_C(-32767)); TEST_SCAN("65535", SCNuMAX, umax, UINTMAX_C(65535)); #if defined(__SMALLER_C_32__) || !defined(__SMALLER_C__) TEST_SCAN("-2147483647", SCNd32, i32, INT32_C(-2147483647)); TEST_SCAN("-2147483647", SCNi32, i32, INT32_C(-2147483647)); TEST_SCAN("37777777777", SCNo32, u32, UINT32_C(4294967295)); TEST_SCAN("4294967295", SCNu32, u32, UINT32_C(4294967295)); TEST_SCAN("ffFFffFF", SCNx32, u32, UINT32_C(4294967295)); TEST_SCAN("-2147483647", SCNdMAX, imax, INTMAX_C(-2147483647)); TEST_SCAN("4294967295", SCNuMAX, umax, UINTMAX_C(4294967295)); #endif return 0; }
void initContext( RenderWindow* window ) { //bgfx::glfwSetWindow( window->getHandle() ); bgfx::init(); bgfx::reset( window->getWidth(), window->getHeight(), BGFX_RESET_VSYNC ); // Enable debug text. //bgfx::setDebug(debug); // Set view 0 clear state. bgfx::setViewClear(0 , UINT8_C(0x01) |UINT8_C(0x08) , 0x303030ff , 1.0f , 0 ); }
/** * Implements VINF_IOM_MMIO_UNUSED_00. * * @returns VINF_SUCCESS. * @param pvValue Where to store the zeros. * @param cbValue How many bytes to read. */ static int iomMMIODoRead00s(void *pvValue, size_t cbValue) { switch (cbValue) { case 1: *(uint8_t *)pvValue = UINT8_C(0x00); break; case 2: *(uint16_t *)pvValue = UINT16_C(0x0000); break; case 4: *(uint32_t *)pvValue = UINT32_C(0x00000000); break; case 8: *(uint64_t *)pvValue = UINT64_C(0x0000000000000000); break; default: { uint8_t *pb = (uint8_t *)pvValue; while (cbValue--) *pb++ = UINT8_C(0x00); break; } } return VINF_SUCCESS; }
void MsixPciConfigWrite(PPDMDEVINS pDevIns, PCPDMPCIHLP pPciHlp, PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len) { int32_t iOff = u32Address - pDev->Int.s.u8MsixCapOffset; Assert(iOff >= 0 && (pciDevIsMsixCapable(pDev) && iOff < pDev->Int.s.u8MsixCapSize)); Log2(("MsixPciConfigWrite: %d <- %x (%d)\n", iOff, val, len)); uint32_t uAddr = u32Address; uint8_t u8NewVal; bool fJustEnabled = false; for (uint32_t i = 0; i < len; i++) { uint32_t reg = i + iOff; uint8_t u8Val = (uint8_t)val; switch (reg) { case 0: /* Capability ID, ro */ case 1: /* Next pointer, ro */ break; case VBOX_MSIX_CAP_MESSAGE_CONTROL: /* don't change read-only bits: 0-7 */ break; case VBOX_MSIX_CAP_MESSAGE_CONTROL + 1: { /* don't change read-only bits 8-13 */ u8NewVal = (u8Val & UINT8_C(~0x3f)) | (pDev->config[uAddr] & UINT8_C(0x3f)); /* If just enabled globally - check pending vectors */ fJustEnabled |= msixBitJustCleared(pDev->config[uAddr], u8NewVal, VBOX_PCI_MSIX_FLAGS_ENABLE >> 8); fJustEnabled |= msixBitJustCleared(pDev->config[uAddr], u8NewVal, VBOX_PCI_MSIX_FLAGS_FUNCMASK >> 8); pDev->config[uAddr] = u8NewVal; break; } default: /* other fields read-only too */ break; } uAddr++; val >>= 8; } if (fJustEnabled) msixCheckPendingVectors(pDevIns, pPciHlp, pDev); }
void app::crc::task_init() { // Initialize the test values to 0x31, ..., 0x39. std::uint_fast8_t i = UINT8_C(1); std::generate_n(app_crc_test_values.begin(), app_crc_test_values.size(), [&i]() -> std::uint_fast8_t { const std::uint_fast8_t value = UINT8_C(0x30) + i; ++i; return std::uint8_t(value); }); // Set the CRC port measurement pin to output app_crc_measurement_port_type::set_direction_output(); }
static void test_b_out(ctest_ctx *ctx) { const uint8_t SENTINEL = UINT8_C(0xFD); uint8_t image[3]; const uint8_t TAG = UINT8_C(0xa5); const uint8_t b = TAG; uint8_t *p = image+1; image[0] = SENTINEL; image[1] = SENTINEL; image[2] = SENTINEL; b_out(b,&p); CTEST(ctx,image[1]==TAG); CTEST(ctx,image[0]==SENTINEL); CTEST(ctx,image[2]==SENTINEL); CTEST(ctx,p==image+2); }
void do_something() { // Set portb to 0. reg_map_dynamic<std::uintptr_t, std::uint8_t, bit8_type>::value(address) = UINT8_C(0); // Set portb.5 to 1. reg_map_dynamic<std::uintptr_t, std::uint8_t, bit8_type>::bits(address).b5 = 1U; }
mcal::pwm::pwm_base& mcal::pwm::mcal_pwm2() { using port2_type = mcal::port::port_pin<std::uint8_t, std::uint8_t, mcal::reg::portc, UINT8_C(5)>; using pwm2_type = mcal::pwm::pwm_board<port2_type>; static pwm2_type the_pwm2(100U); return the_pwm2; }
void mcal::gpt::init(const config_type*) { if(gpt_is_initialized() == false) { // Protection off // SYSTEM.PRCR.WORD = 0xA503u; mcal::reg::access<std::uint32_t, std::uint16_t, mcal::reg::prcr, UINT16_C(0xA503)>::reg_set(); // Activate timer0/timer1 by clearing bit-5 in the module-stop register. mcal::reg::access<std::uint32_t, std::uint32_t, mcal::reg::mstpcra, UINT8_C(5)>::bit_clr(); // Protection on // SYSTEM.PRCR.WORD = 0xA500u; mcal::reg::access<std::uint32_t, std::uint16_t, mcal::reg::prcr, UINT16_C(0xA500)>::reg_set(); // Set timer0 to have an interrupt on overflow. mcal::reg::access<std::uint32_t, std::uint8_t, mcal::reg::tmr0_tcr, UINT8_C(0x20)>::reg_set(); // Enable the timer0 overflow interrupt at ier15.4. mcal::reg::access<std::uint32_t, std::uint8_t, mcal::reg::icu_ier15, UINT8_C(0x04)>::bit_set(); // Set the timer0 overflow interrupt priority to 7. mcal::reg::access<std::uint32_t, std::uint8_t, mcal::reg::icu_ipr170, UINT8_C(0x07)>::reg_set(); // Select the internal clock (not external) with the value 8. // Also select a prescaler of 32 with the value 3. mcal::reg::access<std::uint32_t, std::uint8_t, mcal::reg::tmr0_tccr, static_cast<std::uint8_t>(UINT8_C(0x08) | UINT8_C(0x03))>::reg_set(); // Start timer0 counting up. mcal::reg::access<std::uint32_t, std::uint16_t, mcal::reg::cmt_cmstr0, UINT16_C(0x01)>::reg_set(); gpt_is_initialized() = true; } }
static void test_w_out(ctest_ctx *ctx) { const uint8_t SENTINEL = UINT8_C(0xFD); const uint8_t TAG_HI = UINT8_C(0xA5); const uint8_t TAG_LO = UINT8_C(0x5A); const uint16_t TAG = UINT16_C(0xA55A); const uint16_t w = TAG; uint8_t image[4]; uint8_t *p = image+1; image[0] = SENTINEL; image[1] = SENTINEL; image[2] = SENTINEL; image[3] = SENTINEL; w_out(w,&p); CTEST(ctx,image[1]==TAG_LO); CTEST(ctx,image[2]==TAG_HI); CTEST(ctx,image[0]==SENTINEL); CTEST(ctx,image[3]==SENTINEL); CTEST(ctx,p==image+3); }
void app::led::task_func() { if(app_led_monochrome_timer.timeout()) { // Toggle the monochrome user LED at 1/2 Hz. mcal::led::led_monochrome0().toggle(); // Start the next timer interval for the monochrome user LED. app_led_monochrome_timer.start_interval(app_led_monochrome_timer_type::seconds(1U)); } if(app_led_rgb_timer.timeout()) { // Animate the RGB LED with the colors of the spectrum at 50 Hz. // Define the color transition states. typedef enum color_transition_enum { red_to_yellow, yellow_to_green, green_to_cyan, cyan_to_blue, blue_to_magenta, magenta_to_red } color_transition_type; // Initialize the color transition state. static color_transition_type color_transition_state = red_to_yellow; // Make a smooth color transition and // increment the color transition state // if necessary. switch(color_transition_state) { case red_to_yellow: { if(++app_led_hue_g == UINT8_C(255)) { color_transition_state = yellow_to_green; } } break; case yellow_to_green: { if(--app_led_hue_r == UINT8_C( 0)) { color_transition_state = green_to_cyan; } } break; case green_to_cyan: { if(++app_led_hue_b == UINT8_C(255)) { color_transition_state = cyan_to_blue; } } break; case cyan_to_blue: { if(--app_led_hue_g == UINT8_C( 0)) { color_transition_state = blue_to_magenta; } } break; case blue_to_magenta: { if(++app_led_hue_r == UINT8_C(255)) { color_transition_state = magenta_to_red; } } break; default: case magenta_to_red: { if(--app_led_hue_b == UINT8_C( 0)) { color_transition_state = red_to_yellow; } } break; } // Write the next color to the RGB LED. mcal::led::led_rgb0().set_color(app_led_hue_r, app_led_hue_g, app_led_hue_b); // Start the next timer interval for the RGB LED. app_led_rgb_timer.start_interval(app_led_rgb_timer_type::milliseconds(20U)); } }
EXTERN_C void Pwm_SetPeriodAndDuty(Pwm_ChannelType ChannelNumber, Pwm_PeriodType Period, uint16 DutyCycle) { // first set duty cycle via autosar function. Pwm_SetDutyCycle(ChannelNumber, DutyCycle); if(Period > static_cast<Pwm_PeriodType>(16384)) { // TBD: Switch to a software PWM here. Requires lots of code. } else { std::uint8_t prescaler_register_value; if(Period <= static_cast<Pwm_PeriodType>(16)) { prescaler_register_value = UINT8_C(0x01); } else if(Period <= static_cast<Pwm_PeriodType>(128)) { prescaler_register_value = UINT8_C(0x02); } else if(Period <= static_cast<Pwm_PeriodType>(1024)) { prescaler_register_value = UINT8_C(0x03); } else if(Period <= static_cast<Pwm_PeriodType>(4096)) { prescaler_register_value = UINT8_C(0x04); } else { prescaler_register_value = UINT8_C(0x05); } // util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0b, prescaler_register_value); util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr1b, prescaler_register_value, UINT8_C(0x07)); util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr3b, prescaler_register_value, UINT8_C(0x07)); } }
void Crc08_ProcessBytes(const uint8_t* DataIn, const size_t DataLength, Crc08_Context_Type* Crc_Context) { size_t LoopCnt; /* Loop through the input data stream */ for(LoopCnt = 0U; LoopCnt < DataLength; ++LoopCnt) { /* CRC-8/AUTOSAR Table based on 8-bit BYTEs. */ static const uint8_t Crc08_Table[256U] MCAL_PROGMEM = { UINT8_C(0x00), UINT8_C(0x2F), UINT8_C(0x5E), UINT8_C(0x71), UINT8_C(0xBC), UINT8_C(0x93), UINT8_C(0xE2), UINT8_C(0xCD), UINT8_C(0x57), UINT8_C(0x78), UINT8_C(0x09), UINT8_C(0x26), UINT8_C(0xEB), UINT8_C(0xC4), UINT8_C(0xB5), UINT8_C(0x9A), UINT8_C(0xAE), UINT8_C(0x81), UINT8_C(0xF0), UINT8_C(0xDF), UINT8_C(0x12), UINT8_C(0x3D), UINT8_C(0x4C), UINT8_C(0x63), UINT8_C(0xF9), UINT8_C(0xD6), UINT8_C(0xA7), UINT8_C(0x88), UINT8_C(0x45), UINT8_C(0x6A), UINT8_C(0x1B), UINT8_C(0x34), UINT8_C(0x73), UINT8_C(0x5C), UINT8_C(0x2D), UINT8_C(0x02), UINT8_C(0xCF), UINT8_C(0xE0), UINT8_C(0x91), UINT8_C(0xBE), UINT8_C(0x24), UINT8_C(0x0B), UINT8_C(0x7A), UINT8_C(0x55), UINT8_C(0x98), UINT8_C(0xB7), UINT8_C(0xC6), UINT8_C(0xE9), UINT8_C(0xDD), UINT8_C(0xF2), UINT8_C(0x83), UINT8_C(0xAC), UINT8_C(0x61), UINT8_C(0x4E), UINT8_C(0x3F), UINT8_C(0x10), UINT8_C(0x8A), UINT8_C(0xA5), UINT8_C(0xD4), UINT8_C(0xFB), UINT8_C(0x36), UINT8_C(0x19), UINT8_C(0x68), UINT8_C(0x47), UINT8_C(0xE6), UINT8_C(0xC9), UINT8_C(0xB8), UINT8_C(0x97), UINT8_C(0x5A), UINT8_C(0x75), UINT8_C(0x04), UINT8_C(0x2B), UINT8_C(0xB1), UINT8_C(0x9E), UINT8_C(0xEF), UINT8_C(0xC0), UINT8_C(0x0D), UINT8_C(0x22), UINT8_C(0x53), UINT8_C(0x7C), UINT8_C(0x48), UINT8_C(0x67), UINT8_C(0x16), UINT8_C(0x39), UINT8_C(0xF4), UINT8_C(0xDB), UINT8_C(0xAA), UINT8_C(0x85), UINT8_C(0x1F), UINT8_C(0x30), UINT8_C(0x41), UINT8_C(0x6E), UINT8_C(0xA3), UINT8_C(0x8C), UINT8_C(0xFD), UINT8_C(0xD2), UINT8_C(0x95), UINT8_C(0xBA), UINT8_C(0xCB), UINT8_C(0xE4), UINT8_C(0x29), UINT8_C(0x06), UINT8_C(0x77), UINT8_C(0x58), UINT8_C(0xC2), UINT8_C(0xED), UINT8_C(0x9C), UINT8_C(0xB3), UINT8_C(0x7E), UINT8_C(0x51), UINT8_C(0x20), UINT8_C(0x0F), UINT8_C(0x3B), UINT8_C(0x14), UINT8_C(0x65), UINT8_C(0x4A), UINT8_C(0x87), UINT8_C(0xA8), UINT8_C(0xD9), UINT8_C(0xF6), UINT8_C(0x6C), UINT8_C(0x43), UINT8_C(0x32), UINT8_C(0x1D), UINT8_C(0xD0), UINT8_C(0xFF), UINT8_C(0x8E), UINT8_C(0xA1), UINT8_C(0xE3), UINT8_C(0xCC), UINT8_C(0xBD), UINT8_C(0x92), UINT8_C(0x5F), UINT8_C(0x70), UINT8_C(0x01), UINT8_C(0x2E), UINT8_C(0xB4), UINT8_C(0x9B), UINT8_C(0xEA), UINT8_C(0xC5), UINT8_C(0x08), UINT8_C(0x27), UINT8_C(0x56), UINT8_C(0x79), UINT8_C(0x4D), UINT8_C(0x62), UINT8_C(0x13), UINT8_C(0x3C), UINT8_C(0xF1), UINT8_C(0xDE), UINT8_C(0xAF), UINT8_C(0x80), UINT8_C(0x1A), UINT8_C(0x35), UINT8_C(0x44), UINT8_C(0x6B), UINT8_C(0xA6), UINT8_C(0x89), UINT8_C(0xF8), UINT8_C(0xD7), UINT8_C(0x90), UINT8_C(0xBF), UINT8_C(0xCE), UINT8_C(0xE1), UINT8_C(0x2C), UINT8_C(0x03), UINT8_C(0x72), UINT8_C(0x5D), UINT8_C(0xC7), UINT8_C(0xE8), UINT8_C(0x99), UINT8_C(0xB6), UINT8_C(0x7B), UINT8_C(0x54), UINT8_C(0x25), UINT8_C(0x0A), UINT8_C(0x3E), UINT8_C(0x11), UINT8_C(0x60), UINT8_C(0x4F), UINT8_C(0x82), UINT8_C(0xAD), UINT8_C(0xDC), UINT8_C(0xF3), UINT8_C(0x69), UINT8_C(0x46), UINT8_C(0x37), UINT8_C(0x18), UINT8_C(0xD5), UINT8_C(0xFA), UINT8_C(0x8B), UINT8_C(0xA4), UINT8_C(0x05), UINT8_C(0x2A), UINT8_C(0x5B), UINT8_C(0x74), UINT8_C(0xB9), UINT8_C(0x96), UINT8_C(0xE7), UINT8_C(0xC8), UINT8_C(0x52), UINT8_C(0x7D), UINT8_C(0x0C), UINT8_C(0x23), UINT8_C(0xEE), UINT8_C(0xC1), UINT8_C(0xB0), UINT8_C(0x9F), UINT8_C(0xAB), UINT8_C(0x84), UINT8_C(0xF5), UINT8_C(0xDA), UINT8_C(0x17), UINT8_C(0x38), UINT8_C(0x49), UINT8_C(0x66), UINT8_C(0xFC), UINT8_C(0xD3), UINT8_C(0xA2), UINT8_C(0x8D), UINT8_C(0x40), UINT8_C(0x6F), UINT8_C(0x1E), UINT8_C(0x31), UINT8_C(0x76), UINT8_C(0x59), UINT8_C(0x28), UINT8_C(0x07), UINT8_C(0xCA), UINT8_C(0xE5), UINT8_C(0x94), UINT8_C(0xBB), UINT8_C(0x21), UINT8_C(0x0E), UINT8_C(0x7F), UINT8_C(0x50), UINT8_C(0x9D), UINT8_C(0xB2), UINT8_C(0xC3), UINT8_C(0xEC), UINT8_C(0xD8), UINT8_C(0xF7), UINT8_C(0x86), UINT8_C(0xA9), UINT8_C(0x64), UINT8_C(0x4B), UINT8_C(0x3A), UINT8_C(0x15), UINT8_C(0x8F), UINT8_C(0xA0), UINT8_C(0xD1), UINT8_C(0xFE), UINT8_C(0x33), UINT8_C(0x1C), UINT8_C(0x6D), UINT8_C(0x42), }; /* Perform the CRC-8/AUTOSAR algorithm. */ const uint_fast8_t DataIndex = (uint_fast8_t) ( Crc_Context->Crc08_Value ^ DataIn[LoopCnt]); const uint8_t TableValue = mcal_cpu_read_program_memory_byte((const uint8_t*) &Crc08_Table[(uint8_t) DataIndex]); Crc_Context->Crc08_Value = TableValue; } }
EXTERN_C void Pwm_Init(const Pwm_ConfigType* ConfigPtr) { static_cast<void>(ConfigPtr); for(uint8_least i = 0U; i < countof(Pwm_ConfigSet.PwmChannelConfigSet); ++i) { // Configuration for Pwm Mode. switch(ConfigPtr->PwmChannelConfigSet[i].Mode) { case PWM_MODE_FAST_INVERTED: // if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_C_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_D_0) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else { //Code for other Channels } break; case PWM_MODE_FAST_NONINVERTED: // if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_5) { util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr1a, UINT8_C(0xC1), UINT8_C(0xC1)); util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr1b, UINT8_C(0x08), UINT8_C(0x08)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_6) { util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr1a, UINT8_C(0x31), UINT8_C(0x31)); util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr1b, UINT8_C(0x08), UINT8_C(0x08)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_7) { //util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(0xC3)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_C_6) { util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr3a, UINT8_C(0xC1), UINT8_C(0xC1)); util::dma<uint8, uint8>::reg_msk(mcal::reg::tccr3b, UINT8_C(0x08), UINT8_C(0x08)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_C_7) { //util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(0xC3)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_D_0) { //util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(0xC3)); } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_SW_CHANNEL_D_5) { } // else { //Code for other Channels } break; case PWM_MODE_PHASECORRECT_INVERTED: // if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_C_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_D_0) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else { //Code for other Channels } break; case PWM_MODE_PHASECORRECT_NONINVERTED: // if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_C_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_B_7) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else if(ConfigPtr->PwmChannelConfigSet[i].PwmChannelId == PWM_CHANNEL_D_0) { /* Missing UINT8_C Value x util::dma<uint8, uint8>::reg_set(mcal::reg::tccr0a, UINT8_C(x)); util::dma<uint8, uint8>::reg_set(mcal::reg::timsk0, UINT8_C(x)); */ } // else { //Code for other Channels } break; default: //Code for unused Channels break; } } }
int32_t a3[3] = { INT32_C (17), INT32_MIN, INT32_MAX }; verify (TYPE_MINIMUM (int32_t) == INT32_MIN); verify (TYPE_MAXIMUM (int32_t) == INT32_MAX); verify_same_types (INT32_MIN, (int32_t) 0 + 0); verify_same_types (INT32_MAX, (int32_t) 0 + 0); #ifdef INT64_MAX int64_t a4[3] = { INT64_C (17), INT64_MIN, INT64_MAX }; verify (TYPE_MINIMUM (int64_t) == INT64_MIN); verify (TYPE_MAXIMUM (int64_t) == INT64_MAX); verify_same_types (INT64_MIN, (int64_t) 0 + 0); verify_same_types (INT64_MAX, (int64_t) 0 + 0); #endif uint8_t b1[2] = { UINT8_C (17), UINT8_MAX }; verify (TYPE_MAXIMUM (uint8_t) == UINT8_MAX); verify_same_types (UINT8_MAX, (uint8_t) 0 + 0); uint16_t b2[2] = { UINT16_C (17), UINT16_MAX }; verify (TYPE_MAXIMUM (uint16_t) == UINT16_MAX); verify_same_types (UINT16_MAX, (uint16_t) 0 + 0); uint32_t b3[2] = { UINT32_C (17), UINT32_MAX }; verify (TYPE_MAXIMUM (uint32_t) == UINT32_MAX); verify_same_types (UINT32_MAX, (uint32_t) 0 + 0); #ifdef UINT64_MAX uint64_t b4[2] = { UINT64_C (17), UINT64_MAX }; verify (TYPE_MAXIMUM (uint64_t) == UINT64_MAX); verify_same_types (UINT64_MAX, (uint64_t) 0 + 0);
// Load data from constant file and check for exact match. TEST(bits, reverseBytes) { { uint8_t val = 0x88, val_r; const uint8_t val_r_ok = 0x88; mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { int8_t val = 0x66, val_r; const int8_t val_r_ok = 0x66; mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { uint16_t val = 0x1122, val_r; const uint16_t val_r_ok = 0x2211; mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { int16_t val = 0x1122, val_r; const int16_t val_r_ok = 0x2211; mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { uint32_t val = UINT32_C(0x11223344), val_r; const uint32_t val_r_ok = UINT32_C(0x44332211); mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { int32_t val = INT32_C(0x11223344), val_r; const int32_t val_r_ok = INT32_C(0x44332211); mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { uint64_t val = UINT64_C(0x1122334455667788), val_r; const uint64_t val_r_ok = UINT64_C(0x8877665544332211); mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { int64_t val = INT64_C(0x1122334455667766), val_r; const int64_t val_r_ok = INT64_C(0x6677665544332211); mrpt::reverseBytes(val, val_r); EXPECT_EQ(val_r, val_r_ok); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, val_r_ok); } { bool valTrue = true; bool valFalse = false; mrpt::reverseBytesInPlace(valTrue); mrpt::reverseBytesInPlace(valFalse); EXPECT_TRUE(valTrue); EXPECT_FALSE(valFalse); } { uint8_t val = UINT8_C(0xc1); mrpt::reverseBytesInPlace(val); EXPECT_EQ(val, 0xc1); } { //1.0 == 0x3F800000 float val = 1; const uint32_t val_r_ok = UINT32_C(0x803f); mrpt::reverseBytesInPlace(val); uint32_t val_check = *reinterpret_cast<uint32_t*>(&val); EXPECT_EQ(val_check, val_r_ok); } { //1.0 == 0x3ff0000000000000 double val = 1; const uint64_t val_r_ok = UINT32_C(0xf03f); mrpt::reverseBytesInPlace(val); uint32_t val_check = *reinterpret_cast<uint32_t*>(&val); EXPECT_EQ(val_check, val_r_ok); } }
void MsiPciConfigWrite(PPDMDEVINS pDevIns, PCPDMPCIHLP pPciHlp, PPCIDEVICE pDev, uint32_t u32Address, uint32_t val, unsigned len) { int32_t iOff = u32Address - pDev->Int.s.u8MsiCapOffset; Assert(iOff >= 0 && (pciDevIsMsiCapable(pDev) && iOff < pDev->Int.s.u8MsiCapSize)); Log2(("MsiPciConfigWrite: %d <- %x (%d)\n", iOff, val, len)); uint32_t uAddr = u32Address; bool f64Bit = msiIs64Bit(pDev); for (uint32_t i = 0; i < len; i++) { uint32_t reg = i + iOff; uint8_t u8Val = (uint8_t)val; switch (reg) { case 0: /* Capability ID, ro */ case 1: /* Next pointer, ro */ break; case VBOX_MSI_CAP_MESSAGE_CONTROL: /* don't change read-only bits: 1-3,7 */ u8Val &= UINT8_C(~0x8e); pDev->config[uAddr] = u8Val | (pDev->config[uAddr] & UINT8_C(0x8e)); break; case VBOX_MSI_CAP_MESSAGE_CONTROL + 1: /* don't change read-only bit 8, and reserved 9-15 */ break; default: if (pDev->config[uAddr] != u8Val) { int32_t maskUpdated = -1; /* If we're enabling masked vector, and have pending messages for this vector, we have to send this message now */ if ( !f64Bit && (reg >= VBOX_MSI_CAP_MASK_BITS_32) && (reg < VBOX_MSI_CAP_MASK_BITS_32 + 4) ) { maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_32; } if ( f64Bit && (reg >= VBOX_MSI_CAP_MASK_BITS_64) && (reg < VBOX_MSI_CAP_MASK_BITS_64 + 4) ) { maskUpdated = reg - VBOX_MSI_CAP_MASK_BITS_64; } if (maskUpdated != -1 && msiIsEnabled(pDev)) { uint32_t* puPending = msiGetPendingBits(pDev); for (int iBitNum = 0; iBitNum < 8; iBitNum++) { int32_t iBit = 1 << iBitNum; uint32_t uVector = maskUpdated*8 + iBitNum; if (msiBitJustCleared(pDev->config[uAddr], u8Val, iBit)) { Log(("msi: mask updated bit %d@%x (%d)\n", iBitNum, uAddr, maskUpdated)); /* To ensure that we're no longer masked */ pDev->config[uAddr] &= ~iBit; if ((*puPending & (1 << uVector)) != 0) { Log(("msi: notify earlier masked pending vector: %d\n", uVector)); MsiNotify(pDevIns, pPciHlp, pDev, uVector, PDM_IRQ_LEVEL_HIGH, 0 /*uTagSrc*/); } } if (msiBitJustSet(pDev->config[uAddr], u8Val, iBit)) { Log(("msi: mask vector: %d\n", uVector)); } } } pDev->config[uAddr] = u8Val; } } uAddr++; val >>= 8; } }
int main() { boost::int8_t i8 = INT8_C(0); (void)i8; boost::uint8_t ui8 = UINT8_C(0); (void)ui8; boost::int16_t i16 = INT16_C(0); (void)i16; boost::uint16_t ui16 = UINT16_C(0); (void)ui16; boost::int32_t i32 = INT32_C(0); (void)i32; boost::uint32_t ui32 = UINT32_C(0); (void)ui32; #ifndef BOOST_NO_INT64_T boost::int64_t i64 = 0; (void)i64; boost::uint64_t ui64 = 0; (void)ui64; #endif boost::int_least8_t i8least = INT8_C(0); (void)i8least; boost::uint_least8_t ui8least = UINT8_C(0); (void)ui8least; boost::int_least16_t i16least = INT16_C(0); (void)i16least; boost::uint_least16_t ui16least = UINT16_C(0); (void)ui16least; boost::int_least32_t i32least = INT32_C(0); (void)i32least; boost::uint_least32_t ui32least = UINT32_C(0); (void)ui32least; #ifndef BOOST_NO_INT64_T boost::int_least64_t i64least = 0; (void)i64least; boost::uint_least64_t ui64least = 0; (void)ui64least; #endif boost::int_fast8_t i8fast = INT8_C(0); (void)i8fast; boost::uint_fast8_t ui8fast = UINT8_C(0); (void)ui8fast; boost::int_fast16_t i16fast = INT16_C(0); (void)i16fast; boost::uint_fast16_t ui16fast = UINT16_C(0); (void)ui16fast; boost::int_fast32_t i32fast = INT32_C(0); (void)i32fast; boost::uint_fast32_t ui32fast = UINT32_C(0); (void)ui32fast; #ifndef BOOST_NO_INT64_T boost::int_fast64_t i64fast = 0; (void)i64fast; boost::uint_fast64_t ui64fast = 0; (void)ui64fast; #endif boost::intmax_t im = 0; (void)im; boost::uintmax_t uim = 0; (void)uim; }
IRIRef *IRIRef::normalize() THROWS(BadAllocException, TraceableException) { if (this->normalized && !this->urified) { return this; } uint8_t *normed = NULL; DPtr<uint8_t> *normal = NULL; if (this->utf8str->standable()) { this->utf8str = this->utf8str->stand(); normal = this->utf8str; normal->hold(); } else { NEW(normal, MPtr<uint8_t>, this->utf8str->size()); } normed = normal->dptr(); // Percent encoding; decode if IUnreserved uint8_t bits = UINT8_C(0); uint8_t *begin = this->utf8str->dptr(); uint8_t *end = begin + this->utf8str->size(); uint8_t *marki = begin; uint8_t *markj = begin; uint8_t *markk = normed; for (; marki != end; marki = markj) { for (markj = marki; markj != end && *markj != to_ascii('%'); ++markj) { // loop does the work } size_t sz = markj - marki; memmove(markk, marki, sz * sizeof(uint8_t)); markk += sz; if (markj == end) { break; } uint8_t enc[4] = { UINT8_C(0xFF), UINT8_C(0xFF), UINT8_C(0xFF), UINT8_C(0xFF) }; enc[0] = (((uint8_t) IRI_HEX_VALUE(markj[1])) << 4) | (uint8_t) IRI_HEX_VALUE(markj[2]); if (enc[0] <= UINT8_C(0x7F)) { if (IRIRef::isIUnreserved(enc[0])) { *markk = enc[0]; ++markk; } else { markk[0] = markj[0]; markk[1] = to_upper(markj[1]); markk[2] = to_upper(markj[2]); markk += 3; } markj += 3; continue; } uint8_t *markl = markj + 3; int i = 1; uint8_t bits; for (bits = enc[0] << 1; markl != end && *markl == to_ascii('%') && bits > UINT8_C(0x7F) && i < 4; bits <<= 1) { enc[i] = (((uint8_t) IRI_HEX_VALUE(markl[1])) << 4) | (uint8_t) IRI_HEX_VALUE(markl[2]); markl += 3; ++i; } try { const uint8_t *endenc; uint32_t codepoint = utf8char(enc, &endenc); if (IRIRef::isIUnreserved(codepoint)) { i = endenc - enc; // should already be equal, but just in case memmove(markk, enc, i * sizeof(uint8_t)); markk += i; markj = markl; this->urified = false; } else { for (; markj != markl; markj += 3) { markk[0] = markj[0]; markk[1] = to_upper(markj[1]); markk[2] = to_upper(markj[2]); markk += 3; } } } catch (InvalidEncodingException &e) { markk[0] = markj[0]; markk[1] = to_upper(markj[1]); markk[2] = to_upper(markj[2]); markk += 3; markj += 3; } } if (markk != end) { DPtr<uint8_t> *temp = normal->sub(0, markk - normed); normal->drop(); normal = temp; } if (this->normalized) { this->utf8str->drop(); this->utf8str = normal; return this; } // Character normalization; NFC DPtr<uint32_t> *codepoints = utf8dec(normal); normal->drop(); DPtr<uint32_t> *codepoints2 = nfc_opt(codepoints); codepoints->drop(); normal = utf8enc(codepoints2); codepoints2->drop(); this->utf8str->drop(); this->utf8str = normal; // Path normalization this->resolve(NULL); // Case normalization; scheme and host DPtr<uint8_t> *part = this->getPart(SCHEME); if (part != NULL) { begin = part->dptr(); end = begin + part->size(); for (; begin != end; ++begin) { *begin = to_lower(*begin); } part->drop(); } part = this->getPart(HOST); if (part != NULL) { begin = part->dptr(); end = begin + part->size(); for (; begin != end; ++begin) { *begin = to_lower(*begin); } part->drop(); } this->normalized = true; return this; }
int _main_(int _argc, char** _argv) { Args args(_argc, _argv); uint32_t width = 1280; uint32_t height = 720; uint32_t debug = BGFX_DEBUG_TEXT; uint32_t reset = 0 | BGFX_RESET_VSYNC | BGFX_RESET_MSAA_X16 ; bgfx::init(args.m_type, args.m_pciId); bgfx::reset(width, height, reset); // Enable debug text. bgfx::setDebug(debug); // Set views clear state. bgfx::setViewClear(0 , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH , 0x303030ff , 1.0f , 0 ); // Imgui. imguiCreate(); // Uniforms. Uniforms uniforms; uniforms.init(); // Vertex declarations. PosColorTexCoord0Vertex::init(); LightProbe lightProbes[LightProbe::Count]; lightProbes[LightProbe::Bolonga].load("bolonga"); lightProbes[LightProbe::Kyoto ].load("kyoto"); LightProbe::Enum currentLightProbe = LightProbe::Bolonga; bgfx::UniformHandle u_mtx = bgfx::createUniform("u_mtx", bgfx::UniformType::Mat4); bgfx::UniformHandle u_params = bgfx::createUniform("u_params", bgfx::UniformType::Vec4); bgfx::UniformHandle u_flags = bgfx::createUniform("u_flags", bgfx::UniformType::Vec4); bgfx::UniformHandle u_camPos = bgfx::createUniform("u_camPos", bgfx::UniformType::Vec4); bgfx::UniformHandle s_texCube = bgfx::createUniform("s_texCube", bgfx::UniformType::Int1); bgfx::UniformHandle s_texCubeIrr = bgfx::createUniform("s_texCubeIrr", bgfx::UniformType::Int1); bgfx::ProgramHandle programMesh = loadProgram("vs_ibl_mesh", "fs_ibl_mesh"); bgfx::ProgramHandle programSky = loadProgram("vs_ibl_skybox", "fs_ibl_skybox"); Mesh* meshBunny; meshBunny = meshLoad("meshes/bunny.bin"); Mesh* meshOrb; meshOrb = meshLoad("meshes/orb.bin"); Camera camera; Mouse mouse; struct Settings { Settings() { m_envRotCurr = 0.0f; m_envRotDest = 0.0f; m_lightDir[0] = -0.8f; m_lightDir[1] = 0.2f; m_lightDir[2] = -0.5f; m_lightCol[0] = 1.0f; m_lightCol[1] = 1.0f; m_lightCol[2] = 1.0f; m_glossiness = 0.7f; m_exposure = 0.0f; m_bgType = 3.0f; m_radianceSlider = 2.0f; m_reflectivity = 0.85f; m_rgbDiff[0] = 1.0f; m_rgbDiff[1] = 1.0f; m_rgbDiff[2] = 1.0f; m_rgbSpec[0] = 1.0f; m_rgbSpec[1] = 1.0f; m_rgbSpec[2] = 1.0f; m_lod = 0.0f; m_doDiffuse = false; m_doSpecular = false; m_doDiffuseIbl = true; m_doSpecularIbl = true; m_showLightColorWheel = true; m_showDiffColorWheel = true; m_showSpecColorWheel = true; m_metalOrSpec = 0; m_meshSelection = 0; m_crossCubemapPreview = ImguiCubemap::Latlong; } float m_envRotCurr; float m_envRotDest; float m_lightDir[3]; float m_lightCol[3]; float m_glossiness; float m_exposure; float m_radianceSlider; float m_bgType; float m_reflectivity; float m_rgbDiff[3]; float m_rgbSpec[3]; float m_lod; bool m_doDiffuse; bool m_doSpecular; bool m_doDiffuseIbl; bool m_doSpecularIbl; bool m_showLightColorWheel; bool m_showDiffColorWheel; bool m_showSpecColorWheel; uint8_t m_metalOrSpec; uint8_t m_meshSelection; ImguiCubemap::Enum m_crossCubemapPreview; }; Settings settings; int32_t leftScrollArea = 0; entry::MouseState mouseState; while (!entry::processEvents(width, height, debug, reset, &mouseState) ) { imguiBeginFrame(mouseState.m_mx , mouseState.m_my , (mouseState.m_buttons[entry::MouseButton::Left ] ? IMGUI_MBUT_LEFT : 0) | (mouseState.m_buttons[entry::MouseButton::Right ] ? IMGUI_MBUT_RIGHT : 0) | (mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0) , mouseState.m_mz , uint16_t(width) , uint16_t(height) ); static int32_t rightScrollArea = 0; imguiBeginScrollArea("", width - 256 - 10, 10, 256, 700, &rightScrollArea); imguiLabel("Environment light:"); imguiIndent(); imguiBool("IBL Diffuse", settings.m_doDiffuseIbl); imguiBool("IBL Specular", settings.m_doSpecularIbl); currentLightProbe = LightProbe::Enum(imguiTabs( uint8_t(currentLightProbe) , true , ImguiAlign::LeftIndented , 16 , 2 , 2 , "Bolonga" , "Kyoto" ) ); if (imguiCube(lightProbes[currentLightProbe].m_tex, settings.m_lod, settings.m_crossCubemapPreview, true) ) { settings.m_crossCubemapPreview = ImguiCubemap::Enum( (settings.m_crossCubemapPreview+1) % ImguiCubemap::Count); } imguiSlider("Texture LOD", settings.m_lod, 0.0f, 10.1f, 0.1f); imguiUnindent(); imguiSeparator(8); imguiLabel("Directional light:"); imguiIndent(); imguiBool("Diffuse", settings.m_doDiffuse); imguiBool("Specular", settings.m_doSpecular); const bool doDirectLighting = settings.m_doDiffuse || settings.m_doSpecular; imguiSlider("Light direction X", settings.m_lightDir[0], -1.0f, 1.0f, 0.1f, doDirectLighting); imguiSlider("Light direction Y", settings.m_lightDir[1], -1.0f, 1.0f, 0.1f, doDirectLighting); imguiSlider("Light direction Z", settings.m_lightDir[2], -1.0f, 1.0f, 0.1f, doDirectLighting); imguiColorWheel("Color:", settings.m_lightCol, settings.m_showLightColorWheel, 0.6f, doDirectLighting); imguiUnindent(); imguiSeparator(8); imguiLabel("Background:"); imguiIndent(); { int32_t selection; if (0.0f == settings.m_bgType) { selection = UINT8_C(0); } else if (7.0f == settings.m_bgType) { selection = UINT8_C(2); } else { selection = UINT8_C(1); } selection = imguiTabs( uint8_t(selection) , true , ImguiAlign::LeftIndented , 16 , 2 , 3 , "Skybox" , "Radiance" , "Irradiance" ); if (0 == selection) { settings.m_bgType = 0.0f; } else if (2 == selection) { settings.m_bgType = 7.0f; } else { settings.m_bgType = settings.m_radianceSlider; } const bool isRadiance = (selection == 1); imguiSlider("Mip level", settings.m_radianceSlider, 1.0f, 6.0f, 0.1f, isRadiance); } imguiUnindent(); imguiSeparator(8); imguiLabel("Post processing:"); imguiIndent(); imguiSlider("Exposure", settings.m_exposure, -4.0f, 4.0f, 0.1f); imguiUnindent(); imguiSeparator(); imguiEndScrollArea(); imguiBeginScrollArea("", 10, 70, 256, 636, &leftScrollArea); imguiLabel("Mesh:"); imguiIndent(); settings.m_meshSelection = uint8_t(imguiChoose(settings.m_meshSelection, "Bunny", "Orbs") ); imguiUnindent(); const bool isBunny = (0 == settings.m_meshSelection); if (!isBunny) { settings.m_metalOrSpec = 0; } imguiSeparator(4); imguiLabel("Workflow:"); imguiIndent(); if (imguiCheck("Metalness", 0 == settings.m_metalOrSpec, isBunny) ) { settings.m_metalOrSpec = 0; } if (imguiCheck("Specular", 1 == settings.m_metalOrSpec, isBunny) ) { settings.m_metalOrSpec = 1; } imguiUnindent(); imguiSeparator(4); imguiLabel("Material:"); imguiIndent(); imguiSlider("Glossiness", settings.m_glossiness, 0.0f, 1.0f, 0.01f, isBunny); imguiSlider(0 == settings.m_metalOrSpec ? "Metalness" : "Diffuse - Specular", settings.m_reflectivity, 0.0f, 1.0f, 0.01f, isBunny); imguiUnindent(); imguiColorWheel("Diffuse:", &settings.m_rgbDiff[0], settings.m_showDiffColorWheel, 0.7f); imguiSeparator(); imguiColorWheel("Specular:", &settings.m_rgbSpec[0], settings.m_showSpecColorWheel, 0.7f, (1 == settings.m_metalOrSpec) && isBunny); imguiEndScrollArea(); imguiEndFrame(); uniforms.m_glossiness = settings.m_glossiness; uniforms.m_reflectivity = settings.m_reflectivity; uniforms.m_exposure = settings.m_exposure; uniforms.m_bgType = settings.m_bgType; uniforms.m_metalOrSpec = float(settings.m_metalOrSpec); uniforms.m_doDiffuse = float(settings.m_doDiffuse); uniforms.m_doSpecular = float(settings.m_doSpecular); uniforms.m_doDiffuseIbl = float(settings.m_doDiffuseIbl); uniforms.m_doSpecularIbl = float(settings.m_doSpecularIbl); bx::memCopy(uniforms.m_rgbDiff, settings.m_rgbDiff, 3*sizeof(float) ); bx::memCopy(uniforms.m_rgbSpec, settings.m_rgbSpec, 3*sizeof(float) ); bx::memCopy(uniforms.m_lightDir, settings.m_lightDir, 3*sizeof(float) ); bx::memCopy(uniforms.m_lightCol, settings.m_lightCol, 3*sizeof(float) ); int64_t now = bx::getHPCounter(); static int64_t last = now; const int64_t frameTime = now - last; last = now; const double freq = double(bx::getHPFrequency() ); const double toMs = 1000.0/freq; const float deltaTimeSec = float(double(frameTime)/freq); // Use debug font to print information about this example. bgfx::dbgTextClear(); bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/18-ibl"); bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Image-based lighting."); bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs); // Camera. const bool mouseOverGui = imguiMouseOverArea(); mouse.update(float(mouseState.m_mx), float(mouseState.m_my), mouseState.m_mz, width, height); if (!mouseOverGui) { if (mouseState.m_buttons[entry::MouseButton::Left]) { camera.orbit(mouse.m_dx, mouse.m_dy); } else if (mouseState.m_buttons[entry::MouseButton::Right]) { camera.dolly(mouse.m_dx + mouse.m_dy); } else if (mouseState.m_buttons[entry::MouseButton::Middle]) { settings.m_envRotDest += mouse.m_dx*2.0f; } else if (0 != mouse.m_scroll) { camera.dolly(float(mouse.m_scroll)*0.05f); } } camera.update(deltaTimeSec); bx::memCopy(uniforms.m_cameraPos, camera.m_pos.curr, 3*sizeof(float) ); // View Transform 0. float view[16]; float proj[16]; bx::mtxIdentity(view); bx::mtxOrtho(proj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f); bgfx::setViewTransform(0, view, proj); // View Transform 1. camera.mtxLookAt(view); bx::mtxProj(proj, 45.0f, float(width)/float(height), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth); bgfx::setViewTransform(1, view, proj); // View rect. bgfx::setViewRect(0, 0, 0, uint16_t(width), uint16_t(height) ); bgfx::setViewRect(1, 0, 0, uint16_t(width), uint16_t(height) ); // Env rotation. const float amount = bx::fmin(deltaTimeSec/0.12f, 1.0f); settings.m_envRotCurr = bx::flerp(settings.m_envRotCurr, settings.m_envRotDest, amount); // Env mtx. float mtxEnvView[16]; camera.envViewMtx(mtxEnvView); float mtxEnvRot[16]; bx::mtxRotateY(mtxEnvRot, settings.m_envRotCurr); bx::mtxMul(uniforms.m_mtx, mtxEnvView, mtxEnvRot); // Used for Skybox. // Submit view 0. bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex); bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr); bgfx::setState(BGFX_STATE_RGB_WRITE|BGFX_STATE_ALPHA_WRITE); screenSpaceQuad( (float)width, (float)height, true); uniforms.submit(); bgfx::submit(0, programSky); // Submit view 1. bx::memCopy(uniforms.m_mtx, mtxEnvRot, 16*sizeof(float)); // Used for IBL. if (0 == settings.m_meshSelection) { // Submit bunny. float mtx[16]; bx::mtxSRT(mtx, 1.0f, 1.0f, 1.0f, 0.0f, bx::pi, 0.0f, 0.0f, -0.80f, 0.0f); bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex); bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr); uniforms.submit(); meshSubmit(meshBunny, 1, programMesh, mtx); } else { // Submit orbs. for (float yy = 0, yend = 5.0f; yy < yend; yy+=1.0f) { for (float xx = 0, xend = 5.0f; xx < xend; xx+=1.0f) { const float scale = 1.2f; const float spacing = 2.2f; const float yAdj = -0.8f; float mtx[16]; bx::mtxSRT(mtx , scale/xend , scale/xend , scale/xend , 0.0f , 0.0f , 0.0f , 0.0f + (xx/xend)*spacing - (1.0f + (scale-1.0f)*0.5f - 1.0f/xend) , yAdj/yend + (yy/yend)*spacing - (1.0f + (scale-1.0f)*0.5f - 1.0f/yend) , 0.0f ); uniforms.m_glossiness = xx*(1.0f/xend); uniforms.m_reflectivity = (yend-yy)*(1.0f/yend); uniforms.m_metalOrSpec = 0.0f; uniforms.submit(); bgfx::setTexture(0, s_texCube, lightProbes[currentLightProbe].m_tex); bgfx::setTexture(1, s_texCubeIrr, lightProbes[currentLightProbe].m_texIrr); meshSubmit(meshOrb, 1, programMesh, mtx); } } } // Advance to next frame. Rendering thread will be kicked to // process submitted rendering primitives. bgfx::frame(); } meshUnload(meshBunny); meshUnload(meshOrb); // Cleanup. bgfx::destroyProgram(programMesh); bgfx::destroyProgram(programSky); bgfx::destroyUniform(u_camPos); bgfx::destroyUniform(u_flags); bgfx::destroyUniform(u_params); bgfx::destroyUniform(u_mtx); bgfx::destroyUniform(s_texCube); bgfx::destroyUniform(s_texCubeIrr); for (uint8_t ii = 0; ii < LightProbe::Count; ++ii) { lightProbes[ii].destroy(); } uniforms.destroy(); imguiDestroy(); // Shutdown bgfx. bgfx::shutdown(); return 0; }
void Crc08_Finalize(Crc08_Context_Type* Crc_Context) { Crc_Context->Crc08_Value ^= UINT8_C(0xFF); }
static void parport_poll_pad(struct parport_joypad *pad) { /* RetroArch uses an extended version of the Linux * Multisystem 2-button joystick protocol for parallel port * joypads: * * | Function | Pin | Register | Bit | Active | * |-------------|-----|----------|-----|--------| * | Up | 2 | Data | 0 | Low | * | Down | 3 | Data | 1 | Low | * | Left | 4 | Data | 2 | Low | * | Right | 5 | Data | 3 | Low | * | A | 6 | Data | 4 | Low | * | B | 7 | Data | 5 | Low | * | Start | 8 | Data | 6 | Low | * | Select | 9 | Data | 7 | Low | * | Menu toggle | 10 | Status | 6 | Low | * | X | 11 | Status | 7 | Low* | * | Y | 12 | Status | 5 | Low | * | L1 | 13 | Status | 4 | Low | * | R1 | 15 | Status | 3 | Low | * * (*) Pin is hardware inverted, but RetroArch inverts it * back again so the same pullup scheme may be used for * all pins. * * Pin 1 is set high so it can be used for pullups. * * RetroArch does not perform debouncing, and so long as * the button settling time is less than the frame time * no bouncing will be observed. This replicates the latching * behavior common in old games consoles. For optimum latency * and jitter a high performance debouncing routine should be * implemented in the controller hardware. */ int i; char data; char status; ioctl(pad->fd, PPRDATA, &data); ioctl(pad->fd, PPRSTATUS, &status); for (i = 0; i < 8; i++) { if (!(data & UINT8_C(1 << i)) && pad->button_enable[i]) BIT64_SET(pad->buttons, i); else BIT64_CLEAR(pad->buttons, i); } for (i = 3; i < 8; i++) { if (!(status & UINT8_C(1 << i)) && pad->button_enable[i + 5]) BIT64_SET(pad->buttons, i + 5); else BIT64_CLEAR(pad->buttons, i + 5); } if (BIT64_GET(pad->buttons, 12) && pad->button_enable[12]) BIT64_CLEAR(pad->buttons, 12); else BIT64_SET(pad->buttons, 12); }
void app::crc::task_func() { // Calculate and verify the 8-bit, 16-bit, // 32-bit and 64-bit CRC. typedef enum app_crc_calculation_state { app_crc_calculation_state_initialize, app_crc_calculation_state_process_bytes, app_crc_calculation_state_finalize } app_crc_calculation_state_type; static app_crc_calculation_state_type app_crc_calculation_state = app_crc_calculation_state_initialize; static std::uint_fast8_t app_crc_process_data_byte_count; static std::uint_fast8_t app_crc_object_index; // On 8-bit target, take runtime statistics for the // state machine (averaged over all 8,16,32,64-bit CRCs, // all bytes and all states). // * average 10.3us // * low 3.4us // * high 22 us. // Average load for CRC calculation only is: // * 10.3us / 1ms = approx. 1%. // * 36ms (total) needed to cycle through all 4 CRCs. // Disable all interrupts before each calculation // in order to provide for a clean time measurement. mcal::irq::disable_all(); // Use a port pin to provide a real-time measurement. app_crc_measurement_port_type::set_pin_high(); // Distribute the CRC calculations // over multitasking time slices. // Process one single byte at a time, switch(app_crc_calculation_state) { case app_crc_calculation_state_initialize: // Initialize the CRC object. app_crc_checksums[app_crc_object_index]->initialize(); app_crc_calculation_state = app_crc_calculation_state_process_bytes; break; case app_crc_calculation_state_process_bytes: { // Process the next byte. const std::uint8_t next_byte = *(app_crc_test_values.data() + app_crc_process_data_byte_count); app_crc_checksums[app_crc_object_index]->process_bytes(&next_byte, 1U); } ++app_crc_process_data_byte_count; if(app_crc_process_data_byte_count >= app_crc_test_values.size()) { // If all bytes for this CRC have been processed, // then reset the byte count to 0 and move to the // finalize state for this CRC calculation. app_crc_process_data_byte_count = 0U; // We are now ready to move to CRC state finalize // for this CRC object. app_crc_calculation_state = app_crc_calculation_state_finalize; } break; default: case app_crc_calculation_state_finalize: // Finalize this CRC object. app_crc_checksums[app_crc_object_index]->finalize(); // Increment to othe next CRC object in the list. ++app_crc_object_index; if(app_crc_object_index >= app_crc_checksums.size()) { // If we have reached the end of the CRC object list, // Then reset to the beginning of the list. app_crc_object_index = 0U; // Verify all CRC results. app_crc_results_are_ok = ( (app_crc_checksums[0U]->get_result<std::uint8_t> () == UINT8_C (0xDF)) && (app_crc_checksums[1U]->get_result<std::uint16_t>() == UINT16_C(0x29B1)) && (app_crc_checksums[2U]->get_result<std::uint32_t>() == UINT32_C(0x1697D06A)) && (app_crc_checksums[3U]->get_result<std::uint64_t>() == UINT64_C(0x995DC9BBDF1939FA))); } // Return to CRC state initialization. app_crc_calculation_state = app_crc_calculation_state_initialize; break; } app_crc_measurement_port_type::set_pin_low(); // Remember to enable all interrupts after the calculation. mcal::irq::enable_all(); if(app_crc_results_are_ok == false) { // The CRC results are not OK. for(;;) { // Crash the system and toggle a port // to provide an indication of failure. app_crc_measurement_port_type::toggle_pin(); mcal::cpu::nop(); } } }
void Crc08_Initialize(Crc08_Context_Type* Crc_Context) { /* Set the initial value. */ Crc_Context->Crc08_Value = UINT8_C(0xFF); }
bool mcal::display::display_console::do_write(const std::uint8_t value_to_write) { static const std::array<std::uint8_t, 16U> character_table = {{ UINT8_C('0'), UINT8_C('1'), UINT8_C('2'), UINT8_C('3'), UINT8_C('4'), UINT8_C('5'), UINT8_C('6'), UINT8_C('7'), UINT8_C('8'), UINT8_C('9'), UINT8_C('A'), UINT8_C('b'), UINT8_C('c'), UINT8_C('d'), UINT8_C('E'), UINT8_C('F') }}; std::uint8_t table_index; bool write_is_ok; const bool byte_is_in_range = (value_to_write < std::uint8_t(character_table.size())); if(byte_is_in_range) { table_index = value_to_write; write_is_ok = true; } else { table_index = std::uint8_t(character_table.size() - 1U); write_is_ok = false; } set_data(character_table[table_index]); std::cout << "seven_segment display: " << char(get_data()); if(get_dp_is_on()) { std::cout << char('.'); } std::cout << std::endl; return write_is_ok; }
static bool parport_joypad_init_pad(const char *path, struct parport_joypad *pad) { int i; char data; struct ppdev_frob_struct frob; int datadir = 1; /* read */ bool set_control = false; int mode = IEEE1284_MODE_BYTE; settings_t *settings = config_get_ptr(); if (pad->fd >= 0) return false; if (access(path, R_OK | W_OK) < 0) return false; pad->fd = open(path, O_RDWR | O_NONBLOCK); *pad->ident = '\0'; if (pad->fd >= 0) { RARCH_LOG("[Joypad]: Found parallel port: %s\n", path); /* Parport driver does not log failures with RARCH_ERR because they could be * a normal result of connected non-joypad devices. */ if (ioctl(pad->fd, PPCLAIM) < 0) { RARCH_WARN("[Joypad]: Failed to claim %s\n", path); goto error; } if (ioctl(pad->fd, PPSETMODE, &mode) < 0) { RARCH_WARN("[Joypad]: Failed to set byte mode on %s\n", path); goto error; } if (ioctl(pad->fd, PPDATADIR, &datadir) < 0) { RARCH_WARN("[Joypad]: Failed to set data direction to input on %s\n", path); goto error; } if (ioctl(pad->fd, PPRDATA, &data) < 0) { RARCH_WARN("[Joypad]: Failed to save original data register on %s\n", path); goto error; } pad->saved_data = data; if (ioctl(pad->fd, PPRCONTROL, &data) == 0) { pad->saved_control = data; /* Clear strobe bit to set strobe high for pullup +V */ /* Clear control bit 4 to disable interrupts */ frob.mask = PARPORT_CONTROL_STROBE | (UINT8_C(1 << 4)); frob.val = 0; if (ioctl(pad->fd, PPFCONTROL, &frob) == 0) set_control = true; } else { data = pad->saved_data; if (ioctl(pad->fd, PPWDATA, &data) < 0) RARCH_WARN("[Joypad]: Failed to restore original data register on %s\n", path); RARCH_WARN("[Joypad]: Failed to save original control register on %s\n", path); goto error; } /* Failure to enable strobe can break Linux Multisystem style controllers. * Controllers using an alternative power source will still work. * Failure to disable interrupts slightly increases CPU usage. */ if (!set_control) RARCH_WARN("[Joypad]: Failed to clear nStrobe and nIRQ bits on %s\n", path); strlcpy(pad->ident, path, sizeof(settings->input.device_names[0])); for (i = 0; i < PARPORT_NUM_BUTTONS; i++) pad->button_enable[i] = true; return true; error: close(pad->fd); pad->fd = 0; return false; } RARCH_WARN("[Joypad]: Failed to open parallel port %s (error: %s).\n", path, strerror(errno)); return false; }
C(INTMAX_MAX) C(UINTMAX_MAX) C(PTRDIFF_MIN) C(PTRDIFF_MAX) C(SIG_ATOMIC_MIN) C(SIG_ATOMIC_MAX) C(SIZE_MAX) C(WCHAR_MIN) C(WCHAR_MAX) C(WINT_MIN) C(WINT_MAX) C(INT8_C(0)) C(INT16_C(0)) C(INT32_C(0)) C(INT64_C(0)) C(UINT8_C(0)) C(UINT16_C(0)) C(UINT32_C(0)) C(UINT64_C(0)) C(INTMAX_C(0)) C(UINTMAX_C(0)) S(PRId8) S(PRId16) S(PRId32) S(PRId64) S(PRIdLEAST8) S(PRIdLEAST16) S(PRIdLEAST32) S(PRIdLEAST64) S(PRIdFAST8) S(PRIdFAST16)