Configurar archivo .ini y .hal (PID) para usar librería MAX31855 con gmoccapy_lcd7

Para continuar con este tutorial se debe haber creado los arhivos de los siguientes tutoriales:

GUI Temperatura.
Librería MAX31855.
Componente HAL MAX31855.

Configuración archivo .ini

En el archivo .ini se pondrá la Gui de temperatura y el archivo postguihal necesarios para leer la temperatura y realizar las conexiones.

[DISPLAY]

# Name of display program, e.g., tkemc
#DISPLAY =               tkemc
#DISPLAY =              axis
DISPLAY =              gmoccapy_lcd7


#EMBED_TAB_NAME = right_side_panel
#EMBED_TAB_LOCATION = box_right
#EMBED_TAB_COMMAND = gladevcp -x {XID} ReadTemp.glade

EMBED_TAB_NAME = Temperatura
EMBED_TAB_LOCATION = ntb_user_tabs
EMBED_TAB_COMMAND = gladevcp -x {XID} ReadTemp.glade

En este caso se visualizará la temperatura en las pestañas de gmoccapy.

[HAL]

# The run script first uses halcmd to execute any HALFILE
# files, and then to execute any individual HALCMD commands.

# list of hal config files to run through halcmd
# files are executed in the order in which they appear

HALFILE =  MF5-Dual-Extrusion.hal
#HALFILE =   joypad.hal
HALUI = halui

POSTGUI_HALFILE =       3D.postgui.hal

Se cargan los archivos .hal que se utilizarán, joypad y halui son para poder controlar machinekit con un mando de juegos en mi caso con el control del Xbox 360. Se realizará esta configuración en tutoriales posteriores.

Configuración Archivo .hal

En el archivo .hal se debe aumentar y modificar algunas líneas.

En este caso se va a leer dos extrusores (termocuplas) con el amplificador MAX31855 y se usará el módulo de PID para controlar la temperatura.

loadrt pid count=3
loadrt limit1 count=3
loadusr -Wn Extruder0 hal_temp_max31855 -n Extruder0 -b SPI0 -num 1 -i 0.3 
loadusr -Wn Extruder1 hal_temp_max31855 -n Extruder1 -b SPI0 -num 2 -i 0.3

 
Se añade el pid al servo-thread

addf pid.0.do-pid-calcs                   servo-thread
addf pid.1.do-pid-calcs                   servo-thread
addf pid.2.do-pid-calcs                   servo-thread
addf limit1.0                             servo-thread
addf limit1.1                             servo-thread
addf limit1.2                             servo-thread

 
Se crean nuevas señales que controlarán los extrusores y cama caliente.

newsig e0.temp.set   float
newsig e0.temp.meas  float
newsig bed.temp.set  float
newsig bed.temp.meas float
newsig e1.temp.set   float
newsig e1.temp.meas  float

Se da una frecuencia para generar las señales PWM, en este caso de 1khz.

1000000ns -> 0.001s.

1/0.001 = 1khz

setp hpg.pwmgen.00.pwm_period       1000000

Se define los GPIO que van a generar las señales PWM.

# P9.26 gpio0_14 Extrusor 1
setp hpg.pwmgen.00.out.01.pin       0x2E
setp hpg.pwmgen.00.out.01.enable    1
setp hpg.pwmgen.00.out.01.value     0.0

# J9.16 gpio1_19 Bed
#setp hpg.pwmgen.00.out.00.pin       0x53
#setp hpg.pwmgen.00.out.00.enable    1
#setp hpg.pwmgen.00.out.00.value     0.0

# P9.15 gpio1_16 Extrusor 0
setp hpg.pwmgen.00.out.02.pin       0x50
setp hpg.pwmgen.00.out.02.enable    1
setp hpg.pwmgen.00.out.02.value     0.0

Por útlimo se unen las señales con los componentes.

# PID for Extruder 0 temperature control
net e0.temp.meas    <= Extruder0.Temp.meas
net e0.temp.meas    => pid.0.feedback

sets e0.temp.set  0
net e0.temp.set motion.analog-out-02    => pid.0.command

net e0.temp.set => Extruder0.Temp.set
net e0.done motion.digital-in-02 <= Extruder0.Temp.set.done

net e0.heater  <= pid.0.output
net e0.heater  => limit1.0.in
net e0.heaterl <= limit1.0.out
net e0.heaterl => hpg.pwmgen.00.out.02.value

# Limit heater PWM to positive values
# PWM mimics hm2 implementation, which generates output for negative values
setp limit1.0.min 0

# PID for Extruder 1 temperature control
net e1.temp.meas    <= Extruder1.Temp.meas
net e1.temp.meas    => pid.1.feedback

sets e1.temp.set  0
net e1.temp.set motion.analog-out-01   => pid.1.command

net e1.temp.set => Extruder1.Temp.set
net e1.done motion.digital-in-01 <= Extruder1.Temp.set.done

net e1.heater  <= pid.1.output
net e1.heater  => limit1.2.in
net e1.heaterl <= limit1.2.out
net e1.heaterl => hpg.pwmgen.00.out.01.value


# Limit heater PWM to positive values
# PWM mimics hm2 implementation, which generates output for negative values
setp limit1.2.min 0

# PID for Bed temperature control
#net bed.temp.meas    <= Temp.Temperatura
#net bed.temp.meas    => pid.2.feedback

#sets bed.temp.set  0
#net bed.temp.set     => pid.2.command

#net bed.heater  <= pid.2.output
#net bed.heater  => limit1.2.in
#net bed.heaterl <= limit1.2.out
#net bed.heaterl => hpg.pwmgen.00.out.00.value


# Limit heater PWM to positive values
# PWM mimics hm2 implementation, which generates output for negative values
setp limit1.1.min 0

# PID Parameters for adjusting temperature control
# Extruder0
#setp pid.0.FF0      0
#setp pid.0.FF1      0
#setp pid.0.FF2      0
setp pid.0.Pgain  0.366693
setp pid.0.Igain  0.00001
setp pid.0.Dgain  0.9375
setp pid.0.maxerror 0.0
setp pid.0.bias    0.5
setp pid.0.enable   1

# Extruder1
#setp pid.1.FF0      0
#setp pid.1.FF1      0
#setp pid.1.FF2      0
setp pid.1.Pgain  0.366693
setp pid.1.Igain  0.00001
setp pid.1.Dgain  0.9375
setp pid.1.maxerror 0.0
setp pid.1.bias    0.5
setp pid.1.enable   1

# Bed
#setp pid.2.FF0      0
#setp pid.2.FF1      0
#setp pid.2.FF2      0
#setp pid.2.Pgain  1
#setp pid.2.Igain  0.0
#setp pid.2.Dgain  0.0
#setp pid.2.maxerrorI 1.0
#setp pid.2.bias    0.5
#setp pid.2.enable   1

Archivo Postgui  .hal.

# Include your customized HAL commands here
# Run on Gmoccapy with gladevcp panel 

net e0.temp.set  => ReadTemp.Extruder_Hal_lbl
net e0.temp.meas => ReadTemp.E0_Temp
net bed.temp.set  => ReadTemp.Bed_Hal_lbl
net bed.temp.meas => ReadTemp.Bed_Temp
net e1.temp.set  => ReadTemp.Extruder1_Hal_lbl
net e1.temp.meas => ReadTemp.E1_Temp

El siguiente esquematico se basa en el diseño de Adafruit para los MAX31855 y de CRAMPS para la conexión de los Fusores (Extrusores). A continuación dejo los links para los que deseen descargar los esquemáticos.

Adafruit MAX31855
CRAMPS

En el siguiente gif se muestra la lectura de temperatura usando el amplificador MAX31855 con termocuplas tipo K. Se calienta el primer extrusor y luego el segundo extrusor.

Crear componente hal usando la librería MAX31855

Para poder seguir con este tutorial se recomienda leer Librería MAX31855.

El siguiente tutorial explica como crear componentes para poder cargarlos en la configuración .hal.

Crear archivo.

nano hal_temp_max31855

#!/usr/bin/python
# encoding: utf-8
"""
Temperature.py
Created by Leonardo Noguera on 2015-12-19.
"""

from drivers.MAX31855 import MAX31855

import argparse
import time
import sys

import hal        
        

def parseHandleDevice(spi_bus):
    if spi_bus != 'SPI0' and spi_bus != 'SPI1':
        print(("wrong SPI"))
        sys.exit(1)
    if spi_bus == 'SPI0':
        bus = MAX31855.SPI0
    else:
        bus = MAX31855.SPI1
    return bus

parser = argparse.ArgumentParser(description='HAL component to read MAX31855 Temperature values')
parser.add_argument('-n', '--name', help='HAL component name', required=True)
parser.add_argument('-b', '--spi_bus', help='SPI bus id', default="SPI1")
parser.add_argument('-num', '--num_devices', help='Max 2 MAX31855', default=1)
parser.add_argument('-i', '--interval', help='SPI update interval', default=0.3)
parser.add_argument('-d', '--delay', help='Delay before the SPI should be updated', default=0.0)
args = parser.parse_args()

updateInterval = float(args.interval)
delayInterval = float(args.delay)
error = True
watchdog = True

bus = parseHandleDevice(args.spi_bus)

if (int(args.num_devices) == 1):
    cs = 0
elif (int(args.num_devices) == 2):
    cs = 1
else:
    print("Only two Max31855 are supported")
    sys.exit(1)     

thermocouple = MAX31855(bus=int(bus),spi_cs=int(cs))

# Initialize HAL
h = hal.component(args.name)
halThermocouple = h.newpin("Temp.meas", hal.HAL_FLOAT, hal.HAL_OUT)
halTemperatureSet =  h.newpin("Temp.set", hal.HAL_FLOAT, hal.HAL_IN)
halTempPinActive = h.newpin("Temp.set.done", hal.HAL_BIT, hal.HAL_OUT)
halErrorRead = h.newpin("error", hal.HAL_BIT, hal.HAL_OUT)
halNoErrorRead = h.newpin("no-error", hal.HAL_BIT, hal.HAL_OUT)
halWatchdogRead = h.newpin("watchdog", hal.HAL_BIT, hal.HAL_OUT)
h.ready()

halErrorRead.value = error
halNoErrorRead.value = not error
halWatchdogRead.value = watchdog

try:
    time.sleep(delayInterval)
    while (True):
        try:
            if (error):                
                error = False
              
            temp = thermocouple.readTempC()
            if (temp == None):
                try:
                    # The MAX31855 reported an error, print it:
                    if thermocouple.error == thermocouple.SHORT_TO_GND:
                        print "Thermocouple shorted to GND"
                        

                    elif thermocouple.error == thermocouple.SHORT_TO_VCC:
                        print "Thermocouple shorted to VCC"
                        
                except:
                    if thermocouple.error == thermocouple.OPEN_CIRCUIT:
                        print "Thermocouple not connected"

                    print(("exiting HAL component " + args.name))
                    h.exit()
            else: 
                halThermocouple.value = float("{:0.2f}".format(temp))
            
                if (halThermocouple.value >= halTemperatureSet.value):
                    halTempPinActive.value = 1
                else: halTempPinActive.value = 0
         
        except IOError as e:
            error = True 
            thermocouple.close()
          
        halErrorRead.value = error
        halNoErrorRead.value = not error
        watchdog = not watchdog
        halWatchdogRead.value = watchdog
        time.sleep(updateInterval)

except:
    print(("exiting HAL component " + args.name))
    h.exit()

Lo que hace el siguiente archivo es importar la librería MAX31855, verificar que SPI se quiere usar, por defecto SPI1. Lo que sigue son los argumentos que se pueden usar, siendo obligatorio dar un nombre para el componente.

Usando num = 1 o num = 2, se puede leer un MAX31855 enviando un cero a cs y con una compuerta NOT se obtiene acceso a un segundo MAX31855 mandando un 1 y la compueta NOT convirtiendola en un 0 para que se habilite el segundo MAX31855. Soporta un máximo de 4 MAX31855 usando SPI0 y SPI1. Si se necesitará de más MAX31855 se debería cambiar la librería para que se simule por software la lectura de SPI y habilitar la seleccion del chip (cs) con cualquier GPIO. Ver como ejemplo Adafruit MAX31855.

En el siguiente paso se crea las señales hal que se encargarán de leer la temperatura, adquirir el valor de temperatura proporcionado por "código g" y determinar si la temperatura que se esta leyendo ha sobrepasado la temperatura enviada para seguir con el código G. Esto se explicará en el proximo tutorial al hablar de código G remapeado y uso de PID.

Por último se lee la temperatura y en el caso de no estar conectada la termocupla o este a circuitada GND o VCC se imprimirá lo que retorne, excepto la temperatura que se gaurdará en la variable "halThermocouple.value".

Para entender mejor lo que se ha realizado, se recomienda leer los componentes hal de las librerías de Machinekit. Hal user components.

El código de arriba se lo guardará con el nombre de hal_temp_max31855, luego se le dará permisos de ejecución y finalmente se lo copiará a /usr/bin para poder usarlo con Machinekit.

sudo chmod +x hal_temp_max31855 
sudo cp hal_temp_max31855 /usr/bin

Probar componente hal_temp_max31855.

En mi caso se cargará el componente de la siguiente manera:

loadusr -Wn Extruder0 hal_temp_max31855 -n Extruder0 -b SPI0 -num 1 -i 0.3

Donde loadusr indicá que cargará un componente creado, -Wn se usará para identificar al componente con un nombre, hal_temp_max31855 será el componente que se cargara con -n que es el nombre que se le dará, -b para escoger que se quiere trabajar con SPI0 o SPI1, -num 1 para mandar un cero a cs, -i para dar un tiempo de actualización 300ms.

Como requisito para que funcione es neceserio que se haya Habilitado SPI0 o SPI1 (device tree overlay).

Para probar componentes o archivos se puede usar el ejecutable "halrun" en el terminal

halrun
loadusr -Wn Extruder0 hal_temp_max31855 -n Extruder0 -b SPI0 -num 1 -i 0.3
show pin

Cada vez que se de la orden de show pin se verán los cambios de temperatura.

Librería Max31855 para leer temperatura con termocuplas usando Machinekit

Este tutorial se centra en poder leer la temperatura con el amplificador MAX31855 a través de una termocupla. Lo primero que se necesita es copiar la librería modificada a la carpeta de drivers que maneja Machinekit, donde estan varias librerías para controlar otros dispositivos como el MCP23017, ADS7828,  PCA9685.

En el transcurso de este tutorial se dará una breve explicación de como usar estas librerías dentro del archivo .hal de machinekit para poder expandir los puertos de entradas y salidas en el caso del MCP23017, leer temperatura a través de los 8 canales del ADS7828 y poder generar señales PWM con el PCA9685.

La librería MAX31855 fue obtenida de PyBBIO y una pequeña porción de código de Adafruit se adapto por conflictos que se ha tenido con la librería de serbus originaría de PyBBIO; cambiando Serbus por Spidev.

nano MAX31855.py

 

"""
 MAX31855
 Copyright 2015 - Alexander Hiam <alex@graycat.io>
 A library for PyBBIO to interface with Maxim's MAX31855 thermocouple amplifier.
 MAX31855 is released as part of PyBBIO under its MIT license.
 See PyBBIO/LICENSE.txt
"""

# Copyright (c) 2014 Adafruit Industries
# Author: Tony DiCola
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

import spidev


class MAX31855(object):

  SPI0 = 1
  SPI1 = 2

  OPEN_CIRCUIT   = 1
  SHORT_TO_GND   = 2
  SHORT_TO_VCC   = 4

  def __init__(self, bus, spi_cs=0, offset=0):
    self.spi_bus = spidev.SpiDev()
    self.bus = bus
    self.spi_cs = spi_cs
    self.spi_bus.open(bus,spi_cs)
    self.offset = offset
    self.error = None

  def readTempF(self):
    """ Reads temperature, converts to Fahrenheit and returns, or 
        returns None if error detected. """
    temp = self.readTempC() 
    return temp if not temp else temp * 9.0/5.0 + 32

  def readTempC(self):
    """ Reads and returns the temperature in Celsius, or returns None
        if error detected. """
    value = self.read()
    if value == None: return None
    # Extract 14-bit signed temperature value:
    temp = (value >> 18) & 0x3fff
    # Convert 2's complement:
    if temp >= 2**13: temp -= 2**14 
    return temp*0.25 + self.offset
    
  def readTempInternal(self):
    """ Reads and returns the MAX31855 reference junction temperature 
        in Celsius, or returns None if error detected. """
    value = self.read()
    if value == None: return None
    temp = (value >> 4) & 0xfff
    # Convert 2's complement:
    if temp >= 2**11: temp -= 2**12 
    return temp*0.0625

  def read(self):
    """ Receives and returns full 32-bit map from MAX31855, or sets
        self.error and returns None if fault detected. """
    self.error = None 

    # Configure SPI bus as required by the MAX31855:
    self.spi_bus.mode = 0
    self.spi_bus.max_speed_hz = 5000000
    self.spi_bus.lsbfirst = False
    raw = bytearray(self.spi_bus.readbytes(4))   
        
    value = raw[0] << 24 | raw[1] << 16 | raw[2] << 8 | raw[3] 

    if (value & (1<<16)):
      # Fault bit set, save error code and return None:
      self.error = value & 0b111
      return None

    return value

  def close(self):
    self.spi_bus.close()

En el siguiente tutorial se explicará como se usará la librería MAX31855 con Machinekit, creando un archivo que se usará como componente hal.

Para eso hay que escribir python -v e importar cualquier librería de Machinekit del siguiente link Machinekit Drivers.

python -v
from drivers import MCP23017
#saldrán varias rutas lo que interesa es que ha localizado la carpeta drivers,
#es ahi donde se debe copiar la librería MAX31855.py

sudo cp MAX31855.py /usr/lib/python2.7/dist-packages/drivers

Comprobamos la librería MAX31855.py

python
from drivers import MAX31855

Se ne se obtiene errores se a realizado de forma correcta los pasos. La siguiente parte es crear los archivos DTO para usar SPIDEV.

Para poder usar la librería Spidev se debe exportar el device tree overlay de SPI0 o SPI1, según el que se vaya a usar. En este caso se usará el SPI0 con do como entrada y d1 como salida. Para más información revisar el siguiente link BBB-SPIDEV.

Crear el archivo

nano BB-SPI0-01-00A0.dts

Pegar lo siguiente y guardar ctrl+o

/dts-v1/;
/plugin/;

/ {
    compatible = "ti,beaglebone", "ti,beaglebone-black";

    /* identification */
    part-number = "spi0pinmux";

    fragment@0 {
        target = <&am33xx_pinmux>;
        __overlay__ {
            spi0_pins_s0: spi0_pins_s0 {
                pinctrl-single,pins = <
                  0x150 0x30  /* spi0_sclk, INPUT_PULLUP | MODE0 */
                  0x154 0x30  /* spi0_d0, INPUT_PULLUP | MODE0 */
                  0x158 0x10  /* spi0_d1, OUTPUT_PULLUP | MODE0 */
                  0x15c 0x10  /* spi0_cs0, OUTPUT_PULLUP | MODE0 */
                >;
            };
        };
    };

    fragment@1 {
        target = <&spi0>;
        __overlay__ {
             #address-cells = <1>;
             #size-cells = <0>;

             status = "okay";
             pinctrl-names = "default";
             pinctrl-0 = <&spi0_pins_s0>;

             spidev@0 {
                 spi-max-frequency = <24000000>;
                 reg = <0>;
                 compatible = "spidev";
             };
             spidev@1 {
                 spi-max-frequency = <24000000>;
                 reg = <1>;
                 compatible = "spidev";
             };            
        };
    };
};

spidev@0 permite usar cs (chip select) con 0
spidev@1 permite usar cs (chip select) con 1

Ahora hay que compilar el archivo usando dtc.

dtc -O dtb -o BB-SPI0-01-00A0.dtbo -b 0 -@ BB-SPI0-01-00A0.dts

Si no se ha obtenido ningún error, se procede a copiar el archivo a /lib/firmware

sudo cp BB-SPI0-01-00A0.dtbo /lib/firmware/

Para poder usar SPIDEV hay que habilitar el device tree overlay

sudo su
cd /lib/firmware
echo BB-SPI0-01 > /sys/devices/bone_capemgr.*/slots

Comprobar que se habilito SPI0

cat /sys/devices/bone_capemgr.*/slots
ls /dev/spidev*
ls /sys/bus/spi/devices/

Con el comando cat se obtiene lo siguiente:

 0: 54:PF---
 1: 55:PF---
 2: 56:PF---
 3: 57:PF---
 4: ff:P-O-L Bone-LT-eMMC-2G,00A0,Texas Instrument,BB-BONE-EMMC-2G
 5: ff:P-O-- Bone-Black-HDMI,00A0,Texas Instrument,BB-BONELT-HDMI
 6: ff:P-O-L Bone-Black-HDMIN,00A0,Texas Instrument,BB-BONELT-HDMIN
 7: ff:P-O-L Override Board Name,00A0,Override Manuf,BBB-LCNC-MF5
 8: ff:P-O-L Override Board Name,00A0,Override Manuf,BB-SPI0-01

Usando ls en "/dev/spidev*":

/dev/spidev1.0  /dev/spidev1.1

Usando ls en "ls /sys/bus/spi/devices/":

spi1.0  spi1.1

   
Con lo anterior se verifica que SPI0 se puede usar con cs=0 y cs=1 y se ha cargado correctamente. Si se hubiese cargado SPI1 los valores serían spi2.0 y spi2.1.

El siguiente link facilita la información del dts de SPI0 y SPI1 -> Adafruit Overlays.

Para no repetir el paso anterior cada vez que se reinicia la Beaglebone Black, hay que habilitar SPI a través del script principal de Machinekit. Asi cuando se use Machinekit se exportará de forma automática.

# Make sure required device tree overlay(s) are loaded
for DTBO in BBB-LCNC-MF5 BB-SPI0-01; do

 if grep -q $DTBO $SLOTS ; then
  echo $DTBO overlay found
 else
  echo Loading $DTBO overlay
  sudo -A su -c "echo $DTBO > $SLOTS" || dtbo_err
  sleep 1
 fi
done;

BBB-LCNC-MF5 es mi device tree overlay personalizado para poder ejecutar Machinekit con pantallas LCD. Revisar el siguiente link para poder utilizar mi DTO personalizado BBB-LCNC-MF5.
   
Nota: Otra opción es hacer que reinicie la Beaglebone Black con el SPI que se necesite, revisar el siguiente link DTO LCD7, al final se explica. En futuros tutoriales se explicará como cargar toda la información de los device tree overlays desde una memoria EEPROM para que se configure los GPIO y demás funciones desde el arranque de la BBB.

Gui básica con Glade y Gladevcp integrada a Gmoccapy

Lo primero y bastante importante es saber como funciona la Gui Gmoccapy para lo cuál se debe entender el código de python que contiene todas las instrucciones de funcionamiento y el archivo .glade que integra los componentes de glade y gladevcp con python.

Visitar la wiki de gmoccapy para mas información.

http://wiki.linuxcnc.org/cgi-bin/wiki.pl?Gmoccapy

En los lugares marcados con recuadros de diferentes colores se puede agregar Gui's personalizadas.

- Recuadro color azul es llamado box_left.

- Recuadro color verde es llamado box_custom_1.

- Recuadro color rojo es llamado box_custom_2.

- Recuadro color morada es llamado box_custom_3.

- Recuadro color naranja es llamado box_custom_4.

- Recuadro color marrón es llamado box_right.

Existen otros que se los puede reemplazar como es en el caso de usar gmoccapy  plasma.

- Recuadro de color negro box_coolant_and_spindle, contiene a box_cooling y box_spindle.

- Recuadro de color azul es box_cooling.

- Recuadro de color naranja es box_spindle.

- Recuadro de color rojo es box_vel_info.

Nota: Tool information es reemplazado por Signals y lo que se hace es colocar el archivo glade que se desee reemplazando en frm_tool_info que es una parte de todo el box_tool_and_code_info (Tool information, Gcode y Program).

Las dos siguientes es para agredar pestañas ya sea en la pantalla donde se visualiza el código G (ntb_preview) o en donde se puede visualizar en modo completo (ntb_user_tabs).

Nota: Para poder entender de mejor manera se recomienda ver la configuración de los archivos .ini de gmoccapy.


La interfáz que se creará es para poder leer la temperatura de una impresora 3D reemplazando esta Gui con la antigua 3D.Temps.panel.xml (pyvcp) usada en la Interfáz gráfica de Axis en CRAMPS.

Correr Glade (Instalación)

glade-3

Primero se guardará con el nombre ReadTemp.glade y se irá guardando constantemente para evitar perdidas del trabajo si se cerrara glade.

- Crear Ventana
- Agregar Frame
- Agregar Vertical Box ->6
- Agregar Horizontal Box -> 2 saltando un Vertical Box

- Agregar Label en la parte izquiera de los Horizontal Box creados y HAL Label en la parte derecha de los Horizontal Box creados.

- Agregar HAL Hbar -> 3 en los Vertical Box restantes.

Terminado esto se procede a configurar los componentes agregados.

- En window1 no se modificará nada.
- En frame1 se modificará el nombre y la alineación de la etiqueta para centarla.

- En la etiqueta de Frame 1 se renombrará el componente y asignará el título que va a aparecer

En la alineación del Frame se cambiarán unos parámetros para dar mejor presentación.

Con esto quedará de la siguiente forma:

En mi caso acostumbro a renombrar todos los nombres de los componentes.

- vbox1 -> ReadTemp_vbx
- hbox1 -> Extruder_lbl_hbx
- hbox2 -> Bed_lbl_hbx
- hbox3 -> Extruder2_lbl_hbx

Los nombres pueden ser cualquiera los uso asi porque lbl representa a label; y vbx o hbx a vertical box y horizontal box. Lo demás es para darse cuenta que ese hbox pertenece a extruder o bed, etc.

Ahora viene la parte más importante y es la de dar nombre correcto a los componentes Hal Label y HAL_Hbar que se van a usar con el archivo .hal de CRAMPS.hal, los nombres pueden ser cuailquiera pero luego se los debe conectar con el archivo .hal.

- hal_hbar1 -> E0_Temp
- hal_hbar2 -> Bed_Temp
- hal_hbar3 -> E1_Temp

Lo mismo se realiza con las etiquetas, al final quedá de la siguiente forma.

El último paso es configurar las etiquetas y las barras horizontales que darán la lectura de temperatura.

Para las etiquetas deshabilitar expand y darles un título. Para los Horizontal box tambien deshabiltar el expand.

Para las etiquetas Hal se dará un formato de Hal pin type: 1 en la parte de configuración. Se lo realiza para que pueda recibir datos flotantes.

Para las barras horizontales también deshabilitar Expand, forzar la altura, ancho y cambiar la escala.

Terminado todo el diseño quedará algo así:

No hay que preocuparse que al ejecutar el archivo glade con gladevcp se verá que la venta se rescala al tamaño máximo configurado en el ancho y alto de las barras horizontales. Intentar cambiar los valores de ancho y alto para que se note la diferencia (force height, force width). Guardar.

Ejecutando gladevcp mostrado en el anterior tutorial se obtiene.

Donde se puede apreciar que se ha dimensionado la ventana al tamaño asignado por las barras horizontales.

Creando el archivo .hal para poder vincular los componentes de gladevcp con las señales de machinekit (linuxcnc).

# Include your customized HAL commands here
# Run on Gmoccapy with gladevcp panel 

net e0.temp.set  => ReadTemp.Extruder_Hal_lbl
net e0.temp.meas => ReadTemp.E0_Temp
net bed.temp.set  => ReadTemp.Bed_Hal_lbl
net bed.temp.meas => ReadTemp.Bed_Temp

guardar con cualquier nombre ejemplo 3D.postgui.hal


Si se mira el archivo.hal de CRAMPS se crean las señales e0.temp.set, e0.temp.meas donde el primero da el valor que se esta usando de PID y el segundo indica el valor que el ADC esta leyendo. Lo mismo para las demás señales.

Cuando se haya añadido el archivo .hal creado al archivo .ini de la CRAMPS se podrá ejecutar el archivo glade integrado en este caso a la GUI gmoccapy_lcd7 modificada por mi para pantallas lcd de 7 pulgadas con resolución de 800x480. gmoccapy_lcd7.


En el archivo .ini de CRAMPS se cambiaría lo siguiente:

[DISPLAY]

# Name of display program, e.g., tkemc
#DISPLAY = tkemc
#DISPLAY = gscreen
#DISPLAY = axis
DISPLAY = gmoccapy_lcd7

EMBED_TAB_NAME = right_side_panel
EMBED_TAB_LOCATION = box_right
EMBED_TAB_COMMAND = gladevcp -x {XID} ReadTemp.glade

Se añade el archivo glade creado al box_right de gmoccapy explicado en la parte superior y anteriores tutoriales.

[HAL]

# The run script first uses halcmd to execute any HALFILE
# files, and then to execute any individual HALCMD commands.

# list of hal config files to run through halcmd
# files are executed in the order in which they appear

HALFILE =        CRAMPS.hal

# list of halcmd commands to execute
# commands are executed in the order in which they appear
#HALCMD =               save neta

POSTGUI_HALFILE =       3D.postgui.hal

En este caso el archivo anterior donde se unen las señales hal con glade se lo llamo de la misma forma que el designado en CRAMPS. se debe agregar el archivo .hal y .glade en la misma carpeta donde se encuentran los otros archivos de CRAMPS en la beaglebone black.

El resultado es el siguiente:

Gmoccapy_lcd7 se ha modificado para que presente el archivo glade que captura box_right, solo cuando se realizá un full screen, ya que al ser menor la resolución se distorciona los iconos si se abriera con el panel principal mas el archivo glade.

Sin la opción de pantalla completa de gmoccapy desaparece el cuadro de lectura de temperatura para que no ocurra lo anteriormente explicado.

Si se quiere utilizar la configuración CRAMPS hay que deshabilitar el audio del hdmi en /boo/uEnv.txt.


Si se desea comprobar las aplicaciones en la computadora donde se esta diseñando solo es necesario ir a la carpeta de gmoccapy donde se guardan las configuraciones de gmoccpay y agregar el diseño dentro de la misma carpeta. No olvidarse de correr el scripts de linuxcnc si se copia a la carpeta de configuración de linuxcnc, caso contrario que e use Machinekit correr con machinekit y copiar a la carpeta de configuración de machinekit donde se encuentre gmoccapy.

Resultados con gmoccapy modificando en mi caso está en ~/linuxcnc-mirror/configs/sim/gmoccapy/gmoccapy.ini.

Esta es la ruta donde se deben guardar los archivos .glade o python u otros, tambien se puede crear un carpeta en  ~/linuxcnc-mirror/configs/ y guardar ahi los archivos con los que querramos explorar. En este ejemplo no se usa el archivo .hal ya que no hay lectura ADC como en el caso de la Beaglebone Black que esta configurado en el archivo .CRAMPS con un archivo python. Este es solo de simulación para poder ver como esta quedando el diseño de glade con gmoccapy; en el caso de querer usar gmoccapy_lcd7 en el PC, descargar de github y copiar a las carpetas bin, share de la ruta  ~/linuxcnc-mirror los archivos correspondientes. Utilizar en display gmoccapy_lcd7.

[DISPLAY]

DISPLAY = gmoccapy

EMBED_TAB_NAME = right_side_panel
EMBED_TAB_LOCATION = box_right
EMBED_TAB_COMMAND = gladevcp -x {XID} ReadTemp.glade

Como se ve no hay cambios al estar sin full screen y con full screen se mantiene la ventana de box_right. No mide la temperatura al solo usar el archivo .glade.

Para obtener el archivo glade en una ventana separada se escribe lo siguiente.

[DISPLAY]

DISPLAY = gmoccapy

EMBED_TAB_NAME = right_side_panel
EMBED_TAB_LOCATION = box_right
EMBED_TAB_COMMAND = gladevcp -g 64x697+0+0 ReadTemp.glade

Donde  se define anchoxaltura+desplazamiento X+desplaamiento Y

Utilizando gmoccapy_lcd7 en PC.

cd gmoccapy_lcd7/
cp bin/gmoccapy_lcd7 ~/linuxcnc-mirror/bin/
chmod a+x ~/linuxcnc-mirror/bin/gmoccapy_lcd7
cp -r share/gmoccapy_lcd7/ ~/linuxcnc-mirror/share/
sudo apt-get update
sudo apt-get install matchbox
sudo cp keyboard-cnc.xml /usr/share/matchbox-keyboard
sudo chmod a+x /usr/share/matchbox-keyboard/keyboard-cnc.xml

Se obtiene los mismo resultados que el anterior, con esto ya se puede comenzar a ver cuales son los cambios que e han hecho de la gmoccapy, tento en el archivo .glade como python (gmoccapy_lcd7 y gmoccapy en bin).

En este link ARM.BeagleBone.CRAMPS.tar.xz se podrá descargar la carpeta CRAMPS que contiene todos los archivos incluido ReadTemp.glade creado en este tutorial.

Instalación de Glade y Gladevcp en Debian (Jessie).

Se debe instalar machinekit para poder ocupar gladevcp con Glade.

sudo sh -c \
    "echo 'deb http://deb.dovetail-automata.com jessie main' > \
    /etc/apt/sources.list.d/machinekit.list"

sudo apt-get update
sudo apt-get install dovetail-automata-keyring
sudo apt-get update

En este caso se instalara machinekit como simulador.

sudo apt-get install machinekit-posix

El siguiente paso será instalar Glade con soporte de librerías Gtk2. Ya que el nuevo Glade usa Gtk3, el cuál no es compatible con los componentes de gladevcp usados para interacturar con los componentes HAL de linuxcnc.

El código de glade se lo puede descargar del siguiente link Glade

Se utilizará el último disponible -> glade3-3.8.5.tar.xz

Al terminar la descarga se lo descomprime con el comando tar.

tar -xvf glade3-3.8.5.tar.xz

Antes de compilar el programa se debe instalar algunas librerías necesarias para correr glade junto con el parche de gladevcp.

sudo apt-get install gnome-common devhelp libglade2-dev libgtk2.0-dev python-gtk2-dev \
gnome-doc-utils gtk-doc-tools

Compilación e instalación

./autogen.sh
./configure
make -j`nproc`
sudo make install
sudo ldconfig

Incluir archivos de gladevcp en glade.

Descargar del siguiente link glade3

tar -xvf glade3.tar.xz
#copiar carpeta glade3 a /usr/local/share para obtener componentes de gladevcp
sudo cp -R glade3 /usr/local/share/

Al finalizar se ejecuta glade

glade-3

Si todo se realizó de forma correcta debe aparecer lo siguiente en la parte inferior izquierda de glade.

Ya se puede crear Gui's. Pero existe un pequeño problema con machinekit que impide ejecutar las aplicaciones usando el comando de gladevcp por lo que se realizará una compilación del código de linuxcnc para poder comprobar las Gui's que se haya creado con glade.

Librerías necesarias para poder compilar LinuxCNC.

sudo apt-get install libpth-dev dvipng tcl-dev tk-dev tcl8.5-dev tk8.5-dev bwidget libxaw7-dev \
libncurses5-dev libreadline-dev asciidoc source-highlight dblatex groff python-dev python-tk \
python-lxml libglu1-mesa-dev libgl1-mesa-swx11-dev libgtk2.0-dev autoconf libboost-python-dev \
texlive-lang-cyrillic texlive-lang-french texlive-lang-german texlive-lang-spanish texlive-lang-polish \
libmodbus-dev python-support libudev-dev libusb-1.0-0-dev

Librería necesaria para solucionar problema de audio en gmoccapy.

sudo apt-get install gstreamer0.10-plugins-base

Obtener código de LinuxCNC.

cd 
git clone https://github.com/jepler/linuxcnc-mirror.git
cd linuxcnc-mirror/src
./autogen.sh
#Para ver opciones de configuración ./configure --help
./configure --enable-simulator
make -j`nproc`
sudo make setuid

Al ejecutar el script que habilita el uso de linuxcnc ya se podrá comenzar a probar los programas con el gladevcp de linuxcnc.

cd linuxcnc-mirror
. ./scripts/rip-environment
linuxcnc

Para probar los archivos con gladevcp no hay que cerrar el terminal que ejecutó el script de linuxcnc, ya que en este se ejecutará todo lo que se necesite usar de linuxcnc, una vez cerrado el terminal hay que volver a realizar el paso anterior para habilitar linuxcnc.

#Probando archivos de gladevcp
cd ~/linuxcnc-mirror/configs/apps/gladevcp
gladevcp gladevcp-test.ui