Steps:

Step 1. When checking out, select 'Direct Bank Transfer Discount' payment option. The discounted amount will be showing and Total will be updated. Place Order.

Step 2.  If you are a registered user, your order will appear under My Account → Orders. If you check out as a guest, you will receive an email confirming your order.
Your order will be placed On Hold for 4 hours while we wait for your bank payment. If we do not receive the payment within this 4-hour window, the order will be automatically cancelled, and the reserved products will be returned to inventory.

Step 3. Make a payment

• From your Canadian bank account
• Select Interac e-Transer
• Recipient Email: orders@diycnc.ca
• Put the order# in the message box. The example below shows the TD Bank e-Transfer page. Other banks and financial institutions may have different interfaces.

Step 4, Once we have received and verified your e-Transfer, your order status will change to Processing, and you will receive a confirmation email.

#define SERVO42D_SPEED_MODE 0xF6

Servo42D/57D supports position mode and Speed mode. On Position Mode, the Position Mode includes absolute position and relative position. 

The code below shows the Relative Position motion baccording to pulse number (page 78 on CAN User Manual)

#define SERVO42D_SPEED_MODE 0xF6

void Servo42D_RunPosition(void)
{
  TxHeader.StdId=SERVO42D_ID;
  TxHeader.ExtId=0;
  TxHeader.IDE=CAN_ID_STD;
  TxHeader.RTR=CAN_RTR_DATA;
  TxHeader.DLC=8;
  TxHeader.TransmitGlobalTime=DISABLE;

  TxData=SERVO42D_POSITION_MODE1;
  TxData=0x00;
  TxData=0x3C;
  TxData=0x02;
  TxData=0x00;
  TxData=0x00;
  TxData=0x64;
  TxData=(SERVO42D_ID+TxData+TxData+TxData+TxData+TxData+TxData+TxData)&0xFF;


  if(HAL_CAN_AddTxMessage(&hcan,&TxHeader,TxData,&TxMailbox)!=HAL_OK)
  {
    Error_Handler();
  }
}

#include "main.h"

/* Private variables ---------------------------------------------------------*/
CAN_HandleTypeDef hcan;

/* USER CODE BEGIN PV */

#define SERVO42D_ID 0x01
#define SERVO42D_READ 0x00
#define SERVO42D_WORK_MODE 0x82
CAN_TxHeaderTypeDef TxHeader;
CAN_RxHeaderTypeDef RxHeader;
uint8_t TxData;
uint8_t RxData;
uint32_t TxMailbox;
uint8_t ServoMode=0xFF;

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_CAN_Init(void);
/* USER CODE BEGIN PFP */

void Servo42D_ReadWorkMode(void);

int main(void)
{

  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_CAN_Init();
  if(HAL_CAN_Start(&hcan)!=HAL_OK)
  {
      Error_Handler();
  }
  while (1)
  {
    /* USER CODE END WHILE */
	  Servo42D_ReadWorkMode();
	  HAL_Delay(100);
	  if(HAL_CAN_GetRxFifoFillLevel(&hcan,CAN_RX_FIFO0)>0)
	  {
		  if(HAL_CAN_GetRxMessage(&hcan,CAN_RX_FIFO0,&RxHeader,RxData)==HAL_OK)
		  {
			  if(RxHeader.StdId==SERVO42D_ID&&RxHeader.DLC==3&&RxData==SERVO42D_WORK_MODE)
			  {
				  uint8_t crc=(SERVO42D_ID+RxData+RxData)&0xFF;
				  if(RxData==crc)
				  {
					  ServoMode=RxData;
				  }
			  }
		  }
	  }
	  HAL_Delay(900);
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief CAN Initialization Function
  * @param None
  * @retval None
  */
static void MX_CAN_Init(void)
{

  hcan.Instance = CAN1;
  hcan.Init.Prescaler = 4;
  hcan.Init.Mode = CAN_MODE_NORMAL;
  hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan.Init.TimeSeg1 = CAN_BS1_15TQ;
  hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
  hcan.Init.TimeTriggeredMode = DISABLE;
  hcan.Init.AutoBusOff = DISABLE;
  hcan.Init.AutoWakeUp = DISABLE;
  hcan.Init.AutoRetransmission = DISABLE;
  hcan.Init.ReceiveFifoLocked = DISABLE;
  hcan.Init.TransmitFifoPriority = DISABLE;
  if (HAL_CAN_Init(&hcan) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN_Init 2 */
  CAN_FilterTypeDef CAN_Filter;
  CAN_Filter.FilterBank=0;
  CAN_Filter.FilterMode=CAN_FILTERMODE_IDMASK;
  CAN_Filter.FilterScale=CAN_FILTERSCALE_32BIT;
  CAN_Filter.FilterIdHigh=(SERVO42D_ID<<5);
  CAN_Filter.FilterIdLow=0;
  CAN_Filter.FilterMaskIdHigh=(0x7FF<<5);
  CAN_Filter.FilterMaskIdLow=0;
  CAN_Filter.FilterFIFOAssignment=CAN_FILTER_FIFO0;
  CAN_Filter.FilterActivation=ENABLE;
  CAN_Filter.SlaveStartFilterBank=14;
  if(HAL_CAN_ConfigFilter(&hcan,&CAN_Filter)!=HAL_OK)
  {
      Error_Handler();
  }
  /* USER CODE END CAN_Init 2 */

}

static void MX_GPIO_Init(void)
{

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

}

/* USER CODE BEGIN 4 */
void Servo42D_ReadWorkMode(void)
{
    TxHeader.StdId=SERVO42D_ID;
    TxHeader.ExtId=0;
    TxHeader.IDE=CAN_ID_STD;
    TxHeader.RTR=CAN_RTR_DATA;
    TxHeader.DLC=3;
    TxHeader.TransmitGlobalTime=DISABLE;
    TxData=SERVO42D_READ;
    TxData=SERVO42D_WORK_MODE;
    TxData=(SERVO42D_ID+TxData+TxData)&0xFF;
    HAL_CAN_AddTxMessage(&hcan,&TxHeader,TxData,&TxMailbox);
}
/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif /* USE_FULL_ASSERT */

Referring: https://community.st.com/stm32-mcus-60/using-can-bxcan-in-normal-mode-with-stm32-microcontrollers-part-1-151183

Software enviroment: STM32CubeIDE, STM32CubeMX

STM32F103C8Tx Blue Pill Pins Configuration va STM32CubeMX:

Hardware:  Nema17 with Servo42D, MKS CANable V2.0 USB-CAN, 12V DC Power Power Supply

Wiring: Refer gitbub user manual: Github User Manual, (Note: MKS_ServoD_Control software is not suitable for testing the CAN bus, use CNGaroo or Python)

Step one:  Test the communication, Here, I am using Python to do the test, without using software tool such as CANgaroo.

• Use USB cable connect the CANable adaper to PC
• Use three dopont wires to connect CANable adaper and MKS Servo42D Motor Driver(CAN-H, CAN-L and GRD)
• 12V DC Power to Servo42D Motor Driver
• The following code to test the communication, only CAN ID received is successful. 

import can
import time

bus = can.Bus(
    interface="slcan",
    channel="COM5",       # change to your COM port
    bitrate=500000
)

print("CAN bus opened")

# Send Servo42D encoder request
msg = can.Message(
    arbitration_id=0x01,
    data=,
    is_extended_id=False
)

print("Sending:", msg)
bus.send(msg)

print("Waiting for response...")

# Listen for up to 3 seconds
start = time.time()

while time.time() - start < 3:
    response = bus.recv(timeout=0.5)

    if response is not None:
        print("RECEIVED:", response)
        print("ID:", hex(response.arbitration_id))
        print("DATA:", response.data.hex(" ").upper())
        print("DLC:", response.dlc)

print("Done")

bus.shutdown()

Step two,  Run the motor.  

The following code will control the stepper motor by selecting its direction and speed:

# MKS Servo42D/57D CAN Bus Testing

import can
import time

# =========================
# CAN configuration
# =========================
COM_PORT = "COM5"       # <-- change this based on your USB Port
CAN_BITRATE = 500000
CAN_ID = 0x01

# =========================
# Open CAN bus
# =========================
bus = can.Bus(
    interface="slcan",
    channel=COM_PORT,
    bitrate=CAN_BITRATE
)

print("CAN bus opened")
print(f"Port: {COM_PORT}")
print(f"CAN ID: 0x{CAN_ID:X}")
print(f"Bitrate: {CAN_BITRATE}")
print()


# =========================
# Send CAN frame
# =========================
def send(data):
    msg = can.Message(
        arbitration_id=CAN_ID,
        data=data,
        is_extended_id=False
    )

    print("TX:", " ".join(f"{x:02X}" for x in data))

    try:
        bus.send(msg)
    except can.CanError as e:
        print("CAN ERROR:", e)


# =========================
# Read CAN response
# =========================
def receive(timeout=1.0):
    msg = bus.recv(timeout=timeout)

    if msg is None:
        print("RX: no response")
        return None

    print(
        f"RX ID: 0x{msg.arbitration_id:X}  "
        f"DATA: {msg.data.hex(' ').upper()}  "
        f"DLC: {msg.dlc}"
    )

    return msg

# =========================
# Enable motor
# =========================
def enable():
    # F3 01 + checksum F5
    send()
    receive()


# =========================
# Disable motor
# =========================
def disable():
    # F3 00 + checksum F4
    send()
    receive()


# =========================
# Read encoder
# =========================
def read_encoder():
    # 30 31
    send()
    receive()


# =========================
# Speed command
# =========================
def speed_command(rpm, direction=0, acceleration=2):

    if rpm < 0:
        rpm = -rpm
        direction = 1

    if rpm > 2047:
        print("RPM too high")
        return

    # 12-bit speed value
    speed = int(rpm)

    high = (speed >> 8) & 0x0F
    low = speed & 0xFF

    # Bit 7 = direction
    if direction:
        high |= 0x80

    # Calculate checksum
    checksum = (
        CAN_ID +
        0xF6 +
        high +
        low +
        acceleration
    ) & 0xFF

    data = 

    send(data)


# =========================
# Stop motor
# =========================
def stop():
    # F6 00 00 00 + checksum
    checksum = (
        CAN_ID +
        0xF6
    ) & 0xFF

    send()

    receive()


# =========================
# Main menu
# =========================
try:

    while True:

        print()
        print("============================")
        print(" MKS SERVO42D CAN TEST")
        print("============================")
        print("1 - Enable motor")
        print("2 - Disable motor")
        print("3 - Read encoder")
        print("4 - CW 100 RPM")
        print("5 - CCW 100 RPM")
        print("6 - CW 300 RPM")
        print("7 - CCW 300 RPM")
        print("8 - STOP")
        print("9 - Exit")
        print("============================")

        choice = input("Select: ")
        if choice == "1":
            enable()

        elif choice == "2":
            disable()

        elif choice == "3":
            read_encoder()

        elif choice == "4":
            speed_command(100, direction=0)

        elif choice == "5":
            speed_command(100, direction=1)

        elif choice == "6":
            speed_command(300, direction=0)

        elif choice == "7":
            speed_command(300, direction=1)

        elif choice == "8":
            stop()

        elif choice == "9":
            stop()
            break

        else:
            print("Invalid selection")

finally:
    bus.shutdown()
    print("CAN bus closed")

Notes: If the communication cannot be created between CANable Adapter and Servo42D, check the resister (120 Ω) either in adapter or Servo42D board, at leaset one resistor should be connected for the single master motor. 

https://diycnc.ca/product/mcp2518fd-module-spi-to-canfd-controller-8-mbps/