uruchomiłem sobie sprzętowego UARTa wykorzystując bibliotekę ze strony atmela. Wszystko działa, łączę się z terminalem na komputerze, wyświetla się to co powinno. Dodałem też funkcję do wysyłania całego łańcucha znaków wykorzystując wskaźnik, gdyż w atmelowskiej bibliotece znalazłem jedynie do wysyłania konkretnych pojedynczych znaków. Wyczytałem też, że można do komunikacji wykorzystać strumienie printf i scanf. I o ile printf działa poprawnie to ze scanf mam problem. Kod może wydawać się obszerny ze względu na szczegółowe komentarze producenta i wyłączone przeze mnie pewne fragmenty kodu. Oto i kod:
[syntax=c]#include <stdio.h>
#include "usart_driver.h"
#include "usart_driver.c"
#include "avr_compiler.h"
/*! Number of bytes to send in test example. */
#define NUM_BYTES 3
/*! Define that selects the Usart used in example. */
#define USART USARTC0
/*! USART data struct used in example. */
USART_data_t USART_data;
/*! Test data to send. */
uint8_t sendArray[NUM_BYTES] = {0x55, 0x0d,0x0a };
/*! Array to put received data in. */
uint8_t receiveArray[NUM_BYTES];
/*! Success variable, used to test driver. */
bool success;
//void sendString(char *text);
void uart_puts(char *s);
// funkcje dotyczące obsługi strumieni printf i scanf.
static int uart_putchar(char c, FILE *stream);
int uart_getchar(FILE *stream);
static FILE mystdout = FDEV_SETUP_STREAM (uart_putchar, uart_getchar, _FDEV_SETUP_RW);
/*! \brief Example application.
*
* Example application. This example configures USARTC0 for with the parameters:
* - 8 bit character size
* - No parity
* - 1 stop bit
* - 9600 Baud
*
* This function then sends three bytes and tests if the received data is
* equal to the sent data. The code can be tested by connecting PC3 to PC2. If
* the variable 'success' is true at the end of the function, the three bytes
* have been successfully sent and received.
*/
int main(void)
{
CPU_CCP =CCP_IOREG_gc; // odblokowanie modyfikacji ważnych rejestrów
CLK.CTRL=CLK_SCLKSEL_RC2M_gc;
stdout = &mystdout;
stdin = &mystdout;
/* counter variable. */
uint8_t i;
/* This PORT setting is only valid to USARTC0 if other USARTs is used a
* different PORT and/or pins are used. */
/* PC3 (TXD0) as output. */
PORTC.DIRSET = PIN3_bm;
/* PC2 (RXD0) as input. */
PORTC.DIRCLR = PIN2_bm;
/* Use USARTC0 and initialize buffers. */
USART_InterruptDriver_Initialize(&USART_data, &USART, USART_DREINTLVL_LO_gc);
/* USARTC0, 8 Data bits, No Parity, 1 Stop bit. */
USART_Format_Set(USART_data.usart, USART_CHSIZE_8BIT_gc,
USART_PMODE_DISABLED_gc, false);
/* Enable RXC interrupt. */
USART_RxdInterruptLevel_Set(USART_data.usart, USART_RXCINTLVL_LO_gc);
/* Set Baudrate to 9600 bps:
* Use the default I/O clock frequency that is 2 MHz.
* Do not use the baudrate scale factor
*
* Baudrate select = (1/(16*(((I/O clock frequency)/Baudrate)-1)
* = 12
*/
USART_Baudrate_Set(&USART, 12 , 0);
/* Enable both RX and TX. */
USART_Rx_Enable(USART_data.usart);
USART_Tx_Enable(USART_data.usart);
/* Enable PMIC interrupt level low. */
PMIC.CTRL |= PMIC_LOLVLEX_bm;
/* Enable global interrupts. */
sei();
while(1)
{
/* Send sendArray. */
i = 0;
while (i < NUM_BYTES) {
bool byteToBuffer;
byteToBuffer = USART_TXBuffer_PutByte(&USART_data, (char)sendArray[i]);
if(byteToBuffer){
i++;
}
}
success = true;
/*Fetch received data as it is received.
i = 0;
while (i < NUM_BYTES) {
if (USART_RXBufferData_Available(&USART_data)) {
receiveArray[i] = USART_RXBuffer_GetByte(&USART_data);
i++;
}
}*/
/* Test to see if sent data equals received data. */
/* Assume success first.
success = true;
for(i = 0; i < NUM_BYTES; i++) {
//Check that each element is received correctly.
if (receiveArray[i] != sendArray[i]) {
success = false;
}
}*/
/* If success the program ends up inside the if statement.*/
if(success){
PORTC.DIRSET = PIN1_bm;
PORTC.OUTSET = PIN1_bm;
//char znak = 'c';
//USART_PutChar(&USART, znak);
//while(true);
_delay_ms(1000);
PORTC.OUTCLR = PIN1_bm;
//_delay_ms(2000);
}else{
//while(true);
_delay_ms(5000);
}
uart_puts("Hello World!\n\r");
printf("Wpisz cos! printf\n");
char str [80];
scanf("%79s",str);
}
}
/*! \brief Receive complete interrupt service routine.
*
* Receive complete interrupt service routine.
* Calls the common receive complete handler with pointer to the correct USART
* as argument.
*/
ISR(USARTC0_RXC_vect)
{
USART_RXComplete(&USART_data);
}
/*! \brief Data register empty interrupt service routine.
*
* Data register empty interrupt service routine.
* Calls the common data register empty complete handler with pointer to the
* correct USART as argument.
*/
ISR(USARTC0_DRE_vect)
{
USART_DataRegEmpty(&USART_data);
}
void uart_puts(char *s)// funkcja wysyłająca cały łańcuch znaków
{
char c;
while((c = *s++))
{
while (!USART_IsTXDataRegisterEmpty(&USART));
USART_PutChar(&USART, c);
}
}
static int uart_putchar (char c, FILE *stream)// wysyłanie znaku przy pomocy strumienia printf
{
if (c == '\n')
uart_putchar('\r', stream);
// Wait for the transmit buffer to be empty
while ( !( USARTC0.STATUS & USART_DREIF_bm) );
// Put our character into the transmit buffer
USARTC0.DATA = c;
return 0;
}
int uart_getchar(FILE *stream)// odbieranie znaku przy pomocy strumienia scanf
{
while( !(USARTC0_STATUS & USART_RXCIF_bm) );// Wait until data has been received.
char data = USARTC0_DATA;// Temporarly store received data
if(data == '\r') data = '\n';
uart_putchar(data, stream);// Send to console what has been received, so we can see when typing
return data;
}[/syntax]
Zarówno kod do printf jak i scanf brałem z jednego źródła. Printf jak mówiłem działa, a scanf się opiera. Czym może być to spowodowane?
Proszę uprzejmie o wskazówki i pozdrawiam,
Dawid.
PS: W załączniku cały mój projekt i wszystkie potrzebne pliki. Program pisany pod Xmega128A3U.Statystyki: Napisane przez dawid75_75 — 7 sie 2016, o 13:29
]]>
Po czym poznałem? Po prostu program stał w miejscu. Nawet komunikatów z printfa nie dostałem kiedy mam scanf w kodzie. Dopiero jak skasowałem scanfa to wyświetliło mi napisy.