Source code for canlib.kvmlib.wrapper

import ctypes as ct
import datetime
import time
import os

from .. import dllLoader
from .. import deprecation
from .. import VersionNumber
from . import constants as const
from .dll import KvmlibDll
from .exceptions import kvm_error, KvmNoLogMsg
from .structures import memoLogEventEx


[docs]def dllversion(): """Get the kvmlib version number as a `VersionNumber`""" dll = KvmLib.dll major = ct.c_int() minor = ct.c_int() build = ct.c_int() dll.kvmGetVersion(ct.byref(major), ct.byref(minor), ct.byref(build)) version = VersionNumber(major.value, minor.value, build.value)
return version 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)
[docs]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/ """ _ct_dll = dllLoader.load_dll(win_name='kvmlib.dll', linux_name='libkvmlib.so') dll = KvmlibDll(_ct_dll) def __init__(self): self.handle = None self.kmeHandle = None self.logFileIndex = None self.dll.kvmInitialize()
[docs] 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
[docs] @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)
[docs] 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)
[docs] @deprecation.deprecated.favour("deviceMountKmf") def openLog(self): """Deprecated function .. deprecated:: 1.5 Use `deviceMountKmf` instead. """
self.deviceMountKmf()
[docs] 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)
[docs] @deprecation.deprecated.favour("kmfReadConfig") def readConfig(self): """Deprecated function .. deprecated:: 1.5 Use `kmfReadConfig` instead. """
self.kmfReadConfig()
[docs] 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]
[docs] @deprecation.deprecated.favour("kmfGetUsage") def getFileSystemUsage(self): """Deprecated function .. deprecated:: 1.5 Use `kmfGetUsage` instead. """
self.kmfGetUsage()
[docs] 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)))
[docs] 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)
[docs] 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)
[docs] @deprecation.deprecated.favour("deviceGetDiskSize") def getDiskSize(self): """Deprecated function .. deprecated:: 1.5 Use `deviceGetDiskSize` instead. """
self.deviceGetDiskSize()
[docs] def deviceGetDiskSize(self): diskSize = ct.c_uint32() self.dll.kvmDeviceDiskSize(self.handle, ct.byref(diskSize))
return int((diskSize.value * 512) / (1000 * 1000))
[docs] def logFileGetStartTime(self): startTime = ct.c_uint32() self.dll.kvmLogFileGetStartTime(self.handle, ct.byref(startTime))
return datetime.datetime.fromtimestamp(startTime.value)
[docs] @deprecation.deprecated.favour("deviceGetRTC") def getRTC(self): """Deprecated function .. deprecated:: 1.5 Use `deviceGetRTC` instead. """
self.deviceGetRTC()
[docs] def deviceGetRTC(self): time = ct.c_ulong() self.dll.kvmDeviceGetRTC(self.handle, ct.byref(time))
return datetime.datetime.fromtimestamp(time.value)
[docs] @deprecation.deprecated.favour("deviceSetRTC") def setRTC(self, timestamp): """Deprecated function .. deprecated:: 1.5 Use `deviceSetRTC` instead. """
self.deviceSetRTC(timestamp)
[docs] def deviceSetRTC(self, timestamp): unixTime = ct.c_ulong(int(time.mktime(timestamp.timetuple())))
self.dll.kvmDeviceSetRTC(self.handle, unixTime)
[docs] @deprecation.deprecated.favour("deviceGetDiskStatus") def isDiskPresent(self): """Deprecated function .. deprecated:: 1.5 Use `deviceGetDiskStatus` instead. """
self.deviceGetDiskStatus()
[docs] def deviceGetDiskStatus(self): present = ct.c_int(0) self.dll.kvmDeviceDiskStatus(self.handle, ct.byref(present))
return not(present.value == 0)
[docs] @deprecation.deprecated.favour("logFileGetCount") def getLogFileCount(self): """Deprecated function .. deprecated:: 1.5 Use `logFileGetCount` instead. """
self.logFileGetCount()
[docs] def logFileGetCount(self): fileCount = ct.c_uint32() self.dll.kvmLogFileGetCount(self.handle, ct.byref(fileCount))
return fileCount.value
[docs] @deprecation.deprecated.favour("deviceGetSerialNumber") def getSerialNumber(self): """Deprecated function .. deprecated:: 1.5 Use `deviceGetSerialNumber` instead. """
self.deviceGetSerialNumber()
[docs] def deviceGetSerialNumber(self): serial = ct.c_uint() self.dll.kvmDeviceGetSerialNumber(self.handle, ct.byref(serial))
return serial.value
[docs] @deprecation.deprecated.favour("logFileDismount") def logCloseFile(self): """Deprecated function .. deprecated:: 1.5 Use `logFileDismount` instead. """
self.logFileDismount()
[docs] def logFileDismount(self): self.dll.kvmLogFileDismount(self.handle) self.logFileIndex = None
self.eventCount = 0
[docs] @deprecation.deprecated.favour("logFileMount") def logOpenFile(self, fileIndx): """Deprecated function .. deprecated:: 1.5 Use `logFileMount` instead. """
self.logFileMount(fileIndx)
[docs] 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
[docs] @deprecation.deprecated.favour("logFileReadEvent") def logReadEventEx(self): """Deprecated function .. deprecated:: 1.5 Use `logFileReadEvent` instead. """
self.logFileReadEvent()
[docs] def logFileReadEvent(self): logevent = memoLogEventEx() try: self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent)) except (KvmNoLogMsg): return None memoEvent = logevent.createMemoEvent()
return memoEvent
[docs] def logFileReadEventLogFormat(self): logevent = memoLogEventEx() try: self.dll.kvmLogFileReadEvent(self.handle, ct.byref(logevent)) except (KvmNoLogMsg): return None
return logevent
[docs] def kmeReadEvent(self): logevent = memoLogEventEx() try: self.dll.kvmKmeReadEvent(self.kmeHandle, ct.byref(logevent)) except (KvmNoLogMsg): return None memoEvent = logevent.createMemoEvent()
return memoEvent
[docs] def kmeReadEventLogFormat(self): logevent = memoLogEventEx() try: self.dll.kvmKmeReadEvent(self.kmeHandle, ct.byref(logevent)) except (KvmNoLogMsg): return None
return logevent
[docs] def kmeWriteEvent(self, logevent):
self.dll.kvmKmeWriteEvent(self.kmeHandle, ct.byref(logevent))
[docs] @deprecation.deprecated.favour("logFileReadEvents") def readEvents(self): """Deprecated function .. deprecated:: 1.5 Use `logFileReadEvents` instead. """
return self.logFileReadEvents()
[docs] @deprecation.deprecated.favour("logFileReadEvents") def logReadEvents(self): """Deprecated function .. deprecated:: 1.5 Use `logFileReadEvents` instead. """
self.logFileReadEvents()
[docs] def logFileReadEvents(self): while True: event = self.logFileReadEvent() if event is None: break self.events.append(event)
return self.events
[docs] @deprecation.deprecated.favour("kmfValidate") def validateDisk(self, fix=0): """Deprecated function .. deprecated:: 1.5 Use `kmfValidate` instead. """
self.kmfValidate(fix)
[docs] def kmfValidate(self, fix=0):
self.dll.kvmKmfValidate(self.handle)
[docs] @deprecation.deprecated.favour("kmfWriteConfig") def writeConfigLif(self, lifData): """writeConfig .. deprecated:: 1.5 Use `kmfWriteConfig` instead. """
self.kmfWriteConfig(lifData)
[docs] def kmfWriteConfig(self, lifData): buf = ct.create_string_buffer(lifData)
self.dll.kvmKmfWriteConfig(self.handle, ct.byref(buf), len(lifData))
[docs] def logFileDeleteAll(self):
self.dll.kvmLogFileDeleteAll(self.handle)
[docs] def writeConfig(self, config):
self.kmfWriteConfig(config.toLif())
[docs] @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)
[docs] def deviceFormatDisk(self, reserveSpace=10, dbaseSpace=2, fat32=True): return self.dll.kvmDeviceFormatDisk(self.handle, fat32, reserveSpace,
dbaseSpace)
[docs] @deprecation.deprecated.favour("close") def closeDevice(self): """Deprecated function .. deprecated:: 1.5 Use `close` instead. """
self.close()
[docs] def close(self): self.dll.kvmClose(self.handle)
self.handle = None
[docs] 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)
[docs] 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
[docs] 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)
[docs] def kmeCountEvents(self): eventCount = ct.c_uint32(0) self.dll.kvmKmeCountEvents(self.kmeHandle, ct.byref(eventCount))
return eventCount.value
[docs] def kmeCloseFile(self): self.dll.kvmKmeCloseFile(self.kmeHandle)
self.kmeHandle = None