--- /dev/null
+/* can-calc-bit-timing.c: Calculate CAN bit timing parameters
+ *
+ * Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
+ *
+ * Derived from:
+ * can_baud.c - CAN baudrate calculation
+ * Code based on LinCAN sources and H8S2638 project
+ * Copyright 2004-2006 Pavel Pisa - DCE FELK CVUT cz
+ * Copyright 2005 Stanislav Marek
+ * email:pisa@cmp.felk.cvut.cz
+ *
+ * This software is released under the GPL-License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <getopt.h>
+
+#define do_div(a,b) a = (a) / (b)
+
+static void print_usage(char* cmd)
+{
+ printf("Usage: %s [options] [<CAN-contoller-name>]\n"
+ "\tOptions:\n"
+ "\t-q : don't print header line\n"
+ "\t-l : list all support CAN controller names\n"
+ "\t-b <bitrate> : bit-rate in bits/sec\n"
+ "\t-s <samp_pt> : sample-point in one-tenth of a percent\n"
+ "\t or 0 for CIA recommended sample points\n"
+ "\t-c <clock> : real CAN system clock in Hz\n",
+ cmd);
+
+ exit(1);
+}
+
+struct can_bittime {
+ uint32_t brp;
+ uint8_t prop_seg;
+ uint8_t phase_seg1;
+ uint8_t phase_seg2;
+ uint8_t sjw;
+ uint32_t tq;
+ uint32_t error;
+ int sampl_pt;
+};
+
+struct can_bittiming_const {
+ char name[32];
+ int prop_seg_min;
+ int prop_seg_max;
+ int phase_seg1_min;
+ int phase_seg1_max;
+ int phase_seg2_min;
+ int phase_seg2_max;
+ int sjw_max;
+ int brp_min;
+ int brp_max;
+ int brp_inc;
+ void (*printf_btr)(struct can_bittime *bt, int hdr);
+};
+
+static void printf_btr_sja1000(struct can_bittime *bt, int hdr)
+{
+ uint8_t btr0, btr1;
+
+ if (hdr) {
+ printf("BTR0 BTR1");
+ } else {
+ btr0 = ((bt->brp - 1) & 0x3f) | (((bt->sjw - 1) & 0x3) << 6);
+ btr1 = ((bt->prop_seg + bt->phase_seg1 - 1) & 0xf) |
+ (((bt->phase_seg2 - 1) & 0x7) << 4);
+ printf("0x%02x 0x%02x", btr0, btr1);
+ }
+}
+
+static void printf_btr_at91(struct can_bittime *bt, int hdr)
+{
+ if (hdr) {
+ printf("CAN_BR");
+ } else {
+ uint32_t br = ((bt->phase_seg2 - 1) |
+ ((bt->phase_seg1 - 1) << 4) |
+ ((bt->prop_seg - 1) << 8) |
+ ((bt->sjw - 1) << 12) |
+ ((bt->brp - 1) << 16));
+ printf("0x%08x", br);
+ }
+}
+
+static void printf_btr_mcp2510(struct can_bittime *bt, int hdr)
+{
+ uint8_t cnf1, cnf2, cnf3;
+
+ if (hdr) {
+ printf("CNF1 CNF2 CNF3");
+ } else {
+ cnf1 = ((bt->sjw - 1) << 6) | bt->brp;
+ cnf2 = 0x80 | ((bt->phase_seg1 - 1) << 3) | (bt->prop_seg - 1);
+ cnf3 = bt->phase_seg2 - 1;
+ printf("0x%02x 0x%02x 0x%02x", cnf1, cnf2, cnf3);
+ }
+}
+
+static void printf_btr_rtcantl1(struct can_bittime *bt, int hdr)
+{
+ uint16_t bcr0, bcr1;
+
+ if (hdr) {
+ printf("__BCR0 __BCR1");
+ } else {
+ bcr1 = ((((bt->prop_seg + bt->phase_seg1 - 1) & 0x0F) << 12) |
+ (((bt->phase_seg2 - 1) & 0x07) << 8) |
+ (((bt->sjw - 1) & 0x03) << 4));
+ bcr0 = ((bt->brp - 1) & 0xFF);
+ printf("0x%04x 0x%04x", bcr0, bcr1);
+ }
+}
+
+struct can_bittiming_const can_calc_consts[] = {
+ {
+ "sja1000",
+ /* Note: only prop_seg + bt->phase_seg1 matters */
+ .phase_seg1_min = 1,
+ .phase_seg1_max = 16,
+ .phase_seg2_min = 1,
+ .phase_seg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 64,
+ .brp_inc = 1,
+ .printf_btr = printf_btr_sja1000,
+ },
+ {
+ "mscan",
+ /* Note: only prop_seg + bt->phase_seg1 matters */
+ .phase_seg1_min = 4,
+ .phase_seg1_max = 16,
+ .phase_seg2_min = 2,
+ .phase_seg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 64,
+ .brp_inc = 1,
+ .printf_btr = printf_btr_sja1000,
+ },
+ {
+ "at91",
+ .prop_seg_min = 1,
+ .prop_seg_max = 8,
+ .phase_seg1_min = 1,
+ .phase_seg1_max = 8,
+ .phase_seg2_min = 2,
+ .phase_seg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 128,
+ .brp_inc = 1,
+ .printf_btr = printf_btr_at91,
+ },
+ {
+ "mcp2510",
+ .prop_seg_min = 1,
+ .prop_seg_max = 8,
+ .phase_seg1_min = 1,
+ .phase_seg1_max = 8,
+ .phase_seg2_min = 2,
+ .phase_seg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 64,
+ .brp_inc = 1,
+ .printf_btr = printf_btr_mcp2510,
+ },
+ {
+ "rtcantl1",
+ .prop_seg_min = 2,
+ .prop_seg_max = 8,
+ .phase_seg1_min = 2,
+ .phase_seg1_max = 8,
+ .phase_seg2_min = 2,
+ .phase_seg2_max = 8,
+ .sjw_max = 4,
+ .brp_min = 1,
+ .brp_max = 256,
+ .brp_inc = 1,
+ .printf_btr = printf_btr_rtcantl1,
+ },
+};
+
+static long common_bitrates[] = {
+ 1000000,
+ 800000,
+ 500000,
+ 250000,
+ 125000,
+ 100000,
+ 50000,
+ 20000,
+ 10000
+};
+
+static int can_update_spt(const struct can_bittiming_const *btc,
+ int sampl_pt, int tseg, int *tseg1, int *tseg2)
+{
+ *tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000;
+ if (*tseg2 < btc->phase_seg2_min)
+ *tseg2 = btc->phase_seg2_min;
+ if (*tseg2 > btc->phase_seg2_max)
+ *tseg2 = btc->phase_seg2_max;
+ *tseg1 = tseg - *tseg2;
+ if (*tseg1 > btc->prop_seg_max + btc->phase_seg1_max) {
+ *tseg1 = btc->prop_seg_max + btc->phase_seg1_max;
+ *tseg2 = tseg - *tseg1;
+ }
+ return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
+}
+
+int can_calc_bittiming(struct can_bittime *bt, long bitrate,
+ int sampl_pt, long clock,
+ const struct can_bittiming_const *btc)
+{
+ long best_error = 1000000000, error;
+ int best_tseg = 0, best_brp = 0, brp = 0;
+ int spt_error = 1000, spt = 0;
+ long rate, best_rate = 0;
+ int tseg = 0, tseg1 = 0, tseg2 = 0;
+ uint64_t v64;
+
+ if (sampl_pt == 0) {
+ /* Use CIA recommended sample points */
+ if (bitrate > 800000)
+ sampl_pt = 750;
+ else if (bitrate > 500000)
+ sampl_pt = 800;
+ else
+ sampl_pt = 875;
+ }
+
+#ifdef DEBUG
+ printf("tseg brp bitrate biterror\n");
+#endif
+
+ /* tseg even = round down, odd = round up */
+ for (tseg = (btc->prop_seg_max + btc->phase_seg1_max +
+ btc->phase_seg2_max) * 2 + 1;
+ tseg >= (btc->prop_seg_min + btc->phase_seg1_min +
+ btc->phase_seg2_min) * 2; tseg--) {
+ /* Compute all posibilities of tseg choices (tseg=tseg1+tseg2) */
+ brp = clock / ((1 + tseg / 2) * bitrate) + tseg % 2;
+ /* chose brp step which is possible in system */
+ brp = (brp / btc->brp_inc) * btc->brp_inc;
+ if ((brp < btc->brp_min) || (brp > btc->brp_max))
+ continue;
+ rate = clock / (brp * (1 + tseg / 2));
+ error = bitrate - rate;
+ /* tseg brp biterror */
+#if DEBUG
+ printf("%4d %3d %7ld %8ld %03d\n", tseg, brp, rate, error,
+ can_update_spt(btc, sampl_pt, tseg / 2,
+ &tseg1, &tseg2));
+#endif
+ if (error < 0)
+ error = -error;
+ if (error > best_error)
+ continue;
+ best_error = error;
+ if (error == 0) {
+ spt = can_update_spt(btc, sampl_pt, tseg / 2,
+ &tseg1, &tseg2);
+ error = sampl_pt - spt;
+ //printf("%d %d %d\n", sampl_pt, error, spt_error);
+ if (error < 0)
+ error = -error;
+ if (error > spt_error)
+ continue;
+ spt_error = error;
+ //printf("%d\n", spt_error);
+ }
+ //printf("error=%d\n", best_error);
+ best_tseg = tseg / 2;
+ best_brp = brp;
+ best_rate = rate;
+ if (error == 0)
+ break;
+ }
+
+ if (best_error && (bitrate / best_error < 10))
+ return -1;
+
+ spt = can_update_spt(btc, sampl_pt, best_tseg,
+ &tseg1, &tseg2);
+
+ if (tseg2 > tseg1) {
+ /* sample point < 50% */
+ bt->phase_seg1 = tseg1 / 2;
+ } else {
+ /* keep phase_seg{1,2} equal around the sample point */
+ bt->phase_seg1 = tseg2;
+ }
+ bt->prop_seg = tseg1 - bt->phase_seg1;
+ /* Check prop_seg range if necessary */
+ if (btc->prop_seg_min || btc->prop_seg_max) {
+ if (bt->prop_seg < btc->prop_seg_min)
+ bt->prop_seg = btc->prop_seg_min;
+ else if (bt->prop_seg > btc->prop_seg_max)
+ bt->prop_seg = btc->prop_seg_max;
+ bt->phase_seg1 = tseg1 - bt->prop_seg;
+ }
+ bt->phase_seg2 = tseg2;
+ bt->sjw = 1;
+ bt->brp = best_brp;
+ bt->error = best_error;
+ bt->sampl_pt = spt;
+ v64 = (uint64_t)bt->brp * 1000000000UL;
+ v64 /= clock;
+ bt->tq = (int)v64;
+
+ return 0;
+}
+
+void print_bit_timing(const struct can_bittiming_const *btc,
+ long bitrate, int sampl_pt, long ref_clk, int quiet)
+{
+ struct can_bittime bt;
+
+ memset(&bt, 0, sizeof(bt));
+
+ if (!quiet) {
+ printf("Bit timing parameters for %s using %ldHz\n",
+ btc->name, ref_clk);
+ printf("Bitrate TQ[ns] PrS PhS1 PhS2 SJW BRP SampP Error ");
+ btc->printf_btr(&bt, 1);
+ printf("\n");
+ }
+
+ if (can_calc_bittiming(&bt, bitrate, sampl_pt, ref_clk, btc)) {
+ printf("%7ld ***bitrate not possible***\n", bitrate);
+ return;
+ }
+
+ printf("%7ld %6d %3d %4d %4d %3d %3d %2d.%d%% %4.1f%% ",
+ bitrate, bt.tq, bt.prop_seg, bt.phase_seg1,
+ bt.phase_seg2, bt.sjw, bt.brp,
+ bt.sampl_pt / 10, bt.sampl_pt % 10,
+ (double)100 * bt.error / bitrate);
+ btc->printf_btr(&bt, 0);
+ printf("\n");
+}
+
+int main(int argc, char *argv[])
+{
+ long bitrate = 0;
+ long ref_clk = 8000000;
+ int sampl_pt = 0;
+ int quiet = 0;
+ int list = 0;
+ char *name = NULL;
+ int i, opt;
+
+ const struct can_bittiming_const *btc = NULL;
+
+ while ((opt = getopt(argc, argv, "b:c:lps:")) != -1) {
+ switch (opt) {
+ case 'b':
+ bitrate = atoi(optarg);
+ break;
+
+ case 'c':
+ ref_clk = atoi(optarg);
+ break;
+
+ case 'l':
+ list = 1;
+ break;
+
+ case 'q':
+ quiet = 1;
+ break;
+
+ case 's':
+ sampl_pt = atoi(optarg);
+ break;
+
+ default:
+ print_usage(argv[0]);
+ break;
+ }
+ }
+
+ if (argc > optind + 1)
+ print_usage(argv[0]);
+
+ if (argc == optind + 1)
+ name = argv[optind];
+
+ if (list) {
+ for (i = 0; i < sizeof(can_calc_consts) /
+ sizeof(struct can_bittiming_const); i++)
+ printf("%s\n", can_calc_consts[i].name);
+ return 0;
+ }
+
+ if (sampl_pt && (sampl_pt >= 1000 || sampl_pt < 100))
+ print_usage(argv[0]);
+
+ if (name) {
+ for (i = 0; i < sizeof(can_calc_consts) /
+ sizeof(struct can_bittiming_const); i++) {
+ if (!strcmp(can_calc_consts[i].name, name)) {
+ btc = &can_calc_consts[i];
+ break;
+ }
+ }
+ if (!btc)
+ print_usage(argv[0]);
+
+ } else {
+ btc = &can_calc_consts[0];
+ }
+
+ if (bitrate) {
+ print_bit_timing(btc, bitrate, sampl_pt, ref_clk, quiet);
+ } else {
+ for (i = 0; i < sizeof(common_bitrates) / sizeof(long); i++)
+ print_bit_timing(btc, common_bitrates[i], sampl_pt,
+ ref_clk, i);
+ }
+
+ return 0;
+}
projects / socketcan-devel.git / commitdiff