OK ich werd dann mal konkreter:
Mein Programm soll die am µC anliegende Spannung erfassen (von analogen
Eingang) und die Spannung über die serielle Schnittstelle weitergeben.
Dabei soll die Periode (wie oft "abgetastet" wird) einstellbar sein. So
mein Ansatz für die C-Files:
IO.C:
P2 = 0x0000; // P2 mit Wert initialisieren
ODP2 = 0x0000; // Alle Kanäle in Push/Pull-Mode
DP2 = 0x03FF; // P2.0 - P 2.9 auf Ausgabe setzen
------------------------------------------------------------
Main.C:
#include "MAIN.H"
#include "stdio.H"
unsigned int result;
unsigned int periode;
IEN = 1; // Globale Interrupt-Freigabe
void main(void)
{
while(1){
//printf("Geben Sie die Periode ein! Vorteiler = 512");
periode=_getkey(); // Eingegebenen Wert einlesen
while(ADBSY){} // solange beschäftigt ist, warte
result = ADDAT & 0x03FF; // Maskierung um 10 Bit Ergebnis der
ADC Wandlung zu erhalten
result=(result*5.)/1024.; // Umrechnung: 1024 Stufen, 5 V
printf("%f\n",result); // Ergebnis ausgeben
T3IR=0; // zurücksetzen des Interrupt Request Bits
für neuerliche Abfrage
// wird gesetzt wenn Timer 0 erreicht
}
}
------------------------------------------------------------
ADC.C:
void ADC_vInit(void)
{
/// fixed channel single conversion
/// ADC start bit is set
ADCON = 0x0088; // Start der A/D-Wandlung von Kanal 8
}
------------------------------------------------------------
GT1.C:
#include "MAIN.H"
#include "Math.H"
unsigned int Round(unsigned int Zahl, unsigned int Stellen)
{
Zahl *= pow(10, Stellen);
if (Zahl >= 0)
{
floor(Zahl + 0.5);
}
else
{
ceil(Zahl - 0.5);
Zahl /= pow(10, Stellen);
}
return Zahl;
}
unsigned int extern periode;
void GT1_vInit(void)
{
T3CON = 0x0086; // Vorteiler 512, Timer Mode, noch nicht starten,
Abwärtszähler
T3 = 0x9897; // load timer 3 register, Anzahl der Takte
T3IC = 0x0048; // Gruppenlevel: 0
// Prioritätsstufe: 2
// enable Timer 3 Interrupt
T3R = 1; // set timer 3 run bit
// Starten des Timers
}
void GT1_viIsrTmr3(void) interrupt T3INT
{
T3IR=0; // zurücksetzen des Interrupt Request Bits für neuerliche
Abfrage
// wird gesetzt wenn Timer 0 erreicht
T3=Round(periode/(50e-9*512),0); // 50ns = kleinste Taktzyklus?
// 50e-9*512 ergeben den Zeitraum, in dem 1 x
abgefragt wird
// Bsp.: 1 / erg = Anzahl der Takte wobei 1 für eine
Sekunde steht
ADST=1; // Start der A/D-Wandlung
}
------------------------------------------------------------
ASC.C:
void ASC_vInit(void)
{
/// 8-bit data asynchronous operation
/// one stop bit
/// ignore framing error
/// ignore overrun error
/// divide clock by reload value + constant
/// receiver enabled
S0CON = 0x0011;
// ASC baudrate reload register
/// baudrate = 9615,38 Baud
S0BG = 0x0040; // Baudrate auf 9600 Bd mit S0BRS=0
// S0BRS = 0 Divide clock by reload-value + constant
(depending on mode)
P3 |= 0x0400; // set P3.10 output latch (TXD0)
// P3.10 auf 1 setzen (Rest bleibt wie er ist)
// enstpricht P3 = P3 | 0x0400;
DP3 |= 0x0400; /// set P3.10 direction control (TXD0 output)
// P3.10 auf Ausgang setzen, Rest bleibt
DP3 &= 0xF7FF; /// reset P3.11 direction control (RXD0 input)
// P3.8 - P3.10 bleibt nach Maskierung übrig (Rest 0)
// das was vorher eingestellt war, bleibt
S0TIR=1; // setzen des Interrupt Request Flag
// f. Polling (fortlaufende Abfrage der Signale)
// This source has raised an interrupt request
S0R = 1; // enable baudrate generator
// Start des Baudratengenerators
}
}
Ich hab mir gedacht, ich mach einen Interrupt wenn die serielle
Schnittstelle was empfängt. Wie heißt die dazugehörige Fkt. (verwende
kein Dave im Moment)? Soll ich diese zu ASC.c hinzufügen oder GT1.c?
Wenn ich sie unter GT1.c hinzutue, wie heißt die dann? Wird dann nur der
Einsprungspunkt geändert und sie heißt gleich?
So ganz habe ich noch nicht gecheckt wie das arbeiten soll, ich stelle
es mir aber im Moment so vor:
Ich spiele mein fertige *.h86 HEX Datei auf den Speicher und starte dann
die Flash-Anwendung und Hyperterminal. Irgendwie so geht es. Den
Programmaufbau stelle ich mir so vor: Wenn ich was in meiner C-Datei was
ausgebe (z.B. mit printf), dann wird es auch auf dem Hyperterminal
ausgegeben. Und meine Java-Anwendung schaut nur, wenn was über die
serielle Schnittstelle kommt, zeigt mir das an, und kann wieder was über
die serielle Schnittstelle senden, welches mein C Programm mit _getkey
wieder bekommt. Lieg ich dabei viel daneben?
So zum Schluss meine Java Datei:
package serielle;
import at.htlklu.elektronik.schnittstellen.SerielleSchnittstelle;
import at.htlklu.elektronik.schnittstellen.StringListener;
public class Main implements StringListener{
/** Creates a new instance of Main */
public Main() {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
new Main().echo();
System.out.println(„Geben Sie die Periode ein!“);
String eingegeben =
stringEvent.getStringReceived();
System.out.println(eingegeben);
com.sendString(eingegeben);
}
SerielleSchnittstelle com;
public void echo() {
com = new SerielleSchnittstelle();
// optional Abfrage des Ports
String port =
SerielleSchnittstelle.listAndSelectPort();
if (port != null)
com.setPortName(port);
//
com.addStringListener(this);
}
public void stringReceived(
at.htlklu.elektronik.schnittstellen.StringEvent
stringEvent) {
String empfangen =
stringEvent.getStringReceived();
System.out.println(empfangen);
com.sendString(empfangen);
}
}
Hier könnt ihr meine Files finden (Java ist noch alter Source-Code):
http://www.speedyshare.com/123780834.html
Passwort: http://www.mikrocontroller.net
Mehr weiß ich einfach nicht.
Grüße
Franz
