Creality Ender 3 | Guía Completa de Configuración

Configuración de la Raspberry Pi

Ve a la web oficial de Raspberry Pi y descarga Raspbian Stretch with Desktop si quieres la versión con escritorio o Raspbian Stretch Lite si la quieres sin escritorio. Recomiendo Raspbian Stretch with Desktop.

Después de la descarga, extrae el .zip y obtendrás un .img.

Descarga SD Memory Card Formatter 5.0 for SD/SDHC/SDXC compatible con MacOS y Windows. Úsalo para formatear tu tarjeta SD y evitar problemas al instalar Raspbian.

Descarga Etcher compatible con MacOS, Linux y Windows. Úsalo para instalar la imagen de Raspbian en la SD.

Configurar SSH (Headless)

Crea un archivo en la raíz de la SD, en la partición boot, llamado SSH sin extensión.

Acceder a la Raspberry Pi por SSH

macOS o Linux

Abre terminal y escribe:

ssh pi@IPDERASPBERRYPI

La contraseña por defecto es raspberry y listo.

Windows

Descarga PuTTY, introduce la IP de la Raspberry Pi, el usuario por defecto es pi y la contraseña raspberry.

Configurar Wi-Fi (Headless)

Crea un archivo en la raíz de la SD, en la partición boot, llamado wpa_supplicant.conf con una de las siguientes opciones:

Si tu red tiene contraseña

country=ES
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="TU_SSID"
    psk="TU_CONTRASEÑA"
}

Si tu red no tiene contraseña

network={
    ssid="TU_SSID"
    key_mgmt=NONE
}

Si tu red está oculta

network={
    ssid="TU_SSID_OCULTA"
    scan_ssid=1
    psk="TU_CONTRASEÑA"
}

Fuente: desertbot.io

VNC (Virtual Network Computing)

Accede por SSH

sudo raspi-config

Ve a Interfacing Options y selecciona VNC en Yes.

El usuario y contraseña para el escritorio remoto son los mismos que para iniciar sesión en la Raspberry Pi: usuario: pi y contraseña: raspberry Para cambiar la contraseña de VNC desde terminal:

vncpasswd

Para acceso remoto descarga VNC Connect.

Fuente: raspberrypi.org

Instalar Octoprint en Raspberry Pi 3 B+ con Pi Camera

Configuración básica

Para el paquete básico necesitarás Python 2.7 (debería estar instalado por defecto) y pip. Las dependencias de OctoPrint se instalarán con pip:

cd ~
sudo apt update
sudo apt install python-pip python-dev python-setuptools python-virtualenv git libyaml-dev build-essential
mkdir OctoPrint && cd OctoPrint
virtualenv venv
source venv/bin/activate
pip install pip --upgrade
pip install https://get.octoprint.org/latest

Puede que necesites añadir el usuario pi al grupo dialout y tty para que pueda acceder a los puertos serie:

sudo usermod -a -G tty pi
sudo usermod -a -G dialout pi

Deberías poder iniciar el servidor de OctoPrint:

~/OctoPrint/venv/bin/octoprint serve

Estará corriendo en http://0.0.0.0:5000/

Soporte para reinicio/apagado desde el menú de OctoPrint

Mientras Octoprint está en ejecución, ve a Settings > Commands y configura los siguientes comandos:

• Reiniciar OctoPrint: sudo service octoprint restart
• Reiniciar sistema: sudo shutdown -r now
• Apagar sistema: sudo shutdown -h now

Inicio automático

Descarga los archivos de script de inicio desde el repositorio de OctoPrint, muévelos a sus carpetas respectivas y haz ejecutable el script de inicio:

wget https://github.com/foosel/OctoPrint/raw/master/scripts/octoprint.init && sudo mv octoprint.init /etc/init.d/octoprint
wget https://github.com/foosel/OctoPrint/raw/master/scripts/octoprint.default && sudo mv octoprint.default /etc/default/octoprint
sudo chmod +x /etc/init.d/octoprint

Ajusta las rutas a tu binario de octoprint en /etc/default/octoprint. Si lo configuraste en un virtualenv como arriba, asegúrate de que tu /etc/default/octoprint esté así:

DAEMON=/home/pi/OctoPrint/venv/bin/octoprint

Luego añade el script al inicio automático con sudo update-rc.d octoprint defaults. Esto también te permitirá iniciar/detener/reiniciar el demonio de OctoPrint con:

sudo service octoprint {start|stop|restart}

Hacer todo accesible en el puerto 80 (HAProxy)

Si quieres tener URLs más limpias o necesitas que OctoPrint corra en el puerto 80 (por restricciones de red), recomiendo usar HAProxy como proxy inverso en vez de configurar OctoPrint en el puerto 80. Esto tiene ventajas como:

• OctoPrint no necesita correr como root para usar el puerto 80
• Puedes hacer accesible mjpg-streamer también en el puerto 80
• Puedes añadir autenticación a OctoPrint
• Dependiendo de la versión de HAProxy puedes usar SSL

Instala HAProxy en Raspbian:

sudo apt install haproxy

Luego edita el archivo /etc/haproxy/haproxy.cfg:

sudo nano /etc/haproxy/haproxy.cfg

global
        maxconn 4096
        user haproxy
        group haproxy
        daemon
        log 127.0.0.1 local0 debug

defaults
        log     global
        mode    http
        option  httplog
        option  dontlognull
        retries 3
        option redispatch
        option http-server-close
        option forwardfor
        maxconn 2000
        timeout connect 5s
        timeout client  15min
        timeout server  15min

frontend public
        bind :::80 v4v6
        use_backend webcam if { path_beg /webcam/ }
        default_backend octoprint

backend octoprint
        reqrep ^([^\ :]*)\ /(.*)     \1\ /\2
        option forwardfor
        server octoprint1 127.0.0.1:5000

backend webcam
        reqrep ^([^\ :]*)\ /webcam/(.*)     \1\ /\2
        server webcam1  127.0.0.1:8080

Esto hará que OctoPrint sea accesible en http://<la IP de tu Raspi>/ y mjpg-streamer en http://<la IP de tu Raspi>/webcam/. También tendrás que modificar /etc/default/haproxy:

sudo nano /etc/default/haproxy

Activa HAProxy añadiendo la siguiente línea:

ENABLED=1

Después puedes iniciar HAProxy con:

sudo service haproxy start

Abre tu navegador en http://<la IP de tu Raspi> y deberías ver la interfaz de OctoPrint. Ahora abre los ajustes y cambia la pestaña de webcam o edita ~/.octoprint/config.yaml. Cambia la URL del stream de la webcam de http://<la IP de tu Raspi>:8080/?action=stream a /webcam/?action=stream (deja el snapshotUrl en http://127.0.0.1:8080/?action=snapshot!) y recarga la página.

Si todo funciona, puedes añadir las siguientes líneas a ~/.octoprint/config.yaml para que el servidor solo escuche en la interfaz de loopback:

server:
  host: 127.0.0.1

Reinicia el servidor. OctoPrint debería seguir disponible en el puerto 80, incluyendo el stream de la webcam (si está habilitado).

Acceso a OctoPrint desde Internet (HAProxy)

Muchos quieren usar OctoPrint fuera de su red local (por ejemplo, desde el móvil con datos). Esto es posible, pero primero lee estas advertencias:

• Debes configurar el router al que está conectada tu Raspberry Pi
• No se recomienda hacer OctoPrint accesible desde Internet si no tienes al menos un proxy inverso con autenticación básica

Algunas explicaciones

Aquí tienes un diagrama de la situación en tu red local:

El móvil se conecta localmente al servidor (usando la IP LAN)

1. Tu dispositivo (la Raspberry Pi) tiene una IP local en tu red, por ejemplo 192.168.1.20. Esta IP solo identifica tu dispositivo en la red local. Cada dispositivo tiene sus propios puertos (por ejemplo, puerto 80, 22, 21, 5000…)
2. Tus dispositivos no son accesibles desde Internet por su IP local, solo el router los conoce.
3. El router tiene una IP pública (WAN), por ejemplo 82.24.543.539
4. El router también tiene sus propios puertos públicos (80, 21, 22…). Estos puertos no corresponden a los de tus dispositivos, sino al router.
5. Si quieres acceder a la Raspberry Pi desde Internet, tienes que pedirle al router acceso a ese dispositivo. Por ejemplo: “Hola router, dame acceso al dispositivo 192.168.1.20 en su puerto 80”.
6. Para eso, debes configurar un reenvío de puertos (port forwarding). Asigna un puerto público (por ejemplo 1990) al dispositivo 192.168.1.20 en su puerto 80. Así, cuando accedas a la IP pública del router y el puerto 1990, el router redirigirá al puerto 80 de la Raspberry Pi.

Eso significa:

• Llamar a 82.24.543.539:1990 desde Internet…
• …es lo mismo que llamar a 192.168.1.20:80 desde la red local

Al final, tu móvil se conectará remotamente al servidor usando la IP WAN y el puerto público.

Encuentra tu IP pública (WAN)

No puedes usar la IP local de la Raspberry Pi desde fuera de tu red. Debes usar la IP pública de tu router. Puedes verla en What is my IP conectado a tu red local.

Habilita autenticación básica

Por seguridad, instala un proxy inverso con autenticación básica en la Raspberry Pi y configúralo para proteger OctoPrint.

La autenticación básica del proxy es diferente a la de la interfaz web de OctoPrint. Esta protegerá cada petición con usuario y contraseña.

Instala HAProxy:

sudo apt-get install haproxy.

Configura autenticación básica en /etc/haproxy/haproxy.cfg:

sudo nano /etc/haproxy/haproxy.cfg

global
        maxconn 4096
        user haproxy
        group haproxy
        daemon
        log 127.0.0.1 local0 debug

defaults
        log     global
        mode    http
        option  httplog
        option  dontlognull
        retries 3
        option redispatch
        option http-server-close
        option forwardfor
        maxconn 2000
        timeout connect 5s
        timeout client  15min
        timeout server  15min

frontend public
        bind :::80 v4v6
        use_backend webcam if { path_beg /webcam/ }

### Solo el acceso remoto protegido ###
        use_backend octoprint_unsecure if { hdr_beg(host) -i 192.168 }
###

        default_backend octoprint

backend octoprint
        reqrep ^([^\ :]*)\ /(.*)     \1\ /\2
        option forwardfor
        server octoprint1 127.0.0.1:5000
        acl AuthOkay http_auth(L1)
        http-request auth realm octoprint if !AuthOkay

backend webcam
        reqrep ^([^\ :]*)\ /webcam/(.*)     \1\ /\2
        server webcam1  127.0.0.1:8080

### Solo el acceso remoto protegido ###
backend octoprint_unsecure
        reqrep ^([^\ :]*)\ /(.*) \1\ /\2
        option forwardfor
        server octoprint1 127.0.0.1:5000
        acl needs_scheme req.hdr_cnt(X-Scheme) eq 0
        reqadd X-Scheme:\ https if needs_scheme { ssl_fc }
        reqadd X-Scheme:\ http if needs_scheme !{ ssl_fc }
###

userlist L1
        group G1
        user USUARIO insecure-password CONTRASEÑA groups G1

Redirige el puerto público en tu router

Una vez que conozcas tu IP pública (WAN) y el acceso a tu servidor esté al menos protegido por autenticación básica, puedes hacer accesibles tus instancias de OctoPrint y mjpeg-streamer desde Internet.

No puedo ser más preciso en la siguiente información ya que esta configuración depende únicamente del modelo de tu router.

La siguiente información es muy importante. Debes seguirla en el orden indicado o no funcionará como se espera.

• Encuentra cómo acceder a la interfaz web de tu router. En general, la mayoría de los fabricantes permiten acceder desde la IP 192.168.1.1
• Inicia sesión en la interfaz (normalmente admin/admin o admin/los primeros caracteres de la clave WPA por defecto)
• Encuentra la IP local de tu Raspberry Pi en los dispositivos conectados y asígnala como IP estática (reserva DHCP)
• Luego, busca la página de configuración de “port forwarding” (también llamada NAT/PAT en algunos routers, normalmente en ajustes avanzados)
• En esta pantalla, añade una nueva opción de reenvío de puertos:

En el diagrama 2 al inicio de esta página, puedes ver que:

• El valor externo de puerto 1990 fue elegido (es solo un ejemplo, puedes elegir otro)
• El servidor OctoPrint sigue siendo accesible localmente por el puerto 5000 (además del 80 si has instalado HAProxy)
• El servidor MJPEG (streaming de vídeo) sigue siendo accesible localmente por el puerto 8080 (además del 80 si has instalado HAProxy)
• En resumen, ambos servidores (OctoPrint y MJPEG) son accesibles localmente por el puerto 80 (si has instalado HAProxy), pero ahora también externamente por el puerto 1990.

Ejemplo:

Otro ejemplo: Algunos routers permiten definir rangos de puertos. Si solo quieres reenviar un puerto público a uno local, aplica lo siguiente:

Proteger solo el acceso remoto con autenticación básica (Opcional)

Ten en cuenta que este paso es:

• Opcional. No lo sigas si no lo necesitas.
• Solo para usuarios avanzados.
• Solo para quienes han instalado plugins que no soportan autenticación básica en LAN.

El objetivo principal es solicitar autenticación solo cuando OctoPrint se accede desde Internet, y no cuando se accede localmente.

No copiaré todo el archivo haproxy.cfg de nuevo, solo tienes que aplicar los cambios indicados:

frontend public
        bind :::80 v4v6
        use_backend webcam if { path_beg /webcam/ }

### Solo el acceso remoto protegido ###
        use_backend octoprint_unsecure if { hdr_beg(host) -i 192.168 }
###

        default_backend octoprint

backend octoprint
        reqrep ^([^\ :]*)\ /(.*)     \1\ /\2
        option forwardfor
        server octoprint1 127.0.0.1:5000
        acl AuthOkay http_auth(L1)
        http-request auth realm octoprint if !AuthOkay

backend webcam
        reqrep ^([^\ :]*)\ /webcam/(.*)     \1\ /\2
        server webcam1  127.0.0.1:8080

### Solo el acceso remoto protegido ###
backend octoprint_unsecure
        reqrep ^([^\ :]*)\ /(.*) \1\ /\2
        option forwardfor
        server octoprint1 127.0.0.1:5000
        acl needs_scheme req.hdr_cnt(X-Scheme) eq 0
        reqadd X-Scheme:\ https if needs_scheme { ssl_fc }
        reqadd X-Scheme:\ http if needs_scheme !{ ssl_fc }
###

userlist L1
        group G1
        user USUARIO insecure-password CONTRASEÑA groups G1

Fuente: Printoid

Pi Camera

Si también quieres soporte de webcam y timelapse, tendrás que descargar y compilar MJPG-Streamer:

cd ~
sudo apt install subversion libjpeg62-turbo-dev imagemagick ffmpeg libv4l-dev cmake
git clone https://github.com/jacksonliam/mjpg-streamer.git
cd mjpg-streamer/mjpg-streamer-experimental
export LD_LIBRARY_PATH=.
make

Esto debería compilar sin errores. Ahora deberías poder iniciar el servidor de la webcam usando:

./mjpg_streamer -i "./input_raspicam.so -fps 5" -o "./output_http.so"

Esto debería mostrar algo como:

MJPG Streamer Version: git rev: f387bb44e6c087271b763b27da998bf2e06c4f5d
 i: fps.............: 5
 i: resolution........: 640 x 480
 i: camera parameters..............:

Sharpness 0, Contrast 0, Brightness 50
Saturation 0, ISO 0, Video Stabilisation No, Exposure compensation 0
Exposure Mode 'auto', AWB Mode 'auto', Image Effect 'none'
Metering Mode 'average', Colour Effect Enabled No with U = 128, V = 128
Rotation 0, hflip No, vflip No
ROI x 0.000000, y 0.000000, w 1.000000 h 1.000000
 o: www-folder-path......: disabled
 o: HTTP TCP port........: 8080
 o: HTTP Listen Address..: (null)
 o: username:password....: disabled
 o: commands.............: enabled

Si ahora abres tu navegador en http://<la IP de tu Raspi>:8080/?action=stream, deberías ver una imagen en movimiento a 5fps.

Abre los ajustes de OctoPrint y en Webcam & Timelapse configura lo siguiente:

• URL del stream: /webcam/?action=stream
• URL del snapshot: http://127.0.0.1:8080/?action=snapshot
• Ruta a FFMPEG: /usr/bin/ffmpeg

Reinicia el servidor de OctoPrint, limpia la caché de tu navegador y recarga la página de OctoPrint. Ahora deberías ver el stream de la webcam en la pestaña Control y una pestaña Timelapse con opciones.

Si quieres poder iniciar y detener mjpeg-streamer desde OctoPrint, crea una carpeta y un script llamado webcam:

mkdir /home/pi/scripts/
sudo nano /home/pi/scripts/webcam

Pon lo siguiente en /home/pi/scripts/webcam:

#!/bin/bash
# Iniciar / detener el demonio del streamer

case "$1" in
    start)
        /home/pi/scripts/webcamDaemon >/dev/null 2>&1 &
        echo "$0: started"
        ;;
    stop)
        pkill -x webcamDaemon
        pkill -x mjpg_streamer
        echo "$0: stopped"
        ;;
    *)
        echo "Uso: $0 {start|stop}" >&2
        ;;
esac

Crea otro script llamado webcamDaemon:

sudo nano /home/pi/scripts/webcamDaemon

Pon lo siguiente en /home/pi/scripts/webcamDaemon:

#!/bin/bash

MJPGSTREAMER_HOME=/home/pi/mjpg-streamer/mjpg-streamer-experimental
MJPGSTREAMER_INPUT_USB="input_uvc.so"
MJPGSTREAMER_INPUT_RASPICAM="input_raspicam.so"

# configuración inicial
camera="auto"
camera_usb_options="-r 640x480 -f 10"
camera_raspi_options="-fps 10"

if [ -e "/boot/octopi.txt" ]; then
    source "/boot/octopi.txt"
fi

# ejecuta MJPG Streamer, usando el plugin de entrada y configuración proporcionados
function runMjpgStreamer {
    input=$1
    pushd $MJPGSTREAMER_HOME
    echo Ejecutando ./mjpg_streamer -o "output_http.so -w ./www" -i "$input"
    LD_LIBRARY_PATH=. ./mjpg_streamer -o "output_http.so -w ./www" -i "$input"
    popd
}

# inicia la RasPiCam
function startRaspi {
    logger "Iniciando cámara Raspberry Pi"
    runMjpgStreamer "$MJPGSTREAMER_INPUT_RASPICAM $camera_raspi_options"
}

# inicia la webcam USB
function startUsb {
    logger "Iniciando webcam USB"
    runMjpgStreamer "$MJPGSTREAMER_INPUT_USB $camera_usb_options"
}

# esto previene que las llamadas posteriores a vcgencmd se bloqueen
vcgencmd version

# muestra configuración
echo camera: $camera
echo usb options: $camera_usb_options
echo raspi options: $camera_raspi_options

# mantiene mjpg streamer corriendo si hay alguna cámara conectada
while true; do
    if [ -e "/dev/video0" ] && { [ "$camera" = "auto" ] || [ "$camera" = "usb" ] ; }; then
        startUsb
    elif [ "`vcgencmd get_camera`" = "supported=1 detected=1" ] && { [ "$camera" = "auto" ] || [ "$camera" = "raspi" ] ; }; then
        startRaspi
    fi

    sleep 120
done

Asegúrate de que ambos archivos sean ejecutables:

sudo chmod +x /home/pi/scripts/webcam
sudo chmod +x /home/pi/scripts/webcamDaemon

Si quieres que la webcam se inicie automáticamente, añade la siguiente línea a /etc/rc.local

sh /home/pi/scripts/webcam start

Si quieres poder iniciar y detener el servidor de la webcam desde el menú de sistema de OctoPrint, haz lo siguiente:

sudo nano ~/.octoprint/config.yaml

Añade lo siguiente a config.yaml:

system:
  actions:
    - action: streamon
      command: /home/pi/scripts/webcam start
      confirm: false
      name: Iniciar stream de vídeo
    - action: streamoff
      command: /home/pi/scripts/webcam stop
      confirm: false
      name: Detener stream de vídeo

Fuente: Discourse

Cómo solucionar desconexiones de Wi-Fi en Raspberry Pi 3, B, B+ o Pi Zero W

Comprueba el estado de la Gestión de Energía:

sudo iwconfig wlan0

Si ves Power Management: on y quieres desactivarlo en cada arranque, edita:

sudo nano /etc/rc.local

Añade esta línea:

iwconfig wlan0 power off

Tras reiniciar, comprueba si Power Management: off:

sudo iwconfig wlan0

Y debería aparecer Power Management: off

Fuente: Thelowercasew

Mejores plugins de Octoprint (En desarrollo)

PSU Control

PSU Control

Fuentes:

Instructables

Youtube

Navbar Temp

Navbar Temp

Telegram Bot

Telegram Bot

Bed Level Visualizer

Bed Level Visualizer

Detailed Progress

Detailed Progress

Mejores apps para Octoprint

Printoid

Si usas Android te recomiendo Printoid, puedes obtener más info aquí

OctoClient

Si usas iOS te recomiendo OctoClient, puedes obtener más info aquí

Mods para la Ender 3 (En desarrollo)

Errores típicos (En desarrollo)

EEPROM CRC mismatch - (stored) X != X (calculated)!

El firmware de tu impresora ha reportado un error. Por ello OctoPrint se desconectará. Error reportado: EEPROM CRC mismatch - (stored) 36054 != 4410 (calculated)!

Si te aparece este error al intentar conectar tu impresora vía Octoprint y se desconecta:

1. Ve a Settings > Serial connection > Behaviour.
2. En Error Handing haz clic en Ignore Warning.
3. Ahora podrás conectar tu impresora.
4. Ve a Terminal y escribe M502 y envíalo.
5. Escríbelo en la EEPROM con M500 y envíalo.
6. Vuelve a poner Error Handing en su estado anterior, en mi caso Disconnect from the printer.

Fuente: Robo3d

Calibrar eSteps (Steps per millimeter)

Si tu primera capa no tiene suficiente flujo, necesitas calibrar tus eSteps

Fuente: Youtube

¿Dónde comprar?

Ender 3 (Enlaces USA)

Ender 3 Pro (Enlaces USA)