メインコンテンツまでスキップ

G++版 CANモニタプログラム

動作環境構築​

カレントディレクトリをソースコードと同じディレクトリにして make を実行してください。
ビルドが正常に完了すると、実行ファイル mpx_canfd_monsample が生成されます。

動作仕様​

項目説明
CH1モニタモードで動作します。
100msごとにMPXGetLogを呼び出してログを取得し、コンソールに表示します。
CH2未使用

ログ表示内容詳細​

項目説明
Timeタイムスタンプを表示します。
ProtocolCANプロトコル(CANまたはCAN FD)を表示します。
Dir.ログ方向を表示します。
Rx:受信ログ Tx:送信ログ
IDIDフォーマット(意味合いは下記参照)とCAN ID(16進数)を表示します。
Std:標準ID Ext:拡張ID
DLデータ長(0~64)を表示します。
Dataデータ(D1~D64)を16進数で表示します。データの区切り文字はスペースです。

サンプルソースコード​

対応元: MPXCtrl_CANFD_MonSample/mpx_canfd_monsample.c

#include "MPXCtrlFree.h"
#include "stdio.h"
#include "unistd.h"
#include <chrono>
#include <deque>
#include <iostream>
#include <pthread.h>
#include <sstream>
#include <stdint.h>
#include <string.h>
#include <thread>

// グローバル
uint32_t serial;
StMPXCANSlot MPXCANSlot[2];

// 表示文字列
std::deque<std::string> print_que;

void DispMonitor(void);

pthread_mutex_t que_mutex;
std::string strbuf;

void *thread_routine(void *data) {
while (1) {
usleep(1000 * 5); // wait1ms
pthread_mutex_lock(&que_mutex);
if (!print_que.empty()) {
strbuf = print_que.front();
print_que.pop_front(); // 先頭要素を削除
std::cout << strbuf; // バッファを表示
}
pthread_mutex_unlock(&que_mutex);
pthread_testcancel();
}
return 0;
}

int main() {
ER ret;
uint32_t MSec;
uint16_t USec;

pthread_t print_thread;

printf("CAN FD Monitor Sample Start\n");

/* ADLバージョン取得 */
StMPXAPIVersion apiVersion;
MPXGetAPIVersion(&apiVersion);
printf("API Version : [%s]\n", apiVersion.APIVersion);

/* MicroPeckerXオープン */
StMPXDeviceInfo devices[4];
uint8_t count;

ret = MPXOpen(devices, 4, &count);
if (ret != E_OK) {
printf("MPXOpen : error[%d]\n", ret);
return 1;
} else if (count == 0) {
printf("MPXOpen : no devices\n");
return 1;
} else {
/* シリアル番号 */
serial = devices[0].Serial;
/* LED消灯 */
MPXSetLED(serial, MPX_LED_OFF, MPX_LED_OFF, MPX_LED_OFF, MPX_LED_OFF, MPX_LED_OFF);
}

for (int i = 0; i < count; i++) {
printf("Serial %d: [%d]\n", i, devices[i].Serial);
}

/* CAN FD通信パラメータ設定(CH1) */
StMPXCANParam param1;
memset(&param1, '\0', sizeof(param1));
param1.Mode = MPX_CAN_MODE_MONITOR; /* モニタモード(ACKあり) */
param1.ArbitrationBaudrate = MPX_CAN_PARAM_ABR_500K;
param1.ArbitrationSamplepoint = MPX_CAN_PARAM_SP_80P;
param1.DataBaudrate = MPX_CAN_PARAM_DBR_2M;
param1.DataSamplepoint = MPX_CAN_PARAM_SP_80P;
param1.EnableTerminate = MPX_CAN_TERMINATE_ENABLE; // 終端有効

ret = MPXCANSetParam(serial, 1, &param1);
if (ret != E_OK) {
printf("\n MPXCANSetParam 1 : error[%d]\n", ret);
return -1;
}

/* CAN FD通信パラメータ設定(CH2) */
StMPXCANParam param2;
memset(&param2, '\0', sizeof(param2));
param2 = param1;
param2.Mode = MPX_LIN_MODE_NONE; /* 動作なし */
// モード以外はCH1と同じ

ret = MPXCANSetParam(serial, 2, &param2);
if (ret != E_OK) {
printf("\n MPXCANSetParam 2 : error[%d]\n", ret);
return -1;
}

printf("\n Monitor Start ...\n");
/* モニタリング開始 */
ret = MPXMonitorStart(serial, MPX_SYNC_MASTER);
if (ret != E_OK) {
printf("\n Monitor Start : error[%d]\n", ret);
return -1;
}

int pth_arg;
// 表示スレッド起動
pthread_mutex_init(&que_mutex, NULL);
if (pthread_create(&print_thread, NULL, thread_routine, (void *)&pth_arg) != 0) {
perror("pthread_create\n");
return 1;
}

/* モニタリング */
for (int i = 0; i < 200; i++) {
/* usleep (コメントアウト中):
ソフトウェア制御では周期送信間隔を正確に維持できない
(スケジューリングにより設定したSleep時間より多くの時間を待たされる) */
// usleep(50)
std::this_thread::sleep_for(std::chrono::milliseconds(100));

DispMonitor();
}

ret = MPXMonitorStop(serial, &MSec, &USec);
if (ret != E_OK) {
printf("MPXMonitorStop : error[%d]\n", ret);
return -1;
}
printf("\n Monitor Stop ...\n");

pthread_mutex_lock(&que_mutex);
print_que.clear();
pthread_mutex_unlock(&que_mutex);

usleep(100 * 1000); // wait100ms

pthread_cancel(print_thread);
pthread_join(print_thread, NULL);

// 表示用キューを削除
if (!print_que.empty())
print_que.clear();

MPXClose();
printf("MPXClose\n");
printf("CAN FD Monitor Sample End\n");

return 0;
}

void DispMonitor(void) {
/* モニタログ取得 */
uint16_t Count;
uint8_t BufferOver;

ER ret;
StMPXLog *MPXLog;
std::stringstream dispTmp;

ret = MPXGetLog(serial, 1, &MPXLog, &Count, &BufferOver);

if (ret != E_OK) {
printf("MPXGetLog : error[%d]\n", ret);
return;
}
/* ログ表示 */
for (int i = 0; i < (int)Count; i++) {

// 空ログ無視
if (MPXLog[i].Protocol == MPX_LOG_TYPE_EMPTY) {
continue;
}
/* エラーチェック */
if (MPXLog[i].Misc.CAN.Error == MPX_CAN_ERRFLG_FALSE) {
/* 時間 */
dispTmp << "Time : " << std::dec << (int)MPXLog[i].mSec << "[ms] " << (int)MPXLog[i].uSec << "[us] , ";

/* プロトコル */
dispTmp << "Protocol : ";
if (MPXLog[i].Protocol == MPX_LOG_TYPE_CANFD) {
dispTmp << "CAN FD , ";
} else if (MPXLog[i].Protocol == MPX_LOG_TYPE_CANFD_NOBRS) {
dispTmp << "CAN FD (NO BRS) , ";
} else {
dispTmp << "CAN , ";
}

/* 方向 */
dispTmp << "Dir. : ";
if (MPXLog[i].Dir == MPX_LOG_DIR_RX) {
dispTmp << "Rx , ";
} else {
dispTmp << "Tx , ";
}

/* IDフォーマット */
if (MPXLog[i].Misc.CAN.IDE == MPX_CAN_IDE_STD) {
dispTmp << "ID : Std ";
} else {
dispTmp << "ID : Ext ";
}

/* ID */
dispTmp << std::hex << (int)MPXLog[i].Misc.CAN.ID << " , ";

/* DL */
dispTmp << "DL : " << std::dec << (int)MPXLog[i].Misc.CAN.DL << " , ";

/* Data */
dispTmp << "Data : ";
for (int j = 0; j < MPXLog[i].Misc.CAN.DL; j++) {
dispTmp << std::hex << (int)MPXLog[i].Data[j] << " ";
}
dispTmp << "\n";
} else {
if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_BUS) {
dispTmp << "ERROR : Bus Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_WARN) {
dispTmp << "ERROR : Err. Warning\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_PASV) {
dispTmp << "ERROR : Err. Passive\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_BUSOFF) {
dispTmp << "ERROR : Bus Off Entry\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_BUSWAKE) {
dispTmp << "ERROR : Bus Off Recovery\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_OVERLOAD) {
dispTmp << "ERROR : Overload Frame Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_BUSLOCK) {
dispTmp << "ERROR : Channel Bus Lock\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_ARBLOST) {
dispTmp << "ERROR : Arbitration Lost\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_STAFF) {
dispTmp << "ERROR : Stuff Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_FORM) {
dispTmp << "ERROR : Form Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_ACK) {
dispTmp << "ERROR : ACK Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_CRC) {
dispTmp << "ERROR : CRC Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_RECEIVE) {
dispTmp << "ERROR : Recessive Bit Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_DOMINANT) {
dispTmp << "ERROR : Dominant Err.\n";
} else if (MPXLog[i].Misc.CAN.ErrorInfo & MPX_CAN_ERR_DELIMITER) {
dispTmp << "ERROR : ACK Delimiter Err.\n";
}
}
}
pthread_mutex_lock(&que_mutex);
print_que.push_back(dispTmp.str());
pthread_mutex_unlock(&que_mutex);
}