Reset Problem mit Arduino Uno, Nextion HMI und MCP2515

Servus zusammen,

habe lange immer wieder mal mitgelesen und viele kleinere Programme geschrieben und getestet.
Nun wollte ich diese zusammenbringen und teilweise klappt es auch, jedoch funktioniert mein Programm nur direkt nach dem Flashen bzw. wenn ich “bestromt” die Platine über den Knopf resete.

Spannungsversorgung kommt über einen DC/DC der den Bildschirm und den Uno versorgt. Hat es evtl. etwas mit dem Nextion Availible zu run? Wie Syncronisieren sich die beiden das Sie “DA” sind?

Ich lese meine bald vorhandenen Buttons am Display aus und sende dann ein entsprechendes Can Frame.

Da ich die Serielle TX RX Schnittstelle am Uno nicht verwenden kann benutze ich 5&6. Zudem würde ich gerne den Spannungs “Wert” an das Display übertragen. Hier klappt aber keine der ganzen Varianten mit nextion.Print
oder nextion.write und dann auf das vorhandene TXT Feld. Vll. kann mir hier auch noch einer von euch einen Tipp geben oder ein Codeschnippsel.

Vielen Dank euch

Gruß

#include <SPI.h>                              //Library  SPI Communication 
#include <mcp2515.h>                          //Library  CAN Communication
#include <SoftwareSerial.h>                   //Library NEXTION Communication

SoftwareSerial nextion(6, 5);                 // RX, TX PINS
String daten_display = "";                    // leerer String

double Spannung = A5;

struct can_frame canMsg;
MCP2515 mcp2515(10);

void setup() {

  SPI.begin();                                
  nextion.begin(9600);
  pinMode(Spannung, INPUT);
//Serial.begin(38400);
  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);  
  mcp2515.setNormalMode();

 
}
void loop() {                                 

double Wert =  analogRead(Spannung) * 0.0048275855327468 * 3.000216589861751;

if (nextion.available() > 0) {
daten_display += char (nextion.read());
}

if (daten_display == "FSP_CLEAR"){

    canMsg.can_id  = 0x456;                     
    canMsg.can_dlc = 8;                         
    canMsg.data[0] = 0x33;                      
    canMsg.data[1] = 0x04;
    canMsg.data[2] = 0xFF;
    canMsg.data[3] = 0xFF;
    canMsg.data[4] = 0xFF;
    canMsg.data[5] = 0xFF;
    canMsg.data[6] = 0x00;
    canMsg.data[7] = 0x00;
    mcp2515.sendMessage(&canMsg);               //Sends the CAN message
   
    daten_display="";
  }

  
  }

Du schreibst nirgendwo in dem Sketch zum Nextion, also können wir Dir auch nicht sagen, was Du dabei falsch machst.

Gruß Tommy

Servus Thommy,

ja habe ich wieder gelöscht, weil mein Hauptproblem darin besteht das ich kein CANFrame sende solange ich den Uno nicht resetiert habe.

Das ganze soll ein automatisches Fehlerspeicher Löschgerät werden. Daher ist der plan das anzustecken, von dort kommt auch die Versorgungsspannung.

Wenn das gefixed ist mache ich mit dem Batteriespannung senden an den Nextion weiter.

Gruß

Bernd

vergesst den oberen Post :slight_smile:
ich glaube ich habe es selbst gelöst, ein kleines delay scheint zu helfen
Mache mich jetzt an den Nextion übertrag und melde mich hier nochmals mit dem neuen Programm.

 delay(200);
  SPI.begin();                                //Begins SPI communication
  while (!nextion);
  nextion.begin(9600);
  pinMode(Spannung, INPUT);
//Serial.begin(38400);
  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);  //Sets CAN at speed 500KBPS and Clock 8MHz
  mcp2515.setNormalMode();

Und was genau möchtest du hiermit

while (!nextion);

erreichen ?

Guten Morgen,

@Dieter: keine Ahnung… is schon wieder raus… hab alles versucht was ich ergooglen konnte.

Senden von Werten geht auch, habe zuvor falsch konvertiert.

Also, nun stehe ich an diesem Punkt, dass die Kommunikation grundlegend funktioniert, auf der ersten Seite gehen die 4 Buttons und der MCP schickt meinen Frame.

Sobald ich auf die zweite oder dritte Seite umschalte, jeweils auch 4 Buttons mit 1-12 durchnummeriert passiert folgendes:

Auf dem SerialPrint liegt der analogeingang und der String “daten_display”, also die leeren Felder entspricht dem leeren String.

07:38:23.688 →
07:38:23.793 →

Hier wechsle ich die Seite

07:38:20.724 -> 
07:38:20.827 -> 
07:38:20.929 -> 
07:38:21.033 -> 
07:38:21.137 -> 
07:38:21.240 -> 
07:38:21.345 -> 
07:38:21.449 -> 
07:38:21.551 -> 
07:38:21.656 -> 3.26
07:38:21.656 -> 136
07:38:21.656 -> 
07:38:21.758 -> 
07:38:21.862 -> 
07:38:21.967 -> 
07:38:22.071 -> 
07:38:22.182 -> 
07:38:22.244 -> 
07:38:22.349 -> 
07:38:22.454 -> 
07:38:22.558 -> 
07:38:22.659 -> 3.28
07:38:22.659 -> 136
07:38:22.694 -> 
07:38:22.796 -> 
07:38:22.865 -> 
07:38:22.967 -> 
07:38:23.071 -> 
07:38:23.173 -> 
07:38:23.274 -> 
07:38:23.377 -> 
07:38:23.480 -> 
07:38:23.585 -> 
07:38:23.688 -> 3.26
07:38:23.688 -> 137
07:38:23.688 -> 
07:38:23.793 -> 
07:38:23.895 -> ⸮
07:38:23.999 -> ⸮⸮
07:38:24.102 -> ⸮⸮⸮
07:38:24.204 -> ⸮⸮⸮
07:38:24.307 -> ⸮⸮⸮
07:38:24.408 -> ⸮⸮⸮
07:38:24.510 -> ⸮⸮⸮
07:38:24.612 -> ⸮⸮⸮
07:38:24.714 -> 3.26
07:38:24.714 -> 137
07:38:24.714 -> ⸮⸮⸮
07:38:24.815 -> ⸮⸮⸮
07:38:24.918 -> ⸮⸮⸮⸮
07:38:25.021 -> ⸮⸮⸮⸮⸮
07:38:25.122 -> ⸮⸮⸮⸮⸮⸮
07:38:25.225 -> ⸮⸮⸮⸮⸮⸮
07:38:25.325 -> ⸮⸮⸮⸮⸮⸮
07:38:25.426 -> ⸮⸮⸮⸮⸮⸮
07:38:25.528 -> ⸮⸮⸮⸮⸮⸮
07:38:25.633 -> ⸮⸮⸮⸮⸮⸮
07:38:25.736 -> 3.26
07:38:25.736 -> 137
07:38:25.770 -> ⸮⸮⸮⸮⸮⸮
07:38:25.873 -> ⸮⸮⸮⸮⸮⸮
07:38:25.941 -> ⸮⸮⸮⸮⸮⸮⸮
07:38:26.044 -> ⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.146 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.250 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.354 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.455 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.557 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.661 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.764 -> 3.28
07:38:26.764 -> 135
07:38:26.797 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.867 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮
07:38:26.970 -> ⸮⸮⸮⸮⸮⸮⸮⸮⸮⸮

Ich verstehe nicht woher das kommt…

Hier mein aktueller Code:

#include <SPI.h>                              //Library for using SPI Communication 
#include <mcp2515.h>                          //Library for using CAN Communication
#include <SoftwareSerial.h>                   //Library for using NEXTION Communication

SoftwareSerial nextion(6, 5);                 // RX, TX PINS
String daten_display = "";                    // leerer Sting

int Spannung = A5;

struct can_frame canMsg;
MCP2515 mcp2515(10);

unsigned long previousMillis = 0;
unsigned long interval = 1000;

void setup() {

  SPI.begin();                                //Begins SPI communication
  nextion.begin(9600);
  pinMode(Spannung, INPUT);
  Serial.begin(38400);
  mcp2515.reset();
  mcp2515.setBitrate(CAN_500KBPS, MCP_8MHZ);  //Sets CAN at speed 500KBPS and Clock 8MHz
  mcp2515.setNormalMode();


}
void loop() {                                 // Hauptprogramm

  if (millis() - previousMillis > interval) {
    previousMillis = millis();

    double Wert =  analogRead(Spannung) * 0.0048875855327468 * 4.900216589861751;
    Serial.println(Wert);
    Serial.println(analogRead(Spannung));

    char Test[10];
    dtostrf(Wert, 2, 2, Test);

    nextion.print("v0.txt=\"");
    nextion.print(Test);
    nextion.write('"');

    nextion.write(0xff);
    nextion.write(0xff);
    nextion.write(0xff);

  }

  // daten_display = "";
  if (nextion.available()) {
    daten_display += char (nextion.read());
  }

  Serial.println(daten_display);


  if (daten_display == "01") {

    canMsg.can_id  = 0x561;                     //CAN id as 0x036
    canMsg.can_dlc = 8;                         //CAN data length as 8
    canMsg.data[0] = 0xFF;
    canMsg.data[1] = 0x64;
    canMsg.data[2] = 0xF4;
    canMsg.data[3] = 0xDF;
    canMsg.data[4] = 0xGF;
    canMsg.data[5] = 0xFF;
    canMsg.data[6] = 0x00;
    canMsg.data[7] = 0x00;
    mcp2515.sendMessage(&canMsg);               //Sends the CAN message

    daten_display = "";

    delay(2000);
  }

Woran erkennt dein Sketch, von welcher Nextion-Seite er Daten entgegen nehmen soll ?
Da kann ich nichts erkennen.

Das muss er m.M. nicht, da ich jedem mit Button einen "print 01" "print 02" Befehl übergebe, damit sendet er nur zahlen von 1 bis 12 und die werte ich aus.

Damit geht er in diese Bedingung -> if (daten_display == "01")

bernd_meier_123:
Das muss er m.M. nicht, da ich jedem mit Button einen "print 01" "print 02" Befehl übergebe, damit sendet er nur zahlen von 1 bis 12 und die werte ich aus.

Damit geht er in diese Bedingung -> if (daten_display == "01")

Hast du dir denn im seriellen Monitor mal angesehen, was tatsächlich übertragen wird ?