Decent Espresso

API para balanzas de Decent Espresso

http://decentespresso.com/decentscale_api



Balanza Decent Scale

Documentación de la API BLE abierta

Foro de discusión   API ampliada de Half Decent Scale   contáctenos


Queremos proporcionar ejemplos de código en muchos lenguajes de programación que muestren cómo hacer cosas con la balanza Decent Scale.
Por favor, envíenos un correo electrónico y comparta su propio código de habla a la balanza, para que podamos ayudar a otros a empezar más rápido.

Guía de inicio rápido: notificaciones de peso y de botones, tara y el temporizador

  1. Encienda la balanza Decent Scale manteniendo pulsado el botón O durante 2 segundos.
  2. Haga un escaneo BLE en su dispositivo, y luego conéctese a la 'Decent Scale'.
  3. Envía un comando TARA o LED ON a la balanza para que la APP aparezca en la balanza. La balanza no pesará hasta que se envíe algún tipo de comando a la balanza, para hacerla saber que su aplicación existe.
  4. Encienda el LED: «030A0101000108» o apáguelo: «030A0000000009»
  5. Pide recibir notificaciones de peso desde FFF4 ('0000FFF4-0000-1000-8000-00805F9B34FB'). Las notificaciones de peso llegarán ahora a 10x por segundo, como un entero de dos bytes (corto) con signo, en los bytes 3 y 4.
  6. El firmware v1.0 y v1.1 envía el peso como un mensaje de 7 bytes. El firmware v1.2 y más reciente envía el peso con una marca de tiempo, como un mensaje de 10 bytes.
  7. Optional: Iniciar el temporizador enviando '030B030000000B' y pausar el temporizador con '030B0000000008' y poner el temporizador a cero con '030B020000000A'.
  8. Ponga a cero la balanza enviando «030F000000010D».
  9. Mira la demostración de la aplicación Light Blue haciendo estos comandos.
  10. Error conocido: en el firmware v1.0 de la Balanza Decent Scale, un comando (como la tara, o el inicio del temporizador) podría perderse ocasionalmente. Por seguridad, envía un comando a la balanza dos veces, con un retraso de 50 ms o más. Esto se abordará en el firmware v1.1. En la v1.1 se añadirá un nuevo comando BLE para determinar la versión actual del firmware, en caso de que se quiera poner una lógica condicional para no enviar los comandos dos veces.
  11. La balanza Half Decent se desconecta si no se recibe un latido de «03 0a 03 ff ff 00 0a» al menos cada 5 segundos. Esta es una función muy útil que desconecta las conexiones Bluetooth zombis, que ocurren con frecuencia en Android 9 y versiones anteriores. Enviar el latido a balanzas más antiguas no tiene ningún efecto negativo. El byte 6 de los comandos TARE y LED ON debe establecerse en 01, de lo contrario, la Half Decent Scale asumirá que su aplicación no reconoce la función de latido y no la aplicará.
  12. ¿Tiene problemas? Descarga LightBlue para ios, Android, Mac y sigue los pasos que se muestran en el vídeo de arriba.
  13. Guía para programadores sobre la balanza Half Decent.

Referencia a los comandos:

Peso recibido enFFF4 (0000FFF4-0000-1000-8000-00805F9B34FB)

El firmware v1.0 y v1.1 envía el peso como un mensaje de 7 bytes:
  • 03CE 0000 0000 CD = 0.0 gramos
  • 03CE 0065 0000 A8 = 10.1 gramos
  • 03CE 0794 0000 5E = 194.0 gramos
  • 03CE 1B93 0000 5E = 705.9 gramos
  • 03CE 2BAC 0000 4A = 1118.0 gramos

    El firmware v1.2 y más reciente envía el peso con una marca de tiempo como un mensaje de 10 bytes:
  • 03CE 0000 010203 0000 CD = 0.0 gramos - (1 minuto, 2 segundos, 3 decisegundos)
  • 03CE 0065 010204 0000 A8 = 10.1 gramos - (1 minuto, 2 segundos, 4 decisegundos)
  • 03CE 0794 010205 0000 5E = 194.0 gramos - (1 minuto, 2 segundos, 5 decisegundos)
  • 03CE 1B93 010206 0000 5E = 705.9 gramos - (1 minuto, 2 segundos, 6 decisegundos)
  • 03CE 2BAC 010207 0000 4A = 1118.0 gramos - (1 minuto, 2 segundos, 7 decisegundos)
    • Tara (poner el peso a cero)030F000000010E
    Encendido del LED030A0101000108 (gramos)
    Apagado del LED030A0000000009
    Inicio del temporizador030B030000000B
    Parada del temporizador030B0000000008
    Poner temporizador a cero030B020000000A
    Apagar
    (nuevo en el firmware v1.2)    		030A020000000B

    Conexión con BLE y límite de tiempo

    1. Al encenderla, la balanza se anunciará para la conexión BLE. Un LED azul parpadeará. El dispositivo BLE se denomina ' Decent Scale '.
    2. La balanza permanecerá permanentemente disponible para ser conectada por BLE. No hay tiempo de espera BLE.
    3. Si su aplicación se conecta y luego se desconecta, la balanza volverá al modo de conexión BLE.
    4. Si funciona con pilas, la balanza se apagará después de 2 minutos (10 minutos para el firmware v1.1) si no está conectada por BLE, o si no se ha producido ningún pesaje.
    5. Si funciona con alimentación USB, la balanza nunca se apagará por sí sola.
    6. Cuando su aplicación se conecte, aparecerá la palabra APP en la pantalla de la balanza.
    7. Está disponible un vídeo de presentación rápida de la Decent Scale.

    Objetivos de diseño de la balanza

    1. La información sobre el peso está intencionadamente sin suavizar, ya que pensamos que el suavizado se puede hacer mejor en un dispositivo informático, en el software, que en el firmware de la balanza.
    2. La balanza Decent Scale no tiene el concepto de 'peso estable'. Las lecturas actuales de la célula de carga se transfieren inmediatamente por BLE.
    3. Si desea un peso suavizado, deberá implementarlo usted mismo sobre los datos brutos recibidos por la balanza.
    4. Los cambios de peso se comunican inmediatamente.
    5. No existe un 'umbral de peso' que deba alcanzarse para que se considere que el peso ha cambiado.
    6. Esta balanza tiene como objetivo ser extremadamente rápida para responder a los cambios de peso, hasta 0,1g.
    7. Si hay movimiento en su medio de pesaje (como un líquido) que probablemente verá pequeñas variaciones de peso debido a ese movimiento.
    8. Si su caso de uso implica que prefiere ocultar las variaciones de peso en el LED de la balanza, puede optar por desactivarlas. De este modo, puede optar por mostrar sólo el peso dentro de su aplicación. Esto tendrá la ventaja añadida de alargar en gran medida la duración de la pila.
    9. El firmware v1.2 y posteriores incluyen una marca de tiempo con una precisión de un decisegundo con cada medición de peso. Esto es (1) para ayudarle a calcular el caudal, (2) para saber si ha perdido una medida de peso o (3) ha recibido un mensaje de peso fuera de orden.

    Botones

    1. Hay dos botones, etiquetados con un círculo (botón 0) y un cuadrado (botón 1).
    2. Cuando no hay conexión BLE, estos botones controlan la alimentación, la tara y el temporizador.
    3. Una vez que hay una conexión BLE, estos botones están completamente bajo el control de su aplicación, y los pulsos ya no tienen ningún efecto sobre la balanza.

    Limitaciones

    1. El peso máximo es de 2000 g.
    2. Las bebidas muy calientes pueden hacer que la balanza no muestre una lectura correcta
      1. Esto se debe a que calientan la célula de carga, cambiando su resistencia bajo el peso.
      2. Normalmente esto se manifiesta como que el peso no sube más allá de un número determinado.
      3. Esto se puede solucionar utilizando una almohadilla aislante entre la balanza y la bebida caliente, como un trozo de silicona o madera.
    3. La balanza Decent está calibrada de fábrica con pesos de 1000 g y 2000 g.
      1. Sin embargo, la calibración puede verse afectada por el transporte.
      2. Consulte el Manual del usuario o este vídeo sobre la calibración para obtener más información.
      3. El peso se envía en 10hz.
      4. El estado de la batería se devuelve en la alimentación de datos del peso en respuesta al comando BLE de encendido o apagado del LED.
        1. Ver 'Envío de comandos para encender o apagar los LEDs'.
        2. Una carga de la pila del 3% o inferior hará que aparezca un mensaje de LO en la balanza al encenderla.
      5. No recomendamos dejar pesos pesados en la balanza de forma permanente, ya que esto distorsionará lentamente la célula de carga y la descalibrará.
      6. No hay límite en el número de veces que se puede recalibrar la balanza.
      7. No hay ningún comando BLE para ajustar los gramos o las onzas en la pantalla de la balanza.
        1. This must be done manually, by pressing both O and [] buttons immediately after turning the scale on. See the User Manual for more information.
        2. Puede descubrir si la balanza está mostrando Gramos u Oz leyendo la respuesta al comando BLE de encendido o apagado del LED. Consulte 'Envío de comandos para encender o apagar los LEDs'.
      8. Si se envía un segundo comando BLE a la balanza antes de que haya terminado de ejecutar el primer comando, la balanza ignorará el segundo comando.
        1. Por ejemplo: un comandoa de tara inmediatamente seguida de un comando de inicio de temporizador.
        2. Se recomienda un retraso de 200 ms entre los comandos enviados a la balanza.
        3. Alternativamente, puede retrasar el envío del segundo comando hasta que pueda reconocer que el primer comando fue ejecutado.
        4. Por ejemplo: después de una tara (o de un comando de encendido/apagado del LED), se envía una respuesta a su aplicación, con el byte 6 ajustado a FE para indicar el éxito.


      Resumen de BLE

      Los paquetes de la balanza Decent Scale entran en '0000FFF4-0000-1000-8000-00805F9B34FB'

      Todos los paquetes BLE hacia/desde la balanza Decent Scale tienen la siguiente estructura de 7 bytes:

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      0A=LED encendido/apagado
      0B=Activación/desactivación del temporizador
      0F=Tara      		Comando / datos (1)Comando / datos (2)Comando / datos (3)Comando / datos (4)Validación XOR
      XOR de 6 bytes para la validación
      A continuación se ofrece más información sobre cada comando y tipo de información.

      Aquí hay un procedimiento Tcl que construye el paquete binario de 7 caracteres para enviarlo a la balanza Decent Scale. Se construye primero como una cadena de texto, que luego se convierte en un binario de 7 bytes al final del procedimiento:

        proc decent_scale_make_command {cmdtype cmdddata {cmddata2 {}} } {
    if {$cmddata2 == ""} {
        msg "1 part decent scale command"
        set hex [subst {03${cmdtype}${cmdddata}000000[decent_scale_calc_xor "0x$cmdtype" "0x$cmdddata"]}]
    } else {
        msg "2 part decent scale command"
        set hex [subst {03${cmdtype}${cmdddata}${cmddata2}0000[decent_scale_calc_xor4 "0x$cmdtype" "0x$cmdddata" "0x$cmddata2"]}]
    }
    msg "hex is '$hex' for '$cmdtype' '$cmdddata' '$cmddata2'"
    return [binary decode hex $hex]
}


      Cálculo XOR

      Para calcular el XOR, debe hacer un XOR matemático de los primeros 6 bytes.

      Aquí está el código de programación Tcl que calcula el XOR para un comando simple que toma sólo un parámetro, como TARA:

        proc decent_scale_calc_xor {cmdtype cmdddata} {
    set xor [format %02X [expr {0x03 ^ $cmdtype ^ $cmdddata ^ 0x00 ^ 0x00 ^ 0x00}]]
    msg "decent_scale_calc_xor for '$cmdtype' '$cmdddata' is '$xor'"
    return $xor
}

      Aquí está el código de programación Tcl que calcula el XOR para un comando de dos parámetros, como la activación de los LEDs:

        proc decent_scale_calc_xor4 {cmdtype cmdddata1 cmdddata2} {
    set xor [format %02X [expr {0x03 ^ $cmdtype ^ $cmdddata1 ^ $cmdddata2 ^ 0x00 ^ 0x00}]]
    msg "decent_scale_calc_xor4 for '$cmdtype' '$cmdddata1' '$cmdddata2' is '$xor'"
    return $xor
}

      Peso de recepción

      La recepción de datos de peso es un caso un poco especial, ya que el peso se envía como un entero corto de dos bytes con signo de gramos peso * 10:

      El firmware v1.0 y v1.1 envía el peso como un mensaje de 7 bytes.

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      CE=peso estable
      CA= cambio de peso      		Datos (1)
      Peso en gramos * 10

      Byte alto de un entero corto con signo      		 Datos (2)
      Peso en gramos * 10

      Byte bajo de un entero corto con signo      		Datos (3)
      Cambio * 10

      Byte alto de un entero corto con signo      		 Datos (4)
      Cambio * 10

      Byte bajo de un entero corto con signo      		 Validación XOR
      XOR de 6 bytes para la validación
      El firmware v1.2 y más reciente envía el peso con una marca de tiempo, como un mensaje de 10 bytes.

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7BYTE 8BYTE 9BYTE 10
      Modelo
      03 = Decent      		Tipo
      CE=peso estable
      CA= cambio de peso      		Datos (1)
      Peso en gramos * 10

      Byte alto de un entero corto con signo      		 Datos (2)
      Peso en gramos * 10

      Byte bajo de un entero corto con signo      		 Datos (3)
      Minutos en      		 Datos (4)
      Segundos en ( 0-59 en hexadecimal)      		 Datos (5)
      Decisegundos activados (0-9)      		 Datos (6)
      Para uso futuro      		 Datos (7)
      Para uso futuro      		 Validación XOR
      XOR de 6 bytes para la validación
      Notas:
      1. Tu aplicación debería tener en cuenta la longitud del mensaje recibido, y soportar el análisis de ambos. La mayoría de las aplicaciones sólo necesitan saber el peso actual: simplemente mirando los bytes 3 y 4 es compatible con todos los firmware de Decent Scale También puede comprobar que la versión del firmware es igual o superior a 03.
      2. El peso actual llega como un entero con signo big-endian de dos bytes en los bytes de datos 1 y 2.
      3. El cambio de peso por segundo llega como un corto big-endian de dos bytes sin signo. Sin embargo, esta función tiene actualmente errores y no se recomienda su uso. Si necesita datos de cambio de peso, debe calcularlos usted mismo. La función de cambio de peso se ha suspendido a partir del firmware v1.2.
      4. Los datos del peso se envían en 10 hz.
      5. La balanza intenta determinar cuándo el peso parece ser estable (no hay más cambios) y establece el segundo par de bytes como CE. Cuando el peso está cambiando, la segunda parte de bytes es CA. Sin embargo, puede elegir ignorar esto e implementar su propia lógica para decidir cuándo el peso es estable, ya que no se realiza ningún suavizado o estabilización de datos en los datos de peso informados.
      6. En la parte superior de esta página encontrará ejemplos de mensajes de 7 y 10 bytes.

      Recepción de pulsos de botón

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      AA      		Datos (1)
      01=botón 0
      02=botón 1      		Datos (2)
      01= toque corto
      02= toque largo      		Datos (3)Datos (4)Validación XOR
      00
      Notas:
      1. Cuando se tiene una conexión BLE, las pulsaciones de los botones no tienen ningún efecto funcional en la balanza, y se pueden programar para que tengan cualquier función que se desee, guiada por su programación.
      2. En el firmware v1.1 de la balanza, la pulsación de un botón O no se envía por BLE.Si su aplicación necesita tarar la balanza, su aplicación debe enviar el comando de tara BLE.

      Aquí hay ejemplos de pulsaciones de botones del registro de la aplicación Light Blue: 
        16:59:51.479 - Característica (FFF4) notificada: 03aa0101 0000a9 (pulsación corta del botón O)
17:35:49.591 - Característica (FFF4) notificada: 03aa0102 0000aa (pulsación larga del botón O)
17:38:16.702 - Característica (FFF4) notificada: 03aa0201 0000aa  (pulsación corta del botón [])
17:39:08.003 - Característica (FFF4) notificada: 03aa0202 0000a9  (pulsación larga del botón [])

      Envío de la orden de tara (poner el peso a cero)

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      0F      		Datos (1)
      Número entero incrementado
      (Siempre puede ser 0)      		 Datos (2)
      00      		Datos (3)
      00      		Datos (4)
      00=disable heartbeat requirement
      01=maintain heartbeat      		Validación XOR
      Calculado
      Notas:
      1. El 'entero incrementado' es opcional, y siempre puede ser cero.
      2. La secuencia de bytes 030F000000000C siempre resultará en una tara exitosa.
      3. Asegúrese de calcular correctamente el XOR para BYTE 7 o el comando TARA será ignorado.
      4. La balanza Half Decent se desconecta si no se recibe un latido de «03 0a 03 ff ff 00 0a» al menos cada 5 segundos. Si desea desactivar este requisito, el byte 6 debe ser 00. Si desea mantener este requisito, el byte 6 debe ser 01. Establecer el byte 6 en 01 no tiene ningún efecto negativo en los modelos que no admiten la función de latido.
      Y aquí hay un fragmento de código que muestra cómo construir un comando de tara de 7 bytes:

        proc tare_counter_incr {} {

    if {[info exists ::decent_scale_tare_counter] != 1} {
        set ::decent_scale_tare_counter 0
    } elseif {$::decent_scale_tare_counter >= 255} {
        set ::decent_scale_tare_counter 0
    } else {
        incr ::decent_scale_tare_counter
    }

    # alternatively: the tare counter can in fact be any not-recently-used integer, such as this random digit-picker
    # set ::decent_scale_tare_counter [expr {int(rand() * 255)}]

}

proc decent_scale_tare_cmd {} {
    tare_counter_incr
    set cmd [decent_scale_make_command "0F" [format %02X $::decent_scale_tare_counter]]
    return $cmd
}


      La balanza Decent Scale enviará una respuesta después de un comando de tara. Esa respuesta tiene la siguiente estructura:

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      0F      		Datos (1)
      Contador de taras      		Datos (2)
      00      		Datos (3)
      00      		Datos (4)
      FE      		Validación XOR

      Envío de comandos para encender o apagar los LEDs

      BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
      Modelo
      03 = Decent      		Tipo
      0A      		Datos (1)
      Peso LED encendido/apagado
      00=apagado
      01=encendido
      02=apagado      		Datos (2)
      LED del temporizador encendido/apagado
      00=apagado
      01=encendido      		Datos (3)
      00=gramos
      01=onzas      		Datos (4)
      00      		Validación XOR
      Calculado
      Notas:
      1. La duración de la batería se prolonga manteniendo los LEDs apagados.
      2. La balanza seguirá funcionando, incluso con los dos LEDs apagados.
      3. El comando de apagado se añadió en el firmware v1.2.
      4. El único LED que muestra que 'el peso está cambiando' se encenderá, incluso si ambos LEDs se han apagado.
        1. A partir del firmware v1.1, el LED situado sobre el botón cuadrado ya no se ilumina durante el cambio de peso.
        2. En cambio, ese LED se enciende cuando se pulsa cualquiera de los botones.
        3. Esto es para proporcionar una retroalimentación visual al usuario que la presión del botón fue detectada.
        Ejemplo: comando de encendido de todos los LEDs, usando gramos: 
          03 0A 01 01 00 00 09
        Ejemplo: comando de encendido de todos los LEDs, usando onzas: [requiere firmware v1.1] 
          03 0A 01 01 01 00 08
        Ejemplo: comando de apagado de todos los LEDs: 
          03 0A 00 00 00 00 09
        Ejemplo: Comando de apagado: 
          03 0A 02 00 00 00 0B
        La balanza Decent enviará una respuesta después de un comando de encendido/apagado del LED (firmware v1.1), en la alimentación de datos de peso, con información de gramos vs oz, nivel de energía de la batería y versión del firmware. Tiene la siguiente estructura:

        BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
        Modelo
        03 = Decent        		Tipo
        0A        		Datos (1)
        00        		Datos (2)
        Unidades de peso en el LED
        00=gramos
        01=oz        		Datos (3)
        Nivel de batería
        Entre el 3% (bajo) y el 100% (pleno).
        FF (255) = Alimentación por USB        		Datos (4)
        versión del firmware
        FE=v1.0
        02=v1.1
        03=v1.2        		Validación XOR
        El nivel de la batería se indica siempre al 100%, debido a una limitación en la placa de circuito impreso de la balanza.
        Este es un ejemplo de lectura del nivel de batería desde el registro de la aplicación Light Blue: 
          16:02:36.005 - Característica (36F5) escribió el nuevo valor: <030a0101 000009> (utilizamos la app para enviar este valor, encendiendo el LED)
16:02:36.061 - Característica (36F5) leída: (nula)
16:02:36.135 - Característica (FFF4) notificada: 030a0000 64026f (64 hex = 100%, funcionando con pilas)

          15:59:50.421 - Característica (36F5) escribió el nuevo valor: <030a0101 000009> (utilizamos la app para enviar este valor, encendiendo el LED)
15:59:50.485 - Característica (36F5) leída: (nula)
15:59:50.522 - Característica (FFF4) notificada: 030a0000ff0ac7  (FF hex = 255%, funcionando con alimentación USB)

        Envío de comandos para controlar el temporizador

        BYTE 1BYTE 2BYTE 3BYTE 4BYTE 5BYTE 6BYTE 7
        Modelo
        03 = Decent        		Tipo
        0B        		Datos (1)
        Inicio/parada/reinicio del temporizador
        00=parada
        02=reinicio a cero
        03=inicio        		Datos (2)
        00        		Datos (3)
        00        		Datos (4)
        00        		Validación XOR
        Calculado
        Ejemplo: Comando de inicio del temporizador 
          03 0B 03 00 00 00 0B
        Ejemplo: Comando de parada del temporizador 
          03 0B 00 00 00 00 08
        Ejemplo: Comando de reinicio del temporizador 
          03 0B 02 00 00 00 0A

        Amplio código de muestra sobre la recepción de diversos datos de la balanza Decent Scale

        Ejemplo más grande de bluetooth.tcl en Github

        El siguiente fragmento de código (en el lenguaje Tcl, pero espero que pueda entenderlo) puede:
        1. recibir información de peso
        2. recibir una pulsación de botón
        3. recibir el valor actual del temporizador 
        set ::de1(cuuid_decentscale_read) "0000FFF4-0000-1000-8000-00805F9B34FB"
set ::de1(cuuid_decentscale_write) "000036F5-0000-1000-8000-00805F9B34FB"
set ::de1(cuuid_decentscale_writeback) "83CDC3D4-3BA2-13FC-CC5E-106C351A9352" 

if {$cuuid eq $::de1(cuuid_decentscale_read)} {
    # decent scale
    parse_decent_scale_recv $value weightarray

    if {[ifexists weightarray(command)] == [expr 0x0F] && [ifexists weightarray(data6)] == [expr 0xFE]} {
        # tare cmd success is a msg back to us with the tare in 'command', and a byte6 of 0xFE
        msg "- decent scale: tare confirmed"

        return
    } elseif {[ifexists weightarray(command)] == 0xAA} {
        msg "Decentscale BUTTON $weightarray(data3) pressed"
        if {[ifexists $weightarray(data3)] == 1} {
            # button 1 "O" pressed
            decentscale_tare
        } elseif {[ifexists $weightarray(data3)] == 2} {
            # button 2 "[]" pressed
        }
    } elseif {[ifexists weightarray(command)] != ""} {
        msg "scale command received: [array get weightarray]"

    }

    if {[info exists weightarray(weight)] == 1} {
        set sensorweight [expr {$weightarray(weight) / 10.0}]
        #msg "decent scale: ${sensorweight}g [array get weightarray] '[convert_string_to_hex $value]'"
        #msg "decentscale recv read: '[convert_string_to_hex $value]'"
        ::device::scale::process_weight_update $sensorweight $event_time
    } else {
        msg "decent scale recv: [array get weightarray]"
    }
}

proc parse_decent_scale_recv {packed destarrname} {
    upvar $destarrname recv
    unset -nocomplain recv

       ::fields::unpack $packed [decent_scale_generic_read_spec] recv bigeendian

       if {$recv(command) == 0xCE || $recv(command) == 0xCA} {
           unset -nocomplain recv
           ::fields::unpack $packed [decent_scale_weight_read_spec2] recv bigeendian
       } elseif {$recv(command) == 0xAA} {
           msg "Decentscale BUTTON pressed: [array get recv]"
       } elseif {$recv(command) == 0x0C} {
           unset -nocomplain recv
           ::fields::unpack $packed [decent_scale_timing_read_spec] recv bigeendian
           msg "Decentscale time received: [array get recv]"
       }
}

proc decent_scale_generic_read_spec {} {
    set spec {
        model {char {} {} {unsigned} {}}
        command {char {} {} {unsigned} {}}
        data3 {char {} {} {unsigned} {}}
        data4 {char {} {} {unsigned} {}}
        data5 {char {} {} {unsigned} {}}
        data6 {char {} {} {unsigned} {}}
        xor {char {} {} {unsigned} {}}
    }
    return $spec
}

proc decent_scale_weight_read_spec2 {} {
    set spec {
        model {char {} {} {unsigned} {}}
        wtype {char {} {} {unsigned} {}}
        weight {Short {} {} {signed} {}}
        rate {Short {} {} {unsigned} {}}
        xor {char {} {} {unsigned} {}}
    }
    return $spec
}