Graupner HoTT Telemetrie-Sensoren Eigenbau DIY | Telemetrie-Protokoll entschlüsselt

Hi,
I finally got it work.
To summerize, DO NOT USE AN ARDUINO BOARD WITH USB INTEGRATE ON IT (like Arduino Uno, Arduino Nano, ....) , IT WILL DISRUPT SIGNAL

Configuration is:
Lipomètre v0.43 can be found here: http://www.thyzoon.fr/Aeromod/LipoHott/LipoHott3.php (Thanks to Thyzoon ;) )
Upload with Arduino IDE 0.22
On board Arduino Mini v4
Receiver GR12 with Firmware rx6_2a80_e9
Remote control is MX-12 Hott


http://img580.imageshack.us/img580/4470/imgp7859j.jpg
http://img189.imageshack.us/img189/5853/imgp7860j.jpg
http://img593.imageshack.us/img593/3580/imgp7861.jpg
http://img210.imageshack.us/img210/9570/imgp7862u.jpg
http://img19.imageshack.us/img19/4292/imgp7863z.jpg

Thanks to Mulder (Jochen) also for his help on this forum ;)

New version 1.1:
Adding a text protocol version with parameters stored in the memory of the Arduino:
http://johnlenfr.1s.fr/PHOTOS/Realisations/Electronique/arduino/2012-03-25Lipometre/Lipometre-screen.jpg
The module is capable of other things like use of leds.

Demo of the leds here:
http://www.youtube.com/watch?v=rK5NlR1kAQA
http://www.youtube.com/watch?v=uSyz2yqyp3c

More infos for the module here:
http://johnlenfr.1s.fr/index.php?option=com_content&view=article&id=470&Itemid=110

The code is here:
http://johnlenfr.1s.fr/index.php?option=com_rokdownloads&view=folder&Itemid=122&id=988:lipometre
This code is ready for GPS if needed decomment the code you want.

Tested on MX16 and MX20 Hott with GR12 GR16 and GR24 receivers.



GPS Structure:
/*
// GPS MODULE #33600
struct HOTT_GPS_MSG{
uint8_t startByte; //#1 Starting byte data == 0x7C
uint8_t sensorID; //#2 Sensor ID GPS Sensor == 0x8A
uint8_t warning_beeps; //#3 Byte 3: 0…= warning beeps
VOICE OR BIP WARNINGS
0x00 00 No alarm
0x01 01 A Min Speed ​​A
0x02 02 B Descent / B 3s -1 m / s
0x03 03 C Descent / s C -10 m / s
0x04 04 D Max Distance D
0x05 05 E
0x06 06 F
0x07 07 G
0x08 08 H
0x09 09 I
0xA 10 J
0xB 11 K
0xC 12 L Max Speed ​​L
0xD 13 M Rate of Climb / 3s M 1 m / s
0xE 14 N Rate of Climb / s N 10 m / s
0xF 15 O Min Old O
0x10 16 P
0x11 17 Q
0x12 18 R
0x13 19 S
0x14 20 T
0x15 21 U
0x16 22 V
0x17 23 W
0x18 24 X
0x19 25 Y
0x1A 26 Z Max Old Z

uint8_t sensorTextID; //#4 160 0xA0 Sensor ID Neu!
uint8_t alarmInverse1; //#5 01 inverse status
uint8_t alarmInverse2; //#6 00 inverse status status 1 = no GPS Signal
uint8_t flightDirection; //#7 119 = Flightdir./dir. 1 = 2°; 0° (North), 9 0° (East), 180° (South), 270° (West)
uint16_t GPSSpeed; //#8 LSB 196 8 = speed / low byte GPS speed 8km / h
//#9 MSB 002 0 = speed / GPS speed high byte
uint8_t LatitudeNS; //#10 000 = N = 48°39’988 / north=0, south=1
uint16_t LatitudeMin; //#11 231 0xE7 = 0x12E7 = 4839
//#12 018 18=0x12
uint16_t LatitudeSec; //#13 171 220 = 0xDC = 0x03DC =0988
//#14 016 3 = 0x03
uint8_t longitudeEW; //#15 000 = E= 9° 25’9360 / east=0, west=1
uint16_t longitudeMin; //#16 150 157 = 0x9D = 0x039D = 0925
//#17 003 3 = 0x03
uint16_t longitudeSec; //#18: 056 144 = 0x90 0x2490 = 9360
//#19 004 36 = 0x24
uint16_t distance; //#20 LSB 027 123 = Distance low byte 6 = 6 m
//#21 MSB 036 35 = Distance high byte
uint16_t altitude; //#22 LSB 243 244 = Altitude low byte 500 = 0m
//#23 MSB 001 1 = Altitude high byte
//#24 LSB 48 = m/s (resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/s))
//#25 MSB 117 = High Byte m/s resolution 0.01m
uint16_t climbrate1s; //#26 climb rate in 0.01m/s. Value of 30000 = 0.00 m/s 120 = 0m/3s
uint8_t GPSNumSat; //#27 GPS.Satelites (number of satelites) (1 byte)
uint8_t GPSFixChar; //#28 GPS.FixChar. (GPS fix character. display, if DGPS, 2D oder 3D) (1 byte)
uint8_t HomeDirection; //#29 HomeDirection (direction from starting point to Model position) (1 byte)
uint8_t angleXdirection; //#30 angle x-direction (1 byte)
uint8_t angleYdirection; //#31 angle y-direction (1 byte)
uint8_t angleZdirection; //#32 angle z-direction (1 byte)
int8_t gps_time_h; //#33 UTC time hours / gyro x low byte (2 bytes)
int8_t gps_time_m; //#34 UTC time minutes / gyro x high byte
int8_t gps_time_s; //#35 UTC time seconds / gyro y low byte (2 bytes)
int8_t gps_time_sss; //#36 UTC time milliseconds / gyro y high byte
int16_t msl_altitude; //#37 mean sea level altitude / gyro z low byte (2 bytes)
//#38 gyro z high byte
uint8_t vibration; //#39: vibration (1 bytes)
uint8_t Ascii4; //#40: 00 ASCII Free Character [4]
uint8_t Ascii5; //#41: 00 ASCII Free Character [5]
uint8_t GPS_fix; //#42: 00 ASCII Free Character [6], we use it for GPS FIX
uint8_t version; //#43: 00 version number
uint8_t endByte; //#44: 0x7D End byte
uint8_t parity; //#45: CHECKSUM Parity Byte
} ;

VARIO STRUCTURE:
// VARIO MODULE #33601
// Hott v4
struct HOT_VM_MSG{
uint8_t startByte; //#1 0x7C = Start byte data
uint8_t sensorID; //#2 0x89 = Vario Sensor
uint8_t warning_beeps; //#3 0…= warning beeps
VOICE OR BIP WARNINGS
0x00 00 No alarm
0x01 01 A
0x02 02 B Descent / B 3s -1 m / s
0x03 03 C Descent / s C -10 m / s
0x04 04 D
0x05 05 E
0x06 06 F
0x07 07 G
0x08 08 H
0x09 09 I
0xA 10 J
0xB 11 K
0xC 12 L
0xD 13 M Rate of Climb / 3s M 1 m / s
0xE 14 N Rate of Climb / s N 10 m / s
0xF 15 O Min Alt O
0x10 16 P
0x11 17 Q
0x12 18 R
0x13 19 S
0x14 20 T
0x15 21 U
0x16 22 V
0x17 23 W
0x18 24 X
0x19 25 Y
0x1A 26 Z Max Alt Z

uint8_t sensorTextID; //#4 144 0x90 Sensor ID Neu!
uint8_t alarmInverse; //#5 0 Inverse status
uint16_t altitude; //#6 LSB 244 244 = Low Byte Actual Altitude -2m (244+256=0m)
//#7 MSB 1 1 = actual altitude (500 = 0m)
uint16_t maxAltitude; //#8 LSB 244 244 = Low Byte Maximum Altitude. -2m (244+256=0m)
//#9 MSB 1 = max. altitude (500 = 0m)
uint16_t minAltitude; //#10 LSB 244 244 = Low Byte min. altitude -2m (244+256=0m)
//#11 MSB 1 = High Byte min. altitude (500 = 0m)
uint16_t m1s; //#12 LSB 48 Low Byte m/s resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/s)
//#13 MSB 117 117 = High Byte m/s resolution 0.01m 117
uint16_t m3s; //#14 LSB 48 Low Byte m/3s resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/3s)
//#15 MSB 117 117 = High Byte m/3s resolution 0.01m 117
uint16_t m10s; //#16 LSB 48 Low Byte m/10s resolution 0.01m 48 = 30000 = 0.00m/s (1=0.01m/10s)
//#17 MSB 117 117 = High Byte m/10s resolution 0.01m 117
uint8_t text[24]; //#18: 0 ASCII [1]
//#19: 0 ASCII [2]
//#20: 0 ASCII [3]
//#21: 0 ASCII [4]
//#22: 0 ASCII [5]
//#23: 0 ASCII [6]
//#24: 0 ASCII [7]
//#25: 0 ASCII [8]
//#26: 0 ASCII [9]
//#27: 0 ASCII [10]
//#28: 0 ASCII [11]
//#29: 0 ASCII [12]
//#30: 0 ASCII [13]
//#31: 0 ASCII [14]
//#32: 0 ASCII [15]
//#33: 0 ASCII [16]
//#34: 0 ASCII [17]
//#35: 0 ASCII [18]
//#36: 0 ASCII [19]
//#37: 0 ASCII [20]
//#38: 0 ASCII [21]
//#39: 0 ASCII Free Character [1]
//#40: 0 ASCII Free Character [2]
//#41: 0 ASCII Free Character [3]
uint8_t empty; //#42 0 free
uint8_t version; //#43 0 version number
uint8_t endByte; //#44 0x7D End byte
uint8_t parity; //#45 CHECKSUM Parity Byte
} ;
*/

GENERAL MODULE STRUCTURE:
// GENERAL AIR MODULE (LIPOMETER)
struct HOTT_GAM_MSG {
byte start_byte; //#01 start byte constant value 0x7c
byte gam_sensor_id; //#02 EAM sensort id. constat value 0x8d=GENRAL AIR MODULE
byte warning_beeps; //#03 1=A 2=B ... 0x1a=Z 0 = no alarm
/* VOICE OR BIP WARNINGS
Alarme sonore A.. Z, octet correspondant 1 à 26
0x00 00 0 No alarm
0x01 01 A
0x02 02 B Negative Difference 2 B
0x03 03 C Negative Difference 1 C
0x04 04 D
0x05 05 E
0x06 06 F Min. Sensor 1 temp. F
0x07 07 G Min. Sensor 2 temp. G
0x08 08 H Max. Sensor 1 temp. H
0x09 09 I Max. Sensor 2 temp. I
0xA 10 J Max. Sens. 1 voltage J
0xB 11 K Max. Sens. 2 voltage K
0xC 12 L
0xD 13 M Positive Difference 2 M
0xE 14 N Positive Difference 1 N
0xF 15 O Min. Altitude O
0x10 16 P Min. Power Voltage P // We use this one for Battery Warning
0x11 17 Q Min. Cell voltage Q
0x12 18 R Min. Sens. 1 voltage R
0x13 19 S Min. Sens. 2 voltage S
0x14 20 T Minimum RPM T
0x15 21 U
0x16 22 V Max. used capacity V
0x17 23 W Max. Current W
0x18 24 X Max. Power Voltage X
0x19 25 Y Maximum RPM Y
0x1A 26 Z Max. Altitude Z
*/
byte sensor_id; //#04 constant value 0xd0
byte alarm_invers1; //#05 alarm bitmask. Value is displayed inverted
//Bit# Alarm field
// 0 all cell voltage
// 1 Battery 1
// 2 Battery 2
// 3 Temperature 1
// 4 Temperature 2
// 5 Fuel
// 6 mAh
// 7 Altitude
byte alarm_invers2; //#06 alarm bitmask. Value is displayed inverted
//Bit# Alarm Field
// 0 main power current
// 1 main power voltage
// 2 Altitude
// 3 m/s
// 4 m/3s
// 5 unknown
// 6 unknown
// 7 "ON" sign/text msg active
byte cell[6]; //#7 Volt Cell 1 (in 2 mV increments, 210 == 4.20 V)
//#8 Volt Cell 2 (in 2 mV increments, 210 == 4.20 V)
//#9 Volt Cell 3 (in 2 mV increments, 210 == 4.20 V)
//#10 Volt Cell 4 (in 2 mV increments, 210 == 4.20 V)
//#11 Volt Cell 5 (in 2 mV increments, 210 == 4.20 V)
//#12 Volt Cell 6 (in 2 mV increments, 210 == 4.20 V)
uint16_t Battery1; //#13 LSB battery 1 voltage LSB value. 0.1V steps. 50 = 5.5V only pos. voltages
//#14 MSB
uint16_t Battery2; //#15 LSB battery 2 voltage LSB value. 0.1V steps. 50 = 5.5V only pos. voltages
//#16 MSB
byte temperature1; //#17 Temperature 1. Offset of 20. a value of 20 = 0°C
byte temperature2; //#18 Temperature 2. Offset of 20. a value of 20 = 0°C
byte fuel_procent; //#19 Fuel capacity in %. Values 0--100
//graphical display ranges: 0-100% with new firmwares of the radios MX12/MX20/...
uint16_t fuel_ml; //#20 LSB Fuel in ml scale. Full = 65535!
//#21 MSB
uint16_t rpm; //#22 RPM in 10 RPM steps. 300 = 3000rpm
//#23 MSB
uint16_t altitude; //#24 altitude in meters. offset of 500, 500 = 0m
//#25 MSB
uint16_t climbrate_L; //#26 climb rate in 0.01m/s. Value of 30000 = 0.00 m/s
//#27 MSB
byte climbrate3s; //#28 climb rate in m/3sec. Value of 120 = 0m/3sec
uint16_t current; //#29 current in 0.1A steps 100 == 10,0A
//#30 MSB current display only goes up to 99.9 A (continuous)
uint16_t main_voltage; //#31 LSB Main power voltage using 0.1V steps 100 == 10,0V
//#32 MSB (Appears in GAM display right as alternate display.)
uint16_t batt_cap; //#33 LSB used battery capacity in 10mAh steps
//#34 MSB
uint16_t speed; //#35 LSB (air?) speed in km/h(?) we are using ground speed here per default
//#36 MSB speed
byte min_cell_volt; //#37 minimum cell voltage in 2mV steps. 124 = 2,48V
byte min_cell_volt_num; //#38 number of the cell with the lowest voltage
uint16_t rpm2; //#39 LSB 2nd RPM in 10 RPM steps. 100 == 1000rpm
//#40 MSB
byte general_error_number; //#41 General Error Number (Voice Error == 12) TODO: more documentation
byte pressure; //#42 High pressure up to 16bar. 0,1bar scale. 20 == 2.0bar
byte version; //#43 version number (Bytes 35 .43 new but not yet in the record in the display!)
byte stop_byte; //#44 stop byte 0x7D
byte parity; //#45 CHECKSUM CRC/Parity (calculated dynamicaly)
};
 

MeiT

User
Hi,
wer nen 10S Balancersensor bauen möchte, der kann sich mal den BQ77PL900 von TI anschauen.
Damit hat man mit wenigen Bauteilen einen 10S Sensor.
Grüße
 
Hi!

Ich würde mein Microcontrollerprojekt auf Basis eines Arduino Pro Mini gerne um eine Telemetrie mit meinem HoTT Sender erweitern. Bevor ich "das Rad nochmal erfinde", meine Frage/Bitte:
Hat jemand die Kommunikation zwischen Arduino und HoTT-Empfängern in Bascom bereits implementiert und würde mir seinen Code zur Verfügung stellen?
Oder kann mir jemand einen Link nennen, unter dem ein entsprechender Code veröffentlich ist?
Herzlichen Dank für eure Hinweise.

Viele Grüße

Philipp
 
Hi!

Ich würde mein Microcontrollerprojekt auf Basis eines Arduino Pro Mini gerne um eine Telemetrie mit meinem HoTT Sender erweitern. Bevor ich "das Rad nochmal erfinde", meine Frage/Bitte:
Hat jemand die Kommunikation zwischen Arduino und HoTT-Empfängern in Bascom bereits implementiert und würde mir seinen Code zur Verfügung stellen?
Oder kann mir jemand einen Link nennen, unter dem ein entsprechender Code veröffentlich ist?
Herzlichen Dank für eure Hinweise.

Viele Grüße

Philipp

http://johnlenfr.1s.fr/index.php?option=com_content&view=category&layout=blog&id=59&Itemid=110

;)
 
Danke! :-)
Kennt sonst noch jemand eine Quelle, bei der in BASCOM programmiert wurde?
Ansonsten werde ich mich ans Übersetzen machen...

Hallo Philipp,
ich habe auf Basis des Protokolls V4 einen AVR in Bascom programmiert. Dieser Meldet sich als General-Air-Modul (hex 80) und ist ziemlich Allround. Ich nutze zur Zeit nur Spannungsanzeige und die Temperatur ist in Arbeit. Ich muss dazu schreiben das ich Benzin Modelle fliege die mit elektronischer Zündung ausgerüstet sind und ich um den Zündakku zu messen einen erheblichen Aufwand (schaltungstechnisch im Vergleich mit der restlichen Schaltung) treibe um eine galvanische Trennung zwischen Zündakku und Empfängerstromversorgung zu erreichen. Manche halten das für übertrieben, ich bin da vorsichtig. Diese Galvanische Trennung (über Optokoppler) findet man auch im Programmcode, allerdings nur ein paar kleine Zeilen die man leicht entfernen kann. So wie die Software zur Zeit gestaltet ist, ist auf meiner Hardware zugeschnitten. Falls du Interesse hast kurze PN oder Nachricht hier, ich würde dann alles posten.

Gruß
Andreas
 
Bascom Code

Bascom Code

Hallo Philipp,
hier der Bascom Code. Ich habe bewusst viel in kleinen Schritten geschrieben, z.b. die Berechnung des CRC Bytes. Man wird einiges Abkürzen können. Die Schaltung kommt noch. Ich bin allerdings noch nicht mit allen fertig, es lüft aber recht zuverlässig (in Verbindung mit meiner Hardware). Als Temperatur Sensoren werde ich wohl AD590 nehmen, nicht ganz billig, aber mit denen habe ich beruflich gute Erfahrungen gamacht. Die kann ich in alte AC188K Kühlkörper (Alu Block, mit 3 mm Loch) einkleben und anschließen mit den Kühlrippen verschrauben. Für Temp. im Rumpf könnte man auf Digitale zurückgreifen, die gehen aber leider nur bis 125C. Falls jemand Digitale kennt die bis 200C arbeiten, bitte Info an mich.



Gruß
Andreas
Bearbeitet: Übersetzt mit Bascom Demo, Version 2.0.7.5

Code:
'0x80 Empfänger (Requestanfrage)
'0x8d General Air Modul
'0x8a GPS
'0x89 Vario
'Version unter Nutzung des Interruptes v0.3





$regfile = "m88adef.dat"
$crystal = 16000000
$hwstack = 40
$swstack = 16
$framesize = 32

Ddrb = &B00001010
Ddrd = &B11000000
Portd.6 = 1                                                 ' setze CD4093 auf Durchgang TXD_/OFF
Portd.7 = 1                                                 ' setze CD4093 auf Durchgang RXD_ON_OFF

$baud = 19200
Dim Byte_in(1) As Byte
Dim Startbyte As Byte
Dim Flag As Bit
Dim Anfragebyte As Byte

Config Adc = Single , Prescaler = Auto , Reference = Avcc
Dim W As Word
W = 0
Dim Wlow As Byte
Wlow = 0
Dim Channel As Byte
Channel = 1                                                 ' = ADC1 = PC1

On Urxc Onurxccomplete
Enable Urxc
Enable Interrupts

Dim A As Byte
A = 1

Dim B1 As Byte
Dim B2 As Byte
Dim B3 As Byte
Dim B4 As Byte
Dim B5 As Byte
Dim B6 As Byte
Dim B7 As Byte
Dim B8 As Byte
Dim B9 As Byte
Dim B10 As Byte
Dim B11 As Byte
Dim B12 As Byte
Dim B13 As Byte
Dim B14 As Byte
Dim B15 As Byte
Dim B16 As Byte
Dim B17 As Byte
Dim B18 As Byte
Dim B19 As Byte
Dim B20 As Byte
Dim B21 As Byte
Dim B22 As Byte
Dim B23 As Byte
Dim B24 As Byte
Dim B25 As Byte
Dim B26 As Byte
Dim B27 As Byte
Dim B28 As Byte
Dim B29 As Byte
Dim B30 As Byte
Dim B31 As Byte
Dim B32 As Byte
Dim B33 As Byte
Dim B34 As Byte
Dim B35 As Byte
Dim B36 As Byte
Dim B37 As Byte
Dim B38 As Byte
Dim B39 As Byte
Dim B40 As Byte
Dim B41 As Byte
Dim B42 As Byte
Dim B43 As Byte
Dim B44 As Byte
Dim B45 As Byte
Dim B46 As Byte
Dim B47 As Byte
Dim B49 As Byte
Dim B50 As Byte
Dim B51 As Byte
Dim B52 As Byte
Dim B53 As Byte
Dim B54 As Byte
Dim B55 As Byte
Dim B56 As Byte
Dim B57 As Byte
Dim B58 As Byte
Dim B59 As Byte
Dim B60 As Byte
Dim B61 As Byte
Dim B62 As Byte
Dim B63 As Byte
Dim B64 As Byte
Dim B65 As Byte
Dim B66 As Byte
Dim B67 As Byte
Dim B68 As Byte
Dim B69 As Byte
Dim B70 As Byte
Dim B71 As Byte
Dim B72 As Byte
Dim B73 As Byte
Dim B74 As Byte
Dim B75 As Byte
Dim B76 As Byte
Dim B77 As Byte
Dim B78 As Byte
Dim B79 As Byte
Dim B80 As Byte
Dim B81 As Byte
Dim B82 As Byte
Dim B83 As Byte
Dim B84 As Byte
Dim B85 As Byte
Dim B90 As Byte
Dim B91 As Byte
Dim B92 As Byte
Dim B93 As Byte
Dim B100 As Byte


B1 = &H7C
B2 = &H8D
B3 = 0
B4 = &HD0
B5 = &H00                                                   'invers
B6 = &H00                                                   'invers
B7 = &H00                                                   'Zelle 1 Byte Wert, Spannung in V = (Bitwert *2) / 100
B8 = &H00                                                   'Zelle 2 Byte Wert, Spannung in V = (Bitwert *2) / 100
B9 = &H00                                                   'Zelle 3 Byte Wert, Spannung in V = (Bitwert *2) / 100
B10 = &H00                                                  'Zelle 4 Byte Wert, Spannung in V = (Bitwert *2) / 100
B11 = &H00                                                  'Zelle 5 Byte Wert, Spannung in V = (Bitwert *2) / 100
B12 = &H00                                                  'Zelle 6 Byte Wert, Spannung in V = (Bitwert *2) / 100
B13 = &H00                                                  'AKK1, WORD Variable, Byte 13 LowByte, Byte 14 HighByte unsigned> sixteen-bit binary numbers ranging in value from 0 to 65535
B14 = &H00                                                  'Akk1, Spannung in mV = Bitwert x 100
B15 = &H00                                                  'AKK2, WORD Variable, Byte 15 LowByte, Byte 16 HighByte unsigned> sixteen-bit binary numbers ranging in value from 0 to 65535
B16 = &H00                                                  'AKK2, Spannung in mV = Bitwert x 100
B17 = &H29                                                  'T1
B18 = &H9E                                                  'T2
B19 = &H00                                                  'Tankanzeige Bitwert 64 = Dezimal 100 = 100% Balken
B20 = &H00                                                  'Tankfüllung FF = +255ml
B21 = &H00                                                  'Tankentlerrung FF = -255ml
B22 = &H00                                                  ' Drehzahl Low Byte   Anzeige = Bitwert * 10 Bsp. Bitwert 360 entspricht 3600U/min
B23 = &H00                                                  ' Drehzahl High Byte
B24 = &H8A                                                  'Höhe -500m = B24 = 00, B25 = 00.  B24 = F4 und B25 = 01 entspricht 0m, 01F4 = 0m  Beispiel +150 wäre 500+150=650 enstricht 028A
B25 = &H02                                                  'Höhe siehe B24
B26 = &H00                                                  'Steigen / Sinken m/Sek
B27 = &H00
B28 = &H00
B29 = 0
B30 = 0
B31 = 0
B32 = 0
B33 = 0
B34 = 0
B35 = 0
B36 = 0
B37 = 0
B38 = 0
B39 = 0
B40 = 0
B41 = 0
B42 = 0
B43 = 0
B44 = &H7D
B45 = 0

Do



If Flag = 1 Then
Portd.7 = 0

Anfragebyte = Byte_in(1) - Startbyte
If Anfragebyte = 13 Then

W = Getadc(channel)
Shift W , Right , 2                                         '10 Bit -> 8 Bit
W = W + 4                                                   '+ 4 zum kalibrieren
Wlow = W                                                    'word -> byte
B13 = Wlow                                                  'byte -> B13 = Hott Anzeige in akku 1
B14 = &H00


B46 = B1 + B2
B47 = B3 + B4
B70 = B46 + B47

B49 = B5 + B6
B50 = B7 + B8
B71 = B49 + B50

B80 = B70 + B71

B51 = B9 + B10
B52 = B11 + B12
B72 = B51 + B52


B53 = B13 + B14
B54 = B15 + B16
B73 = B53 + B54

B81 = B72 + B73

B55 = B17 + B18
B56 = B19 + B20
B74 = B55 + B56

B57 = B21 + B22
B58 = B23 + B24
B75 = B57 + B58

B82 = B74 + B75

B59 = B25 + B26
B60 = B27 + B28
B76 = B59 + B60

B61 = B29 + B30
B62 = B31 + B32
B77 = B61 + B62

B83 = B76 + B77

B63 = B33 + B34
B64 = B35 + B36
B78 = B63 + B64

B65 = B37 + B38
B66 = B39 + B40
B79 = B65 + B66

B84 = B78 + B79

B67 = B41 + B42
B68 = B43 + B44
B85 = B67 + B68



B90 = B80 + B81
B91 = B82 + B83
B93 = B84 + B85

B100 = B90 + B91
B45 = B100 + B93

Waitms 5
   Printbin B1
   Waitms A
   Printbin B2
   Waitms A
   Printbin B3
   Waitms A
   Printbin B4
   Waitms A
   Printbin B5
   Waitms A
   Printbin B6
   Waitms A
   Printbin B7
   Waitms A
   Printbin B8
   Waitms A
   Printbin B9
   Waitms A
   Printbin B10
   Waitms A
   Printbin B11
   Waitms A
   Printbin B12
   Waitms A
   Printbin B13
   Waitms A
   Printbin B14
   Waitms A
   Printbin B15
   Waitms A
   Printbin B16
   Waitms A
   Printbin B17
   Waitms A
   Printbin B18
   Waitms A
   Printbin B19
   Waitms A
   Printbin B20
   Waitms A
   Printbin B21
   Waitms A
   Printbin B22
   Waitms A
   Printbin B23
   Waitms A
   Printbin B24
   Waitms A
   Printbin B25
   Waitms A
   Printbin B26
   Waitms A
   Printbin B27
   Waitms A
   Printbin B28
   Waitms A
   Printbin B29
   Waitms A
   Printbin B30
   Waitms A
   Printbin B31
   Waitms A
   Printbin B32
   Waitms A
   Printbin B33
   Waitms A
   Printbin B34
   Waitms A
   Printbin B35
   Waitms A
   Printbin B36
   Waitms A
   Printbin B37
   Waitms A
   Printbin B38
   Waitms A
   Printbin B39
   Waitms A
   Printbin B40
   Waitms A
   Printbin B41
   Waitms A
   Printbin B42
   Waitms A
   Printbin B43
   Waitms A
   Printbin B44
   Waitms A
   Printbin B45
   Waitms A

End If
Flag = 0
Portd.7 = 1
End If


Loop



Onurxccomplete:
Startbyte = Udr
If Startbyte = 128 Then
Inputbin Byte_in(1) ; 1
Flag = 1
Else
Startbyte = 0
Flag = 0
End If



Return
 
Moin Philipp,

jetzt die Hardware. In der Schaltung ist nur eine Spannungsmessung eingebaut. Die Temperaturbeschaltung ist noch eine Versuchs Freiluft Verdrahtung;). Das IC3 und das Kleinzeug daran brauche ich nur für eine Zündung Abschaltung, weil ich Benziner betreibe (Für Not Aus vom Sender).

Gruß
Andreas

Schaltung Hot_Zuendungsschalter.jpg
 
Hi!

Danke nochmal, dass du deinen Code hier teilst.
Ich hab ihn in mein Programm integriert und er funktioniert super. Ich habe lediglich Header (anderer µC) und die Auswahl der gesendeten Daten ändern müssen.

Danke nochmal! Hat mich wieder eienn Schritt weiter gebracht.

VG Philipp
 
Hi,

ich mach ja auch so ein wenig mit Atmel-Chips rum, würde mir mit nem Attiny45 gerne was basteln, was einfach nur die Temperatur übertragen könnte. Also müsste ich über einen Port des Attiny das serielle Signal erzeugen, welches in den Empfänger eingespeist wird. Also Byte 0 7C, Byte 1 8D ... Byte 20 : Temperatur ...

Ich hab nur absolut keinen Plan, wie ich eine Eindraht-Seriellverbindung zu verstehen habe. Wie wird der Start eines Bytes ausgelöst? Werden die drei Drähte des Kabels als Zweidraht-Leitung verwendet?

Danke und Grüße

Hartmut
 
Hi,


Ich hab nur absolut keinen Plan, wie ich eine Eindraht-Seriellverbindung zu verstehen habe. Wie wird der Start eines Bytes ausgelöst? Werden die drei Drähte des Kabels als Zweidraht-Leitung verwendet?

Hallo,
eigentlich sagt der Name schon alles. RX / TX benutzen den gleichen "Draht". Genau genommen ist es eine Zweidraht Verbindung, aber die Masse wird vorausgesetzt und wird nicht mitgezählt. Einfacher ist es die Hardware UART zu verwenden, es gibt aber z.B. in der Programmier Sprache Basic /Bascom auch die Möglichkeit eine Software RX / TX zu programmieren die auch auf den kleinen Tinys verwendet werden kann.
Wie wird der Start eines Bytes ausgelöst? Der Sender gibt ein Signal raus, macht dann eine kleine Pause und lauscht während der Pause auf der Leitung. Der AVR bekommt also das Signal, seine Programmierung sieht es vor mit dem Daten zu Antworten. Eigentlich recht einfach. Der Thread Starter zeigt sehr schön wie er die Dekodierung angegangen ist. Lese einfach mal.

Welche Programmier Sprache benutzt du?

Gruß
Andreas
 
Ich nutze Assembler.

Noch einmal zum Verständnis:

Wenn ich mit dem Oskar das Signal vom Empfänger anschaue, so werdend a anscheinend ständig verschiedene Bytes gesendet. Das werden wohl die erwähnten Bytes sein, die der Empänger an die telemetrie-Hardware sendet, um sie dazu anzuregen, mit ihren Codes zu antworten.

Vor dem "Burst" der Daten ist lange Nullpegel, dann ein Eins-Pegel, da vermute ich, dass dieser Eins-Pegel das eine (oder zwei?) Startbit(s) ist.

Dann folgt ein "Rechteck", welches vorne "wabert", also werden da unterschiedliche Daten übertragen. Nach dem Rechteck-Inmpuls ist immer ne zeit lang ruhe (Null-Pegel).

Ich habe nun den Timer des Atmels so programmiert, dass er nach 1/19200stel Sekunde in die Interrupt-Routine springt, um dort den Eingang abzufragen.

Er sucht nach einem Stártbit und liest 8 Bit an Daten ein, das zwei mal, also 2 Byte.

Jetzt hat so ein Attiny13 nicht so gerade viele Ausgangs-Pins, so dass ich schwer nach Außen melden kann, ob Bytes empfangen werden und welchen Wert diese beiden Bytes haben. Ich müsste im prinzip einen größeren Chip nehmen, der zumindestens ein Byte parallel nach Außen melden kann. Oder halt auf Bytes vergleichen und Erfolgreiche Vergleiche über einen Port nach Außen melden.

Es ist also verflixt schwer, festzustellen, ob das Teil das macht, was es soll.
 
Hallo,

Assembler kenn ich nur die allerwenigsten grundsätzlichen Gegebenheiten. Willst du tatsächlich die Byte Werte parallel ausgeben :confused: ? Kannst du nicht auf einen Chip ausweichen der UART eingebaut hat, atmega8 oder so.

Schönen Sonntag noch.
Gruß
Andreas
 
Ich hab halt hier so ne Sammlung Tinys rumfliegen, Tiny13, um genau zu sein. Das wird schon klappen, so schätze ich.

Der Assembler-Code der Atmel-Chips ist sehr komfortabel und einfach, macht einfach Spaß.

Ich hab jetzt noch mal nachgeschaut, der Empfänger wirft kaut Posting in diesem Thread immer FF, 7F aus, das kommt mit den Messungen mit dem Oskar hin, das Wabern könnte das erste Bit direkt nach dem Startbit sein. Dann muss ich nur noch nach dem FF oder 7F dem Teil das Senden beibringen, dann sollte das funzen. Muss noch einen Speicherbereich für die zu sendende Bytefolge suchen.

Dann noch einen NTC suchen, den anschließen und eine Linearisierung programmieren, so dass ich die Temperaturen ermitteln kann. Dann wäre der Mini-Temperatursensor fertig.
 

ingo_s

User
Hi,

um auch ohne Hott Equipment arbeiten zu können, die Frage:

Gibt es eine PC-Simulations Software die die Sender Anzeige und und den RX als Sensor Master simuliert?

Wobei die Sender Binärmodus Anzeige bildlich nicht identisch sein muss.

Gruß Ingo
 
Ansicht hell / dunkel umschalten
Oben Unten