/*----------------------------------------------------------------------------*/ void uartConfigPins(struct UartBase *interface, const struct UartBaseConfig *config) { /* Direction configuration is not needed for alternate function pins */ if (config->rx) { /* Configure UART RX pin */ const struct PinEntry * const pinEntry = pinFind(uartPins, config->rx, interface->channel); assert(pinEntry); const struct Pin pin = pinInit(config->rx); pinInput(pin); pinSetFunction(pin, pinEntry->value); } if (config->tx) { /* Configure UART TX pin */ const struct PinEntry * const pinEntry = pinFind(uartPins, config->tx, interface->channel); assert(pinEntry); const struct Pin pin = pinInit(config->tx); pinInput(pin); pinSetFunction(pin, pinEntry->value); } }
/*----------------------------------------------------------------------------*/ static enum Result interfaceInit(void *object, const void *configBase) { const struct InterfaceWrapperConfig * const config = configBase; struct InterfaceWrapper * const interface = object; interface->pipe = config->pipe; interface->rx = pinInit(config->rx); assert(pinValid(interface->rx)); pinOutput(interface->rx, 0); interface->tx = pinInit(config->tx); assert(pinValid(interface->tx)); pinOutput(interface->tx, 0); return E_OK; }
void init( int argc, char * argv[] ) { if(argc > 1) if(Serial.init_tty(argv[1]) != 0) return; if(Serial1.init_tty(LINUX_SERIAL1_TTY) != 0) return; if(Serial2.init_tty(LINUX_SERIAL2_TTY) != 0) return; sizeof_g_APinDescription = sizeof(g_APinDescription)/sizeof(struct _PinDescription); sizeof_g_APinState = sizeof(g_APinState)/sizeof(struct _PinState); pinInit(); /* Initialize fast path to GPIO */ if (fastGpioPciInit()) trace_error("Unable to initialize fast GPIO mode!"); sizeof_g_APwmDescription = sizeof(g_APwmDescription)/sizeof(struct _PwmDescription); pwmInit(); sizeof_g_AdcDescription = sizeof(g_AdcDescription)/sizeof(struct _AdcDescription); adcInit(); eepromInit(); }
/*----------------------------------------------------------------------------*/ int main(void) { const struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct Interface * const adc = init(AdcOneShot, &adcConfig); assert(adc); struct Timer * const timer = init(GpTimer, &timerConfig); assert(timer); timerSetOverflow(timer, 1000); bool event = false; timerSetCallback(timer, onTimerOverflow, &event); timerEnable(timer); while (1) { while (!event) barrier(); event = false; pinSet(led); uint16_t voltage; const size_t bytesRead = ifRead(adc, &voltage, sizeof(voltage)); assert(bytesRead == sizeof(voltage)); (void)bytesRead; /* Suppress warning */ pinReset(led); } return 0; }
/*----------------------------------------------------------------------------*/ int main(void) { const uint32_t maxPeriod = captureUnitConfig.frequency / pwmUnitConfig.frequency + 1; const uint32_t minPeriod = captureUnitConfig.frequency / pwmUnitConfig.frequency - 1; setupClock(); const struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct GpTimerPwmUnit * const pwmUnit = init(GpTimerPwmUnit, &pwmUnitConfig); assert(pwmUnit); struct Pwm * const pwm = gpTimerPwmCreate(pwmUnit, OUTPUT_PIN); assert(pwm); pwmSetEdges(pwm, 0, pwmGetResolution(pwm) / 2); struct GpTimerCaptureUnit * const captureUnit = init(GpTimerCaptureUnit, &captureUnitConfig); assert(pwmUnit); struct Capture * const capture = gpTimerCaptureCreate(captureUnit, INPUT_PIN, PIN_RISING, PIN_PULLDOWN); assert(capture); uint32_t previousTime = 0; bool event = false; captureSetCallback(capture, onCaptureEvent, &event); captureEnable(capture); pwmEnable(pwm); while (1) { while (!event) barrier(); event = false; const uint32_t currentTime = captureGetValue(capture); const uint32_t period = currentTime - previousTime; if (period >= minPeriod && period <= maxPeriod) pinReset(led); else pinSet(led); previousTime = currentTime; } return 0; }
/*----------------------------------------------------------------------------*/ static enum Result pinInterruptInit(void *object, const void *configBase) { const struct PinInterruptConfig * const config = configBase; assert(config); const struct Pin input = pinInit(config->pin); assert(pinValid(input)); /* Try to allocate a new channel */ struct PinInterrupt * const interrupt = object; const int channel = setInstance(interrupt); if (channel == -1) return E_BUSY; /* Configure the pin */ pinInput(input); pinSetPull(input, config->pull); interrupt->callback = 0; interrupt->channel = channel; interrupt->enabled = false; interrupt->event = config->event; interrupt->pin = input.data; const uint8_t index = interrupt->channel >> 2; const uint32_t mask = 1UL << interrupt->channel; /* Enable peripheral */ if (!sysClockStatus(CLK_PINT)) sysClockEnable(CLK_PINT); /* Select pin and port */ LPC_SYSCON->PINTSEL[index] = (LPC_SYSCON->PINTSEL[index] & ~PINTSEL_CHANNEL_MASK(channel)) | PINTSEL_CHANNEL(channel, input.data.port, input.data.offset); /* Configure interrupt as edge sensitive */ LPC_GPIO_INT->ISEL &= ~mask; /* Configure edge sensitivity options */ if (config->event == PIN_RISING || config->event == PIN_TOGGLE) LPC_GPIO_INT->SIENR = mask; if (config->event == PIN_FALLING || config->event == PIN_TOGGLE) LPC_GPIO_INT->SIENF = mask; #ifdef CONFIG_PM /* Interrupt will wake the controller from low-power modes */ LPC_SYSCON->STARTERP0 |= STARTERP0_PINT(interrupt->channel); #endif /* Configure interrupt priority, interrupt is disabled by default */ irqSetPriority(calcVector(interrupt->channel), config->priority); return E_OK; }
/*----------------------------------------------------------------------------*/ static uint8_t configMatchPin(uint8_t channel, PinNumber key) { const struct PinEntry * const pinEntry = pinFind(gpPwmPins, key, channel); assert(pinEntry); const struct Pin pin = pinInit(key); pinOutput(pin, false); pinSetFunction(pin, UNPACK_FUNCTION(pinEntry->value)); return UNPACK_CHANNEL(pinEntry->value); }
/********************************************************************************************************* ** Function name: main ** Descriptions: 用户程序入口函数 ** input parameters: 无 ** output parameters: 无 ** Returned value: 无 *********************************************************************************************************/ int main(void) { targetInit(); /* 初始化目标板,切勿删除 */ pinInit(); /* 引脚初始化 */ BEEP_INIT(); BEEP_OFF(); while (1) { BEEP_OFF(); myDelay(200); BEEP_ON(); myDelay(200); } }
/*----------------------------------------------------------------------------*/ int main(void) { setupClock(); const struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct Interface * const adc = init(AdcDma, &adcConfig); assert(adc); ifSetCallback(adc, onConversionCompleted, adc); struct Timer * const conversionTimer = init(GpTimer, &timerConfig); assert(conversionTimer); /* * The overflow frequency of the timer should be two times higher * than that of the hardware events for ADC. */ timerSetOverflow(conversionTimer, timerConfig.frequency / (ADC_RATE * 2)); unsigned int iteration = 0; size_t count; /* Enqueue buffers */ while (ifGetParam(adc, IF_AVAILABLE, &count) == E_OK && count > 0) { const size_t index = iteration++ % BUFFER_COUNT; ifRead(adc, buffers[index], sizeof(buffers[index])); } /* Start conversion */ timerEnable(conversionTimer); while (1) { while (!event) barrier(); event = false; pinSet(led); while (ifGetParam(adc, IF_AVAILABLE, &count) == E_OK && count > 0) { const size_t index = iteration++ % BUFFER_COUNT; ifRead(adc, buffers[index], sizeof(buffers[index])); } pinReset(led); } return 0; }
/*----------------------------------------------------------------------------*/ int main(void) { const struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct Interface * const flash = init(Flash, 0); assert(flash); size_t flashSize, pageSize; enum Result res; pinSet(led); if ((res = ifGetParam(flash, IF_SIZE, &flashSize)) == E_OK) pinReset(led); assert(res == E_OK); pinSet(led); if ((res = ifGetParam(flash, IF_FLASH_PAGE_SIZE, &pageSize)) == E_OK) pinReset(led); assert(res == E_OK); uint8_t * const buffer = malloc(pageSize); for (size_t i = 0; i < pageSize; ++i) buffer[i] = i; /* Test sector erase */ const size_t address = findNearestSector(); assert(address < flashSize); pinSet(led); if ((res = ifSetParam(flash, IF_FLASH_ERASE_SECTOR, &address)) == E_OK) pinReset(led); assert(res == E_OK); pinSet(led); if ((res = program(flash, buffer, pageSize, address)) == E_OK) pinReset(led); assert(res == E_OK); pinSet(led); if ((res = verify(flash, buffer, pageSize, address)) == E_OK) pinReset(led); assert(res == E_OK); /* Page erase is not available on some parts */ while (1); return 0; }
/*----------------------------------------------------------------------------*/ static void deviceInit(struct DeviceDriver *device, struct Interface *interface, PinNumber ledNumber, uint16_t address) { device->interface = interface; device->state = DEVICE_IDLE; device->desiredRate = DEVICE_CLOCK; device->localAddress = 0; device->deviceAddress = address; device->change = false; static_assert(MEMORY_ADDRESS_SIZE && MEMORY_ADDRESS_SIZE <= 2, "Incorrect address size"); if (MEMORY_ADDRESS_SIZE == 2) device->localAddress = toBigEndian16(device->localAddress); device->led = pinInit(ledNumber); pinOutput(device->led, false); }
/*----------------------------------------------------------------------------*/ int main(void) { setupClock(); const struct Pin led = pinInit(LED_PIN); pinOutput(led, true); struct GpTimerPwmUnit * const pwmUnit = init(GpTimerPwmUnit, &pwmUnitConfig); assert(pwmUnit); struct Pwm * const pwmOutput = gpTimerPwmCreate(pwmUnit, OUTPUT_PIN); assert(pwmOutput); pwmSetDuration(pwmOutput, pwmGetResolution(pwmOutput) / 2); struct Timer * const counter = init(GpTimerCounter, &counterConfig); assert(counter); struct Timer * const timer = init(GpTimer, &timerConfig); assert(timer); timerSetOverflow(timer, 1000); bool event = false; timerSetCallback(timer, onTimerOverflow, &event); timerEnable(counter); pwmEnable(pwmOutput); timerEnable(timer); while (1) { while (!event) barrier(); event = false; const uint32_t period = timerGetValue(counter); timerSetValue(counter, 0); if (period >= 999 && period <= 1001) pinReset(led); else pinSet(led); } return 0; }
void init( int argc, char * argv[] ) { if(argc > 1) if(Serial.init_tty(argv[1]) != 0) return; if(Serial1.init_tty(LINUX_SERIAL1_TTY) != 0) return; if(Serial2.init_tty(LINUX_SERIAL2_TTY) != 0) return; sizeof_g_APinDescription = sizeof(g_APinDescription)/sizeof(struct _PinDescription); pinInit(); sizeof_g_APwmDescription = sizeof(g_APwmDescription)/sizeof(struct _PwmDescription); pwmInit(); sizeof_g_AdcDescription = sizeof(g_AdcDescription)/sizeof(struct _AdcDescription); adcInit(); sizeof_g_APinState = sizeof(g_APinState)/sizeof(struct _PinState); }
/*----------------------------------------------------------------------------*/ int main(void) { /* Initialize peripherals */ struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct Timer * const timer = init(SysTickTimer, 0); assert(timer); timerSetOverflow(timer, timerGetFrequency(timer) / 2); timerSetCallback(timer, onTimerOverflow, &led); /* Initialize Work Queue */ workQueueInit(WORK_QUEUE_SIZE); /* Start event generation and queue handler */ timerEnable(timer); workQueueStart(0); return 0; }
/*----------------------------------------------------------------------------*/ static void configPins(struct I2sBase *interface, const struct I2sBaseConfig *config) { const pinNumber pinArray[] = { config->rx.sck, config->rx.ws, config->rx.sda, config->rx.mclk, config->tx.sck, config->tx.ws, config->tx.sda, config->tx.mclk }; for (unsigned int index = 0; index < ARRAY_SIZE(pinArray); ++index) { if (pinArray[index]) { const struct PinEntry * const pinEntry = pinFind(i2sPins, pinArray[index], interface->channel); assert(pinEntry); const struct Pin pin = pinInit(pinArray[index]); pinInput(pin); pinSetFunction(pin, pinEntry->value); } } }
/*----------------------------------------------------------------------------*/ int main(void) { static const uint32_t address = 0; uint8_t buffer[384]; for (size_t i = 0; i < sizeof(buffer); ++i) buffer[i] = i; const struct Pin led = pinInit(LED_PIN); pinOutput(led, false); struct Interface * const eeprom = init(Eeprom, 0); assert(eeprom); uint32_t size; enum Result res; pinSet(led); if ((res = ifGetParam(eeprom, IF_SIZE, &size)) == E_OK) pinReset(led); assert(res == E_OK); assert(address < size); pinSet(led); if ((res = program(eeprom, buffer, sizeof(buffer), address)) == E_OK) pinReset(led); assert(res == E_OK); pinSet(led); if ((res = verify(eeprom, buffer, sizeof(buffer), address)) == E_OK) pinReset(led); assert(res == E_OK); while (1); return 0; }
/*----------------------------------------------------------------------------*/ int main(void) { const struct Pin led = pinInit(LED_PIN); pinOutput(led, true); struct Timer * const timer = init(GpTimer, &timerConfig); assert(timer); timerSetOverflow(timer, 500); bool event = false; timerSetCallback(timer, onTimerOverflow, &event); timerEnable(timer); while (1) { while (!event) barrier(); event = false; pinToggle(led); } return 0; }
/*----------------------------------------------------------------------------*/ static void configPins(struct SdmmcBase *interface, const struct SdmmcBaseConfig *config) { const pinNumber pinArray[] = { config->clk, config->cmd, config->dat0, config->dat1, config->dat2, config->dat3 }; bool wide = true; for (unsigned int index = 0; index < ARRAY_SIZE(pinArray); ++index) { if (!pinArray[index]) { /* First three pins are mandatory */ assert(index >= 3); wide = false; continue; } const struct PinEntry * const pinEntry = pinFind(sdmmcPins, pinArray[index], 0); assert(pinEntry); const struct Pin pin = pinInit(pinArray[index]); pinInput(pin); pinSetFunction(pin, pinEntry->value); } interface->wide = wide; }
.init = oneWireInit, .deinit = oneWireDeinit, .callback = oneWireCallback, .get = oneWireGet, .set = oneWireSet, .read = oneWireRead, .write = oneWireWrite }; /*----------------------------------------------------------------------------*/ const struct InterfaceClass * const OneWireUart = &oneWireTable; /*----------------------------------------------------------------------------*/ static void adjustPins(struct OneWireUart *interface __attribute__((unused)), const struct OneWireUartConfig *config) { pinSetType(pinInit(config->tx), PIN_OPENDRAIN); } /*----------------------------------------------------------------------------*/ static void beginTransmission(struct OneWireUart *interface) { LPC_UART_Type * const reg = interface->base.reg; uartSetRate((struct UartBase *)interface, interface->resetRate); interface->state = STATE_RESET; /* Clear RX FIFO and set trigger level to 1 character */ reg->FCR |= FCR_RX_RESET | FCR_RX_TRIGGER(RX_TRIGGER_LEVEL_1); reg->THR = 0xF0; /* Execute reset */ } /*----------------------------------------------------------------------------*/ static void sendWord(struct OneWireUart *interface, uint8_t word) {
/* Constructor */ MAX3421E::MAX3421E() { spi_init(); pinInit(); }
int main(void){ pinInit(); rcInterruptInit(); timerInit(); while(1){ // update loop every 1 ms if(micros() - loopTimer > LOOPTIME){ loopTimer = micros(); // check the current pulse reading for validity if(checkPulse(pw)){ lastPw = pw; }else{ pwGood = 0; pw = lastPw; } // bound the pulse width if(pw > RCMAX){ pw = RCMAX; }else if(pw < RCMIN){ pw = RCMIN; } // process the pulse width for output if(pwGood){ rawCmd = mWRADB(pw, rawCmd, RCMIN, RCMAX, RCMID, -MAXPWM, MAXPWM, 0, RCDB, 2); } // get direction, 1 is forward if(rawCmd >= 0){ dir = 1; }else{ dir = 0; } cmd = rawCmd; // get magnitude of cmd if(!dir){ cmd = -(cmd); } // exponential lookup and limit output cmd = exp1x[cmd]; if(cmd > MAXPWM){ cmd = MAXPWM; } // if failsafe isnt true, send output to motor if(!failsafe){ if(dir){ OCR1A = cmd; PORTD |= DIRA1; PORTD &= ~(DIRA2); }else{ OCR1A = cmd; PORTD &= ~(DIRA1); PORTD |= DIRA2; } }else{ // else shut off the pwm OCR1A = 0; } // failsafe check if(micros() - fsTimer > FSTIME){ fsTimer = micros(); if(pwGood){ PORTD |= (SDPINA | SDPINB); failsafe = 0; }else{ // shutdown the gate drivers PORTD &= ~(SDPINA | SDPINB); failsafe = 1; } pwGood = 0; } } } }