Format everything

Test.py

@@ -1,17 +1,21 @@
 import time
 import can
 
-bustype = 'socketcan'
+bustype = "socketcan"
-channel = 'can0'  #echten can nutzen
+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)
+        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

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

canTest.py

@@ -5,51 +5,54 @@ import can
 waitForUserInput = True
 bus = None
 
-def sendMessageOnCan(message, bustype='socketcan',channel='can0'):
 
+def sendMessageOnCan(message, bustype="socketcan", channel="can0"):
     global bus
     if bus is None:
-		bus = can.interface.Bus(channel, bustype='socketcan')
+        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'):
+
+def recive(bustype="socketcan", channel="can0"):
     global bus
     message = bus.recv()
 
     if message is None:
-		print('Timeout occurred, no message.')
+        print("Timeout occurred, no message.")
-		#timeOut
+        # timeOut
 
-	else :
+    else:
-		#print('We got a message hell yeah')
+        # print('We got a message hell yeah')
         print(message)
         return message
 
+
 def waitForUserInput(waitForUserInput):
-	if(waitForUserInput):
+    if waitForUserInput:
         readInput = "n"
         print("Ready to start ? ")
-		while('y' not in readInput):
+        while "y" not in readInput:
             print("Enter y to start or c to cancel ")
             readInput = input(" ")
-			if(readInput == 'c'):
+            if readInput == "c":
                 return -1
     return 0
 
-def CanTest(bustype='socketcan',channel='can0'):
+
-#-----------------------------------------------------------------------------------------------------#
+def CanTest(bustype="socketcan", channel="can0"):
+    # -----------------------------------------------------------------------------------------------------#
     print("Start testing the can bus connectivity ")
     global waitForUserInput
-	if (waitForUserInput(waitForUserInput) != 0):
+    if waitForUserInput(waitForUserInput) != 0:
         return
 
     print("testing can for a single message")
     messageType = 1
-	testMessage = [messageType, 0xc, 0, 0xf, 0xf, 0xe, 0xe]
+    testMessage = [messageType, 0xC, 0, 0xF, 0xF, 0xE, 0xE]
     testMessageData = [1, 12, 0, 15, 15, 14, 14, 0]
 
     sendMessageOnCan(testMessage)
@@ -58,7 +61,7 @@ def CanTest(bustype='socketcan',channel='can0'):
     result = True
     count = 0
 
-	for entry in recivedMessage :
+    for entry in recivedMessage:
         if entry != testMessageData[count]:
             result = False
             break
@@ -67,27 +70,28 @@ def CanTest(bustype='socketcan',channel='can0'):
 
     print(recivedMessage)
     print("Sending a single message test with answer result {}".format(result))
-#-----------------------------------------------------------------------------------------------------#
+    # -----------------------------------------------------------------------------------------------------#
 
     print("testing for multiple sends")
-	if (waitForUserInput(waitForUserInput) != 0):
+    if waitForUserInput(waitForUserInput) != 0:
         return
 
     packete = []
     sendCountFinally = 0
     trials = 12
     for sendCount in range(trials):
-		sendMessageOnCan([1, 0xc, 0, 0xf, 0xf, 0xe, 0xe, sendCount])
+        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(
+        "Sending multiple testmessages test with answer result {}".format(
+            len(packete) == len(range(trials))
+        )
+    )
 
-#-----------------------------------------------------------------------------------------------------#
+    # -----------------------------------------------------------------------------------------------------#
     print("I am done with this shit")
-
-
-

eProm.py

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

realTest.py

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

tempTest.py

@@ -3,12 +3,15 @@ import can
 import canTest
 import struct
 
-bustype = 'socketcan'
+bustype = "socketcan"
-channel = 'can0'
+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)
+    message = can.Message(
+        arbitration_id=0x002, data=[3, 0, 0, 0, 0, 0, 0], is_extended_id=False
+    )
     bus.send(message)
     voltages = []
     runtime = 2
@@ -19,9 +22,10 @@ def getTempOverCan():
         voltages.append(msg.data)
         print("begin {}".format(begin))
         begin = begin + 1
-        if(begin > runtime):
+        if begin > runtime:
             return voltages
 
+
 def verifyNumbers(numberListList):
     zeroCount = 0
     max = 0
@@ -29,16 +33,16 @@ def verifyNumbers(numberListList):
     for numberList in numberListList:
         print("Temperatures {}".format(numberList))
         for number in numberList:
-
             if number < min:
                 min = number
 
-            elif number > max :   
+            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)
@@ -47,14 +51,13 @@ def tempTest():
     changed = []
 
     for temp in Temps:
-        allTemp.append(struct.unpack("<HHHH", temp)) #Format anpassen
+        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))
+            changed.append(((con / 16) * 0.0625))
     print(changed)
     print("I am done with this shit")
-

voltageTest.py

@@ -3,25 +3,29 @@ import can
 import canTest
 import struct
 
-bustype = 'socketcan'
+bustype = "socketcan"
-channel = 'can0'
+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)
+    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)
+        # print(msg.data)
         voltages.append(msg.data)
-        #print("begin {}".format(begin))
+        # print("begin {}".format(begin))
         begin = begin + 1
-        if(begin > 4):
+        if begin > 4:
             return voltages
 
+
 def verifyNumbers(numberListList):
     zeroCount = 0
     max = 0
@@ -29,16 +33,21 @@ def verifyNumbers(numberListList):
     for numberList in numberListList:
         for number in numberList:
             if number == 0:
-                zeroCount +=1
+                zeroCount += 1
 
             elif number < min:
                 min = number
 
-            elif number > max :   
+            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)))
+    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")
@@ -50,4 +59,3 @@ def voltagesTest():
 
     verifyNumbers(allVoltages)
     print("I am done with this shit")
-