Willkommen, Gast
Benutzername: Passwort: Angemeldet bleiben:

THEMA: Neues zum EX Protokoll

Neues zum EX Protokoll 22 Feb 2015 22:08 #19

  • Höllenhund
  • Höllenhunds Avatar
  • Offline
  • Fresh Boarder
  • Fresh Boarder
  • Beiträge: 4
  • Dank erhalten: 0
Auch wenn der Beitrag schon sehr alt ist, hänge ich mich mal ganz frech hier an :-)

Ich versuche gerade erfolglos eines der drei Beispiele aus der Telemetriedokumentation lauffähig zu bekommen, aber egal was ich probiere es tut sich rein garnichts in der Telemtrieanzeige meiner Fernsteuerung. Auch mehrfaches Zurücksetzten der Telemetrieanzeige in der Fernsteuerung bewirkt nichts. Zu Kontrollzwecken habe ich zeitweise die Übertragung auf 8Bit zurückgestellt und am PC mittels Terminalprogramm eingelsen. Unterschiede zu den Beispielen sind dabei nicht aufgetreten. Da mir so langsam die Ideen ausgehen wäre es schön wenn mir jemand ein Tip geben könnte was ich falsch mache.


Verwendete Komponenten:
Fernsteuerung Jeti DS16 Firmware V3.02
Empfänger Jeti R6F Firmware V3.23 (Spannungsversorgung über Kanal 3 und am EXT-Anschluss der TxD-Pin vom Mikroprozessor)
Mikroprozessor: Atmel ATMega644 mit 7.3728 MHz Taktquarz und 10K Ohm Widerstand zwischen TxD und RxD

Verwendete Unterlagen:
Beschreibung EX-Protokoll: www.jetimodel.com/de/show-file/26/

Quellcode siehe Anhang:

Da das Anhängen nicht klappt, hier der Quellcode:
#include <avr/io.h>

#define F_CPU 7372800UL //Systemtakt in Hz
#define BAUD0 9600UL //Baudrate Telemetrie
#include <util/delay.h>


void USART0_senden( unsigned char data )
{
while ( !( UCSR0A & (1<<UDRE0)) )
;
UDR0 = data;
}


void jeti_beispiel_data()
{
// EX Data
USART0_senden(0x07E);
USART0_senden(0x09F); // Protokoll EX-Data
USART0_senden(0x04C); // Upper Serial
USART0_senden(0x0A1); //
USART0_senden(0x0A8); // Lower Serial
USART0_senden(0x05D); //
USART0_senden(0x055); //
USART0_senden(0x000); // Reserved
USART0_senden(0x011); // Identifier 1:
USART0_senden(0x0E8); // Position Dezimalpunkt
USART0_senden(0x023); //
USART0_senden(0x021); // Identifier 2:
USART0_senden(0x01B); // Position Dezimalpunkt
USART0_senden(0x000); //
USART0_senden(0x0F4); // CRC

USART0_senden(0x0FE); // Protokoll simple Text
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x02A); // *
USART0_senden(0x04D); // M
USART0_senden(0x053); // S
USART0_senden(0x050); // P
USART0_senden(0x045); // E
USART0_senden(0x045); // E
USART0_senden(0x044); // D
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x06D); // *
USART0_senden(0x02F); // m
USART0_senden(0x073); // /
USART0_senden(0x020); // s
USART0_senden(0x020); //
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x020); // >
USART0_senden(0x031); // 1
USART0_senden(0x030); // 0
USART0_senden(0x030); // 0
USART0_senden(0x02E); // .
USART0_senden(0x030); // 0
USART0_senden(0x0FF);
}

void jeti_beispiel_text(){
USART0_senden(0x07E);
USART0_senden(0x09F); // Protokoll EX-Text
USART0_senden(0x00F); // Messagetype
USART0_senden(0x0A1); // Upper Serial
USART0_senden(0x0A8); //
USART0_senden(0x05D); // Lower Serial
USART0_senden(0x055); //
USART0_senden(0x000); // Reserved
USART0_senden(0x002); // Identifier
USART0_senden(0x02A); // Length
USART0_senden(0x054); // T
USART0_senden(0x065); // e
USART0_senden(0x06D); // m
USART0_senden(0x070); // p
USART0_senden(0x02E); // .
USART0_senden(0x0B0); // °
USART0_senden(0x043); // C
USART0_senden(0x028); // CRC

USART0_senden(0x0FE); // Protokoll simple Text
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x02A); // *
USART0_senden(0x04D); // M
USART0_senden(0x053); // S
USART0_senden(0x050); // P
USART0_senden(0x045); // E
USART0_senden(0x045); // E
USART0_senden(0x044); // D
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x06D); // *
USART0_senden(0x02F); // m
USART0_senden(0x073); // /
USART0_senden(0x020); // s
USART0_senden(0x020); //
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x020); // >
USART0_senden(0x031); // 1
USART0_senden(0x030); // 0
USART0_senden(0x030); // 0
USART0_senden(0x02E); // .
USART0_senden(0x030); // 0
USART0_senden(0x0FF);

}

void jeti_beispiel_alarm(){
USART0_senden(0x07E); // Protokoll Alarm
USART0_senden(0x092); // Länge
USART0_senden(0x023); // Akustischer Alarm
USART0_senden(0x059); // Ascii *Y* für Morsealarm

USART0_senden(0x0FE); // Protokoll simple Text
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x02A); // *
USART0_senden(0x04D); // M
USART0_senden(0x053); // S
USART0_senden(0x050); // P
USART0_senden(0x045); // E
USART0_senden(0x045); // E
USART0_senden(0x044); // D
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x020); //
USART0_senden(0x06D); // *
USART0_senden(0x02F); // m
USART0_senden(0x073); // /
USART0_senden(0x020); // s
USART0_senden(0x020); //
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x03E); // >
USART0_senden(0x020); // >
USART0_senden(0x031); // 1
USART0_senden(0x030); // 0
USART0_senden(0x030); // 0
USART0_senden(0x02E); // .
USART0_senden(0x030); // 0
USART0_senden(0x0FF);
}

int main(void)
{
// Register für USART0 setzen
// Asynchon
// Halbduplex
// 9 Datenbits
// 2 Stoppbits
// Odd-Parity
UBRR0 = (F_CPU / (BAUD0 * 16L) - 1);
UCSR0B |= (1<<TXEN0) | (1<<UCSZ02); // Senden aktiv; 9 Datenbits
UCSR0C |= (1<<UPM01) | (1<<UPM00) | (1<<USBS0) | (1<<UCSZ01) | (1<<UCSZ00); // Asynchron; Odd Parity ; 2 Stoppbits; 9 Datenbits

while(1)
{
jeti_beispiel_data();
//jeti_beispiel_text();
//jeti_beispiel_alarm();
_delay_ms(20);
//_delay_ms(100);
//_delay_ms(200);
}
}

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Letzte Änderung: von Höllenhund.

Neues zum EX Protokoll 22 Feb 2015 22:27 #20

  • dvcam99
  • dvcam99s Avatar
  • Offline
  • Senior Boarder
  • Senior Boarder
  • Beiträge: 48
  • Dank erhalten: 11
Hallo,

geht denn der gute alte klassische Jeti Box Text Mode auch nicht?

Gibt denn der Atmel UART die 9 Datenbits plus das zehnte Parity Bit aus??
Also am besten mal mit einem Logic Analyser richtig auf dem Bus messen.

VG

Dirk

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Neues zum EX Protokoll 22 Feb 2015 22:43 #21

  • Höllenhund
  • Höllenhunds Avatar
  • Offline
  • Fresh Boarder
  • Fresh Boarder
  • Beiträge: 4
  • Dank erhalten: 0
Hallo,
danke für die schnelle Rückmeldung.
Habe die 3 Beispiele ausprobiert und leider hat keines davon funktioniert. Wenn ich den AVR auf 8Datenbits umstelle, sehe ich im Terminalprogramm (HTerm: 9600Baud, 8Datenbits, 1 Startbit, 2 Stopbits und ODD-Parity) jedenfalls die korrekten Daten. Stelle ich dann den AVR wieder auf 9Datenbits zurück, kommt nur noch Müll. Daher vermute ich mal das der AVR auch das 9te Datenbit sendet.

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Neues zum EX Protokoll 22 Feb 2015 22:47 #22

  • Henning
  • Hennings Avatar
  • Offline
  • Gold Boarder
  • Gold Boarder
  • Beiträge: 305
  • Dank erhalten: 142
Hallo,

beim ersten Drüberlesen sehe ich nicht, wie Du das 9.Bit behandelst.

Es steht recht genau in der Jeti-Dokumentation, und nur so tut es dann auch: Das 1.Byte eines Datenblocks ist ein spezielles Token-Byte und muss immer mit gelöschtem 9.Bit gesendet werden. Der Rest dann mit gesetztem 9.Bit.

Falls Du mit Arduino weitermachen möchtest, hier eine kleine Demo, die ich mal im OpenRC-Forum gepostet hatte:
JetiSensor Codebeispiel (Arduino)

Viel Spaß beim Ausprobieren!

Gruß
Henning
Folgende Benutzer bedankten sich: Sepp62, Höllenhund

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Re:Neues zum EX Protokoll 22 Feb 2015 22:48 #23

  • 0n3 70uch
  • 0n3 70uchs Avatar
  • Offline
  • Expert Boarder
  • Expert Boarder
  • Beiträge: 133
  • Karma: 1
  • Dank erhalten: 32
Hallo,

vielleicht hilft dir mein alter Code weiter:
#include <avr/io.h>		//Headerdatei für Ports
#define F_CPU 16000000UL	//CPU läuft mit 16MHz
#define BAUD 9600L		//Baudrate 9600
#include <util/delay.h>		//Headerdatei für Pausen
#include <avr/interrupt.h>	//Headerdatei für Interrupts
#include <stdlib.h>		//Headerdatei für Standardroutinen
 
//Definitionen für die Messung der Drehzahlimpulse
#define ANFANG 0
#define ENDE 1
#define PAUSE 2
 
//Definition für die Pfeilrichtung im Menü
#define LINKS 0
#define RECHTS 1
 
//Definitionen für Jetibox Menüs
#define STARTSEITE 0
#define ACTUAL 10
	#define ACTUAL_REVOLUTION 11
	#define ACTUAL_POWER 12
#define MINMAX 20
	#define MINMAX_REVOLUTION 21
	#define MINMAX_POWER 22
#define SETTING 30
	#define SETTING_ERASE 31
	#define SETTING_BEEPHIGH 32
	#define SETTING_BEEPLOW 33
	#define SETTING_POWER 34
	#define SETTING_TRIGGER 35
	#define SETTING_DELAY 36
	#define SETTING_FREQUENZY 37
#define ALARMS 40
	#define ALARMS_HIGH 41
	#define ALARMS_LOW 42
#define SERVICE 50
	#define SERVICE_PRESET 51
	#define SERVICE_ID 52
 
 
 
 
//Globale Variablen definieren
volatile uint8_t jb_tasten = 0;
volatile uint8_t jetimenu = STARTSEITE;
volatile uint8_t flanke = ANFANG;
volatile uint16_t drehzahl_takt = 0;
 
 
 
//UART Baudrate berrechnen
#define UBRR_VAL ((F_CPU+BAUD * 8)/(BAUD*16)-1)		//clever runde
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))		//reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD-1000)		//Fehler in Promille
 
//UART Fehlertoleranz überprüfen
#if ((BAUD_ERROR>10)||(BAUD_ERROR<-10))
	#error Systematischer Fehler in der Baudrate größer 1% und damit zu hoch!
#endif
 
 
 
//Übertragung der Zeichenkette auf die JetiBox mittels UART
int uart_putc (unsigned char c)
{
	while (!(UCSRA & (1<<UDRE)))	//warten bis Senden moeglich ist
	{
	}                        
	UCSRB |= (1<<TXB8);
	UDR = c;			//sende Zeichen
	return 0;
}
 
void uart_puts (char *s)
{
	while (*s)			//so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)"
	{
		uart_putc(*s);
		s++;
	}
}
 
//Frameanfang und Frameende
void frameanfang (void)
{
	while (!(UCSRA & (1<<UDRE)))	//warten bis senden möglich ist
	{
	}
	UCSRB &= ~(1<<TXB8);
	UDR = 0xFE;	//Frameanfang
}
 
void frameende (void)
{
	while (!(UCSRA & (1<<UDRE)))	//warten bis senden möglich ist
	{
	}
	UCSRB &= ~(1<<TXB8);
	UDR = 0xFF;	//Frameende
}
 
//Auffüllen der fehlenden Ziffern bei der Drehzahl mit einem Leerzeichen
void leerzeichen_drehzahl (uint16_t drehzahl)
{
	if (drehzahl < 10000)
	{
		uart_puts (" \0");
	}
	if (drehzahl < 1000)
	{
		uart_puts (" \0");
	}
	if (drehzahl < 100)
	{
		uart_puts (" \0");
	}
	if (drehzahl < 10)
	{
		uart_puts (" \0");
	}
}
 
//Menüpfeil nach links oder rechts
void pfeil (uint8_t richtung)
{
	if (richtung == LINKS)
	{
		uart_putc (0x7F);
		return;
	}
	if (richtung == RECHTS)
	{
		uart_putc (0x7E);
		return;
	}
}
 
//Tastendruck der Jetibox zur Menünavigation auswerten
void navigation (uint8_t jb_tasten, uint8_t jb_tasten_alt)
{
	//keine Taste gedrückt
	if (jb_tasten == 0xF0)
	{
		return;
	}
 
	//Taste "rechts" einmal gedrückt
	if ((jb_tasten == 0xE0) && (jb_tasten != jb_tasten_alt))
	{
		if ((jetimenu == ACTUAL) || (jetimenu == MINMAX) || (jetimenu == SETTING) || (jetimenu == ALARMS))
		{
			jetimenu = jetimenu + 10;
			return;	
		}
	}
 
	//Taste "hoch" einmal gedrückt
	if ((jb_tasten == 0xD0) && (jb_tasten != jb_tasten_alt))
	{
		if (jetimenu == STARTSEITE)
		{
			return;
		}
		if ((jetimenu == ACTUAL) || (jetimenu == MINMAX) || (jetimenu == SETTING) || (jetimenu == ALARMS) || (jetimenu == SERVICE))
		{
			jetimenu = 0;
			return;
		}
		else
		{
			jetimenu--;
			return;
		}
	}
 
	//Taste "runter" einmal gedrückt
	if ((jb_tasten == 0xB0) && (jb_tasten != jb_tasten_alt))
	{
		if (jetimenu == STARTSEITE)
		{
			jetimenu = ACTUAL;
			return;
		}
		if ((jetimenu == ACTUAL_POWER) || (jetimenu == MINMAX_POWER) || (jetimenu == SETTING_FREQUENZY) || (jetimenu == ALARMS_LOW) || (jetimenu == SERVICE_ID))
		{
			return;
		}
		if (ACTUAL <= jetimenu <= SERVICE)
		{
			jetimenu++;
			return;
		}
	}
 
	//Taste "links" einmal gedrückt
	if ((jb_tasten == 0x70) && (jb_tasten != jb_tasten_alt))
	{
		if (jetimenu == STARTSEITE)
		{
			//Expander Escape Sequenze 0x07E 0x191 0x131
			while (!(UCSRA & (1<<UDRE)))	//warten bis Senden moeglich ist
			{
			}                        
			UCSRB &= ~(1<<TXB8);
			UDR = 0x7E;
			uart_putc (0x91);
			uart_putc (0x31);
			return;
		}
		if ((jetimenu == MINMAX) || (jetimenu == SETTING) || (jetimenu == ALARMS) || (jetimenu == SERVICE))
		{
			jetimenu = jetimenu - 10;
			return;	
		}
	}
}
 
 
 
//Interrupt bei steigender Flanke an PD2
ISR (INT0_vect)
{
	if (flanke == ENDE)
	{
		drehzahl_takt = TCNT1;
		TCNT1 = 0;
		flanke = PAUSE;
	}
	if (flanke == ANFANG)
	{
		TCNT1 = 0;
		flanke = ENDE;
	}
}
 
 
//Interrupt beim überlaufen von Timer1
ISR (TIMER1_OVF_vect)
{
	if ((flanke == ANFANG) || (flanke == ENDE))
	{
		drehzahl_takt = 0;
		flanke = ANFANG;
	}
}
 
//Interrupt beim erreichen des Vergleichswerts (halbe Sekunde) von Timer1
ISR (TIMER1_COMPA_vect)
{
	if (flanke == PAUSE)
	{
		flanke = ANFANG;
	}
}
 
//Interrupt beim empfangen eines Zeichens über den UART
ISR (USART_RXC_vect)
{
	jb_tasten = UDR;		//neuer Tastenzustand einlesen
}
 
 
 
int main(void)
{
	char drehzahl_ziffern[5];
	uint16_t drehzahl = 0;
	uint8_t jb_tasten_alt = 0;
 
	//PD4, PD3 und PD2 als Eingang und Pullups aktivieren
	DDRD &= ~((1<<PD4)|(1<<PD3)|(1<<PD2));
	PORTD |= (1<<PD4)|(1<<PD3)|(1<<PD2);
 
	//Baudrate einstellen
	UBRRH = UBRR_VAL >> 8;
	UBRRL = UBRR_VAL & 0xFF;
 
	//UART Asynchron 9O1
	UCSRC |= (1<<URSEL)|(1<<UPM1)|(1<<UPM0)|(1<<UCSZ1)|(1<<UCSZ0);
	UCSRB |= (1<<TXEN)|(1<<UCSZ2);
 
	//16Bit Timer1 Teiler auf clk/256
	TCCR1B |= (1<<CS12);
 
	//Timer1 Overflow Interrupt
	TIMSK |= (1<<TOIE1);
 
	//Timer1 Compare Match Interrupt auf 31250-1 (halbe Sekunde)
	OCR1A = 31249;
	TIMSK |= (1<<OCIE1A);
 
 
	//Interrupt INT0 an PD2 auf steigende Flanke stellen und Interrupt global aktivieren
	GIMSK |= (1<<INT0);
	MCUCR |= (1<<ISC01)|(1<<ISC00);
	sei ();
 
 
	while (1)
	{
		//Drehzahl berechnen
		if (drehzahl_takt == 0)
		{
			drehzahl = 0;
		}
		else
		{
			drehzahl = 3750000 / drehzahl_takt;
		}
 
 
 
		//Boxframe ausgeben
		frameanfang ();
 
		if (jetimenu == STARTSEITE)
		{
			uart_puts (" SENSOR MRPM CSK\0");	//Erste Zeile im Display
			uart_puts ("  \0");			//Anfang der zweite Zeile im Display
 
			leerzeichen_drehzahl (drehzahl);	//Leere Zeichen mit einem Leerzeichen auffüllen
			uart_puts (itoa (drehzahl, drehzahl_ziffern, 10));	//Ausgabe der Drehzahl in eine Dezimalzahl
 
			//Zustand der Zündung
			if (PIND & (1<<PIND3))
			{
				uart_puts ("RPM   OFF\0");		//Zündung aus
			}
			else
			{
				uart_puts ("RPM    ON\0");		//Zündung an
			}
		}
 
		if (jetimenu == ACTUAL)
		{
			uart_puts ("   *MRPM MENU*  \0");	//Erste Zeile im Display			
			uart_puts ("    ACTUAL VAL \0");	//Zweite Zeile im Display
			pfeil (RECHTS);
		}
			if (jetimenu == ACTUAL_REVOLUTION)
			{
				uart_puts ("   Revolution   \0");	//Erste Zeile im Display
				uart_puts ("        0 RPM   \0");	//Zweite Zeile im Display
			}
			if (jetimenu == ACTUAL_POWER)
			{
				uart_puts (" Power propeller\0");	//Erste Zeile im Display
				uart_puts ("        0 W     \0");	//Zweite Zeile im Display
			}
 
		if (jetimenu == MINMAX)
		{
			uart_puts ("   *MRPM MENU*  \0");	//Erste Zeile im Display
			uart_puts ("  \0");			//Zweite Zeile im Display
			pfeil (LINKS);
			uart_puts ("  MIN/MAX   \0");
			pfeil (RECHTS);
		}
			if (jetimenu == MINMAX_REVOLUTION)
			{
				uart_puts ("  MIN/MAX  RPM  \0");	//Erste Zeile im Display
				uart_puts ("  _____ / _____ \0");	//Zweite Zeile im Display
			}
			if (jetimenu == MINMAX_POWER)
			{
				uart_puts ("  MIN/MAX Power \0");	//Erste Zeile im Display
				uart_puts ("  _____ / _____ \0");	//Zweite Zeile im Display
			}
 
		if (jetimenu == SETTING)
		{
			uart_puts ("   *MRPM MENU*  \0");	//Erste Zeile im Display
			uart_puts ("  \0");			//Zweite Zeile im Display
			pfeil (LINKS);
			uart_puts ("  SETTING   \0");
			pfeil (RECHTS);
		}
			if (jetimenu == SETTING_ERASE)
			{
				uart_puts ("   Erase data   \0");	//Erste Zeile im Display
				uart_puts ("   Press <- ->  \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_BEEPHIGH)
			{
				uart_puts (" Beep High Alarm\0");	//Erste Zeile im Display
				uart_puts ("  <     X     > \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_BEEPLOW)
			{
				uart_puts (" Beep Low Alarm \0");	//Erste Zeile im Display
				uart_puts ("  <     X     > \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_POWER)
			{
				uart_puts ("      n100W     \0");	//Erste Zeile im Display
				uart_puts ("  <    XXXX   > \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_TRIGGER)
			{
				uart_puts ("  Trigger Level \0");	//Erste Zeile im Display
				uart_puts ("  <  XXXX RPM > \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_DELAY)
			{
				uart_puts ("   Time delay   \0");	//Erste Zeile im Display
				uart_puts ("  <     Xs    > \0");	//Zweite Zeile im Display
			}
			if (jetimenu == SETTING_FREQUENZY)
			{
				uart_puts ("  RPM frequency \0");	//Erste Zeile im Display
				uart_puts ("  <     Xs    > \0");	//Zweite Zeile im Display
			}
 
		if (jetimenu == ALARMS)
		{
			uart_puts ("   *MRPM MENU*  \0");	//Erste Zeile im Display
			uart_puts ("  \0");			//Zweite Zeile im Display
			pfeil (LINKS);
			uart_puts ("  ALARMS    \0");
			pfeil (RECHTS);
		}
			if (jetimenu == ALARMS_HIGH)
			{
				uart_puts ("Rev. High Alarm \0");	//Erste Zeile im Display
				uart_puts ("  <     OFF     \0");	//Zweite Zeile im Display
			}
			if (jetimenu == ALARMS_LOW)
			{
				uart_puts ("Rev. Low Alarm  \0");	//Erste Zeile im Display
				uart_puts ("        OFF    >\0");	//Zweite Zeile im Display
			}
 
		if (jetimenu == SERVICE)
		{
			uart_puts ("   *MRPM MENU*  \0");	//Erste Zeile im Display
			uart_puts ("  \0");			//Zweite Zeile im Display
			pfeil (LINKS);
			uart_puts ("  SERVICE    \0");
		}
			if (jetimenu == SERVICE_PRESET)
			{
				uart_puts ("PresetToSetup <>\0");	//Erste Zeile im Display
				uart_puts ("Factory Defaults\0");	//Zweite Zeile im Display
			}
			if (jetimenu == SERVICE_ID)
			{
				uart_puts ("MRPM1   v.  2.00\0");	//Erste Zeile im Display
				uart_puts ("ID _____:_____  \0");	//Zweite Zeile im Display
			}
 
		frameende ();
 
		jb_tasten_alt = jb_tasten;	//alter Tastenzustand sichern
 
		//Von senden auf empfangen schalten und Tastendruck der Jetibox einlesen
		while (!(UCSRA & (1<<TXC)))
		{
		}
		//UCSRA |= (1<<TXC);
		UCSRB = (1<<RXEN)|(1<<RXCIE)|(1<<UCSZ2);	//auf empfangen schalten und Interrupt aktivieren
 
		_delay_ms (15);
 
		UCSRB = (1<<TXEN)|(1<<UCSZ2);		//auf senden schalten
		navigation (jb_tasten, jb_tasten_alt);	//Funktion zur Menünavigation aufrufen	
	}
 
	return 0;							
}

Gruß
Fabi
JETI4ever
Folgende Benutzer bedankten sich: Höllenhund

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Re:Neues zum EX Protokoll 22 Feb 2015 23:47 #24

  • Höllenhund
  • Höllenhunds Avatar
  • Offline
  • Fresh Boarder
  • Fresh Boarder
  • Beiträge: 4
  • Dank erhalten: 0
@Henning: Du hast recht, ich behandel das 9te Bit nicht. ......tilt....... Hatte das so interpretiert, das über das 9te Bit Werte von 256-512 dargestellt werden und nicht eine Unterscheidung von Separatoren und Daten. Da habe ich es mir zu leicht gemacht. Mit dem Arduino kenne ich mich allerdings überhaupt nicht aus.

@0n3 70uch: Danke für das Codebespiel, werde mir das mal genauer ansehen.

Habe mal schnell meinen Code mit dem Register TXB80 ergänzt, aber keinen Erfolgt gehabt. Werden mich morgen mal intensiv damit auseinandersetzen, denn zu dieser fortgeschrittenen Stunde schleichen sich nur noch mehr Fehler ein.

Großes Dankeschön an Euch beide.

Bitte Anmelden oder Registrieren um der Konversation beizutreten.

Ladezeit der Seite: 0.207 Sekunden
Powered by Kunena Forum