Daten via USART senden auf SAM V71

[TomMy (Gast)]

Hallo zusammen,

ich arbeite schon länger an einem Projekt, in dem ich Daten auf einem 
SAM V71 via eingerichteter USART-Schnittstelle übermitteln möchte. 
Leider schaffe ich es nicht eine entsprechende Funktion zu schreiben, 
die diese Aufgabe erfüllt.

Eine beispielhafte Struktur meiner Daten sieht wie folgt aus:

//example send_data(FUNCTIONCODE_Phasor, data, size);
#define FUNCTIONCODE_Phasor      0x1010
// data are results of a calculation

  int size = amount_of_channels_tft *(3)*sizeof(float) + config_bytes;
  char * data = (char *)malloc(size);
  char channels = (char)amount_of_channels_tft;
  char harmonics = (char)harmonic_number_tft;
  signed char *pt_amplitude;
  signed char *pt_phase;
  signed char *pt_frequency;
  signed char *pt_channels;
  signed char *pt_harmonics;
  pt_channels = (signed char*)&channels;
  memcpy(&data[0],pt_channels,1);
  pt_harmonics = (signed char*)&harmonics;
  memcpy(&data[1],pt_harmonics,1);
  for(int i = 0; i < amount_of_channels_tft; i++)
  {
    pt_amplitude = (signed char*)&fTFTAmplitude[1][i][finished_result_counter%5];
    memcpy(&data[(i*3)*sizeof(float) + config_bytes],pt_amplitude,4);
    pt_phase = (signed char*)&fTFTPhase[1][i][finished_result_counter%5];
    memcpy(&data[(i*(3) + 1)*sizeof(float) + config_bytes],pt_phase,4);
    pt_frequency = (signed char*)&fTFTFrequency[i][finished_result_counter%5];
    memcpy(&data[(i*(3) + 2)*sizeof(float) + config_bytes],pt_frequency,4);
  }

//send_data_function(FUNCTIONCODE_Phasor, data, size);

Da ich also ein Array mit einer gewissen Datengröße übertragen möchte, 
muss die Übertragung via USART im Zusammenhang mit dem XDMAC Modul 
geschehen oder könnte die Lösung auch anders aussehen? Ich sitze 
jedenfalls schon etwas länger an dem Problem, dass ich es nicht schaffe 
eine richtige Konfiguration für entsprechende USART-Übertragung mit 
XDMAC zu erstellen.

Ich würde mich freuen, wenn ihr mir helfen könnt oder jemand mögliche 
Erfahrungen mit mir teilt.

Gruß,
TomMy

[N2 (Gast)]

Hi,

Niemand zwingt Dich zu DMA.

Wenn Du die Zeit hast, synchron zu übertragen, warum nicht?
ASynchron sollte aber gehen ausser Du macht sonst noch total
zeit abhängige Geschichten.

Ohne Code kann Dir da aber auch keiner bei DMA helfen...

Oder hast Du die Probleme, diese Struktur zu senden ?

Gruß N2

[TomMy (Gast)]

Also ich empfange Daten von 9 ADCs durch eine SPI-Schnittstelle, die 
entsprechend verarbeitet, fouriertransformiert etc. werden und in der 
oben dargestellten Struktur hinterlegt werden. Hatte ein ähnliches 
Projekt schon mal lauffähig auf einem SAM4(mit DMAC- und PMC-Modul), 
aber bei dem V71 habe ich einfach Probleme in Verbindung mit dem XDMAC 
überhaupt was zu senden. Die Doku beim neuen Board empfinde ich da 
einfach lange nicht so hilfreich und enthält auch nicht gerade viel 
Beispielcode.


Als eine Möglichkeit zur Initialisierung eines entsprechenden Kanals 
habe ich z.B.den folgenden Code:

/* Initialize and enable DMA controller */
  pmc_enable_periph_clk(ID_XDMAC);

  /*Enable XDMA interrupt */
  NVIC_ClearPendingIRQ(XDMAC_IRQn);
  NVIC_SetPriority( XDMAC_IRQn ,1);
  NVIC_EnableIRQ(XDMAC_IRQn);
  
  xdmac_channel_cfg.mbr_ubc = MICROBLOCK_LEN;
  xdmac_channel_cfg.mbr_sa = &Decoded_Byte_Array[0];
  xdmac_channel_cfg.mbr_da = (uint32_t)&USART0->US_THR;     //Usart
  xdmac_channel_cfg.mbr_cfg = XDMAC_CC_SWREQ_HWR_CONNECTED |
    XDMAC_CC_MEMSET_NORMAL_MODE |
    XDMAC_CC_MBSIZE_SINGLE |
    XDMAC_CC_DWIDTH_BYTE |
    XDMAC_CC_SIF_AHB_IF0 |
    XDMAC_CC_DIF_AHB_IF0 |
    XDMAC_CC_SAM_FIXED_AM;
  xdmac_channel_cfg.mbr_bc = BLOCK_LEN - 1;
  xdmac_channel_cfg.mbr_ds =  0;
  xdmac_channel_cfg.mbr_sus = 0;
  xdmac_channel_cfg.mbr_dus = 0;

  xdmac_configure_transfer(XDMAC, USART0_DMAC_ID_TX, &xdmac_channel_cfg);
  xdmac_channel_enable(XDMAC, USART0_DMAC_ID_TX);

Aber ich komm echt nicht drauf, wie ich das zum erfolgreichen Senden mit 
meiner Struktur verknüpfen könnte.

[Adam P. (adamap)]

TomMy schrieb:
> Aber ich komm echt nicht drauf, wie ich das zum erfolgreichen Senden mit
> meiner Struktur verknüpfen könnte.

Also versteh ich dich richtig, dass dieser Code funktioniert - um dein 
'Decoded_Byte_Array' zu versenden?

Falls ja, warum legst du dann den 'mbr_sa' nicht auf die Adresse deiner 
Struktur?

[TomMy (Gast)]

Genauso bin ich auch vorgegangen. Damit ihr es einmal viel besser 
nachvollziehen könnt, seht ihr unten mal mein Programm auf das nötigste 
reduziert mit einem Testarray "src_buf". Selbst bei dieser einfachen 
Struktur erzeuge ich keine Ausgabe von Daten über die 
USART-Schnittstelle. Ich bin mir auch ziemlich sicher, dass in 
"conf_clock" und "conf_uart_serial" die  richtigen Konfigurationen für 
USART und Clock hinterlegt sind, sodass ich vermute, dass meine Main 
noch einen groben Fehler enthält.


Vielen Dank schon mal für die jetzigen Antworten und mögliche weitere, 
die folgen!

Gruß,
TomMy

#include <asf.h>
#include <conf_board.h>
#include <conf_clock.h>
#include <conf_uart_serial.h>

/** XDMA channel used in this example. */
#define XDMA_CH 0
/** The buffer size for transfer  */
#define BUFFER_SIZE               512

static xdmac_channel_config_t xdmac_channel_cfg; //
#define MICROBLOCK_LEN       16 
#define BLOCK_LEN            16
#define USART1_DMAC_ID_TX    7

uint32_t i;

COMPILER_ALIGNED(8)
static uint8_t src_buf[BUFFER_SIZE];

static void configure_console(void)
{
  const usart_serial_options_t uart_serial_options = {
    .baudrate = CONF_UART_BAUDRATE,
    .charlength = CONF_UART_CHAR_LENGTH,
    .paritytype = CONF_UART_PARITY,
    .stopbits = CONF_UART_STOP_BITS,
  };

  /* Configure console UART. */
  sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
  stdio_serial_init(CONF_UART, &uart_serial_options);
}





int main (void)
{  
  uint32_t i;  
  
  /* Insert system clock initialization code here (sysclk_init()). */


  /* Initialize the system */
  sysclk_init();
  board_init();

  /* Configure console UART */
  configure_console();
  
  /* Initialize source and destination buffer */
  for (i = 0; i < BUFFER_SIZE; i++) {
    src_buf[i] = 0x55;
  }

  
  //***************** DMA SETUP ********************
    /* Initialize and enable DMA controller */
    pmc_enable_periph_clk(ID_XDMAC);
    /*Enable XDMA interrupt */
    NVIC_ClearPendingIRQ(XDMAC_IRQn);
    NVIC_SetPriority( XDMAC_IRQn ,1);
    NVIC_EnableIRQ(XDMAC_IRQn);
    
    xdmac_channel_cfg.mbr_ubc = MICROBLOCK_LEN;
    xdmac_channel_cfg.mbr_sa = (uint32_t)&src_buf;
    xdmac_channel_cfg.mbr_da = (uint32_t)&USART1->US_THR;
    xdmac_channel_cfg.mbr_cfg =   XDMAC_CC_TYPE_PER_TRAN | 
        XDMAC_CC_MBSIZE_SINGLE | 
        XDMAC_CC_DWIDTH_BYTE |
        XDMAC_CC_DSYNC_MEM2PER | 
        XDMAC_CC_SWREQ_HWR_CONNECTED |
        XDMAC_CC_MEMSET_NORMAL_MODE | 
        XDMAC_CC_SIF_AHB_IF1 | 
        XDMAC_CC_DIF_AHB_IF1 | 
        XDMAC_CC_SAM_INCREMENTED_AM |
        XDMAC_CC_DAM_FIXED_AM |
        XDMAC_CC_PERID(USART1_DMAC_ID_TX);
    xdmac_channel_cfg.mbr_bc = BLOCK_LEN - 1;
    xdmac_channel_cfg.mbr_ds =  0;
    xdmac_channel_cfg.mbr_sus = 0;
    xdmac_channel_cfg.mbr_dus = 0;
    xdmac_configure_transfer(XDMAC, XDMA_CH, &xdmac_channel_cfg);
    
    xdmac_enable_interrupt(XDMAC, XDMA_CH);
    xdmac_channel_enable_interrupt(XDMAC, XDMA_CH, XDMAC_CIE_BIE);
    xdmac_channel_enable(XDMAC, XDMA_CH);
  
  void XDMAC_Handler(void)
  {
    uint32_t dma_status;
    dma_status = xdmac_channel_get_interrupt_status(XDMAC, XDMA_CH);
    xdmac_channel_cfg.mbr_sa = (uint32_t)&src_buf;
    xdmac_configure_transfer(XDMAC, XDMA_CH, &xdmac_channel_cfg);
    
  };

}

[Adam P. (adamap)]

Was macht die 'void XDMAC_Handler(void)' innerhalb der main? Oder hast 
du hier nur die Klammern falsch gesetzt?

[Adam P. (adamap)]

#define USART1_DMAC_ID_TX    7

USART1 ist aber 9 - 7 ist USART0!
...nicht das du nun am falschen Port auf Daten wartest.

[TomMy (Gast)]

Sorry, ich hab beim Kopieren nur die Klammern falsch gesetzt. Der 
XDMAC_Handler ist in meinem Code normalerweise außerhalb der main.

[TomMy (Gast)]

Vielen Dank schon mal, Adam! Tatächlich hatte ich das falsch gesetzt und 
am falschen Port gewartet.
Scheint aber leider nicht der einzige Fehler gewesen zu sein, da eine 
Ausgabe immer noch nicht vorhanden ist :(

[Adam P. (adamap)]

TomMy schrieb:
> xdmac_channel_cfg.mbr_sa = (uint32_t)&src_buf;

Versuch mal das & wegzulassen.

xdmac_channel_cfg.mbr_sa = (uint32_t)src_buf;

Sonst sieht der Init. ok aus :-/

[TomMy (Gast)]

Habe ich mal direkt ausprobiert, ist aber scheinbar nicht die 
vollständige Lösung des Problems :(

[Adam P. (adamap)]

Kannst da mal schauen...

https://github.com/avrxml/asf/blob/master/sam/drivers/spi/spi_xdmac_example/spi_xdmac_example.c

Da überträgt er via SPI, sollte vom Aufbau das gleiche sein -
jedoch siehts deinem sehr ähnlich.

edit:
Leider hab ich kein SAM V Board, sonst würd ich es gleich mal selbst 
versuchen ;-)

Beim V71 gibts halt kein Bsp. mit USART und XDMAC, hab ich auch geschaut 
- aber schau mal bei anderen µC die XDMAC haben, ob da was hinterlegt 
ist und der Aufbau gleich ist, vllt. XMEGA Reihe oder andere Cortex µC 
mit XDMAC.

Bei dem SAM4E hab ich auch nach etwas gesucht, gabs net, aber Infos beim 
anderen µC Typ gefunden (Application Notes / Example Projects).

[Marco H. (damarco)]

Muss man doch nur in die Referenz schauen ;) . Also im Normalfall war es 
immer so wenn man die Peripherie(Usart) aktiviert das dann der Transfer 
startet.

Versuche doch erst mal so etwas auf die Usart auszugeben. Wenn das 
klappt dann fehlt der trigger und der ist eigentlich wie gesagt das man 
die Komponente aktiviert. Diese triggert sich dann selber durch das 
entsprechende BIT in der Usart wenn der Buffer leer ist. Der DMA 
Controller schiebt dann Daten nach...

[Adam P. (adamap)]

Hey...bist du weiter gekommen?

[TomMy (Gast)]

Hey Adam, vielen Dank für dein Interesse und Nachfragen! Leider konnte 
ich das Problem bis heute nicht lösen :(

[Adam P. (adamap)]

Welchen SAM V71 hast du?
Hast du das SAM V71 Xplained Board oder ein eigen Entwickeltes?

[TomMy (Gast)]

Ja genau, habe das V71 Xplained Ultra Board!

[Adam P. (adamap)]

Welche UART nutzt du als CONF_UART für deine Debug-Ausgaben,
hoffe diese und die für XDMAC sind nicht die gleichen?

Hast du mal versucht, auf der gewünschten UART erstmal etwas ganz 
"normal" zu versenden? mittels uart_write / uart_put - wie die Fkt. auch 
heißen.

[TomMy (Gast)]

Ich nutze USART1 als CONF_UART. Ich bin anfangs mit einem kleinem 
Programm mit der selben Konfiguration und einer putchar-Fkt gestartet, 
das zu Testzwecken zunächst einfache Characters überträgt. Das hat auch 
alles soweit geklappt ;)

[Adam P. (adamap)]

Also möchtest du dein "Console-Port" (USART1) mit DMA nutzen?
Weil:

TomMy schrieb:
> Ich nutze USART1 als CONF_UART

Das bedeutet: USART1 = CONF_UART = USART1_DMAC_ID_TX

[Adam P. (adamap)]

Hey TomMy,

hab da was für dich :-)

Bei Atmel-Start
http://start.atmel.com/#examples/SAMV71XplainedUltra

"Search: DMA"

gibt es ein Beispiel mit USART und DMA.

Könntest ja da mal schauen, ob du was findest und es mit deinem Source 
vergleichen (auch wenn da der Source Aufbau anders ist) -> ASF4.

[TomMy (Gast)]

Hey Adam! Ich schaue es mir morgen mal genauer an. Falls ich die Lösung 
meines Problems finde, werde ich euch teilhaben lassen ;-)

Vielen Dank!