1. LDR (Light Dependent Resistor): Para detectar la diferencia de luz.
2. Resistor fijo: Usualmente de unos 10kΩ, que forma un divisor de voltaje con el LDR.
3. Transistor: Un NPN como el BC547 para amplificar la señal.
4. Relé: Capaz de manejar la carga de corriente alterna de 120V.
5. Diodo: Un 1N4007 puede proteger el circuito del retorno de corriente del relé.
6. Fuente de alimentación DC: Apropiada para operar el circuito de control. Por ejemplo, 9V o 12V.
7. Potenciómetro (opcional): Para ajustar la sensibilidad del LDR.

1. Divisor de Voltaje:
   • Conecta el LDR y un resistor fijo en serie. Puedes usar un potenciómetro en lugar del resistor fijo para ajustar la sensibilidad.
   • Conecta el punto medio de este divisor al base del transistor NPN, que actúa como un interruptor controlado.
2. Circuito de Control del Transistor:
   • Conecta un extremo del divisor de voltaje al Vcc (positivo de la fuente de alimentación) y el otro extremo al GND.
   • Conecta el colector del transistor al un lado de la bobina del relé.
   • Conecta el emisor del transistor a GND.
3. Conexión del Relé:
   • Conecta el otro extremo de la bobina del relé al Vcc de la fuente de alimentación.
   • Conecta un diodo en paralelo con la bobina del relé, con el cátodo hacia el lado positivo, para evitar picos de tensión inversa.
4. Conexión de la Luminaria:
   • Conecta la luminaria al lado normalmente abierto del relé, de manera que se cierre el circuito solo cuando el relé sea activado.

• En la oscuridad, la resistencia del LDR aumenta, lo que incrementa el voltaje en la base del transistor y lo activa.
• Esto hace que el transistor conduzca, energizando la bobina del relé y cerrando los contactos para encender la luminaria.
• En presencia de luz, el LDR reduce su resistencia, desactivando el transistor y abriendo el circuito para apagar la luminaria.

• LDR (Light Dependent Resistor): para detectar la luz.
• Arduino (u otro microcontrolador): para procesar la señal del LDR.
• Relevador de estado sólido (SSR): para encender y apagar las luminarias de 120V.
• Resistencia: para el divisor de voltaje del LDR.
• Fuente de alimentación: para el Arduino y el circuito de control.

1. LDR y Resistencia: Conectar el LDR en serie con una resistencia formando un divisor de tensión. Este divisor se conecta a una entrada analógica del Arduino.
   • Conexiones:
     • Conectar un terminal del LDR al pin analógico A0 del Arduino y al extremo de la resistencia.
     • Conectar el otro terminal del LDR a VCC (5V).
     • Conectar el otro extremo de la resistencia a GND.
2. Relevador de Estado Sólido (SSR): Usar una salida digital del Arduino para controlar el SSR
   • Conexiones:
     • Conectar un pin digital del Arduino (por ejemplo, D2) a la entrada de control del SSR.
     • Asegurarse de que las conexiones de carga del SSR se conecten correctamente a la línea de 120V y las luminarias.
3. Luminarias: Conectar a la salida del SSR para que sean controladas.

1. Leer el valor del LDR a través del pin analógico del Arduino.
2. Comparar el valor leído con un umbral predefinido (por ejemplo, un valor correspondiente a cuando oscurece).
3. Activar el pin de control del SSR cuando el valor del LDR esté por debajo del umbral (indica oscuridad) y desactivarlo de lo contrario.

Cpp
const int ldrPin = A0;
const int ssrPin = 2;
const int threshold = 500;  // Ajusta esto según las condiciones de luminosidad reales

void setup() {
  pinMode(ssrPin, OUTPUT);
  digitalWrite(ssrPin, LOW);
}

void loop() {
  int ldrValue = analogRead(ldrPin);
  if (ldrValue < threshold) {
    digitalWrite(ssrPin, HIGH);  // Enciende la luz
  } else {
    digitalWrite(ssrPin, LOW);   // Apaga la luz
  }
  delay(1000);  // Espera 1 segundo antes de volver a leer
}

• Aislamiento del circuito de control: Asegúrate de que el circuito de baja tensión del Arduino esté aislado físicamente del circuito de alta tensión de las luminarias. Utilizar un SSR es una opción segura ya que proporciona aislamiento.
• Corriente máxima del SSR: Verificar que el SSR usado esté especificado para manejar la carga total de las luminarias conectadas.

• Arduino (cualquier modelo adecuado como el Uno o Nano)
• LDR o fototransistor
• Resistor (10kΩ es típico cuando usas un LDR)
• Módulo de relé
• Luminarias (puede ser una lámpara o cualquier dispositivo eléctrico)
• Fuente de alimentación adecuada para las luminarias
• Protoboard y cables de conexión

1. Sensor de luz (LDR)
   • Conecta un terminal del LDR al pin VCC del Arduino.
   • Conecta el otro terminal del LDR al pin de entrada analógica del Arduino, por ejemplo, A0.
   • Conecta en paralelo un resistor (10kΩ) entre el pin de entrada analógica (A0) y GND.
2. Módulo de relé
   • Conecta el pin de control del módulo de relé a uno de los pines digitales del Arduino, por ejemplo, D2.
   • Conecta el pin COM del módulo de relé a un cable de alimentación (puede ser fase o neutro según el diseño del relé).
   • La salida del relé (NO o NC, normalmente abierto o cerrado según cómo quieras operar) se conecta a la luminaria.
3. Conexiones de energía
   • Alimenta el Arduino a través de su conexión USB o una fuente externa adecuada.
   • Asegúrate de que la fuente de alimentación de las luminarias está adecuada y segura.

Cpp
int ldrPin = A0; // Pin donde está conectado el LDR
int relayPin = 2; // Pin conectado al módulo de relé
int threshold = 500; // Umbral para decidir cuándo es oscuro

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW); // Asegúrate de que el relé esté apagado inicialmente
  Serial.begin(9600); // Para monitorear los valores en el monitor serial
}

void loop() {
  int ldrValue = analogRead(ldrPin); // Lee el valor del LDR

  Serial.println(ldrValue); // Mostrar el valor en el monitor serial

  if (ldrValue < threshold) { 
    digitalWrite(relayPin, HIGH); // Enciende las luminarias
  } else {
    digitalWrite(relayPin, LOW); // Apaga las luminarias
  }

  delay(1000); // Pequeño retardo para evitar lecturas muy rápidas
}

• Ajusta el umbral (threshold) en el código hasta encontrar el nivel adecuado de oscuridad para tu aplicación.
• Verifica la capacidad del módulo de relé y asegúrate de que puede manejar la corriente necesaria para tus luminarias.
• Siempre tener en cuenta la seguridad, especialmente cuando trabaje con voltajes de red.

• ATtiny85
• Programador USB para ATtiny (como USBasp o un Arduino configurado como programador ISP)
• LDR o fototransistor
• Resistor (10kΩ típico para LDR)
• Módulo de relé
• Luminarias
• Fuente de alimentación adecuada para las luminarias
• Protoboard y cables de conexión

1. Programación del ATtiny85:
   • Programa el ATtiny85 con un Arduino Uno como ISP o usando un programador USB.
   • Carga el código antes de realizar las conexiones finales.
2. Conexiones para el sensor de luz (LDR):
   • Conecta un terminal del LDR al VCC del ATtiny85 (usualmente 5V desde una fuente externa).
   • Conecta el otro terminal del LDR al pin 2 $(PB3)$ del ATtiny85.
   • Coloca un resistor de 10kΩ entre el pin 2 $(PB3)$ y GND.
3. Módulo de relé:
   • Conecta el pin de control del módulo de relé al pin 3 $(PB4)$ del ATtiny85.
   • Conecta el pin COM del módulo de relé a uno de los cables de alimentación de las luminarias.
   • Conecta la salida NO o NC del módulo de relé, según la configuración deseada, a las luminarias.
4. Conexiones de energía:
   • Provee al ATtiny85 una alimentación de 5V adecuada.
   • Asegúrate de la seguridad en la conexión de las luminarias.

Cpp
int ldrPin = A3; // PB3 es el pin físico 2 en el ATtiny85
int relayPin = 4; // PB4 es el pin físico 3 en el ATtiny85
int threshold = 500; // Umbral de oscuridad

void setup() {
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW); // Asegúrate de que el relé esté apagado inicialmente
}

void loop() {
  int ldrValue = analogRead(ldrPin); // Lee el valor del LDR

  if (ldrValue < threshold) { 
    digitalWrite(relayPin, HIGH); // Enciende las luminarias
  } else {
    digitalWrite(relayPin, LOW); // Apaga las luminarias
  }

  delay(1000); // Retardo para estabilidad de lectura
}

• Asegúrate de tener los fuses del ATtiny85 configurados para usar el reloj interno a 8MHz.
• Puedes necesitar un programador USB para cargar el código en el ATtiny85 a través del IDE de Arduino.
• Verifica que el consumo del módulo de relé y del circuito en su totalidad sea adecuado para la fuente de alimentación que planeas usar.

• LDR
• Resistor (10kΩ para el divisor de voltaje)
• Potenciómetro (10kΩ para ajustar el umbral de luz)
• Transistor NPN (como el BC547)
• Diodo (1N4007 para protección del relé)
• Módulo de relé
• Luminarias (como una lámpara)
• Fuente de alimentación para el relé y las luminarias
• Protoboard y cables de conexión

1. Divisor de voltaje con LDR:
   • Conecta un terminal del LDR al VCC.
   • Conecta el otro terminal del LDR a un terminal del potenciómetro y a la base del transistor a través de un resistor (1kΩ).
   • Conecta el otro terminal del potenciómetro a GND.
   • Ajusta el potenciómetro para establecer el umbral de luz que deseas.
2. Transistor y relé:
   • Conecta el colector del transistor al pin de control del módulo de relé.
   • Conecta el emisor del transistor a GND.
   • Conecta un extremo del diodo al pin positivo de la bobina del relé y el otro extremo al pin negativo (en paralelo con la bobina) para evitar picos de voltaje reverso.
   • Conecta el otro extremo del módulo de relé a la fuente de alimentación del relé.
3. Conexión de la luminaria:
   • Conecta el terminal COM del módulo de relé a uno de los cables de alimentación de la luminaria.
   • Conecta el terminal NO (normally open) del módulo de relé al otro cable de alimentación de la luminaria.

• Cuando la luz disminuye, el voltaje en la base del transistor aumenta suficiente para encender el transistor.
• Esto activa el relé, que cierra el circuito y enciende las luminarias.
• Ajusta el potenciómetro para definir el nivel de luz en el cual el relé se activa.

• Asegúrate de que el transistor y el relé seleccionados son adecuados para la carga que estás controlando.
• Siempre presta atención a la seguridad al trabajar con voltaje de red y asegúrate de que las conexiones son seguras y aisladas adecuadamente.