Forum Replies Created

Viewing 15 posts - 976 through 990 (of 1,015 total)
  • Author
    Posts
  • Renzo Mischianti
    Keymaster

      Download attached file, there is the complete sketch.

      Bye Renzo

      Renzo Mischianti
      Keymaster

        Hi Kemran,

        yes, It’s possible, I attach a simple sketch that do this work.

        Respect the code from the article

        FTP server on esp8266 and esp32

        I add this part

        // Connect to Wi-Fi network with SSID and password
        Serial.print("Setting AP (Access Point)…");
        // Remove the password parameter, if you want the AP (Access Point) to be open
        WiFi.softAP(ssid, password);
        
        IPAddress IP = WiFi.softAPIP();
        Serial.print("AP IP address: ");
        Serial.println(IP);
        
        
        Attachments:
        You must be logged in to view attached files.
        Renzo Mischianti
        Keymaster

          I think there Is no way tuo check that the buffer retrieved Is correct.

          I only check if there are data to buffer but It isn’t a solution maybe.

          Bye Renzo

          in reply to: Arduino OTA upload remotely? Or via LoRa? #6061
          Renzo Mischianti
          Keymaster

            Hi Ludopot,

            your idea is intesting, basically if you attach a serial device to a serial microcontroller Is possible to manage OTA.

            I write a simple article to update Arduino via Bluetooth configured as serial pass through.

            Arduino Remote/wireless Programming

            the solution can be similar, but more simple with a secondary device.

            If I find some time I’m going in deep.

            Bye Renzo

             

            Renzo Mischianti
            Keymaster

              No E32 doesn’t have RSSI and repeater function.

              E22 can reach a greater distance with less power:
              from 3Km of E32 to 4/5Km of E22
              from 8Km of E32 1W to 10/12Km of E22

              The packet size of E22 is configurable from 32Kb to 240Kb.

              It’s also more difficult to find module versione, so for the first test I use a PCB as adapter

              Ebyte LoRa E22 device for Arduino, esp32 or esp8266 3 devices module SMD
              Ebyte LoRa E22 device for Arduino, esp32 or esp8266 3 devices module SMD

              Bye Renzo

              Renzo Mischianti
              Keymaster

                Hehehehhe… you discover me…

                yes the library is ready and tested,

                the base commands is the same of library for E32 but there are addictions of the new features like RSSI, configuration for repeater mode packet size increased etc. etc.

                I start writing documentation, a library without documentation is half work..

                But probably first I release the “EByte E32 Web Manager“,  a web manager to configure and test E32..

                EByte LoRa E32 Manager Custom Home Page
                EByte LoRa E32 Manager Custom Home Page

                 

                Bye Renzo

                Renzo Mischianti
                Keymaster

                  Hi Ludophot,

                  for

                  LoRa_E32 e32ttl100(2, 3,5,6,7); and LoRa_E32 e32ttl(2, 3,5,6,7)

                  change only the variable name e32ttl100 in e32ttl.

                   

                  I think you mean difference from

                  LoRa_E32 e32ttl100(2, 3,5,6,7); // Arduino RX <-- e22 TX, Arduino TX --> e22 RX AUX M0 M1


                  and

                  #include <SoftwareSerial.h>
                  SoftwareSerial mySerial(2, 3); // Arduino RX <-- e22 TX, Arduino TX --> e22 RX
                  LoRa_E22 e22ttl(&mySerial, 5, 6, 7); // AUX M0 M1


                  and

                  LoRa_E22 e22ttl(&Serial1, 5, 6, 7); // AUX M0 M1

                  the first and the second is the samething the difference is that in the first case I instantiate SoftwareSerial internally.

                  The last one you pass a reference of the HardwareSerial.

                   

                  The better solution is to use HardwareSerial, because SoftwareSerial is an emulation of Hardware one, so to do the emulation need more processors time respect an hardware implementation of the Serial, and can be more fast.

                  But not all Arduino like have multiple Serial, so for Arduino UNO, if you want use debug and other you need to do Software one.

                  Bye Renzo

                  Renzo Mischianti
                  Keymaster

                    Hi Ludopot,

                    I found this implementation

                     

                    
                    #include <ArduinoHttpClient.h>
                    #include <MD5.h>
                    HttpClient client = HttpClient(wifiConnection, adress, port);
                    ...
                    bool HttpSendDigest(String uri, String user, String password, String data)
                    {
                    
                      //Serial.println("HttpSendDigest::POST request");
                      client.beginRequest();
                      client.post(uri,"application/x-www-form-urlencoded",data);
                      client.endRequest();
                    
                    
                      String header ="";
                      // read the status code and body of the response
                      int statusCode = client.responseStatusCode();
                      if (client.headerAvailable()){
                        while(!client.endOfHeadersReached()){
                          header = header + char(client.readHeader());
                        }
                      }
                      String headerName = client.readHeaderName();
                      String headerValue = client.readHeaderValue();
                      String response = client.responseBody();
                      /*
                      Serial.println("HttpSendDigest::Headername: "+ headerName);
                      Serial.println("HttpSendDigest::Headervalue: "+ headerValue);
                      Serial.println("HttpSendDigest::header: ");
                      Serial.println(header);
                      Serial.print("HttpSendDigest::statuscode: ");
                      Serial.println(statusCode);
                      Serial.println("HttpSendDigest::response: ");
                      Serial.println(response);
                      */
                    
                      if (statusCode == 401 && headerName.equalsIgnoreCase("WWW-Authenticate"))
                      {
                          //Serial.println("HttpSendDigest::401+WWW-Authenticate detected");  
                          String AuthMethod = headerValue.substring(0,headerValue.indexOf(' '));
                          String realm = strGetValue(headerValue,"realm=\"","\"");
                          String nonce = strGetValue(headerValue,"nonce=\"","\"");
                          String qop = strGetValue(headerValue,"qop=\"","\"");
                          /*
                          Serial.println("HttpSendDigest::AuthMethod: "+AuthMethod);  
                          Serial.println("HttpSendDigest::realm: "+realm);  
                          Serial.println("HttpSendDigest::nonce: "+nonce);  
                          Serial.println("HttpSendDigest::qop: "+qop);  
                          */
                          //Serial.print("HttpSendDigest::Calculate HA1...");  
                          String HA1 = calcMD5(user+":"+realm+":"+password);
                          //Serial.println(HA1);  
                    
                          //Serial.print("HttpSendDigest::Calculate HA2...");  
                          String HA2 = calcMD5("POST:"+uri);
                          //Serial.println(HA2);  
                    
                          String cnonce = String(random(8556822323));
                          //Serial.println("HttpSendDigest::cnonce: "+cnonce);  
                          //Serial.println("HttpSendDigest::Calculate authResponse...");  
                          String authResponse =calcMD5(HA1+":"+nonce+":"+"00000001"+":"+cnonce+":"+qop+":"+HA2); //MD5(HA1:nonce:nonceCount:cnonce:qop:HA2)
                          //Serial.println("HttpSendDigest::authResponse: "+authResponse);      
                    
                          String authHeaderString = "Authorization: Digest username=\"" + user +
                                            "\",realm=\"" + realm +
                                            "\",nonce=\"" + nonce +
                                            "\",uri=\"" + uri +
                                            "\",cnonce=\"" + cnonce +
                                            "\",qop=auth, nc=00000001, response=\"" + authResponse + "\"";//\r\n";
                          //Serial.println("HttpSendDigest::authHeaderString: "+authHeaderString);  
                          
                          //Serial.println("HttpSendDigest::---auth post---");
                          client.beginRequest();
                          client.post(uri);
                          client.sendHeader(authHeaderString);
                          client.sendHeader(HTTP_HEADER_CONTENT_TYPE, "application/x-www-form-urlencoded");
                          client.sendHeader(HTTP_HEADER_CONTENT_LENGTH, data.length());
                          client.beginBody();
                          client.print(data);
                          client.endRequest();
                          
                          //Serial.println("HttpSendDigest::---authresponse---");
                          header ="";
                          // read the status code and body of the response
                          statusCode = client.responseStatusCode();
                          if (client.headerAvailable()){
                            while(!client.endOfHeadersReached()){
                              header = header + char(client.readHeader());
                            }
                          }
                    
                          headerName = client.readHeaderName();
                          headerValue = client.readHeaderValue();
                          response = client.responseBody();
                          /*
                          Serial.println("HttpSendDigest::Headername: "+ headerName);
                          Serial.println("HttpSendDigest::Headervalue: "+ headerValue);
                          Serial.println("HttpSendDigest::header: ");
                          Serial.println(header);
                          Serial.print("HttpSendDigest::statuscode: ");
                          Serial.println(statusCode);
                          Serial.println("HttpSendDigest::response: ");
                          Serial.println(response);
                          */
                      }
                      if (statusCode==200)
                      {
                        return true;  
                      }
                      else
                      {
                        return false;
                      }
                      
                    }
                    

                    than you must call like this

                    HttpSendDigest("/command.cgi",user,password,dataString)

                    But you must check if the software need HTTPS because Arduino not support that protocol.

                     

                    Bye Renzo

                    in reply to: More than one pcf8574 expander #5528
                    Renzo Mischianti
                    Keymaster

                      Hi hmronline,
                      It’s true, the sketch not working on Arduino, only in esp8266 core, try this

                      
                      #include "Arduino.h"
                      #include "PCF8574.h"
                      
                      PCF8574 pcf8574_1(0x38);
                      PCF8574 pcf8574_2(0x39);
                      
                      PCF8574* arrayOfPCF[2];
                      //The setup function is called once at startup of the sketch
                      void setup()
                      {
                      	Serial.begin(115200);
                      
                      	pcf8574_1.pinMode(P0, OUTPUT);
                      	pcf8574_1.pinMode(P1, OUTPUT);
                      	pcf8574_1.pinMode(P2, OUTPUT);
                      
                      	pcf8574_2.pinMode(P1, OUTPUT);
                      	pcf8574_2.pinMode(P2, OUTPUT);
                      	pcf8574_2.pinMode(P3, OUTPUT);
                      
                      	pcf8574_1.begin();
                      	pcf8574_2.begin();
                      
                      	arrayOfPCF[0] = &pcf8574_1;
                      	arrayOfPCF[1] = &pcf8574_2;
                      
                      }
                      
                      void loop()
                      {
                      	arrayOfPCF[0]->digitalWrite(P1, HIGH);
                      	arrayOfPCF[1]->digitalWrite(P1, HIGH);
                      	delay(2000);
                      	arrayOfPCF[0]->digitalWrite(P1, HIGH);
                      	arrayOfPCF[1]->digitalWrite(P1, HIGH);
                      	delay(2000);
                      
                      }
                      

                      or

                      #include "Arduino.h"
                      #include "PCF8574.h"
                      
                      PCF8574 pcf8574_1(0x38);
                      PCF8574 pcf8574_2(0x39);
                      
                      PCF8574 arrayOfPCF[2] = {pcf8574_1, pcf8574_2};
                      //The setup function is called once at startup of the sketch
                      void setup()
                      {
                      	Serial.begin(115200);
                      
                      	pcf8574_1.pinMode(P0, OUTPUT);
                      	pcf8574_1.pinMode(P1, OUTPUT);
                      	pcf8574_1.pinMode(P2, OUTPUT);
                      
                      	pcf8574_2.pinMode(P1, OUTPUT);
                      	pcf8574_2.pinMode(P2, OUTPUT);
                      	pcf8574_2.pinMode(P3, OUTPUT);
                      
                      	pcf8574_1.begin();
                      	pcf8574_2.begin();
                      
                      }
                      
                      void loop()
                      {
                      	arrayOfPCF[0].digitalWrite(P1, HIGH);
                      	arrayOfPCF[1].digitalWrite(P1, HIGH);
                      	delay(2000);
                      	arrayOfPCF[0].digitalWrite(P1, HIGH);
                      	arrayOfPCF[1].digitalWrite(P1, HIGH);
                      	delay(2000);
                      
                      }
                      

                      Bye Renzo
                       

                      in reply to: More than one pcf8574 expander #5525
                      Renzo Mischianti
                      Keymaster

                        I try to compile my sketch and no error, can you post your code??

                        in reply to: More than one pcf8574 expander #5523
                        Renzo Mischianti
                        Keymaster

                          Hi hmronline,
                          I think something like this can work

                           

                          #include "Arduino.h"
                          #include "PCF8574.h"
                          
                          PCF8574 pcf8574_1(0x38);
                          PCF8574 pcf8574_2(0x39);
                          
                          
                          PCF8574 arrayOfPCF[2];
                          //The setup function is called once at startup of the sketch
                          void setup()
                          {
                          	Serial.begin(115200);
                          
                          	pcf8574_1.pinMode(P0, OUTPUT);
                          	pcf8574_1.pinMode(P1, OUTPUT);
                          	pcf8574_1.pinMode(P2, OUTPUT);
                          
                          	pcf8574_2.pinMode(P1, OUTPUT);
                          	pcf8574_2.pinMode(P2, OUTPUT);
                          	pcf8574_2.pinMode(P3, OUTPUT);
                          
                          
                          	pcf8574_1.begin();
                          	pcf8574_2.begin();
                          
                          	arrayOfPCF[0] = pcf8574_1;
                          	arrayOfPCF[1] = pcf8574_1;
                          
                          }
                          
                          
                          void loop()
                          {
                          	arrayOfPCF[0].digitalWrite(P1, HIGH);
                          	arrayOfPCF[1].digitalWrite(P1, HIGH);
                          	delay(2000);
                          	arrayOfPCF[0].digitalWrite(P1, HIGH);
                          	arrayOfPCF[1].digitalWrite(P1, HIGH);
                          	delay(2000);
                          
                          }
                          

                          Give me a feedback.
                          Bye Renzo

                          Renzo Mischianti
                          Keymaster

                            Hi Dan-Ã…ke Asp,

                            sorry for the problem, but the thingiverse account is not updated (no time to do that), I update only this site at this link

                            http://mischianti.org/improved-z-axis-for-cyclone-pcb-factory/

                            there you can find all the updated parts.

                            Bye Renzo

                            Renzo Mischianti
                            Keymaster

                              Hi Alejandro,

                              yes, can be an usefully features, but not so simple to develop, the message in the buffer can be not in sequence, and the order in a long transmission can change with the enviroenment condition.

                              But when I have more time I think how to do that.

                              Bye Renzo

                              Renzo Mischianti
                              Keymaster

                                Hi Alejandro,

                                EByte response me

                                Hi Renzo,
                                The single packet limit is 58 bytes. It means one transmission can only send 58 bytes. it will cut your data into serveral 58-byte packet to send.
                                The buffer is 512 bytes, it means you can input maximum 512 bytes of data by UART, and the module will cut the 512-byte of data into several packet to send all those 512 byte data in serveral times.
                                ---------------------------------
                                Best Regards,
                                

                                The packet size is 58Bytes if you put a stream of packet the device send they one to one not like a single package.

                                Bye Renzo

                                Renzo Mischianti
                                Keymaster

                                  Hi Alejandro,
                                  then, on this point it is not very clear,

                                  initially I left the possibility of sending packets of any size, but they are truncated at 58byte,

                                  and on the specifications page they write “TX length 58byte Maximun capacity of singlepackage”,

                                  so I interpreted what they have written later as if you can send packet in series (even if not yet transmitted) until the buffer is filled,

                                  and I add new receive message method this days

                                  ResponseContainer rs = e32ttl.receiveMessageUntil();

                                  that if you receive more than one String message at the same time can read single message instead all message in the buffer.

                                  but if you had the same doubt you too, I can try to send 58 bytes and then the rest.

                                  But if the size is not relevant the upgraded version e22 (I’m doing the library now) have packet size variable (max 240byte) but if there are no limit why to manage packet size?

                                  But as soon as I find time I do another test.

                                  Keep in touch.

                                  Bye Renzo

                                Viewing 15 posts - 976 through 990 (of 1,015 total)