Continue to Site

Welcome to our site!

Electro Tech is an online community (with over 170,000 members) who enjoy talking about and building electronic circuits, projects and gadgets. To participate you need to register. Registration is free. Click here to register now.

  • Welcome to our site! Electro Tech is an online community (with over 170,000 members) who enjoy talking about and building electronic circuits, projects and gadgets. To participate you need to register. Registration is free. Click here to register now.

How to send the USART data through USB to PC.

Status
Not open for further replies.

veerubiji

Member
Hi All,
I am new to programming AVR micro controllers. I have one board which was designed to get some sensor values, which contains ATmega32-A micro controller, AD9833 programmable waveform generator, external ADC and some other peripherals. I have designed the firmware for that board. I have used USART communication (RS232) to display data in hyper terminal. I am sending one command to display the data in hyper terminal. I am using CodeVision AVR compiler.
Now the problem is I have to connect this board to the other board, which having RS232 point. The second board is communicating to the PC using USB communication, which contains AT90USB1287 micro controller and some other peripherals.
I have to send the data what is getting using my board to the PC by connecting this RS232 cable to the second board, which sending data to the PC using USB communication. Please help me how can I transfer the data what I am getting by using USART communication in my board to the PC using second board which is communicating through USB.

thanks in advance.
 
Please help me how can I transfer the data what I am getting by using USART communication in my board to the PC using second board which is communicating through USB.
I don't understand what you mean exact.
To interface an USART to a PC, you can use a FT232R Chip from FTDI.
The second board ist then not needed anymore.
This Chip can only work as USB Slave not as USB Host.

When you want to connect the 2 boards via USB one of them is to have USB Host functionality.
 
I don't understand what you mean exact.
To interface an USART to a PC, you can use a FT232R Chip from FTDI.
The second board ist then not needed anymore.
This Chip can only work as USB Slave not as USB Host.

When you want to connect the 2 boards via USB one of them is to have USB Host functionality.
sorry for not providing clear information,
I have two boards, one having AT90USB1287 micro controller with some peripherals which is connected to the PC via USB and it is working and transferring data to PC. Now I have another board with ATmega32-A controller with some peripherals. I have designed the firmware for the ATmega32-A and i am able to read data using USART communication. Now i have to connect this board with the main board which is connected to the PC via USB. I have connected my board to the main board using RS232. Initially I have connected this RS232 cable to the PC directly now I have connected this RS232 to the main board.

I have to send the data from my board to the PC through main board. main board and my board are connected through RS232. What changes i have to make in the firmware of AT90USB1287 to get data from my board to the PC.

my ATMEGA32 has to send serial data to AT90USB1287 using UART and that data received by AT90USB1287 has to be sent to PC via USB. I have already connected through RS232 cable. i am confusing what changes i have to made in the AT90USB1287 firmware.
 
Ok, now I understand.

I have already connected through RS232 cable. i am confusing what changes i have to made in the AT90USB1287 firmware.
When your AT90USB working as VCP ( Virtual Com Port ) you only have to sample the Mega 32 Data until a complete frame is achieved.
Then transfer that to the send buffer of the VCP interface.
When putting the date from the AT90USB board and the Mega32 Board bytewyse together, you get a mix of both Data on your PC.

To avoid that, you should built complete Data Packets ( Strings ) and put the whole String at once into the send buffer of the USB transmission routine.

How to make that, depends on the USB Data Send routine. When that is Interrupt driven you have to fill a transmissen Buffer, when it's polling then you can put the whole sampled string direct out.
I prefer the interrupt driven variant, because the Controller can do other things between sending of two bytes.
 
Ok, now I understand.


When your AT90USB working as VCP ( Virtual Com Port ) you only have to sample the Mega 32 Data until a complete frame is achieved.
Then transfer that to the send buffer of the VCP interface.
When putting the date from the AT90USB board and the Mega32 Board bytewyse together, you get a mix of both Data on your PC.

To avoid that, you should built complete Data Packets ( Strings ) and put the whole String at once into the send buffer of the USB transmission routine.

How to make that, depends on the USB Data Send routine. When that is Interrupt driven you have to fill a transmissen Buffer, when it's polling then you can put the whole sampled string direct out.
.
It is interrupt driven,

I have tried with some functions like
Code:
while (rx_counter)
{
  uart_putchar(uart_usb_getchar());   // loop back USB to USART
}

while (rx_counter)
{
  //uart_putchar(uart_usb_getchar());   // loop back USB to USART
  uart_usb_putchar(uart_usb_getchar()); //loop back USB to USB
}
but still i can't able to get data from ATmega32-A using UART. Please can you help me how can i get data from second board.

I have attached the files which are communication AT90USB1287 to PC and working as VCP. I am successfully sending commands and receiving data from AT90USB1287 to PC.

I am struggling to get data from ATmega32_A board. i am new to micro controller programming. please help me.
 
Last edited:
I've a little example for an ATMEGA1280:
Code:
/*****************************************************
This program was produced by the
CodeWizardAVR V1.25.5 Standard
Automatic Program Generator
© Copyright 1998-2007 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : 
Version : 
Date    : 20.06.2010
Author  : Wilhelm Krug                    
Company : 92345 Dietfurt, Germany         
Comments: 


Chip type           : ATmega1280
Program type        : Application
Clock frequency     : 14,745600 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size     : 2048
*****************************************************/

#include <mega1280.h>
#include <delay.h>
#include <string.h>

#define RXB8 1
#define TXB8 0
#define UPE 2
#define OVR 3
#define FE 4
#define UDRE 5
#define RXC 7

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<OVR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

// USART0 Receiver buffer
#define RX_BUFFER_SIZE0 16
char rx_buffer0[RX_BUFFER_SIZE0];

#if RX_BUFFER_SIZE0<256
unsigned char rx_wr_index0,rx_rd_index0,rx_counter0;
#else
unsigned int rx_wr_index0,rx_rd_index0,rx_counter0;
#endif

// This flag is set on USART0 Receiver buffer overflow
bit rx_buffer_overflow0;

// USART0 Receiver interrupt service routine
interrupt [USART0_RXC] void usart0_rx_isr(void)
{
char status,data;
status=UCSR0A;
data=UDR0;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer0[rx_wr_index0]=data;
   if (++rx_wr_index0 == RX_BUFFER_SIZE0) rx_wr_index0=0;
   if (++rx_counter0 == RX_BUFFER_SIZE0)
      {
      rx_counter0=0;
      rx_buffer_overflow0=1;
      };
   };
}

#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART0 Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter0==0);
data=rx_buffer0[rx_rd_index0];
if (++rx_rd_index0 == RX_BUFFER_SIZE0) rx_rd_index0=0;
#asm("cli")
--rx_counter0;
#asm("sei")
return data;
}
#pragma used-
#endif

// USART0 Transmitter buffer
#define TX_BUFFER_SIZE0 16
char tx_buffer0[TX_BUFFER_SIZE0];

#if TX_BUFFER_SIZE0<256
unsigned char tx_wr_index0,tx_rd_index0,tx_counter0;
#else
unsigned int tx_wr_index0,tx_rd_index0,tx_counter0;
#endif

// USART0 Transmitter interrupt service routine
interrupt [USART0_TXC] void usart0_tx_isr(void)
{
if (tx_counter0)
   {
   --tx_counter0;
   UDR0=tx_buffer0[tx_rd_index0];
   if (++tx_rd_index0 == TX_BUFFER_SIZE0) tx_rd_index0=0;
   };
}

#ifndef _DEBUG_TERMINAL_IO_
// Write a character to the USART0 Transmitter buffer
#define _ALTERNATE_PUTCHAR_
#pragma used+
void putchar(char c)
{
while (tx_counter0 == TX_BUFFER_SIZE0);
#asm("cli")
if (tx_counter0 || ((UCSR0A & DATA_REGISTER_EMPTY)==0))
   {
   tx_buffer0[tx_wr_index0]=c;
   if (++tx_wr_index0 == TX_BUFFER_SIZE0) tx_wr_index0=0;
   ++tx_counter0;
   }
else
   UDR0=c;
#asm("sei")
}
#pragma used-
#endif

// Standard Input/Output functions
#include <stdio.h>

// Declare your global variables here

void main(void)
{
// Declare your local variables here
unsigned char uc_string[16];
unsigned char uc_i=0;
// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTA=0x00;
DDRA=0x00;

// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTB=0x00;
DDRB=0x00;

// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTD=0x00;
DDRD=0x00;

// Port E initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTE=0x00;
DDRE=0x00;

// Port F initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTF=0x00;
DDRF=0x00;

// Port G initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTG=0x00;
DDRG=0x00;

// Port H initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTH=0x00;
DDRH=0x00;

// Port J initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTJ=0x00;
DDRJ=0x00;

// Port K initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTK=0x00;
DDRK=0x00;

// Port L initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTL=0x00;
DDRL=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: Timer 0 Stopped
// Mode: Normal top=FFh
// OC0A output: Disconnected
// OC0B output: Disconnected
TCCR0A=0x00;
TCCR0B=0x00;
TCNT0=0x00;
OCR0A=0x00;
OCR0B=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: Timer 1 Stopped
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// OC1C output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x00;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;
OCR1CH=0x00;
OCR1CL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2A output: Disconnected
// OC2B output: Disconnected
ASSR=0x00;
TCCR2A=0x00;
TCCR2B=0x00;
TCNT2=0x00;
OCR2A=0x00;
OCR2B=0x00;

// Timer/Counter 3 initialization
// Clock source: System Clock
// Clock value: Timer 3 Stopped
// Mode: Normal top=FFFFh
// Noise Canceler: Off
// Input Capture on Falling Edge
// OC3A output: Discon.
// OC3B output: Discon.
// OC3C output: Discon.
// Timer 3 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR3A=0x00;
TCCR3B=0x00;
TCNT3H=0x00;
TCNT3L=0x00;
ICR3H=0x00;
ICR3L=0x00;
OCR3AH=0x00;
OCR3AL=0x00;
OCR3BH=0x00;
OCR3BL=0x00;
OCR3CH=0x00;
OCR3CL=0x00;

// Timer/Counter 4 initialization
// Clock source: System Clock
// Clock value: Timer 4 Stopped
// Mode: Normal top=FFFFh
// OC4A output: Discon.
// OC4B output: Discon.
// OC4C output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 4 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR4A=0x00;
TCCR4B=0x00;
TCNT4H=0x00;
TCNT4L=0x00;
ICR4H=0x00;
ICR4L=0x00;
OCR4AH=0x00;
OCR4AL=0x00;
OCR4BH=0x00;
OCR4BL=0x00;
OCR4CH=0x00;
OCR4CL=0x00;

// Timer/Counter 5 initialization
// Clock source: System Clock
// Clock value: Timer 5 Stopped
// Mode: Normal top=FFFFh
// OC5A output: Discon.
// OC5B output: Discon.
// OC5C output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 5 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
// Compare C Match Interrupt: Off
TCCR5A=0x00;
TCCR5B=0x00;
TCNT5H=0x00;
TCNT5L=0x00;
ICR5H=0x00;
ICR5L=0x00;
OCR5AH=0x00;
OCR5AL=0x00;
OCR5BH=0x00;
OCR5BL=0x00;
OCR5CH=0x00;
OCR5CL=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
// INT3: Off
// INT4: Off
// INT5: Off
// INT6: Off
// INT7: Off
EICRA=0x00;
EICRB=0x00;
EIMSK=0x00;
// PCINT0 interrupt: Off
// PCINT1 interrupt: Off
// PCINT2 interrupt: Off
// PCINT3 interrupt: Off
// PCINT4 interrupt: Off
// PCINT5 interrupt: Off
// PCINT6 interrupt: Off
// PCINT7 interrupt: Off
// PCINT8 interrupt: Off
// PCINT9 interrupt: Off
// PCINT10 interrupt: Off
// PCINT11 interrupt: Off
// PCINT12 interrupt: Off
// PCINT13 interrupt: Off
// PCINT14 interrupt: Off
// PCINT15 interrupt: Off
// PCINT16 interrupt: Off
// PCINT17 interrupt: Off
// PCINT18 interrupt: Off
// PCINT19 interrupt: Off
// PCINT20 interrupt: Off
// PCINT21 interrupt: Off
// PCINT22 interrupt: Off
// PCINT23 interrupt: Off
PCMSK0=0x00;
PCMSK1=0x00;
PCMSK2=0x00;
PCICR=0x00;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;
// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x00;
// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;
// Timer/Counter 3 Interrupt(s) initialization
TIMSK3=0x00;
// Timer/Counter 4 Interrupt(s) initialization
TIMSK4=0x00;
// Timer/Counter 5 Interrupt(s) initialization
TIMSK5=0x00;

// USART0 initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART0 Receiver: On
// USART0 Transmitter: On
// USART0 Mode: Asynchronous
// USART0 Baud Rate: 115200
UCSR0A=0x00;
UCSR0B=0xD8;
UCSR0C=0x06;
UBRR0H=0x00;
UBRR0L=0x07;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;

// Global enable interrupts
#asm("sei")

while (1)
      {
      //Einfache Senderoutine
      strcpyf(uc_string,"Hallo Welt");
      for(uc_i=0;uc_i<strlen(uc_string);uc_i++)
        {
        putchar(uc_string[uc_i]);
        }
      putchar('\r');                //Carriage Return
      putchar('\n');                //Line Feed
      delay_ms(500);                //500 ms Sekunden Pause da es sonst zu einem Puffer Überlauf kommen würde
      
      /*
      Die Empfangenenen Bytes kannst Du Dir mit variable=getchar(); byteweise aus dem Puffer abholen, 
      so lange die Variable rx_counter größer 0 ist, sind noch Bytes im Empfangspuffer.
      Die Auswertung des Strings starte ich wenn ein <CR> <LF> eintrifft. Die Länge deines Auswertepuffers ist von der
      maximalen Anzahl der übertrgenen Bytes abhängig
      */

      };
}
 
Code:
/*************************************************** 
C O M U N I C A T I O N  RS-232 
****************************************************/ 
unsigned char CompIndex;            // Index in Copmare array 
unsigned char Compare[COMPBUFSIZE]; // Command string tokenizer 
extern unsigned char Command;              // Current Command is executed 
extern unsigned int  Param;                // Parameter used in command 
//       float  Param2;               // Optional (second) parameter used in command 
//unsigned long Param3;               // Optional (third) parameter in command 

unsigned char Step; 

extern unsigned char state; 
extern unsigned int status; 
extern unsigned char debug; 

#define RXB8 1 
#define TXB8 0 
#define UPE 2 
#define OVR 3 
#define FE 4 
#define UDRE 5 
#define RXC 7 

#define FRAMING_ERROR (1<<FE) 
#define PARITY_ERROR (1<<UPE) 
#define DATA_OVERRUN (1<<OVR) 
#define DATA_REGISTER_EMPTY (1<<UDRE) 
#define RX_COMPLETE (1<<RXC) 

// USART Receiver buffer 
#define RX_BUFFER_SIZE0 32 
char rx_buffer0[RX_BUFFER_SIZE0]; 

#if RX_BUFFER_SIZE0<256 
unsigned char rx_wr_index0,rx_rd_index0,rx_counter0; 
#else 
unsigned int rx_wr_index0,rx_rd_index0,rx_counter0; 
#endif 

// This flag is set on USART Receiver buffer overflow 
bit rx_buffer_overflow0; 

// USART Receiver interrupt service routine 
interrupt [USART_RXC] void usart_rx_isr(void){ 
    char status,data; 
    status=UCSRA; 
    data=UDR; 
    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0) 
       { 
       rx_buffer0[rx_wr_index0]=data; 
       if (++rx_wr_index0 == RX_BUFFER_SIZE0) rx_wr_index0=0; 
       if (++rx_counter0 == RX_BUFFER_SIZE0) 
          { 
          rx_counter0=0; 
          rx_buffer_overflow0=1; 
          }; 
       }; 
} 

#ifndef _DEBUG_TERMINAL_IO_ 
// Get a character from the USART Receiver buffer 
#define _ALTERNATE_GETCHAR_ 
#pragma used+                                
char getchar(void){ 
    char data; 
    while (rx_counter0==0); 
    data=rx_buffer0[rx_rd_index0]; 
    if (++rx_rd_index0 == RX_BUFFER_SIZE0) rx_rd_index0=0; 
    #asm("cli") 
    --rx_counter0; 
    #asm("sei") 
    return data; 
} 
#pragma used- 
#endif 

// USART Transmitter buffer 
#define TX_BUFFER_SIZE0 32 
char tx_buffer0[TX_BUFFER_SIZE0]; 

#if TX_BUFFER_SIZE0<256 
unsigned char tx_wr_index0,tx_rd_index0,tx_counter0; 
#else 
unsigned int tx_wr_index0,tx_rd_index0,tx_counter0; 
#endif 

// USART Transmitter interrupt service routine 
interrupt [USART_TXC] void usart_tx_isr(void){ 
    if (tx_counter0){ 
        --tx_counter0; 
        UDR=tx_buffer0[tx_rd_index0]; 
        if (++tx_rd_index0 == TX_BUFFER_SIZE0) tx_rd_index0=0; 
        //#asm("WDR"); // For long words and slow baud-rates 
    } 
} 

#ifndef _DEBUG_TERMINAL_IO_ 
// Write a character to the USART Transmitter buffer 
#define _ALTERNATE_PUTCHAR_ 
#pragma used+ 
void putchar(char c){ 
    while (tx_counter0 == TX_BUFFER_SIZE0); 
    #asm("cli") 
    if (tx_counter0 || ((UCSRA & DATA_REGISTER_EMPTY)==0)){
        tx_buffer0[tx_wr_index0]=c; 
        if (++tx_wr_index0 == TX_BUFFER_SIZE0) tx_wr_index0=0; 
        ++tx_counter0; 
    } 
    else 
    UDR=c; 
    #asm("sei") 
} 
#pragma used- 
#endif

The above code is for ATmega32A. it seems quite similar to your code. I have written this when I using direct transfer between PC and Atmega32A using UART. Now I have connected to Atmega32A board to USB. Is it need to implement UARt for AT90USB1287 as like above.
upto now I have code like this in the ATusb901287 interface to PC.
Code:
/***************************************************
C O M U N I C A T I O N  RS-232
****************************************************/
unsigned char SerIn[SIBUFSIZE];     // Input buffer (raw data)
unsigned char RxCnt;                // Location of next byte to be written
unsigned char RdCnt;                // Location of next byte to be read
unsigned char BufCnt;               // Size of unread contents in ring buffer
unsigned char CompIndex;            // Index in Copmare array
unsigned char Compare[COMPBUFSIZE]; // Command string tokenizer
unsigned char Command;              // Current Command is executed
unsigned int  Param;                // Parameter used in command
       float  Param2;               // Optional (second) parameter used in command
unsigned long Param3;               // Optional (third) parameter in command

extern unsigned char Plot;
unsigned char Step;


// USART1 Receiver interrupt service routine
interrupt [USART1_RXC] void usart1_rx_isr(void){   
    
    if(UCSR1A & 0x1C){       
        SerIn[RxCnt] = UDR1; //Read the corrupted byte          
        return;              // Error
    }

    if(++BufCnt >= SIBUFSIZE){                 // Increment & check for buffer overflow
        BufCnt = SIBUFSIZE-1;                  // Set to max value
        return;                                // Skip char
    }else{                                     // Else: if buffer ok
        if(++RxCnt >= SIBUFSIZE) RxCnt = 0;    // Increment read counter, if 10 -> 0 (max 9)
        SerIn[RxCnt] = UDR1;                   // Write to SBUF (load the transmit register)
    }
}

// USB Receive
void catchString(void){
    
    while(UEBCLX){
    
        if(++BufCnt >= SIBUFSIZE){               // Increment & check for buffer overflow  
            BufCnt = SIBUFSIZE-1;                // Set to max value 
//            printf("!Overflow\r\n");
//            UENUM = 2;   
            return;                              // Skip char
        }else{                                   // Else: if buffer ok
            if(++RxCnt >= SIBUFSIZE) RxCnt = 0;  // Increment read counter, if 10 -> 0 (max 9)
            SerIn[RxCnt] = UEDATX;               // Write to SBUF (load the transmit register)
        }
     }  
}


// Read from ringbuffer
char getcharb(void){

    if(BufCnt){                                 // If anything
        BufCnt--;                               // Decrement buffer counter
        if(++RdCnt >= SIBUFSIZE) RdCnt = 0;     // Increment read counter, if 10 -> 0 (max 9)
        return SerIn[RdCnt];                    // Read from SBUF (access receive register)
    }
    return 0;
}

But i am not able to display data in PC. Help me with this what I have to do.
 
Last edited:
Please help me with that problem. I need to write UART RX&TX functionality for AT90USB1287. Can i use the same code that i have written for ATmega32.
 
Last edited:
I have written Uart TX&Rx functionality for AT90USb1287 like same as above and tested with connecting UART directly to PC, it is working. Now can you help me, how to send received data to USB write buffer. for example can you explain with your code of UART. You have provided some code for me as example data if you send that received data to usb buffer?
 
Status
Not open for further replies.

Latest threads

New Articles From Microcontroller Tips

Back
Top