EasyRadio Atmega128

**FSTII** · 03.12.2006, 16:47

Hi,

habe zwei RN-Mega128Funk-Board und möchte diese über ihr Funkmodul (EasyRadio ER400TRS) miteinander kommunizieren lassen. Leider scheitere ich schon beim senden.
Muss ich das Funkmodul, wie eine RS232-Schnittstelle, über den UART ansprechen, oder gibt es (wie in Bascom) eine einfache print-Funktion?

Wäre prima, wenn mir jemand ein bißchen auf die Sprünge helfen kann.

Gruß Matthias

**vajk** · 03.12.2006, 16:59

Das easyfunkmodul wird an die serielle angeschlossen 19200 Baud und gut is ... testen kannst Du es, in dem Du bei einem Modul TXd und Txd verbidnest, dann weißt Du schon mal, ob es funktioniert, wenn Du mit einem Terminal auf der einen Seite probierst .. beachte auf PC-Seite muß ein MAX232 dran .. beachte auch, daß Du es richtig anschließt ... (drum mein Tipp mit dem Echo-Test) ...

ICh habg hier Module im EInsatz gehen prima .. auch via USB-Adapter ...
Viel Erfolg,
Vajk

**FSTII** · 03.12.2006, 17:22

Die Module funktionieren. Da der MAX232 schon auf dem Board vorhanden ist, habe ich das mit nem Bascom-Beispielprogramm schon ausprobiert.
Mein Problem ist nur die Umsetzung in C. Mit Bascom reicht ne Print #2 Anweisung, doch wie bekomme ich das unter C hin?

Gruß Matthias

**vajk** · 03.12.2006, 19:25

Ach so - o.k. Nun Du mußt entsp. die RS232 - Schnittstelle aktiveren .. wenn Du nur Testdaten in eine Richtung übermitteln willst, reicht es, eine einfache Sendroutine zu definieren ... es gibt auch Biliotheken für C, ich mache sowas aber lieber selber.
Hier die Codeschnippsel ich gehe davon aus, daß Du Dich in C etwas mehr auskennst, auch wenn Du bisher nix mit der seiellen gemacht hast :

Du "nur" InitUart aufrufen, neben sonstigen Initialisierungen.

Code:

Hier meine Uart.h

#ifndef _uart_h_
#define _uart_h_

#define TXRXBUFFERMAX 64

#define SlaveUnitID   80
#define MasterUnitID  110


#ifdef _uart_intern_

// private:

volatile byte UART0_rx_byte_flag	= 0;
volatile byte UART0_rx_byte			= 0;
volatile byte UART0_transmitting    = 0;

byte UART0_rx_a_pos					= 0;
byte UART0_rx_array_tmp[TXRXBUFFERMAX + 1];

byte UART0_tx_a_pos					= 0;
byte UART0_tx_array_tmp[TXRXBUFFERMAX + 1];

void ClearRX(void);
void ClearRXtmpBuf(void);
void ClearTransmitting(void);

// public:

byte UART0_rx_array[TXRXBUFFERMAX + 1];
byte UART0_tx_array[TXRXBUFFERMAX + 1];

// Prototyping

void UART_Init(void);
byte UART_rx_loop(void);
void ClearRXBuf(void);
void SendUart_tx_array(void);

uint16_t crc(char *str);
byte CheckSlashes(void);
uint16_t crc_xmodem_update (uint16_t crc, const int8_t daten);


#else

// public:

extern byte UART0_rx_array[TXRXBUFFERMAX + 1];
extern byte UART0_tx_array[TXRXBUFFERMAX + 1];

//extern volatile byte UART0_receiving;
extern volatile byte UART0_transmitting;
// Prototyping

extern void UART_Init(void);
extern byte UART_rx_loop(void);
extern void ClearRXBuf(void);
extern void SendUart_tx_array(void);

extern uint16_t crc(char *str);
extern byte CheckSlashes(void);


#endif

#endif

Code:

Hier meine Uart.c

#include <inttypes.h>
#include <avr/io.h>
#include <avr/signal.h>
#include <avr/interrupt.h>
#include <avr/delay.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
//-------------------------------------------------------

#include "basdef_h.h"
#include "symtrm_h.h"

//-------------------------------------------------------

#define  _uart_intern_
#include "uart.h"


#define UNIT_ID 80

//-------------------------------------------------------
void UART_Init(void)
{
	// Init UART 0
	//  0 für UART 0
	
	/*
	UCSR0A  = 0x00; // Control und Status Register
	UCSR0B |= (1 << TXEN)  | (1 << RXEN) | (1 << TXCIE) | (1 << RXCIE); // TXEN=TX an, RXEN=RX an, RXCIE=RXcomplete Int, TXCIE=TXdto.
	UCSR0C |= (1 << USBS0) | (3 << UCSZ0);  // asyncron 8N1 -> siehe ATmega128.S.191
	UBRR0H  = 0;
	UBRR0L  = 25; // 103 für 9600 || 51 für 19200 || 25 für 38400 - alles bezogen auf 16 MHz
	*/
	// Ser.Ausgabe => UDR0  = 'a';
	// Init UART 1
	UCSR1A  = 0x00; // Control und Status Register
	UCSR1B |= (1 << TXEN)  | (1 << RXEN) | (1 << TXCIE) | (1 << RXCIE); // TXEN=TX an, RXEN=RX an, RXCIE=RXcomplete Int, TXCIE=TXdto.
	UCSR1C |= (1 << USBS0) | (3 << UCSZ0);  // asyncron 8N1 -> siehe ATmega128.S.191
	UBRR1H  = 0;
	UBRR1L  = 103; // 103 für 9600 || 51 für 19200 || 25 für 38400 || 16 für 57,6k || 12 für 76,8 || 8 für 115,2 - alles bezogen auf 16 MHz

	DDRD |= (1 << DDD5);  // DDD5 als Schaltleitung für TX RS485

	ClearRX();
	ClearRXtmpBuf();
}

//-------------------------------------------------------
void ClearRXtmpBuf(void)
{
	memset(UART0_rx_array,		0, TXRXBUFFERMAX + 1);
	memset(UART0_rx_array_tmp,	0, TXRXBUFFERMAX + 1);
}

//-------------------------------------------------------
void ClearRXBuf(void)
{
	memset(UART0_rx_array,		0, TXRXBUFFERMAX);
}

//-------------------------------------------------------
SIGNAL(SIG_USART1_TRANS) // UART0 TX complete
{
	UART0_tx_a_pos++;
	
	if(UART0_tx_a_pos < TXRXBUFFERMAX)
	{
		if(UART0_tx_array_tmp[UART0_tx_a_pos] == '\0')
		{
			ClearTransmitting();
		}
		else // näcshtes zeichen senden
		{
			UDR1 = UART0_tx_array_tmp[UART0_tx_a_pos];
		}
	}
	else
		ClearTransmitting();
}

//-------------------------------------------------------
void ClearTransmitting(void)
{
	UART0_transmitting	= 0;
	UART0_tx_a_pos		= 0;
	
	// switch off the RS485-FLAG
	PORTD &=~ (1 << DDD5);
}

//-------------------------------------------------------
void SendUart_tx_array(void) // sende gefülltes array, \0 muß diesen beenden !!!
{
	while(UART0_transmitting);
	
	UART0_transmitting	= 1;
	
	// switch on the RS485-FLAG
    PORTD |= (1 << DDD5);

	// durch die Übertragung in einen temporären Übertragungspuffer
	// ist die nächste Füllung schon möglich
	// mit +1 ist ein abschließendes \0 sichergestellt
	
	memset(UART0_tx_array_tmp,	0,				TXRXBUFFERMAX + 1);
	memcpy(UART0_tx_array_tmp,	UART0_tx_array,	TXRXBUFFERMAX);
	memset(UART0_tx_array,		0,				TXRXBUFFERMAX + 1);
	
	UART0_tx_a_pos		= 0;
	
	UDR1			= UART0_tx_array_tmp[UART0_tx_a_pos];
}

//-------------------------------------------------------
SIGNAL(SIG_USART1_RECV) // UART0 RX complete
{
    UART0_rx_byte_flag = 1;
	UART0_rx_byte      = UDR1;
	
	// if(!UART0_receiving)
	//	UART0_receiving = 1;
}

//-------------------------------------------------------
void ClearRX(void)
{
	UART0_rx_byte_flag = 0;
	UART0_rx_byte      = 0;
}

//-------------------------------------------------------
byte UART_rx_loop(void)
{
	byte rxok    = 0;
	byte lastrxb = 0;

	if(UART0_rx_byte_flag)
	{
		// ankommen Zeichen in puffer schreiben
		
		if(UART0_rx_a_pos < TXRXBUFFERMAX)
		{
			lastrxb = UART0_rx_byte;
			
			UART0_rx_array_tmp[UART0_rx_a_pos] = UART0_rx_byte;
			UART0_rx_a_pos++;
			UART0_rx_array_tmp[UART0_rx_a_pos] = 0;
		}
		
		ClearRX();
	}
	
	if((UART0_rx_a_pos >= TXRXBUFFERMAX) || (lastrxb == '>')) // Endezeichen oder Pufferüberschrietung
	{
		memset(UART0_rx_array, 0, TXRXBUFFERMAX);
		memcpy(UART0_rx_array, UART0_rx_array_tmp, UART0_rx_a_pos + 1);
		
		UART0_rx_a_pos  = 0;
		
		memset(UART0_rx_array_tmp,	0, TXRXBUFFERMAX);
		
		rxok = 1;
	}

	return(rxok);
}

Du mußt dann nur einfach ins UART0_tx_array

Code:

Zum Datensenden:

			sprintf(UART0_tx_array, "</%03d/%03d/%03d/%03d/%05d/", (int)SlaveUnitID, (int)MasterUnitID, (int)sequenzid, Hold_type, Hold_val);
			uint16_t crc_ist = crc(UART0_tx_array);
			sprintf(strchr(UART0_tx_array, 0), "%05u/>", crc_ist);
			SendUart_tx_array();

In der Hauptschleife von main erfolgt dann noch ein

Code:

			if(UART_rx_loop())
			{
				UART_DATA_Auswertung();
			}		

mit entsprechender Datenstringauswertung:

void UART_DATA_Auswertung(void)
{
	if(UART0_rx_array[0] == '<') // Startzeichen
	{
...
	}
	ClearRXBuf();
}

Ich benütze gerne sprintf - funktionen, wenn es weder Zeit- noch Platzkritisch ist ....

Was auch geht - zum Einseitigen senden:
in main gleich am Anfang:

fdevopen(uart_putchar, NULL, 0); // 4 debugging -> use printf

die Initialsieriung der Baudrate:

Code:

	// Init UART 0

	UCSRA  = 0x00; // Control und Status Register
	// UCSRB |= (1 << TXEN) | (1 << RXEN) | (1 << TXCIE) | (1 << RXCIE); // TXEN=TX an, RXEN=RX an, RXCIE=RXcomplete Int, TXCIE=TXdto.
	UCSRB |= (1 << RXEN) | (1 << RXCIE); // | (1 << TXEN) | (1 << TXCIE)  // TXEN=TX an, RXEN=RX an, RXCIE=RXcomplete Int, TXCIE=TXdto.
	UCSRC |= (1 << USBS) | (3 << UCSZ0);  // asyncron 8N1 -> siehe ATmega128.S.191
	UBRRH  = 0;
    #define USART_BAUD_RATE		19200
	#define USART_BAUD_SELECT	(F_CPU/(USART_BAUD_RATE*16l)-1)  
	UBRRL = (unsigned char) USART_BAUD_SELECT;
	// UBRRL  = 51; // 103 für 9600 || 51 für 19200 || 25 für 38400 || 16 für 57,6k || 12 für 76,8 || 8 für 115,2 - alles bezogen auf 16 MHz

und irgendwo noch ein

Code:

//-------------------------------------------------------
int uart_putchar(char c)
{
  if (c == '\n')
    uart_putchar('\r');
  loop_until_bit_is_set(UCSRA, UDRE);
  
  UDR = c;
  
  return 0;
}

und dann eben ein printf() .. da ja die Ausgabe an die stdout umgelenkt wird ...

sind alles Codeschnippsel aus funktionierenden Programmen heraus ...
.. ich verwende inzwischen immer die Baudrateninit via dem
#define USART_BAUD_SELECT ....
so muß man weniger Datenblattnachschlagen

Hoff DU kommst damit zurecht und findest Dich rein ..

Liebe Grüße
Vajk

**FSTII** · 03.12.2006, 20:13

Hallo Vajk,

vielen Dank schon mal für deine Hilfe. So ganz fit bin ich in C noch nicht, da ich mich noch nicht so lange damit beschäftige. Aber ich denke deine Codes helfen mir schon einmal weiter. Muss mich halt erst einmal einlesen...

Gruß Matthias

Thema: EasyRadio Atmega128

Themen-Optionen

Thema durchsuchen

Anzeige

EasyRadio Atmega128

Lesezeichen

Lesezeichen

Berechtigungen