Forum-passionnement

Code : Tout sélectionner

/**********************************************************************
  Filename    : Drive Stepper Motor
  Description : Use ULN2003 to drive the stepper motor.
  Auther      : www.freenove.com
  Modification: 2024/06/19
**********************************************************************/
// Conncet the port of the stepper motor driver
int outPorts[] = {14, 27, 26, 25};

void setup() {
  // set pins to output
  for (int i = 0; i < 4; i++) {
    pinMode(outPorts[i], OUTPUT);
  }
}

void loop()
{
  // Rotate a full turn
  moveSteps(true, 32 * 64, 3);
  delay(1000);
  // Rotate a full turn towards another direction
  moveSteps(false, 32 * 64, 3);
  delay(1000);
}

//Suggestion: the motor turns precisely when the ms range is between 3 and 20
void moveSteps(bool dir, int steps, byte ms) {
  for (unsigned long i = 0; i < steps; i++) {
    moveOneStep(dir); // Rotate a step
    delay(constrain(ms,3,20));        // Control the speed
  }
}

void moveOneStep(bool dir) {
  // Define a variable, use four low bit to indicate the state of port
  static byte out = 0x01;
  // Decide the shift direction according to the rotation direction
  if (dir) {  // ring shift left
    out != 0x08 ? out = out << 1 : out = 0x01;
  }
  else {      // ring shift right
    out != 0x01 ? out = out >> 1 : out = 0x08;
  }
  // Output singal to each port
  for (int i = 0; i < 4; i++) {
    digitalWrite(outPorts[i], (out & (0x01 << i)) ? HIGH : LOW);
  }
}

void moveAround(bool dir, int turns, byte ms){
  for(int i=0;i<turns;i++)
    moveSteps(dir,32*64,ms);
}
void moveAngle(bool dir, int angle, byte ms){
  moveSteps(dir,(angle*32*64/360),ms);
}

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Drive LiquidCrystal I2C to display characters
      Description : I2C is used to control the display characters of LCD1602.
      Auther      : www.freenove.com
      Modification: 2022/10/25
    **********************************************************************/
    #include <LiquidCrystal_I2C.h>
    #include <Wire.h>

    #define SDA 14                    //Define SDA pins
    #define SCL 13                    //Define SCL pins

    /*
     * note:If lcd1602 uses PCF8574T, IIC's address is 0x27,
     *      or lcd1602 uses PCF8574AT, IIC's address is 0x3F.
    */
    LiquidCrystal_I2C lcd(0x27,16,2);
    void setup() {
      Wire.begin(SDA, SCL);          // attach the IIC pin
      if (!i2CAddrTest(0x27)) {
        lcd = LiquidCrystal_I2C(0x3F, 16, 2);
      }
      lcd.init();                    // LCD driver initialization
      lcd.backlight();                // Open the backlight
      lcd.setCursor(0,0);            // Move the cursor to row 0, column 0
      lcd.print("hello, world!");    // The print content is displayed on the LCD
    }

    void loop() {
      lcd.setCursor(0,1);            // Move the cursor to row 1, column 0
      lcd.print("Counter:");          // The count is displayed every second
      lcd.print(millis() / 1000);
      delay(1000);
    }

    bool i2CAddrTest(uint8_t addr) {
      Wire.beginTransmission(addr);
      if (Wire.endTransmission() == 0) {
        return true;
      }
      return false;
    }

Code : Tout sélectionner

/**********************************************************************
  Filename    : Ultrasonic Ranging
  Description : Use the ultrasonic module to measure the distance.
  Auther      : www.freenove.com
  Modification: 2022/10/25
**********************************************************************/
#define trigPin 13 // define TrigPin
#define echoPin 14 // define EchoPin.
#define MAX_DISTANCE 700 // Maximum sensor distance is rated at 400-500cm.
//timeOut= 2*MAX_DISTANCE /100 /340 *1000000 = MAX_DISTANCE*58.8
float timeOut = MAX_DISTANCE * 60;
int soundVelocity = 340; // define sound speed=340m/s

void setup() {
  pinMode(trigPin,OUTPUT);// set trigPin to output mode
  pinMode(echoPin,INPUT); // set echoPin to input mode
  Serial.begin(115200);   // Open serial monitor at 115200 baud to see ping results.
}

void loop() {
  delay(100); // Wait 100ms between pings (about 20 pings/sec).
  Serial.printf("Distance: ");
  Serial.print(getSonar()); // Send ping, get distance in cm and print result
  Serial.println("cm");
}

float getSonar() {
  unsigned long pingTime;
  float distance;
  // make trigPin output high level lasting for 10μs to triger HC_SR04
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Wait HC-SR04 returning to the high level and measure out this waitting time
  pingTime = pulseIn(echoPin, HIGH, timeOut);
  // calculate the distance according to the time
  distance = (float)pingTime * soundVelocity / 2 / 10000;
  return distance; // return the distance value
}

Code : Tout sélectionner

/**********************************************************************
  Filename    : Ultrasonic Ranging
  Description : Use the ultrasonic module to measure the distance.
  Auther      : www.freenove.com
  Modification: 2022/10/25
**********************************************************************/
#include <UltrasonicSensor.h>

UltrasonicSensor ultrasonic(13, 14);

void setup() {
  Serial.begin(115200);
 
  int temperature = 22;
  ultrasonic.setTemperature(temperature);
}

void loop() {
  int distance = ultrasonic.distanceInCentimeters();
  Serial.printf("Distance: %dcm\n",distance);
  delay(300);
}

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Get Input Characters
      Description : Call the Keypad function to set the matrix keyboard and get the value for the matrix keyboard
      Auther      : www.freenove.com
      Modification: 2022/10/25
    **********************************************************************/
    #include <Keypad.h>

    // define the symbols on the buttons of the keypad
    char keys[4][4] = {
      {'1', '2', '3', 'A'},
      {'4', '5', '6', 'B'},
      {'7', '8', '9', 'C'},
      {'*', '0', '#', 'D'}
    };

    byte rowPins[4] = {14, 13, 12, 11}; // connect to the row pinouts of the keypad
    byte colPins[4] = {10,  9,  8, 18};  // connect to the column pinouts of the keypad

    // initialize an instance of class NewKeypad
    Keypad myKeypad = Keypad(makeKeymap(keys), rowPins, colPins, 4, 4);

    void setup() {
      Serial.begin(115200); // Initialize the serial port and set the baud rate to 115200
      Serial.println("ESP32S3 is ready!");  // Print the string "UNO is ready!"
    }

    void loop() {
      // Get the character input
      char keyPressed = myKeypad.getKey();
      // If there is a character input, sent it to the serial port
      if (keyPressed) {
        Serial.println(keyPressed);
      }
    }

Code : Tout sélectionner

/**********************************************************************
  Filename    : Combination Lock
  Description : Make a simple combination lock.
  Auther      : www.freenove.com
  Modification: 2022/10/26
**********************************************************************/
#include <Keypad.h>

#define SERVO_PIN 21  //define the pwm pin
#define SERVO_CHN 0  //define the pwm channel
#define SERVO_FRQ 50  //define the pwm frequency
#define SERVO_BIT 12  //define the pwm precision
#define BUZZER_PIN 17 // Define the buzzer pin

void servo_set_pin(int pin);
void servo_set_angle(int angle);

byte rowPins[4] = {14, 13, 12, 11}; // connect to the row pinouts of the keypad
byte colPins[4] = {10,  9,  8, 18}; // connect to the column pinouts of the keypad

// define the symbols on the buttons of the keypad
char keys[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

// initialize an instance of class NewKeypad
Keypad myKeypad = Keypad(makeKeymap(keys), rowPins, colPins, 4, 4);

char passWord[] = {"1234"}; // Save the correct password

void setup() {
  servo_set_pin(SERVO_PIN);
  pinMode(BUZZER_PIN, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  static char keyIn[4];    // Save the input character
  static byte keyInNum = 0; // Save the the number of input characters
  char keyPressed = myKeypad.getKey();  // Get the character input
  // Handle the input characters
  if (keyPressed) {
    // Make a prompt tone each time press the key
    digitalWrite(BUZZER_PIN, HIGH);
    delay(100);
    digitalWrite(BUZZER_PIN, LOW);
    // Save the input characters
    keyIn[keyInNum++] = keyPressed;
    // Judge the correctness after input
    if (keyInNum == 4) {
      bool isRight = true;            // Save password is correct or not
      for (int i = 0; i < 4; i++) {  // Judge each character of the password is correct or not
        if (keyIn[i] != passWord[i])
          isRight = false;            // Mark wrong passageword if there is any wrong character.
      }
      if (isRight) {                  // If the input password is right
        servo_set_angle(90);          // Open the switch
        delay(2000);                  // Delay a period of time
        servo_set_angle(0);            // Close the switch
        Serial.println("passWord right!");
      }
      else {                          // If the input password is wrong
        digitalWrite(BUZZER_PIN, HIGH);// Make a wrong password prompt tone
        delay(1000);
        digitalWrite(BUZZER_PIN, LOW);
        Serial.println("passWord error!");
      }
      keyInNum = 0; // Reset the number of the input characters to 0
    }
  }
}

void servo_set_pin(int pin) {
  ledcAttachChannel(pin, SERVO_FRQ, SERVO_BIT, SERVO_CHN);
}

void servo_set_angle(int angle) {
  if (angle > 180 || angle < 0)
    return;
  long pwm_value = map(angle, 0, 180, 103, 512);
  ledcWrite(SERVO_PIN, pwm_value);
}

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Infrared Remote Control
      Description : Decode the infrared remote control and print it out through the serial port.
      Auther      : www.freenove.com
      Modification: 2024/07/01
    **********************************************************************/
    #include "Freenove_IR_Lib_for_ESP32.h"

    const uint16_t recvPin = 21;              // Infrared receiving pin
    Freenove_ESP32_IR_Recv ir_recv(recvPin);  // Create a class object used to receive class

    void setup() {
      Serial.begin(115200);      // Initialize the serial port and set the baud rate to 115200
      Serial.print("IRrecvDemo is now running and waiting for IR message on Pin ");
      Serial.println(recvPin);  //print the infrared receiving pin
    }

    void loop() {
      ir_recv.task();                  //Get IR receice data.
      if(ir_recv.nec_available()){    //The data of the NEC protocol is checked
        //Print IR data.
        Serial.printf("IR Code:  %#x\r\n", ir_recv.data());
      }
    }

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Control LED through Infrared Remote
      Description : Remote control the LED with the infrared remote control.
      Auther      : www.freenove.com
      Modification: 2024/07/01
    **********************************************************************/
    #include "Freenove_IR_Lib_for_ESP32.h"

    const uint16_t recvPin = 21;  // Infrared receiving pin
    Freenove_ESP32_IR_Recv ir_recv(recvPin);  // Create a class object used to receive class

    int ledPin = 13;              // the number of the LED pin
    int buzzerPin = 14;          // the number of the buzzer pin

    void setup()
    {
      //Initialize the ledc configuration
      ledcAttachChannel(ledPin, 1000, 8, 0);// set the frequency,solution_bits,channel to GPIO pin
      pinMode(buzzerPin, OUTPUT);          // set buzzer pin into output mode
    }

    void loop() {
      ir_recv.task();                  // Get IR receice data.
      if(ir_recv.nec_available()){      // The data of the NEC protocol is checked
        handleControl(ir_recv.data());  // Handle the commands from remote control
      }
    }

    void handleControl(unsigned long value) {
      // Make a sound when it rereives commands
      digitalWrite(buzzerPin, HIGH);
      delay(100);
      digitalWrite(buzzerPin, LOW);
      // Handle the commands
      switch (value) {
        case 0xff6897:              // Receive the number '0'
          ledcWrite(ledPin, 0);    // Turn off LED
          break;
        case 0xff30CF:              // Receive the number '1'
          ledcWrite(ledPin, 7);    // Dimmest brightness
          break;
        case 0xff18E7:              // Receive the number '2'
          ledcWrite(ledPin, 63);    // Medium brightness
          break;
        case 0xff7A85:              // Receive the number '3'
          ledcWrite(ledPin, 255);  // Strongest brightnss
          break;
      }
    }

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Temperature and Humidity Sensor
      Description : Use DHT11 to measure temperature and humidity.Print the result to the serial port.
      Auther      : www.freenove.com
      Modification: 2022/10/26
    **********************************************************************/
    #include "DHTesp.h"

    DHTesp dht;    //Define the DHT object
    int dhtPin = 21;//Define the dht pin

    void setup() {
      dht.setup(dhtPin, DHTesp::DHT11);//Initialize the dht pin and dht object
      Serial.begin(115200);              //Set the baud rate as 115200
    }

    void loop() {
      flag:TempAndHumidity newValues = dht.getTempAndHumidity();//Get the Temperature and humidity
      if (dht.getStatus() != 0) {//Judge if the correct value is read
        goto flag;              //If there is an error, go back to the flag and re-read the data
      }
      Serial.println(" Temperature:" + String(newValues.temperature) +
      " Humidity:" + String(newValues.humidity));
      delay(2000);
    }

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Temperature and Humidity Sensor
      Description : Use DHT11 to measure temperature and humidity.Print the result to the LCD1602.
      Auther      : www.freenove.com
      Modification: 2024/07/01
    **********************************************************************/
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
    #include "DHTesp.h"

    #define SDA 14                    //Define SDA pins
    #define SCL 13                    //Define SCL pins

    DHTesp dht;                      // create dht object
    LiquidCrystal_I2C lcd(0x27,16,2); //initialize the LCD
    int dhtPin = 21;                  // the number of the DHT11 sensor pin

    void setup() {
      Wire.begin(SDA, SCL);          // attach the IIC pin
      if (!i2CAddrTest(0x27)) {
        lcd = LiquidCrystal_I2C(0x3F, 16, 2);
      }
      lcd.init();                    // LCD driver initialization
      lcd.backlight();                // Open the backlight
      dht.setup(dhtPin, DHTesp::DHT11); //attach the dht pin and initialize it
    }

    void loop() {
      // read DHT11 data and save it
      flag:TempAndHumidity DHT = dht.getTempAndHumidity();
      if (dht.getStatus() != 0) {      //Determine if the read is successful, and if it fails, go back to flag and re-read the data
        goto flag;
      } 
      lcd.setCursor(0, 0);              //set the cursor to column 0, line 1
      lcd.print("Temperature:");        //display the Humidity on the LCD1602
      lcd.print(DHT.temperature); 
      lcd.setCursor(0, 1);              //set the cursor to column 0, line 0
      lcd.print("Humidity  :");        //display the Humidity on the LCD1602
      lcd.print(DHT.humidity); 
      delay(2000);
    }

    bool i2CAddrTest(uint8_t addr) {
      Wire.beginTransmission(addr);
      if (Wire.endTransmission() == 0) {
        return true;
      }
      return false;
    }

Code : Tout sélectionner

    /**********************************************************************
      Filename    : Infrared Motion Sensor
      Description : LED lamp is controlled by Infrared Motion Sensor
      Auther      : www.freenove.com
      Modification: 2022/10/26
    **********************************************************************/
    int sensorPin = 13; // the number of the infrared motion sensor pin
    int ledPin = 14;    // the number of the LED pin

    void setup() {
      pinMode(sensorPin, INPUT);  // initialize the sensor pin as input
      pinMode(ledPin, OUTPUT);    // initialize the LED pin as output
    }

    void loop() {
      // Turn on or off LED according to Infrared Motion Sensor
      digitalWrite(ledPin, digitalRead(sensorPin));
      delay(1000);              // wait for a second
    }