Example with len superior of 02

[plckr]

I cannot find any example with second parameter (len) superior of 02
I tried to do this to catch the next 3 bytes:

Nextion button:

printh 23 03 4c 01 01

C++ code:

    case 'L':
      Serial.println(_serial->read());
      break;

the above code reports 01 only, and not the entire combination like "01 01"

Is there anything to combine both in single variable?
Or how do you do in your cases?

EDIT: when first posted I said it reports twice but I was wrong. It is reporting only once

[Seithan]

Hello,

From what I can understand, you are using the custom commands, with one new command group "L".

You are receiving only one, because with Serial.println(_serial->read()); , you read only one byte. To read the next byte, you will need to make one more _serial->read()

In your example, you will to write one more time Serial.println(_serial->read());

Also, len is used for us to know if all the bytes arrived. It is also used to know how many bytes we are going to have to handle in the code.

Whatever you need, do not hesitate to write :)

[plckr]

Ok, I get it.
Anyways, one suggestion is to pass the content based on the length inserted into the custom command, I think it's more useful that way for the user

for example, you can capture the content, store it in a class variable and call the function, then in user custom commands, anyone can call that variable to get the value more easy

EDIT: Or maybe more efficient, declare a weak function for custom commands, and if command isn't "P" or "T", it calls the weak function with two parameters, the command letter, and the content based on the . That way, the user don't need to change the library files, staying it intact

Didn't tested, but here's the idea
header file

extern void readCustomCommand(); 
extern void readCustomCommand() __attribute__((weak));

readCustomCommands.cpp

void EasyNex::readCommand(){
  switch(_cmd1){
    case 'P':
	  /* code here for P */
      break;
	  
    case 'T':
	  /* code here for T */
      break;
  }
	  
  /* _data computed and stored in class variable before reaching here */
  readCustomCommand(_cmd1, _data, _len);
}

[Seithan]

I understand your point .
For that reason we have the trigger functions, where there are declared as weak attribute extern void trigger1() __attribute__((weak));
So a user can easily and without modifying the library's files call a trigger() and read or write any value at any variable or run a piece of code.

The readCustomCommands has a different meaning and it is used for a custom protocol feature. You can read about it at this link:
https://seithan.com/Easy-Nextion-Library/Custom-Protocol/

I also have in mind to make the custom protocol as a weak function but as it is a very special feature and only advanced on programing users can use it, it is not necessary for them, as they can easily modify the .cpp file of the library.

It will be good to avoid modifying on library's file, as an update of library can erase the custom code.
I will do that in next update (declare the customProtocol as weak and make the add-ons from the code).

examples for trigger function

void trigger1(){
int x = 22;  // set value of variable x equal to 22

x = myNex.readNumber("n0.val");   // We read the value of n0 and store it to number variable

}

If you want to capture a value or to turn ON/OFF a relay you don't have to complicate it with a custom protocol as you simply use the trigger function.
See at trigger example of the library

https://github.com/Seithan/EasyNextionLibrary/blob/master/examples/Trigger/TriggerCode/TriggerCode.ino

I hope that I have answered your questions.

[plckr]

In the last days, I spent reading your docs, some of them more than once to fully understand how this library works.
I really understand the trigger function, but for me, I find it not appealing because function names like trigger1 makes no sense when you have a lot of triggers. In my case, I'll have maybe 40 triggers for the letter L, more 10 for letter 'S', and probably more will come.
Sure I can edit the library source code, but I'm using platformio for programming, and sometimes platformio downloads the library, making my changes deleted

[Seithan]

Ok, for the moment and until I make the changes, you can write the code for case letter L in a function in your code, like
void letterLCase(){ // code for read bytes etc }

and you can call it from readCustomCommands.cpp with only one line

void EasyNex::readCommand(){
  switch(_cmd1){

    case 'L':
	letterLCase();
      break;

    case 'P':
	  /* code here for P */
      break;
	  
    case 'T':
	  /* code here for T */
      break;
  }
	  
}

Also an array like this always helps to handle many cases

const uint8_t TOTAL_RELAY = 6    // How many warning relays we use


const uint8_t relayPin[TOTAL_RELAY] = {2, 3, 4, 5, 6, 7};  // assigns the pin number for every relay
 /*
  * Declare that pin D2 is the pin that controls the Relay No0 (front lights)
  * Declare that pin D3 is the pin that controls the Relay No1 (Backyard lights)
  * Declare that pin D4 is the pin that controls the Relay No2 (swimming pool lights)
  * Declare that pin D5 is the pin that controls the Relay No3 (roofgarden lights)
  * Declare that pin D6 is the pin that controls the Relay No4 (adviser lights)
  * Declare that pin D7 is the pin that controls the Relay No5 (extra auxiliary lights)
  */

[plckr]

I did some changes in your code, and it seems to work as expected, I didn't coded the data variable but the rest is working.

At the end of the EasyNextionLibrary.h

extern void easyNexReadCustomCommand(uint8_t _cmd1, uint8_t _len);
extern void easyNexReadCustomCommand(uint8_t _cmd1, uint8_t _len) __attribute__((weak));

readCustomCommands.cpp

void EasyNex::readCommand(){		
  switch(_cmd1){
    case 'P': 
      /* code */   
      break;
      
    case 'T':
      /* code */
      break;

    default:
      easyNexReadCustomCommand(_cmd1, _len);
}

In my main.cpp -> Example of incoming serial data -> printh 23 03 4c 01 01

void easyNexReadCustomCommand(uint8_t cmd1, uint8_t len) {
  Serial.println(cmd1, HEX); //This is reporting the letter as expected -> 4C
  Serial.println(len); // Reporting the correct length -> 03
}

The only thing left is the content being captured and passed into the function.
What do you think?

[Seithan]

let me see it more carefully

[plckr]

if you can point me the direction to catch the data, I can try to make a pull request if you want

[plckr]

• Declare that pin D2 is the pin that controls the Relay No0 (front lights)
• Declare that pin D3 is the pin that controls the Relay No1 (Backyard lights)
• Declare that pin D4 is the pin that controls the Relay No2 (swimming pool lights)
• Declare that pin D5 is the pin that controls the Relay No3 (roofgarden lights)
• Declare that pin D6 is the pin that controls the Relay No4 (adviser lights)
• Declare that pin D7 is the pin that controls the Relay No5 (extra auxiliary lights)

This is the way I'm using.
I'm using an Array of Objects, one Array for letter L, another for S

This example mentioned earlier printh 23 03 4c 01 01 defined both the id of the Array and the state it should change (00 or 01)
And for letter S the first Byte is the id, and the second is a number between 0 and 100 (percentage)

[Seithan]

Ok,
This seems nice approach, as I have it in my mind.

1. we do not need the len, as len used to declare the number of bytes we are waiting in order to have a completed command
2. void easyNexReadCustomCommand must be in the code (.ino file) I believe with main.ccp is the user code in the compiler that you are using

so the code inside the void easyNexReadCustomCommand is uppon the user is that right?

[Seithan]

if you can point me the direction to catch the data, I can try to make a pull request if you want

No problem with the point to the direction
As for the pull request I believe that it will be better to make the changes my self and of course to mention your name for the help on that

[plckr]

1. I don't need the len in my code, until for now atleast. But could be useful if the Group Letter have different lengths.
2. Correct!

If user wants to implement Group Commands/Letters, he has to declare the function himself. If don't, just ignore and don't declare.

[plckr]

Will you intend to implement the data being parsed into the function?
I think that would be very useful.

[Seithan]

So from users code file you can use the switch function again
For more accurate code you must tell me what the id's is going to used for,
example you only need to change the value of the array?

[plckr]

This is an example of my idea

void easyNexReadCustomCommand(uint8_t cmd1, uint8_t len, char data) {
  switch(cmd1){
    case 'L':
      lights[(int)data[0]].setState((int)data[1]);
      break;
    
    case 'S':
      shutters[(int)data[0].setLevel((int)data[1])];
      break;
  }
}

Something like this, if it makes sense