1. Creating an Account:
   • Visit $\text{flux.ai/signup}$ and enter your username, email, and password. Alternatively, you can sign up using your Google account.
2. Placing Components:
   • In schematic mode, drag components from the library onto the canvas and drop them where you want them to be placed.
3. Connecting Components:
   • Use the wire tool to connect components by clicking from one pin to another. For instance, to connect a resistor $R1$ and a capacitor $C1$, connect $R1:1$ to $C1:1$.
4. Simulation:
   • You can simulate your circuit by using the simulator feature. For more details on how to use the simulator, check out the tutorial available in the documentation.
5. Positioning and Routing:
   • Properly positioning and routing your components is essential for creating an efficient PCB layout.
6. Getting Help and Learning More:
   • To deepen your knowledge and find more tutorials, you can explore the video tutorials, crash courses, and recorded events available on YouTube.
   • For support and to connect with the community, join the Flux Slack community where you can ask questions directly to the Flux team and interact with other users.

• Motor 1:
  • Señal PWM conectada al pin 9 del Arduino
• Motor 2:
  • Señal PWM conectada al pin 10 del Arduino

Cpp
#include 

Servo motor1;  // Crear objeto Servo para el motor 1
Servo motor2;  // Crear objeto Servo para el motor 2

int motor1Pin = 9;  // Pin de PWM para motor 1
int motor2Pin = 10; // Pin de PWM para motor 2

void setup() {
  // Configurar los pines de los motores
  motor1.attach(motor1Pin);
  motor2.attach(motor2Pin);

  // Inicializar los motores a la posición neutral
  motor1.writeMicroseconds(1000);  // Señal mínima
  motor2.writeMicroseconds(1000);  // Señal mínima

  delay(1000);  // Esperar un segundo para que los ESC se inicialicen
}

void loop() {
  // Aumentar la velocidad de los motores gradualmente
  for $$int \, speed = 1000; \, speed \leq 2000; \, speed += 10$$ {
    motor1.writeMicroseconds(speed);
    motor2.writeMicroseconds(speed);
    delay(50);
  }

  // Mantener la máxima velocidad por 2 segundos
  delay(2000);

  // Disminuir la velocidad de los motores gradualmente
  for $$int \, speed = 2000; \, speed \geq 1000; \, speed -= 10$$ {
    motor1.writeMicroseconds(speed);
    motor2.writeMicroseconds(speed);
    delay(50);
  }

  // Mantener la mínima velocidad por 2 segundos antes de repetir
  delay(2000);
}

1. Incluimos la librería Servo: Usada para controlar los PWM que van a los ESC.
2. Creamos objetos Servo para los motores.
3. En la función setup():
   • Asignamos los pines de los motores y los inicializamos a la posición mínima (1000 microsegundos).
4. En la función loop():
   • Gradualmente aumentamos la velocidad de los motores de 1000 a 2000 microsegundos.
   • Mantenemos la velocidad máxima durante 2 segundos.
   • Gradualmente reducimos la velocidad de los motores de vuelta a 1000 microsegundos.
   • Mantenemos la velocidad mínima durante 2 segundos antes de repetir el ciclo.

• Motor 1:
  • Señal PWM conectada al pin 9 del Arduino
• Motor 2:
  • Señal PWM conectada al pin 10 del Arduino
• Motor 3:
  • Señal PWM conectada al pin 11 del Arduino
• Motor 4:
  • Señal PWM conectada al pin 12 del Arduino

Cpp
#include 

Servo motor1;  // Crear objeto Servo para el motor 1
Servo motor2;  // Crear objeto Servo para el motor 2
Servo motor3;  // Crear objeto Servo para el motor 3
Servo motor4;  // Crear objeto Servo para el motor 4

int motor1Pin = 9;  // Pin de PWM para motor 1
int motor2Pin = 10; // Pin de PWM para motor 2
int motor3Pin = 11; // Pin de PWM para motor 3
int motor4Pin = 12; // Pin de PWM para motor 4

void setup() {
  // Configurar los pines de los motores
  motor1.attach(motor1Pin);
  motor2.attach(motor2Pin);
  motor3.attach(motor3Pin);
  motor4.attach(motor4Pin);

  // Inicializar los motores a la posición neutral
  motor1.writeMicroseconds(1000);  // Señal mínima
  motor2.writeMicroseconds(1000);  // Señal mínima
  motor3.writeMicroseconds(1000);  // Señal mínima
  motor4.writeMicroseconds(1000);  // Señal mínima

  delay(1000);  // Esperar un segundo para que los ESC se inicialicen
}

void loop() {
  // Aumentar la velocidad de los motores gradualmente
  for $int speed = 1000; speed = 1000; speed -= 10$ {
    motor1.writeMicroseconds(speed);
    motor2.writeMicroseconds(speed);
    motor3.writeMicroseconds(speed);
    motor4.writeMicroseconds(speed);
    delay(50);
  }

  // Mantener la mínima velocidad por 2 segundos antes de repetir
  delay(2000);
}

1. Incluimos la librería Servo: Se utiliza para generar las señales PWM.
2. Creamos objetos Servo para cada uno de los cuatro motores.
3. En la función setup():
   • Asignamos los pines correspondientes a los motores.
   • Inicializamos todos los motores a la posición mínima (1000 microsegundos).
4. En la función loop():
   • Aumentamos gradualmente la velocidad de todos los motores de 1000 a 2000 microsegundos.
   • Mantendremos la velocidad máxima durante 2 segundos.
   • Reducimos gradualmente la velocidad de todos los motores de vuelta a 1000 microsegundos.
   • Mantendremos la velocidad mínima durante 2 segundos antes de repetir el ciclo.

• Motor 1:
  • Señal PWM conectada al pin 3 del Arduino
• Motor 2:
  • Señal PWM conectada al pin 5 del Arduino
• Motor 3:
  • Señal PWM conectada al pin 6 del Arduino
• Motor 4:
  • Señal PWM conectada al pin 9 del Arduino

Cpp
#include 

Servo motor1;  // Crear objeto Servo para el motor 1
Servo motor2;  // Crear objeto Servo para el motor 2
Servo motor3;  // Crear objeto Servo para el motor 3
Servo motor4;  // Crear objeto Servo para el motor 4

int motor1Pin = 3;  // Pin de PWM para motor 1
int motor2Pin = 5;  // Pin de PWM para motor 2
int motor3Pin = 6;  // Pin de PWM para motor 3
int motor4Pin = 9;  // Pin de PWM para motor 4

void setup() {
  // Configurar los pines de los motores
  motor1.attach(motor1Pin);
  motor2.attach(motor2Pin);
  motor3.attach(motor3Pin);
  motor4.attach(motor4Pin);

  // Inicializar los motores a la posición neutral
  motor1.writeMicroseconds(1000);  // Señal mínima
  motor2.writeMicroseconds(1000);  // Señal mínima
  motor3.writeMicroseconds(1000);  // Señal mínima
  motor4.writeMicroseconds(1000);  // Señal mínima

  delay(1000);  // Esperar un segundo para que los ESC se inicialicen
}

void loop() {
  // Aumentar la velocidad de los motores gradualmente
  for $$int \textit{speed} = 1000; \textit{speed} \leq 2000; \textit{speed} += 10$$ {
    motor1.writeMicroseconds(speed);
    motor2.writeMicroseconds(speed);
    motor3.writeMicroseconds(speed);
    motor4.writeMicroseconds(speed);
    delay(50);
  }

  // Mantener la máxima velocidad por 2 segundos
  delay(2000);

  // Disminuir la velocidad de los motores gradualmente
  for $$int \textit{speed} = 2000; \textit{speed} \geq 1000; \textit{speed} -= 10$$ {
    motor1.writeMicroseconds(speed);
    motor2.writeMicroseconds(speed);
    motor3.writeMicroseconds(speed);
    motor4.writeMicroseconds(speed);
    delay(50);
  }

  // Mantener la mínima velocidad por 2 segundos antes de repetir
  delay(2000);
}

1. Incluimos la librería Servo: Esta se utiliza para generar las señales PWM necesarias que controlan los ESC.
2. Creamos objetos Servo para los cuatro motores.
3. En la función setup():
   • Asignamos los pines de salida de PWM correspondientes a cada motor.
   • Inicializamos los motores a la posición mínima (1000 microsegundos).
4. En la función loop():
   • Gradualmente aumentamos la velocidad de los motores desde 1000 hasta 2000 microsegundos.
   • Mantenemos la velocidad máxima durante 2 segundos.
   • Gradualmente reducimos la velocidad de los motores de vuelta a 1000 microsegundos.
   • Mantenemos la velocidad mínima durante 2 segundos antes de repetir el ciclo.

• Motor 1:
  • Señal PWM conectada al pin 3 del Arduino
• Motor 2:
  • Señal PWM conectada al pin 5 del Arduino
• Motor 3:
  • Señal PWM conectada al pin 6 del Arduino
• Motor 4:
  • Señal PWM conectada al pin 9 del Arduino

Cpp
#include 

// Crear objetos Servo para los motores
Servo motor1;
Servo motor2;
Servo motor3;
Servo motor4;

void setup() {
  // Conectar cada motor a su respectivo pin
  motor1.attach(3);  // Pin de PWM para motor 1
  motor2.attach(5);  // Pin de PWM para motor 2
  motor3.attach(6);  // Pin de PWM para motor 3
  motor4.attach(9);  // Pin de PWM para motor 4

  // Inicializar los motores a la posición neutral (señal mínima)
  motor1.writeMicroseconds(1000);
  motor2.writeMicroseconds(1000);
  motor3.writeMicroseconds(1000);
  motor4.writeMicroseconds(1000);

  delay(1000);  // Esperar un segundo para que los ESC se inicialicen
}

void loop() {
  // Aumentar la velocidad de los motores gradualmente
  for $$int \text{speed} = 1000; \text{speed} \leq 2000; \text{speed} += 10$$ {
    motor1.writeMicroseconds$$speed$$;
    motor2.writeMicroseconds$$speed$$;
    motor3.writeMicroseconds$$speed$$;
    motor4.writeMicroseconds$$speed$$;
    delay$$50$$;
  }

  // Mantener la máxima velocidad por 2 segundos
  delay$$2000$$;

  // Disminuir la velocidad de los motores gradualmente
  for $$int \text{speed} = 2000; \text{speed} \geq 1000; \text{speed} -= 10$$ {
    motor1.writeMicroseconds$$speed$$;
    motor2.writeMicroseconds$$speed$$;
    motor3.writeMicroseconds$$speed$$;
    motor4.writeMicroseconds$$speed$$;
    delay$$50$$;
  }

  // Mantener la mínima velocidad por 2 segundos antes de repetir
  delay$$2000$$;
}

1. Incluimos la librería Servo: Se utiliza para generar las señales PWM requeridas para controlar los ESC.
2. Creamos cuatro objetos Servo: Para cada uno de los cuatro motores.
3. En la función setup():
   • Conectamos cada motor a su respectivo pin de salida de PWM.
   • Inicializamos todos los motores a la señal mínima (1000 microsegundos).
4. En la función loop():
   • Gradualmente aumentamos la velocidad de los motores de 1000 a 2000 microsegundos.
   • Mantenemos la velocidad máxima durante 2 segundos.
   • Gradualmente disminuimos la velocidad de vuelta a 1000 microsegundos.
   • Mantenemos la velocidad mínima durante 2 segundos antes de repetir el ciclo.

1. Visit the Flux Signup Page: Go to Flux Signup.
2. Enter your Details: You can create an account using your email and password or link a Google account.

1. Starting a New Project
   • Click on the "New Project" button on the home page or your dashboard.
   • Choose to start with a blank schematic or use a predefined template.
2. Adding Components
   • Drag components from the library onto the canvas and drop them where you want. You can find a variety of components suitable for different needs.
3. Connecting Components
   • Use wires to connect the components. Clicking on a pin of a component will allow you to draw a wire to the pin of another component.
4. Simulating Your Design
   • You can simulate your schematic design directly in Flux to test circuit behavior before fabricating the PCB. Refer to the simulator tutorial for more details.

1. Positioning Components
   • Once your schematic is ready, you can switch to PCB layout mode where you can position your components on the board layout.
2. Routing Traces
   • Connect your components by routing traces between the pads. Make sure to consider trace width, spacing, and routing layers for a manufacturable design.

1. Documentation
   • Access the detailed documentation directly in Flux or visit the documentation section for more information on specific features and tasks.
2. Support and Community
   • Join the Flux Slack community for support and to connect with other users.
3. Tutorials and Videos
   • Explore the library of video tutorials on YouTube which cover various aspects of using Flux for your projects.

1. Microcontrolador: ESP32 o similar.
2. Controladores de Motores: Controladores ESC (Electronic Speed Controllers).
3. Motores: Motores brushless.
4. Batería: Batería LiPo.
5. Sensores: Giroscopio y acelerómetro (por ejemplo, MPU6050).
6. Receptor de RF: Para recibir señales de un control remoto.
7. Regulador de Voltaje: Para asegurar que todos los componentes reciban el voltaje adecuado.
8. LEDs y otros periféricos: Indicadores de estado.

• Conexiones del ESP32:
  • Connect ESP32:3V3 a VCC del MPU6050.
  • Connect ESP32:GND a GND del MPU6050.
  • Connect ESP32:SCL a SCL del MPU6050.
  • Connect ESP32:SDA a SDA del MPU6050.
• Conexiones de los ESCs:
  • Connect Batería + a ESC1:Vin, ESC2:Vin, ESC3:Vin, y ESC4:Vin.
  • Connect Batería - a ESC1:GND, ESC2:GND, ESC3:GND, y ESC4:GND.
  • Connect ESC1:Sal$a$ a Motor1.
  • Connect ESC2:Sal$a$ a Motor2.
  • Connect ESC3:Sal$a$ a Motor3.
  • Connect ESC4:Sal$a$ a Motor4.
  • Connect ESC1:Control a ESP32:D5.
  • Connect ESC2:Control a ESP32:D6.
  • Connect ESC3:Control a ESP32:D7.
  • Connect ESC4:Control a ESP32:D8.
• Receptor de RF:
  • Connect Receptor VCC a 5V de la batería.
  • Connect Receptor GND a GND.
  • Connect Receptor S1 a ESP32:D2 $canal\ de\ acelerador$.
  • Connect Receptor S2 a ESP32:D3 $canal\ de\ dirección$.

Cpp
#include 
#include 

MPU6050 mpu;
int escPin1 = 5;
int escPin2 = 6;
int escPin3 = 7;
int escPin4 = 8;

int channel1; // Acelerador
int channel2; // Dirección

void setup() {
  Serial.begin(115200);
  Wire.begin();
  mpu.initialize();
  
  pinMode(escPin1, OUTPUT);
  pinMode(escPin2, OUTPUT);
  pinMode(escPin3, OUTPUT);
  pinMode(escPin4, OUTPUT);

  pinMode(2, INPUT); // Canal de acelerador
  pinMode(3, INPUT); // Canal de dirección
}

void loop() {
  // Leer valores del receptor
  channel1 = pulseIn(2, HIGH);
  channel2 = pulseIn(3, HIGH);
  
  // Leer valores del MPU6050
  int16_t ax, ay, az;
  int16_t gx, gy, gz;
  mpu.getMotion6($$ax, ay, az, gx, gy, gz$$);
  
  // Asignar valores de PWM a los ESCs
  analogWrite(escPin1, map(channel1, 1000, 2000, 0, 255));
  analogWrite(escPin2, map(channel1, 1000, 2000, 0, 255));
  analogWrite(escPin3, map(channel1, 1000, 2000, 0, 255));
  analogWrite(escPin4, map(channel1, 1000, 2000, 0, 255));

  delay(20); // Delay para sincronización
}

Python
import matplotlib.pyplot as plt
import networkx as nx

# Create a directed graph
G = nx.DiGraph()

# Define nodes
nodes = {
    'ESP32': (2, 8),
    'MPU6050': (4, 8),
    'ESC1': (3, 5),
    'ESC2': (4, 5),
    'ESC3': (5, 5),
    'ESC4': (3, 3),
    'Motor1': (2, 2),
    'Motor2': (4, 2),
    'Motor3': (6, 2),
    'Motor4': (4, 1),
    'Battery +': (0, 5),
    'Receiver': (1, 8),
}

# Add nodes to the graph
for node, pos in nodes.items():
    G.add_node(node, pos=pos)

# Define edges
edges = [
    ('ESP32', 'MPU6050'), 
    ('ESP32', 'ESC1'), 
    ('ESP32', 'ESC2'), 
    ('ESP32', 'ESC3'), 
    ('ESP32', 'ESC4'), 
    ('ESC1', 'Motor1'), 
    ('ESC2', 'Motor2'), 
    ('ESC3', 'Motor3'), 
    ('ESC4', 'Motor4'), 
    ('Battery +', 'ESC1'),
    ('Battery +', 'ESC2'),
    ('Battery +', 'ESC3'),
    ('Battery +', 'ESC4'),
    ('Battery +', 'Receiver'),
    ('Receiver', 'ESP32')
]

# Add edges to the graph
G.add_edges_from(edges)

# Define positions for nodes
pos = nx.get_node_attributes(G, 'pos')

# Draw the graph
plt.figure(figsize=(10, 7))
nx.draw(G, pos, with_labels=True, node_size=3000, node_color="skyblue", font_size=10, font_weight="bold", arrowsize=20, edge_color='gray')

# Title
plt.title('Circuit Diagram for Drone')
plt.show()

1. ESP32: Controlador central de tu dron.
2. MPU6050: Sensor giroscópico y acelerómetro.
3. ESC1, ESC2, ESC3, y ESC4: Controladores de velocidad electrónica para los motores.
4. Motores 1, 2, 3, y 4: Motores brushless del dron.
5. Batería: Fuente de alimentación.
6. Receptor RF: Recibe las señales del control remoto.

• Conexiones del ESP32:
  • Connect ESP32:3V3 a VCC del MPU6050.
  • Connect ESP32:GND a GND del MPU6050.
  • Connect ESP32:SCL a SCL del MPU6050.
  • Connect ESP32:SDA a SDA del MPU6050.
  • Connect ESP32:D5 a ESC1:Control.
  • Connect ESP32:D6 a ESC2:Control.
  • Connect ESP32:D7 a ESC3:Control.
  • Connect ESP32:D8 a ESC4:Control.
• Conexiones de los ESCs:
  • Connect Batería $+$ a ESC1:Vin, ESC2:Vin, ESC3:Vin, y ESC4:Vin.
  • Connect Batería $-$ a ESC1:GND, ESC2:GND, ESC3:GND, y ESC4:GND.
  • Connect ESC1 al Motor1.
  • Connect ESC2 al Motor2.
  • Connect ESC3 al Motor3.
  • Connect ESC4 al Motor4.
• Conexiones del receptor de RF:
  • Connect Receptor VCC a 5V de la batería.
  • Connect Receptor GND a GND.
  • Connect Receptor S1 a ESP32:D2 $($canal de acelerador$)$.
  • Connect Receptor S2 a ESP32:D3 $($canal de dirección$)$.

1. Crear una Cuenta y Proyecto
   • Visita flux.ai y crea una cuenta.
   • Crea un nuevo proyecto.
2. Añadir Componentes al Esquema
   • En la pantalla principal de tu proyecto, selecciona la opción para agregar componentes desde la librería en el lado izquierdo.
   • Busca y selecciona los componentes necesarios: ESP32, MPU6050, ESC (Electronic Speed Controllers), motores brushless, batería LiPo, y un receptor de RF.
3. Colocar los Componentes
   • Arrastra y suelta los componentes necesarios en tu canvas de esquema.
4. Hacer Conexiones entre los Componentes
   • Conecta los componentes de acuerdo a las conexiones listadas anteriormente.

• Conexiones del ESP32:
  • Conecta ESP32:3V3 a VCC del MPU6050.
  • Conecta ESP32:GND a GND del MPU6050.
  • Conecta ESP32:SCL a SCL del MPU6050.
  • Conecta ESP32:SDA a SDA del MPU6050.
  • Conecta ESP32:D5 a Control de ESC1.
  • Conecta ESP32:D6 a Control de ESC2.
  • Conecta ESP32:D7 a Control de ESC3.
  • Conecta ESP32:D8 a Control de ESC4.
• Conexiones de los ESCs:
  • Conecta Batería $+$ a Vin de ESC1, ESC2, ESC3, y ESC4.
  • Conecta Batería $-$ a GND de ESC1, ESC2, ESC3, y ESC4.
  • Conecta ESC1 al Motor1.
  • Conecta ESC2 al Motor2.
  • Conecta ESC3 al Motor3.
  • Conecta ESC4 al Motor4.
• Conexiones del Receptor de RF:
  • Conecta VCC del Receptor a 5V de la Batería.
  • Conecta GND del Receptor a GND de la Batería.
  • Conecta S1 del Receptor a ESP32:D2 $\text{(canal de acelerador)}$.
  • Conecta S2 del Receptor a ESP32:D3 $\text{(canal de dirección)}$.

• Flux incorpora un simulador que te permitirá verificar el comportamiento eléctrico de tu diseño mientras trabajas.

• Guarda tu proyecto y compártelo con otros para recibir feedback o colaboraciones.