Skip to content

Commit 581debd

Browse files
jsouterjsouter
committed
use snake_case in CanVendorSystec
1 parent 67de368 commit 581debd

2 files changed

Lines changed: 88 additions & 86 deletions

File tree

‎src/include/CanVendorSystec.h‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -32,12 +32,12 @@ struct CanVendorSystec : CanDevice {
3232
static DWORD WINAPI SystecRxThread(LPVOID pCanVendorSystec);
3333

3434
private:
35-
bool m_CanScanThreadShutdownFlag = true;
35+
bool m_receive_thread_flag = true;
3636
tUcanHandle m_UcanHandle;
37-
int m_moduleNumber;
38-
int m_channelNumber;
39-
HANDLE m_hReceiveThread;
40-
DWORD m_idReceiveThread;
37+
int m_module_number;
38+
int m_channel_number;
39+
HANDLE m_receive_thread_handle;
40+
DWORD m_receive_thread_id;
4141
CanReturnCode vendor_open() noexcept override;
4242
CanReturnCode vendor_close() noexcept override;
4343
CanReturnCode vendor_send(const CanFrame& frame) noexcept override;
@@ -46,11 +46,11 @@ struct CanVendorSystec : CanDevice {
4646
CanReturnCode init_can_port();
4747
static std::mutex m_handles_lock;
4848

49-
inline void map_module_to_handle(int module, tUcanHandle handle) { m_handleMap[module] = handle; }
50-
inline int erase_module_handle(int module) { return m_handleMap.erase(module); }
49+
inline void map_module_to_handle(int module, tUcanHandle handle) { m_handle_map[module] = handle; }
50+
inline int erase_module_handle(int module) { return m_handle_map.erase(module); }
5151

5252
// TODO i don't like this too much
53-
inline static std::unordered_map<int, tUcanHandle> m_handleMap = {};
53+
inline static std::unordered_map<int, tUcanHandle> m_handle_map = {};
5454
};
5555

5656
#endif // SRC_INCLUDE_CANVENDORSYSTEC_H_

‎src/main/CanVendorSystec.cpp‎

Lines changed: 80 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -39,65 +39,66 @@ CanVendorSystec::CanVendorSystec(const CanDeviceArguments& args)
3939
}
4040

4141
// TODO trim possible can prefix use hardcoded value
42-
int handleNumber = std::stoi(args.config.bus_name.value());
43-
m_moduleNumber = handleNumber / 2;
44-
m_channelNumber = handleNumber % 2;
42+
int handle_number = std::stoi(args.config.bus_name.value());
43+
m_module_number = handle_number / 2;
44+
m_channel_number = handle_number % 2;
4545
}
4646

4747
// TODO should we make this noexcept? how can we guarantee that?
4848
CanReturnCode CanVendorSystec::init_can_port() {
49-
BYTE systecCallReturn = USBCAN_SUCCESSFUL;
50-
tUcanHandle canModuleHandle;
49+
BYTE systec_call_return = USBCAN_SUCCESSFUL;
50+
tUcanHandle can_module_handle;
5151

52-
unsigned int baudRate = USBCAN_BAUD_125kBit;
52+
unsigned int baud_rate = USBCAN_BAUD_125kBit;
5353
switch (args().config.bitrate.value_or(0)) {
54-
case 50000: baudRate = USBCAN_BAUD_50kBit; break;
55-
case 100000: baudRate = USBCAN_BAUD_100kBit; break;
56-
case 125000: baudRate = USBCAN_BAUD_125kBit; break;
57-
case 250000: baudRate = USBCAN_BAUD_250kBit; break;
58-
case 500000: baudRate = USBCAN_BAUD_500kBit; break;
59-
case 1000000: baudRate = USBCAN_BAUD_1MBit; break;
54+
case 50000: baud_rate = USBCAN_BAUD_50kBit; break;
55+
case 100000: baud_rate = USBCAN_BAUD_100kBit; break;
56+
case 125000: baud_rate = USBCAN_BAUD_125kBit; break;
57+
case 250000: baud_rate = USBCAN_BAUD_250kBit; break;
58+
case 500000: baud_rate = USBCAN_BAUD_500kBit; break;
59+
case 1000000: baud_rate = USBCAN_BAUD_1MBit; break;
6060
default: {
61-
LOG(Log::WRN, CanLogIt::h()) << "baud rate illegal, taking default 125000 [" << baudRate << "]";
61+
LOG(Log::WRN, CanLogIt::h()) << "baud rate illegal, taking default 125000 [" << baud_rate << "]";
6262
}
6363
}
6464

65+
tUcanInitCanParam initialization_parameters;
66+
initialization_parameters.m_dwSize = sizeof(initialization_parameters); // size of this struct
67+
initialization_parameters.m_bMode = kUcanModeNormal; // normal operation mode
68+
initialization_parameters.m_bBTR0 = HIBYTE( baud_rate ); // baudrate
69+
initialization_parameters.m_bBTR1 = LOBYTE( baud_rate );
70+
initialization_parameters.m_bOCR = 0x1A; // standard output
71+
initialization_parameters.m_dwAMR = USBCAN_AMR_ALL; // receive all CAN messages
72+
initialization_parameters.m_dwACR = USBCAN_ACR_ALL;
73+
initialization_parameters.m_dwBaudrate = USBCAN_BAUDEX_USE_BTR01;
74+
initialization_parameters.m_wNrOfRxBufferEntries = USBCAN_DEFAULT_BUFFER_ENTRIES;
75+
initialization_parameters.m_wNrOfTxBufferEntries = USBCAN_DEFAULT_BUFFER_ENTRIES;
76+
6577
// check if USB-CANmodul already is initialized
6678
std::lock_guard<std::mutex> guard(CanVendorSystec::m_handles_lock);
67-
auto pos = m_handleMap.find(m_moduleNumber);
68-
if (pos == m_handleMap.end()) { // module not in use
69-
systecCallReturn = ::UcanInitHardwareEx(&canModuleHandle, m_moduleNumber, 0, 0);
70-
if (systecCallReturn != USBCAN_SUCCESSFUL ) {
71-
LOG(Log::ERR, CanLogIt::h()) << "UcanInitHardwareEx, return code = [ 0x" << std::hex << (int) systecCallReturn << std::dec << "]";
72-
::UcanDeinitHardware(canModuleHandle);
79+
auto pos = m_handle_map.find(m_module_number);
80+
if (pos == m_handle_map.end()) { // module not in use
81+
systec_call_return = ::UcanInitHardwareEx(&can_module_handle, m_module_number, 0, 0);
82+
if (systec_call_return != USBCAN_SUCCESSFUL ) {
83+
LOG(Log::ERR, CanLogIt::h()) << "UcanInitHardwareEx, return code = [ 0x" << std::hex << (int) systec_call_return << std::dec << "]";
84+
::UcanDeinitHardware(can_module_handle);
7385
return CanReturnCode::unknown_open_error;
7486
}
75-
map_module_to_handle(m_moduleNumber, canModuleHandle);
87+
map_module_to_handle(m_module_number, can_module_handle);
7688
} else { // find existing handle of module
77-
canModuleHandle = pos->second;
89+
can_module_handle = pos->second;
7890
LOG(Log::WRN, CanLogIt::h()) << "trying to open a can port which is in use, reuse handle, skipping UCanDeinitHardware";
7991
}
80-
tUcanInitCanParam initializationParameters;
81-
initializationParameters.m_dwSize = sizeof(initializationParameters); // size of this struct
82-
initializationParameters.m_bMode = kUcanModeNormal; // normal operation mode
83-
initializationParameters.m_bBTR0 = HIBYTE( baudRate ); // baudrate
84-
initializationParameters.m_bBTR1 = LOBYTE( baudRate );
85-
initializationParameters.m_bOCR = 0x1A; // standard output
86-
initializationParameters.m_dwAMR = USBCAN_AMR_ALL; // receive all CAN messages
87-
initializationParameters.m_dwACR = USBCAN_ACR_ALL;
88-
initializationParameters.m_dwBaudrate = USBCAN_BAUDEX_USE_BTR01;
89-
initializationParameters.m_wNrOfRxBufferEntries = USBCAN_DEFAULT_BUFFER_ENTRIES;
90-
initializationParameters.m_wNrOfTxBufferEntries = USBCAN_DEFAULT_BUFFER_ENTRIES;
91-
92-
systecCallReturn = ::UcanInitCanEx2(canModuleHandle, m_channelNumber, &initializationParameters);
93-
if ( systecCallReturn != USBCAN_SUCCESSFUL ) {
94-
LOG(Log::ERR, CanLogIt::h()) << "UcanInitCanEx2, return code = [ 0x" << std::hex << (int) systecCallReturn << std::dec << "]";
95-
::UcanDeinitCanEx(canModuleHandle, m_channelNumber);
92+
93+
systec_call_return = ::UcanInitCanEx2(can_module_handle, m_channel_number, &initialization_parameters);
94+
if ( systec_call_return != USBCAN_SUCCESSFUL ) {
95+
LOG(Log::ERR, CanLogIt::h()) << "UcanInitCanEx2, return code = [ 0x" << std::hex << (int) systec_call_return << std::dec << "]";
96+
::UcanDeinitCanEx(can_module_handle, m_channel_number);
9697
return CanReturnCode::unknown_open_error;
9798
}
9899

99-
m_UcanHandle = canModuleHandle;
100-
LOG(Log::INF, CanLogIt::h()) << "Successfully opened CAN port on module " << m_moduleNumber << ", channel " << m_channelNumber;
100+
m_UcanHandle = can_module_handle;
101+
LOG(Log::INF, CanLogIt::h()) << "Successfully opened CAN port on module " << m_module_number << ", channel " << m_channel_number;
101102
return CanReturnCode::success;
102103
}
103104

@@ -110,9 +111,10 @@ CanReturnCode CanVendorSystec::vendor_open() noexcept {
110111
// m_statistics.setTimeSinceOpened();
111112

112113
// After the canboard is configured and started, we start the scan control thread
113-
m_hReceiveThread = CreateThread(NULL, 0, SystecRxThread, this, 0, &m_idReceiveThread);
114+
m_receive_thread_flag = true;
115+
m_receive_thread_handle = CreateThread(NULL, 0, SystecRxThread, this, 0, &m_receive_thread_id);
114116

115-
if (NULL == m_hReceiveThread) {
117+
if (NULL == m_receive_thread_handle) {
116118
LOG(Log::ERR, CanLogIt::h()) << "Error creating the canScanControl thread.";
117119
return CanReturnCode::internal_api_error;
118120
}
@@ -123,10 +125,10 @@ CanReturnCode CanVendorSystec::vendor_open() noexcept {
123125
CanReturnCode CanVendorSystec::vendor_close() noexcept {
124126
// TODO what if the return code is not success?
125127
std::lock_guard<std::mutex> guard(CanVendorSystec::m_handles_lock);
126-
erase_module_handle(m_moduleNumber);
127-
m_CanScanThreadShutdownFlag = false;
128-
DWORD result = WaitForSingleObject(m_hReceiveThread, INFINITE); //Shut down can scan thread
129-
UcanDeinitCanEx (m_UcanHandle, (BYTE)m_channelNumber);
128+
erase_module_handle(m_module_number);
129+
m_receive_thread_flag = false;
130+
DWORD result = WaitForSingleObject(m_receive_thread_handle, INFINITE); //Shut down can scan thread
131+
UcanDeinitCanEx (m_UcanHandle, (BYTE)m_channel_number);
130132
LOG(Log::DBG, CanLogIt::h()) << __FUNCTION__ << " closed successfully";
131133
return CanReturnCode::success;
132134
};
@@ -140,31 +142,31 @@ CanReturnCode CanVendorSystec::vendor_send(const CanFrame& frame) noexcept {
140142

141143
LOG(Log::DBG, CanLogIt::h()) << "Sending message: [" << ( message == 0 ? "" : (const char *) message) << "], cobID: [" << cobID << "], Message Length: [" << static_cast<int>(len) << "]";
142144

143-
tCanMsgStruct canMsgToBeSent;
145+
tCanMsgStruct can_msg_to_send;
144146
BYTE Status;
145147

146-
canMsgToBeSent.m_dwID = cobID;
147-
canMsgToBeSent.m_bDLC = len;
148-
canMsgToBeSent.m_bFF = 0;
148+
can_msg_to_send.m_dwID = cobID;
149+
can_msg_to_send.m_bDLC = len;
150+
can_msg_to_send.m_bFF = 0;
149151
if (rtr) {
150-
canMsgToBeSent.m_bFF = USBCAN_MSG_FF_RTR;
152+
can_msg_to_send.m_bFF = USBCAN_MSG_FF_RTR;
151153
}
152-
int messageLengthToBeProcessed;
154+
int message_length_to_process;
153155
//If there is more than 8 characters to process, we process 8 of them in this iteration of the loop
154156
if (len > 8) {
155-
messageLengthToBeProcessed = 8;
157+
message_length_to_process = 8;
156158
LOG(Log::DBG, CanLogIt::h()) << "The length is more then 8 bytes, adjust to 8, ignore >8. len= " << len;
157159
} else {
158160
//Otherwise if there is less than 8 characters to process, we process all of them in this iteration of the loop
159-
messageLengthToBeProcessed = len;
161+
message_length_to_process = len;
160162
if (len < 8) {
161163
LOG(Log::DBG, CanLogIt::h())<< "The length is less then 8 bytes, process only. len= " << len;
162164
}
163165
}
164-
canMsgToBeSent.m_bDLC = messageLengthToBeProcessed;
165-
memcpy(canMsgToBeSent.m_bData, message, messageLengthToBeProcessed);
166-
// MLOG(TRC,this) << "Channel Number: [" << m_channelNumber << "], cobID: [" << canMsgToBeSent.m_dwID << "], Message Length: [" << static_cast<int>(canMsgToBeSent.m_bDLC) << "]";
167-
Status = UcanWriteCanMsgEx(m_UcanHandle, m_channelNumber, &canMsgToBeSent, NULL);
166+
can_msg_to_send.m_bDLC = message_length_to_process;
167+
memcpy(can_msg_to_send.m_bData, message, message_length_to_process);
168+
// MLOG(TRC,this) << "Channel Number: [" << m_channel_number << "], cobID: [" << can_msg_to_send.m_dwID << "], Message Length: [" << static_cast<int>(can_msg_to_send.m_bDLC) << "]";
169+
Status = UcanWriteCanMsgEx(m_UcanHandle, m_channel_number, &can_msg_to_send, NULL);
168170
if (Status != USBCAN_SUCCESSFUL) {
169171
LOG(Log::ERR, CanLogIt::h()) << "There was a problem when sending a message.";
170172

@@ -185,7 +187,7 @@ CanReturnCode CanVendorSystec::vendor_send(const CanFrame& frame) noexcept {
185187
case USBCAN_WARN_TXLIMIT:
186188
default: return CanReturnCode::unknown_send_error;
187189
}
188-
// m_statistics.onTransmit( canMsgToBeSent.m_bDLC );
190+
// m_statistics.onTransmit( can_msg_to_send.m_bDLC );
189191
// m_statistics.setTimeSinceTransmitted();
190192
}
191193
return CanReturnCode::success;
@@ -197,7 +199,7 @@ CanDiagnostics CanVendorSystec::vendor_diagnostics() noexcept {
197199
CanDiagnostics diagnostics{};
198200
tStatusStruct status;
199201
// TODO check return code of these functions...
200-
UcanGetStatusEx(m_UcanHandle, m_channelNumber, &status);
202+
UcanGetStatusEx(m_UcanHandle, m_channel_number, &status);
201203
WORD can_status = status.m_wCanStatus;
202204
switch (can_status) {
203205
case USBCAN_CANERR_OK:
@@ -223,12 +225,12 @@ CanDiagnostics CanVendorSystec::vendor_diagnostics() noexcept {
223225
}
224226

225227
tUcanMsgCountInfo msg_count_info;
226-
UcanGetMsgCountInfoEx(m_UcanHandle, m_channelNumber, &msg_count_info);
228+
UcanGetMsgCountInfoEx(m_UcanHandle, m_channel_number, &msg_count_info);
227229
diagnostics.tx = msg_count_info.m_wSentMsgCount;
228230
diagnostics.rx = msg_count_info.m_wRecvdMsgCount;
229231

230232
DWORD tx_error, rx_error;
231-
UcanGetCanErrorCounter(m_UcanHandle, m_channelNumber, &tx_error, &rx_error);
233+
UcanGetCanErrorCounter(m_UcanHandle, m_channel_number, &tx_error, &rx_error);
232234
diagnostics.tx_error = tx_error;
233235
diagnostics.rx_error = rx_error;
234236

@@ -250,37 +252,37 @@ CanDiagnostics CanVendorSystec::vendor_diagnostics() noexcept {
250252
return diagnostics;
251253
};
252254

253-
std::string UsbCanGetErrorText( long errCode ); // forward declaration
255+
std::string UsbCanGetErrorText( long err_code ); // forward declaration
254256

255257
/**
256258
* thread to handle reception of Can messages from the systec device
257259
*/
258260
DWORD WINAPI CanVendorSystec::SystecRxThread(LPVOID pCanVendorSystec)
259261
{
260262
BYTE status;
261-
tCanMsgStruct readCanMessage;
262-
CanVendorSystec *vendorPointer = reinterpret_cast<CanVendorSystec*>(pCanVendorSystec);
263-
LOG(Log::DBG, CanLogIt::h()) << "SystecRxThread Started. m_CanScanThreadShutdownFlag = [" << vendorPointer->m_CanScanThreadShutdownFlag <<"]";
264-
while (vendorPointer->m_CanScanThreadShutdownFlag) {
265-
status = UcanReadCanMsgEx(vendorPointer->m_UcanHandle, (BYTE *)&vendorPointer->m_channelNumber, &readCanMessage, NULL);
263+
tCanMsgStruct read_can_message;
264+
CanVendorSystec *vendor_pointer = reinterpret_cast<CanVendorSystec*>(pCanVendorSystec);
265+
LOG(Log::DBG, CanLogIt::h()) << "SystecRxThread Started. m_receive_thread_flag = [" << vendor_pointer->m_receive_thread_flag <<"]";
266+
while (vendor_pointer->m_receive_thread_flag) {
267+
status = UcanReadCanMsgEx(vendor_pointer->m_UcanHandle, (BYTE *)&vendor_pointer->m_channel_number, &read_can_message, NULL);
266268
switch (status) {
267269
case USBCAN_WARN_SYS_RXOVERRUN: // fallthrough intended for warnings
268270
case USBCAN_WARN_DLL_RXOVERRUN:
269271
case USBCAN_WARN_FW_RXOVERRUN:
270272
LOG(Log::WRN, CanLogIt::h()) << UsbCanGetErrorText(status);
271273
case USBCAN_SUCCESSFUL: {
272-
if (readCanMessage.m_bFF & USBCAN_MSG_FF_RTR) break;
273-
// canMsgCopy.c_time = convertTimepointToTimeval(currentTimeTimeval());
274-
std::vector<char> data(readCanMessage.m_bData, readCanMessage.m_bData + 8);
274+
if (read_can_message.m_bFF & USBCAN_MSG_FF_RTR) break;
275+
// can_msg_copy.c_time = convertTimepointToTimeval(currentTimeTimeval());
276+
std::vector<char> data(read_can_message.m_bData, read_can_message.m_bData + 8);
275277
// id, data, flags
276-
CanFrame canMsgCopy(readCanMessage.m_dwID, data, readCanMessage.m_bFF);
277-
// TODO the readCanMessage contains a DWORD m_dwTime "receipt time in ms"
278-
vendorPointer->received(canMsgCopy);
279-
// vendorPointer->m_statistics.onReceive( readCanMessage.m_bDLC );
280-
// vendorPointer->m_statistics.setTimeSinceReceived();
278+
CanFrame can_msg_copy(read_can_message.m_dwID, data, read_can_message.m_bFF);
279+
// TODO the read_can_message contains a DWORD m_dwTime "receipt time in ms"
280+
vendor_pointer->received(can_msg_copy);
281+
// vendor_pointer->m_statistics.onReceive( read_can_message.m_bDLC );
282+
// vendor_pointer->m_statistics.setTimeSinceReceived();
281283

282284
// we can reset the reconnectionTimeout here, since we have received a message
283-
// vendorPointer->resetTimeoutOnReception();
285+
// vendor_pointer->resetTimeoutOnReception();
284286
break;
285287
}
286288
case USBCAN_WARN_NODATA:
@@ -306,8 +308,8 @@ DWORD WINAPI CanVendorSystec::SystecRxThread(LPVOID pCanVendorSystec)
306308
* I am just copying the whole descriptions from the doc, verbatim, wtf.
307309
* you get some shakespeare from it.
308310
*/
309-
std::string UsbCanGetErrorText( long errCode ){
310-
switch( errCode ){
311+
std::string UsbCanGetErrorText( long err_code ){
312+
switch( err_code ){
311313
case USBCAN_SUCCESSFUL: return("success");
312314

313315
case USBCAN_ERR_RESOURCE: return ("This error code returns if one resource could not be generated. In this "

0 commit comments

Comments
 (0)