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]);
}
