added all bitrates and silent mode

Inc/can.h

@@ -2,15 +2,15 @@
 #define _CAN_H
 
 enum can_bitrate {
-    CAN_BITRATE_1000K,
-    CAN_BITRATE_500K,
-    CAN_BITRATE_250K,
-    CAN_BITRATE_125K,
-    CAN_BITRATE_100K,
-    CAN_BITRATE_83K3,
-    CAN_BITRATE_62K5,
+    CAN_BITRATE_10K,
+    CAN_BITRATE_20K,
     CAN_BITRATE_50K,
-    CAN_BITRATE_33K3,
+    CAN_BITRATE_100K,
+    CAN_BITRATE_125K,
+    CAN_BITRATE_250K,
+    CAN_BITRATE_500K,
+    CAN_BITRATE_750K,
+    CAN_BITRATE_1000K,
 };
 
 enum can_bus_state {

Src/can.c

@@ -3,6 +3,7 @@
 
 CAN_HandleTypeDef hcan;
 CAN_FilterConfTypeDef filter;
+uint32_t prescaler;
 enum can_bus_state bus_state;
 
 void can_init(void) {
@@ -19,26 +20,26 @@ void can_init(void) {
     filter.BankNumber = 0;
     filter.FilterActivation = ENABLE;
 
+    // default to 125 kbit/s
+    prescaler = 48;
     hcan.Instance = CAN;
-    hcan.Init.Prescaler = 48;
-    hcan.Init.Mode = CAN_MODE_NORMAL;
-    hcan.Init.SJW = CAN_SJW_1TQ;
-    hcan.Init.BS1 = CAN_BS1_4TQ;
-    hcan.Init.BS2 = CAN_BS2_3TQ;
-    hcan.Init.TTCM = DISABLE;
-    hcan.Init.ABOM = DISABLE;
-    hcan.Init.AWUM = DISABLE;
-    hcan.Init.NART = DISABLE;
-    hcan.Init.RFLM = DISABLE;
-    hcan.Init.TXFP = DISABLE;
-
     bus_state = OFF_BUS;
 }
 
 void can_enable(void) {
     uint32_t status;
     if (bus_state == OFF_BUS) {
-        hcan.Init.Mode = CAN_MODE_NORMAL;
+	hcan.Init.Prescaler = prescaler;
+	hcan.Init.Mode = CAN_MODE_NORMAL;
+	hcan.Init.SJW = CAN_SJW_1TQ;
+	hcan.Init.BS1 = CAN_BS1_4TQ;
+	hcan.Init.BS2 = CAN_BS2_3TQ;
+	hcan.Init.TTCM = DISABLE;
+	hcan.Init.ABOM = DISABLE;
+	hcan.Init.AWUM = DISABLE;
+	hcan.Init.NART = DISABLE;
+	hcan.Init.RFLM = DISABLE;
+	hcan.Init.TXFP = DISABLE;
         hcan.pTxMsg = NULL;
         status = HAL_CAN_Init(&hcan);
         status = HAL_CAN_ConfigFilter(&hcan, &filter);
@@ -63,32 +64,32 @@ void can_set_bitrate(enum can_bitrate bitrate) {
     }
 
     switch (bitrate) {
-    case CAN_BITRATE_1000K:
-	// TODO
+    case CAN_BITRATE_10K:
+	prescaler = 600;
         break;
-    case CAN_BITRATE_500K:
-        hcan.Init.Prescaler = 12;
-        break;
-    case CAN_BITRATE_250K:
-        hcan.Init.Prescaler = 24;
-        break;
-    case CAN_BITRATE_125K:
-        hcan.Init.Prescaler = 1;
-        break;
-    case CAN_BITRATE_100K:
-	// TODO
-        break;
-    case CAN_BITRATE_83K3:
-	// TODO
-        break;
-    case CAN_BITRATE_62K5:
-	// TODO
+    case CAN_BITRATE_20K:
+	prescaler = 300;
         break;
     case CAN_BITRATE_50K:
-	// TODO
+	prescaler = 120;
         break;
-    case CAN_BITRATE_33K3:
-	// TODO
+    case CAN_BITRATE_100K:
+        prescaler = 60;
+        break;
+    case CAN_BITRATE_125K:
+        prescaler = 48;
+        break;
+    case CAN_BITRATE_250K:
+        prescaler = 24;
+        break;
+    case CAN_BITRATE_500K:
+        prescaler = 12;
+        break;
+    case CAN_BITRATE_750K:
+        prescaler = 8;
+        break;
+    case CAN_BITRATE_1000K:
+        prescaler = 6;
         break;
     }
 }

Src/slcan.c

@@ -80,33 +80,67 @@ int8_t slcan_parse_str(char *buf, uint8_t len) {
         // open channel command
         can_enable();
         return 0;
+
     } else if (buf[0] == 'C') {
         // close channel command
         can_disable();
         return 0;
+
     } else if (buf[0] == 'S') {
         // set bitrate command
         switch(buf[1]) {
-            case 0:
-                can_set_bitrate(CAN_BITRATE_125K);
-                break;
-            case 1:
-                can_set_bitrate(CAN_BITRATE_250K);
-                break;
-            case 2:
-                can_set_bitrate(CAN_BITRATE_500K);
-                break;
-            default:
-                // invalid setting
-                return -1;
+        case 0:
+            can_set_bitrate(CAN_BITRATE_10K);
+            break;
+        case 1:
+            can_set_bitrate(CAN_BITRATE_20K);
+            break;
+        case 2:
+            can_set_bitrate(CAN_BITRATE_50K);
+            break;
+        case 3:
+            can_set_bitrate(CAN_BITRATE_100K);
+            break;
+        case 4:
+            can_set_bitrate(CAN_BITRATE_125K);
+            break;
+        case 5:
+            can_set_bitrate(CAN_BITRATE_250K);
+            break;
+        case 6:
+            can_set_bitrate(CAN_BITRATE_500K);
+            break;
+        case 7:
+            can_set_bitrate(CAN_BITRATE_750K);
+            break;
+        case 8:
+            can_set_bitrate(CAN_BITRATE_1000K);
+            break;
+        default:
+            // invalid setting
+            return -1;
         }
         return 0;
+
+    } else if (buf[0] == 'm' || buf[0] == 'M') {
+        // set mode command
+        if (buf[1] == 1) {
+            // mode 1: silent
+            can_set_silent(1);
+        } else {
+            // default to normal mode
+            can_set_silent(0);
+        }
+        return 0;
+
     } else if (buf[0] == 't' || buf[0] == 'T') {
         // transmit data frame command
         frame.RTR = CAN_RTR_DATA;
+
     } else if (buf[0] == 'r' || buf[0] == 'R') {
-        frame.RTR = CAN_RTR_REMOTE;
         // transmit remote frame command
+        frame.RTR = CAN_RTR_REMOTE;
+
     } else {
         // error, unknown command
         return -1;
@@ -139,7 +173,7 @@ int8_t slcan_parse_str(char *buf, uint8_t len) {
             frame.StdId += buf[i++];
         }
     }
-    
+
 
     frame.DLC = buf[i++];
     if (frame.DLC < 0 || frame.DLC > 8) {