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.

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();
  }
}

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. 

CAM: OV5640

Test environment:  Arduino IDE

• Select 'ESP32S3 Dev Module'
• Enable PSRAM (ODI PSRAM)

Sample code: (Refer: Exsamples -> ESP32 -> Camera -> CameraWebServer

#include <Arduino.h>
#include "esp_camera.h"
#include <WiFi.h>

const char *ssid = "wifi name";
const char *password = "wifi password";

#define PWDN_GPIO_NUM    -1
#define RESET_GPIO_NUM   -1
#define XCLK_GPIO_NUM    15
#define SIOD_GPIO_NUM    4
#define SIOC_GPIO_NUM    5
#define Y9_GPIO_NUM      16
#define Y8_GPIO_NUM      17
#define Y7_GPIO_NUM      18
#define Y6_GPIO_NUM      12
#define Y5_GPIO_NUM      10
#define Y4_GPIO_NUM       8
#define Y3_GPIO_NUM       9
#define Y2_GPIO_NUM      11
#define VSYNC_GPIO_NUM    6
#define HREF_GPIO_NUM     7
#define PCLK_GPIO_NUM    13

void startCameraServer();

void setup() {
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  Serial.println("=== ESP32-S3 Camera ===");
  if (psramFound()) {
    Serial.println("PSRAM: YES");
    Serial.printf("PSRAM size: %u bytes\n", ESP.getPsramSize());
    Serial.printf("Free PSRAM: %u bytes\n", ESP.getFreePsram());
  } else {
    Serial.println("PSRAM: NO");
  }

  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.frame_size = FRAMESIZE_XGA;
  config.pixel_format = PIXFORMAT_JPEG;
  config.jpeg_quality = 8;
  config.fb_location = CAMERA_FB_IN_PSRAM;
  config.fb_count = 2;
  config.grab_mode = CAMERA_GRAB_LATEST;

  Serial.println("Initializing camera...");
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return;
  }

  sensor_t *s = esp_camera_sensor_get();
  if (s == NULL) {
    Serial.println("ERROR: Camera sensor not found");
    return;
  }

  Serial.printf("Camera PID: %u (0x%04X)\n", s->id.PID, s->id.PID);

  if (s->id.PID == OV5640_PID) {
    Serial.println("Camera: OV5640");
    s->set_hmirror(s, 1);
    s->set_brightness(s, 1);
    s->set_saturation(s, -2);
  }

  Serial.printf("Frame size: %d\n", s->status.framesize);
  Serial.printf("JPEG quality: %d\n", s->status.quality);
  Serial.printf("Free PSRAM after camera init: %u bytes\n", ESP.getFreePsram());

  WiFi.begin(ssid, password);
  WiFi.setSleep(false);
  Serial.print("WiFi connecting");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("WiFi connected");

  startCameraServer();

  Serial.print("Camera Ready! Use 'http://");
  Serial.print(WiFi.localIP());
  Serial.println("' to connect");
}

void loop() {
  delay(10000);
}