int Xbee_init() {
uint8_t garbage;
int ret;
//init the serial link
#ifdef ARCH_X86_LINUX
ret=UART_init(XBEE_UART_PATH,E_115200_8N2);
#elif defined(ARCH_328P_ARDUINO)
Xbee_rst();
ret=UART_init(NULL,111111);
#elif defined(ARCH_LM4FXX)
Xbee_rst();
ret=UART_init(NULL,111111);
#else
#error "no arch defined for Xbee4sb.c, or arch no available (yet)"
#endif
if (ret<0) return ret;
//waits for the Xbee to totally start
uint32_t sw=0;
while( testTimeout(10000000,&sw));
//clear in buffer from remaining bytes
while ( serialReadEscaped(&garbage,1000)>0 );
return 0;
}
int main(void) {
unsigned char s[80];
int n;
UART_init(); // in UART.c
sei(); // Global interrupt enable
//fdevopen( UART_fputc, UART_fgetc ); // establish buffered I/O callbacks
for(;;) {
// this demos the small memory function set. See below for FILE buffered version.
UART_puts_P(PSTR("Enter text\r\n"));
n = UART_gets(s, sizeof(s)-2);
s[strlen(s)-1] = 0; // drop the ending \r
UART_puts_P(PSTR("You entered '"));
UART_puts(s);
UART_puts_P(PSTR("' length="));
UART_puts(itoa(n, s, 10));
UART_puts_P(PSTR("\n\r"));
// uncomment this to use the buffered I/O (memory hog).
// and fdevopen(), above too.
/* Same function as printf() but the format string resides in flash */
//printf_P(PSTR("Enter text\r\n"));
//fgets(s, sizeof(s)-1, stdin);
//s[strlen(s)-2] = 0; // drop the ending \r\n
//printf_P(PSTR("\r\nYou entered '%s'\r\n"),s);
}
}
int main(void)
{
char c; // odebrany znak
UART_init(); // inicjalizacja portu szeregowego
LCD_init(); // inicjalizacja wy�wietlacza LCD
LCD_PL_chars_init(); // polskie znaki na wy�wietlaczu LCD
KBD_init(); // inicjalizacja klawiatury
LED7SEG_init(); // inicjalizacja wy�wietlacza
sei(); // w��cz obs�ug� przerwa�
while(1) // p�tla niesko�czona
{
PCF8583_get_time(&godz,&min,&sek,&ssek);
LED7SEG_putU08(sek); // wy�wietlaj warto��
if (UART_rxlen()>0) // je�li odebrano znak
{
c=UART_getchar();
// tu mo�na wstawi� reakcje na komendy steruj�ce np. typu ESC[
LCD_putchar(c); // wy�wietl go na LCD
}
if (KBD_read()) // je�li naci�ni�to klawisz
{
if ((KBD_ascii>='A')&&(KBD_ascii<='D'))
UART_putstr_P(CURSOR); // sterowanie kursorem
UART_putchar(KBD_ascii); // wy�lij go na port szeregowy
KBD_wait(); // czekaj na zwolnienie klawisza
}
}
}
int main(void)
{
uint16_t adc_result;
int i;
char value[10];
sbi(DDRB, 4);
sbi(DDRC, 5);
cbi(PORTB,4);
sbi(PORTC,5);
UART_init(250000);
InitADC();
sei();
while(1)
{
adc_result=ReadADC(2); // Read Analog value from channel-2
// Voltage = adc_result*5/1024
// Temperature = (V - 1035 mV)/(-5.5 (mV/oC))
itoa(adc_result,value,10);
for(i=0;i<=2;i++){
UART_TxChar(value[i]);}
UART_TxStr("\n\r\0");
PORTB ^= (1<<PB4);
_delay_ms(100);
}
}
int main(void)
{
int SYSm;
/* Initialise MPU, I/O and SysTick */
SCS_init();
UART_init();
SysTick_init();
/* Finally change Thread mode to unprivileged
* but continue using Main Stack Pointer */
SYSm = __MRS_control();
SYSm |= 1;
__MSR_control(SYSm);
/* Flush and refill pipline with unprivileged permissions */
__ISB();
printf("Cortex-M3 Example - Build 3\n");
/* Loop forever */
while( 1 )
{
Display_80((char*) ".");
}
}
/**
* /fn SetupUartTask
* /brief Setup UART tasks.
*
* Task has priority 15 and receives 1kB of stack.
*
* /return Always 0. In case of error the system halts.
*/
int SetupUartTask(void) {
Task_Params taskTransferParams;
Task_Handle taskTransfer;
Error_Block eb;
/* Enable and configure the peripherals used by the UART7 */
SysCtlPeripheralEnable(GPIO_PORTC_BASE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
GPIOPinConfigure(GPIO_PC4_U7RX);
GPIOPinConfigure(GPIO_PC5_U7TX);
GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
/* Enable and configure the peripherals used by the UART6 */
SysCtlPeripheralEnable(GPIO_PORTP_BASE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART6);
GPIOPinConfigure(GPIO_PP0_U6RX);
GPIOPinConfigure(GPIO_PP1_U6TX);
GPIOPinTypeUART(GPIO_PORTP_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UART_init();
InitializeLedUserSwitch();
Error_init(&eb);
Task_Params_init(&taskTransferParams);
taskTransferParams.stackSize = 1024;
taskTransferParams.priority = 15;
taskTransfer = Task_create((Task_FuncPtr) TransferFunction,
&taskTransferParams, &eb);
if (taskTransfer == NULL) {
System_abort("UART task create failed");
}
return (0);
}
int main(void)
{
Board_init();
UART_init(UART2_ID,9600);
printf("\r\nUno Serial Test Harness\r\nAfter this Message the terminal should mirror anything you type.\r\n");
unsigned char ch = 0;
int x;
while (1) {
if (UART_isTransmitEmpty(UART1_ID) == TRUE){
if (UART_isReceiveEmpty(UART1_ID) == FALSE){
ch = UART_getChar(UART1_ID);
UART_putChar(UART1_ID, ch);
printf(" Through UART2: ");
UART_putChar(UART2_ID, ch);
x = 1024;
while(--x){
if(UART_isReceiveEmpty(UART2_ID) ==FALSE)
break;
}
if(UART_isReceiveEmpty(UART2_ID) == FALSE){
printf("%c\n", UART_getChar(UART2_ID));
} else{
printf("FAILED\n");
}
//DELAY(1000)
}
}
}
return 0;
}
void Setup(void) {
PinSetMode();
// setup internal clock for 72MHz/36MIPS
// 12 /2 = 6 *24 = 144 / 2=72
CLKDIVbits.PLLPRE = 0; // PLLPRE (N2) 0=/2c
CLKDIVbits.DOZE = 0;
PLLFBD = 22; // pll multiplier (M) = +2
CLKDIVbits.PLLPOST = 0; // PLLPOST (N1) 0=/2
// Initiate Clock Switch to Primary Oscillator with PLL (NOSC = 0b011)
__builtin_write_OSCCONH(0x03);
__builtin_write_OSCCONL(OSCCON | 0x01);
// Wait for Clock switch to occur
while (OSCCONbits.COSC != 0b011);
while (!OSCCONbits.LOCK); // wait for PLL ready
INTCON1bits.NSTDIS = 1; //no nesting of interrupts
timerOne();
initADC();
//timerTwo();
begin(receiveArray, sizeof (receiveArray), SAS_ADDRESS, false, Send_put, Receive_get, Receive_available, Receive_peek);
UART_init();
//UART1_init();
//begin(receiveArray1, sizeof (receiveArray1), SAS_ADDRESS, false, Send_put1, Receive_get1, Receive_available1, Receive_peek1);
}
void main (void)
{
//Stop WDT
WDT_hold(__MSP430_BASEADDRESS_WDT_A__);
//P3.4,5 = USCI_A0 TXD/RXD
GPIO_setAsPeripheralModuleFunctionInputPin(__MSP430_BASEADDRESS_PORT3_R__,
GPIO_PORT_P3,
GPIO_PIN4 + GPIO_PIN5
);
//Initialize USCI UART module
if ( STATUS_FAIL == UART_init(__MSP430_BASEADDRESS_USCI_A0__,
UART_CLOCKSOURCE_SMCLK,
UCS_getSMCLK(__MSP430_BASEADDRESS_UCS__),
BAUD_RATE,
UART_NO_PARITY,
UART_LSB_FIRST,
UART_ONE_STOP_BIT,
UART_MODE,
UART_OVERSAMPLING_BAUDRATE_GENERATION
)){
return;
}
//Enable UART module for operation
UART_enable(__MSP430_BASEADDRESS_USCI_A0__);
//Enable Receive Interrupt
UART_enableInterrupt(__MSP430_BASEADDRESS_USCI_A0__, UART_RECEIVE_INTERRUPT);
//Enter LPM3, interrupts enabled
__bis_SR_register(LPM3_bits + GIE);
__no_operation();
}
int main(void) {
OSC_init();
TRISA = 0b00000000;
TRISB = 0b00000011;
TRISC = 0b10000000;
ANCON0 = 0b11111111;
ANCON1 = 0b00011111;
INTCON2bits.RBPU = 0; // Pull-up enable
timer0_init(3);
UART_init();
uint8_t txbuf[100];
ringbuf_init(&tx_buf, txbuf, sizeof (txbuf));
INTCONbits.GIE = 1;
while (1) {
static int16_t prev_e;
if (encoder != prev_e) {
prev_e = encoder;
if (encoder < 0) {
tx_send('-');
tx_sendn(-encoder, 5);
tx_send('\n');
} else {
tx_sendn(encoder, 5);
tx_send('\n');
}
}
}
return 0;
}
int main(void)
{
DDRB = 0xFF;
PORTB = 0x20;
// use CLK/1024 prescale value, clear timer/counter on compareA match
TCCR1B = (1<<CS10) | (1<<CS12) | (1<<WGM12);
// preset timer1 high/low byte
OCR1A = ((F_CPU/1024) - 1 );
// enable Output Compare 1 overflow interrupt
//TIMSK = (1<<OCIE1A);
// Enable interrupts
sei();
UART_init(4800);
UART_putchar('W');
UART_putchar('\n');
UART_putchar('\r');
UART_puts("Hello World!\n\r");
UART_puts("This is a longer message!\n\rLet's hope it works well enough...\n\r");
UART_puts("Hello World! 1\n\r");
UART_puts("Hello World! 2\n\r");
UART_puts("Hello World! 3\n\r");
unsigned int i = 0;
while (1) {
i++;
PORTB ^= 0x20;
char charbuf[100];
sprintf(charbuf, "Loop number %d\n\r",i);
UART_puts(charbuf);
}
}
//*****************************************************************************
//
// 板级开发包初始化
//
//*****************************************************************************
void BSP_init(void)
{
// Set the clocking to run directly from the crystal.
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
// Enable processor interrupts.
IntMasterEnable();
// Configure SysTick for a periodic interrupt.
SysTickPeriodSet(SysCtlClockGet() / SYSTICKHZ);
SysTickEnable();
SysTickIntEnable();
// Initialize the DEBUG UART. (UART0)
DEBUG_UART_init();
// Initialize the IO Hardware. (LED/SOL/I2C_HOTSWAP)
IO_init();
// Initialize the UART Hardware. (ICMB/SOL)
UART_init();
// Initialize the SPI Hardware. (SSIF)
SPI_init();
// Initialize the I2C Hardware. (IPMB/PMB)
I2C_init();
// Initialize the Ethernet Hardware. (LAN)
ETH_init();
}
uint8_t Xbee_init(uint8_t uartId){
xbeeUartId = uartId;
UART_init(uartId,XBEE_BAUD_RATE);
#ifdef XBEE_REPROGRAM_SETTINGS
if( programMode() == FAILURE){
while(1);
return FAILURE;
}
#else
/*
int i = 0;
char confirm[3];
DELAY(2000);
UART_putString(uartId, "+++", 3);
DELAY(API_DELAY);
//wait for "OK\r"
do {
confirm[i] = UART_getChar(XBEE_UART_ID);
if (confirm[i] != 0)
i++;
} while(i < 3);
if (!(confirm[0] == 0x4F && confirm[1] == 0x4B && confirm[2] == 0x0D)){
return FAILURE;
}
* */
#endif
return SUCCESS;
}
void __main(void)
{
uint8_t k;
uint32_t i;
UART_init();
TMR16_Init();
GPIO_init();
if ( SysTick_Config(12000000) ) {
while(1);
}
__enable_irq();
puts("LPC1114 UART Test\r\n");
while(1) {
for ( k = 0; k < 8*3; k++ ) {
LPC_TMR16B1->MR0 = Freq[k];
LPC_TMR16B1->TCR = 1;
for (i = 0xfffff; i !=0; i--);
LPC_TMR16B1->TCR = 0;
LPC_TMR16B1->TCR |= (1 << 1);
}
}
}
/*
* UART_open( )
* Open UART handle and configure it for 115200 baud
*
*/
Int16 EZDSP5535_UART_open( )
{
CSL_Status status;
CSL_UartConfig Config;
/*
* Configuring for baud rate of 115200
* Divisor = UART input clock frequency / (Desired baud rate*16)
* = 100MHz / 115200 / 16
* = 54 = 0x36
*/
Config.DLL = 0x36; // Set baud rate
Config.DLH = 0x00;
Config.FCR = 0x0000; // Clear UART TX & RX FIFOs
Config.LCR = 0x0003; // 8-bit words,
// 1 STOP bit generated,
// No Parity, No Stick paritiy,
// No Break control
Config.MCR = 0x0000; // RTS & CTS disabled,
// Loopback mode disabled,
// Autoflow disabled
status = UART_init(&uartObj, CSL_UART_INST_0, UART_INTERRUPT);
hUart = (CSL_UartHandle)&uartObj;
status |= UART_reset(hUart);
status |= UART_config(hUart,&Config);
status |= UART_resetOff(hUart);
CSL_SYSCTRL_REGS->EBSR &= ~0xF000; //
CSL_SYSCTRL_REGS->EBSR |= 0x1000; // Set parallel port to mode 1 (SPI, GPIO, UART, and I2S2)
return status;
}
int main(void)
{
initTimeOut();
initQueue();
UART_init();
LCDInit();
clearMem(WHITE);
LCDStart();
refresh();
while (1) {
if (msg_flag) {
if(RxBuffer[0] == 1){
printNewMsg();
START_TIMEOUT;
} else if(RxBuffer[0] == 2){
uint8_t h = RxBuffer[1]-1;
uint8_t m = RxBuffer[2]-1;
uint8_t s = RxBuffer[3]-1; //since it's probably a bad idea to have a data value that's the same as the string terminator
RTCinit(h,m,s);
rtc_time_flag = 1;
}
msg_flag = 0;
RxBuffer[0] = 0;
}if (rtc_time_flag) {
printTime();
rtc_time_flag = 0;
}
}
}
int main(void)
{
CLK_init();
SYS_init();
UART_init();
ADC_init();
PWM_init(); //Initialize PWM (servos not running)
PWM_dutySet(500, 200);
_bis_SR_register(LPM0_bits + GIE); // interrupts enabled
while(1)
{
//_ldrL_ADCVal = _readADC(INCH_4); //Read ADC input on P2.1
//_ldrR_ADCVal = _readADC(INCH_5); //Read ADC input on P2.2
UART_puts((char *)"\n\r");
UART_puts((char *)"_ldrL_ADCVal: ");
UART_outdec(_ldrL_ADCVal, 0);
UART_puts((char *)"\n\r");
UART_puts((char *)"_ldrR_ADCVal: ");
UART_outdec(_ldrR_ADCVal, 0);
_delay_cycles(125000);
P1OUT ^= (BIT0 + BIT6);
}
}
/*
* ======== SENSORTAG_CC2650_initUART ========
*/
Void SENSORTAG_CC2650_initUART()
{
/* Initialize the UART driver */
UART_init();
/* Initialize the UART IOs */
UARTCC26XX_ioInit(UART_config);
}
void init(){
init_parametre();
PWM1_init ();
QEI_init ();
io_init();
UART_init();
timer_init();
}
char Serial_init()
{
#ifdef DEBUG
printf("Intializing the Serial on UART %d.\n", SERIAL_UART_ID);
#endif
UART_init(SERIAL_UART_ID,SERIAL_UART_BAUDRATE);
return SUCCESS;
}
/**
* usage: this method sets up the environment to make sure the UART interface can be used
* @method initializeUART
* @author: patrik.szabo
* @param *none*
* @return *none*
*/
void initializeUART() {
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UART_init();
}
int main()
{
UART_init();
TWI_init();
sei();
while (1);
return 0;
}
void init(){
init_osc();
__builtin_write_OSCCONL(OSCCON & ~(0x40)); // Débloquage des RPIN et RPOR
io_init();
PWM1_init ();
QEI_init ();
UART_init();
__builtin_write_OSCCONL(OSCCON | 0x40); // Rebloquage des RPIN et RPOR
}
static void UART_putc(unsigned char ch)
{
if (init_UART_done == 0) {
UART_init();
init_UART_done++;
}
while ((AT91C_BASE_DBGU->DBGU_CSR & AT91C_US_TXRDY) == 0) __nop();
AT91C_BASE_DBGU->DBGU_THR = ch;
}
void _init(void)
{
UART_init( &g_uart, COREUARTAPB0_BASE_ADDR, BAUD_VALUE_115200, (DATA_8_BITS | NO_PARITY) );
extern int main(int, char**);
const char *argv0 = "hello";
char *argv[] = {(char *)argv0, NULL, NULL};
exit(main(1, argv));
}
/*
* ======== Board_openUART ========
* Initialize the UART driver.
* Initialize the UART port's pins.
* Open the UART port.
*/
UART_Handle Board_openUART(UInt uartPortIndex, UART_Params *uartParams)
{
/* Initialize the UART driver */
/* By design, UART_init() is idempotent */
UART_init();
/* initialize the pins associated with the respective UART */
switch(uartPortIndex) {
case 0:
/* Serial */
/* enable UART1 clock */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA1, PRCM_RUN_MODE_CLK);
/*
* Configure LaunchPad P2.9 as a UART1: UART1 TX (via USB port)
* device pin: 55 (UART1_TX)
* Wiring id : 12
*/
MAP_PinTypeUART(PIN_55, PIN_MODE_6);
/*
* Configure LaunchPad P3.3 as a UART1: UART1 RX (via USB port)
* device pin: 57 (UART1_RX)
* Wiring id : 23
*/
MAP_PinTypeUART(PIN_57, PIN_MODE_6);
break;
case 1:
/* Serial1 */
/* enable UART0 clock */
MAP_PRCMPeripheralClkEnable(PRCM_UARTA0, PRCM_RUN_MODE_CLK);
/*
* Configure LaunchPad P1.4 as a UART0: UART0 TX
* device pin: 3 (UART0_TX)
* Wiring id : 4
*/
MAP_PinTypeUART(PIN_03, PIN_MODE_7);
/*
* Configure LaunchPad P1.3 as a UART0: UART0 RX
* device pin: 4 (UART0_RX)
* Wiring id : 3
*/
MAP_PinTypeUART(PIN_04, PIN_MODE_7);
break;
default:
return (NULL);
}
/* open the UART */
return (UART_open(uartPortIndex, uartParams));
}
int main(void) {
volatile float zz = 360.0 * zz;
// clear stripe
for(uint16_t i = 0; i < LED; i++){
stripe[i].blue = 0;
stripe[i].green = 0;
stripe[i].red = 0;
}
// run uart
UART_init();
UART_SendString("STM32F103WS2812 says hello\n\0");
//WS2812_Init();
//WS2812_clear();
Delay(5000000L);
Animator_Init();
while(1){
for(uint16_t j = 1; j < LED; j++){
// wandering light
for(uint16_t i = 0; i < LED; i++){
stripe[i].blue = 0;
stripe[i].green = 0;
stripe[i].red = 0;
}
stripe[j].red = 0xAF;
stripe[j].green = 0;
stripe[j].blue = 0;
// first led bugfix? pegel zu klein?
// if(j!=0){
// stripe[0].blue = 1;
// }
//WS2812_Init();
// WS2812_send(stripe, LED);
Delay(7500000L);
//while(1);
}
}
}
int main() /////////////////////////////////// MASTER ///////////////////////////////////////////
{
CLEAR_BIT(DDRA,PA0); // motor start button
CLEAR_BIT(PORTA,PA0); // motor start button initialization
CLEAR_BIT(DDRA,PA1); // motor stop button
CLEAR_BIT(PORTA,PA1); // motor stop button initialization
CLEAR_BIT(DDRA,PA2); // request motor status button
CLEAR_BIT(PORTA,PA2); // request motor status button initialization
SET_BIT(DDRC,PC0); // status led
CLEAR_BIT(PORTC,PC0); // status led initialization
UART_init(); // UART module initialization
uint8 motorStatus;
while(1)
{
if(BIT_IS_SET(PINA,PA0))
{
_delay_ms(250);
UART_sendByte('A'); // turn motor on
}
if(BIT_IS_SET(PINA,PA1))
{
_delay_ms(250);
UART_sendByte('B'); // turn motor off
}
if(BIT_IS_SET(PINA,PA2))
{
_delay_ms(250);
UART_sendByte('G'); // request motor status
motorStatus = UART_recieveByte(); // update led
switch(motorStatus)
{
case 0:
CLEAR_BIT(PORTC,PC0);
break;
case 1:
SET_BIT(PORTC,PC0);
break;
}
}
}
return 0;
}
int main()
{
DDRB = 0xff;
PORTB = 0x00;
UART_init();
TWI_init();
sei();
while (1);
return 0;
}
int main()
{
UART_init(9600); // 把串口波特率配置为9600
while(1)
{
delay();
UART_send("www.rationMCU.com", 17);//串口发送字符串数组
UART_send_byte('\n'); //串口发送换行符字节
}
}
