Aktuelle Version vom 11. Januar 2015, 15:38 Uhr

RP6v2 USB-RS232-Adapter: Hardware

In diesem Projekt soll eine "Exp" (Experimentierplatine, CONRAD 191537) für den RP6v2 (natürlich auch für den RP6) "gebaut" werden, mit der ein (bei mir) ständig auftretendes "Problem" behoben wird:

Ich brauche eine Verbindung vom Microcontroller (µC) zu einer RS232-Schnittstelle oder zum USB-Port eines PCs. Natürlich gibt es schon das mitgelieferte USB Interface des RP6v2 und neuerdings auch das RP6V2-TRANS bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die RP6v2 M256 WiFi Platine hat aber z.B. noch zwei freie USARTs, die ich gern eigenständig und unabhängig von der seriellen Verbindung zum RobotLoader verwenden will.

Da hilft nur ein eigener USB-UART-Umsetzer. Ich habe mich für dieses Projekt entschieden für den UM2102 von ELV. Die Platine ist preisgünstig, super-kompakt und nutzt den CP2102, der kaum Außenbeschaltung braucht. Treiber gibt es für Windows, Mac, WinCE, Linux und für den Direktzugriff auf den CP2102.

Das Projekt soll aber auch noch einen RS232-Pegelwandler vorsehen. Auch das ist (noch) ein typisches Problem (zumindest bei mir, weil ich noch einen PC mit RS232-Schnittstelle habe). Man könnte die kleine Schaltung auch mit einem MAX232N direkt auf der Exp aufbauen, ich habe mich aber aus Platzgründen für den RS232-TTL-Wandler-Bausatz von Pollin entschieden. Das ist zwar eine relativ große Platine, die man aber huckepack gut auf der Exp montieren kann.

Für die Teile, die man für das ganze Projekt braucht, werden Bestell-Nummern vom großen C angegeben. Natürlich gibt es auch andere Versender, bei denen es evtl. günstiger wird.

Was braucht man allgemein für den Aufbau einer Schaltung auf der Exp:

• Seitenschneider, Schere, Zange
• Lötkolben 25..30 Watt, Lötzinn
• Plastik 70 Schutzlack (CONRAD 813621)
• Isolierter Schaltdraht YV 0,20 mm² (CONRAD 606065)
• Versilberter CU-Draht 0,6 mm (CONRAD 605581)

Mit dem versilberten CU-Draht stellt man auf der Unterseite (= Lötseite) der Exp Verbindungen zwischen den Bauteilen her; mit dem isolierten Schaltdraht werden Drahtbrücken auf der Oberseite (= Bestückungsseite) der Exp eingesetzt. Die Lage der Verbindungen zeige ich im Bestückungsplan. Man muss sich nicht an die genaue Lage der Verbindungen halten.

Wenn man die Drähte und Bauteile an anderen Positionen einlötet, kann es aber sein, dass man die weitere Schaltung nicht mehr so aufbauen kann, wie ich das hier zeige! Möglicherweise sind die weiteren Teile dann nur noch mit einer "wilden" Freiverdrahtung machbar!

Aufbau

Man braucht folgende Bauteile (Bestell-Nummern CONRAD):

Hier erst einmal der Schaltplan:

Und dann der Bestückungsplan:

Ich habe die Drahtbrücken aus isoliertem Schaltdraht (es sind 33) rot eingezeichnet. Sie werden auf der Oberseite der Experimentierplatine bestückt!

Zunächst wird der RS232-TTL-Wandler-Bausatz nach Anleitung aufgebaut. Die drei 2-poligen Anschlussklemmen werden NICHT eingelötet. In die Experimentierplatine werden 4 Löcher (mit 3,2 mm Durchmesser) an den im Bestückungsplan hellgrün gekennzeichneten Stellen gebohrt. Hier werden die vier M3-Abstandbolzen 10 mm mit Muttern M3 eingesetzt. Darauf wird später die RS232-TTL-Wandler-Platine montiert.

Die UM2102-Platine wird vorbereitet, indem zwei 5-polige und eine 6-polige Stiftleiste RM 2,54 mm auf der Lötseite direkt anliegend eingelötet werden.

Danach werden alle Leiterbahnen, Brücken, Stecker und Jumper hergestellt und zum Schluß die UM2102-Platine an ihren Platz gelötet. Auf der Lötseite der RS232-TTL-Wandler-Platine werden 6 kurze Stücke (~ 2 cm) isolierte Schaltlitze (z.B. CONRAD 605808 o.ä.) an die Punkte +5V, Masse, CTS, RTS, TXD, RXD angelötet. Anschließend werden diese 6 Litzen auf der Exp an den gekennzeichneten Stellen angelötet, und die RS232-TTL-Wandler-Platine wird auf den Abstandbolzen mit Schrauben M3 befestigt.

Viel Erfolg beim Aufbau!

Test

Will man zunächst den Mini-USB-UART-Umsetzer grob testen, werden die Jumper auf JP1 bis JP4 in Stellung "U" aufgesteckt. Alle anderen Jumper bleiben offen. Dann schließt man ihn mit einem USB-A zu Mini-USB Adapterkabel an einen PC an. Die UM2102-Platine sollte z.B. in Windows 7 problemlos erkannt werden. Falls ein VCP-Treiber nicht gefunden wird bzw. ein anderes Betriebssystem verwendet wird, finden sich die notwendigen Treiber hier. Der Mini-USB-UART-Umsetzer dürfte in Ordnung sein, wenn er vom Betriebssystem erkannt wird. Die komplette Funktion läßt sich aber nur prüfen, wenn man die Übertragung vom Microcontroller zum PC und umgekehrt ausführlich testet. Das kann man z.B. tun, indem man ST1 (UART_TTL) mit dem 10-poligen Flachkabel des RP6 USB Interface (oder des RP6V2-TRANS) mit dem PROG_UART Stecker der RP6v2Base, M32, M128 oder M256 WiFi verbindet.

ACHTUNG: Kein anderes (1:1) Flachkabel verwenden!!!

Die seriellen Ausgaben jedes beliebigen µC-Programms müßten dann auf einem Terminal-Programm (siehe auch Geeignete Terminals!) auf dem PC zu empfangen sein. Damit ist die UART-USB Übertragung (zumindest in EINE Richtung) erfolgreich getestet.

Genau so kann man den RS232-TTL-Wandler testen: JP1 bis JP4 von Stellung "U" umstecken in die andere (rechte) Stellung. JP5 aufstecken. Alle anderen Jumper bleiben offen. Der RS232-TTL-Wandler wird mit einem 1:1 Sub-D Kabel (9-polig, Stecker-Buchse) mit der RS232-Schnittstelle des PCs verbunden. Wie oben beschrieben wird ST1 (UART_TTL) mit dem Flachkabel des RP6 USB Interface mit dem PROG_UART Stecker der RP6v2Base, M32, M128 oder M256 WiFi verbunden. Auch hier sollte die serielle Verbindung zwischen dem Microcontroller und dem PC-Terminal-Programm in beiden Richtungen möglich sein.

Letzte Arbeiten

Was bleibt noch?

• Wenn die Platine komplett aufgebaut ist, kann man sie mit Plastik 70 Spray auf der Lötseite gegen Korrosion schützen
• Sich Anwendungen überlegen
• Anwendungen programmieren
• ...

Allgemeine Daten und Tabellen

Stecker

Zu *) Falls JP7 = ON!

Zu **) Abhängig von JP1..JP4!

ST1 (UART_TTL)

Die Belegung dieses Steckers entspricht dem Stecker PROG des RP6 USB Interface und des RP6V2-TRANS. Das bedeutet, dass das 10-polige Flachkabel, das mit den beiden RP6 USB Interfaces mitgeliefert wird, auch für die Verbindung zwischen diesem Stecker UART_TTL und dem Wannenstecker PROG_UART des RP6-Systems (Base, M32, M128, M256 WiFi) verwendet werden kann.

Will man ein eigenes Flachkabel für diese Verbindung herstellen,
ist zu beachten, dass das Flachkabel gedreht (aus Pin 1 wird 10,
aus Pin 2 wird 9, usw.) einzubauen ist!

Die Signale Suspend, RI, DSR und DTR werden zur Verbindung mit dem RP6-System nicht benötigt.

ST2

ST3

An diesem Stecker ST3 sind alle Signale vorhanden, die für die Kommunikation zwischen einem µC des RP6-Systems und einem USB-Port bzw. einer RS232-Schnittstelle relevant sind. Von diesem Stecker können die Schnittstellen-Signale (in der Regel werden nur TX, RX benötigt!) direkt zum UART auf einer der Platinen des RP6-Systems geführt werden.

ACHTUNG:
==> RX und TX kreuzen (d.h. µC:RX an ST3:TX und µC:TX an ST3:RX)!!!
==> TX und RTS dürfen nur mit µC-Eingängen verbunden werden!!!

ST4

An diesem Stecker ST4 liegen Signale der seriellen Schnittstelle vom UM2102, die normalerweise nicht benötigt werden. Wenn Suspend, RI, DTR, DSR an ST1 (UART_TTL) genutzt werden sollen, kann man eine Drahtverbindung der Pins 1..3 und 5 dieses Steckers zu ST2 herstellen.

ST5

An diesem Stecker ST5 kann man eine Spannung von 3,3 V abnehmen, die vom UM2102 zur Verfügung gestellt wird. Der Ausgang darf maximal mit 100 mA belastet werden.

USRBUS

Der USRBUS stellt 14 Verbindungen zwischen den µC-Platinen (RP6Base, M32 und M128) und Experimentierplatinen, die man selbst gebaut hat, zur Verfügung. Die 14 Pins können frei belegt werden.

Eine mögliche Belegung habe ich hier vorgeschlagen. Wenn man diesem Vorschlag folgt, ist RX des µCs an Y6, TX an Y8 und RST an Y10 des USRBUS zu finden. Natürlich muss man dann auf der jeweiligen µC-Platine oder Exp eine Verbindung der USRBUS-Pins (Y6, Y8) zum UART herstellen.

Auf dieser Exp muss man JP8..10 schließen, wenn man den USRBUS auf diese Weise nutzen will.

UARTs

Im RP6-System sind die Hardware-UARTs an folgenden Steckern/Pins zu finden:

Zu *) Kann man auch am Stecker "Serielle Schnittstelle" auf dem RP6 Mainboard anschliessen!

Zu **) Kann man auch am Stecker "Serielle Schnittstelle" auf der M32 Platine anschliessen!

Zu ***) Fest verbunden mit dem WLAN Modul, daher nicht nutzbar!

Stecker-Kürzel:
PROGU   PROG_UART
USPI15  UART_SPI1/T5
USPI24  UART_SPI2/T4

Jumper

Zeichenerklärung:

• Zweipolige Jumper:
  • Stellung ON = Jumper aufgesteckt (Kontakt geschlossen)
  • Stellung OFF = Jumper abgezogen (Kontakt offen)
• Dreipolige Jumper:
  • Stellung U = Jumper links * aufgesteckt
  • Stellung R = Jumper rechts * aufgesteckt

Zu *) Platine so gesehen, wie im Bestückungsplan!

Zu (S) Standard-Stellung der Jumper (USB-UART-Betrieb über UART_TTL Stecker)!

Hinweis: JP1 bis JP4 IMMER in dieselbe Stellung (U oder R) bringen!

RP6v2 USB-RS232-Adapter: Software

Nutzt man die UARTs, die am PROG_UART Stecker der RP6Base, M32, M128 oder M256 WiFi liegen, mit dieser Adapter-Platine (siehe Tabelle UARTs!), kann man zum seriellen Lesen und Schreiben von Daten die Funktionen der vorhandenen UART-Libraries verwenden.

Befehle für den Zugriff auf UART1 der RP6 CCPRO M128 sind in CompactC und BASIC des C-Control-Pro Systems enthalten (siehe Kapitel 6.19 RS232 der C-Control-Pro Anleitung!). Der Parameter serport der seriellen Funktionen muss auf 1 gesetzt werden, um den UART1 anzusprechen.

Es bleibt die Frage, wie man mit den vertrauten Funktionen der RP6M256-UART-Library auf UART1 und UART2 der M256 WiFi zugreifen kann.

Das ist recht einfach möglich, indem man die RP6M256uart Library anpasst.

RP6M256uart1 Library

Hier z.B. die Anpassung der RP6M256uart Library an UART1:

Datei RP6M256uart1.h:

/* ****************************************************************************
 *                           _______________________
 *                           \| RP6  ROBOT SYSTEM |/
 *                            \_-_-_-_-_-_-_-_-_-_/           >>> RP6 M256 WIFI
 * ----------------------------------------------------------------------------
 * ------------------- [c]2011 / 2012 - AREXX ENGINEERING ---------------------
 * -------------------------- http://www.arexx.com/ ---------------------------
 * --------------------------- All rights reserved ----------------------------
 * ****************************************************************************
 * File: RP6M256uart1.h
 * Version: 1.1 - 24.02.2012
 * Target: RP6 CONTROL M256 WIFI - ATMEGA2560 @16.00MHz
 * Author(s): Dominik S. Herwald
 * ****************************************************************************
 * Description:
 * The M256 uart1 function Library header file. Detailled description
 * of each function can be found in the RP6M256uart1.c file!
 *
 * ****************************************************************************
 * CHANGELOG AND LICENSING INFORMATION CAN BE FOUND AT THE END OF THIS FILE!
 * ****************************************************************************
 */

#ifndef RP6UART1_H
#define RP6UART1_H

/*****************************************************************************/
// Includes:

#include <avr/pgmspace.h> 	// Program memory (=Flash ROM) access routines.
#include <stdlib.h>			// C standard functions (e.g. itoa...)
#include <string.h>
#include <avr/io.h>			// I/O Port definitions
#include <avr/interrupt.h>	// Interrupt macros (e.g. cli(), sei())

/*****************************************************************************/
// UART1


// TX:

void writeChar1(char ch);
void writeStringLength1(char *data, uint8_t length, uint8_t offset);
void writeString1(char *data);
void writeNStringP1(const char *pstring);
#define writeString_P1(__pstr) writeNStringP1((PSTR(__pstr)))

#define HEX 16
#define DEC 10
#define OCT 8
#define BIN 2
void writeInteger1(int16_t number, uint8_t base);
void write32BitInteger1(int32_t number, uint8_t base);
void writeIntegerLength1(int16_t number, uint8_t base, uint8_t length);


// RX:
extern volatile uint8_t uart1_status;

#define UART1_RECEIVE_BUFFER_SIZE 500
#define UART1_BUFFER_OK 0
#define UART1_BUFFER_OVERFLOW 1

char readChar1(void);
uint16_t readChars1(char *buf, uint16_t numberOfChars);
uint16_t getBufferLength1(void);
void clearReceptionBuffer1(void);

#endif

/******************************************************************************
 * Additional info
 * ****************************************************************************
 * Changelog:
 * 
 *  ---> changes are documented in the file "RP6M256uart1.c"
 *
 * ****************************************************************************
 * Bugs, feedback, questions and modifications can be posted on the AREXX Forum
 * on http://www.arexx.com/forum/ !
 * Of course you can also write us an e-mail to: info@arexx.nl
 * AREXX Engineering may publish updates from time to time on AREXX.com!
 * ****************************************************************************
 * - LICENSE -
 * GNU GPL v2 (http://www.gnu.org/licenses/gpl.txt, a local copy can be found
 * on the RP6 CD in the RP6 sorce code folders!)
 * This program is free software. You can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 * ****************************************************************************
 */

/*****************************************************************************/
// EOF

Datei RP6M256uart1.c:

/* ****************************************************************************
 *                           _______________________
 *                           \| RP6  ROBOT SYSTEM |/
 *                            \_-_-_-_-_-_-_-_-_-_/           >>> RP6 M256 WIFI
 * ----------------------------------------------------------------------------
 * ------------------- [c]2011 / 2012 - AREXX ENGINEERING ---------------------
 * -------------------------- http://www.arexx.com/ ---------------------------
 * --------------------------- All rights reserved ----------------------------
 * ****************************************************************************
 * File: RP6M256uart1.c
 * Version: 1.1 - 16.07.2012
 * Target: RP6 CONTROL M256 WIFI - ATMEGA2560 @16.00MHz
 * Author(s): Dominik S. Herwald
 * ****************************************************************************
 * Description:
 *
 * The M256 UART1 Library. (UART = "Universal Aynchronous Receiver Transceiver")
 *
 * It contains data transfer functions for the UART (1). 
 * Reception is Interrupt based with a circular buffer.
 *
 * --------
 *
 * Hint: You should better leave all this as it is if you just started with
 * C programming, but it is a good idea to read the comments and review the
 * code, it will help you to understand C programming for AVR better.
 *
 * Of course you are free to add new functions and improvements to this
 * library and make them available to the public on the Internet.
 * Please use the changelog at the end of this file to document your
 * changes. And add your name (or nickname) to any new function or 
 * modification you added! E.g. a "modified by <nickname> at <date>" is 
 * always a good idea to show other users where and what you changed the 
 * source code!
 *
 * ****************************************************************************
 * CHANGELOG AND LICENSING INFORMATION CAN BE FOUND AT THE END OF THIS FILE!
 * ****************************************************************************
 */
 
/*****************************************************************************/
// Includes:

#include "RP6M256uart1.h"

/*****************************************************************************/
// UART1 transmit functions:

/**
 * Write a single character to the UART1.
 *
 * Example:
 *
 *			writeChar1('R');
 *			writeChar1('P');
 *			writeChar1('6');
 *			writeChar1('\n');
 *			// '\n' is a special code for the "new line" character!
 *			writeChar1('0');
 *			writeChar1(48); // 48 is ASCII code for '0'
 *			writeChar1(49); // 1
 *			writeChar1(50); // 2
 *			writeChar1(51); // 3
 *			//...
 *
 *			would output:
 *			RP6
 *			00123
 *
 */
void writeChar1(char ch)
{
    while (!(UCSR1A & (1<<UDRE1)));
    UDR1 = (uint8_t)ch;
}

/**
 * Writes a null terminated string or buffer from SRAM to UART1.
 * Make sure that it really IS null terminated!
 * ("null terminated" means that the string has a null (=0) at the end.
 * this is automatically added to it by the compiler when you put the
 * string in double quotes like this: writeString1("test");  )
 *
 * ATTENTION: This fills up SRAM Memory with the
 * strings, even if they are constant and never changed.
 * If you want to write constant text strings to the UART1, better use
 * writeNStringP1(const uint8_t *pstring) (s. below), which reads the
 * text from flash program memory and does not fill up the SRAM with
 * the string data!
 *
 * Example:
 *
 *			writeString1("RP6 Robot System\n");
 *
 */
void writeString1(char *string)
{
	while(*string)
		writeChar1(*string++);
}
		
/**
 * Writes a null terminated string from flash program memory to UART1.
 * You can use the macro writeString_P1(STRING); , this macro
 * ensures that the String is stored in program memory only!
 * Otherwise you need to use PSTR("your string") from AVRLibC for this. 
 *
 * Example:
 *
 *			writeNStringP1(PSTR("RP6 Robot System\n"));
 *
 *			// There is also a Macro that makes life easier and
 *			// you can simply write:
 *			writeString_P1("RP6 Robot System\n");
 *
 */
void writeNStringP1(const char *pstring)
{
    uint8_t c;
    for (;(c = pgm_read_byte_near(pstring++));writeChar1(c));
}


/**
 * Writes a string with specified length and offset from SRAM to UART1.
 * If it is a null terminated string, output will be stopped at the
 * end! It does not need to be null terminated, but it is recommended
 * to use only null terminated strings/buffers, otherwise the function could
 * output any SRAM memory data stored after the string until it reaches a 0
 * or the specified length.
 *
 * Example:
 *
 *			writeStringLength1("RP6 Robot Sytem\n",16,0);
 *			// would output: "RP6 Robot Sytem\n"
 *			writeStringLength1("RP6 Robot Sytem\n",11,4);
 *			// would output: "Robot System"
 * 			writeStringLength1("RP6 Robot Sytem\n",40,4);
 *			// would output: "Robot System\n"
 *			// No matter if the specified length is 40 characters!
 *
 */
void writeStringLength1(char *string, uint8_t length, uint8_t offset)
{
	for(string = &string[offset]; *string && length; length--)
		writeChar1(*string++);
}

/**
 * Write a number (with specified base) to the UART1.
 *
 * Example:
 *
 *			// Write a hexadecimal number to the UART1:
 *			writeInteger1(0xAACC,16);
 *			// Instead of 16 you can also write "HEX" as this is defined in the
 *			// RP6M256uart1.h :
 *			writeInteger1(0xAACC, HEX);
 *			// Other Formats:
 *			writeInteger1(1024,DEC);  	// Decimal
 *			writeInteger1(044,OCT);		// Ocal
 *			writeInteger1(0b11010111,BIN); // Binary
 */
void writeInteger1(int16_t number, uint8_t base)
{
	char buffer[17];
	itoa(number, &buffer[0], base);
	writeString1(&buffer[0]);
}

/**
 * Write a 32 Bit number (with specified base) to the UART1.
 * Usage is the same as writeInteger1.
 */
void write32BitInteger1(int32_t number, uint8_t base)
{
	char buffer[33];
	ltoa(number, &buffer[0], base);
	writeString1(&buffer[0]);
}

/**
 * Same as writeInteger1, but with defined length.
 * This means this routine will add leading zeros to the number if length is
 * larger than the actual value or cut the upper digits if length is smaller
 * than the actual value.
 *
 * Example:
 *
 *			// Write a hexadecimal number to the UART1:
 *			writeIntegerLength1(0xAACC, 16, 8);
 *			// Instead of 16 you can also write "HEX" as this is defined in the
 *			// RP6M256uart1.h :
 *			writeIntegerLength1(0xAACC, HEX, 8);
 *			// Other Formats:
 *			writeIntegerLength1(1024,DEC,6);  	// Decimal
 *			writeIntegerLength1(044,OCT,4);		// Ocal
 *			writeIntegerLength1(0b11010111,BIN,8); // Binary
 */
void writeIntegerLength1(int16_t number, uint8_t base, uint8_t length)
{
	char buffer[17];
	itoa(number, &buffer[0], base);
	int8_t cnt = length - strlen(buffer);
	if(cnt > 0) {
		for(; cnt > 0; cnt--, writeChar1('0'));
		writeString1(&buffer[0]);
	}
	else 
		writeStringLength1(&buffer[0],length,-cnt);
}

/*****************************************************************************/
// UART1 receive functions:

volatile char uart1_receive_buffer[UART1_RECEIVE_BUFFER_SIZE+1];

volatile uint8_t uart1_status;

uint16_t read_pos1 = 0;
uint16_t write_pos1 = 0; 
uint16_t read_size1 = 0;
uint16_t write_size1 = 0;

/**
 * UART1 receive ISR.
 * Handles reception to circular buffer.
 */
ISR(USART1_RX_vect)
{	
	static volatile uint8_t dummy;
	if(((uint16_t)(write_size1 - read_size1)) < UART1_RECEIVE_BUFFER_SIZE) {
		uart1_receive_buffer[write_pos1++] = UDR1;
		write_size1++;
		if(write_pos1 > UART1_RECEIVE_BUFFER_SIZE) 
			write_pos1 = 0;
		uart1_status = UART1_BUFFER_OK;
	}
	else {	
		dummy = UDR1;
		uart1_status = UART1_BUFFER_OVERFLOW;
	}
}

/**
 * Read a char from the circular buffer. 
 * The char is removed from the buffer (or more precise: not accessible directly anymore
 * and will be overwritten as soon as new data becomes available)!
 *
 * Example:
 *
 * // [...]
 * if(getBufferLength1()) 		
 *	   receivedData[data_position++] = readChar1();
 * // [...]
 *
 */
char readChar1(void)
{
	uart1_status = UART1_BUFFER_OK;
	if(((uint16_t)(write_size1 - read_size1)) > 0) {
		read_size1++;
		if(read_pos1 > UART1_RECEIVE_BUFFER_SIZE) 
			read_pos1 = 0;
		return uart1_receive_buffer[read_pos1++];
	}
	return 0;
}

/**
 * Same as readChar1, but this function copies numberOfChars chars from the
 * circular buffer to buf. 
 * It also returns the number of characters really copied to the buffer! 
 * Just in case that there were fewer chars in the buffer...
 */
uint16_t readChars1(char *buf, uint16_t numberOfChars)
{
	uint16_t i = 0;
	uart1_status = UART1_BUFFER_OK;
	while(((uint16_t)(write_size1 - read_size1)) > 0 && i < numberOfChars) {
		read_size1++;
		buf[i++] = uart1_receive_buffer[read_pos1++];
		if(read_pos1 > UART1_RECEIVE_BUFFER_SIZE) 
			read_pos1 = 0;
	}
	return i;
}

/**
 * Returns the current number of elements in the buffer.
 *
 * Example:
 * s. readChar1 function above!
 */
uint16_t getBufferLength1(void)
{
	return (((uint16_t)(write_size1 - read_size1)));
}

/**
 * Clears the reception buffer - it disables UART1 Receive 
 * interrupt for a short period of time. 
 */
void clearReceptionBuffer1(void)
{
	static uint8_t dummy;
	UCSR1B &= ~(1 << RXCIE1); // disable UART1 RX Interrupt
	dummy = UDR1;
	read_pos1 = 0;
	write_pos1 = 0; 
	read_size1 = 0;
	write_size1 = 0;
	uart1_status = UART1_BUFFER_OK;
	UCSR1B |= (1 << RXCIE1); // enable Interrupt again
}

/******************************************************************************
 * Additional info
 * ****************************************************************************
 * Changelog:
 * - v. 1.1 16.07.2012 by Dominik S. Herwald
 * - v. 1.0 (initial release) 24.02.2012 by Dominik S. Herwald
 *
 * ****************************************************************************
 * Bugs, feedback, questions and modifications can be posted on the AREXX Forum
 * on http://www.arexx.com/forum/ !
 * Of course you can also write us an e-mail to: info@arexx.nl
 * AREXX Engineering may publish updates from time to time on AREXX.com!
 * ****************************************************************************
 * - LICENSE -
 * GNU GPL v2 (http://www.gnu.org/licenses/gpl.txt, a local copy can be found
 * on the RP6 CD in the RP6 sorce code folders!)
 * This program is free software. You can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 * ****************************************************************************
 */

/*****************************************************************************/
// EOF

Für den Zugriff auf UART1 wurde allen Funktionsnamen eine "1" angehängt. Aus writeChar (UART0) wird also z.B. writeChar1 (UART1). Für UART2 kann diese Library auf dieselbe Weise angepaßt werden. Die RP6M256uart1 Library kann wie die ursprüngliche Library in eigene Programme eingebunden werden,- natürlich auch ZUSÄTZLICH zur RP6M256uart Library.

Initialisierung

Wenn man die RP6M256uart Library auf den UART1 oder UART2 anpasst, muss man die Initialisierung des UARTs im eigenen Hauptprogramm durchführen.

Für UART1 kann das dann so aussehen:

	cli();			// Disable global interrupts.

	// UART1:
	UBRR1H = UBRR_BAUD_LOW >> 8;	// Setup UART1: Baud is Low Speed
	UBRR1L = (uint8_t) UBRR_BAUD_LOW;
	UCSR1A = 0x00;
	UCSR1C = (0<<UMSEL10) | (0<<UMSEL11) | (1<<UCSZ11) | (1<<UCSZ10);
	UCSR1B = (1 << TXEN1) | (1 << RXEN1) | (1 << RXCIE1);

	clearReceptionBuffer1();

	sei();			// Enable Global Interrupts

USB-Treiber

Der Hardwaretreiber wird von Windows eventuell nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber dann manuell installiert werden. Für Windows 7 wurde dieser Windows Treiber von SiLabs getestet. Treiber für andere Betriebssysteme können direkt bei ELV oder auch bei SiLabs gefunden werden.

Installation

1. Treiber installieren, Verzeichnis merken

2. USB-Modul anstecken

3. Gerätemanager öffnen

4. UM2102 wählen, Treibersoftware aktualisieren

5. Auf dem Computer nach Treibersoftware suchen

6. Installationsverzeichnis angeben, Unterordner einbeziehen

COM-Terminal

Zum Auswerten der empfangenen Daten eignet sich eigentlich jedes COM-Terminal, z.B. HTerm; siehe auch Geeignete Terminals! Es gilt lediglich zu beachten, dass die virtuelle Schnittstelle folgendermassen konfiguriert ist: 38400 Baud, 8Bit, 1Stop, Parity: None.

Siehe auch

• RP6
• RP6 - Programmierung
• RP6v2
• RP6 Sensor Board und Xtra Module
• RP6 Kamera - Mitmach-Projekt
• RP6 - Morse-Code
• RP6v2 I2C-Portexpander
• RP6v2 Orientierung
• RP6 Multi IO Projekt
• RP6 Multi IO Projekt - Software
• RP6 ArduIO
• RP6 ArduIO - Software
• CCRP5
• Yeti
• Asuro

Quellen

• USB
• RS232
• UART
• TTL
• CP2102 Datasheet
• MAX232N Datasheet
• 1N5817 Datasheet

Autoren

--Dirk 15:38, 11. Jan 2015 (CET)

--Filou 19:20, 26. Sep 2012 (CET)