Hallo,
ich habe folgendes Problem:
Ich arbeite zum ersten mal mit einem ARM Cortex-M3 Controller und möchte
eine Compilervalidierung vollziehen. Dafür muss ich auf die
UART-Schnittstelle zugreifen und möchte über ein Eingabeterminal (PuTTy)
eine Funktion aufrufen. Was ich schon geschafft habe ist, dass ich den
UART so konfiguriert habe und mir diverse Zeichenketten ausgegeben
wurden. Was ich aber nicht schaffe ist, dass ich sozusagen dazu komme
irgendwas einzugeben. Habe es schon mit der
scanf/printf-Funktionskombination probiert, aber da hängt sich das
Programm nur dabei auf. Zeichen sende und empfange ich ja über COMTX
bzw. COMRX. Wie schaffe ich es jetzt Zeichen zu senden über COMRX? Der
Controller ist ein ADuCM301 von Analog Devices.
Ich habe schon im Internet recherchiert, aber nix brauchbares gefunden.
Wäre dankbar wenn mir jemand helfen könnte.
Hallo,
ich kenne mich mit deinem Controller nicht aus,
aber es gibt folgendes Problem:
Wenn du mit deiner Tastatur Worte etc. eingeben willst, woher soll die
Empfangsroutine wissen, wann die Eingabe beendet ist??
besser du verwendest ein Zeichen zur Funktionsauswahl. Und du verwendest
GetChr(), also jedes einzelne Zeichen auslesen.
Hallo Externer,
mit Deinen Angaben ist es etwas schwierig Dir zu helfen.
Ist das Dein erster Mikrocontroller mit dem Du programmierst?
Wenn Du an Deinen Controller Werte schickst müssen die ja auch irgendwo
herkommen, da hast Du keine Aussage dazu gemacht.
Etwas Programmcode wäre auch hilfreich. Printf und scanf sind in einer
Interruptroutine wohl auch nicht das optimale.
Grüße
Dr. Datensalat schrieb:> Hallo Externer,mit Deinen Angaben ist es etwas schwierig Dir zu helfen.Ist das
Dein erster Mikrocontroller mit dem Du programmierst?Wenn Du an Deinen Controller
Werte schickst müssen die ja auch irgendwoherkommen, da hast Du keine Aussage dazu
gemacht.Etwas Programmcode wäre auch hilfreich. Printf und scanf sind in
einerInterruptroutine wohl auch nicht das optimale.Grüße
Nein, das ist nicht mein erster Controller, aber meine erste
UART-Schnittstelle die ich programmiere um darüber Daten senden und
empfangen zu können.
Ich habe bisher ohne Interrupts gearbeitet, da ich diese für den ersten
Test nicht als allzu notwendig empfinde. Ich habe dazu größtenteils
versucht
[[http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART|dieses
AVR-GCC-Tutorial]] für den ARM nachzuvollziehen was bis zum Empfangsweg
auch geklappt hat. Senden kann ich über die Eingabe noch nichts.
Ich poste mal hier kurz den Code:
1
#include"ioadcm301.h"
2
#include<stdio.h>
3
#include<stdlib.h>
4
5
//Prototypes
6
voidInitialize(void);
7
voidconfig_Clk(void);
8
voidconfig_UART(void);
9
voidUART_test(void);
10
voiduart_puts(constchar*s);
11
staticinlineintuart_putc(constcharc);
12
13
//Global
14
chareingabe[]="start";//RX String
15
16
intmain(void)
17
{
18
unsignedcharc;//Sending Sign
19
20
T3CON=0;// Stop Watch Dog
21
22
Initialize();//Initialize all
23
24
COMTX=0x0A;// LF
25
while((COMLSR&(1<<6))==0);// Wait till TX shift is empty
26
COMTX=0x0D;// CR
27
28
while(1){
29
30
for(inti=0;i<=9;++i)
31
{
32
c=i+'0';
33
while((COMLSR&(1<<6))==0);// Wait till TX shift is empty
34
COMTX=c;
35
}
36
37
while((COMLSR&(1<<6))==0);// Wait till TX shift is empty
38
COMTX=0x0D;// CR
39
printf("\n\n");
40
41
uart_puts(eingabe);
42
uart_puts("start");
43
44
if(eingabe=="start")
45
UART_test();
46
47
for(inti=0;i<100000;++i);
48
GP4TGL=(1<<2);// Toggle LED
49
50
}
51
52
53
// return 0;
54
}
55
56
voiduart_puts(constchar*s){
57
do{
58
uart_putc(*s);
59
}
60
while(*s++);
61
}
62
63
staticinlineintuart_putc(constcharc){
64
while((COMLSR&(1<<6))==0);// Wait till TX shift is empty
65
COMRX=c;// Send sign
66
return1;
67
}
68
69
voidUART_test(void){
70
printf("Die Testfunktion konnte erfolgreich aufgerufen werden!\n");
71
}
72
73
voidInitialize(void){
74
config_Clk();// Clock configuration
75
76
// General Purpose I/O configuration
77
GP1CON=(2<<(2*1))// Set P1.1 to UART TXD and P1.0 to UART RXD Mode
78
|(1<<(2*0));
79
80
GP4CON=(1<<(2*2));// P4.2 GPIO LED
81
GP4OEN=(1<<2);
82
GP4PUL=(1<<2);
83
GP4OUT=(1<<2);
84
85
config_UART();// UART configuration
86
}
87
88
voidconfig_Clk(void){
89
CLKCON=0x0000;// Choose Internal Oscillator with 16MHz in active mode
Externer schrieb:> Ich habe bisher ohne Interrupts gearbeitet, da ich diese für den ersten> Test nicht als allzu notwendig empfinde.
Passt doch.
Machs halt erst mal ohne Interrupts.
Erster SChritt: ein einzelnes Zeichen zu empfangen und gleich wieder
zurückzusenden.
> AVR-GCC-Tutorial]] für den ARM nachzuvollziehen was bis zum Empfangsweg> auch geklappt hat. Senden kann ich über die Eingabe noch nichts.
Bitte gewöhn dich daran, dass die Begriffe Senden/Empfangen aus Sicht
des µC gesehen werden.
Wenn der µC sendet, dann gehen die Zeichen von ihm aus und werden vom
Terminal empfangen und dargestellt
Wenn das Terminal sendet, dann gehen die Zeichen vom Terminal zum µC und
werden vom µC empfangen.
Da es hier um die Programmierung des µC geht, sind die Begriffe Senden
und Empfangen aus seiner Sicht zu sehen. Das bedeutet: nicht du 'kannst
noch nichts über die Eingabe senden', sondern du weißt noch nicht wie du
die UART im µC abfragst, ob sie etwas empfangen hat.
Diese Verwirrung hattest du schon mal in einem vorhergehenden Post. Ich
habs damals einem Postingfehler zugeschrieben. Da derselbe
Begriffsdreher hier nochmal auftaucht, bin ich mir sicher, dass das kein
Zufall war.
Warum ist das interessant. Weil es keinen Menschen interessiert (und
schon gar nicht den µC), wer oder was am anderen Ende des Kabels hängt.
Die UART empfängt etwas und dein Programm muss damit was machen.
PS:
Deine Schreibweise mit den vielen direkt im Code geschriebenen Zahlen
ist natürlich nicht besonders angetan, das man nachvollziehen kann, was
du da eigentlich konfigurierst.
Zb. wirst du ja wohl irgendwo den Transmitter der UART eingeschaltet
haben (wenn das so funktioniert, dass man Transmitter und Receiver
getrennt einschalten kann). In deinem Code mit den vielen Zahlen ist das
aber absolut nicht erkennbar, wo das sein könnte.
Sei es wies sei: Auch diese UART wird irgendwo ein Statusregister haben,
in dem es ein Bit gibt, welches aussagt, das die UART ein Byte empfangen
hat.
