Initial commit

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.py[ocd]

Test.py

@@ -0,0 +1,17 @@
+import time
+import can
+
+bustype = 'socketcan'
+channel = 'can0'  #echten can nutzen
+
+def producer(id):
+    """:param id: Spam the bus with messages including the data id."""
+    bus = can.Bus(channel=channel, interface=bustype)
+    for i in range(10):
+        msg = can.Message(arbitration_id=0x002, data=[id, i, 0, 1, 3, 1, 4, 1], is_extended_id=False)
+        bus.send(msg)
+
+    time.sleep(1)
+   
+producer(10) # rausfinden welche id der Slave hat
+print("I am done with this shit")

TestRead.py

@@ -0,0 +1,15 @@
+import can
+
+
+input("startReading")
+
+can_interface = 'can0' #echten can nutzen
+bus = can.interface.Bus(can_interface, bustype='socketcan')
+message = bus.recv(5.0)
+
+if message is None:
+    print('Timeout occurred, no message.')
+else :
+	print('We got a message hell yeah')
+	print("{}".format(message.data)) #hat gesendete data von can benutzen
+

canTest.py

@@ -0,0 +1,93 @@
+import random
+import time
+import can
+
+waitForUserInput = True
+bus = None
+
+def sendMessageOnCan(message, bustype='socketcan',channel='can0'):
+	
+	global bus
+	if bus is None:
+		bus = can.interface.Bus(channel, bustype='socketcan')
+		busEnabled = True
+
+	msg = can.Message(arbitration_id=0x002, data=message, is_extended_id=False)
+	bus.send(msg)
+	time.sleep(1)
+
+def recive(bustype='socketcan',channel='can0'):
+	global bus	
+	message = bus.recv()
+
+	if message is None:
+		print('Timeout occurred, no message.')
+		#timeOut
+
+	else :
+		#print('We got a message hell yeah')
+		print(message)
+		return message
+
+def waitForUserInput(waitForUserInput):
+	if(waitForUserInput):
+		readInput = "n"
+		print("Ready to start ? ")
+		while('y' not in readInput):
+			print("Enter y to start or c to cancel ")
+			readInput = input(" ")
+			if(readInput == 'c'):
+				return -1
+	return 0
+
+def CanTest(bustype='socketcan',channel='can0'):
+#-----------------------------------------------------------------------------------------------------#
+	print("Start testing the can bus connectivity ")
+	global waitForUserInput
+	if (waitForUserInput(waitForUserInput) != 0):
+		return
+
+	print("testing can for a single message")
+	messageType = 1
+	testMessage = [messageType, 0xc, 0, 0xf, 0xf, 0xe, 0xe]
+	testMessageData = [1, 12, 0, 15, 15, 14, 14, 0]
+	
+	sendMessageOnCan(testMessage)
+	recivedMessage = recive().data
+
+	result = True
+	count = 0
+
+	for entry in recivedMessage :
+		if entry != testMessageData[count]:
+			result = False
+			break
+
+		count = count + 1
+
+	print(recivedMessage)
+	print("Sending a single message test with answer result {}".format(result))
+#-----------------------------------------------------------------------------------------------------#
+	
+	print("testing for multiple sends")
+	if (waitForUserInput(waitForUserInput) != 0):
+		return
+
+	packete = []
+	sendCountFinally = 0
+	trials = 12
+	for sendCount in range(trials):
+		sendMessageOnCan([1, 0xc, 0, 0xf, 0xf, 0xe, 0xe, sendCount])
+		time.sleep(0.1)
+		packete.append(recive())
+
+	for packet in packete:	
+		print(packet.data)
+
+	print("Sending multiple testmessages test with answer result {}".format(len(packete) == len(range(trials))))
+	
+#-----------------------------------------------------------------------------------------------------#
+	print("I am done with this shit")
+
+
+

eProm.py

@@ -0,0 +1,12 @@
+import canTest
+
+def ePromTest():
+	print("start eprom test")
+	message = [4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,0x00]
+	canTest.waitForUserInput(True)
+	canTest.sendMessageOnCan(message)
+	answer = canTest.recive();
+	print("ePromTest reult {}".format(str(answer.data) == "bytearray(b'iiiiBiii')"))
+	
+
+	print("I am done with this shit")

realTest.py

@@ -0,0 +1,37 @@
+import canTest
+import voltageTest
+import tempTest
+import eProm
+
+
+def startBalancingTest():
+	message = [5, 0xc, 0, 0xf, 0xf, 0xe, 0xe]
+	print("startBalancing")
+	canTest.waitForUserInput(True)
+	canTest.sendMessageOnCan(message)
+
+
+#canTest.CanTest()
+#eProm.ePromTest()
+#voltageTest.voltagesTest()
+tempTest.tempTest() 
+
+#startBalancingTest()
+"""
+print("start Temp test")
+message = [3, 0xc, 0, 0xf, 0xf, 0xe, 0xe]
+canTest.waitForUserInput(True)
+canTest.sendMessageOnCan(message)
+
+answer = canTest.recive();
+print(answer.data)
+
+print("start eprom test")
+message = [4, 0xc, 0, 0xf, 0xf, 0xe, 0xe,0x00]
+canTest.waitForUserInput(True)
+canTest.sendMessageOnCan(message)
+answer = canTest.recive();
+print(answer.data)
+"""
+
+

tempTest.py

@@ -0,0 +1,60 @@
+import time
+import can
+import canTest
+import struct
+
+bustype = 'socketcan'
+channel = 'can0'
+
+def getTempOverCan():
+    bus = can.Bus(channel=channel, interface=bustype)
+    message = can.Message(arbitration_id=0x002, data=[3, 0, 0, 0, 0, 0, 0], is_extended_id=False)
+    bus.send(message)
+    voltages = []
+    runtime  =  2
+    begin = 0
+
+    for msg in bus:
+        print(msg.data)
+        voltages.append(msg.data)
+        print("begin {}".format(begin))
+        begin = begin + 1
+        if(begin > runtime):
+            return voltages
+
+def verifyNumbers(numberListList):
+    zeroCount = 0
+    max = 0
+    min = 1000000
+    for numberList in numberListList: 
+    	print("Temperatures {}".format(numberList))
+    	for number in numberList:
+
+            if number < min:
+                min = number
+
+            elif number > max :   
+                max = number
+
+    print("Temperatures {}".format())
+    print("The biggest difference tmep was max{} and min{}".format((max), (min)))
+
+def tempTest():  
+    print("starting temperature test ")
+    canTest.waitForUserInput(True)
+    Temps = getTempOverCan() 
+    allTemp = []
+    changed = []
+
+    for temp in Temps:
+        allTemp.append(struct.unpack("<HHHH", temp)) #Format anpassen
+
+    print("all Number")    
+    print(allTemp)    
+
+    for te in allTemp:    
+        for con in te:
+            changed.append(((con/16)*0.0625))
+    print(changed)        
+    print("I am done with this shit")
+

voltageTest.py

@@ -0,0 +1,53 @@
+import time
+import can
+import canTest
+import struct
+
+bustype = 'socketcan'
+channel = 'can0'
+
+def getBatteryVoltageOverCan():
+    bus = can.Bus(channel=channel, interface=bustype)
+    message = can.Message(arbitration_id=0x002, data=[2, 0, 0, 0, 0, 0, 0], is_extended_id=False)
+    bus.send(message)
+    voltages = []
+    runtime  =  3
+    begin = 0
+
+    for msg in bus:
+        #print(msg.data)
+        voltages.append(msg.data)
+        #print("begin {}".format(begin))
+        begin = begin + 1
+        if(begin > 4):
+            return voltages
+
+def verifyNumbers(numberListList):
+    zeroCount = 0
+    max = 0
+    min = 1000000
+    for numberList in numberListList: 
+        for number in numberList:
+            if number == 0:
+                zeroCount +=1
+
+            elif number < min:
+                min = number
+
+            elif number > max :   
+                max = number
+
+    print("There were 3 expected Zeros and {} detected".format(zeroCount))
+    print("The biggest difference were over {} and under {}".format((max-35000), (35000-min)))
+
+def voltagesTest():  
+    print("starting voltage test pls but 3.500 as reference value")
+    canTest.waitForUserInput(True)
+    voltages = getBatteryVoltageOverCan() # rausfinden welche id der Slave hat
+    allVoltages = []
+    for volt in voltages:
+        allVoltages.append(struct.unpack("<HHHH", volt))
+    
+    verifyNumbers(allVoltages)        
+    print("I am done with this shit")
+