import ctypes as ct
import datetime
import time
import os
from .. import deprecation
from . import constants as const
from .exceptions import kvm_error, KvmNoLogMsg
from .events import memoLogEventEx
from .wrapper import dll
class kvmVersion(object):
"""
Class that holds kvmlib version number.
"""
def __init__(self, major, minor, build):
self.major = major
self.minor = minor
self.build = build
def __str__(self):
"""
Presents the version number as 'major.minor.build'.
"""
return "%d.%d.%d" % (self.major, self.minor, self.build)
class KvmLib(object):
"""Wrapper class for the Kvaser kvmlib.
This class wraps the Kvaser kvmlib dll. For more info, see the kvmlib help
files which are availible in the CANlib SDK.
https://www.kvaser.com/developer/canlib-sdk/
"""
dll = dll
def __init__(self):
self.handle = None
self.kmeHandle = None
self.logFileIndex = None
self.dll.kvmInitialize()
def getVersion(self):
"""Get the kvmlib version number.
Returns the kvmlib version number from the kvmlib DLL currently in use.
.. deprecated:: 1.5
Use `dllversion` instead.
Args:
None
Returns:
version (kvmVersion): Major and minor version number
"""
major = ct.c_int()
minor = ct.c_int()
build = ct.c_int()
self.dll.kvmGetVersion(ct.byref(major), ct.byref(minor),
ct.byref(build))
version = kvmVersion(major.value, minor.value, build.value)
return version
@deprecation.deprecated.favour("deviceOpen")
def openDeviceEx(self, memoNr=0, devicetype=const.kvmDEVICE_MHYDRA):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceOpen` instead.
"""
self.deviceOpen(memoNr, devicetype)
def deviceOpen(self, memoNr=0, devicetype=const.kvmDEVICE_MHYDRA):
status_p = ct.c_int()
self.handle = self.dll.kvmDeviceOpen(memoNr, ct.byref(status_p), devicetype)
@deprecation.deprecated.favour("deviceMountKmf")
def openLog(self):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceMountKmf` instead.
"""
self.deviceMountKmf()
def deviceMountKmf(self):
"""Mount device log files (kmf)
Mount the log area on the SD card on a connected Kvaser Memorator and
return the logger data format (LDF) version.
Returns:
ldfVersion (str): The logger data format (e.g. '5.0')
"""
ldfMajor = ct.c_int(0)
ldfMinor = ct.c_int(0)
self.dll.kvmDeviceMountKmfEx(self.handle, ldfMajor, ldfMinor)
return "%d.%d" % (ldfMajor.value, ldfMinor.value)
@deprecation.deprecated.favour("kmfReadConfig")
def readConfig(self):
"""Deprecated function
.. deprecated:: 1.5
Use `kmfReadConfig` instead.
"""
self.kmfReadConfig()
def kmfReadConfig(self):
lif_buf = ct.create_string_buffer(320 * 32 * 1024)
actual_len = ct.c_size_t(0)
self.dll.kvmKmfReadConfig(self.handle, ct.byref(lif_buf),
ct.sizeof(lif_buf), ct.byref(actual_len))
return lif_buf.raw[:actual_len.value]
@deprecation.deprecated.favour("kmfGetUsage")
def getFileSystemUsage(self):
"""Deprecated function
.. deprecated:: 1.5
Use `kmfGetUsage` instead.
"""
self.kmfGetUsage()
def kmfGetUsage(self):
totalSectorCount = ct.c_uint32()
usedSectorCount = ct.c_uint32()
self.dll.kvmKmfGetUsage(self.handle,
ct.byref(totalSectorCount),
ct.byref(usedSectorCount))
return (int((totalSectorCount.value * 512) / (1000 * 1000)),
int((usedSectorCount.value * 512) / (1000 * 1000)))
def kmfOpen(self, filename, deviceType=const.kvmDEVICE_MHYDRA):
status_p = ct.c_int()
self.handle = self.dll.kvmKmfOpen(filename.encode(),
ct.byref(status_p),
deviceType)
if status_p.value < 0:
self.handle = None
print("ERROR filename:%s, devicetype:%d\n" %
(filename, deviceType))
raise kvm_error(status_p.value)
def kmfOpenEx(self, filename, deviceType=const.kvmDEVICE_MHYDRA):
status_p = ct.c_int()
ldfMajor = ct.c_int()
ldfMinor = ct.c_int()
self.handle = self.dll.kvmKmfOpenEx(filename.encode(),
ct.byref(status_p),
deviceType, ct.byref(ldfMajor),
ct.byref(ldfMinor))
if status_p.value < 0:
self.handle = None
print("ERROR filename:%s, devicetype:%d\n" %
(filename, deviceType))
raise kvm_error(status_p.value)
return "%d.%d" % (ldfMajor.value, ldfMinor.value)
@deprecation.deprecated.favour("deviceGetDiskSize")
def getDiskSize(self):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceGetDiskSize` instead.
"""
self.deviceGetDiskSize()
def deviceGetDiskSize(self):
diskSize = ct.c_uint32()
self.dll.kvmDeviceDiskSize(self.handle, ct.byref(diskSize))
return int((diskSize.value * 512) / (1000 * 1000))
def logFileGetStartTime(self):
startTime = ct.c_uint32()
self.dll.kvmLogFileGetStartTime(self.handle,
ct.byref(startTime))
return datetime.datetime.fromtimestamp(startTime.value)
@deprecation.deprecated.favour("deviceGetRTC")
def getRTC(self):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceGetRTC` instead.
"""
self.deviceGetRTC()
def deviceGetRTC(self):
time = ct.c_uint32()
self.dll.kvmDeviceGetRTC(self.handle, ct.byref(time))
return datetime.datetime.fromtimestamp(time.value)
@deprecation.deprecated.favour("deviceSetRTC")
def setRTC(self, timestamp):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceSetRTC` instead.
"""
self.deviceSetRTC(timestamp)
def deviceSetRTC(self, timestamp):
unixTime = ct.c_uint32(int(time.mktime(timestamp.timetuple())))
self.dll.kvmDeviceSetRTC(self.handle, unixTime)
@deprecation.deprecated.favour("deviceGetDiskStatus")
def isDiskPresent(self):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceGetDiskStatus` instead.
"""
self.deviceGetDiskStatus()
def deviceGetDiskStatus(self):
present = ct.c_int(0)
self.dll.kvmDeviceDiskStatus(self.handle,
ct.byref(present))
return not(present.value == 0)
@deprecation.deprecated.favour("logFileGetCount")
def getLogFileCount(self):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileGetCount` instead.
"""
self.logFileGetCount()
def logFileGetCount(self):
fileCount = ct.c_uint32()
self.dll.kvmLogFileGetCount(self.handle,
ct.byref(fileCount))
return fileCount.value
@deprecation.deprecated.favour("deviceGetSerialNumber")
def getSerialNumber(self):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceGetSerialNumber` instead.
"""
self.deviceGetSerialNumber()
def deviceGetSerialNumber(self):
serial = ct.c_uint()
self.dll.kvmDeviceGetSerialNumber(self.handle,
ct.byref(serial))
return serial.value
@deprecation.deprecated.favour("logFileDismount")
def logCloseFile(self):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileDismount` instead.
"""
self.logFileDismount()
def logFileDismount(self):
self.dll.kvmLogFileDismount(self.handle)
self.logFileIndex = None
self.eventCount = 0
@deprecation.deprecated.favour("logFileMount")
def logOpenFile(self, fileIndx):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileMount` instead.
"""
self.logFileMount(fileIndx)
def logFileMount(self, fileIndx):
if self.logFileIndex is not None:
self.logFileDismount
eventCount = ct.c_uint32()
self.dll.kvmLogFileMount(self.handle, fileIndx, ct.byref(eventCount))
self.logFileIndex = fileIndx
self.eventCount = eventCount.value
self.events = []
return self.eventCount
@deprecation.deprecated.favour("logFileReadEvent")
def logReadEventEx(self):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileReadEvent` instead.
"""
self.logFileReadEvent()
def logFileReadEvent(self):
logevent = memoLogEventEx()
try:
self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent))
except (KvmNoLogMsg):
return None
memoEvent = logevent.createMemoEvent()
return memoEvent
def logFileReadEventLogFormat(self):
logevent = memoLogEventEx()
try:
self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent))
except (KvmNoLogMsg):
return None
return logevent
@deprecation.deprecated.favour("Kme50.read_event")
def kmeReadEvent(self):
logevent = memoLogEventEx()
try:
self.dll.kvmKmeReadEvent(self.kmeHandle, logevent)
except (KvmNoLogMsg):
return None
hexstring = ''.join(['%02x' % b for b in logevent.event.raw.data])
n = 4
grouped_hexstring = [hexstring[i:i+n] for i in range(0, len(hexstring), n)]
print('Read Dr event:', ' '.join(grouped_hexstring))
memoEvent = logevent.createMemoEvent()
return memoEvent
@deprecation.deprecated.favour("Kme.read_event")
def kmeReadEventLogFormat(self):
logevent = memoLogEventEx()
try:
self.dll.kvmKmeReadEvent(self.kmeHandle, ct.byref(logevent))
except (KvmNoLogMsg):
return None
return logevent
@deprecation.deprecated.favour("Kme50.write_event")
def kmeWriteEvent(self, logevent):
self.dll.kvmKmeWriteEvent(self.kmeHandle, logevent)
@deprecation.deprecated.favour("logFileReadEvents")
def readEvents(self):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileReadEvents` instead.
"""
return self.logFileReadEvents()
@deprecation.deprecated.favour("logFileReadEvents")
def logReadEvents(self):
"""Deprecated function
.. deprecated:: 1.5
Use `logFileReadEvents` instead.
"""
self.logFileReadEvents()
def logFileReadEvents(self):
while True:
event = self.logFileReadEvent()
if event is None:
break
self.events.append(event)
return self.events
@deprecation.deprecated.favour("kmfValidate")
def validateDisk(self, fix=0):
"""Deprecated function
.. deprecated:: 1.5
Use `kmfValidate` instead.
"""
self.kmfValidate(fix)
def kmfValidate(self, fix=0):
self.dll.kvmKmfValidate(self.handle)
@deprecation.deprecated.favour("kmfWriteConfig")
def writeConfigLif(self, lifData):
"""writeConfig
.. deprecated:: 1.5
Use `kmfWriteConfig` instead.
"""
self.kmfWriteConfig(lifData)
def kmfWriteConfig(self, lifData):
buf = ct.create_string_buffer(lifData)
self.dll.kvmKmfWriteConfig(self.handle, ct.byref(buf), len(lifData))
def logFileDeleteAll(self):
self.dll.kvmLogFileDeleteAll(self.handle)
def writeConfig(self, config):
self.kmfWriteConfig(config.toLif())
@deprecation.deprecated.favour("deviceFormatDisk")
def formatDisk(self, reserveSpace=10, dbaseSpace=2, fat32=True):
"""Deprecated function
.. deprecated:: 1.5
Use `deviceFormatDisk` instead.
"""
self.deviceFormatDisk(reserveSpace, dbaseSpace, fat32)
def deviceFormatDisk(self, reserveSpace=10, dbaseSpace=2, fat32=True):
return self.dll.kvmDeviceFormatDisk(self.handle, fat32, reserveSpace,
dbaseSpace)
@deprecation.deprecated.favour("close")
def closeDevice(self):
"""Deprecated function
.. deprecated:: 1.5
Use `close` instead.
"""
self.close()
def close(self):
self.dll.kvmClose(self.handle)
self.handle = None
@deprecation.deprecated.favour("kvmlib.openKme")
def kmeOpenFile(self, filename, filetype=const.kvmFILE_KME40):
if self.kmeHandle is not None:
self.kmeCloseFile()
status_p = ct.c_int32()
self.kmeHandle = self.dll.kvmKmeOpenFile(filename.encode(),
ct.byref(status_p),
filetype)
if status_p.value != 0:
self.kmeHandle = None
print("ERROR kmeOpenFile failed with filename:"
"%s, filetype:%s\n" % (filename, filetype))
raise kvm_error(status_p.value)
@deprecation.deprecated.favour("kvmlib.kme_file_type")
def kmeScanFileType(self, filename):
"""Scan KME file and report version
Open and read the file filename and try to decode what version
of KME it contains. Returns type as kvmFILE_xxx.
"""
type = ct.c_int32()
filename = os.path.realpath(filename)
ct_filename = ct.c_char_p(filename.encode())
self.dll.kvmKmeScanFileType(ct_filename, ct.byref(type))
return type.value
@deprecation.deprecated.favour("kvmlib.createKme")
def kmeCreateFile(self, filename, filetype=const.kvmFILE_KME40):
if self.kmeHandle is not None:
self.kmeCloseFile()
status_p = ct.c_int32()
ct_filename = ct.c_char_p(filename.encode())
self.kmeHandle = self.dll.kvmKmeCreateFile(ct_filename,
ct.byref(status_p),
filetype)
if status_p.value != 0:
self.kmeHandle = None
print("ERROR kmeCreateFile failed with filename:"
"%s, filetype:%s\n" % (filename, filetype))
raise kvm_error(status_p.value)
@deprecation.deprecated.favour("Kme.estimate_events")
def kmeCountEvents(self):
eventCount = ct.c_uint32(0)
self.dll.kvmKmeCountEvents(self.kmeHandle,
ct.byref(eventCount))
return eventCount.value
@deprecation.deprecated.favour("Kme.close")
def kmeCloseFile(self):
self.dll.kvmKmeCloseFile(self.kmeHandle)
self.kmeHandle = None