static void Config_PWM(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_GPIOPinConfigure(GPIO_PB6_T0CCP0); ROM_GPIOPinConfigure(GPIO_PB2_T3CCP0); ROM_GPIOPinTypeTimer(GPIO_PORTB_BASE, GPIO_PIN_2 | GPIO_PIN_6); // Configure timer ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER3); ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM); ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, DEFAULT); ROM_TimerMatchSet(TIMER0_BASE, TIMER_A, DEFAULT); // PWM ROM_TimerEnable(TIMER0_BASE, TIMER_A); ROM_TimerConfigure(TIMER3_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PWM); ROM_TimerLoadSet(TIMER3_BASE, TIMER_A, DEFAULT); ROM_TimerMatchSet(TIMER3_BASE, TIMER_A, DEFAULT); // PWM ROM_TimerControlLevel(TIMER3_BASE, TIMER_A, true); ROM_TimerEnable(TIMER3_BASE, TIMER_A); ROM_SysCtlPeripheralEnable(DRV_ENABLE_LEFT_CHN_PERIPHERAL); ROM_SysCtlPeripheralEnable(DRV_ENABLE_RIGHT_CHN_PERIPHERAL); ROM_GPIOPinTypeGPIOOutput(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN); ROM_GPIOPinTypeGPIOOutput(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN); ROM_GPIOPinWrite(DRV_ENABLE_LEFT_CHN_PORT, DRV_ENABLE_LEFT_CHN_PIN, 0); ROM_GPIOPinWrite(DRV_ENABLE_RIGHT_CHN_PORT, DRV_ENABLE_RIGHT_CHN_PIN, 0); }
//***************************************************************************** // // Configure the UART and its pins. This must be called before UARTprintf(). // //***************************************************************************** void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Use the system clock for the UART. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_SYSTEM); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 9600, g_ui32SysClock); }
void UART_setup_gps(void) { // // Enable the peripherals used by gps. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // // Set GPIO B0 and B1 as UART pins for the gps. // ROM_GPIOPinConfigure(GPIO_PB0_U1RX); ROM_GPIOPinConfigure(GPIO_PB1_U1TX); ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure the GPS for 9600, 8-N-1 operation. // ROM_UARTConfigSetExpClk(UART1_BASE, ROM_SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Enable the UART interrupt. // ROM_IntEnable(INT_UART1); ROM_UARTIntEnable(UART1_BASE, UART_INT_RX | UART_INT_RT); }
BOOL xMBTCPPortInit(USHORT port) { ROM_SysCtlPeripheralEnable(WIZ610_GPIO_PERIPH); ROM_GPIODirModeSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE ,GPIO_DIR_MODE_OUT); ROM_GPIOPadConfigSet(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,GPIO_STRENGTH_8MA,GPIO_PIN_TYPE_STD_WPU); ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE); // uart setup ROM_SysCtlPeripheralEnable(WIZ610_UART_PERIPH); ROM_GPIOPinConfigure(GPIO_PB0_U1RX); ROM_GPIOPinConfigure(GPIO_PB1_U1TX); ROM_GPIOPinTypeUART(WIZ610_GPIO_BASE, WIZ610_GPIO_PIN_RX | WIZ610_GPIO_PIN_TX); ROM_UARTConfigSetExpClk(WIZ610_UART_BASE, ROM_SysCtlClockGet(), 38400, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); ROM_GPIOPinWrite(WIZ610_GPIO_BASE,WIZ610_GPIO_PIN_CMD_ENABLE,WIZ610_GPIO_PIN_CMD_ENABLE); ROM_UARTFIFOLevelSet(WIZ610_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX1_8); ROM_IntEnable(INT_UART1); ROM_UARTEnable(WIZ610_UART_BASE); ROM_UARTDMAEnable(WIZ610_UART_BASE, UART_DMA_TX); ROM_UARTIntEnable(WIZ610_UART_BASE, UART_INT_RX); ROM_IntEnable(INT_UDMA); WIZ610Transfer(); cmd_modbus_switch=0; g_ulRxBufACount=0; modbus_tcp_rab=MODBUS_TCP_IDLE; return TRUE; }
//***************************************************************************** // // Configure the UART and its pins. This must be called before UARTprintf(). // //***************************************************************************** void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, g_ui32SysClock); }
static int init_base(uart_t uart, uint32_t baudrate) { /*The base address of the chosen UART */ unsigned long ulBase = g_ulUARTBase[uart]; ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uart]); switch(uart){ #if UART_0_EN case UART_0: ROM_SysCtlPeripheralEnable(UART_0_PORT); ROM_GPIOPinConfigure(UART_0_RX_PIN); ROM_GPIOPinConfigure(UART_0_TX_PIN); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); break; #endif #if UART_1_EN case UART_1: ROM_SysCtlPeripheralEnable(UART_1_PORT); ROM_GPIOPinConfigure(UART_1_RX_PIN); ROM_GPIOPinConfigure(UART_1_TX_PIN); ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); break; #endif } ROM_UARTDisable(ulBase); ROM_UARTConfigSetExpClk(ulBase,UART_CLK, baudrate, (UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE | UART_CONFIG_WLEN_8)); ROM_UARTEnable(ulBase); return 0; }
void MCInitPwm(uint32_t DutyCycle) { // Clock PWM peripheral at SysClk/PWMDIV ROM_SysCtlPWMClockSet(SYSCTL_PWMDIV_64); // Enable peripherals ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_PWM1); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // Configure pin PD0 as PWM output ROM_GPIOPinTypePWM(GPIO_PORTD_BASE, GPIO_PIN_0|GPIO_PIN_1); ROM_GPIOPinConfigure(GPIO_PD0_M1PWM0); ROM_GPIOPinConfigure(GPIO_PD1_M1PWM1); // Calculate PWM clock uint32_t PWMClock = SysCtlClockGet() / 64; // Value from/to which PWM counter counts (subtract 1 becouse counter counts from 0). This is PWM period LoadValue = (PWMClock/PWM_FREQUENCY) - 1; // Configure PWM ROM_PWMGenConfigure(PWM1_BASE, PWM_GEN_0, PWM_GEN_MODE_DOWN); ROM_PWMGenPeriodSet(PWM1_BASE, PWM_GEN_0, LoadValue); // Set PWM signal width ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_1, (DutyCycle*LoadValue)/DUTY_CYCLE_DIVIDER); ROM_PWMPulseWidthSet(PWM1_BASE, PWM_OUT_0, (DutyCycle*LoadValue)/DUTY_CYCLE_DIVIDER); // Enable PWM output 0 and 1 ROM_PWMOutputState(PWM1_BASE, PWM_OUT_0_BIT|PWM_OUT_1_BIT, true); // Enable PWM generator ROM_PWMGenEnable(PWM1_BASE, PWM_GEN_0); }
//Initialize as a slave void TwoWire::begin(uint8_t address) { if(i2cModule == NOT_ACTIVE) { i2cModule = BOOST_PACK_WIRE; } ROM_SysCtlPeripheralEnable(g_uli2cPeriph[i2cModule]); ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][0]); ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][1]); ROM_GPIOPinTypeI2C(g_uli2cBase[i2cModule], g_uli2cSDAPins[i2cModule]); ROM_GPIOPinTypeI2CSCL(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule]); slaveAddress = address; //Enable slave interrupts ROM_IntEnable(g_uli2cInt[i2cModule]); I2CSlaveIntEnableEx(SLAVE_BASE, I2C_SLAVE_INT_DATA | I2C_SLAVE_INT_STOP); HWREG(SLAVE_BASE + I2C_O_SICR) = I2C_SICR_DATAIC | I2C_SICR_STARTIC | I2C_SICR_STOPIC; //Setup as a slave device ROM_I2CMasterDisable(MASTER_BASE); I2CSlaveEnable(SLAVE_BASE); I2CSlaveInit(SLAVE_BASE, address); ROM_IntMasterEnable(); }
int xMotorDriverInit() { SYSCTL_RCGCGPIO_R |= SYSCTL_RCGCGPIO_R10 | SYSCTL_RCGCGPIO_R5; vSemaphoreCreateBinary(changeSpeed); ROM_GPIOPinTypePWM(MOTOR_L_PWM_PORT, MOTOR_L_PWM_PIN); ROM_GPIOPinConfigure(GPIO_PF2_M0PWM2); ROM_GPIOPinTypePWM(MOTOR_R_PWM_PORT, MOTOR_R_PWM_PIN); ROM_GPIOPinConfigure(GPIO_PF3_M0PWM3); GPIO_PORTL_DIR_R |= 0xF; GPIO_PORTL_DEN_R |= 0xF; PWM0_1_GENA_R = 0x8C; PWM0_1_GENB_R = 0x8C; ROM_PWMGenConfigure(PWM0_BASE, PWM_GEN_1, PWM_GEN_MODE_DOWN | PWM_GEN_MODE_GEN_NO_SYNC); ROM_PWMGenPeriodSet(PWM0_BASE, PWM_GEN_1, 256); ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_2, 25); ROM_PWMPulseWidthSet(PWM0_BASE, PWM_OUT_3, 25); ROM_PWMGenEnable(PWM0_BASE, PWM_GEN_1); MOTOR_L_DIR1_PORT &= ~MOTOR_L_DIR1_PIN; MOTOR_L_DIR2_PORT |= MOTOR_L_DIR2_PIN; MOTOR_R_DIR1_PORT &= ~MOTOR_R_DIR1_PIN; MOTOR_R_DIR2_PORT |= MOTOR_R_DIR2_PIN; PWM0_1_CTL_R |= 0x5; PWM0_ENABLE_R |= 0x4 | 0x8; return 0; }
//***************************************************************************** // //! Enable the RGB LED with already configured timer settings //! //! This function or RGBDisable should be called during application //! initialization to configure the GPIO pins to which the LEDs are attached. //! This function enables the timers and configures the GPIO pins as timer //! outputs. //! //! \return None. // //***************************************************************************** void RGBEnable(void) { // // Enable timers to begin counting // ROM_TimerEnable(RED_TIMER_BASE, TIMER_BOTH); ROM_TimerEnable(GREEN_TIMER_BASE, TIMER_BOTH); ROM_TimerEnable(BLUE_TIMER_BASE, TIMER_BOTH); // // Reconfigure each LED's GPIO pad for timer control // ROM_GPIOPinConfigure(GREEN_GPIO_PIN_CFG); ROM_GPIOPinTypeTimer(GREEN_GPIO_BASE, GREEN_GPIO_PIN); MAP_GPIOPadConfigSet(GREEN_GPIO_BASE, GREEN_GPIO_PIN, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD); ROM_GPIOPinConfigure(BLUE_GPIO_PIN_CFG); ROM_GPIOPinTypeTimer(BLUE_GPIO_BASE, BLUE_GPIO_PIN); MAP_GPIOPadConfigSet(BLUE_GPIO_BASE, BLUE_GPIO_PIN, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD); ROM_GPIOPinConfigure(RED_GPIO_PIN_CFG); ROM_GPIOPinTypeTimer(RED_GPIO_BASE, RED_GPIO_PIN); MAP_GPIOPadConfigSet(RED_GPIO_BASE, RED_GPIO_PIN, GPIO_STRENGTH_8MA_SC, GPIO_PIN_TYPE_STD); }
//***************************************************************************** // // Configure the UART and its pins. This must be called before UARTprintf(). // //***************************************************************************** s8 ConfigureUART0(u32 BaudRate, u8 Prio) { if (BaudRate > 115200) { /* 波特率太高,错误返回 */ return(AC_RET_ERROR); } // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Use the internal 16MHz oscillator as the UART clock source. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); // // Initialize the UART for console I/O. // UARTStdioConfig(0, BaudRate, 16000000); return AC_RET_OK; }
// * svm_init ***************************************************************** // * setup pins and PWM hardware to talk to servomotors * // * Assumes system clock already configured * // **************************************************************************** void svm_init(void) { ROM_SysCtlPeripheralEnable(SVM_OUTPUT_PORT); // enable clock to GPIO port ROM_SysCtlPeripheralReset(SVM_OUTPUT_PORT); // reset to clear any previous config // configure output pads GPIOPinTypeGPIOOutput(SVM_OUTPUT_PORT_BASE, SVM_OUTPUT_PINS); // configure PWM ROM_SysCtlPeripheralEnable(SVM_PWM_MODULE); // enable clock to pwm module ROM_SysCtlPWMClockSet(SVM_PWM_FPWM_DIV); // configure clock divider to derive Fpwm from Fsys // wrap 16b PWM counter at 1041 for 3kHz pwm output ROM_PWMDeadBandDisable(SVM_PWM_BASE, SVM_PWM_GEN); // allow PWM0, PWM1 to behave independently ROM_PWMGenConfigure(SVM_PWM_BASE, SVM_PWM_GEN, // configure pwm generator PWM_GEN_MODE_DOWN | // up/down count for center timed PWM PWM_GEN_MODE_NO_SYNC); // outputs from generator behave independently ROM_PWMGenPeriodSet(SVM_PWM_BASE, SVM_PWM_GEN, // sets period for generator to appropriate period SVM_PWM_PERIOD_TICKS); ROM_PWMPulseWidthSet(SVM_PWM_BASE, SVM_1_PWM, 0); // set initial pulse widths to 0 for safety ROM_PWMPulseWidthSet(SVM_PWM_BASE, SVM_2_PWM, 0); // set initial pulse widths to 0 for safety ROM_GPIOPinConfigure(SVM_1_PWM_MUX); // select mux for pwm output hbridge 1 ROM_GPIOPinConfigure(SVM_2_PWM_MUX); // select mux for pwm output hbridge 2 ROM_GPIOPinTypePWM(SVM_OUTPUT_PORT_BASE, SVM_1_PWM_PIN);// do some other step configuring pwm... ROM_GPIOPinTypePWM(SVM_OUTPUT_PORT_BASE, SVM_2_PWM_PIN);// ...exact function is unknown ROM_PWMOutputState(SVM_PWM_BASE, SVM_1_PWM_BIT | SVM_2_PWM_BIT, true); // enable outputs from pwm generator to pins ROM_PWMGenEnable(SVM_PWM_BASE, SVM_PWM_GEN); // enable pwm output generator }
//***************************************************************************** // // Initialize UART0 and set the appropriate communication parameters. // //***************************************************************************** void SetupForUART(void) { // // We need to make sure that UART0 and its associated GPIO port are // enabled before we pass control to the boot loader. The serial boot // loader does not enable or configure these peripherals for us if we // enter it via its SVC vector. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Set GPIO PA0 and PA1 as UART. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Configure the UART for 115200, n, 8, 1 // ROM_UARTConfigSetExpClk(UART0_BASE, g_ui32SysClockFreq, 115200, (UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE | UART_CONFIG_WLEN_8)); // // Enable the UART operation. // ROM_UARTEnable(UART0_BASE); }
void init() { ROM_FPUEnable(); ROM_FPULazyStackingEnable(); ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); GPIO_PORTB_DIR_R = 0x00; GPIO_PORTB_DEN_R = 0xff; ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, LED_RED|LED_GREEN|LED_BLUE); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 1000000); ROM_SysTickEnable(); ROM_SysTickIntEnable(); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0); ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_32_BIT_PER); reset(); }
//***************************************************************************** // // Configure the UART and its pins. This must be called before UARTprintf(). // //***************************************************************************** void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Use the internal 16MHz oscillator as the UART clock source. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, 16000000); // UARTStdioConfig(0, 115200, 16000000); }
/* * UART3 is used to communicate with the Optode. Set UART3 * to 9600 baud, 8, N, 1. Also, set up and enable the RX FIFO interrupt * to receive data. */ void UART3Init(void) { // set up UART3 to the optode ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3); ROM_GPIOPinConfigure(GPIO_PC6_U3RX); //set up the pins ROM_GPIOPinConfigure(GPIO_PC7_U3TX); ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7); //9600 baud, 8, N, 1 ROM_UARTConfigSetExpClk(UART3_BASE, ROM_SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // Enable the UART. ROM_UARTEnable(UART3_BASE); //RX interrupt will occur when FIFO is 1/8 full ROM_UARTFIFOLevelSet(UART3_BASE, UART_FIFO_TX7_8, UART_FIFO_RX1_8); //enable the interrupt ROM_IntEnable(INT_UART3); //flush the RX fifo before enabling the RX interrupt to get rid of residual data while(ROM_UARTCharsAvail(UART3_BASE)) { ROM_UARTCharGetNonBlocking(UART3_BASE); } //Enable the UART peripheral interrupt...receive ROM_UARTIntEnable(UART3_BASE, UART_INT_RX); }
void i2c_0_init() { //enable I2C module 0 ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0); //reset module ROM_SysCtlPeripheralReset(SYSCTL_PERIPH_I2C0); //enable GPIO peripheral that contains I2C 0 // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // Configure the pin muxing for I2C0 functions on port B2 and B3. ROM_GPIOPinConfigure(GPIO_PIN_2); ROM_GPIOPinConfigure(GPIO_PIN_3); // Select the I2C function for these pins. GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2); GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3); // Enable and initialize the I2C0 master module. Use the system clock for // the I2C0 module. The last parameter sets the I2C data transfer rate. // If false the data rate is set to 100kbps and if true the data rate will // be set to 400kbps. ROM_I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), true); //clear I2C FIFOs // HWREG(I2C0_BASE + I2C_O_FIFOCTL) = 80008000; }
static void uart_setup(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); }
static void tm4c123_clib_initialize(void) { unsigned int rate; /* Enable Peripheral Clocks */ ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); /* Enable pin PA0 for UART0 U2RX */ ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinTypeUART(GPIOA_BASE, GPIO_PIN_0); /* Enable pin PA1 for UART0 U2TX */ /* Now modify the configuration of the pins that we unlocked. */ ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIOA_BASE, GPIO_PIN_1); /* * BRD = BRDI + BRDF = UARTSysClk / (16 * BaudRate) * * Scale by 64 to compute the fraction: * * BRD * 64 = (UARTSysClk * 64) / (16 * BaudRate) * BRD * 64 = (UARTSysClk * 4) / (BaudRate) * BRDI = (BRD * 64) / 64; * BRDF = (BRD * 64) % 64; * * Round by 0.5: * * BRD * 64 = (2 * ((UARTSysClk * 4) / (BaudRate)) + 1) / 2 * BRD * 64 = (((UARTSysClk * 8) / (BaudRate)) + 1) / 2 * * UARTSysClk = SystemCoreClock * BaudRate = 115200 */ rate = ((SystemCoreClock * 8) / TM4C123_CLIB_UART_SPEED + 1) >> 1; UART0->CTL = 0; UART0->ECR_UART_ALT = ~0u; UART0->IBRD = rate >> 6; UART0->FBRD = rate & 63; UART0->LCRH = UART_LCRH_WLEN_8 | UART_LCRH_FEN; UART0->IM = 0; UART0->ICR = ~0u; UART0->CTL = (UART_CTL_RXE | UART_CTL_TXE | UART_CTL_UARTEN); tm4c123_clib_initialized = 1; }
void Terminal_Init() { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_1); ROM_UARTConfigSetExpClk(UART0_BASE, g_ui32SysClock, 57600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); ROM_UARTEnable(UART0_BASE); }
//***************************************************************************** // // Configure the UART and its pins. This must be called before UARTprintf(). // //***************************************************************************** void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Use the internal 16MHz oscillator as the UART clock source. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, 16000000); // Configure URAT4 ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4); ROM_GPIOPinConfigure(GPIO_PC4_U4RX); ROM_GPIOPinConfigure(GPIO_PC5_U4TX); ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5); // // Configure the UART for 115,200, 8-N-1 operation. // UARTConfigSetExpClk(UART4_BASE, ROM_SysCtlClockGet(), 115200, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); UARTFlowControlSet(UART4_BASE, UART_FLOWCONTROL_NONE); // // Enable the UART interrupt. // UARTIntDisable(UART4_BASE, 0xFFFFFFFF); UARTIntEnable(UART4_BASE, UART_INT_RX | UART_INT_RT); IntEnable(INT_UART4); }
//Initialize as a master void TwoWire::begin(void) { if(i2cModule == NOT_ACTIVE) { i2cModule = BOOST_PACK_WIRE; } ROM_SysCtlPeripheralEnable(g_uli2cPeriph[i2cModule]); //Configure GPIO pins for I2C operation ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][0]); ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][1]); ROM_GPIOPinTypeI2C(g_uli2cBase[i2cModule], g_uli2cSDAPins[i2cModule]); ROM_GPIOPinTypeI2CSCL(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule]); ROM_I2CMasterInitExpClk(MASTER_BASE, F_CPU, speedMode);//Bus speed if(speedMode==I2C_SPEED_FASTMODE_PLUS)//Force 1Mhz { uint32_t ui32TPR = ((F_CPU + (2 * 10 * 1000000l) - 1) / (2 * 10 * 1000000l)) - 1; HWREG(MASTER_BASE + I2C_O_MTPR) = ui32TPR; } //force a stop condition if(!ROM_GPIOPinRead(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule])) forceStop(); //Handle any startup issues by pulsing SCL if(ROM_I2CMasterBusBusy(MASTER_BASE) || ROM_I2CMasterErr(MASTER_BASE) || !ROM_GPIOPinRead(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule])) { uint8_t doI = 0; ROM_GPIOPinTypeGPIOOutput(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule]); unsigned long mask = 0; do { for(unsigned long i = 0; i < 10 ; i++) { if(speedMode==I2C_SPEED_FASTMODE_PLUS) ROM_SysCtlDelay(F_CPU/1000000/3);//1000Hz=desired frequency, delay iteration=3 cycles else if(speedMode==I2C_SPEED_FASTMODE) ROM_SysCtlDelay(F_CPU/400000/3);//400Hz=desired frequency, delay iteration=3 cycles else ROM_SysCtlDelay(F_CPU/100000/3);//100Hz=desired frequency, delay iteration=3 cycles mask = (i%2) ? g_uli2cSCLPins[i2cModule] : 0; ROM_GPIOPinWrite(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule], mask); } doI++; } while(ROM_I2CMasterBusBusy(MASTER_BASE) && doI < 100); ROM_GPIOPinTypeI2CSCL(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule]); if(!ROM_GPIOPinRead(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule])) forceStop(); } }
void ConfigureUART(void) { // // Enable the GPIO Peripheral used by the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC); // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3); // // Configure GPIO Pins for UART mode. // ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); //GSM MOUDLE // ROM_GPIOPinConfigure(GPIO_PD6_U2RX); // ROM_GPIOPinConfigure(GPIO_PD7_U2TX); ROM_GPIOPinConfigure(GPIO_PC6_U3RX); ROM_GPIOPinConfigure(GPIO_PC7_U3TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_6 | GPIO_PIN_7); // ROM_GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7); // // Use the internal 16MHz oscillator as the UART clock source. // UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC); // UARTClockSourceSet(UART2_BASE, UART_CLOCK_PIOSC); // UARTClockSourceSet(UART3_BASE, UART_CLOCK_PIOSC); UARTConfigSetExpClk(UART3_BASE, SysCtlClockGet(), 9600, (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE)); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, 16000000); IntEnable(INT_UART3); UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT); }
void InitialiseDisplayTFT(void) { /* Enable peripherals */ ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); SysCtlDelay(100); /* Set command and reset pin as outputs */ ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, TFT_RESET_PIN | TFT_COMMAND_PIN); /* Enable CS pin as output */ ROM_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_5); /* Enable pin PB7 for SSI2 SSI2TX */ ROM_GPIOPinConfigure(GPIO_PB7_SSI2TX); ROM_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_7); /* Enable pin PB6 for SSI2 SSI2RX */ ROM_GPIOPinConfigure(GPIO_PB6_SSI2RX); ROM_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_6); /* Enable pin PB4 for SSI2 SSI2CLK */ ROM_GPIOPinConfigure(GPIO_PB4_SSI2CLK); ROM_GPIOPinTypeSSI(GPIO_PORTB_BASE, GPIO_PIN_4); /* Configure the SSI2 port to run at 15.0MHz */ ROM_SSIConfigSetExpClk(SSI2_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 15000000, 8); ROM_SSIEnable(SSI2_BASE); /* Reset the display */ TFT_RESET_HIGH; my_delay_tft(100); TFT_RESET_LOW; my_delay_tft(100); TFT_RESET_HIGH; my_delay_tft(100); /* Send command sequence */ init_sequence_tft(); cursor_y = cursor_x = 0; textcolor = 0xFFFF; textbgcolor = 0x0000; wrap = 1; }
void Init_I2C(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_GPIOPinConfigure(GPIO_PB2_I2C0SCL); ROM_GPIOPinConfigure(GPIO_PB3_I2C0SDA); ROM_GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3); GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2); ROM_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD); ROM_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_OD); ROM_I2CMasterInitExpClk(I2C0_BASE,ROM_SysCtlClockGet(),true); SysCtlDelay(500000); ROM_I2CMasterEnable(I2C0_BASE); }
void cmd_init(void) { // // Enable and Initialize the UART. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); cmd_printf("\nSplitAlarm - UART Loaded\n"); cmd_printf("> "); }
//***************************************************************************** // //! Initializes and enables the specified I2C block. //! //! \param I2C_PORT is the I2C peripheral to be used. //! \param ulI2CSpeed defines the normal (100kbps) or fast (400kbps) I2C mode. //! //! This function enables the specified I2C block and sets it up to run at //! the either 100kbps or 400kbps. If the \e ulI2CSpeed is false, the I2C will //! run at 100kbps and if true, then the I2C will run at 400kbps. The //! \e I2C_PORT parameter can be one of the following values: //! //! \return None. // //***************************************************************************** void SetupI2C(void) { ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6); ROM_GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7); ROM_GPIOPinConfigure(GPIO_PA6_I2C1SCL); ROM_GPIOPinConfigure(GPIO_PA7_I2C1SDA); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C1); ROM_I2CMasterInitExpClk(I2C_PORT, SysCtlClockGet(), 1); // 1 : 400Khz, 0 : 100Khz }
void PWMWrite(uint8_t pin, uint32_t analog_res, uint32_t duty, unsigned int freq) { if (duty == 0) { pinMode(pin, OUTPUT); digitalWrite(pin, LOW); } else if (duty >= analog_res) { pinMode(pin, OUTPUT); digitalWrite(pin, HIGH); } else { uint8_t bit = digitalPinToBitMask(pin); // get pin bit uint8_t port = digitalPinToPort(pin); // get pin port uint8_t timer = digitalPinToTimer(pin); uint32_t portBase = (uint32_t) portBASERegister(port); uint32_t offset = timerToOffset(timer); uint32_t timerBase = getTimerBase(offset); uint32_t timerAB = TIMER_A << timerToAB(timer); if (port == NOT_A_PORT) return; // pin on timer? uint32_t periodPWM = ROM_SysCtlClockGet()/freq; enableTimerPeriph(offset); ROM_GPIOPinConfigure(timerToPinConfig(timer)); ROM_GPIOPinTypeTimer((long unsigned int) portBase, bit); // // Configure for half-width mode, allowing timers A and B to // operate independently // HWREG(timerBase + TIMER_O_CFG) = 0x04; if(timerAB == TIMER_A) { HWREG(timerBase + TIMER_O_CTL) &= ~TIMER_CTL_TAEN; HWREG(timerBase + TIMER_O_TAMR) = PWM_MODE; } else { HWREG(timerBase + TIMER_O_CTL) &= ~TIMER_CTL_TBEN; HWREG(timerBase + TIMER_O_TBMR) = PWM_MODE; } ROM_TimerLoadSet(timerBase, timerAB, periodPWM); ROM_TimerMatchSet(timerBase, timerAB, (analog_res-duty)*periodPWM/analog_res); // // If using a 16-bit timer, with a periodPWM > 0xFFFF, // need to use a prescaler // if((offset < WTIMER0) && (periodPWM > 0xFFFF)) { ROM_TimerPrescaleSet(timerBase, timerAB, (periodPWM & 0xFFFF0000) >> 16); ROM_TimerPrescaleMatchSet(timerBase, timerAB, (((analog_res-duty)*periodPWM/analog_res) & 0xFFFF0000) >> 16); } ROM_TimerEnable(timerBase, timerAB); }
//***************************************************************************** // // Configure the USB controller and power the bus. // // This function configures the USB controller for host operation. // It is assumed that the main system clock has been configured at this point. // // \return None. // //***************************************************************************** void ConfigureUSBInterface(void) { // // Enable the uDMA controller and set up the control table base. // This is required by usblib. // SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA); SysCtlDelay(80); uDMAEnable(); uDMAControlBaseSet(g_sDMAControlTable); // // Enable the USB controller. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Set the USB pins to be controlled by the USB controller. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); ROM_GPIOPinConfigure(GPIO_PD6_USB0EPEN); ROM_GPIOPinTypeUSBDigital(GPIO_PORTD_BASE, GPIO_PIN_6); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Register the host class driver // USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS); // // Open an instance of the mass storage class driver. // g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback); // // Initialize the power configuration. This sets the power enable signal // to be active high and does not enable the power fault. // USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER); // // Force the USB mode to host with no callback on mode changes since // there should not be any. // USBStackModeSet(0, eUSBModeForceHost, 0); // // Wait 10ms for the pin to go low. // SysCtlDelay(g_ui32SysClock/100); // // Initialize the host controller. // USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE); }
void HardwareSerial::begin(unsigned long baud) { // // Initialize the UART. // ROM_SysCtlPeripheralEnable(g_ulUARTInt[uartModule]); //TODO:Add functionality for PinConfigure with variable uartModule ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); // // Only allow a single instance to be opened. // ASSERT(g_ulUARTBase[uartModule] == 0); // // Check to make sure the UART peripheral is present. // if(!ROM_SysCtlPeripheralPresent(g_ulUARTPeriph[uartModule])) { return; } ROM_SysCtlPeripheralEnable(g_ulUARTPeriph[uartModule]); ROM_UARTConfigSetExpClk(g_ulUARTBase[uartModule], ROM_SysCtlClockGet(), baud, (UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE | UART_CONFIG_WLEN_8)); // // Set the UART to interrupt whenever the TX FIFO is almost empty or // when any character is received. // ROM_UARTFIFOLevelSet(g_ulUARTBase[uartModule], UART_FIFO_TX1_8, UART_FIFO_RX1_8); flushAll(); ROM_UARTIntDisable(g_ulUARTBase[uartModule], 0xFFFFFFFF); ROM_UARTIntEnable(g_ulUARTBase[uartModule], UART_INT_RX | UART_INT_RT); ROM_IntMasterEnable(); ROM_IntEnable(g_ulUARTInt[uartModule]); // // Enable the UART operation. // ROM_UARTEnable(g_ulUARTBase[uartModule]); }