ghassan/espnow-rc-car
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

the code didnt work so i created example sender and receiver code

Browse Source
This commit is contained in:
ghassan committed 2025-03-24 02:29:28 +03:00
1 parent dfbcc976e6
commit 7ae4d9ae5e
11 files changed
+533 -237
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

espnow-car/espnow-car.ino
+122 -172
View File
@@ -1,194 +1,144 @@
#include <Arduino.h>
#include "L298N_ESP32.h"
#include "Servo_ESP32.h"
#include <Arduino.h>
#include "espnow.h"
#include "motor.h"
#include "servo.h"
#include "fuzzy.h"
// Motor 1 Pins
#define MOTOR1_PIN1 27
#define MOTOR1_PIN2 26
#define MOTOR1_ENABLE 14
#define terminal Serial
// Motor 2 Pins
#define MOTOR2_PIN1 25
#define MOTOR2_PIN2 33
#define MOTOR2_ENABLE 32
void setup() {
// Servo Pins
#define SERVO1_PIN 13
#define SERVO2_PIN 12
// Terminal
terminal.begin(115200);
// Motor Objects
L298N_ESP32 motor1(MOTOR1_PIN1, MOTOR1_PIN2, MOTOR1_ENABLE, 0);
L298N_ESP32 motor2(MOTOR2_PIN1, MOTOR2_PIN2, MOTOR2_ENABLE, 1);
terminal.println("Hello");
// Servo Objects
Servo_ESP32 servo1(SERVO1_PIN, 2, 1000, 2000);
Servo_ESP32 servo2(SERVO2_PIN, 3, 1000, 2000);
// ESPNOW Communications
espnow_begin();
// ESPNOW
#include <esp_now.h>
#include <WiFi.h>
// Initialize Motors
motor1.begin();
motor2.begin();
// Packet Data Structure
struct PacketData {
uint8_t X; // Steering (left/right)
uint8_t Y; // Throttle (forward/backward)
bool B; // Button
};
// Initialize Servos
servo1.begin();
servo2.begin();
// Data Received From Remote
PacketData data;
// Constants
const unsigned long MOTOR_ACTION_DELAY = 5000; // Delay between motor actions
const int SERVO1_START = 10;
const int SERVO1_END = 170;
const int SERVO2_START = 20;
const int SERVO2_END = 160;
enum MotorState {
STOPPED,
FORWARD_M1,
BACKWARD_M1,
FORWARD_M2,
BACKWARD_M2
};
MotorState currentMotorState = STOPPED;
unsigned long motorStateStartTime = 0;
void setup() {
Serial.begin(115200);
// Initialize Motors
motor1.begin();
motor2.begin();
// Initialize Servos
servo1.begin();
servo2.begin();
Serial.println("Initialization complete.");
// ESP-NOW setup
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW init failed");
return;
// Print Terminal Message
// terminal.println("Initialization complete.");
}
// When Receive Data Execute OnDataRecv Function
esp_now_register_recv_cb(OnDataRecv);
void loop() {
}
terminal.print(data.X); // 0% to 100%
terminal.print(" ");
terminal.print(data.Y);
terminal.print(" ");
terminal.println(data.B);
void loop() {
delay(20);
// Non Blocking Motor control
if(millis() - motorStateStartTime >= MOTOR_ACTION_DELAY) {
// // Non Blocking Motor control
// if(millis() - motorStateStartTime >= MOTOR_ACTION_DELAY) {
motorStateStartTime = millis();
// motorStateStartTime = millis();
switch (currentMotorState) {
// switch(currentMotorState) {
case STOPPED:
Serial.println("Moving motor 1 forward...");
motor1.forward();
motor1.setPercentage(75); //PWM set percentage
motor2.stop();
currentMotorState = FORWARD_M1;
break;
case FORWARD_M1:
Serial.println("Moving motor 1 backward...");
motor1.backward();
motor1.setPercentage(50); //PWM set percentage
motor2.stop();
currentMotorState = BACKWARD_M1;
break;
case BACKWARD_M1:
Serial.println("Moving motor 2 forward...");
motor1.stop();
motor2.forward();
motor2.setPercentage(25); //PWM set percentage
currentMotorState = FORWARD_M2;
break;
case FORWARD_M2:
Serial.println("Moving motor 2 backward...");
motor1.stop();
motor2.backward();
motor2.setPercentage(100); //PWM set percentage
currentMotorState = BACKWARD_M2;
break;
case BACKWARD_M2:
Serial.println("Stopping motors ...");
motor1.stop();
motor2.stop();
currentMotorState = STOPPED;
break;
// case STOPPED:
// Serial.println("Moving motor 1 forward...");
// motor1.forward();
// motor1.setPercentage(75); //PWM set percentage
// motor2.stop();
// currentMotorState = FORWARD_M1;
// break;
// case FORWARD_M1:
// Serial.println("Moving motor 1 backward...");
// motor1.backward();
// motor1.setPercentage(50); //PWM set percentage
// motor2.stop();
// currentMotorState = BACKWARD_M1;
// break;
// case BACKWARD_M1:
// Serial.println("Moving motor 2 forward...");
// motor1.stop();
// motor2.forward();
// motor2.setPercentage(25); //PWM set percentage
// currentMotorState = FORWARD_M2;
// break;
// case FORWARD_M2:
// Serial.println("Moving motor 2 backward...");
// motor1.stop();
// motor2.backward();
// motor2.setPercentage(100); //PWM set percentage
// currentMotorState = BACKWARD_M2;
// break;
// case BACKWARD_M2:
// Serial.println("Stopping motors ...");
// motor1.stop();
// motor2.stop();
// currentMotorState = STOPPED;
// break;
}
// }
// }
// // Non Blocking Servos
// static unsigned long servoTimer = 0;
// static int servo1Pos = SERVO1_START;
// static int servo2Pos = SERVO2_START;
// static bool servoForward = true;
// unsigned long currentTime = millis();
// if(currentTime - servoTimer >= 20) { // Adjust for speed
// servoTimer = currentTime;
// if (servoForward) {
// servo1Pos++;
// if (servo1Pos >= SERVO1_END) {
// servoForward = false;
// }
// } else {
// servo1Pos--;
// if (servo1Pos <= SERVO1_START) {
// servoForward = true;
// }
// }
// servo1.write(servo1Pos);
// }
// // Non Blocking Servos
// static unsigned long servoTimer2 = 0;
// static int servo2Pos2 = SERVO2_START;
// static bool servoForward2 = true;
// unsigned long currentTime2 = millis();
// if(currentTime2 - servoTimer2 >= 20) { // Adjust for speed
// servoTimer2 = currentTime2;
// if (servoForward2) {
// servo2Pos2++;
// if (servo2Pos2 >= SERVO2_END) {
// servoForward2 = false;
// }
// } else {
// servo2Pos2--;
// if (servo2Pos2 <= SERVO2_START) {
// servoForward2 = true;
// }
// }
// servo2.write(servo2Pos2);
// }
}
//Non Blocking Servos
static unsigned long servoTimer = 0;
static int servo1Pos = SERVO1_START;
static int servo2Pos = SERVO2_START;
static bool servoForward = true;
unsigned long currentTime = millis();
if(currentTime - servoTimer >= 20) { // Adjust for speed
servoTimer = currentTime;
if (servoForward) {
servo1Pos++;
if (servo1Pos >= SERVO1_END) {
servoForward = false;
}
} else {
servo1Pos--;
if (servo1Pos <= SERVO1_START) {
servoForward = true;
}
}
servo1.write(servo1Pos);
}
//Non Blocking Servos
static unsigned long servoTimer2 = 0;
static int servo2Pos2 = SERVO2_START;
static bool servoForward2 = true;
unsigned long currentTime2 = millis();
if(currentTime2 - servoTimer2 >= 20) { // Adjust for speed
servoTimer2 = currentTime2;
if (servoForward2) {
servo2Pos2++;
if (servo2Pos2 >= SERVO2_END) {
servoForward2 = false;
}
} else {
servo2Pos2--;
if (servo2Pos2 <= SERVO2_START) {
servoForward2 = true;
}
}
servo2.write(servo2Pos2);
}
}
// ESP-NOW callback
void OnDataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) {
if (len == sizeof(PacketData)) {
memcpy(&data, data, sizeof(PacketData));
}
}
espnow-car/espnow.h
+44
View File
@@ -0,0 +1,44 @@
// ESPNOW
#include <esp_now.h>
#include <WiFi.h>
// Packet Data Structure
struct PacketData {
uint8_t X; // Steering (left/right)
uint8_t Y; // Throttle (forward/backward)
bool B; // Button
};
// Data Received From Remote
PacketData data;
// ESP-NOW callback
void OnDataRecv(const esp_now_recv_info *info, const uint8_t *data, int len) {
if (len == sizeof(PacketData)) {
memcpy(&data, data, sizeof(PacketData));
}
}
// Function To Start ESPNOW
void espnow_begin() {
// ESP-NOW setup
WiFi.mode(WIFI_STA);
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW init failed");
return;
}
delay(100);
// Print MAC Address
Serial.println(WiFi.macAddress());
delay(2000);
// When Receive Data Execute OnDataRecv Function
esp_now_register_recv_cb(OnDataRecv);
}
espnow-car/fuzzy.h
+65
View File
@@ -0,0 +1,65 @@
#ifndef FUZZY_H
#define FUZZY_H
#include <Arduino.h>
#include <algorithm>
// Rear servo configuration
const int REAR_MIN = 52;
const int REAR_MAX = 140;
const int REAR_STRAIGHT = 95;
// Fuzzy logic functions
float triangularMF(float x, float a, float b, float c) {
return std::max(std::min((x - a) / (b - a), (c - x) / (c - b)), 0.0f);
}
float calculateCentroid(float* memberships, float* angles, int size) {
float sumMembership = 0;
float sumProduct = 0;
for (int i = 0; i < size; i++) {
sumMembership += memberships[i];
sumProduct += memberships[i] * angles[i];
}
return sumProduct / sumMembership;
}
float fuzzyRearSteering(float accelX, float accelY) {
// Define membership functions for inputs
float accelNeg = triangularMF(accelX, -1, -0.5, 0);
float accelZero = triangularMF(accelX, -0.5, 0, 0.5);
float accelPos = triangularMF(accelX, 0, 0.5, 1);
float rotSmall = triangularMF(accelY, -1, -0.5, 0);
float rotMedium = triangularMF(accelY, -0.5, 0, 0.5);
float rotLarge = triangularMF(accelY, 0, 0.5, 1);
// Define rule base
float ruleStrengths[9];
ruleStrengths[0] = std::min(accelNeg, rotSmall); // Right
ruleStrengths[1] = std::min(accelNeg, rotMedium); // Straight
ruleStrengths[2] = std::min(accelNeg, rotLarge); // Left
ruleStrengths[3] = std::min(accelZero, rotSmall); // Straight
ruleStrengths[4] = std::min(accelZero, rotMedium); // Straight
ruleStrengths[5] = std::min(accelZero, rotLarge); // Left
ruleStrengths[6] = std::min(accelPos, rotSmall); // Left
ruleStrengths[7] = std::min(accelPos, rotMedium); // Straight
ruleStrengths[8] = std::min(accelPos, rotLarge); // Right
// Define output angles (adjusted for rear servo range)
float outputAngles[9] = {
REAR_MAX, REAR_STRAIGHT, REAR_MIN, // Right, Straight, Left
REAR_STRAIGHT, REAR_STRAIGHT, REAR_MIN, // Straight, Straight, Left
REAR_MIN, REAR_STRAIGHT, REAR_MAX // Left, Straight, Right
};
// Defuzzification using centroid method
return calculateCentroid(ruleStrengths, outputAngles, 9);
}
#endif
espnow-car/l298n_esp32.h
+1
View File
@@ -1,3 +1,4 @@
#ifndef L298N_ESP32_h
#define L298N_ESP32_h
espnow-car/motor.h
+31
View File
@@ -0,0 +1,31 @@
// Libraries
#include "l298n_esp32.h"
// Motor 1 Pins
#define MOTOR1_PIN1 27
#define MOTOR1_PIN2 26
#define MOTOR1_ENABLE 14
// Motor 2 Pins
#define MOTOR2_PIN1 25
#define MOTOR2_PIN2 33
#define MOTOR2_ENABLE 32
// Motor State
enum MotorState {
STOPPED,
FORWARD_M1,
BACKWARD_M1,
FORWARD_M2,
BACKWARD_M2
};
// Motor Variables
MotorState currentMotorState = STOPPED;
unsigned long motorStateStartTime = 0;
const unsigned long MOTOR_ACTION_DELAY = 5000; // Delay between motor actions
// Motor Objects
L298N_ESP32 motor1(MOTOR1_PIN1, MOTOR1_PIN2, MOTOR1_ENABLE, 0);
L298N_ESP32 motor2(MOTOR2_PIN1, MOTOR2_PIN2, MOTOR2_ENABLE, 1);
espnow-car/servo.h
+17
View File
@@ -0,0 +1,17 @@
// Servo Library
#include "Servo_ESP32.h"
// Servo Pins
#define SERVO1_PIN 13
#define SERVO2_PIN 12
// Servo Objects
Servo_ESP32 servo1(SERVO1_PIN, 2, 1000, 2000);
Servo_ESP32 servo2(SERVO2_PIN, 3, 1000, 2000);
// Constants
const int SERVO1_START = 10;
const int SERVO1_END = 170;
const int SERVO2_START = 20;
const int SERVO2_END = 160;
espnow-car/servo_esp32.h
+63 -58
View File
@@ -1,74 +1,78 @@
#ifndef Servo_ESP32_h
#define Servo_ESP32_h
#include <Arduino.h>
#ifndef Servo_ESP32_h
#define Servo_ESP32_h
class Servo_ESP32 {
private:
uint8_t servoPin;
uint8_t pwmChannel;
int minPulseWidth;
int maxPulseWidth;
int currentAngle;
const int freq = 50; // 50Hz for standard servos
const int resolution = 16; // 16-bit resolution for smoother control
bool _invert = false;
uint8_t _min_pos = 0;
uint8_t _max_pos = 180;
uint8_t _init_pos = 90;
uint8_t _prv_pos = 0;
#include <Arduino.h>
bool verify(uint8_t input) {
class Servo_ESP32 {
private:
uint8_t servoPin;
uint8_t pwmChannel;
int minPulseWidth;
int maxPulseWidth;
int currentAngle;
const int freq = 50; // 50Hz for standard servos
const int resolution = 16; // 16-bit resolution for smoother control
bool _invert = false;
uint8_t _min_pos = 0;
uint8_t _max_pos = 180;
uint8_t _init_pos = 90;
uint8_t _prv_pos = 0;
bool verify(uint8_t input) {
if (input != _prv_pos) {
_prv_pos = input;
return true;
_prv_pos = input;
return true;
}
return false;
}
}
public:
Servo_ESP32() {}
Servo_ESP32(uint8_t pin, uint8_t channel, int minPulse = 500, int maxPulse = 2500) :
servoPin(pin), pwmChannel(channel), minPulseWidth(minPulse), maxPulseWidth(maxPulse), currentAngle(0) {}
public:
void begin() {
Servo_ESP32() {}
Servo_ESP32(uint8_t pin, uint8_t channel, int minPulse = 500, int maxPulse = 2500) : servoPin(pin), pwmChannel(channel), minPulseWidth(minPulse), maxPulseWidth(maxPulse), currentAngle(0) {}
void begin() {
ledcAttachChannel(pwmChannel, freq, resolution, servoPin); // Correct order: channel, freq, resolution, pin
write(_init_pos);
}
}
void setPin(uint8_t pin) {
void setPin(uint8_t pin) {
servoPin = pin;
}
}
void invert() {
void invert() {
_invert = !_invert;
}
}
void setMin(uint8_t start) {
void setMin(uint8_t start) {
_min_pos = start;
}
}
void setMax(uint8_t stop) {
void setMax(uint8_t stop) {
_max_pos = stop;
}
}
void setInit(uint8_t init) {
void setInit(uint8_t init) {
_init_pos = init;
}
}
void goMax() {
void goMax() {
write(_max_pos);
}
}
void goMin() {
void goMin() {
write(_min_pos);
}
}
void goInit() {
void goInit() {
write(_init_pos);
}
}
void write(int angle) {
void write(int angle) {
if (!verify(angle)) return;
currentAngle = _invert ? 180 - angle : angle;
currentAngle = constrain(currentAngle, 0, 180);
@@ -76,29 +80,30 @@ public:
minPulseWidth,
maxPulseWidth);
ledcWrite(pwmChannel, dutyCycle);
}
}
int read() {
int read() {
return currentAngle;
}
}
void move(uint8_t pos) {
void move(uint8_t pos) {
pos = constrain(pos, _min_pos, _max_pos);
write(pos);
}
}
void percent(uint8_t pos) {
void percent(uint8_t pos) {
pos = map(pos, 0, 100, _min_pos, _max_pos);
write(pos);
}
}
void override(uint8_t pos) {
void override(uint8_t pos) {
write(pos);
}
}
// Add these functions to access the private attributes
uint8_t getMin() const { return _min_pos; }
uint8_t getMax() const { return _max_pos; }
};
// Add these functions to access the private attributes
uint8_t getMin() const { return _min_pos; }
uint8_t getMax() const { return _max_pos; }
#endif
};
#endif