1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
import Stream._
import java.io.{ InputStream, EOFException }
import java.net.{ InetAddress, InetSocketAddress, Socket }
class EbusDefinition(val ebusXmlFile: String) {
import scala.xml.XML
import scala.xml.NodeSeq
val xml = XML.loadFile(ebusXmlFile)
def packetFromCommandId(primaryCommand: Char, secondaryCommand: Char): NodeSeq = {
val packet = (xml \ "packets" \ "packet").filter(n =>
n.attribute("primary").get.text.toInt == primaryCommand &&
n.attribute("secondary").get.text.toInt == secondaryCommand)
packet
}
}
object EbusPacket {
/**
* Wird von {@link EbusReader} mit einer Streamposition aufgerufen.
* Ausgehend von dieser Position wird versucht ein Paket aufzubauen,
* und anschliesend die Checksumme geprüft.
* Im Erfolgsfall wird eine EbusPacket-Instanz als Option zurückgegen,
* sonst None
*/
def apply(stream: Stream[Int]): Option[EbusPacket] = {
try {
var rawLength = 0
val source = stream.apply(0).toChar
val destination = stream.apply(1).toChar
val primaryCommand = stream.apply(2).toChar
val secondaryCommand = stream.apply(3).toChar
val payloadLength = stream.apply(4).toChar
rawLength = 5
var payload = new Array[Char](payloadLength)
for (i <- 0 until payloadLength) {
var it = stream.apply(rawLength).toChar
rawLength += 1
// Handle escape sequences
// "eBUS Spezifikation Physikalische Schicht – OSI 1
// Verbindungsschicht – OSI 2 V.1.3.1" auf Seite 8
if (it == 0xa9.toChar) {
val itNext = stream.apply(rawLength).toChar
rawLength += 1
if (itNext == 0x00.toChar) {
it = 0xa9.toChar
} else if (itNext == 0x01.toChar) {
it = 0xaa.toChar
} else {
println("Ignore escape sequence 0xa9 0x%02x".format(itNext))
rawLength -= 1
}
}
payload.update(i, it)
}
val crc = stream.apply(5 + payloadLength).toChar
rawLength += 1
return Some(new EbusPacket(source, destination,
primaryCommand, secondaryCommand,
payloadLength, payload, crc, rawLength))
} catch {
case exc: IndexOutOfBoundsException => {
println(exc.toString)
exc.printStackTrace
return None
}
}
}
}
class EbusPacket(val source: Char,
val destination: Char,
val primaryCommand: Char,
val secondaryCommand: Char,
val payloadLength: Char,
val payload: Array[Char],
val crc: Char,
val rawLength: Int) {
val length = 6 + payload.size
override def toString: String = {
val p = if (payload.size == 0)
""
else
payload.map(a => "%02x".format(a.toInt)).
reduceLeft((a: Any, b: String) => a + " " + b)
"Ebus: d=%02x pC=%02x sC=%02x pL=%02x crc=%02x p=%s".format(
destination.toInt, primaryCommand.toInt, secondaryCommand.toInt, payloadLength.toInt,
crc.toInt, p.toString)
}
/**
* Die CRC-Prüfsumme wird vom jeweiligen Sender über der expandierten Bytesendefolge mit dem
* Generatorpolynom X8 +X7 + X4 + X3 + X +1 gebildet und als letztes Byte der Nachricht,
* sofern notwendig, sogar expandiert gesendet.
*
* Generatorpol. 11001101
*/
private def calcCrc: Char = {
val sum = destination + primaryCommand + secondaryCommand + payloadLength +
payload.reduce((a, b) => ((a.intValue + b.intValue) % 256).toChar)
val crc = 1 + 1
1
}
}
object EbusReader {
def apply(streamI: Stream[Int]): EbusPacket = {
var stream = streamI
while (true) {
// Überspringe Synchronisationszeichen
stream = stream.dropWhile(v => v.toChar == 0xaa.toChar)
EbusPacket(stream) match {
case Some(packet) => {
stream = stream.drop(packet.rawLength)
return packet
}
case None => {
// Es konnte kein Paket eingelesen werden
// verschieben die Anfangsposition um ein Byte
stream = stream.drop(1)
println("skip 1 byte")
}
}
}
null
}
}
object App {
val ebusDefinition = new EbusDefinition("/home/yvesf/vcs/ebus/ebus/ebus-xml/ebus.xml")
var source: InputStream = null
def main(args: Array[String]): Unit = {
if (args.size == 1) {
println("Use stdin as source")
source = System.in
} else if (args.size == 2) {
val addr = InetAddress.getByName(args(0))
val sockAddr = new InetSocketAddress(addr, args(1).toInt)
val s = new Socket()
s.connect(sockAddr)
println("Connected to %s %d".format(args(0), args(1).toInt))
source = s.getInputStream
} else if (args.size == 3 && args(0) == "dump") {
val addr = InetAddress.getByName(args(1))
val sockAddr = new InetSocketAddress(addr, args(2).toInt)
val s = new Socket()
s.connect(sockAddr)
System.err.println("Connected to %s %d".format(args(1), args(2).toInt))
while (true) {
val v = s.getInputStream.read
if (v == -1)
System.exit(1)
print(v.toChar)
}
} else {
println("Missing Arguments")
println(" Read from stdin: -")
println(" Read from TCP: HOST PORT")
println(" Read from TCP and dump to stdout: dump HOST PORT")
System.exit(1)
}
val read = (() => {
val value = source.read
if (value == -1)
throw new EOFException("End of File reached (read returned -1)")
value
})
val stream: Stream[Int] = Stream.continually(read())
while (true) {
EbusReader(stream) match {
case x: EbusPacket => {
println(x)
val p = ebusDefinition.packetFromCommandId(x.primaryCommand, x.secondaryCommand)
if (p.size == 1)
println(p(0).attribute("name").get)
}
case null => {
println("null")
}
}
}
println("exiting")
source.close
}
}
|
