AVR Freaks

-My application is to read the data coming from host using Target USB port & Send the exact data back through Target USB port .

- I can send whatever data i want. So sending is not a problem.

-The receiving of multiple bytes only creating issue I cant read more that one byte of data.

-For sending and receiving i'm using the same Target USB port .

- EDBG UART port i'm using only for debugging.

This call back will call after the respective transfers  complete. I have given you the link for the code above can you please check the file i'm attaching below and check.

/**
 * \file
 *
 * \brief UART functions
 *
 * Copyright (c) 2014-2018 Microchip Technology Inc. and its subsidiaries.
 *
 * \asf_license_start
 *
 * \page License
 *
 * Subject to your compliance with these terms, you may use Microchip
 * software and any derivatives exclusively with Microchip products.
 * It is your responsibility to comply with third party license terms applicable
 * to your use of third party software (including open source software) that
 * may accompany Microchip software.
 *
 * THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
 * WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
 * INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
 * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
 * LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
 * LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
 * SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
 * POSSIBILITY OR THE DAMAGES ARE FORESEEABLE.  TO THE FULLEST EXTENT
 * ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
 * RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
 * THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
 *
 * \asf_license_stop
 *
 */
/*
 * Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
 */

#include <asf.h>
#include "conf_example.h"
#include "uart.h"
#include "main.h"
#include "ui.h"

/* Structure for USART module connected to EDBG */
struct usart_module usart_module_edbg;

/* Structure for USART parameter configuration */
struct usart_config usart_conf;

/* Data for EDBG communication */
static uint8_t tx_data;
static uint8_t rx_data;

/* USART TX callback flag */
static volatile uint8_t tx_callback_flag = 0;

/**
 * \internal
 * \brief USART interrupt callback function
 *
 * Called by USART driver when transmit is complete.
 *
 * * \param module USART module causing the interrupt (not used)
 */
static void usart_tx_callback(struct usart_module *const module)
{
    tx_callback_flag = 1;
    /* Data ready to be sent */
    if (udi_cdc_is_rx_ready()) {
        /* Transmit next data */
        ui_com_rx_start();
        tx_data = udi_cdc_getc();
        //udi_cdc_write_buf(tx_buff, 10);
        usart_write_buffer_job(&usart_module_edbg, &tx_data, 10);
    } else {
        /* Fifo empty then Stop UART transmission */
        usart_disable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
        ui_com_rx_stop();
    }
    tx_callback_flag = 0;
}

/**
 * \internal
 * \brief USART interrupt callback function
 *
 * Called by USART driver when receiving is complete.
 *
 * * \param module USART module causing the interrupt (not used)
 */
static void usart_rx_callback(struct usart_module *const module)
{
    /* Data received */
    ui_com_tx_start();

    /* Transfer UART RX fifo to CDC TX */
if (!udi_cdc_is_tx_ready()) {
        ///* Fifo full */
        udi_cdc_signal_overrun();
        ui_com_overflow();
    } else {
        //udi_cdc_putc(rx_data);
        udi_cdc_write_buf(&rx_data, 10);  //Writes a RAM buffer on CDC line. 
        
    }

    ui_com_tx_stop();

    usart_read_buffer_job(&usart_module_edbg, &rx_data, 10);//Asynchronous buffer read.Sets up the driver to read from the USART to a given buffer.

                                                                    // If registered and enabled, a callback function will be called.

    return;
}

void uart_rx_notify(uint8_t port)   //CALLED by inface when cdc rec data
{
    UNUSED(port);
    if (!tx_callback_flag) {
        /* Transmit first data */
        ui_com_rx_start();
        usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
        tx_data = udi_cdc_getc();         //Waits and gets a value on CDC line & read
        rx_data=tx_data;
          udi_cdc_putc(rx_data);    //rx_data    Pointer to data to be received -act
        
        usart_write_buffer_job(&usart_module_edbg, &tx_data, 10);
    }
}

void uart_config(uint8_t port,usb_cdc_line_coding_t *cfg)
{
    UNUSED(port);
    /* Configure USART for unit test output */
    usart_get_config_defaults(&usart_conf);
    usart_conf.generator_source = GCLK_GENERATOR_3;

    switch (cfg->bCharFormat) {
    case CDC_STOP_BITS_2:
        usart_conf.stopbits = USART_STOPBITS_2;
        break;

    case CDC_STOP_BITS_1_5:
        usart_conf.stopbits = USART_STOPBITS_1;
        break;

    case CDC_STOP_BITS_1:
    default:
        /* Default stop bit = 1 stop bit */
        usart_conf.stopbits = USART_STOPBITS_1;
        break;
    }

    switch (cfg->bParityType) {
    case CDC_PAR_EVEN:
        usart_conf.parity = USART_PARITY_EVEN;
        break;

    case CDC_PAR_ODD:
        usart_conf.parity = USART_PARITY_ODD;
        break;

    case CDC_PAR_MARK:
        usart_conf.parity = USART_PARITY_NONE;
        break;

    case CDC_PAR_SPACE:
        usart_conf.parity = USART_PARITY_NONE;
        break;

    case CDC_PAR_NONE:
    default:
        usart_conf.parity = USART_PARITY_NONE;
        break;
    }

    switch(cfg->bDataBits) {
    case 5:
        usart_conf.character_size = USART_CHARACTER_SIZE_5BIT;
        break;
    case 6:
        usart_conf.character_size = USART_CHARACTER_SIZE_6BIT;
        break;
    case 7:
        usart_conf.character_size = USART_CHARACTER_SIZE_7BIT;
        break;
    case 8:
    default:
        usart_conf.character_size = USART_CHARACTER_SIZE_8BIT;
        break;
    }

    /* Options for USART. */
    usart_conf.baudrate = LE32_TO_CPU(cfg->dwDTERate);
    usart_conf.mux_setting = CONF_USART_MUX_SETTING;
    usart_conf.pinmux_pad0 = CONF_USART_PINMUX_PAD0;
    usart_conf.pinmux_pad1 = CONF_USART_PINMUX_PAD1;
    usart_conf.pinmux_pad2 = CONF_USART_PINMUX_PAD2;
    usart_conf.pinmux_pad3 = CONF_USART_PINMUX_PAD3;
    usart_disable(&usart_module_edbg);
    usart_init(&usart_module_edbg, CONF_USART_BASE, &usart_conf);
    usart_enable(&usart_module_edbg);

    /* Enable interrupts */
    usart_register_callback(&usart_module_edbg, usart_tx_callback,
            USART_CALLBACK_BUFFER_TRANSMITTED);
    usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
    usart_register_callback(&usart_module_edbg, usart_rx_callback,
            USART_CALLBACK_BUFFER_RECEIVED);
    usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_RECEIVED);
    usart_read_buffer_job(&usart_module_edbg, &rx_data, 10);
}

void uart_open(uint8_t port)
{
    UNUSED(port);

    usart_enable(&usart_module_edbg);
}

void uart_close(uint8_t port)
{
    UNUSED(port);
    /* Close RS232 communication */
    usart_disable(&usart_module_edbg);
}
 

hi,

    Can you help me with how can i fix this issue? what changes i need to make?

IF i change that to one how can i receive more that one byte at a time?

Can you tell me where i need to change in this code?

I'm connecting the TARGET USB PORT to the host and DEBUG PORT to the machine where the atmel studio is running.

The host is sending me data and i'm trying to send it back.  I'm not that much clear with the code flow and all the stuff. I can read and write one byte .

why i cant do it for multiple bytes?

My requirement is to receive more that one byte. Can you point out  the changes which i need to make to read more than one byte of data. 

I'm also do testing here i can also send and receive one byte.

Why cant i do it for multiple bytes?

In my case the host is sending a string "12345" .

The host is sending it 5  times i'm able to read 5 times . The issue is i'm only reading "1"  5  times rest of the string "2345" is missing.

I'm attaching the logs i'm getting from the host side this may help you to understand the problem.

byteArr55-->12345- Data from host to device.

received data ->1-Data get back from device

libusb initialised
handle-->libusb device handle 0x7ff84017f870
device found

count-1
byteArr55-->12345

5-->bytes sent to device
read00
capacity-->64
1 bytes read from device
received data ->1

count-2
byteArr55-->12345

5-->bytes sent to device
read00
capacity-->64
1 bytes read from device
received data ->

count-3
byteArr55-->12345

5-->bytes sent to device
read00
capacity-->64
1 bytes read from device
received data ->1

count-4
byteArr55-->12345

5-->bytes sent to device
read00
capacity-->64
1 bytes read from device
received data ->1

count-5
byteArr55-->12345
10-->bytes sent to device
read00
capacity-->64
1 bytes read from device
received data ->1

This is my issue.Please check

I don't want to notify after each byte . After filling the buffer completely calling call back function is enough. Can you suggest me a change. And send me the code?

Here the functions which i'm using

udi_cdc_getc(); & 

 udi_cdc_putc()

0nly can read and write one byte of data at a time is there any alternatives fo fixing this issue by another read and write calls?