RN-Wissen.de - Benutzerbeiträge [de]

RP6v2 USB-RS232-Adapter

2012-09-27T16:23:29Z

Filou89: /* Software und USB-Treiber */

=RP6v2 USB-RS232-Adapter: Hardware=

In diesem Projekt soll eine "Exp" ([[RP6#Experimentierplatine]], CONRAD [http://www.conrad.de/ce/de/product/191537/RP6-EXPERIMENTIERPLATINE 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 [http://www.conrad.de/ce/de/product/191638/Arexx-RP6-USB-Interface-RP6V2-TRANS RP6V2-TRANS] bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die [[RP6v2#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 [http://www.elv.de/mini-usb-modul-um2102-komplettbausatz.html 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 [http://www.pollin.de/shop/dt/MzY5OTgxOTk-/Bausaetze_Module/Bausaetze/RS232_TTL_Wandler_Bausatz.html 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 [http://www.conrad.de/ce/ 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 [http://www.conrad.de/ce/ CONRAD]):
{| {{Blauetabelle}}
|-
| Anzahl || Bestell-Nr. || Bauteil-Bezeichnung:
|-
| 1 || 191537 || RP6 Experimentierplatine
|-
| 1 || [http://www.elv.de/ ELV] || Mini-USB-UART-Umsetzer UM2102
|-
| 1 || [http://www.pollin.de/shop/index.html Pollin] || RS232-TTL-Wandler-Bausatz
|-
| 1 || 168274 || Schottky-Diode 1N5817
|-
| 1 || 736950 || Wannenstecker gewinkelt, 2 x 5-polig
|-
| 1 || 741119 || 1-reihige Stiftleiste RM 2,54 mm (36-polig)
|-
| 1 || 742902 || Zehn Codierbrücken (aus Set)
|-
| 4 || 526630 || M3-Abstandbolzen 10 mm
|-
| 1 || 815624 || Vier Muttern M3 (aus Set)
|-
| 1 || 815322 || Vier Schrauben M3 (aus Set)
|}

Hier erst einmal der Schaltplan:

[[bild:RP6_RS232_USB_SP.JPG]]

Und dann der Bestückungsplan:

[[bild:RP6_RS232_USB.JPG]]

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''' [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx 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 [[RP6_-_Programmierung#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===
{| {{Blauetabelle}}
|-
| Stecker || Pins || Bedeutung
|-
| ST1 || 10 || UART_TTL Wannenstecker (RX, TX, RTS, +5V *, GND)
|-
| ST2 || 4 || Suspend, RI, DTR, DSR an ST1
|-
| ST3 || 4 || TX, RX, RTS, CTS von UM2102 ODER RS232-TTL **
|-
| ST4 || 5 || Suspend, RI, DTR, DCD, DSR von UM2102
|-
| ST5 || 2 || 3,3 V, GND von UM2102
|}

'''Zu *)''' Falls JP7 = ON!

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

====ST1 (UART_TTL)====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || VDD || || +5 V
|-
| 2 || GND || || Masse
|-
| 3 || Suspend || A || Suspend (= ST2: 1)
|-
| 4 || n.c. || ||
|-
| 5 || RI || E || Ring Indicator (= ST2: 2)
|-
| 6 || DSR || E || Data Set Ready (= ST2: 4)
|-
| 7 || DTR || A || Data Terminal Ready (= ST2: 3)
|-
| 8 || RX || E || Receive Data (= ST3: 2)
|-
| 9 || TX || A || Transmit Data (= ST3: 1)
|-
| 10 || RTS || A || Request to Send (= ST3: 3)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || = ST1: 3
|-
| 2 || RI || E || = ST1: 5
|-
| 3 || DTR || A || = ST1: 7
|-
| 4 || DSR || E || = ST1: 6
|}

====ST3====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || TX || A || Transmit Data (= ST1: 9)
|-
| 2 || RX || E || Receive Data (= ST1: 8)
|-
| 3 || RTS || A || Request to Send (= ST1: 10)
|-
| 4 || CTS || E || Clear to Send
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || Suspend (von UM2102)
|-
| 2 || RI || E || Ring Indicator (von UM2102)
|-
| 3 || DTR || A || Data Terminal Ready (von UM2102)
|-
| 4 || DCD || E || Data Carrier Detect (von UM2102)
|-
| 5 || DSR || E || Data Set Ready (von UM2102)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || Bedeutung
|-
| 1 || + 3,3 V || 3,3 V / max. 100 mA (von UM2102)
|-
| 2 || GND || Masse
|}

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 [http://www.roboternetz.de/community/threads/29281-RP6-USRBUS 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:
{| {{Blauetabelle}}
|-
| Platine || UART || RX || TX || RX an Stecker || TX an Stecker
|-
| RP6v2Base || 0 || PD0 || PD1 || PROGU: 2 * || PROGU: 3 *
|-
| RP6 CONTROL M32 || 0 || PD0 || PD1 || PROGU: 2 **|| PROGU: 3 **
|-
| RP6 CCPRO M128 || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || I/O: 8 || I/O: 7
|-
| RP6v2 M256 WIFI || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || USPI15: 8 || USPI15: 6
|-
| || 2 || PH0 || PH1 || USPI24: 8 || USPI24: 6
|-
| || 3 || PJ0 || PJ1 || n.c. ***|| n.c. ***
|}

'''Zu *)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle]]" auf dem RP6 Mainboard anschliessen!

'''Zu **)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle_2]]" 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!

{| {{Blauetabelle}}
|-
| Jumper || Stellung || Bedeutung
|-
| JP1 || U (S) || TX von USB
|-
| JP1 || R || TX von RS232
|-
| JP2 || U (S) || RX von USB
|-
| JP2 || R || RX von RS232
|-
| JP3 || U (S) || CTS von USB
|-
| JP3 || R || CTS von RS232
|-
| JP4 || U (S) || RTS von USB
|-
| JP4 || R || RTS von RS232
|-
| JP5 || ON || RS232-TTL-Wandler Power ON
|-
| JP5 || OFF (S) || RS232-TTL-Wandler Power OFF
|-
| JP6 || ON || Power für UM2102 auch von UART_TTL Stecker (Pin 1)
|-
| JP6 || OFF (S) || Power für UM2102 nur vom PC über USB-Stecker
|-
| JP7 || ON || +5 V Verbindung zwischen XBUS: VDD und UART_TTL Stecker (Pin 1)
|-
| JP7 || OFF (S) || Keine +5 V Verbindung zwischen XBUS und UART_TTL Stecker
|-
| JP8 || ON || TX an USRBUS RX (Pin Y6)
|-
| JP8 || OFF (S) || TX nicht an USRBUS
|-
| JP9 || ON || RTS an USRBUS RST (Pin Y10)
|-
| JP9 || OFF (S) || RTS nicht an USRBUS
|-
| JP10 || ON || RX an USRBUS TX (Pin Y8)
|-
| JP10 || OFF (S) || RX nicht an USRBUS
|}

'''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 [[RP6v2_USB-RS232-Adapter#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:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>

Datei RP6M256uart1.c:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>
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:
<pre> 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
</pre>

=Software und USB-Treiber=
Der Hardwaretreiber wird von Windows eventuell nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber manuell installiert werden.
Für Windows 7 wurde dieser [http://www.silabs.com/Support%20Documents/Software/CP210x_VCP_Win_XP_S2K3_Vista_7.exe Windows Treiber] von SiLabs getestet.
Treiber für andere Betriebssysteme können direkt bei ELV oder auch bei [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx SiLabs] gefunden werden.

==Vorgehen USB-Treiber==
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. [http://www.heise.de/download/hterm.html HTerm]. 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 Kamera - Mitmach-Projekt]]
* [[RP6v2 I2C-Portexpander]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Quellen=
* [http://de.wikipedia.org/wiki/Universal_Serial_Bus USB]
* [http://de.wikipedia.org/wiki/RS-232 RS232]
* [[UART]]
* [http://de.wikipedia.org/wiki/Transistor-Transistor-Logik TTL]
* [http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf CP2102 Datasheet]
* [http://www.ti.com/lit/ds/symlink/max232.pdf MAX232N Datasheet]
* [http://www.fairchildsemi.com/ds/1N/1N5818.pdf 1N5817 Datasheet]

[[Kategorie:Elektronik]]
[[Kategorie:Projekte]]

=Autoren=
--[[Benutzer:Dirk|Dirk]] 17:06, 5. Sep 2012 (CET)

--[[Benutzer:Filou89|Filou]] 19:20, 26. Sep 2012 (CET)

RP6v2 USB-RS232-Adapter

2012-09-26T20:03:17Z

Filou89: /* Vorgehen */

=RP6v2 USB-RS232-Adapter: Hardware=

In diesem Projekt soll eine "Exp" ([[RP6#Experimentierplatine]], CONRAD [http://www.conrad.de/ce/de/product/191537/RP6-EXPERIMENTIERPLATINE 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 [http://www.conrad.de/ce/de/product/191638/Arexx-RP6-USB-Interface-RP6V2-TRANS RP6V2-TRANS] bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die [[RP6v2#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 [http://www.elv.de/mini-usb-modul-um2102-komplettbausatz.html 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 [http://www.pollin.de/shop/dt/MzY5OTgxOTk-/Bausaetze_Module/Bausaetze/RS232_TTL_Wandler_Bausatz.html 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 [http://www.conrad.de/ce/ 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 [http://www.conrad.de/ce/ CONRAD]):
{| {{Blauetabelle}}
|-
| Anzahl || Bestell-Nr. || Bauteil-Bezeichnung:
|-
| 1 || 191537 || RP6 Experimentierplatine
|-
| 1 || [http://www.elv.de/ ELV] || Mini-USB-UART-Umsetzer UM2102
|-
| 1 || [http://www.pollin.de/shop/index.html Pollin] || RS232-TTL-Wandler-Bausatz
|-
| 1 || 168274 || Schottky-Diode 1N5817
|-
| 1 || 736950 || Wannenstecker gewinkelt, 2 x 5-polig
|-
| 1 || 741119 || 1-reihige Stiftleiste RM 2,54 mm (36-polig)
|-
| 1 || 742902 || Zehn Codierbrücken (aus Set)
|-
| 4 || 526630 || M3-Abstandbolzen 10 mm
|-
| 1 || 815624 || Vier Muttern M3 (aus Set)
|-
| 1 || 815322 || Vier Schrauben M3 (aus Set)
|}

Hier erst einmal der Schaltplan:

[[bild:RP6_RS232_USB_SP.JPG]]

Und dann der Bestückungsplan:

[[bild:RP6_RS232_USB.JPG]]

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''' [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx 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 [[RP6_-_Programmierung#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===
{| {{Blauetabelle}}
|-
| Stecker || Pins || Bedeutung
|-
| ST1 || 10 || UART_TTL Wannenstecker (RX, TX, RTS, +5V *, GND)
|-
| ST2 || 4 || Suspend, RI, DTR, DSR an ST1
|-
| ST3 || 4 || TX, RX, RTS, CTS von UM2102 ODER RS232-TTL **
|-
| ST4 || 5 || Suspend, RI, DTR, DCD, DSR von UM2102
|-
| ST5 || 2 || 3,3 V, GND von UM2102
|}

'''Zu *)''' Falls JP7 = ON!

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

====ST1 (UART_TTL)====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || VDD || || +5 V
|-
| 2 || GND || || Masse
|-
| 3 || Suspend || A || Suspend (= ST2: 1)
|-
| 4 || n.c. || ||
|-
| 5 || RI || E || Ring Indicator (= ST2: 2)
|-
| 6 || DSR || E || Data Set Ready (= ST2: 4)
|-
| 7 || DTR || A || Data Terminal Ready (= ST2: 3)
|-
| 8 || RX || E || Receive Data (= ST3: 2)
|-
| 9 || TX || A || Transmit Data (= ST3: 1)
|-
| 10 || RTS || A || Request to Send (= ST3: 3)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || = ST1: 3
|-
| 2 || RI || E || = ST1: 5
|-
| 3 || DTR || A || = ST1: 7
|-
| 4 || DSR || E || = ST1: 6
|}

====ST3====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || TX || A || Transmit Data (= ST1: 9)
|-
| 2 || RX || E || Receive Data (= ST1: 8)
|-
| 3 || RTS || A || Request to Send (= ST1: 10)
|-
| 4 || CTS || E || Clear to Send
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || Suspend (von UM2102)
|-
| 2 || RI || E || Ring Indicator (von UM2102)
|-
| 3 || DTR || A || Data Terminal Ready (von UM2102)
|-
| 4 || DCD || E || Data Carrier Detect (von UM2102)
|-
| 5 || DSR || E || Data Set Ready (von UM2102)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || Bedeutung
|-
| 1 || + 3,3 V || 3,3 V / max. 100 mA (von UM2102)
|-
| 2 || GND || Masse
|}

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 [http://www.roboternetz.de/community/threads/29281-RP6-USRBUS 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:
{| {{Blauetabelle}}
|-
| Platine || UART || RX || TX || RX an Stecker || TX an Stecker
|-
| RP6v2Base || 0 || PD0 || PD1 || PROGU: 2 * || PROGU: 3 *
|-
| RP6 CONTROL M32 || 0 || PD0 || PD1 || PROGU: 2 **|| PROGU: 3 **
|-
| RP6 CCPRO M128 || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || I/O: 8 || I/O: 7
|-
| RP6v2 M256 WIFI || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || USPI15: 8 || USPI15: 6
|-
| || 2 || PH0 || PH1 || USPI24: 8 || USPI24: 6
|-
| || 3 || PJ0 || PJ1 || n.c. ***|| n.c. ***
|}

'''Zu *)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle]]" auf dem RP6 Mainboard anschliessen!

'''Zu **)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle_2]]" 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!

{| {{Blauetabelle}}
|-
| Jumper || Stellung || Bedeutung
|-
| JP1 || U (S) || TX von USB
|-
| JP1 || R || TX von RS232
|-
| JP2 || U (S) || RX von USB
|-
| JP2 || R || RX von RS232
|-
| JP3 || U (S) || CTS von USB
|-
| JP3 || R || CTS von RS232
|-
| JP4 || U (S) || RTS von USB
|-
| JP4 || R || RTS von RS232
|-
| JP5 || ON || RS232-TTL-Wandler Power ON
|-
| JP5 || OFF (S) || RS232-TTL-Wandler Power OFF
|-
| JP6 || ON || Power für UM2102 auch von UART_TTL Stecker (Pin 1)
|-
| JP6 || OFF (S) || Power für UM2102 nur vom PC über USB-Stecker
|-
| JP7 || ON || +5 V Verbindung zwischen XBUS: VDD und UART_TTL Stecker (Pin 1)
|-
| JP7 || OFF (S) || Keine +5 V Verbindung zwischen XBUS und UART_TTL Stecker
|-
| JP8 || ON || TX an USRBUS RX (Pin Y6)
|-
| JP8 || OFF (S) || TX nicht an USRBUS
|-
| JP9 || ON || RTS an USRBUS RST (Pin Y10)
|-
| JP9 || OFF (S) || RTS nicht an USRBUS
|-
| JP10 || ON || RX an USRBUS TX (Pin Y8)
|-
| JP10 || OFF (S) || RX nicht an USRBUS
|}

'''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 [[RP6v2_USB-RS232-Adapter#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:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>

Datei RP6M256uart1.c:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>
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:
<pre> 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
</pre>

=Software und USB-Treiber=
Der Hardwaretreiber wird von Windows nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber manuell installiert werden.
Für Windows 7 wurde dieser [http://www.silabs.com/Support%20Documents/Software/CP210x_VCP_Win_XP_S2K3_Vista_7.exe Windows Treiber] von SiLabs getestet.
Treiber für andere Betriebssysteme können direkt bei ELV oder auch bei [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx SiLabs] gefunden werden.

==Vorgehen USB-Treiber==
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. [http://www.heise.de/download/hterm.html HTerm]. 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 Kamera - Mitmach-Projekt]]
* [[RP6v2 I2C-Portexpander]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Quellen=
* [http://de.wikipedia.org/wiki/Universal_Serial_Bus USB]
* [http://de.wikipedia.org/wiki/RS-232 RS232]
* [[UART]]
* [http://de.wikipedia.org/wiki/Transistor-Transistor-Logik TTL]
* [http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf CP2102 Datasheet]
* [http://www.ti.com/lit/ds/symlink/max232.pdf MAX232N Datasheet]
* [http://www.fairchildsemi.com/ds/1N/1N5818.pdf 1N5817 Datasheet]

[[Kategorie:Elektronik]]
[[Kategorie:Projekte]]

=Autoren=
--[[Benutzer:Dirk|Dirk]] 17:06, 5. Sep 2012 (CET)

--[[Benutzer:Filou89|Filou]] 19:20, 26. Sep 2012 (CET)

RP6v2 USB-RS232-Adapter

2012-09-26T19:58:23Z

Filou89: /* Software und USB-Treiber */

=RP6v2 USB-RS232-Adapter: Hardware=

In diesem Projekt soll eine "Exp" ([[RP6#Experimentierplatine]], CONRAD [http://www.conrad.de/ce/de/product/191537/RP6-EXPERIMENTIERPLATINE 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 [http://www.conrad.de/ce/de/product/191638/Arexx-RP6-USB-Interface-RP6V2-TRANS RP6V2-TRANS] bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die [[RP6v2#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 [http://www.elv.de/mini-usb-modul-um2102-komplettbausatz.html 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 [http://www.pollin.de/shop/dt/MzY5OTgxOTk-/Bausaetze_Module/Bausaetze/RS232_TTL_Wandler_Bausatz.html 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 [http://www.conrad.de/ce/ 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 [http://www.conrad.de/ce/ CONRAD]):
{| {{Blauetabelle}}
|-
| Anzahl || Bestell-Nr. || Bauteil-Bezeichnung:
|-
| 1 || 191537 || RP6 Experimentierplatine
|-
| 1 || [http://www.elv.de/ ELV] || Mini-USB-UART-Umsetzer UM2102
|-
| 1 || [http://www.pollin.de/shop/index.html Pollin] || RS232-TTL-Wandler-Bausatz
|-
| 1 || 168274 || Schottky-Diode 1N5817
|-
| 1 || 736950 || Wannenstecker gewinkelt, 2 x 5-polig
|-
| 1 || 741119 || 1-reihige Stiftleiste RM 2,54 mm (36-polig)
|-
| 1 || 742902 || Zehn Codierbrücken (aus Set)
|-
| 4 || 526630 || M3-Abstandbolzen 10 mm
|-
| 1 || 815624 || Vier Muttern M3 (aus Set)
|-
| 1 || 815322 || Vier Schrauben M3 (aus Set)
|}

Hier erst einmal der Schaltplan:

[[bild:RP6_RS232_USB_SP.JPG]]

Und dann der Bestückungsplan:

[[bild:RP6_RS232_USB.JPG]]

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''' [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx 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 [[RP6_-_Programmierung#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===
{| {{Blauetabelle}}
|-
| Stecker || Pins || Bedeutung
|-
| ST1 || 10 || UART_TTL Wannenstecker (RX, TX, RTS, +5V *, GND)
|-
| ST2 || 4 || Suspend, RI, DTR, DSR an ST1
|-
| ST3 || 4 || TX, RX, RTS, CTS von UM2102 ODER RS232-TTL **
|-
| ST4 || 5 || Suspend, RI, DTR, DCD, DSR von UM2102
|-
| ST5 || 2 || 3,3 V, GND von UM2102
|}

'''Zu *)''' Falls JP7 = ON!

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

====ST1 (UART_TTL)====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || VDD || || +5 V
|-
| 2 || GND || || Masse
|-
| 3 || Suspend || A || Suspend (= ST2: 1)
|-
| 4 || n.c. || ||
|-
| 5 || RI || E || Ring Indicator (= ST2: 2)
|-
| 6 || DSR || E || Data Set Ready (= ST2: 4)
|-
| 7 || DTR || A || Data Terminal Ready (= ST2: 3)
|-
| 8 || RX || E || Receive Data (= ST3: 2)
|-
| 9 || TX || A || Transmit Data (= ST3: 1)
|-
| 10 || RTS || A || Request to Send (= ST3: 3)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || = ST1: 3
|-
| 2 || RI || E || = ST1: 5
|-
| 3 || DTR || A || = ST1: 7
|-
| 4 || DSR || E || = ST1: 6
|}

====ST3====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || TX || A || Transmit Data (= ST1: 9)
|-
| 2 || RX || E || Receive Data (= ST1: 8)
|-
| 3 || RTS || A || Request to Send (= ST1: 10)
|-
| 4 || CTS || E || Clear to Send
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || Suspend (von UM2102)
|-
| 2 || RI || E || Ring Indicator (von UM2102)
|-
| 3 || DTR || A || Data Terminal Ready (von UM2102)
|-
| 4 || DCD || E || Data Carrier Detect (von UM2102)
|-
| 5 || DSR || E || Data Set Ready (von UM2102)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || Bedeutung
|-
| 1 || + 3,3 V || 3,3 V / max. 100 mA (von UM2102)
|-
| 2 || GND || Masse
|}

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 [http://www.roboternetz.de/community/threads/29281-RP6-USRBUS 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:
{| {{Blauetabelle}}
|-
| Platine || UART || RX || TX || RX an Stecker || TX an Stecker
|-
| RP6v2Base || 0 || PD0 || PD1 || PROGU: 2 * || PROGU: 3 *
|-
| RP6 CONTROL M32 || 0 || PD0 || PD1 || PROGU: 2 **|| PROGU: 3 **
|-
| RP6 CCPRO M128 || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || I/O: 8 || I/O: 7
|-
| RP6v2 M256 WIFI || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || USPI15: 8 || USPI15: 6
|-
| || 2 || PH0 || PH1 || USPI24: 8 || USPI24: 6
|-
| || 3 || PJ0 || PJ1 || n.c. ***|| n.c. ***
|}

'''Zu *)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle]]" auf dem RP6 Mainboard anschliessen!

'''Zu **)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle_2]]" 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!

{| {{Blauetabelle}}
|-
| Jumper || Stellung || Bedeutung
|-
| JP1 || U (S) || TX von USB
|-
| JP1 || R || TX von RS232
|-
| JP2 || U (S) || RX von USB
|-
| JP2 || R || RX von RS232
|-
| JP3 || U (S) || CTS von USB
|-
| JP3 || R || CTS von RS232
|-
| JP4 || U (S) || RTS von USB
|-
| JP4 || R || RTS von RS232
|-
| JP5 || ON || RS232-TTL-Wandler Power ON
|-
| JP5 || OFF (S) || RS232-TTL-Wandler Power OFF
|-
| JP6 || ON || Power für UM2102 auch von UART_TTL Stecker (Pin 1)
|-
| JP6 || OFF (S) || Power für UM2102 nur vom PC über USB-Stecker
|-
| JP7 || ON || +5 V Verbindung zwischen XBUS: VDD und UART_TTL Stecker (Pin 1)
|-
| JP7 || OFF (S) || Keine +5 V Verbindung zwischen XBUS und UART_TTL Stecker
|-
| JP8 || ON || TX an USRBUS RX (Pin Y6)
|-
| JP8 || OFF (S) || TX nicht an USRBUS
|-
| JP9 || ON || RTS an USRBUS RST (Pin Y10)
|-
| JP9 || OFF (S) || RTS nicht an USRBUS
|-
| JP10 || ON || RX an USRBUS TX (Pin Y8)
|-
| JP10 || OFF (S) || RX nicht an USRBUS
|}

'''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 [[RP6v2_USB-RS232-Adapter#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:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>

Datei RP6M256uart1.c:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>
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:
<pre> 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
</pre>

=Software und USB-Treiber=
Der Hardwaretreiber wird von Windows nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber manuell installiert werden.
Für Windows 7 wurde dieser [http://www.silabs.com/Support%20Documents/Software/CP210x_VCP_Win_XP_S2K3_Vista_7.exe Windows Treiber] von SiLabs getestet.
Treiber für andere Betriebssysteme können direkt bei ELV oder auch bei [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx SiLabs] gefunden werden.

==Vorgehen==
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. [http://www.heise.de/download/hterm.html HTerm]. 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 Kamera - Mitmach-Projekt]]
* [[RP6v2 I2C-Portexpander]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Quellen=
* [http://de.wikipedia.org/wiki/Universal_Serial_Bus USB]
* [http://de.wikipedia.org/wiki/RS-232 RS232]
* [[UART]]
* [http://de.wikipedia.org/wiki/Transistor-Transistor-Logik TTL]
* [http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf CP2102 Datasheet]
* [http://www.ti.com/lit/ds/symlink/max232.pdf MAX232N Datasheet]
* [http://www.fairchildsemi.com/ds/1N/1N5818.pdf 1N5817 Datasheet]

[[Kategorie:Elektronik]]
[[Kategorie:Projekte]]

=Autoren=
--[[Benutzer:Dirk|Dirk]] 17:06, 5. Sep 2012 (CET)

--[[Benutzer:Filou89|Filou]] 19:20, 26. Sep 2012 (CET)

RP6v2 USB-RS232-Adapter

2012-09-26T17:22:01Z

Filou89: /* Autoren */

=RP6v2 USB-RS232-Adapter: Hardware=

In diesem Projekt soll eine "Exp" ([[RP6#Experimentierplatine]], CONRAD [http://www.conrad.de/ce/de/product/191537/RP6-EXPERIMENTIERPLATINE 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 [http://www.conrad.de/ce/de/product/191638/Arexx-RP6-USB-Interface-RP6V2-TRANS RP6V2-TRANS] bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die [[RP6v2#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 [http://www.elv.de/mini-usb-modul-um2102-komplettbausatz.html 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 [http://www.pollin.de/shop/dt/MzY5OTgxOTk-/Bausaetze_Module/Bausaetze/RS232_TTL_Wandler_Bausatz.html 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 [http://www.conrad.de/ce/ 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 [http://www.conrad.de/ce/ CONRAD]):
{| {{Blauetabelle}}
|-
| Anzahl || Bestell-Nr. || Bauteil-Bezeichnung:
|-
| 1 || 191537 || RP6 Experimentierplatine
|-
| 1 || [http://www.elv.de/ ELV] || Mini-USB-UART-Umsetzer UM2102
|-
| 1 || [http://www.pollin.de/shop/index.html Pollin] || RS232-TTL-Wandler-Bausatz
|-
| 1 || 168274 || Schottky-Diode 1N5817
|-
| 1 || 736950 || Wannenstecker gewinkelt, 2 x 5-polig
|-
| 1 || 741119 || 1-reihige Stiftleiste RM 2,54 mm (36-polig)
|-
| 1 || 742902 || Zehn Codierbrücken (aus Set)
|-
| 4 || 526630 || M3-Abstandbolzen 10 mm
|-
| 1 || 815624 || Vier Muttern M3 (aus Set)
|-
| 1 || 815322 || Vier Schrauben M3 (aus Set)
|}

Hier erst einmal der Schaltplan:

[[bild:RP6_RS232_USB_SP.JPG]]

Und dann der Bestückungsplan:

[[bild:RP6_RS232_USB.JPG]]

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''' [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx 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 [[RP6_-_Programmierung#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===
{| {{Blauetabelle}}
|-
| Stecker || Pins || Bedeutung
|-
| ST1 || 10 || UART_TTL Wannenstecker (RX, TX, RTS, +5V *, GND)
|-
| ST2 || 4 || Suspend, RI, DTR, DSR an ST1
|-
| ST3 || 4 || TX, RX, RTS, CTS von UM2102 ODER RS232-TTL **
|-
| ST4 || 5 || Suspend, RI, DTR, DCD, DSR von UM2102
|-
| ST5 || 2 || 3,3 V, GND von UM2102
|}

'''Zu *)''' Falls JP7 = ON!

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

====ST1 (UART_TTL)====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || VDD || || +5 V
|-
| 2 || GND || || Masse
|-
| 3 || Suspend || A || Suspend (= ST2: 1)
|-
| 4 || n.c. || ||
|-
| 5 || RI || E || Ring Indicator (= ST2: 2)
|-
| 6 || DSR || E || Data Set Ready (= ST2: 4)
|-
| 7 || DTR || A || Data Terminal Ready (= ST2: 3)
|-
| 8 || RX || E || Receive Data (= ST3: 2)
|-
| 9 || TX || A || Transmit Data (= ST3: 1)
|-
| 10 || RTS || A || Request to Send (= ST3: 3)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || = ST1: 3
|-
| 2 || RI || E || = ST1: 5
|-
| 3 || DTR || A || = ST1: 7
|-
| 4 || DSR || E || = ST1: 6
|}

====ST3====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || TX || A || Transmit Data (= ST1: 9)
|-
| 2 || RX || E || Receive Data (= ST1: 8)
|-
| 3 || RTS || A || Request to Send (= ST1: 10)
|-
| 4 || CTS || E || Clear to Send
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || Suspend (von UM2102)
|-
| 2 || RI || E || Ring Indicator (von UM2102)
|-
| 3 || DTR || A || Data Terminal Ready (von UM2102)
|-
| 4 || DCD || E || Data Carrier Detect (von UM2102)
|-
| 5 || DSR || E || Data Set Ready (von UM2102)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || Bedeutung
|-
| 1 || + 3,3 V || 3,3 V / max. 100 mA (von UM2102)
|-
| 2 || GND || Masse
|}

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 [http://www.roboternetz.de/community/threads/29281-RP6-USRBUS 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:
{| {{Blauetabelle}}
|-
| Platine || UART || RX || TX || RX an Stecker || TX an Stecker
|-
| RP6v2Base || 0 || PD0 || PD1 || PROGU: 2 * || PROGU: 3 *
|-
| RP6 CONTROL M32 || 0 || PD0 || PD1 || PROGU: 2 **|| PROGU: 3 **
|-
| RP6 CCPRO M128 || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || I/O: 8 || I/O: 7
|-
| RP6v2 M256 WIFI || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || USPI15: 8 || USPI15: 6
|-
| || 2 || PH0 || PH1 || USPI24: 8 || USPI24: 6
|-
| || 3 || PJ0 || PJ1 || n.c. ***|| n.c. ***
|}

'''Zu *)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle]]" auf dem RP6 Mainboard anschliessen!

'''Zu **)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle_2]]" 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!

{| {{Blauetabelle}}
|-
| Jumper || Stellung || Bedeutung
|-
| JP1 || U (S) || TX von USB
|-
| JP1 || R || TX von RS232
|-
| JP2 || U (S) || RX von USB
|-
| JP2 || R || RX von RS232
|-
| JP3 || U (S) || CTS von USB
|-
| JP3 || R || CTS von RS232
|-
| JP4 || U (S) || RTS von USB
|-
| JP4 || R || RTS von RS232
|-
| JP5 || ON || RS232-TTL-Wandler Power ON
|-
| JP5 || OFF (S) || RS232-TTL-Wandler Power OFF
|-
| JP6 || ON || Power für UM2102 auch von UART_TTL Stecker (Pin 1)
|-
| JP6 || OFF (S) || Power für UM2102 nur vom PC über USB-Stecker
|-
| JP7 || ON || +5 V Verbindung zwischen XBUS: VDD und UART_TTL Stecker (Pin 1)
|-
| JP7 || OFF (S) || Keine +5 V Verbindung zwischen XBUS und UART_TTL Stecker
|-
| JP8 || ON || TX an USRBUS RX (Pin Y6)
|-
| JP8 || OFF (S) || TX nicht an USRBUS
|-
| JP9 || ON || RTS an USRBUS RST (Pin Y10)
|-
| JP9 || OFF (S) || RTS nicht an USRBUS
|-
| JP10 || ON || RX an USRBUS TX (Pin Y8)
|-
| JP10 || OFF (S) || RX nicht an USRBUS
|}

'''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 [[RP6v2_USB-RS232-Adapter#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:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>

Datei RP6M256uart1.c:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>
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:
<pre> 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
</pre>

=Software und USB-Treiber=
Der Hardwaretreiber wird von Windows nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber manuell installiert werden.
Für Windows 7 wurde dieser [http://www.silabs.com/Support%20Documents/Software/CP210x_VCP_Win_XP_S2K3_Vista_7.exe Windows Treiber] von SiLabs getestet.
Treiber fur andere Betriebssysteme können direkt bei ELV oder auch bei [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx SiLabs] gefunden werden.

Zum auswerten der empfangenen Daten eignet sich eigentlich jedes COM-Terminal. 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 Kamera - Mitmach-Projekt]]
* [[RP6v2 I2C-Portexpander]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Quellen=
* [http://de.wikipedia.org/wiki/Universal_Serial_Bus USB]
* [http://de.wikipedia.org/wiki/RS-232 RS232]
* [[UART]]
* [http://de.wikipedia.org/wiki/Transistor-Transistor-Logik TTL]
* [http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf CP2102 Datasheet]
* [http://www.ti.com/lit/ds/symlink/max232.pdf MAX232N Datasheet]
* [http://www.fairchildsemi.com/ds/1N/1N5818.pdf 1N5817 Datasheet]

[[Kategorie:Elektronik]]
[[Kategorie:Projekte]]

=Autoren=
--[[Benutzer:Dirk|Dirk]] 17:06, 5. Sep 2012 (CET)

--[[Benutzer:Filou89|Filou]] 19:20, 26. Sep 2012 (CET)

RP6v2 USB-RS232-Adapter

2012-09-26T17:20:20Z

Filou89:

=RP6v2 USB-RS232-Adapter: Hardware=

In diesem Projekt soll eine "Exp" ([[RP6#Experimentierplatine]], CONRAD [http://www.conrad.de/ce/de/product/191537/RP6-EXPERIMENTIERPLATINE 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 [http://www.conrad.de/ce/de/product/191638/Arexx-RP6-USB-Interface-RP6V2-TRANS RP6V2-TRANS] bei CONRAD, das anstelle des mitgelieferten Exemplars verwendet werden kann. Die [[RP6v2#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 [http://www.elv.de/mini-usb-modul-um2102-komplettbausatz.html 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 [http://www.pollin.de/shop/dt/MzY5OTgxOTk-/Bausaetze_Module/Bausaetze/RS232_TTL_Wandler_Bausatz.html 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 [http://www.conrad.de/ce/ 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 [http://www.conrad.de/ce/ CONRAD]):
{| {{Blauetabelle}}
|-
| Anzahl || Bestell-Nr. || Bauteil-Bezeichnung:
|-
| 1 || 191537 || RP6 Experimentierplatine
|-
| 1 || [http://www.elv.de/ ELV] || Mini-USB-UART-Umsetzer UM2102
|-
| 1 || [http://www.pollin.de/shop/index.html Pollin] || RS232-TTL-Wandler-Bausatz
|-
| 1 || 168274 || Schottky-Diode 1N5817
|-
| 1 || 736950 || Wannenstecker gewinkelt, 2 x 5-polig
|-
| 1 || 741119 || 1-reihige Stiftleiste RM 2,54 mm (36-polig)
|-
| 1 || 742902 || Zehn Codierbrücken (aus Set)
|-
| 4 || 526630 || M3-Abstandbolzen 10 mm
|-
| 1 || 815624 || Vier Muttern M3 (aus Set)
|-
| 1 || 815322 || Vier Schrauben M3 (aus Set)
|}

Hier erst einmal der Schaltplan:

[[bild:RP6_RS232_USB_SP.JPG]]

Und dann der Bestückungsplan:

[[bild:RP6_RS232_USB.JPG]]

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''' [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx 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 [[RP6_-_Programmierung#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===
{| {{Blauetabelle}}
|-
| Stecker || Pins || Bedeutung
|-
| ST1 || 10 || UART_TTL Wannenstecker (RX, TX, RTS, +5V *, GND)
|-
| ST2 || 4 || Suspend, RI, DTR, DSR an ST1
|-
| ST3 || 4 || TX, RX, RTS, CTS von UM2102 ODER RS232-TTL **
|-
| ST4 || 5 || Suspend, RI, DTR, DCD, DSR von UM2102
|-
| ST5 || 2 || 3,3 V, GND von UM2102
|}

'''Zu *)''' Falls JP7 = ON!

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

====ST1 (UART_TTL)====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || VDD || || +5 V
|-
| 2 || GND || || Masse
|-
| 3 || Suspend || A || Suspend (= ST2: 1)
|-
| 4 || n.c. || ||
|-
| 5 || RI || E || Ring Indicator (= ST2: 2)
|-
| 6 || DSR || E || Data Set Ready (= ST2: 4)
|-
| 7 || DTR || A || Data Terminal Ready (= ST2: 3)
|-
| 8 || RX || E || Receive Data (= ST3: 2)
|-
| 9 || TX || A || Transmit Data (= ST3: 1)
|-
| 10 || RTS || A || Request to Send (= ST3: 3)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || = ST1: 3
|-
| 2 || RI || E || = ST1: 5
|-
| 3 || DTR || A || = ST1: 7
|-
| 4 || DSR || E || = ST1: 6
|}

====ST3====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || TX || A || Transmit Data (= ST1: 9)
|-
| 2 || RX || E || Receive Data (= ST1: 8)
|-
| 3 || RTS || A || Request to Send (= ST1: 10)
|-
| 4 || CTS || E || Clear to Send
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || E/A || Bedeutung
|-
| 1 || Suspend || A || Suspend (von UM2102)
|-
| 2 || RI || E || Ring Indicator (von UM2102)
|-
| 3 || DTR || A || Data Terminal Ready (von UM2102)
|-
| 4 || DCD || E || Data Carrier Detect (von UM2102)
|-
| 5 || DSR || E || Data Set Ready (von UM2102)
|}

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====
{| {{Blauetabelle}}
|-
| Pin || Funktion || Bedeutung
|-
| 1 || + 3,3 V || 3,3 V / max. 100 mA (von UM2102)
|-
| 2 || GND || Masse
|}

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 [http://www.roboternetz.de/community/threads/29281-RP6-USRBUS 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:
{| {{Blauetabelle}}
|-
| Platine || UART || RX || TX || RX an Stecker || TX an Stecker
|-
| RP6v2Base || 0 || PD0 || PD1 || PROGU: 2 * || PROGU: 3 *
|-
| RP6 CONTROL M32 || 0 || PD0 || PD1 || PROGU: 2 **|| PROGU: 3 **
|-
| RP6 CCPRO M128 || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || I/O: 8 || I/O: 7
|-
| RP6v2 M256 WIFI || 0 || PE0 || PE1 || PROGU: 2 || PROGU: 3
|-
| || 1 || PD2 || PD3 || USPI15: 8 || USPI15: 6
|-
| || 2 || PH0 || PH1 || USPI24: 8 || USPI24: 6
|-
| || 3 || PJ0 || PJ1 || n.c. ***|| n.c. ***
|}

'''Zu *)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle]]" auf dem RP6 Mainboard anschliessen!

'''Zu **)''' Kann man auch am Stecker "[[RP6#Serielle_Schnittstelle_2]]" 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!

{| {{Blauetabelle}}
|-
| Jumper || Stellung || Bedeutung
|-
| JP1 || U (S) || TX von USB
|-
| JP1 || R || TX von RS232
|-
| JP2 || U (S) || RX von USB
|-
| JP2 || R || RX von RS232
|-
| JP3 || U (S) || CTS von USB
|-
| JP3 || R || CTS von RS232
|-
| JP4 || U (S) || RTS von USB
|-
| JP4 || R || RTS von RS232
|-
| JP5 || ON || RS232-TTL-Wandler Power ON
|-
| JP5 || OFF (S) || RS232-TTL-Wandler Power OFF
|-
| JP6 || ON || Power für UM2102 auch von UART_TTL Stecker (Pin 1)
|-
| JP6 || OFF (S) || Power für UM2102 nur vom PC über USB-Stecker
|-
| JP7 || ON || +5 V Verbindung zwischen XBUS: VDD und UART_TTL Stecker (Pin 1)
|-
| JP7 || OFF (S) || Keine +5 V Verbindung zwischen XBUS und UART_TTL Stecker
|-
| JP8 || ON || TX an USRBUS RX (Pin Y6)
|-
| JP8 || OFF (S) || TX nicht an USRBUS
|-
| JP9 || ON || RTS an USRBUS RST (Pin Y10)
|-
| JP9 || OFF (S) || RTS nicht an USRBUS
|-
| JP10 || ON || RX an USRBUS TX (Pin Y8)
|-
| JP10 || OFF (S) || RX nicht an USRBUS
|}

'''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 [[RP6v2_USB-RS232-Adapter#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:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>

Datei RP6M256uart1.c:
<pre>/* ****************************************************************************
* _______________________
* \| 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
</pre>
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:
<pre> 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
</pre>

=Software und USB-Treiber=
Der Hardwaretreiber wird von Windows nicht automatisch gefunden. Um das USB-Modul verwenden zu können, muss der Treiber manuell installiert werden.
Für Windows 7 wurde dieser [http://www.silabs.com/Support%20Documents/Software/CP210x_VCP_Win_XP_S2K3_Vista_7.exe Windows Treiber] von SiLabs getestet.
Treiber fur andere Betriebssysteme können direkt bei ELV oder auch bei [http://www.silabs.com/products/mcu/Pages/USBtoUARTBridgeVCPDrivers.aspx SiLabs] gefunden werden.

Zum auswerten der empfangenen Daten eignet sich eigentlich jedes COM-Terminal. 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 Kamera - Mitmach-Projekt]]
* [[RP6v2 I2C-Portexpander]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Quellen=
* [http://de.wikipedia.org/wiki/Universal_Serial_Bus USB]
* [http://de.wikipedia.org/wiki/RS-232 RS232]
* [[UART]]
* [http://de.wikipedia.org/wiki/Transistor-Transistor-Logik TTL]
* [http://www.silabs.com/Support%20Documents/TechnicalDocs/cp2102.pdf CP2102 Datasheet]
* [http://www.ti.com/lit/ds/symlink/max232.pdf MAX232N Datasheet]
* [http://www.fairchildsemi.com/ds/1N/1N5818.pdf 1N5817 Datasheet]

[[Kategorie:Elektronik]]
[[Kategorie:Projekte]]

=Autoren=
--[[Benutzer:Dirk|Dirk]] 17:06, 5. Sep 2012 (CET)
--[[Benutzer:Filou89|Filou]] 19:20, 26. Sep 2012 (CET)

RP6Control M32: I2C-Slave

2012-09-13T22:16:06Z

Filou89: /* I2C-Slave */

=Planung=

Erst mal die [http://www.roboternetz.de/community/threads/59178-RP6Control-M32-Projekt-I2C-Slave Planung]:

* 1. Der I2C-Slave für die M32 soll genauso arbeiten, wie der RP6Base I2C-Slave (RP6Base_I2CSlave.c) in den Demos.
* 2. Er soll möglichst (fast) alle Funktionen/Ressourcen der M32 über I2C "fernsteuerbar" bzw. abfragbar machen.
* 3. Er soll als I2C-Master eine andere M32, die CCPRO M128 oder die M256 WiFi akzeptieren.
* 4. Er soll die I2C-Adresse 12 bekommen.
* 5. Er soll über XBUS INT2 mit dem Master verbunden sein.
* 6. Er soll wie der Base-Slave auch eine Timeout-Funktion haben.
* 7. Er soll folgende Befehle (commands) über I2C verstehen:
<pre>// Commands:
#define CMD_CONFIGIOS 0
#define CMD_SETIOS 1
#define CMD_CONFIG 2
#define CMD_SETLEDS 3
#define CMD_DISCHARGEPEAKDETECTOR 4
#define CMD_GETMICROPHONEPEAK 5
#define CMD_SETMEM_CS2 6
#define CMD_WRITESPI 7
#define CMD_WRITEWORDSPI 8
#define CMD_READSPI 9
#define CMD_READWORDSPI 10

#define CMD_SET_WDT 11
#define CMD_SET_WDT_RQ 12
#define CMD_SET_HEARTBEAT 13

#define CMD_SPI_EEPROM_WRITEBYTE 14
#define CMD_SPI_EEPROM_WRITEWORD 15
#define CMD_SPI_EEPROM_ENABLEWRITE 16
#define CMD_SPI_EEPROM_DISABLEWRITE 17
#define CMD_SPI_EEPROM_READBYTE 18
#define CMD_SPI_EEPROM_READWORD 19
#define CMD_SPI_EEPROM_GETSTATUS 20

#define CMD_INITLCD 21
#define CMD_CLEARLCD 22
#define CMD_CLEARPOSLCD 23
#define CMD_WRITECHARLCD 24
#define CMD_WRITEINTEGERLCD 25
#define CMD_SETCURSORPOSLCD 26

#define CMD_BEEP 27
#define CMD_SETBEEPERPITCH 28
#define CMD_SOUND 29
</pre>
Dabei setzt Befehl 0 die 8 freien I/O-Pins der M32 als Ein- oder Ausgänge.
Befehl 1 schaltet die einzelnen I/O-Portpins.
Befehl 2 ist Platzhalter ohne Funktion (z.B. zur Konfiguration des Slave).
Befehl 3 schaltet die LEDs. Befehle 4, 5 gehen mit dem Mikro um.
Befehle 6-10 sind die SPI-Befehle.
Befehle 11,12 gehören zum Watchdog-Timer (wie bei der Base!).
Befehl 13 schaltet die LCD Heartbeat (Herzschlag) Funktion.
Befehle 14-20 lesen und schreiben von/aus dem SPI-EEPROM auf der M32.
Befehle 21-26 steuern das LCD auf der M32 an.
Befehle 27-29 steuern den Sound mit dem Beeper.
* 8. Er soll folgende Register zum Lesen durch den Master vorhalten:
<pre>
#define I2C_REG_STATUS1 0
#define I2C_REG_STATUS2 1
#define I2C_REG_IO_STATUS 2
#define I2C_REG_MEM_CS2 3
#define I2C_REG_SPIBYTE 4
#define I2C_REG_SPIWORD_L 5
#define I2C_REG_SPIWORD_H 6
#define I2C_REG_SPIEEPROMSTATUS 7
#define I2C_REG_SPIEEPROMBYTE 8
#define I2C_REG_SPIEEPROMWORD_L 9
#define I2C_REG_SPIEEPROMWORD_H 10
#define I2C_REG_ADC_4_L 11
#define I2C_REG_ADC_4_H 12
#define I2C_REG_ADC_3_L 13
#define I2C_REG_ADC_3_H 14
#define I2C_REG_ADC_2_L 15
#define I2C_REG_ADC_2_H 16
#define I2C_REG_ADC_6_L 17
#define I2C_REG_ADC_6_H 18
#define I2C_REG_ADC_5_L 19
#define I2C_REG_ADC_5_H 20
#define I2C_REG_ADC_7_L 21
#define I2C_REG_ADC_7_H 22
#define I2C_REG_ADC_MIC_L 23
#define I2C_REG_ADC_MIC_H 24
#define I2C_REG_ADC_KEYPAD_L 25
#define I2C_REG_ADC_KEYPAD_H 26
#define I2C_REG_RELEASEDKEYNUMBER 27
#define I2C_REG_PRESSEDKEYNUMBER 28
#define I2C_REG_LEDS 29
</pre>
Die REGs 0,1 sind die Interrupt- und Status-Register wie beim Base-Slave.
IO-Status (REG 2) sind die 8 freien I/O-Ports (sofern auf Eingänge geschaltet).
REGs 3-10 sind Leseregister der SPI- und SPI-EEPROM-Funktionen.
REGs 11-22 sind die freien ADC-Kanäle der M32.
REGs 23,24 sind der ADC-Wert des Mikro.
REGs 25,26 sind der ADC-Keypad-Wert.
REGs 27,28 sind die Nummern der zuletzt losgelassenen bzw. gedrückten Taste.
Mit REG 29 läßt sich der aktuelle Stand der 4 LEDs auslesen (an/aus).
* 9. Er soll auf die RP6Control Library [http://www.roboternetz.de/community/showthread.php?47198-RP6Control-M32-Neue-Library-Version-1.3beta V1.32beta] aufsetzen. Grund: Die aktuelle Lib V1.32beta ist voll kompatibel zur neuesten Version 1.3 und stellt mit eigenen Tasks schon regelmäßig die ADC-Werte und Werte der I/O-Ports zur Verfügung.
* 10. Bei Timeout soll die M32 funktionsfähig bleiben (Base-Slave bleibt dann in einer Endlosschleife stehen und muss resettet werden!).

=I2C-Slave=
Hier mal eine erste Version des M32 I2C-Slave.

Bitte testet diese Version! Was sollte noch geändert/verbessert werden? Fehler?

Datei RP6Control_I2CSlave.c:
<pre>/*
* ****************************************************************************
* RP6 ROBOT SYSTEM - RP6 CONTROL M32 EXAMPLES
* ****************************************************************************
* Example: I2C Slave
* Author(s): Dirk
* ****************************************************************************
* Description:
*
* A very common thing that many users will want to do with their M32 is
* to control it with a second controller which has more free resources.
* (more free memory, free I/O Ports and ADCs, faster, etc. pp.
* for example the RP6 C-Control PRO M128 or M256 WIFI expansion Module)
*
* This programs allows you to control the RP6 CONTROL M32 completely via
* I2C-Bus as a slave device!
*
* ############################################################################
* The Robot does NOT move in this example! You can simply put it on a table
* next to your PC and you should connect it to the PC via the USB Interface!
* ############################################################################
* ****************************************************************************
*/

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

#include "RP6ControlLib.h" // The RP6 Control Library v1.32beta.
// Always needs to be included!
#include "RP6I2CslaveTWI.h" // Include the I²C-Bus Slave Library

/*****************************************************************************/

// The Slave Address on the I2C Bus can be specified here:
#define RP6Control_I2C_SLAVE_ADR 12

/*****************************************************************************/

// This bitfield contains the main interrupt event status bits. This can be
// read out and any Master devices can react on the specific events.
union {
uint8_t byte;
struct {
uint8_t timeout:1;
uint8_t mem_cs2Change:1;
uint8_t insChange:1;
uint8_t keyChange:1;
uint8_t keypressed:1;
uint8_t unused:3;
};
} interrupt_status;

// Some status bits with current settings and other things.
union {
uint8_t byte;
struct {
uint8_t old_mem_cs2:1;
uint8_t mem_cs2:1;
uint8_t watchDogTimer:1;
uint8_t wdtRequest:1;
uint8_t wdtRequestEnable:1;
uint8_t heartbeat:1;
uint8_t unused:2;
};
} status;

/*****************************************************************************/

/**
* Generates Interrupt Signal and starts Software Watchdog
*/
void signalInterrupt(void)
{
I2CTWI_dataWasRead = 0;
DDRD |= EINT2; // XBUS INT2
PORTD |= EINT2;
if(status.watchDogTimer)
startStopwatch2();
}

/**
* Clears Interrupt
*/
void clearInterrupt(void)
{
stopStopwatch2();
setStopwatch2(0);
status.wdtRequest = false;
PORTD &= ~EINT2; // XBUS INT2
DDRD &= ~EINT2;
}

freeIOs_t old_ins;
uint8_t old_releasedKeyNumber;
uint8_t update_count = 0;

/**
* This function needs to be called frequently in the main loop. It updates
* some values (currently only mem_cs2Change, insChange, keyChange and
* keypressed status, but this may be expanded in future).
*/
void task_update(void)
{
if(getStopwatch4() > 250)
{
// Update mem_cs2 status:
status.mem_cs2 = PINB & MEM_CS2;
update_count++;
setStopwatch4(0);
}
if(update_count > 5)
{
// Update mem_cs2Change:
if(!interrupt_status.mem_cs2Change
&& (status.mem_cs2 != status.old_mem_cs2))
{
status.old_mem_cs2 = status.mem_cs2;
interrupt_status.mem_cs2Change = true;
signalInterrupt();
}
else if(interrupt_status.mem_cs2Change
&& (status.mem_cs2 == status.old_mem_cs2))
{
interrupt_status.mem_cs2Change = false;
signalInterrupt();
}
// Update insChange:
if(!interrupt_status.insChange && (ins.byte != old_ins.byte))
{
old_ins = ins;
interrupt_status.insChange = true;
signalInterrupt();
}
else if(interrupt_status.insChange && (ins.byte == old_ins.byte))
{
interrupt_status.insChange = false;
signalInterrupt();
}
// Update keyChange:
if(!interrupt_status.keyChange
&& (releasedKeyNumber != old_releasedKeyNumber))
{
old_releasedKeyNumber = releasedKeyNumber;
interrupt_status.keyChange = true;
signalInterrupt();
}
else if(interrupt_status.keyChange
&& (releasedKeyNumber == old_releasedKeyNumber))
{
interrupt_status.keyChange = false;
signalInterrupt();
}
update_count = 0;
}
// Update keypressed status:
interrupt_status.keypressed = pressedKeyNumber;
}

/*****************************************************************************/
// I2C Registers that can be read by the Master. Their names should
// be self-explanatory and directly relate to the equivalent variables/functions
// in the RP6Library

#define I2C_REG_STATUS1 0
#define I2C_REG_STATUS2 1
#define I2C_REG_IO_STATUS 2
#define I2C_REG_MEM_CS2 3
#define I2C_REG_SPIBYTE 4
#define I2C_REG_SPIWORD_L 5
#define I2C_REG_SPIWORD_H 6
#define I2C_REG_SPIEEPROMSTATUS 7
#define I2C_REG_SPIEEPROMBYTE 8
#define I2C_REG_SPIEEPROMWORD_L 9
#define I2C_REG_SPIEEPROMWORD_H 10
#define I2C_REG_ADC_4_L 11
#define I2C_REG_ADC_4_H 12
#define I2C_REG_ADC_3_L 13
#define I2C_REG_ADC_3_H 14
#define I2C_REG_ADC_2_L 15
#define I2C_REG_ADC_2_H 16
#define I2C_REG_ADC_6_L 17
#define I2C_REG_ADC_6_H 18
#define I2C_REG_ADC_5_L 19
#define I2C_REG_ADC_5_H 20
#define I2C_REG_ADC_7_L 21
#define I2C_REG_ADC_7_H 22
#define I2C_REG_ADC_MIC_L 23
#define I2C_REG_ADC_MIC_H 24
#define I2C_REG_ADC_KEYPAD_L 25
#define I2C_REG_ADC_KEYPAD_H 26
#define I2C_REG_RELEASEDKEYNUMBER 27
#define I2C_REG_PRESSEDKEYNUMBER 28
#define I2C_REG_LEDS 29

// These variables contain the results of the functions readSPI(),
// readWordSPI(), SPI_EEPROM_readByte[s](), SPI_EEPROM_getStatus() after the
// Master sent one of the commands CMD_READSPI, CMD_READWORDSPI,
// CMD_SPI_EEPROM_READBYTE/WORD, CMD_SPI_EEPROM_GETSTATUS. So these variables
// are updated only "on demand" and NOT permanently!
uint8_t spibyte;
uint16_t spiword;
uint8_t spieepromstatus;
uint8_t spieeprombyte;
uint16_t spieepromword;

/**
* This very important function updates ALL registers that the Master can read.
* It is called frequently out of the Main loop.
*/
void task_updateRegisters(void)
{
if(!I2CTWI_readBusy)
{
I2CTWI_readRegisters[I2C_REG_STATUS1] = (uint8_t)(interrupt_status.byte);
I2CTWI_readRegisters[I2C_REG_STATUS2] = (uint8_t)(status.byte);
I2CTWI_readRegisters[I2C_REG_IO_STATUS] = (uint8_t)(ins.byte);
I2CTWI_readRegisters[I2C_REG_MEM_CS2] = (uint8_t)(status.mem_cs2);
I2CTWI_readRegisters[I2C_REG_SPIBYTE] = (uint8_t)(spibyte);
I2CTWI_readRegisters[I2C_REG_SPIWORD_L] = (uint8_t)(spiword);
I2CTWI_readRegisters[I2C_REG_SPIWORD_H] = (uint8_t)(spiword>>8);
I2CTWI_readRegisters[I2C_REG_SPIEEPROMSTATUS] = (uint8_t)(spieepromstatus);
I2CTWI_readRegisters[I2C_REG_SPIEEPROMBYTE] = (uint8_t)(spieeprombyte);
I2CTWI_readRegisters[I2C_REG_SPIEEPROMWORD_L] = (uint8_t)(spieepromword);
I2CTWI_readRegisters[I2C_REG_SPIEEPROMWORD_H] = (uint8_t)(spieepromword>>8);
I2CTWI_readRegisters[I2C_REG_ADC_4_L] = (uint8_t)(adc4);
I2CTWI_readRegisters[I2C_REG_ADC_4_H] = (uint8_t)(adc4>>8);
I2CTWI_readRegisters[I2C_REG_ADC_3_L] = (uint8_t)(adc3);
I2CTWI_readRegisters[I2C_REG_ADC_3_H] = (uint8_t)(adc3>>8);
I2CTWI_readRegisters[I2C_REG_ADC_2_L] = (uint8_t)(adc2);
I2CTWI_readRegisters[I2C_REG_ADC_2_H] = (uint8_t)(adc2>>8);
I2CTWI_readRegisters[I2C_REG_ADC_6_L] = (uint8_t)(adc6);
I2CTWI_readRegisters[I2C_REG_ADC_6_H] = (uint8_t)(adc6>>8);
I2CTWI_readRegisters[I2C_REG_ADC_5_L] = (uint8_t)(adc5);
I2CTWI_readRegisters[I2C_REG_ADC_5_H] = (uint8_t)(adc5>>8);
I2CTWI_readRegisters[I2C_REG_ADC_7_L] = (uint8_t)(adc7);
I2CTWI_readRegisters[I2C_REG_ADC_7_H] = (uint8_t)(adc7>>8);
I2CTWI_readRegisters[I2C_REG_ADC_MIC_L] = (uint8_t)(adcMic);
I2CTWI_readRegisters[I2C_REG_ADC_MIC_H] = (uint8_t)(adcMic>>8);
I2CTWI_readRegisters[I2C_REG_ADC_KEYPAD_L] = (uint8_t)(adcKeypad);
I2CTWI_readRegisters[I2C_REG_ADC_KEYPAD_H] = (uint8_t)(adcKeypad>>8);
I2CTWI_readRegisters[I2C_REG_RELEASEDKEYNUMBER] = (uint8_t)(releasedKeyNumber);
I2CTWI_readRegisters[I2C_REG_PRESSEDKEYNUMBER] = (uint8_t)(pressedKeyNumber);
I2CTWI_readRegisters[I2C_REG_LEDS] = (uint8_t)(externalPort.LEDS);
if(I2CTWI_dataWasRead && I2CTWI_dataReadFromReg == 0)
clearInterrupt();
}
}

/*****************************************************************************/
// Command Registers - these can be written by the Master.
// The other registers (read registers) can NOT be written to. The only way to
// communicate with the M32 is via specific commands.
// Of course you can also add more registers if you like...

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

#define I2C_REGW_CMD 0
#define I2C_REGW_CMD_PARAM1 1
#define I2C_REGW_CMD_PARAM2 2
#define I2C_REGW_CMD_PARAM3 3
#define I2C_REGW_CMD_PARAM4 4
#define I2C_REGW_CMD_PARAM5 5
#define I2C_REGW_CMD_PARAM6 6

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

uint8_t cmd;
uint8_t param1;
uint8_t param2;
uint8_t param3;
uint8_t param4;
uint8_t param5;
uint8_t param6;

/**
* Checks if a new Command has been received and also reads all
* paramters associated with this command.
* It returns true if a new command has been received.
*/
uint8_t getCommand(void)
{
if(I2CTWI_writeRegisters[I2C_REGW_CMD] && !I2CTWI_writeBusy)
{
cmd = I2CTWI_writeRegisters[I2C_REGW_CMD]; // store command register
I2CTWI_writeRegisters[I2C_REGW_CMD] = 0; // clear command register (!!!)
param1 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM1]; // parameters 1-6...
param2 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM2];
param3 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM3];
param4 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM4];
param5 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM5];
param6 = I2CTWI_writeRegisters[I2C_REGW_CMD_PARAM6];
return true;
}
return false;
}

/*****************************************************************************/
// Command processor:

// Commands:
#define CMD_CONFIGIOS 0
#define CMD_SETIOS 1
#define CMD_CONFIG 2
#define CMD_SETLEDS 3
#define CMD_DISCHARGEPEAKDETECTOR 4
#define CMD_GETMICROPHONEPEAK 5
#define CMD_SETMEM_CS2 6
#define CMD_WRITESPI 7
#define CMD_WRITEWORDSPI 8
#define CMD_READSPI 9
#define CMD_READWORDSPI 10

#define CMD_SET_WDT 11
#define CMD_SET_WDT_RQ 12
#define CMD_SET_HEARTBEAT 13

#define CMD_SPI_EEPROM_WRITEBYTE 14
#define CMD_SPI_EEPROM_WRITEWORD 15
#define CMD_SPI_EEPROM_ENABLEWRITE 16
#define CMD_SPI_EEPROM_DISABLEWRITE 17
#define CMD_SPI_EEPROM_READBYTE 18
#define CMD_SPI_EEPROM_READWORD 19
#define CMD_SPI_EEPROM_GETSTATUS 20

#define CMD_INITLCD 21
#define CMD_CLEARLCD 22
#define CMD_CLEARPOSLCD 23
#define CMD_WRITECHARLCD 24
#define CMD_WRITEINTEGERLCD 25
#define CMD_SETCURSORPOSLCD 26

#define CMD_BEEP 27
#define CMD_SETBEEPERPITCH 28
#define CMD_SOUND 29

uint8_t rw_buffer[3];

/**
* This function checks if commands have been received and processes them.
*/
void task_commandProcessor(void)
{
if(getCommand())
{
switch(cmd)
{
case CMD_CONFIGIOS: if(param1) setFreeIOsToOUT(); else setFreeIOsToIN(); break;
case CMD_SETIOS: setOUTs(param1); break;
case CMD_CONFIG: break;
case CMD_SETLEDS: setLEDs(param1); break;
case CMD_DISCHARGEPEAKDETECTOR: dischargePeakDetector(); break;
case CMD_GETMICROPHONEPEAK: adcMic = getMicrophonePeak(); break;
case CMD_SETMEM_CS2: if(param1) PORTB |= MEM_CS2; else PORTB &= ~MEM_CS2; break;
case CMD_WRITESPI: writeSPI(param1); break;
case CMD_WRITEWORDSPI: writeWordSPI((param1<<8)+param2); break;
case CMD_READSPI: spibyte = readSPI(); break;
case CMD_READWORDSPI: spiword = readWordSPI(); break;
case CMD_SET_WDT: status.watchDogTimer = param1 ? true : false; break;
case CMD_SET_WDT_RQ: status.wdtRequestEnable = param1 ? true : false; break;
case CMD_SET_HEARTBEAT: status.heartbeat = param1 ? true : false; break;
case CMD_SPI_EEPROM_WRITEBYTE: SPI_EEPROM_writeByte((param1<<8)+param2, param3); break;
case CMD_SPI_EEPROM_WRITEWORD: rw_buffer[0] = param3; rw_buffer[1] = param4;
SPI_EEPROM_writeBytes((param1<<8)+param2, &rw_buffer[0], 2); break;
case CMD_SPI_EEPROM_ENABLEWRITE: SPI_EEPROM_enableWrite(); break;
case CMD_SPI_EEPROM_DISABLEWRITE: SPI_EEPROM_disableWrite(); break;
case CMD_SPI_EEPROM_READBYTE: spieeprombyte = SPI_EEPROM_readByte((param1<<8)+param2); break;
case CMD_SPI_EEPROM_READWORD: SPI_EEPROM_readBytes((param1<<8)+param2, &rw_buffer[0], 2);
spieepromword = (rw_buffer[0]<<8)+rw_buffer[1]; break;
case CMD_SPI_EEPROM_GETSTATUS: spieepromstatus = SPI_EEPROM_getStatus(); break;
case CMD_INITLCD: initLCD(); break;
case CMD_CLEARLCD: clearLCD(); break;
case CMD_CLEARPOSLCD: clearPosLCD(param1, param2, param3); break;
case CMD_WRITECHARLCD: writeCharLCD(param1); break;
case CMD_WRITEINTEGERLCD: writeIntegerLCD((param1<<8)+param2, param3); break;
case CMD_SETCURSORPOSLCD: setCursorPosLCD(param1, param2); break;
case CMD_BEEP: beep(param1, (param2<<8)+param3); break;
case CMD_SETBEEPERPITCH: setBeeperPitch(param1); break;
case CMD_SOUND: sound(param1, (param2<<8)+param3, (param4<<8)+param5); break;
}
}
}

/**
* This is the Software watchdog function. After any interrupt event, a timer is
* started and if a certain amount of time has passed by with no reaction from
* the Master, the RP6 CONTROL M32 shows this by blinking with status LEDs 1..4
* for 3 seconds. After this the interrupt and interrupt status are cleared.
* Usually the Master program has errors or is locked up if it does not react,
* so the blinking LEDs show, that there is a communication problem.
*/
void task_MasterTimeout(void)
{
if(status.watchDogTimer)
{
static uint8_t blinkflag = 0;
if(getStopwatch2() > 3000) // 3 seconds timeout for the master to react on
{ // our interrupt events - if he does not react, we
// blink with LEDs 1..4 for another 3 seconds!
interrupt_status.timeout = true;
if(getStopwatch2() > 6000)
{
setLEDs(0b0000); // Clear LEDs
interrupt_status.byte = 0; // Clear interrupt status
setStopwatch4(0);
clearInterrupt(); // Clear interrupt
}
}
else if(getStopwatch3() > 250)
{
status.wdtRequest = true;
signalInterrupt();
setStopwatch3(0);
}
if(interrupt_status.timeout)
{
if(getStopwatch5() > 200)
{
if(blinkflag)
{
setLEDs(0b1001);
blinkflag = 0;
}
else
{
setLEDs(0b0110);
blinkflag = 1;
}
setStopwatch5(0);
}
}
}
}

/**
* LCD Heartbeat function
*/
void task_LCDHeartbeat(void)
{
if(status.heartbeat)
{
if(getStopwatch1() > 500)
{
static uint8_t heartbeat = false;
if(heartbeat)
{
clearPosLCD(1, 15, 1);
heartbeat = false;
}
else
{
setCursorPosLCD(1, 15);
writeStringLCD_P("*");
heartbeat = true;
}
setStopwatch1(0);
}
}
}

/*****************************************************************************/
// Main - The program starts here:

int16_t main(void)
{
initRP6Control();

clearLCD();

setLEDs(0b1111);
mSleep(500);
setLEDs(0b0000);

I2CTWI_initSlave(RP6Control_I2C_SLAVE_ADR);

status.byte = 0;
interrupt_status.byte = 0;
// TEST TEST TEST TEST TEST TEST
status.watchDogTimer = true;
status.heartbeat = true;
// TEST TEST TEST TEST TEST TEST
startStopwatch1(); // For LCDHeartbeat function
startStopwatch3();
startStopwatch4();
startStopwatch5();

while(true)
{
task_commandProcessor();
task_update();
task_updateRegisters();
task_RP6M32System();
task_MasterTimeout();
task_LCDHeartbeat();
}

return 0;
}
</pre>

=I2C-Master (RP6v2 M256 WiFi)=

=Siehe auch=

* [[RP6]]
* [[RP6 - Programmierung]]
* [[RP6v2]]
* [[RP6 - Morse-Code]]
* [[CCRP5]]
* [[Yeti]]
* [[Asuro]]

=Weblinks=

* [http://www.roboternetz.de/community/threads/59178-RP6Control-M32-Projekt-I2C-Slave RP6Control M32: Projekt I2C-Slave]

[[Kategorie:Robotikeinstieg]]
[[Kategorie:Praxis]]

=Autoren=

--[[Benutzer:Dirk|Dirk]] 19:20, 12. Sep 2012 (CET)