Forum Replies Created

Viewing 15 posts - 991 through 1,005 (of 1,006 total)
  • Author
    Posts
  • in reply to: DHT12 Esp8266 (D1Mini) OneWire conections & blynk #4675
    Renzo Mischianti
    Keymaster

      Hi LottyZak,

      The sensor is a DHT12, and the value -127 isn’t present.

      Can you put an example of your idea.

      Thanks Renzo

      Renzo Mischianti
      Keymaster

        Hi Rossic, yes D0 Reset is for wake up for deep sleep, thanks to share your experience. Bye Renzo

        Renzo Mischianti
        Keymaster

          Hi Rossic, It’s strange, do you have set the pull-up resistor?

          Renzo Mischianti
          Keymaster

            Hi Joergen,

            I think the relevant error is

            501 5.5.2 <mischianti:>: Helo command rejected: Invalid name

            probably you aren’t attached to the Sunrise contract line, and you can use SMTP only with Sunrise line.

            For example, if you have a Sunrise cellular line and you try to access SMTP via your home line the provider reject the request.

            As test (if you don’t use a mail client) you can try to configure a client like Outlook to send email from the same line.

             

            Tell me if is this the problem.

            Bye Renzo

            in reply to: EByte e32 sendFixedMessage Parameters Issue #4488
            Renzo Mischianti
            Keymaster

              Hi cglkr97,

              as you can see in the file at line 228 I add e32ttl.setMode(MODE_1_WAKE_UP); than I use simple Int value to set ADDH, ADDL and CHAN (I print the HEX value to check the channel).

              I don’t have problem to use decimal value instead HEX.

              I try to send a string value without problem, If you use ArduinoJSON pay attention the string generated isn’t clean value check this http://mischianti.org/forums/topic/how-to-send-message-use-json-format/

              But if you want use a String value remember that you have only 59Byte to send message and binary data like structure is good optimized.

              Bye Renzo

              in reply to: EByte e32 sendFixedMessage Parameters Issue #4461
              Renzo Mischianti
              Keymaster

                Hi,

                I do some change (set WAKE UP mode to sent do the receiver) and I set channel to 4 (but I test It with 17 also with send 23 that in HEX is 17) and works correctly the first handshake.

                 

                ----------------------------------------
                HEAD : 11000000 192 C0
                
                AddH : 0
                AddL : 2
                Chan : 4 -> 414MHz
                
                SpeedParityBit : 0 -> 8N1 (Default)
                SpeedUARTDatte : 11 -> 9600bps (default)
                SpeedAirDataRate : 10 -> 2.4kbps (default)
                OptionTrans : 1 -> Fixed transmission (first three bytes can be used as high/low address and channel)
                OptionPullup : 1 -> TXD, RXD, AUX are push-pulls/pull-ups 
                OptionWakeup : 0 -> 250ms (default)
                OptionFEC : 1 -> Turn on Forward Error Correction Switch (Default)
                OptionPower : 0 -> 20dBm (Default)
                ----------------------------------------
                Press any key to start conversation with any node at any time.
                Start listening!
                ----------------------------------------
                HEAD : 11000000 192 C0
                
                AddH : 0
                AddL : 1
                Chan : 4 -> 414MHz
                
                SpeedParityBit : 0 -> 8N1 (Default)
                SpeedUARTDatte : 11 -> 9600bps (default)
                SpeedAirDataRate : 10 -> 2.4kbps (default)
                OptionTrans : 1 -> Fixed transmission (first three bytes can be used as high/low address and channel)
                OptionPullup : 1 -> TXD, RXD, AUX are push-pulls/pull-ups 
                OptionWakeup : 0 -> 250ms (default)
                OptionFEC : 1 -> Turn on Forward Error Correction Switch (Default)
                OptionPower : 0 -> 20dBm (Default)
                ----------------------------------------
                Press any key to start conversation with any node at any time.
                Start listening!
                
                >>Send to COM3: "0"<<
                ----------------------------------------
                Now you are in interrupt mode.
                First, tell me the node adress you want to talk to
                Enter the ADDH in decimal
                
                >>Send to COM3: "0"<<
                ADDH: 0
                Enter the ADDL in decimal
                
                >>Send to COM3: "1"<<
                ADDL: 1
                Enter the CHAN in hex
                
                >>Send to COM3: "4"<<
                CHAN: 4
                Your adress is: 0
                1
                4
                Press 1 if you want to wake the node up and fetch the sensor data, press 2 to see the sleep schedule..
                
                >>Send to COM3: "1"<<
                Sending message to wake the node up!
                Success
                ----------------------------------------
                Data is coming thru.. 
                Coming from -> 0
                1
                4
                Temperature -> 18.91°C
                Humidity -> 67.89
                Pressure -> 1234
                Light intensity -> 433
                Current battery state -> 0
                Sending confirmation info to the sender..
                Success

                 

                I used 2 arduino UNO (with my shield) but no overflow.

                Bye Renzo

                Attachments:
                You must be logged in to view attached files.
                in reply to: EByte e32 sendFixedMessage Parameters Issue #4459
                Renzo Mischianti
                Keymaster

                  Hi cglkr97,
                  can you send the complete code PLZ.
                  Thanks Renzo

                  Renzo Mischianti
                  Keymaster

                    Thanks for your feedback, I’m happy that you have resolved your issue, in the next time I publish my shield, but I already worked on Arduino Mega one and surely I need to test It. If you like I need help on my site too.
                    Keep in touch Renzo

                    Renzo Mischianti
                    Keymaster

                      I check with my Arduino Mega, and my error is that I don’t use a correct RX pin as Arduino guide describe.

                      https://www.arduino.cc/en/Reference/softwareSerial

                      Not all pins on the Mega and Mega 2560 support change interrupts, so only the following can be used for RX: 10, 11, 12, 13, 14, 15, 50, 51, 52, 53, A8 (62), A9 (63), A10 (64), A11 (65), A12 (66), A13 (67), A14 (68), A15 (69).

                      Now I can send without problem and receive without problem on my Mega without any freeze.

                      I use this configuration

                      SoftwareSerial mySerial(11, 5);
                      LoRa_E32 e32ttl100(&mySerial, 3, 7, 6);

                      Now work correctly.

                      Please update the libray, uncomment
                      #define LoRa_E32_DEBUG

                      Enable debug mode on Lora e32 EByte library

                      And send me your log, I try to understand.

                      If you want to use HardwareSerial you must do like so
                      LoRa_E32 e32ttl100(&Serial2, 3, 7, 6);

                      Bye Renzo

                      Renzo Mischianti
                      Keymaster

                        I’m doing some test with mega and there is a problem, I’m going to discover in the next week.
                        Bye Renzo

                        Renzo Mischianti
                        Keymaster

                          I tested the example with a1 case but work for me and my Arduino UNO, I’m going to try with Mega.
                          Thanks for your patience Renzo

                          Renzo Mischianti
                          Keymaster

                            Hi fransolomon,
                            I tested your sketch with 2 Arduino UNO, and It’s work correctly, I only add the correct configuration, please try It.

                            #include "Arduino.h"
                            #include "LoRa_E32.h"
                            
                            // SoftwareSerial mySerial(11, 10);
                            // LoRa_E32 e32ttl100(&mySerial,5, 7, 6);
                            
                            SoftwareSerial mySerial(4, 5);
                            LoRa_E32 e32ttl100(&mySerial, 3, 7, 6);
                            //LoRa_E32 e32ttl100(4, 5, 3, 7, 6);
                            
                            void printParameters(struct Configuration configuration) ;
                            
                            void setup() {
                            	Serial.begin(9600);
                            	delay(500);
                            
                            // Startup all pins and UART
                            	e32ttl100.begin();
                            
                            	ResponseStructContainer c;
                            	c = e32ttl100.getConfiguration();
                            	Configuration configuration = *(Configuration*) c.data;
                            	configuration.ADDL = 3;
                            	configuration.ADDH = 0;
                            	configuration.CHAN = 0x04;
                            	configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
                            	configuration.OPTION.wirelessWakeupTime = WAKE_UP_250;
                            
                                configuration.OPTION.fec = FEC_1_ON;
                                configuration.OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS;
                                configuration.OPTION.transmissionPower = POWER_20;
                            
                                configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
                                configuration.SPED.uartBaudRate = UART_BPS_9600;
                                configuration.SPED.uartParity = MODE_00_8N1;
                            
                                e32ttl100.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
                            	printParameters(configuration);
                            
                            	Serial.println("Hi, I'm going to send message!");
                            // Send message
                            	ResponseStatus rs = e32ttl100.sendMessage("Hello, world?"); // OK The message is received on the other device
                            // Check If there is some problem of succesfully send
                            	Serial.println(rs.getResponseDescription());
                            }
                            
                            void loop() {
                            // If something available
                            //	Serial.println("continuity test point"); //This instruction is not executed unless you comment on the previous line "Serial.println(rs.getResponseDescription());"
                            	if (e32ttl100.available() > 1) {
                            		ResponseContainer rc = e32ttl100.receiveMessage();
                            		Serial.println(rc.data);
                            // Is something goes wrong print error
                            		if (rc.status.code != 1) {
                            			rc.status.getResponseDescription();
                            		} else {
                            // Print the data received
                            			Serial.println(rc.data);
                            		}
                            	}
                            	if (Serial.available()) {
                            		String input = Serial.readString();
                            		e32ttl100.sendMessage(input);
                            	}
                            }
                            void printParameters(struct Configuration configuration) {
                            	Serial.println("----------------------------------------");
                            
                            	Serial.print(F("HEAD : "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
                            	Serial.println(F(" "));
                            	Serial.print(F("AddH : "));  Serial.println(configuration.ADDH, DEC);
                            	Serial.print(F("AddL : "));  Serial.println(configuration.ADDL, DEC);
                            	Serial.print(F("Chan : "));  Serial.print(configuration.CHAN, DEC); Serial.print(" -> "); Serial.println(configuration.getChannelDescription());
                            	Serial.println(F(" "));
                            	Serial.print(F("SpeedParityBit     : "));  Serial.print(configuration.SPED.uartParity, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTParityDescription());
                            	Serial.print(F("SpeedUARTDatte  : "));  Serial.print(configuration.SPED.uartBaudRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTBaudRate());
                            	Serial.print(F("SpeedAirDataRate   : "));  Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getAirDataRate());
                            
                            	Serial.print(F("OptionTrans        : "));  Serial.print(configuration.OPTION.fixedTransmission, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFixedTransmissionDescription());
                            	Serial.print(F("OptionPullup       : "));  Serial.print(configuration.OPTION.ioDriveMode, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getIODroveModeDescription());
                            	Serial.print(F("OptionWakeup       : "));  Serial.print(configuration.OPTION.wirelessWakeupTime, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getWirelessWakeUPTimeDescription());
                            	Serial.print(F("OptionFEC          : "));  Serial.print(configuration.OPTION.fec, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFECDescription());
                            	Serial.print(F("OptionPower        : "));  Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getTransmissionPowerDescription());
                            
                            	Serial.println("----------------------------------------");
                            
                            }

                            And please recheck your connection schema with the schema on the article not on Github library, and check that you have the last version of the library, I fix sometings 2 days ago.

                            Bye Renzo

                            Renzo Mischianti
                            Keymaster

                              Hi, I can’t check the sketch now, but please refer to my site, i update all the schema.
                              In the next few days I check all with my Arduino mega.
                              Thanks to write, and please wait.
                              Bye Renzo

                              in reply to: EByte e32 How to Send Message use JSON Format? #4415
                              Renzo Mischianti
                              Keymaster

                                Hi I check your sketch and seems quite ok.

                                But I think you must add AUX pin or put a pull up resistor on It, with no AUX not work for me, but with aux I have a correct send.

                                And Arduino Json have some problem on serialize on String

                                #include "Arduino.h"
                                #include "LoRa_E32.h"
                                
                                #include <DHT.h>
                                #include <ArduinoJson.h>
                                
                                #define DHTPIN 4
                                #define DHTTYPE DHT11
                                int freeRame () {
                                #ifdef ESP8266
                                	return Esp.getFreeHeap();
                                #else
                                	extern int __heap_start, *__brkval;
                                	int v;
                                	return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
                                #endif // ESP8266
                                }
                                
                                DHT dht(DHTPIN, DHTTYPE);
                                
                                DynamicJsonDocument doc(512);
                                
                                // ---------- esp8266 pins --------------
                                //LoRa_E32 e32ttl(D2, D3, D5, D7, D6);
                                //LoRa_E32 e32ttl(D2, D3); // Config without connect AUX and M0 M1
                                
                                //#include <SoftwareSerial.h>
                                //SoftwareSerial mySerial(D2, D3); // RX, TX
                                //LoRa_E32 e32ttl(&mySerial, D5, D7, D6);
                                // -------------------------------------
                                
                                // ---------- Arduino pins --------------
                                //LoRa_E32 e32ttl(2, 3, 5, 7, 6);
                                LoRa_E32 e32ttl100(4, 5, 3); // Config without connect AUX and M0 M1
                                
                                //#include <SoftwareSerial.h>
                                //SoftwareSerial mySerial(2, 3); // RX, TX
                                //LoRa_E32 e32ttl(&mySerial, 5, 7, 6);
                                // -------------------------------------
                                void printParameters(struct Configuration configuration) {
                                	Serial.println("----------------------------------------");
                                
                                	Serial.print(F("HEAD BIN: "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
                                	Serial.println(F(" "));
                                	Serial.print(F("AddH BIN: "));  Serial.println(configuration.ADDH, BIN);
                                	Serial.print(F("AddL BIN: "));  Serial.println(configuration.ADDL, BIN);
                                	Serial.print(F("Chan BIN: "));  Serial.print(configuration.CHAN, DEC); Serial.print(" -> "); Serial.println(configuration.getChannelDescription());
                                	Serial.println(F(" "));
                                	Serial.print(F("SpeedParityBit BIN    : "));  Serial.print(configuration.SPED.uartParity, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTParityDescription());
                                	Serial.print(F("SpeedUARTDataRate BIN : "));  Serial.print(configuration.SPED.uartBaudRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTBaudRate());
                                	Serial.print(F("SpeedAirDataRate BIN  : "));  Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getAirDataRate());
                                
                                	Serial.print(F("OptionTrans BIN       : "));  Serial.print(configuration.OPTION.fixedTransmission, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFixedTransmissionDescription());
                                	Serial.print(F("OptionPullup BIN      : "));  Serial.print(configuration.OPTION.ioDriveMode, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getIODroveModeDescription());
                                	Serial.print(F("OptionWakeup BIN      : "));  Serial.print(configuration.OPTION.wirelessWakeupTime, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getWirelessWakeUPTimeDescription());
                                	Serial.print(F("OptionFEC BIN         : "));  Serial.print(configuration.OPTION.fec, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFECDescription());
                                	Serial.print(F("OptionPower BIN       : "));  Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getTransmissionPowerDescription());
                                
                                	Serial.println("----------------------------------------");
                                
                                }
                                
                                void setup() {
                                	Serial.begin(9600);
                                	delay(500);
                                
                                	// Startup all pins and UART
                                	e32ttl100.begin();
                                	dht.begin();
                                
                                //		ResponseStructContainer c;
                                //		c = e32ttl100.getConfiguration();
                                //		struct Configuration configuration = *(Configuration*) c.data;
                                //		printParameters(configuration);
                                //
                                //		configuration.ADDL = 0x01;
                                //		configuration.ADDH = 0x00;
                                //		configuration.CHAN = 0x04;
                                //
                                //		configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
                                //		configuration.OPTION.wirelessWakeupTime = WAKE_UP_750;
                                //
                                //		    configuration.OPTION.fec = FEC_1_ON;
                                //		    configuration.OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS;
                                //		    configuration.OPTION.transmissionPower = POWER_20;
                                //
                                //		    configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
                                //		    configuration.SPED.uartBaudRate = UART_BPS_9600;
                                //		    configuration.SPED.uartParity = MODE_00_8N1;
                                //
                                //
                                //		    e32ttl100.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
                                //			printParameters(configuration);
                                
                                	Serial.println("Hi, I'm going to send message!");
                                
                                	Serial.println(freeRame());
                                	// Send message
                                	ResponseStatus rs = e32ttl100.sendMessage("Hello, Taurus!");
                                	Serial.println(freeRame());
                                	// Check If there is some problem of succesfully send
                                	Serial.println(rs.getResponseDescription());
                                }
                                
                                int i = 0;
                                
                                void loop() {
                                	Serial.println(freeRame());
                                	float h = dht.readHumidity();
                                	// Read temperature as Celsius (the default)
                                	float t = dht.readTemperature();
                                	// Read temperature as Fahrenheit (isFahrenheit = true)
                                	float f = dht.readTemperature(true);
                                
                                	// Check if any reads failed and exit early (to try again).
                                	if (isnan(h) || isnan(t) || isnan(f)) {
                                		Serial.println(F("Failed to read from DHT sensor!"));
                                //		return;
                                	}
                                
                                	// Compute heat index in Fahrenheit (the default)
                                	float hif = dht.computeHeatIndex(f, h);
                                	// Compute heat index in Celsius (isFahreheit = false)
                                	float hic = dht.computeHeatIndex(t, h, false);
                                	Serial.println(freeRame());
                                	h = random(90);
                                	t = random(40);
                                	f = 1.0;
                                	hif = 2.0;
                                	hic = 2.0;
                                
                                	Serial.print(F("Humidity: "));
                                	Serial.print(h);
                                	Serial.print(F("% Temperature: "));
                                	Serial.print(t);
                                	Serial.print(F("°C "));
                                	Serial.print(f);
                                	Serial.print(F("°F Heat index: "));
                                	Serial.print(hic);
                                	Serial.print(F("°C "));
                                	Serial.print(hif);
                                	Serial.println(F("°F"));
                                	Serial.println(freeRame());
                                	delay(1000);
                                
                                	doc["temperature"] = t;
                                	doc["humidity"] = h;
                                	Serial.println(freeRame());
                                
                                	int size = measureJson(doc)+1;
                                
                                	char buf[size];
                                	serializeJson(doc, buf, size);
                                	Serial.println(buf);
                                	Serial.println(measureJson(doc));
                                	ResponseStatus rs = e32ttl100.sendMessage(buf, size);
                                
                                //	String buf;
                                //	serializeJson(doc, buf);
                                //	Serial.println(buf);
                                //	Serial.println(buf.length());
                                //	ResponseStatus rs = e32ttl100.sendMessage(buf);
                                
                                	Serial.println(freeRame());
                                	Serial.println(rs.getResponseDescription());
                                	Serial.println(freeRame());
                                
                                	delay(2000);
                                
                                }
                                #include "Arduino.h"
                                #include "LoRa_E32.h"
                                #include <ArduinoJson.h>
                                
                                #define E32_TTL_100
                                LoRa_E32 e32ttl(4, 5, 3); // Config without connect AUX and M0 M1
                                
                                //#include <SoftwareSerial.h>
                                //SoftwareSerial mySerial(D2, D3); // RX, TX
                                //E32_TTL e32ttl(&mySerial, D5, D7, D6);
                                
                                void printParameters(struct Configuration configuration);
                                void printModuleInformation(struct ModuleInformation moduleInformation);
                                //The setup function is called once at startup of the sketch
                                void setup()
                                {
                                	Serial.begin(9600);
                                	while (!Serial) {
                                	    ; // wait for serial port to connect. Needed for native USB
                                    }
                                	delay(400);
                                
                                	e32ttl.begin();
                                
                                //			ResponseStructContainer c;
                                //			c = e32ttl.getConfiguration();
                                //			struct Configuration configuration = *(Configuration*) c.data;
                                //			printParameters(configuration);
                                //
                                //			configuration.ADDL = 0x01;
                                //			configuration.ADDH = 0x00;
                                //			configuration.CHAN = 0x04;
                                //
                                //			configuration.OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION;
                                //			configuration.OPTION.wirelessWakeupTime = WAKE_UP_750;
                                //
                                //			configuration.OPTION.fec = FEC_1_ON;
                                //			configuration.OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS;
                                //			configuration.OPTION.transmissionPower = POWER_20;
                                //
                                //			configuration.SPED.airDataRate = AIR_DATA_RATE_010_24;
                                //			configuration.SPED.uartBaudRate = UART_BPS_9600;
                                //			configuration.SPED.uartParity = MODE_00_8N1;
                                //
                                //
                                //			e32ttl.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
                                //			printParameters(configuration);
                                
                                //	ResponseContainer c;
                                //	c = e32ttl.getConfiguration();
                                //	Configuration configuration = *(Configuration*) c.data;
                                //	Serial.println(configuration.SPED.getUARTBaudRate());
                                //	Serial.println(c.status.getResponseDescription());
                                //
                                //	printParameters(configuration);
                                //
                                //	ResponseContainer cMi;
                                //	cMi = e32ttl.getModuleInformation();
                                //	ModuleInformation mi = *(ModuleInformation*)cMi.data;
                                //
                                //	Serial.println(cMi.status.getResponseDescription());
                                //	Serial.println(cMi.status.code);
                                //
                                //	printModuleInformation(mi );
                                //
                                //	configuration.CHAN = configuration.CHAN-1;
                                //	e32ttl.setConfiguration(configuration, WRITE_CFG_PWR_DWN_SAVE);
                                //
                                //	ResponseContainer cNext;
                                //	cNext = e32ttl.getConfiguration();
                                //	Configuration configurationNext = *(Configuration*) cNext.data;
                                //	Serial.println(configurationNext.SPED.getUARTBaudRate());
                                //	Serial.println(cNext.status.getResponseDescription());
                                //	printParameters(configurationNext);
                                
                                }
                                DynamicJsonDocument doc(512);
                                
                                // The loop function is called in an endless loop
                                void loop()
                                {
                                	if (e32ttl.available()  > 1){
                                //		struct Messaggione {
                                //			char message[8];
                                //			bool mitico;
                                //		};
                                //
                                //		char type[5];
                                //		ResponseContainer rs = e32ttl.receiveInitialMessage(sizeof(type));
                                //		memcpy ( type, rs.data.c_str(), sizeof(type) );
                                ////		ResponseContainer rs = e32ttl.receiveInitialMessage(5);
                                ////		char type[5] = {rs.data.c_str()};
                                //
                                //		Serial.println("READ TYPE: ");
                                //		Serial.println(rs.status.getResponseDescription());
                                //		Serial.println(type);
                                //
                                //		ResponseStructContainer rsc = e32ttl.receiveMessage(sizeof(Messaggione));
                                //		struct Messaggione messaggione = *(Messaggione*) rsc.data;
                                
                                		ResponseContainer rs = e32ttl.receiveMessage();
                                		String message = rs.data;
                                
                                		Serial.println(rs.status.getResponseDescription());
                                
                                		Serial.println(message);
                                		deserializeJson(doc, message);
                                
                                		Serial.print("humidity --> ");
                                		Serial.println((float)doc["humidity"]);
                                
                                //		Serial.println(messaggione.message);
                                //		Serial.println(messaggione.mitico);
                                
                                	}
                                }
                                
                                //void printParameters(struct Configuration configuration) {
                                //	Serial.println("----------------------------------------");
                                //
                                //	Serial.print(F("HEAD BIN: "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
                                //	Serial.println(F(" "));
                                //	Serial.print(F("AddH BIN: "));  Serial.println(configuration.ADDH, BIN);
                                //	Serial.print(F("AddL BIN: "));  Serial.println(configuration.ADDL, BIN);
                                //	Serial.print(F("Chan BIN: "));  Serial.print(configuration.CHAN, HEX); Serial.print(" -> "); Serial.println();
                                //	Serial.println(F(" "));
                                //	Serial.print(F("SpeedParityBit BIN    : "));  Serial.print(configuration.SPED.uartParity, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("SpeedUARTDataRate BIN : "));  Serial.print(configuration.SPED.uartBaudRate, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("SpeedAirDataRate BIN  : "));  Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println();
                                //
                                //	Serial.print(F("OptionTrans BIN       : "));  Serial.print(configuration.OPTION.fixedTransmission, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("OptionPullup BIN      : "));  Serial.print(configuration.OPTION.ioDriveMode, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("OptionWakeup BIN      : "));  Serial.print(configuration.OPTION.wirelessWakeupTime, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("OptionFEC BIN         : "));  Serial.print(configuration.OPTION.fec, BIN);Serial.print(" -> "); Serial.println();
                                //	Serial.print(F("OptionPower BIN       : "));  Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println();
                                //
                                //	Serial.println("----------------------------------------");
                                //
                                //}
                                void printParameters(struct Configuration configuration) {
                                	Serial.println("----------------------------------------");
                                
                                	Serial.print(F("HEAD BIN: "));  Serial.print(configuration.HEAD, BIN);Serial.print(" ");Serial.print(configuration.HEAD, DEC);Serial.print(" ");Serial.println(configuration.HEAD, HEX);
                                	Serial.println(F(" "));
                                	Serial.print(F("AddH BIN: "));  Serial.println(configuration.ADDH, BIN);
                                	Serial.print(F("AddL BIN: "));  Serial.println(configuration.ADDL, BIN);
                                	Serial.print(F("Chan BIN: "));  Serial.print(configuration.CHAN, DEC); Serial.print(" -> "); Serial.println(configuration.getChannelDescription());
                                	Serial.println(F(" "));
                                	Serial.print(F("SpeedParityBit BIN    : "));  Serial.print(configuration.SPED.uartParity, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTParityDescription());
                                	Serial.print(F("SpeedUARTDataRate BIN : "));  Serial.print(configuration.SPED.uartBaudRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getUARTBaudRate());
                                	Serial.print(F("SpeedAirDataRate BIN  : "));  Serial.print(configuration.SPED.airDataRate, BIN);Serial.print(" -> "); Serial.println(configuration.SPED.getAirDataRate());
                                
                                	Serial.print(F("OptionTrans BIN       : "));  Serial.print(configuration.OPTION.fixedTransmission, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFixedTransmissionDescription());
                                	Serial.print(F("OptionPullup BIN      : "));  Serial.print(configuration.OPTION.ioDriveMode, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getIODroveModeDescription());
                                	Serial.print(F("OptionWakeup BIN      : "));  Serial.print(configuration.OPTION.wirelessWakeupTime, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getWirelessWakeUPTimeDescription());
                                	Serial.print(F("OptionFEC BIN         : "));  Serial.print(configuration.OPTION.fec, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getFECDescription());
                                	Serial.print(F("OptionPower BIN       : "));  Serial.print(configuration.OPTION.transmissionPower, BIN);Serial.print(" -> "); Serial.println(configuration.OPTION.getTransmissionPowerDescription());
                                
                                	Serial.println("----------------------------------------");
                                
                                }
                                void printModuleInformation(struct ModuleInformation moduleInformation) {
                                	Serial.println("----------------------------------------");
                                	Serial.print(F("HEAD BIN: "));  Serial.print(moduleInformation.HEAD, BIN);Serial.print(" ");Serial.print(moduleInformation.HEAD, DEC);Serial.print(" ");Serial.println(moduleInformation.HEAD, HEX);
                                
                                	Serial.print(F("Model no.: "));  Serial.println(moduleInformation.model, HEX);
                                	Serial.print(F("Version  : "));  Serial.println(moduleInformation.version, HEX);
                                	Serial.print(F("Features : "));  Serial.println(moduleInformation.features, HEX);
                                	Serial.println("----------------------------------------");
                                
                                }
                                in reply to: EByte e32 How to Send Message use JSON Format? #4413
                                Renzo Mischianti
                                Keymaster

                                  Hi taurushappy,
                                  you can use ArduinoJSON library, (I’m going to publish a post on how to use It).

                                  You can

                                    DynamicJsonDocument doc(512);
                                  
                                    // Set the values in the document
                                    doc["energyLifetime"] = 21698620;
                                    doc["energyYearly"] = 1363005;
                                  
                                  String buf;
                                  serializeJson(doc, buf);
                                  
                                  ResponseStatus rs = e32ttl.sendMessage(buf);

                                  Remember you have a size limit on message size of the lora E32.

                                  The code is untested, but I think It can be usefully to understand.

                                  Tell me if It’s ok.

                                  Bye Renzo

                                Viewing 15 posts - 991 through 1,005 (of 1,006 total)