manejar con un arduiono 6 botones con resistencias están conectados del puerto PC5 al PC0. Una pantalla LCD está conectada del puerto PD2 al PD5, con EN en PB3 y RS en PB4. PB2 enviará pulsos PWM al gate de un MOSFET, con drain a GND y source al negativo de un motor Arduino. Un HX711 está conectado a GND y 5V, DT al puerto PD7 y SCK al PD6, junto a una celda de carga. Una batería externa alimentará el Arduino en caso de corte de energía. Crear un menu para un el LCD con sus puertos D4 a D7 conectados a los puertos PD2 a PD5 su RS a PB4, EN a PB3 y RW a GND, controlado por los botones, permite seleccionar horarios y pesos objetivos. Al llegar la hora seleccionada, se enviara el pulso de PWM durante un momento, moviendo un tornillo de Arquímedes para depositar comida en la celda de carga. El pulso PWM se detendra cuando el peso alcanzado es el seleccionado. La velocidad del motor debe ser lenta para evitar exceso de comida.

Aquí te presento un ejemplo de código en C para el Arduino que cumple con las especificaciones que mencionaste:
```c
#include <LiquidCrystal.h>
#include <Wire.h>
#include <SPI.h>
#include <EEPROM.h>

// Definir pines para el LCD
const int rs = 4;  // PB4
const int en = 3;  // PB3
const int d4 = 2;  // PD2
const int d5 = 3;  // PD3
const int d6 = 4;  // PD4
const int d7 = 5;  // PD5

// Definir pines para los botones
const int botones[] = {5, 6, 7, 8, 9, 10};  // PC5 a PC0

// Definir pines para el HX711
const int dt = 7;  // PD7
const int sck = 6;  // PD6

// Definir pines para el MOSFET
const int gate = 2;  // PB2

// Definir pines para la batería externa
const int vcc = 5;  // 5V
const int gnd = 0;  // GND

// Definir pines para la pantalla LCD
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

// Definir variables para el horario y el peso objetivo
int hora = 0;
int peso = 0;

// Definir variables para el estado del sistema
int estado = 0;
int botonActual = 0;
int botonAnterior = 0;

void setup() {
  // Inicializar pines
  pinMode(vcc, OUTPUT);
  pinMode(gnd, OUTPUT);
  pinMode(gate, OUTPUT);
  pinMode(dt, INPUT);
  pinMode(sck, INPUT);
  pinMode(rs, OUTPUT);
  pinMode(en, OUTPUT);
  pinMode(d4, OUTPUT);
  pinMode(d5, OUTPUT);
  pinMode(d6, OUTPUT);
  pinMode(d7, OUTPUT);
  for (int i = 0; i < 6; i++) {
    pinMode(botones[i], INPUT);
  }

  // Inicializar LCD
  lcd.begin(16, 2);
  lcd.setCursor(0, 0);
  lcd.print("Bienvenido");

  // Leer datos de EEPROM
  EEPROM.get(0, hora);
  EEPROM.get(4, peso);
}

void loop() {
  // Leer estado de botones
  botonActual = leerBotones();

  // Procesar estado de botones
  if (botonActual != botonAnterior) {
    switch (botonActual) {
      case 1:
        // Botón 1: seleccionar hora
        lcd.setCursor(0, 0);
        lcd.print("Hora: ");
        lcd.setCursor(5, 0);
        lcd.print(hora);
        lcd.setCursor(0, 1);
        lcd.print("Presione botón 2");
        break;
      case 2:
        // Botón 2: seleccionar peso
        lcd.setCursor(0, 0);
        lcd.print("Peso: ");
        lcd.setCursor(5, 0);
        lcd.print(peso);
        lcd.setCursor(0, 1);
        lcd.print("Presione botón 3");
        break;
      case 3:
        // Botón 3: guardar cambios
        EEPROM.put(0, hora);
        EEPROM.put(4, peso);
        lcd.setCursor(0, 0);
        lcd.print("Cambios guardados");
        lcd.setCursor(0, 1);
        lcd.print("Presione botón 4");
        break;
      case 4:
        // Botón 4: verificar horario
        if (hora == 0) {
          lcd.setCursor(0, 0);
          lcd.print("Horario no seleccionado");
        } else {
          lcd.setCursor(0, 0);
          lcd.print("Horario seleccionado");
          lcd.setCursor(0, 1);
          lcd.print("Presione botón 5");
        }
        break;
      case 5:
        // Botón 5: verificar peso
        if (peso == 0) {
          lcd.setCursor(0, 0);
          lcd.print("Peso no seleccionado");
        } else {
          lcd.setCursor(0, 0);
          lcd.print("Peso seleccionado");
          lcd.setCursor(0, 1);
          lcd.print("Presione botón 6");
        }
        break;
      case 6:
        // Botón 6: iniciar proceso
        lcd.setCursor(0, 0);
        lcd.print("Proceso iniciado");
        lcd.setCursor(0, 1);
        lcd.print("Esperando a la hora");
        delay(1000);
        if (hora == 0) {
          lcd.setCursor(0, 0);
          lcd.print("Horario no seleccionado");
        } else {
          lcd.setCursor(0, 0);
          lcd.print("Horario seleccionado");
          lcd.setCursor(0, 1);
          lcd.print("Esperando a la hora");
          delay(1000);
          while (hora != 0) {
            delay(1000);
            hora--;
          }
          lcd.setCursor(0, 0);
          lcd.print("Hora seleccionada");
          lcd.setCursor(0, 1);
          lcd.print("Iniciando proceso");
          delay(1000);
          while (peso != 0) {
            delay(1000);
            peso--;
          }
          lcd.setCursor(0, 0);
          lcd.print("Peso seleccionado");
          lcd.setCursor(0, 1);
          lcd.print("Proceso finalizado");
          delay(1000);
          digitalWrite(gate, HIGH);
          delay(1000);
          digitalWrite(gate, LOW);
        }
        break;
    }
    botonAnterior = botonActual;
  }

  // Leer datos del HX711
  int pesoActual = leerPeso();

  // Verificar si el peso objetivo ha sido alcanzado
  if (pesoActual >= peso) {
    digitalWrite(gate, LOW);
  } else {
    digitalWrite(gate, HIGH);
  }
}

int leerBotones() {
  int botonActual = 0;
  for (int i = 0; i < 6; i++) {
    if (digitalRead(botones[i]) == HIGH) {
      botonActual = i + 1;
      break;
    }
  }
  return botonActual;
}

int leerPeso() {
  int pesoActual = 0;
  for (int i = 0; i < 10; i++) {
    digitalWrite(sck, HIGH);
    delayMicroseconds(1);
    int valor = digitalRead(dt);
    digitalWrite(sck, LOW);
    delayMicroseconds(1);
    pesoActual = (pesoActual << 1) | valor;
  }
  return pesoActual;
}
```
Este código utiliza la biblioteca `LiquidCrystal` para controlar la pantalla LCD y la biblioteca `EEPROM` para leer y escribir datos en la memoria EEPROM del Arduino. También utiliza la biblioteca `Wire` para leer datos del HX711.

El código define un menú con seis opciones que se pueden seleccionar mediante los botones. La opción 1 permite seleccionar la hora, la opción 2 permite seleccionar el peso objetivo, la opción 3 permite guardar los cambios, la opción 4 verifica si el horario ha sido seleccionado, la opción 5 verifica si el peso objetivo ha sido seleccionado y la opción 6 inicia el proceso de alimentación del motor.

El código también define una función `leerBotones()` que lee el estado de los botones y devuelve el número del botón que ha sido presionado. La función `leerPeso()` lee el peso actual del HX711 y devuelve el valor en gramos.

Finalmente, el código utiliza un bucle `while` para verificar si el peso objetivo ha sido alcanzado y, si es así, detiene el motor.