int main(void)
{
char Message[18];
DDRD = 0xFF;
USART_Init(BAUD(1200));
do
{
USART_GetString(Message);
USART_PutString(Message);
}
while (1);
return 0;
}
void GPSDATA::PASER_GPS::startGPS() {
if(conf.GPS_ENABLE == 0){
return;
}
bool error;
bool m_ReadingStarted = false;
// repeating reconnection if problems arise
do {
error = false;
try {
// create the serial device, note it takes the io service and the port name
m_Port = new serial_port(m_IO, conf.GPS_SERIAL_PORT);
// m_Port = new serial_port(m_IO, "/dev/ttyS2");
} catch (...) {
error = true;
PASER_LOG_WRITE_LOG(PASER_LOG_ERROR, "Problem wile trying to access port %s\n", conf.GPS_SERIAL_PORT.c_str());
boost::xtime xt;
boost::xtime_get(&xt, boost::TIME_UTC);
xt.nsec += 1000000000;
boost::thread::sleep(xt);
// after some time try to reconnect;
}
} while (error);
// prepare settings
serial_port_base::baud_rate BAUD(conf.GPS_SERIAL_SPEED); // what baud rate do we communicate at
// serial_port_base::baud_rate BAUD(4800); // what baud rate do we communicate at
serial_port_base::character_size CSIZE2(8); // how big is each "packet" of data (default is 8 bits)
serial_port_base::flow_control FLOW(serial_port_base::flow_control::none); // what flow control is used (default is none)
serial_port_base::parity PARITY(serial_port_base::parity::none); // what parity is used (default is none)
serial_port_base::stop_bits STOP(serial_port_base::stop_bits::one); // how many stop bits are used (default is one)
// go through and set all the options as we need them
// all of them are listed, but the default values work for most cases
m_Port->set_option(BAUD);
m_Port->set_option(CSIZE2);
m_Port->set_option(FLOW);
m_Port->set_option(PARITY);
m_Port->set_option(STOP);
if (!m_ReadingStarted) {
boost::thread t(boost::bind(&boost::asio::io_service::run, &m_IO));
boost::asio::async_read_until(*m_Port, b, '\n',
boost::bind(&GPSDATA::PASER_GPS::Handler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
m_ReadingStarted = true;
}
}
bool serialInterface::openDevice(std::string device, int baudrate) {
ROS_DEBUG("Open Device");
try {
boost::asio::serial_port_base::baud_rate BAUD(baudrate);
serial_.open(device);
serial_.set_option(BAUD);
} catch (boost::system::system_error &e) {
ROS_ERROR("Connection to device %s failed; %s",e.what(), device.c_str());
return 1;
}
/* start the read from the serial device */
serialInterface::readSome();
boost::thread t(boost::bind(&boost::asio::io_service::run, &io_));
return 0;
}
void initialize_board() {
// Configure SPI
init_spi();
// Shift all Zeroes out the SPI line
for (int i = 0; i < 12; i++) {
spi_shift_out(0x00);
spi_latch();
}
rs485_init(BAUD(1000000));
sei();
buttons_init();
diagled_init();
boardaddr_init();
diagled_blink(board_address); // Blink out this board's address
}
void com_init(void interrupt (*isr)(),uchar intno,uint portid,uint baud,uchar data,uchar stop,uchar parity)
{
uchar setbyte;
setbyte=DLAB;
outportb(portid+LINE_CONTROL,setbyte);
outport(portid+DATA,BAUD(baud));
setbyte=data+stop+parity;
outportb(portid+LINE_CONTROL,setbyte);
outportb(portid+INT_ENABLE,0);
outportb(portid+FIFO,0);
outportb(portid+MODEM_CONTROL,0)
setvect(intno,isr);
}
void main(void) {
static uint32_t dataPointer = 0;
static uint32_t readPointer = 0;
static uint32_t dataAddress;
static uint32_t dataLength;
static uint16_t bufPointer = 0;
uint8_t c = 0;
uint8_t uart = 0;
wdtDisable();
// Move Interrupt Vectors into Bootloader Section
c = INTERRUPTMOVE;
INTERRUPTMOVE = c | (1 << IVCE);
INTERRUPTMOVE = c | (1 << IVSEL);
TCRA |= (1 << WGM21); // CTC Mode
#if F_CPU == 16000000
TCRB |= (1 << CS22); // Prescaler: 64
OCR = 250;
#else
#error F_CPU not compatible with timer module. DIY!
#endif
TIMS |= (1 << OCIE); // Enable compare match interrupt
for (uint8_t i = 0; i < serialAvailable(); i++) {
serialInit(i, BAUD(BAUDRATE, F_CPU));
}
sei();
set(buf, 0xFF, sizeof(buf));
debugPrint("YASAB ");
debugPrint(VERSION);
debugPrint(" by xythobuz\n");
while (systemTime < BOOTDELAY) {
for (uint8_t i = 0; i < serialAvailable(); i++) {
if (serialHasChar(i)) {
c = serialGet(i); // Clear rx buffer
uart = i;
goto ok; // Yeah, shame on me...
}
}
}
gotoApplication();
ok:
serialWrite(uart, OKAY);
while (!serialTxBufferEmpty(uart)); // Wait till it's sent
uint32_t t = systemTime;
while (systemTime < (t + BOOTDELAY)) {
if (serialHasChar(uart)) {
if (serialGet(uart) == CONFIRM) {
goto ack; // I deserve it...
}
}
}
gotoApplication();
ack:
serialWrite(uart, ACK);
while (!serialTxBufferEmpty(uart));
dataAddress = readFourBytes(uart, serialGetBlocking(uart));
serialWrite(uart, OKAY);
while (!serialTxBufferEmpty(uart)); // Wait till it's sent
debugPrint("Got address!\n");
dataLength = readFourBytes(uart, serialGetBlocking(uart));
if ((dataAddress + dataLength) >= BOOTSTART) {
serialWrite(uart, ERROR);
} else {
serialWrite(uart, OKAY);
}
while (!serialTxBufferEmpty(uart));
debugPrint("Got length!\n");
while (readPointer < dataLength) {
buf[bufPointer] = serialGetBlocking(uart);
readPointer++;
if (bufPointer < (SPM_PAGESIZE - 1)) {
bufPointer++;
} else {
bufPointer = 0;
program(uart, dataPointer + dataAddress, buf);
dataPointer += SPM_PAGESIZE;
set(buf, 0xFF, sizeof(buf));
serialWrite(uart, OKAY);
}
}
debugPrint("Got data!\n");
if (bufPointer != 0) {
program(uart, dataPointer + dataAddress, buf);
serialWrite(uart, OKAY);
}
uint8_t sreg = SREG;
cli();
boot_spm_busy_wait();
boot_rww_enable(); // Allows us to jump to application
SREG = sreg;
gotoApplication();
}
void rs485_init(void)
{
RS485_RX();
RS485_TXRX_ENABLE();
uart_init(UART_RS485,BAUD(RS485_BAUDRATE),RS485_BUFSIZE,RS485_MUTEX,RS485_MUTEX_PRIO);
}
static void __init sphe_uart_init(void)
{
int baud = BAUD(115200);
UART0_set_baudrate(baud);
}
static rt_err_t sam4_usart_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
{
struct sam4_usart *usart;
RT_ASSERT(serial != RT_NULL);
usart = (struct sam4_usart *)serial->parent.user_data;
/* 复位并禁止USART的发送和接收*/
usart->usart_device->US_CR = US_CR_RSTRX | US_CR_RSTTX
| US_CR_RXDIS | US_CR_TXDIS;
/*config baudrate*/
usart->usart_device->US_BRGR = BAUD(cfg->baud_rate);
/*config databits*/
switch (cfg->data_bits)
{
case DATA_BITS_5:
usart->usart_device->US_MR &=~US_MR_CHRL_8_BIT;
usart->usart_device->US_MR |= US_MR_CHRL_5_BIT;
break;
case DATA_BITS_6:
usart->usart_device->US_MR &=~US_MR_CHRL_8_BIT;
usart->usart_device->US_MR |= US_MR_CHRL_6_BIT;
break;
case DATA_BITS_7:
usart->usart_device->US_MR &=~US_MR_CHRL_8_BIT;
usart->usart_device->US_MR |= US_MR_CHRL_7_BIT;
break;
case DATA_BITS_8:
usart->usart_device->US_MR &=~US_MR_CHRL_8_BIT;
usart->usart_device->US_MR |= US_MR_CHRL_8_BIT;
break;
default:
usart->usart_device->US_MR &=~US_MR_CHRL_8_BIT;
usart->usart_device->US_MR |= US_MR_CHRL_8_BIT;
break;
}
/*config stopbits*/
switch (cfg->stop_bits)
{
case STOP_BITS_1:
usart->usart_device->US_MR&=~(0x03<<12);
usart->usart_device->US_MR |= US_MR_NBSTOP_1_BIT;
break;
case STOP_BITS_2:
usart->usart_device->US_MR&=~(0x03<<12);
usart->usart_device->US_MR |= US_MR_NBSTOP_1_BIT;
break;
default:
usart->usart_device->US_MR&=~(0x03<<12);
usart->usart_device->US_MR |= US_MR_NBSTOP_1_BIT;
break;
}
/*config parity*/
switch (cfg->parity)
{
case PARITY_NONE:
usart->usart_device->US_MR&=~(0x07<<9);
usart->usart_device->US_MR |= US_MR_PAR_NO;
break;
case PARITY_EVEN:
usart->usart_device->US_MR&=~(0x07<<9);
usart->usart_device->US_MR |= US_MR_PAR_EVEN;
break;
case PARITY_ODD:
usart->usart_device->US_MR&=~(0x07<<9);
usart->usart_device->US_MR |= US_MR_PAR_ODD;
break;
default:
usart->usart_device->US_MR&=~(0x07<<9);
usart->usart_device->US_MR |= US_MR_PAR_NO;
break;
}
/*config transfer direction*/
switch (cfg->bit_order)
{
case BIT_ORDER_LSB:
usart->usart_device->US_MR&=~US_MR_MSBF;
break;
case BIT_ORDER_MSB:
usart->usart_device->US_MR|=US_MR_MSBF;
break;
default:
usart->usart_device->US_MR&=~US_MR_MSBF;
break;
}
/*使能USART接收和发送*/
USART0->US_CR = US_CR_RXEN | US_CR_TXEN;
return RT_EOK;
}
void rt_hw_usart_init(void)
{
struct sam4_usart *usart;
#ifdef RT_USING_USART0
usart = &usart0;
usart->usart_device = USART0;
usart->usart_irq = USART0_IRQn;
/*禁止外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4300;
/*使能USART1和PIOA时钟*/
PMC->PMC_PCER0 = ((1UL << ID_PIOA) |
(1UL << ID_USART0) );
/*使能外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4301;
/*配置PA5为USART0的RXD，PA6为USART0的TXD*/
PIOA->PIO_IDR=(PIO_PA5A_RXD0|PIO_PA6A_TXD0);
PIOA->PIO_PUDR=(PIO_PA5A_RXD0|PIO_PA6A_TXD0);
PIOA->PIO_ABCDSR[0]&=~(PIO_PA5A_RXD0|PIO_PA6A_TXD0);
PIOA->PIO_ABCDSR[1]&=~(PIO_PA5A_RXD0|PIO_PA6A_TXD0);
PIOA->PIO_PDR=(PIO_PA5A_RXD0|PIO_PA6A_TXD0);
/* 复位并禁止USART的发送和接收*/
USART0->US_CR = US_CR_RSTRX | US_CR_RSTTX
| US_CR_RXDIS | US_CR_TXDIS;
/*配置USART0的波特率*/
USART0->US_BRGR=BAUD(BAUD_RATE_115200);
/*定义数据位为8bit，停止位为1，校验位为NONE*/
USART0->US_MR = US_MR_USART_MODE_NORMAL| //普通模式
US_MR_CHRL_8_BIT| //数据位为8位
US_MR_NBSTOP_1_BIT| //停止位为1位
US_MR_PAR_NO| //校验位为NONE
US_MR_CHMODE_NORMAL; //普通通道模式
/*禁止 DMA 通道 */
USART0->US_PTCR = US_PTCR_RXTDIS | US_PTCR_TXTDIS;
/*使能USART接收和发送*/
USART0->US_CR = US_CR_RXEN | US_CR_TXEN;
/*使能接收中断*/
USART0->US_IER=US_IER_RXRDY;
/*使能USART0的中断通道*/
NVIC_EnableIRQ(USART0_IRQn);
usart->serial.config.baud_rate = BAUD_RATE_115200;
usart->serial.config.bit_order = BIT_ORDER_LSB;
usart->serial.config.data_bits = DATA_BITS_8;
usart->serial.config.parity = PARITY_NONE;
usart->serial.config.stop_bits = STOP_BITS_1;
usart->serial.config.invert = NRZ_NORMAL;
usart->serial.ops = &sam4_usart_ops;
usart->serial.int_rx = &usart->int_rx;
/* register UART1 device */
rt_hw_serial_register(&usart->serial,
"usart0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
usart);
#endif // RT_USING_USART0
#ifdef RT_USING_USART1
usart = &usart1;
usart->usart_device = USART1;
usart->usart_irq = USART1_IRQn;
/*禁止外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4300;
/*使能USART1和PIOB时钟*/
PMC->PMC_PCER0 = ((1UL << ID_PIOA) |
(1UL << ID_USART1) );
/*使能外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4301;
/*配置PA21为USART1的RXD，PA22为USART1的TXD*/
PIOA->PIO_IDR=(PIO_PA21A_RXD1|PIO_PA22A_TXD1);
PIOA->PIO_PUDR=(PIO_PA21A_RXD1|PIO_PA22A_TXD1);
PIOA->PIO_ABCDSR[0]&=~(PIO_PA21A_RXD1|PIO_PA22A_TXD1);
PIOA->PIO_ABCDSR[1]&=~(PIO_PA21A_RXD1|PIO_PA22A_TXD1);
PIOA->PIO_PDR=(PIO_PA21A_RXD1|PIO_PA22A_TXD1);
/* 复位并禁止USART的发送和接收*/
USART1->US_CR = US_CR_RSTRX | US_CR_RSTTX
| US_CR_RXDIS | US_CR_TXDIS;
/*配置USART1的波特率*/
USART1->US_BRGR=BAUD(BAUD_RATE_115200);
/*定义数据位为8bit，停止位为1，校验位为NONE*/
USART1->US_MR = US_MR_USART_MODE_NORMAL| //普通模式
US_MR_CHRL_8_BIT| //数据位为8位
US_MR_NBSTOP_1_BIT| //停止位为1位
US_MR_PAR_NO| //校验位为NONE
US_MR_CHMODE_NORMAL; //普通通道模式
/*禁止 DMA 通道 */
USART1->US_PTCR = US_PTCR_RXTDIS | US_PTCR_TXTDIS;
/*使能USART接收和发送*/
USART1->US_CR = US_CR_RXEN | US_CR_TXEN;
/*使能接收中断*/
USART1->US_IER=US_IER_RXRDY;
/*使能USART1的中断通道*/
NVIC_EnableIRQ(USART1_IRQn);
usart->serial.config.baud_rate = BAUD_RATE_115200;
usart->serial.config.bit_order = BIT_ORDER_LSB;
usart->serial.config.data_bits = DATA_BITS_8;
usart->serial.config.parity = PARITY_NONE;
usart->serial.config.stop_bits = STOP_BITS_1;
usart->serial.config.invert = NRZ_NORMAL;
usart->serial.ops = &sam4_usart_ops;
usart->serial.int_rx = &usart->int_rx;
/* register UART1 device */
rt_hw_serial_register(&usart->serial,
"usart1",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
usart);
#endif // RT_USING_USART1
#ifdef RT_USING_USART2
usart = &usart2;
usart->usart_device = USART2;
usart->usart_irq = USART2_IRQn;
/*禁止外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4300;
/*使能USART2和PIOA时钟*/
PMC->PMC_PCER0 = ((1UL << ID_PIOC) |
(1UL << ID_USART2) );
/*使能外设管理控制寄存器(PMC)写保护*/
PMC->PMC_WPMR = 0x504D4301;
/*配置PC9为USART2的RXD，PC10为USART2的TXD*/
PIOC->PIO_IDR=(PIO_PC9A_RXD2|PIO_PC10A_TXD2);
PIOC->PIO_PUDR=(PIO_PC9A_RXD2|PIO_PC10A_TXD2);
PIOC->PIO_ABCDSR[0]&=~(PIO_PC9A_RXD2|PIO_PC10A_TXD2);
PIOC->PIO_ABCDSR[1]&=~(PIO_PC9A_RXD2|PIO_PC10A_TXD2);
PIOC->PIO_PDR=(PIO_PC9A_RXD2|PIO_PC10A_TXD2);
/* 复位并禁止USART的发送和接收*/
USART2->US_CR = US_CR_RSTRX | US_CR_RSTTX
| US_CR_RXDIS | US_CR_TXDIS;
/*配置USART2的波特率*/
USART2->US_BRGR=BAUD(BAUD_RATE_115200);
/*定义数据位为8bit，停止位为1，校验位为NONE*/
USART2->US_MR = US_MR_USART_MODE_NORMAL| //普通模式
US_MR_CHRL_8_BIT| //数据位为8位
US_MR_NBSTOP_1_BIT| //停止位为1位
US_MR_PAR_NO| //校验位为NONE
US_MR_CHMODE_NORMAL; //普通通道模式
/*禁止 DMA 通道 */
USART2->US_PTCR = US_PTCR_RXTDIS | US_PTCR_TXTDIS;
/*使能USART接收和发送*/
USART2->US_CR = US_CR_RXEN | US_CR_TXEN;
/*使能接收中断*/
USART2->US_IER=US_IER_RXRDY;
/*使能USART2的中断通道*/
NVIC_EnableIRQ(USART2_IRQn);
usart->serial.config.baud_rate = BAUD_RATE_115200;
usart->serial.config.bit_order = BIT_ORDER_LSB;
usart->serial.config.data_bits = DATA_BITS_8;
usart->serial.config.parity = PARITY_NONE;
usart->serial.config.stop_bits = STOP_BITS_1;
usart->serial.config.invert = NRZ_NORMAL;
usart->serial.ops = &sam4_usart_ops;
usart->serial.int_rx = &usart->int_rx;
/* register UART2 device */
rt_hw_serial_register(&usart->serial,
"usart2",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX,
usart);
#endif // RT_USING_USART2
}
