def testGetMinimumDlc(self):
sig = cansignal.CanSignalDefinition('testsignal', 56, 3)
result = sig.get_minimum_dlc()
self.assertEqual(result, 8)
sig = cansignal.CanSignalDefinition('testsignal', 2, 3)
result = sig.get_minimum_dlc()
self.assertEqual(result, 1)
def testGetSignalMask(self):
testsig2 = cansignal.CanSignalDefinition('testsignal2', 8, 16, endianness='big') # Two leftmost bytes
testsig3 = cansignal.CanSignalDefinition('testsignal3', 24, 16, endianness='little',
maxvalue=1200) # Two center bytes
testsig4 = cansignal.CanSignalDefinition('testsignal4', 48, 8, signaltype='signed') # Second last byte
self.frame_def.signaldefinitions.append(testsig2)
self.frame_def.signaldefinitions.append(testsig3)
self.frame_def.signaldefinitions.append(testsig4)
self.assertEqual(self.frame_def.get_signal_mask(), b'\xff\xff\x00\xff\xff\x00\xff\x01')
def testRepr(self):
print('\nOutput from repr():') # Check the output manually
sig = cansignal.CanSignalDefinition('testsignal', 56, 1, comment="ABC")
print(repr(sig))
comment = "ABC" + " " * 100
sig = cansignal.CanSignalDefinition('testsignal',
56,
1,
comment=comment,
endianness='big')
print(repr(sig))
def setUp(self):
self.frame_def = canframe_definition.CanFrameDefinition(
1, 'testframedef')
self.frame_def.producer_ids = set(["9"])
sig1 = cansignal.CanSignalDefinition(
'testsignal', 56, 1) # Least significant bit in last byte
self.frame_def.signaldefinitions.append(sig1)
def testMinimumPossibleValueGet(self):
sig = cansignal.CanSignalDefinition('testsignal',
56,
3,
scalingfactor=2,
valueoffset=10)
result = sig.get_minimum_possible_value()
self.assertEqual(result, 10)
def setUp(self):
self.frame = canframe.CanFrame(1, b'\x00\x02\x00\x08\x00\x00\x00\xff')
self.testsig1 = cansignal.CanSignalDefinition(
'testsignal1', 56, 1) # Least significant bit in last byte
self.testsig2 = cansignal.CanSignalDefinition(
'testsignal2', 8, 16, endianness='big') # Two leftmost bytes
self.testsig3 = cansignal.CanSignalDefinition(
'testsignal3', 24, 16, endianness='little',
maxvalue=1200) # Two center bytes
self.testsig4 = cansignal.CanSignalDefinition(
'testsignal4', 48, 8, signaltype='signed') # Second last byte
self.frame_def = canframe_definition.CanFrameDefinition(
1, 'testmessage')
self.frame_def.signaldefinitions.append(self.testsig1)
self.frame_def.signaldefinitions.append(self.testsig2)
self.frame_def.signaldefinitions.append(self.testsig3)
self.frame_def.signaldefinitions.append(self.testsig4)
def testSignalvalueGetSingle(self):
testsig1 = cansignal.CanSignalDefinition('testsignal1',
56,
32,
endianness='big',
signaltype='single')
# Example from https://en.wikipedia.org/wiki/Single-precision_floating-point_format
frame1 = canframe.CanFrame(1, b'\x00\x00\x00\x00\x3E\x20\x00\x00')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1), 0.15625)
def testSignalvalueGetDoubleLittle(self):
testsig1 = cansignal.CanSignalDefinition('testsignal1',
0,
64,
endianness='little',
signaltype='double')
# Example from https://en.wikipedia.org/wiki/Single-precision_floating-point_format
frame1 = canframe.CanFrame(1, b'\x00\x00\x00\x00\x00\x00\xF0\x3F')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1), 1.0)
def testGetDescriptiveAsciiArt(self):
print('\nOutput from get_descriptive_ascii_art():'
) # Check the output manually
sig = cansignal.CanSignalDefinition('testsignalA', 56, 1)
print(sig.get_descriptive_ascii_art())
sig = cansignal.CanSignalDefinition('testsignalB', 54, 4)
print(sig.get_descriptive_ascii_art())
sig = cansignal.CanSignalDefinition('testsignalC',
54,
2,
endianness='big')
print(sig.get_descriptive_ascii_art())
sig = cansignal.CanSignalDefinition('testsignalD',
54,
4,
endianness='big')
print(sig.get_descriptive_ascii_art())
def testConstructor(self):
sig = cansignal.CanSignalDefinition(
'testsignal', 56, 1) # Least significant bit in last byte
self.assertEqual(sig.signalname, 'testsignal')
self.assertEqual(sig.startbit, 56)
self.assertEqual(sig.numberofbits, 1)
self.assertEqual(sig.scalingfactor, 1)
self.assertEqual(sig.valueoffset, 0)
self.assertEqual(sig.endianness, 'little')
self.assertEqual(sig.signaltype, 'unsigned')
self.assertEqual(sig.minvalue, None)
self.assertEqual(sig.maxvalue, None)
self.assertEqual(sig.defaultvalue, 0)
sig = cansignal.CanSignalDefinition(
'testsignal2', 7, 1,
endianness='big') # Most significant bit in first byte
self.assertEqual(sig.signalname, 'testsignal2')
self.assertEqual(sig.startbit, 7)
self.assertEqual(sig.numberofbits, 1)
self.assertEqual(sig.scalingfactor, 1)
self.assertEqual(sig.valueoffset, 0)
self.assertEqual(sig.endianness, 'big')
self.assertEqual(sig.signaltype, 'unsigned')
self.assertEqual(sig.minvalue, None)
self.assertEqual(sig.maxvalue, None)
self.assertEqual(sig.defaultvalue, 0)
sig = cansignal.CanSignalDefinition(
'testsignal3', 56, 1,
defaultvalue=1) # Least significant bit in last byte
self.assertEqual(sig.signalname, 'testsignal3')
self.assertEqual(sig.startbit, 56)
self.assertEqual(sig.numberofbits, 1)
self.assertEqual(sig.scalingfactor, 1)
self.assertEqual(sig.valueoffset, 0)
self.assertEqual(sig.endianness, 'little')
self.assertEqual(sig.signaltype, 'unsigned')
self.assertEqual(sig.minvalue, None)
self.assertEqual(sig.maxvalue, None)
self.assertEqual(sig.defaultvalue, 1)
def testSignalvalueSetDoubleLittle(self):
testsig1 = cansignal.CanSignalDefinition('testsignal1',
0,
64,
endianness='little',
signaltype='double')
frame1 = canframe.CanFrame(1, b'\x00\x00\x00\x00\x00\x00\x00\x00')
# Example from https://en.wikipedia.org/wiki/Double-precision_floating-point_format
frame1.set_signalvalue(testsig1, 2.0)
self.assertEqual(frame1.frame_data,
b'\x00\x00\x00\x00\x00\x00\x00\x40')
def testSignalvalueSetSingleLittle(self):
testsig1 = cansignal.CanSignalDefinition('testsignal1',
32,
32,
endianness='little',
signaltype='single')
print(testsig1.get_descriptive_ascii_art())
frame1 = canframe.CanFrame(1, b'\x00\x00\x00\x00\x00\x00\x00\x00')
# Example from https://en.wikipedia.org/wiki/Single-precision_floating-point_format
frame1.set_signalvalue(testsig1, 0.15625)
self.assertEqual(frame1.frame_data,
b'\x00\x00\x00\x00\x00\x00\x20\x3E')
def testConstructor(self):
config = configuration.Configuration()
self.assertEqual(config.framedefinitions, {})
self.assertEqual(config.busname, None)
config = configuration.Configuration(None, "ABC")
self.assertEqual(config.framedefinitions, {})
self.assertEqual(config.busname, "ABC")
config = configuration.Configuration(None, "ABC", ["1", "2", "3"])
self.assertEqual(config.framedefinitions, {})
self.assertEqual(config.busname, "ABC")
self.assertEqual(config.ego_node_ids, set(["1", "2", "3"]))
fr_def = canframe_definition.CanFrameDefinition(1, 'testframedef')
sig1 = cansignal.CanSignalDefinition('testsignal', 56, 1) # Least significant bit in last byte
fr_def.signaldefinitions.append(sig1)
config = configuration.Configuration({1:fr_def}, "DEF")
self.assertEqual(config.framedefinitions[1], fr_def)
self.assertEqual(config.busname, "DEF")
def testSignalvalueGetDouble(self):
testsig1 = cansignal.CanSignalDefinition('testsignal1',
56,
64,
endianness='big',
signaltype='double')
# Example from https://en.wikipedia.org/wiki/Single-precision_floating-point_format
frame1 = canframe.CanFrame(1, b'\x40\x00\x00\x00\x00\x00\x00\x00')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1), 2.0)
frame1 = canframe.CanFrame(1, b'\x3F\xF0\x00\x00\x00\x00\x00\x00')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1), 1.0)
frame1 = canframe.CanFrame(1, b'\x3F\xF0\x00\x00\x00\x00\x00\x01')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1), 1.0)
frame1 = canframe.CanFrame(1, b'\x7F\xEF\xFF\xFF\xFF\xFF\xFF\xFF')
self.assertAlmostEqual(frame1.get_signalvalue(testsig1),
1.7976931348623157e308)
import os
import sys
import unittest
assert sys.version_info >= (3, 3, 0), "Python version 3.3 or later required!"
from can4python import canframe_definition
from can4python import cansignal
from can4python import configuration
from can4python import exceptions
FRAME_ID_SEND = 7
FRAME_ID_RECEIVE = 12
NON_EXISTING_FRAME_ID = 99
testsig1 = cansignal.CanSignalDefinition('testsignal1', 56, 1) # Least significant bit in last byte
testsig2 = cansignal.CanSignalDefinition('testsignal2', 8, 16, endianness='big') # Two leftmost bytes
testsig3 = cansignal.CanSignalDefinition('testsignal3', 24, 16, endianness='little') # Two center bytes
testsig4 = cansignal.CanSignalDefinition('testsignal4', 59, 4, endianness='big', signaltype='signed')
fr_def1 = canframe_definition.CanFrameDefinition(FRAME_ID_SEND, 'testframedef_send')
fr_def1.producer_ids = ["1"]
fr_def1.signaldefinitions.append(testsig1)
fr_def1.signaldefinitions.append(testsig2)
fr_def1.signaldefinitions.append(testsig3)
fr_def1.signaldefinitions.append(testsig4)
testsig11 = cansignal.CanSignalDefinition('testsignal11', 56, 1) # Least significant bit in last byte
testsig12 = cansignal.CanSignalDefinition('testsignal12', 8, 16, endianness='big') # Two leftmost bytes
testsig13 = cansignal.CanSignalDefinition('testsignal13', 24, 16, endianness='little') # Two center bytes
testsig14 = cansignal.CanSignalDefinition('testsignal14', 59, 4, endianness='big', signaltype='signed')
fr_def2 = canframe_definition.CanFrameDefinition(FRAME_ID_RECEIVE, 'testframedef_receive')
fr_def2.producer_ids = ["77"]
def setUp(self):
self.signal = cansignal.CanSignalDefinition(
'testsignal', 56, 1) # Least significant bit in last byte
def testPropertiesWrongValues(self):
self.assertRaises(exceptions.CanException, setattr, self.signal,
'startbit', -1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'startbit', 64)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'startbit', None)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'numberofbits', -1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'numberofbits', 0)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'numberofbits', None)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'endianness', 1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'endianness', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'endianness', None)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'signaltype', 1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'signaltype', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'signaltype', None)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'maxvalue', 2)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'maxvalue', -1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'maxvalue', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'minvalue', -1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'minvalue', 2)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'minvalue', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'defaultvalue', -1)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'defaultvalue', 2)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'defaultvalue', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'scalingfactor', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'scalingfactor', None)
self.assertRaises(exceptions.CanException, setattr, self.signal,
'valueoffset', 'ABC')
self.assertRaises(exceptions.CanException, setattr, self.signal,
'valueoffset', None)
sig = cansignal.CanSignalDefinition('testsignal',
56,
1,
endianness='big')
sig.signaltype = constants.CAN_SIGNALTYPE_SINGLE
self.assertRaises(exceptions.CanException, setattr, sig,
'numberofbits', 31)
sig.signaltype = constants.CAN_SIGNALTYPE_DOUBLE
self.assertRaises(exceptions.CanException, setattr, sig,
'numberofbits', 63)
def __init__(self):
print("Distance for both sensors:", distance)
self.bus = BCM('can0', timeout=5.0)
print("Bus created")
#byte position 1 & bit position 4 --> startbit=10 & signal size 3
self.signals = [
cansignal.CanSignalDefinition('ParkAssitVolumeState', 48, 3),
cansignal.CanSignalDefinition('SensorAvailabilityFrontCenter', 34,
1),
cansignal.CanSignalDefinition('SensorAvailabilityFrontleft', 33,
1),
cansignal.CanSignalDefinition('SensorAvailabilityFrontRight', 41,
1),
cansignal.CanSignalDefinition('SensorAvailabilityRearCenter', 55,
1),
cansignal.CanSignalDefinition('SensorAvailabilityRearLeft', 54, 1),
cansignal.CanSignalDefinition('SensorAvailabilityRearRight', 53,
1),
cansignal.CanSignalDefinition('SonarObstacleDistanceDisplay', 44,
4),
cansignal.CanSignalDefinition('UPA_ClosingAuthorization', 58, 1),
cansignal.CanSignalDefinition('UPA_Image_DisplayRequest', 17, 2),
cansignal.CanSignalDefinition('UPA_Obstacle_Zone_Front_Center', 31,
3),
cansignal.CanSignalDefinition('UPA_Obstacle_zone_front_left', 15,
3),
cansignal.CanSignalDefinition('UPA_Obstacle_zone_front_Right', 12,
3),
cansignal.CanSignalDefinition('UPA_Obstacle_zone_Rear_Center', 29,
3),
cansignal.CanSignalDefinition('UPA_Obstacle_zone_Rear_Left', 23,
3),
cansignal.CanSignalDefinition('UPA_Obstacle_zone_Rear_Right', 20,
3),
cansignal.CanSignalDefinition('UPA_SoundActivationBeep ', 24, 1),
cansignal.CanSignalDefinition('UPA_SoundErrorBeep', 25, 1),
cansignal.CanSignalDefinition('UPA_SoundObstacleZone', 34, 3),
cansignal.CanSignalDefinition('UPA_SoundReccurencePeriod', 1, 7),
cansignal.CanSignalDefinition('UPA_SoundReccurenceType', 0, 1),
cansignal.CanSignalDefinition('UPA_SystemState', 9, 2),
cansignal.CanSignalDefinition('UPAStatusDisplayRequest', 39, 3)
]
#byte position 1 & bit position 7 --> startbit=13 & signal size 3
#self.signals[1] = cansignal.CanSignalDefinition('UPA_Obstacle_zone_front_left', 13, 3)
#ajout des signaux sur la trame global
self.frame_def = canframe_definition.CanFrameDefinition(1, 'sonarA4')
self.frame_def.signaldefinitions.append(self.signals[0])
self.frame_def.signaldefinitions.append(self.signals[1])
self.frame_def.signaldefinitions.append(self.signals[2])
self.frame_def.signaldefinitions.append(self.signals[3])
self.frame_def.signaldefinitions.append(self.signals[4])
self.frame_def.signaldefinitions.append(self.signals[5])
self.frame_def.signaldefinitions.append(self.signals[6])
self.frame_def.signaldefinitions.append(self.signals[7])
self.frame_def.signaldefinitions.append(self.signals[2])
self.frame_def.signaldefinitions.append(self.signals[9])
self.frame_def.signaldefinitions.append(self.signals[10])
self.frame_def.signaldefinitions.append(self.signals[11])
self.frame_def.signaldefinitions.append(self.signals[12])
self.frame_def.signaldefinitions.append(self.signals[13])
self.frame_def.signaldefinitions.append(self.signals[14])
self.frame_def.signaldefinitions.append(self.signals[15])
self.frame_def.signaldefinitions.append(self.signals[16])
self.frame_def.signaldefinitions.append(self.signals[17])
self.frame_def.signaldefinitions.append(self.signals[18])
self.frame_def.signaldefinitions.append(self.signals[19])
self.frame_def.signaldefinitions.append(self.signals[20])
self.frame = CanFrame(0x53D,
frame_data=[0, 0, 0, 0, 0, 0, 0, 0],
frame_format='standard')
print("Frame created")
self.th1 = threading.Thread(target=self.sensor_reader,
args=(triggers[SENSOR_2_ID],
echos[SENSOR_2_ID], SENSOR_2_ID))
