beginners vragen

hallo,

heb een arduino mega, met een nextion 7"touchscreen
mn program/menu voor de nextion werkt en is geupload

voor de knop "afschuimer heb ik ‘b0’ en ‘b1’ gebruik 0 is aan en 2 uit
dit gaan door tot alle 8 relais, dus in totaal 16 knoppen.
hoe kan ik dit nu het beste schtijven voor de arduino.
kom er niet uit.

dit heb ik tot nu toe

/*
* april 2016
* willy's arduino mega, nextion 7inch
* 8 kanaal reais kaart
* RTC 3231
*/

#include <doxygen.h>
#include <NexButton.h>
#include <NexConfig.h>
#include <NexCrop.h>
#include <NexGauge.h>
#include <NexHardware.h>
#include <NexHotspot.h>
#include <NexObject.h>
#include <NexPage.h>
#include <NexPicture.h>
#include <NexProgressBar.h>
#include <NexSlider.h>
#include <NexText.h>
#include <Nextion.h>
#include <NexTouch.h>
#include <NexWaveform.h>
#include <Wire.h>
#include <DS3232RTC.h>
#include "Arduino.h"

#define at_serial Serial1

#define RELAY1  52
#define RELAY2  50                    
#define RELAY3  48                        
#define RELAY4  46                       
#define RELAY5  44
#define RELAY6  42                     
#define RELAY7  40                        
#define RELAY8  38   

/*
 *******************************************************************
 * Nextion component for page:hoofd pagina
 * 
 *******************************************************************
 */
NexButton hoofd pagina = NexButton(0, b0, "b0");
NexButton relais pagina = NexButton(0, b1, "b1");
NexButton tijd datum = NexButton(0, b2, "b2");
NexText temperature = NexText(0, t1, "t1");
NexText hour = NexText(0, hour, "hour");
NexText minute = NexText(0, minute, "minute");
NexText second = NexText(0, seconde, "seconde");
NexText year = NexText(0, year, "year");
NexText month = NexText(0, month, "month");
NexText week = NexText(0, week, "week");
NexText day = NexText(0, day, "day");

/*
 *******************************************************************
 * Nextion component for page:relais pagina
 * 
 *******************************************************************
 */
NexButton b0 = NexButton(1, bo, "b0");
NexButton b1 = NexButton(1, b1, "b1");
NexButton b2 = NexButton(1, b2, "b2");
NexButton b3 = NexButton(1, b3, "b3");
NexButton b4 = NexButton(1, b4, "b4");
NexButton b5 = NexButton(1, b5, "b5");
NexButton b6 = NexButton(1, b6, "b6");
NexButton b7 = NexButton(1, b7, "b7");
NexButton b8 = NexButton(1, b8, "b8");
NexButton b9 = NexButton(1, b9, "b9");
NexButton b10 = NexButton(1, b10, "b10");
NexButton b11 = NexButton(1, b11, "b11");
NexButton b12 = NexButton(1, b12, "b12");
NexButton b13 = NexButton(1, b13, "b13");
NexButton b14 = NexButton(1, b14, "b14");
NexButton b15 = NexButton(1, b15, "b15");
NexButton b16 = NexButton(1, b16, "b16");
NexButton b17 = NexButton(1, b17, "b17");
NexButton b18 = NexButton(1, b18, "b18");

/*
 *********************************************************************
 *Nextion component for page: tijd datum
 *
 *********************************************************************
 */
NexText sethour = NexText(2, sethour, "sethour");
NexText setmin = NexText(2, setminute, "setminute");
NexText setday = NexText(2, setday, "setday");
NexText setmon = NexText(2, setmonth, "setmonth");
NexText setyear = NexText(2, setyear1, "setyear1");
NexText setyear = NexText(2, setyear2, "setyear2");

void setup() 

  {    
  // Initialize the Arduino data pins for OUTPUT
  pinMode(RELAY1, OUTPUT);       
  pinMode(RELAY2, OUTPUT);
  pinMode(RELAY3, OUTPUT);
  pinMode(RELAY4, OUTPUT);
  pinMode(RELAY5, OUTPUT);       
  pinMode(RELAY6, OUTPUT);
  pinMode(RELAY7, OUTPUT);
  pinMode(RELAY8, OUTPUT);
  
//setting all pins to high so that all relays are off at start
  digitalWrite(RELAY1,HIGH);    
  digitalWrite(RELAY2,HIGH);    
  digitalWrite(RELAY3,HIGH);  
  digitalWrite(RELAY4,HIGH);      
  digitalWrite(RELAY5,HIGH);    
  digitalWrite(RELAY6,HIGH);    
  digitalWrite(RELAY7,HIGH);    
  digitalWrite(RELAY8,HIGH);  
  
  //wait for serial connect from COM Port
  while (!Serial);
  Serial.begin(19200);
}

void loop()
{
  String command;
  char charBuf[5];
  
  //waiting for data command
  if(Serial.available() > 0)
  {
    command = Serial.readStringUntil('\r');
    command.toCharArray(charBuf, 5);
  }
  else
    return;

  //-1 - off relay 01 
  //+1 - on relay 01
  
  if  (charBuf[0]=='+') //relay off
    SetStatus(true, charBuf[1]);
  else if (charBuf[0]=='-') //relay on
    SetStatus(false, charBuf[1]);  
  }

  void SetStatus(boolean on,char relayNumber)
  {
    int relayState =0;//off 
    if (on)
      relayState =1;//on 

    switch (relayNumber) {
    case '1':
      digitalWrite(RELAY1,relayState);        
      break;
    case '2':
      digitalWrite(RELAY2,relayState);        
      break;
    case '3':
      digitalWrite(RELAY3,relayState);        
      break;
    case '4':
      digitalWrite(RELAY4,relayState);        
      break;
    case '5':
      digitalWrite(RELAY5,relayState);        
      break;
    case '6':
      digitalWrite(RELAY6,relayState);        
      break;
    case '7':
      digitalWrite(RELAY7,relayState);        
      break;
    case '8':
      digitalWrite(RELAY8,relayState);        
      break;
    }
  }


void loop() {
  // put your main code here, to run repeatedly:

}

Geen idee wat je wil, waar je mee bezig bent, en wat je vraag nou eigenlijk is.

Ik zou voor een event driven aanpak kiezen. Alle button events verwijzen naar dezelfde routine omdat je uit de event info al kan bepalen welke button je binnen hebt gekregen.
Alle Relais kun je in een tabel zetten. Op deze manier kan de code veel compacter worden.
Verder kun je voor de Nextion volstaan met alleen:

#include "Nextion.h"

En heb je dit al eens gecompileerd?

nicoverduin:
Ik zou voor een event driven aanpak kiezen. Alle button events verwijzen naar dezelfde routine omdat je uit de event info al kan bepalen welke button je binnen hebt gekregen.
Alle Relais kun je in een tabel zetten. Op deze manier kan de code veel compacter worden.
Verder kun je voor de Nextion volstaan met alleen:

#include "Nextion.h"

En heb je dit al eens gecompileerd?

heb idd nog niet compileerd, wil eerst mn relais code schrijven en zo stap verder uitbreiden.
heb ook nog een RTC en Temp sensor liggen.
zal nog ff een screen shot post met de knop ID's erbij

hier de screen shot

nicoverduin:
Ik zou voor een event driven aanpak kiezen. Alle button events verwijzen naar dezelfde routine omdat je uit de event info al kan bepalen welke button je binnen hebt gekregen.
Alle Relais kun je in een tabel zetten. Op deze manier kan de code veel compacter worden.
Verder kun je voor de Nextion volstaan met alleen:

#include "Nextion.h"

En heb je dit al eens gecompileerd?

kan en wil een voorbeeld geven @nicoverduin?? op internet kan je veel vinden maar een simpel
voor beeld wat ik wil kan ik niet vinden

Hoi William,
Bedoel je zo iets?

youtu.be/qftD3McpXf0 en bekijk ook het andere deel.
ik heb dit deel voor deel opgebouwd, eerst 1 toets met led(lees relias),
als je dat hebt, is de uitbreiding eenvoudig en kan je hem als alles werkt mooier maken.

grt Vic

je schrijft if(on) { relay aan} maar dan moet er nog wel een else komen dus relay uit.
\

@william:
a) Je gaat een hele batterij fouten uit de compilatie krijgen. Je definitie van je buttons is niet juist. De 2e parameter moet een numeriek getal zijn. “b0” is de naam van de button binnen nextion. De eerste parameter is het schermnummer.
b) compButton.ino in de voorbeelden is een voorbeeld van eventdriven buttonacties. (elke keer als de button wordt losgelaten wordt de event (gebeurtenis) routine aangeroepen.
c) Als je alle buttons die dezelfde actie hebben (alleen een ander relais) kun je ze allemaal naar dezelfde routine verwijzen.
d) in die routine wordt een parameter gegeven. Deze verwijst naar het NexButton object in jouw programma. Het is een pointer dus die kun je vergelijken met &b0 of &b1 enz.
e) En hier is het veel interessanter om een array te maken van al die buttons. Dan kun je gewoon de array aflopen om te kijken welke button het event heeft afgevuurd. En door de index in de array weet je gelijk welke het is.
f) ik was al begonnen maar ik ben ff een week uit de lucht. Dus je kan hier op verder voortborduren of eerst een test programma maken.

#include "Arduino.h"
#include "Nextion.h"


#define MENU_PAGINA 1			// button pagina
#define AANTAL_BUTTONS 10		// we hebben in dit voorbeeld 10 buttons

NexButton buttonArray[AANTAL_BUTTONS] = {
		{ MENU_PAGINA,  0, "b0" },
		{ MENU_PAGINA,  1, "b1" },
		{ MENU_PAGINA,  2, "b2" },
		{ MENU_PAGINA,  3, "b3" },
		{ MENU_PAGINA,  4, "b4" },
		{ MENU_PAGINA,  5, "b5" },
		{ MENU_PAGINA,  6, "b6" },
		{ MENU_PAGINA,  7, "b7" },
		{ MENU_PAGINA,  8, "b8" },
		{ MENU_PAGINA,  9, "b9" }
};

int8_t lastButtonPressed;				// Deze functie bevat de laatst los gelaten button
/**
 * de volgende lijst bevat alle buttons waarnaar geluisterd moet worden als we nexLoop() aanroepen
 */
NexTouch *nex_listen_list[] =
{
	&buttonArray[0]	,
	&buttonArray[1]	,
	&buttonArray[2]	,
	&buttonArray[3]	,
	&buttonArray[4]	,
	&buttonArray[5]	,
	&buttonArray[6]	,
	&buttonArray[7]	,
	&buttonArray[8]	,
	&buttonArray[9]	,
	&buttonArray[10],
    NULL
};

/*
 * De nextionon library zal nu elke keer dat er een button wordt losgelaten
 * deze functie aanroepen. ptr bevat het adres van(pointer naar) het buttonobject
 * in dit programma
 */
void buttonPopCallback(void *ptr)
{
	int8_t selectedButton = -1;			// default onbekende button
    NexButton *btn = (NexButton *)ptr;	// we hebben nu een pointer naar onze button
    //
    // bepalen welke button het is in de array
    //
    for (uint8_t i = 0; i < AANTAL_BUTTONS; i++){
    	if (btn == &buttonArray[i]) {
    		//
    		// button gevonden
    		//
    		selectedButton = i;
    		//
    		// en spring uit de loop
    		//
    		break;
    	}
    }
    //
    // bewaar de laatste ingedrukte knop
    //
    lastButtonPressed = selectedButton;
}

void setup(void)
{
    //
	// opstarten Nextions scherm en verbinding
	///
    nexInit();
    //
    // koppel alle buttons aan dezelfde call back functie
    //
    for (uint8_t i = 0; i < AANTAL_BUTTONS; i++) {
    	buttonArray[i].attachPop(buttonPopCallback, &buttonArray[i]);
    }
}

void loop(void)
{
	//
	// eerst kijken of er een button is losgelaten van de buttons in nex_listen_list
	// je kan dus bijvoorbeeld meerdere lijsten nemen
	//
    nexLoop(nex_listen_list);
    //
    // Nu kun je kijken welke knop is ingedrukt of geen
    //
    if (lastButtonPressed != -1) {
    	//
    	// er is een knop ingedrukt en je weet nu welke
    	//

    	//
    	// indicatie gelijk dat je hem verwerkt hebt
    	//
    	lastButtonPressed = -1;
    }
}

En ik zou 2-state buttons overwegen ipv one state.

nicoverduin:
@william:
a) Je gaat een hele batterij fouten uit de compilatie krijgen. Je definitie van je buttons is niet juist. De 2e parameter moet een numeriek getal zijn. “b0” is de naam van de button binnen nextion. De eerste parameter is het schermnummer.
b) compButton.ino in de voorbeelden is een voorbeeld van eventdriven buttonacties. (elke keer als de button wordt losgelaten wordt de event (gebeurtenis) routine aangeroepen.
c) Als je alle buttons die dezelfde actie hebben (alleen een ander relais) kun je ze allemaal naar dezelfde routine verwijzen.
d) in die routine wordt een parameter gegeven. Deze verwijst naar het NexButton object in jouw programma. Het is een pointer dus die kun je vergelijken met &b0 of &b1 enz.
e) En hier is het veel interessanter om een array te maken van al die buttons. Dan kun je gewoon de array aflopen om te kijken welke button het event heeft afgevuurd. En door de index in de array weet je gelijk welke het is.
f) ik was al begonnen maar ik ben ff een week uit de lucht. Dus je kan hier op verder voortborduren of eerst een test programma maken.

#include "Arduino.h"

#include “Nextion.h”

#define MENU_PAGINA 1 // button pagina
#define AANTAL_BUTTONS 10 // we hebben in dit voorbeeld 10 buttons

NexButton buttonArray[AANTAL_BUTTONS] = {
{ MENU_PAGINA,  0, “b0” },
{ MENU_PAGINA,  1, “b1” },
{ MENU_PAGINA,  2, “b2” },
{ MENU_PAGINA,  3, “b3” },
{ MENU_PAGINA,  4, “b4” },
{ MENU_PAGINA,  5, “b5” },
{ MENU_PAGINA,  6, “b6” },
{ MENU_PAGINA,  7, “b7” },
{ MENU_PAGINA,  8, “b8” },
{ MENU_PAGINA,  9, “b9” }
};

int8_t lastButtonPressed; // Deze functie bevat de laatst los gelaten button
/**

  • de volgende lijst bevat alle buttons waarnaar geluisterd moet worden als we nexLoop() aanroepen
    */
    NexTouch *nex_listen_list =
    {
    &buttonArray[0] ,
    &buttonArray[1] ,
    &buttonArray[2] ,
    &buttonArray[3] ,
    &buttonArray[4] ,
    &buttonArray[5] ,
    &buttonArray[6] ,
    &buttonArray[7] ,
    &buttonArray[8] ,
    &buttonArray[9] ,
    &buttonArray[10],
        NULL
    };

/*

  • De nextionon library zal nu elke keer dat er een button wordt losgelaten
  • deze functie aanroepen. ptr bevat het adres van(pointer naar) het buttonobject
  • in dit programma
    */
    void buttonPopCallback(void *ptr)
    {
    int8_t selectedButton = -1; // default onbekende button
        NexButton *btn = (NexButton *)ptr; // we hebben nu een pointer naar onze button
        //
        // bepalen welke button het is in de array
        //
        for (uint8_t i = 0; i < AANTAL_BUTTONS; i++){
        if (btn == &buttonArray[i]) {
        //
        // button gevonden
        //
        selectedButton = i;
        //
        // en spring uit de loop
        //
        break;
        }
        }
        //
        // bewaar de laatste ingedrukte knop
        //
        lastButtonPressed = selectedButton;
    }

void setup(void)
{
    //
// opstarten Nextions scherm en verbinding
///
    nexInit();
    //
    // koppel alle buttons aan dezelfde call back functie
    //
    for (uint8_t i = 0; i < AANTAL_BUTTONS; i++) {
    buttonArray[i].attachPop(buttonPopCallback, &buttonArray[i]);
    }
}

void loop(void)
{
//
// eerst kijken of er een button is losgelaten van de buttons in nex_listen_list
// je kan dus bijvoorbeeld meerdere lijsten nemen
//
    nexLoop(nex_listen_list);
    //
    // Nu kun je kijken welke knop is ingedrukt of geen
    //
    if (lastButtonPressed != -1) {
    //
    // er is een knop ingedrukt en je weet nu welke
    //

//
    // indicatie gelijk dat je hem verwerkt hebt
    //
    lastButtonPressed = -1;
    }
}



En ik zou 2-state buttons overwegen ipv one state.

@nicoverduin, je bent geweldig met je hulp. hier is een kwartje gevallen. THANKS

DuikerVic:
Hoi William,
Bedoel je zo iets?

youtu.be/qftD3McpXf0 en bekijk ook het andere deel.
ik heb dit deel voor deel opgebouwd, eerst 1 toets met led(lees relias),
als je dat hebt, is de uitbreiding eenvoudig en kan je hem als alles werkt mooier maken.

grt Vic

dat is idd, het geen wat ik zocht als voorbeeld, thanks voor je hulp

nou we liggen stil, scherm opgeblazen. grrr
wou het scherm voeden via de arduino, ging mn scherm knipperen dacht ik geef het scherm een eigen voeding en dan het signaal wel van de arduino, nou dat is te veel geweest.

hier heb ik de code van nicoverduin, aangepast naar het aantal buttons wat ik wil.
en het compileren werkt ook nog,

#include "Arduino.h"
#include "Nextion.h"


#define RELAIS_PAGINA 1      // button pagina
#define AANTAL_BUTTONS 17   // we hebben in dit voorbeeld 16 buttons

NexButton buttonArray[AANTAL_BUTTONS] = {
    { RELAIS_PAGINA,  0, "b0" },
    { RELAIS_PAGINA,  1, "b1" },
    { RELAIS_PAGINA,  2, "b2" },
    { RELAIS_PAGINA,  3, "b3" },
    { RELAIS_PAGINA,  4, "b4" },
    { RELAIS_PAGINA,  5, "b5" },
    { RELAIS_PAGINA,  6, "b6" },
    { RELAIS_PAGINA,  7, "b7" },
    { RELAIS_PAGINA,  8, "b8" },
    { RELAIS_PAGINA,  9, "b9" },
    { RELAIS_PAGINA,  10, "b10" },
    { RELAIS_PAGINA,  11, "b11" },
    { RELAIS_PAGINA,  12, "b12" },
    { RELAIS_PAGINA,  13, "b13" },
    { RELAIS_PAGINA,  14, "b14" },
    { RELAIS_PAGINA,  15, "b15" },
    { RELAIS_PAGINA,  16, "b16" },
    
};

int8_t lastButtonPressed;       // Deze functie bevat de laatst los gelaten button
/**
 * de volgende lijst bevat alle buttons waarnaar geluisterd moet worden als we nexLoop() aanroepen
 */
NexTouch *nex_listen_list[] =
{
  &buttonArray[0] ,
  &buttonArray[1] ,
  &buttonArray[2] ,
  &buttonArray[3] ,
  &buttonArray[4] ,
  &buttonArray[5] ,
  &buttonArray[6] ,
  &buttonArray[7] ,
  &buttonArray[8] ,
  &buttonArray[9] ,
  &buttonArray[10],
  &buttonArray[11],
  &buttonArray[12],
  &buttonArray[13],
  &buttonArray[14],
  &buttonArray[15],
  &buttonArray[16],
    NULL
};

/*
 * De nextionon library zal nu elke keer dat er een button wordt losgelaten
 * deze functie aanroepen. ptr bevat het adres van(pointer naar) het buttonobject
 * in dit programma
 */
void buttonPopCallback(void *ptr)
{
  int8_t selectedButton = -1;     // default onbekende button
    NexButton *btn = (NexButton *)ptr;  // we hebben nu een pointer naar onze button
    //
    // bepalen welke button het is in de array
    //
    for (uint8_t i = 0; i < AANTAL_BUTTONS; i++){
      if (btn == &buttonArray[i]) {
        //
        // button gevonden
        //
        selectedButton = i;
        //
        // en spring uit de loop
        //
        break;
      }
    }
    //
    // bewaar de laatste ingedrukte knop
    //
    lastButtonPressed = selectedButton;
}

void setup(void)
{
    //
  // opstarten Nextions scherm en verbinding
  ///
    nexInit();
    //
    // koppel alle buttons aan dezelfde call back functie
    //
    for (uint8_t i = 0; i < AANTAL_BUTTONS; i++) {
      buttonArray[i].attachPop(buttonPopCallback, &buttonArray[i]);
    }
}

void loop(void)
{
  //
  // eerst kijken of er een button is losgelaten van de buttons in nex_listen_list
  // je kan dus bijvoorbeeld meerdere lijsten nemen
  //
    nexLoop(nex_listen_list);
    //
    // Nu kun je kijken welke knop is ingedrukt of geen
    //
    if (lastButtonPressed != -1) {
      //
      // er is een knop ingedrukt en je weet nu welke
      //

      //
      // indicatie gelijk dat je hem verwerkt hebt
      //
      lastButtonPressed = -1;
    }
}

Hoezo opgeblazen? Die grote schermen moeten altijd een eigen voedung hebben.

nicoverduin:
Hoezo opgeblazen? Die grote schermen moeten altijd een eigen voedung hebben.

dat heb ik dus ook gedaan, eerst deed ik de arduino voeden via de pc usb en de nextion volledig op de arduino
dat gaf knipperend beeld.
toen de ieder zn eigen voeding en dat was dus niet goed, zal vast iets niet goed aangesloten hebben.

wacht nog op mn pakjes uit het verre oosten, dan kan ik weer verder.

Heb je wel de GNDS van beide (Arduino en Scherm) door verbonden?

neem aan dat bedoeld de ground- van het scherm op een ground contact van de arduino??

en heb ook voor de + 5v uitgang gebruikt

Als je meerder apparaten gebruikt met eigen voedingen, dan moet je alleen alle GNDS verbinden om zo een gemeenschappelijk referentie punt te krijgen. 5V aftappen van de Arduino is zinloos maar nog geen reden om het scherm kapot te laten gaan. Wat nog wel eens helpt is een default scherm op een SD zetten en dan vanaf de SD reloaden. Mogelijk herstel je zo de STM32 chip op je scherm waarna hij weer werkt. Vermoedelijk is de flash opgeblazen door de instortende voeding van de Arduino.

correct if i'm wrong

dus de 9v + naar de arduino vanaf mn trafo (heb een 9v dc trafo)
de 12V + naar mn relais shield
en de 5v+ vanaf de arduino naar mn nextion
en alles GND - bij elkaar lassen via een breadboard?? bijvoorbeeld

wacht nog steeds op post uit het verre oosten

Op post uit het verre oosten kun je vaak lang wachten, grootste vertraging is meestal de douane van je eigen land.

Je Arduino heeft meerdere GND aansluitingen, en die zitten allemaal aan elkaar.
Als een aansluiting de naam deelt met een andere aansluiting, dan zijn ze ook gewoon verbonden met elkaar.
Dus GND en GND zijn met elkaar verbonden.
Bijvoorbeeld AGND, DGND en GND zijn niet per se met elkaar verbonden, en moet je ook uit elkaar houden als je iets gaat aansluiten.

De 5 volt uit je Arduino word op je Arduino boardje gedestilleerd (das inclusief warmteproductie) uit de 9 volt die je uit je voedingsmodule haalt en op de stekker van je Arduino aansluit.
Die 5 volt is wel ruim voldoende voor de Arduino zelf, en kun je wel gebruiken voor heel kleine belastingen, maar voor je schermpje zou ik het absoluut niet doen.
Daarvoor heb je dus een aparte gestabiliseerde 5 volt nodig, en ik vermoed dat dat is wat Nico je probeerde te vertellen.
De min van die extra 5 volt sluit je dan dus ook aan op GND van zowel schermpje als die van de Arduino, en de plus sluit je alleen aan op de 5 volt aansluiting van je schermpje.

MAS3:
Daarvoor heb je dus een aparte gestabiliseerde 5 volt nodig, en ik vermoed dat dat is wat Nico je probeerde te vertellen.
De min van die extra 5 volt sluit je dan dus ook aan op GND van zowel schermpje als die van de Arduino, en de plus sluit je alleen aan op de 5 volt aansluiting van je schermpje.

Yep. Een 7"tft scherm trekt wel wat meer als een paar honderd mA. Namelijk 510mA in max brightness. Zie : NX8048T070 - ITEAD Wiki
Dat gaat die Arduino never nooit leveren!!!!