FaSTTUBe/slave-testbench-23
54
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format everything

Browse Source
This commit is contained in:
Jasper Blanckenburg
2023-04-01 18:55:55 +02:00
parent 414e407151
commit 91f29264f9
7 changed files with 160 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
Test.py
View File

@ -1,17 +1,21 @@
import time import time
import can import can
bustype = 'socketcan' bustype = "socketcan"
channel = 'can0' #echten can nutzen channel = "can0" # echten can nutzen
def producer(id): def producer(id):
""":param id: Spam the bus with messages including the data id.""" """:param id: Spam the bus with messages including the data id."""
bus = can.Bus(channel=channel, interface=bustype) bus = can.Bus(channel=channel, interface=bustype)
for i in range(10): 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) bus.send(msg)
time.sleep(1) time.sleep(1)
producer(10) # rausfinden welche id der Slave hat
producer(10) # rausfinden welche id der Slave hat
print("I am done with this shit") print("I am done with this shit")

13
TestRead.py
View File

@ -3,13 +3,12 @@ import can
input("startReading") 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) message = bus.recv(5.0)
if message is None: 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

158
canTest.py
View File

@ -5,89 +5,93 @@ import can
waitForUserInput = True waitForUserInput = True
bus = None 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) def sendMessageOnCan(message, bustype="socketcan", channel="can0"):
bus.send(msg) global bus
time.sleep(1) if bus is None:
bus = can.interface.Bus(channel, bustype="socketcan")
busEnabled = True
def recive(bustype='socketcan',channel='can0'): msg = can.Message(arbitration_id=0x002, data=message, is_extended_id=False)
global bus bus.send(msg)
message = bus.recv() time.sleep(1)
if message is None:
print('Timeout occurred, no message.')
#timeOut
else : def recive(bustype="socketcan", channel="can0"):
#print('We got a message hell yeah') global bus
print(message) message = bus.recv()
return message
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): def waitForUserInput(waitForUserInput):
if(waitForUserInput): if waitForUserInput:
readInput = "n" readInput = "n"
print("Ready to start ? ") print("Ready to start ? ")
while('y' not in readInput): while "y" not in readInput:
print("Enter y to start or c to cancel ") print("Enter y to start or c to cancel ")
readInput = input(" ") readInput = input(" ")
if(readInput == 'c'): if readInput == "c":
return -1 return -1
return 0 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")
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")

18
eProm.py
View File

@ -1,12 +1,12 @@
import canTest 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") 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")

20
realTest.py
View File

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

41
tempTest.py
View File

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

40
voltageTest.py
View File

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