Probleme comunicare UART Arduino Uno <-> TMC2209 (FYSETC V4.0)

[RaduDNS]

Salutare tuturor !

 

Încerc să controlez un motor stepper NEMA17 cu un driver TMC2209 prin UART, folosind un Arduino Uno, dar întâmpin probleme la stabilirea comunicării și aș aprecia orice ajutor.

1. Scop: Controlul vitezei (RPM), curentului și sensului unui motor stepper NEMA17 folosind un driver TMC2209 în modul UART, prin comenzi trimise din monitorul serial al Arduino IDE. Pe termen lung, doresc să beneficiez și de funcții avansate precum StallGuard și CoolStep, pentru o operare mai eficientă și detectarea blocajelor.

2. Hardware Utilizat:

Microcontroller: Arduino Uno

Driver Motor Stepper: TMC2209 FYSETC V4.0

Motor Stepper: NEMA17 

Sursă de Alimentare Externă: 12V/5A

Alte componente: Un rezistor de 1K Ohm utilizat într-una din configurațiile de cablaj half-duplex.

3. Descrierea Problemei: Codul meu Arduino returnează eroarea Eroare conexiune TMC2209! Status: 0x2 la apelarea driver.test_connection() în funcția setup(). Acest status 0x2 (corespondent unei citiri de 0xFFFFFFFF din registru) indică faptul că nu primesc un răspuns valid de la driver, sugerând o problemă de comunicare UART. Motorul este blocat/ținut ferm după activarea driverului, ceea ce indică faptul că driverul este alimentat și activ, dar comunicarea bidirecțională este problematică.

4. Detalii Cablaj UART și Tentative Efectuate:

Am încercat două configurații de cablaj, ambele fără succes (eroarea 0x2 persistă în ambele cazuri):

Tentativa 1: Conexiune standard (două fire) half-duplex:

Arduino D2 (SW_TX_PIN) conectat la TMC2209 RX 

Arduino D3 (SW_RX_PIN) conectat la TMC2209 TX 

Rezultat: Comunicare eșuată cu eroarea 0x2.

Tentativa 2: Conexiune half-duplex pe o singură linie (implementare proprie cu suntare pe driver):

Pe Modulul TMC2209:

Am suntat fizic pinul RX cu un pin identificat ca fiind pinul TX  al driverului  Acești doi pini, care sunt în mod normal intrarea și ieșirea serială separată a driverului, sunt conectați direct unul la celălalt pe modulul driver.

Această linie comună (pini RX  + TX  suntati) de pe TMC2209 este apoi conectată la Arduino.

Conexiunea la Arduino Uno:

Arduino D3 (SW_RX_PIN) este conectat direct la linia comună (RX  + TX  suntati) a TMC2209.

Arduino D2 (SW_TX_PIN) este conectat la linia comună (RX  + TX  suntati) a TMC2209, dar printr-un rezistor de 1K Ohm montat în serie între D2 și linia comună.

Rezultat: Comunicare eșuată cu eroarea 0x2.

5. Alte Conexiuni Esențiale (valabile pentru ambele tentative):

Arduino D4 (EN_PIN) conectat la TMC2209 ENABLE

Arduino 5V conectat la TMC2209 VCC

Arduino GND conectat la TMC2209 GND 

Sursă de Alimentare Externă ( 12V/5A) conectată la TMC2209 VM

Motorul stepper este conectat la terminalele A1/A2, B1/B2 ale driverului.

6. Codul Utilizat: 

#include <Arduino.h>

#include <SoftwareSerial.h>

#include <TMCStepper.h> // Asigură-te că ai instalat biblioteca "TMCStepper" în Arduino IDE.

 

// --- Definirea pinilor ---

// Pinul Arduino conectat la TX al TMC2209 (pentru a primi date de la driver)

#define SW_RX_PIN 3

// Pinul Arduino conectat la RX al TMC2209 (pentru a trimite date către driver)

#define SW_TX_PIN 2

// Pinul de enable al driverului TMC2209 (LOW pentru activat, HIGH pentru dezactivat)

#define EN_PIN 4

 

// Adresa implicită a TMC2209. Pentru majoritatea driverelor TMC2209, aceasta este 0b00 (0x00).

// Nu este necesară încercarea mai multor adrese, deoarece TMC2209 nu are opțiuni de adresare.

#define TMC2209_ADDRESS 0b00

 

// Valoarea RSense (de obicei 0.11 Ohm pentru modulele TMC2209 comune, precum cele de la BIGTREETECH)

// Verifică valoarea pe placa ta TMC2209.

#define R_SENSE 0.11f

 

// Valoarea maximă pentru VACTUAL (viteza motorului).

// Aceasta depinde de RPM-ul maxim dorit, numărul de micro-pași și pași/revoluție ai motorului.

// Ex: Pentru un motor cu 200 pași/rev, 16 micro-pași, cu un ceas intern de 12MHz:

// O valoare VACTUAL de aproximativ 20000 corespunde la ~540 RPM.

// Formula pentru conversia RPM la VACTUAL (aproximativă):

// VACTUAL = (RPM_dorit * pași_pe_rev * micro_pași) / (60 * (f_CLK / 2^23))

// Unde f_CLK = 12MHz (12,000,000 Hz) și 2^23 = 8388608.

// Deci, (f_CLK / 2^23) = ~1.4305.

// Pentru 200 pași/rev și 16 micro-pași: VACTUAL = RPM_dorit * 37.28

// Ajustează MAX_VACTUAL pentru a se potrivi nevoilor tale.

#define MAX_VACTUAL 20000

 

// Obiect SoftwareSerial pentru comunicarea cu TMC2209

SoftwareSerial TMCSERIAL(SW_RX_PIN, SW_TX_PIN);

 

// Obiect TMC2209Stepper. Constructorul primește Stream-ul serial, valoarea RSense și adresa slave.

TMC2209Stepper driver(&TMCSERIAL, R_SENSE, TMC2209_ADDRESS);

 

// Variabile pentru controlul motorului

long motorSpeedValue = 0; // Valoarea VACTUAL pentru viteză (0-MAX_VACTUAL)

int motorCurrent_mA = 800; // Curentul de funcționare în mA (e.g., 100-1500mA)

bool motorDirection = false; // false pentru un sens, true pentru sens opus

bool motorEnabled = true; // Starea de activare a driverului

 

void setup() {

// Inițializează portul serial hardware pentru monitorul serial

Serial.begin(115200);

while (!Serial) { ; } // Așteaptă conectarea monitorului serial

 

Serial.println(F("--- Exemplu de Control TMC2209 UART ---"));

 

// Setează pinul EN ca ieșire și activează driverul (LOW)

pinMode(EN_PIN, OUTPUT);

digitalWrite(EN_PIN, LOW); // LOW = Enabled. Asigură-te că modulul tău este conectat corespunzător.

 

// --- Încearcă diferite baud rate-uri pentru conexiunea UART ---

const uint32_t baudRates[] = {115200, 57600, 38400, 19200, 9600};

bool connected = false;

uint8_t connectionStatus = 0;

 

for (uint8_t i = 0; i < sizeof(baudRates) / sizeof(baudRates[0]); i++) {

uint32_t currentBaud = baudRates[i];

Serial.print(F("Încerc conectare TMC2209 la baud rate: ")); Serial.print(currentBaud); Serial.print(F("... "));

 

// Închide și redeschide SoftwareSerial la noul baud rate

TMCSERIAL.end(); // Asigură-te că portul este închis înainte de a-l deschide cu un baud rate nou

TMCSERIAL.begin(currentBaud);

// Informează obiectul driverului ce baud rate să folosească

driver.beginSerial(currentBaud);

driver.begin(); // Inițializează driverul cu noul baud rate setat prin beginSerial()

 

// Testează conexiunea

connectionStatus = driver.test_connection();

if (connectionStatus == 0) {

Serial.println(F("OK!"));

connected = true;

break; // Conectat cu succes, ieși din buclă

} else {

Serial.print(F("Eroare (0x")); Serial.print(connectionStatus, HEX); Serial.println(F(")."));

}

}

 

if (!connected) {

Serial.println(F("\n-----------------------------------------------------------"));

Serial.println(F("ERROARE FATALĂ: Nu s-a putut stabili conexiunea UART cu TMC2209."));

Serial.println(F("Cauze posibile (verificați cu atenție):"));

Serial.println(F("1. Cablaj RX/TX incorect: Arduino D3 (RX) -> TMC2209 TX, Arduino D2 (TX) -> TMC2209 RX (PDN_UART)."));

Serial.println(F("2. Modulul TMC2209 nu este configurat pentru UART (lipsă lipitură/solder bridge DIAG-TX)."));

Serial.println(F("3. Alimentare incorectă (VCC, GND, VM)."));

Serial.println(F("4. Baud rate-ul driverului nu este în lista încercată."));

Serial.println(F("5. Driverul TMC2209 este defect."));

Serial.println(F("-----------------------------------------------------------\n"));

while (true); // Oprește programul dacă conexiunea eșuează

}

 

// Setările driverului, acum că suntem conectați

driver.defaults();

 

// --- Configurare Registrul GCONF (General Configuration) ---

// Acestea sunt metode directe ale driverului, nu sub-obiecte

driver.pdn_disable(true); // Activează interfața UART (PDN_UART trebuie să fie HIGH)

driver.mstep_reg_select(true); // Selectează rezoluția micro-pașilor din registru, nu de la pinii MS1/MS2

driver.multistep_filt(true); // Activează filtrarea multi-pas pentru o mișcare mai lină (StealthChop)

driver.en_spreadCycle(false); // Dezactivează SpreadCycle, activează StealthChop pentru operare silențioasă

driver.shaft(motorDirection); // Setează sensul inițial

 

// --- Configurare Registrul CHOPCONF (Chopper Configuration) ---

driver.microsteps(16); // Setează 16 micro-pași (driverul va interpola la 256)

driver.intpol(true); // Activează interpolarea micro-pașilor (spre 256)

driver.toff(5); // Timpul de oprire al chopperului (0=dezactivat). Ajustează pentru zgomot/căldură motor.

driver.tbl(1); // Timp gol (blank time) 16 cicluri de ceas (0-3)

driver.hend(0); // Istereza finală (hysteresis end) (0-15)

driver.hstrt(5); // Istereza de pornire (hysteresis start) (1-8)

driver.vsense(false); // VSENSE: False pentru mai multă putere, True pentru mai multă liniște (depinde de Rsense)

 

// --- Configurare curenți (IHOLD_IRUN) ---

// Funcția helper rms_current() setează corect curenții HOLD și RUN.

driver.rms_current(motorCurrent_mA); // Setează curentul de funcționare și de așteptare.

driver.iholddelay(8); // Cicluri de ceas (2^iholddelay) pentru tranziția ihold->irun

 

// Aplica toate setările configurate către driverul TMC2209

// Registrele GCONF, CHOPCONF, IHOLD_IRUN sunt setate local și trebuie "împinse" către driver.

driver.push();

 

// Verificare și afișare a unor registre după configurare

Serial.print(F("Driver GSTAT (General Status): 0x")); Serial.println(driver.GSTAT(), HEX);

Serial.print(F("Driver IOIN (Input/Output Status): 0x")); Serial.println(driver.IOIN(), HEX);

Serial.print(F("Driver CHOPCONF (Chopper Configuration): 0x")); Serial.println(driver.CHOPCONF(), HEX);

Serial.print(F("Driver IHOLD_IRUN (Current Configuration): 0x")); Serial.println(driver.IHOLD_IRUN(), HEX);

Serial.print(F("Curent RMS setat la: ")); Serial.print(driver.rms_current()); Serial.println(F("mA"));

Serial.print(F("Micro-pași driver: ")); Serial.println(driver.microsteps());

 

// Setează viteza inițială a motorului la 0

driver.VACTUAL(0); // VACTUAL este scris direct și nu necesită push()

Serial.println(F("Motor oprit. Introduceți comenzi în Monitorul Serial:"));

Serial.println(F("S<valoare_viteza> (ex: S10000 pentru o viteză dată de VACTUAL)"));

Serial.println(F("C<curent_mA> (ex: C800 pentru 800mA)"));

Serial.println(F("D0 (un sens de rotație), D1 (sensul opus)"));

Serial.println(F("E (Activează/Dezactivează driverul)"));

Serial.println(F("? (Afișează starea curentă a driverului)"));

}

 

void loop() {

// Verifică dacă există date disponibile pe portul serial hardware (de la monitor)

if (Serial.available()) {

String command = Serial.readStringUntil('\n'); // Citește comanda până la newline

command.trim(); // Elimină caracterele de spațiu, newline, carriage return

// Extrage primul caracter ca tip de comandă și restul ca valoare

char cmdChar = toupper(command.charAt(0)); // Convertește la majuscule

String valueStr = command.substring(1);

long value = valueStr.toInt(); // Convertește valoarea în număr întreg (pentru viteză și curent)

 

Serial.print(F("Comanda primită: "));

Serial.println(command);

 

switch (cmdChar) {

case 'S': // Setează Viteza (folosind VACTUAL)

if (value >= 0 && value <= MAX_VACTUAL) {

motorSpeedValue = value;

// VACTUAL controlează direct viteza motorului.

// O valoare pozitivă generează mișcare într-o direcție, negativă în cealaltă.

// Însă, pentru a simplifica, vom folosi VACTUAL mereu pozitiv și vom schimba sensul cu driver.shaft().

driver.VACTUAL(motorSpeedValue);

// VACTUAL este un registru de tip "live" și nu necesită driver.push() după modificare.

Serial.print(F("Viteza motorului (VACTUAL) setată la: ")); Serial.println(motorSpeedValue);

Serial.print(F("Sens curent (driver.shaft()): ")); Serial.println(driver.shaft() ? "Inversat" : "Normal");

} else {

Serial.print(F("Valoare viteză invalidă. Introduceți 0 la ")); Serial.print(MAX_VACTUAL); Serial.println(F("."));

}

break;

 

case 'C': // Setează Curentul (în mA)

if (value >= 100 && value <= 1500) { // Limite exemplu pentru curent. Ajustează după motor/driver.

motorCurrent_mA = value;

driver.rms_current(motorCurrent_mA); // Setează curentul de rulare și de așteptare

driver.push(); // Aplică modificările registrului IHOLD_IRUN

Serial.print(F("Curentul motorului setat la: ")); Serial.print(motorCurrent_mA); Serial.println(F("mA"));

} else {

Serial.println(F("Valoare curent invalidă. Introduceți între 100 și 1500 mA."));

}

break;

 

case 'D': // Setează Sensul de rotație (folosind GCONF.shaft)

if (value == 0 || value == 1) {

motorDirection = (value == 1); // 0 = un sens, 1 = sens opus

driver.shaft(motorDirection); // Modifică bitul shaft din GCONF

driver.push(); // Aplică modificările registrului GCONF

Serial.print(F("Sensul motorului setat la: ")); Serial.println(motorDirection ? "Inversat (D1)" : "Normal (D0)");

} else {

Serial.println(F("Valoare sens invalidă. Folosiți D0 sau D1."));

}

break;

 

case 'E': // Activează/Dezactivează driverul

motorEnabled = !motorEnabled; // Inversează starea curentă

digitalWrite(EN_PIN, motorEnabled ? LOW : HIGH); // LOW = activat, HIGH = dezactivat

Serial.print(F("Driver ")); Serial.println(motorEnabled ? "Activat" : "Dezactivat");

if (!motorEnabled) {

driver.VACTUAL(0); // Oprește motorul când driverul este dezactivat

Serial.println(F("Motor oprit din cauza dezactivării driverului."));

}

break;

 

case '?': // Afișează starea curentă a driverului

Serial.println(F("\n--- Stare Curentă Driver ---"));

Serial.print(F("Driver Activ: ")); Serial.println(motorEnabled ? "Da" : "Nu");

Serial.print(F("Viteza motorului (VACTUAL): ")); Serial.println(motorSpeedValue);

Serial.print(F("Curent RMS: ")); Serial.print(driver.rms_current()); Serial.println(F("mA"));

Serial.print(F("Sens de rotație (driver.shaft()): ")); Serial.println(driver.shaft() ? "Inversat" : "Normal");

Serial.print(F("GSTAT (0x01): 0x")); Serial.println(driver.GSTAT(), HEX); // Stare generală

Serial.print(F("IOIN (0x06): 0x")); Serial.println(driver.IOIN(), HEX); // Stare pini I/O

Serial.print(F("DRV_STATUS (0x6F): 0x")); Serial.println(driver.DRV_STATUS(), HEX); // Starea driverului

Serial.print(F("Micro-pași setati: ")); Serial.println(driver.microsteps());

Serial.println(F("---------------------------\n"));

break;

 

default:

Serial.println(F("Comandă necunoscută. Folosiți S<viteză>, C<curent>, D0/D1, E sau ?."));

break;

}

}

 

// O scurtă întârziere pentru a evita supraîncărcarea CPU prin interogare continuă

delay(10);

}

7. Pași de Depanare Încercați Până Acum:

Am verificat cablajul în ambele configurații detaliate mai sus.

Am confirmat că toate GND-urile sunt comune și că driverul primește atât 5V pentru logică, cât și tensiunea pentru motor (12V) de la sursa externă.

Am folosit funcția de testare a baud rate-ului în cod, încercând secvențial 115200, 57600, 38400, 19200, 9600. Niciunul nu a reușit să stabilească conexiunea.

Am confirmat că pinul ENABLE al driverului este setat pe LOW (activat) la pornire.

Eroarea 0x2 persistă în ambele configurații.

 

Care este configurația corectă de cablaj UART (half-duplex) pentru un TMC2209 cu Arduino Uno, folosind biblioteca TMCStepper și SoftwareSerial ? Având în vedere că nici varianta pe două fire (Tentativa 1) și nici cea cu suntare pe driver (Tentativa 2) nu a funcționat.

Configurația din Tentativa 2 (suntarea fizică a pinilor RX UART și TX UART ai driverului) este o abordare corectă sau este o sursă sigură de probleme ?

Este posibil ca pinul pe care îl consider TX UART al driverului  să nu fie de fapt pinul corect pentru TX ? Cum îl pot identifica cu certitudine ?

Există vreo modalitate de a testa (chiar și cu un multimetru, dacă nu am osciloscop) dacă TMC2209 chiar emite ceva pe pinul său TX UART, sau dacă Arduino-ul transmite corect pe D2 ?

Este posibil ca pinii RX UART sau TX UART ai driverului să nu funcționeze corect sau să fie deteriorați din cauza suntării directe ?

Sunt cele două SoftwareSerial.begin() / driver.beginSerial() / driver.begin() apeluri în bucla de încercare a baud rate-ului corecte pentru a reseta și reinițializa serialul în mod corespunzător?

Oare modelul meu specific de placă TMC2209 FYSETC V4.0  are o particularitate cunoscută legată de comunicarea UART ?

După ce voi rezolva problema comunicării de bază, intenționez să configurez funcții precum StallGuard (pentru detectarea blocajelor) și CoolStep (pentru eficiență energetică). Orice informație preliminară legată de aceste funcționalități în contextul TMC2209 și Arduino ar fi, de asemenea, foarte utilă.

Orice sfat sau direcție este binevenită. Vă mulțumesc anticipat pentru ajutor !

 

[Elison]

Verificati, daca este posibil, continuitatea intre pinul RX de la driver si pinul PDN_UART(14) TMC2209.
Daca nu exista continuitate, trebuie sa verificati care din cele doua paduri de pe driver asigura aceasta continuitate.
Verificati daca rezistenta dintre  pinii RX si TX de la driver are 1 Kohm.
Verificati daca pinii de adresa MS1 si MS2 sunt conectati la GND.
Conectati pinul TX arduino la pinul TX driver si pinul RX arduino la pinul RX driver.
Incercati acest setup minim:

#include <SoftwareSerial.h>
#include <TMCStepper.h>
#define EN_PIN           4
#define SW_RX_PIN        3
#define SW_TX_PIN        2
#define DRIVER_ADDRESS   0b00 
#define R_SENSE          0.11f 

SoftwareSerial TMCSERIAL(SW_RX_PIN, SW_TX_PIN);
TMC2209Stepper driver(&TMCSERIAL, R_SENSE, DRIVER_ADDRESS);

void setup() {
  Serial.begin(115200);
  TMCSERIAL.begin(57600); 
  
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW); // Activare driver 

  driver.begin();
  driver.pdn_disable(true); // pinul PDN în mod UART
  delay(200);
  driver.rms_current(600);
  driver.VACTUAL(2000); //daca motorul se roteste UART functioneaza
  Serial.println(F("--- Test Conexiune FYSETC V4.0 ---"));
  uint8_t result = driver.test_connection();
  if (result == 0) {
    Serial.println(F("SUCCES: Comunicare UART stabilită!"));
  } else {
    Serial.print(F("Eroare: 0x")); Serial.println(result, HEX);
    Serial.println(F("Sfat: Verifică dacă ai 12V pornit și pinii MS1/MS2 la GND."));
  }
}

void loop() {}

 

[roadrunner]

pune un logic analyzer pe pinul ala sa vezi exact ce se intampla. (sau un osciloscop cu memorie) ca sa elimini orice dubiu legat de hardware.

RR

Edited March 26 by roadrunner

[daniels]

Acum 15 ore, RaduDNS a spus:

delay(10);

Evita delay cand comazi motoare, sunt toate sansele sa se blocheze, 

Evita folosirea pinilor Rx Tx (D0, D1) de pe placa

[Rumburak]

18 hours ago, RaduDNS said:

Este posibil ca pinii RX UART sau TX UART ai driverului să nu funcționeze corect sau să fie deteriorați din cauza suntării directe ?

Pinii UART NU se pot arde prin punerea in scurt, la GND sau +5V.
 

 

18 hours ago, RaduDNS said:

Serial.print(F("Încerc conectare TMC2209 la baud rate: ")); Serial.print(currentBaud); Serial.print(F("... "));

Ce afiseaza aceste linii ?
Posteaza codul folosind "<>". Este greu de urmarit asa cum l-ai pus.

[nico_2010]

In atentia initiatorului: formateaza codul postat la inceputul topicului folosind butonul "<>"

[RaduDNS]

Acum 13 ore, Elison a spus:

Verificati, daca este posibil, continuitatea intre pinul RX de la driver si pinul PDN_UART(14) TMC2209.
Daca nu exista continuitate, trebuie sa verificati care din cele doua paduri de pe driver asigura aceasta continuitate.
Verificati daca rezistenta dintre  pinii RX si TX de la driver are 1 Kohm.
Verificati daca pinii de adresa MS1 si MS2 sunt conectati la GND.
Conectati pinul TX arduino la pinul TX driver si pinul RX arduino la pinul RX driver.
Incercati acest setup minim:

#include <SoftwareSerial.h>
#include <TMCStepper.h>
#define EN_PIN           4
#define SW_RX_PIN        3
#define SW_TX_PIN        2
#define DRIVER_ADDRESS   0b00 
#define R_SENSE          0.11f 

SoftwareSerial TMCSERIAL(SW_RX_PIN, SW_TX_PIN);
TMC2209Stepper driver(&TMCSERIAL, R_SENSE, DRIVER_ADDRESS);

void setup() {
  Serial.begin(115200);
  TMCSERIAL.begin(57600); 
  
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW); // Activare driver 

  driver.begin();
  driver.pdn_disable(true); // pinul PDN în mod UART
  delay(200);
  driver.rms_current(600);
  driver.VACTUAL(2000); //daca motorul se roteste UART functioneaza
  Serial.println(F("--- Test Conexiune FYSETC V4.0 ---"));
  uint8_t result = driver.test_connection();
  if (result == 0) {
    Serial.println(F("SUCCES: Comunicare UART stabilită!"));
  } else {
    Serial.print(F("Eroare: 0x")); Serial.println(result, HEX);
    Serial.println(F("Sfat: Verifică dacă ai 12V pornit și pinii MS1/MS2 la GND."));
  }
}

void loop() {}

 

Vă mulțumesc pentru implicare.

Pinii RX și TX ai driverului sunt suntați (rezistența este zero) și există o continuitate între aceștia și pinul PDN_UART (14). Pinii MS1 și MS2 nu sunt legați la GND (există o rezistență de ordinul zecilor de mii de ohmi). Am conectat atât pinul RX al Arduino-ului la RX driver, cât și TX al Arduino-ului la TX driver, precum și RX al Arduino-ului la TX driver și TX al Arduino-ului la RX driver. Pe baza codului furnizat de dumneavoastră, am obținut acest mesaj:

<16:27:14.533 -> Ϝ�--- Test Conexiune FYSETC V4.0 ---

16:27:16.350 -> Eroare: 0x2

16:27:16.350 -> Sfat: Verifică dacă ai 12V pornit și pinii MS1/MS2 la GND.>

Rotorul abia se simte că se rotește.

[RaduDNS]

Acum 8 ore, daniels a spus:

Evita delay cand comazi motoare, sunt toate sansele sa se blocheze, 

Evita folosirea pinilor Rx Tx (D0, D1) de pe placa

Mulțumesc.

[Elison]

Pinii MS1 si MS2 trebuie legati la GND pentru a seta adresa UART la 0b00
In documentatia de aici este mentionat ca pinul TX este legat la PDN cu un rezistor de 1K ohm, dar
in schema driverului sunt rezistorii R11 si R12 cu valoarea de 0 ohmi, cazul de fata.
In acest caz trebuie sa montati un rezistor de 1 kohm intre pinii RX si TX arduino uno, iar de la pinul RX arduino uno, conectati un fir la oricare din pinii TX, RX driver.
Dupa ce faceti aceste modificari, incercati din nou comunicatia!
 

[RaduDNS]

Acum 9 ore, roadrunner a spus:

pune un logic analyzer pe pinul ala sa vezi exact ce se intampla. (sau un osciloscop cu memorie) ca sa elimini orice dubiu legat de hardware.

RR

Mulțumesc pentru sugestie. Nu dispun și nici nu am cum să apelez la cineva pentru o astfel de analiză.

[RaduDNS]

Acum 14 minute, Elison a spus:

Pinii MS1 si MS2 trebuie legati la GND pentru a seta adresa UART la 0b00
In documentatia de aici este mentionat ca pinul TX este legat la PDN cu un rezistor de 1K ohm, dar
in schema driverului sunt rezistorii R11 si R12 cu valoarea de 0 ohmi, cazul de fata.
In acest caz trebuie sa montati un rezistor de 1 kohm intre pinii RX si TX arduino uno, iar de la pinul RX arduino uno, conectati un fir la oricare din pinii TX, RX driver.
Dupa ce faceti aceste modificari, incercati din nou comunicatia!
 

<20:09:09.837 -> --- Test Conexiune FYSETC V4.0 ---

20:09:09.837 -> SUCCES: Comunicare UART stabilită!>

Vă mulțumesc tare mult pentru ajutor !

[RaduDNS]

Acum 20 ore, Rumburak a spus:

Pinii UART NU se pot arde prin punerea in scurt, la GND sau +5V.

Mulțumesc pentru aceste informații.

[informer]

La 26.03.2026 la 20:57, RaduDNS a spus:

Nu dispun și nici nu am cum să apelez la cineva pentru o astfel de analiză.

Pai daca intentionezi sa experimentezi in continuare cu astfel de dispozitive, ar fi foarte bine pentru tine sa "dispui".
Cred ca 50-150 ron (cateva burgere/beri) pentru un analizor logic clona Saleae or sa-ti raspunda la multe intrebari si or sa-ti faca munca mult mai usoara.

Edited March 28 by informer