Bitrate calculation with CANtegrity

samples\example\c\kvdiag\autobaud.c

#include "stdio.h"
#include "signal.h"
#include "canlib.h"
#include "kvDiag.h"

static void check(const char *name, canStatus status); /* Checks for errors */
static void intHandler(int unused); /* Handle Ctrl-C */
static void usage(); /* Print usage */

static int interrupt = 0;

int main(int argc, char *argv[])
{
  int channel = -1;

  /* Parse command-line parameters. */
  for (int i=1; i<argc; i++) {
    if (sscanf(argv[i], "-ch=%d", &channel) == 1);
    else {
      usage();
      exit(1);
    }
  }

  if (channel == -1) {
    usage();
    exit(1);
  }

  canInitializeLibrary();

  canHandle hnd;
  /* We open the channel with the EXCLUSIVE flag to not let any other
   * application interfere with the CANtegrity channel */
  hnd = canOpenChannel(channel, canOPEN_EXCLUSIVE);

  canStatus stat;
  /* Attach an analyzer to an open CAN channel. */
  stat = kvDiagAttachAnalyzer(hnd, DIAG_ANALYZER_TYPE_DEFAULT);
  check("kvDiagAttachAnalyzer", stat);

  /* We want to run DIAG_PROGRAM_TYPE_AUTOBAUD. It doesn't need a configuration,
   * so we pass an empty JSON string. */
  stat = kvDiagSetProgram(hnd, DIAG_PROGRAM_TYPE_AUTOBAUD, "{}");
  check("kvDiagSetProgram", stat);

  /* Start the analyzer. */
  stat = kvDiagStart(hnd);
  check("kvDiagStart", stat);

  /* Continuously measure bitrate until Ctrl-C is pressed. */
  signal(SIGINT, intHandler);

  bitrates_t btrs;
  while (1) {
    Sleep(100); /* Wait for samples to accumulate. */
    stat = kvDiagCalculateBitrate(hnd, &btrs);
    if (stat == canOK) {
      printf("Estimated CAN bitrate to %.0f KBit/s with quality %d %%.\n",
             btrs.bitrate.bitrate, btrs.bitrate.quality);
    }
    /* Reset bitrate calculation to get a fresh measurement. */
    stat = kvDiagResetBitrateCalculation(hnd);
    check("kvDiagResetBitrateCalculation", stat);

    /* Check Ctrl-C. */
    if (interrupt) {
      break;
    }
  }

  /* Stop the analyzer. */
  stat = kvDiagStop(hnd);
  check("kvDiagStop", stat);

  /* Detach the analyzer, since we're not going to restart it. */
  stat = kvDiagDetachAnalyzer(hnd);
  check("kvDiagDetachAnalyzer", stat);

  /* Close the CAN channel. */
  stat = canClose(hnd);
  check("canClose", stat);
  return 0;
}

static void check(const char *name, canStatus status)
{
  if (status != canOK) {
    printf("%s returned %d\n", name, status);
    exit(1);
  }
}

static void intHandler(int unused)
{
  interrupt = 1;
}

static void usage()
{
  printf(
    "Usage: 'autobaud_example -ch=n', "
    "where 'n' is a CANlib channel with analyzer capability.\n\n"
    "Note: This program requires a working CAN bus with traffic to function properly.\n");
}