MI INTERFACE PC A CCTALK. Hazlo tu mismo.

(EN) My pc to cctalk interface. DIY.
(FR) Ma connexion pc à cctalk. Do it yourself.
(PT) Minha conexão pc com cctalk. Faça você mesmo.
-------------------------------------------------------------------------------------------------

 PARA REPASAR: Ya he tratado bastante el tema. Esta entrada es una revisión, tratando de mejorar aquella primera que puedes ver aquí.

Como podrás ver por mis últimas entradas, he vuelto a darle alguna vuelta al tema del cctalk. Así que he mejorado mi primera placa interface pc-cctalk. Pretendo aquí exponerla un poco mejor por si le puede interesar a alguien más. 

Aclarar que el diseño original es de Money Controls y está extraída de las especificaciones genéricas del protocolo CcTalk. Sobre el esquema (que puedes buscar en "parte3" de la web sobre cctalk)  yo he hecho mis conexiones, a modo particular, para alimentarlo siempre con +12Vdc. 

Aquí presento un esquema hecho con KiCad:

PC-cctalk interface

 Observarás que he usado los transistores no smd y el diodo BAT85 mucho más comunes. Al pc se conecta via serie RS-232. Con mi portátil uso un adaptador usb-serie.

El pcb, aunque parece de dos  caras (verde y roja), ha sido pensada para hacer solo una cara, y sustituir la otra por apenas tres puentes por el lado de los componentes.

PC-cctalk pcb

 Visto por el lado de los componentes la disposición es la siguiente:

Distribución componentes pc-cctalk

Y en plan bonito debería quedar algo parecido a este dibujito en 3D.

Idea de Sancos para pcb pc-cctalk en 3D

En la realidad, ha habido alguna modificación de última hora, pero menor. El tamaño de los condensadores que había en la tienda era un poco más grande del que había pensado. Y aunque los conectores P1 y P2 en el esquema del pcb son ambos de 5 pines, porque eran los que tenía prediseñados en las librerias del KiCad, en la práctica he preferido poner uno de 4 pines como P2 para no confundir el conector P1 (alimentación a 12Vdc y Data cctalk) con el P2 (señales RS232 Tx, Rx y GND -las mismas que las del conector DB9-) Es al revés de la idea original que se intuye sobre el esquema original. Cuando corté no fuí consciente de la diferencia con el esquema original.

En las fotos siguientes se puede ver una imagen un poco mejor de la chapuza original que en su entrada tenía una mala foto de móvil, y esta última más trabajada. Ambas funcionan.

Mi primera conexión pc a cctalk

Mi 2ª versión interface pc a cctalk

Y creo que sólo me queda por exponer el dibujo del negativo del pcb por si a alguien le interesa probar.

Foto negativo del pcb pc-cctalk

Como aquí es importantísimo el mantener el escalado, me ha parecido mucho más interesante aportar el archivo final en pdf, generado por kicad. No copies la foto anterior. Está puesta porque hace bonito, pero lo interesante, es que descargues el archivo pdf final, y lo imprimas, asegurándote de no variar el tamaño, modificando margenes o escalados.

También he decidido compartir los archivos que he generado para mi proyecto con el programa KiCad. Supongo, que con el tiempo, es fácil que estos archivos se  vayan desfasando con las nuevas versiones de KiCad. No estaré pendiente de actualizar nada, pero confío en que puedan ser aprovechables por alguien durante un tiempo.

Y hasta aquí la ejecución sobre el papel. Si quieres ver como ha sido la realización práctica, hecha un vistazo aquí.

ANÁLISIS DE TRAMA DE COMUNICIÓN CCTALK CON UN SELECTOR DE MONEDAS

(EN) CcTalk communication frame analysis with a coin acceptor.
(FR) Analyse de trame de communication cctalk avec un monnayeur.
(PT) Análise da trama de comunicação cctalk com um selector de moedas.
----------------------------------------------------------------------------------------------------------------------

PARA REPASAR: Protocolo cctalk. He usado un selector modular Z6 de Azkoyen. No es igual pero el protocolo se parece mucho al que puedes encontrar googleando por "modular x6 cctalk".

   emoreno en un comentario a la entrada "Descifrar trama de comunicación cctalk" me solicitaba una trama con un selector de monedas.

Sat2ep en un comentario a la entrada "Obtener tramas cctalk" habla de un programa para probar selectores de monedas cctalk llamado "cctalk demo".

Es gratuito y lo he encontrado. (Googleando por "cctalk demo" hay enlaces a nri que es fabricante de monederos. De ahí acabo redirigido a una web de Crane Payment Solutions. En Suport/NRI suport/Other accesories/ccTalk-Demo-Software, v.3.1.0.0 for PC-based applications of ccTalk coin validators).

Probador monederos cctalk de NRI

 Así que he estado trasteando con él. Es un programa para windows pero yo lo he usado con linux (Ubuntu) con Wine sin problemas.

Y he monitorizado la actividad del puerto serie. Otra vez con una demo del programa Docklight. Se trata de algo parecido a lo de la entrada "Obtener tramas cctalk" pero ahora no hay máquina tragaperras. Un ordenador maneja al selector con el cctalk demo y la placa interface pc-cctalk. Y con otro monitorizo las dos lineas Rx y Tx del puerto serie.

Esquema para leer tramas cctalk de un selector de monedas

He ejecutado el "cctalk demo" y he introducido una moneda que ha sido aceptada. He recortado una captura de pantalla del escaneo de la linea Rx entre el ordenador1 y el interface cctalk. Esta vez los códigos de los bytes están en decimal (en una entrada anterior estaban en hexadecimal),

Una anotación curiosa y supongo que importante para los que quieran programar: observarás que solo aparecen códigos de la linea Rx. Eso es porque el interface Pc-cctalk que yo he montado es "con eco". Explicaré esto brevemente. Si observas el esquema de "mi conexión cctalk a pc" verás que en el punto "cctalk data" se generan los pulsos a masa o a tensión positiva a través del transistor BC546 gobernado a su vez por el otro transistor y el MAX232 por la linea Tx del PC. Pero todo lo generado por esa linea Tx del pc se une a través del diodo BAT54 y el MAX232 a la linea Rx del pc. Es decir, todo lo que el pc "envía" a través del buffer de Tx a la linea de datos cctalk, es "leído" a través del buffer de Rx del mismo pc. Para no liarnos entonces con numeritos repetidos y tener que interpertar si "van o vienen", mejor solo leemos Rx que coíncide exactamente con la linea de "cctalk DATA". Esto pasa con este interface pero a lo mejor otro que haya por ahí, es sin eco...

Dejo por aquí los datos capturados. Y los analizaré brevemente.

Trama cctalk selector de monedas

No vuelvo a explicar generalidades sobre le protocolo cctalk. Si no entiendes lo que comento tal vez debieras leerte primero mis entradas anteriores: "Obtener tramas cctalk" y  "Descifrar trama de comunicación cctalk". Podeis profundizar más buscando las directivas del protocolo por cctalk.org.

Leamos los datos:

002 000 001 254 255-----001 000 002 000 253
Para el dispositivo 002 (selector de monedas), 000 datos, desde la cpu 001, orden 254 ( SIMPLE POLL, "encuesta simple o sencilla"), y checksum.
Pretende confirmar la presencia de un dispositivo en la dirección 2. El dispositivo 2 contesta OK(000).
----------------------------------------------------------------------------------------------------------------------

002 000 001 246 007------001 003 002 000 065 090 075 020
Para el dispositivo 002 (selector), 000 datos, desde cpu 001, orden 246 REQUEST MANUFACTURER ID.  ("pedir identificación del fabricante"), y checksum.
Para la cpu 001, se envían 003 datos, desde el selector 002, como 000 (respuesta), 065="A", 090="Z", 075="K" (AZK en ascii), y checksum. El fabricante es AZKoyen.
---------------------------------------------------------------------------------------------------------------------

002 000 001 244 009------001 002 002 000 090 054 107
Para el 002 (selector), 000 datos, desde cpu 001, orden 244 REQUEST PRODUCT CODE ("pedir código del producto"), y checksum.
De la misma forma que antes en selector contesta en código ascii 090="Z", 054="6". Modular Z6 es el nombre del modelo del selector.
--------------------------------------------------------------------------------------------------------------------

002 000 001 242 011-----001 003 002 000 243 088 029 146
Para el 002, 000 datos, desde cpu 001, orden 242 REQUEST SERIAL NUMBER ("petición del número de serie), y el checksum.
Se envían a la cpu 001, 003 datos, desde el selector 002, como respuesta 000. Primero los bits menos significativos y luego los más significativos. Hay que pensar que son tres bytes en binario. 243d=11110011b; 088d=01011000b; 029d=00011101b. Que ordenando como de más significativo a menos (como hacemos cuando contamos en decimal) sería 29-88-243 o   000111010101100011110011 en binario, 1D58F3 en hexadecimal, y 1923315 en decimal.
----------------------------------------------------------------------------------------------------------------------
  
002 000 001 241 012-------001 014 002 000 090 054 032 099 099 116 097 108 107 032 086 055 046 051 191
Para el 002, 000 datos, desde la cpu 001, orden 241 REQUEST SOFTWARE REVISION ("petición de la versión del software") y cheksum.
El dispositivo 002 (selector) responde (000) al 001 (cpu) con 014 datos. En ascii 090="Z"; 054="6"; 032=" "; 099="c"; 099="c"; 116="t"; 097="a"; 108="l"; 107="k"; 032=" "; 086="V"; 055="7"; 046="."; 051="3"; y el checksum. Z6 cctalk V7.3 es el software programado en el selector de monedas.
-----------------------------------------------------------------------------------------------------------------------

002 000 001 213 040-------001 001 002 000 000 252
La cpu ordena 213 REQUEST OPTION FLAGS, preguntando de que forma se envían los valores de las monedas.
El selector contesta con 001 dato, el 000, que indica que las monedas se indicarán por la posición de cada moneda en la memoria del selector.
------------------------------------------------------------------------------------------------------------------------

002 002 001 231 255 255 022-------001 000 002 000 253
La cpu 001 envía 002 datos al selector 002. Mediante la orden 231 MODIFY INHIBIT STATUS indica que monedas se habilitan y cuales están inhibidas. Cada bit de los dos bytes está asociado a una moneda. El primer byte son las monedas del 1 al 8. El segundo las monedas del 9 al 16. Después de un reset y al arrancar todos los bits valen 0 y por lo tanto todas las monedas están inhibidas. Aquí se envían dos bytes 255, es decir, todo unos. Todas las monedas están habilitadas.
La respuesta 000 confirma que todo OK.
--------------------------------------------------------------------------------------------------------------------------

002 001 001 228 001 023-------001 000 002 000 253
La orden 228 MODIFY MASTER INHIBIT STATUS activa o desactiva la  aceptación de monedas (inhibición maestra). Sólo se usa el bit menos significativo del byte "dato" (001) si está a cero no se aceptan monedas. Si está a 1 sí se aceptan. Cuando se hace un reset o un encendido se inicializa (creo que a 0). Aquí es 001, por lo tanto 1 y se aceptan monedas.
---------------------------------------------------------------------------------------------------------------------------

002 000 001 227 026-------001 001 002 000 001 251
La orden 227 REQUEST MASTER INHIBIT STATUS consulta el estado actual del bit "inhibición maestra". Si el bit menos significativo del dato devuelto es 0 no se aceptan monedas. Si es 1 se aceptan. Aquí, como lo hemos puesto en la trama anterior, está a 1 (001).
-----------------------------------------------------------------------------------------------------------------------------

002 001 001 184 001 067-------001 006 002 000 069 085 048 048 053 065 135
184 REQUEST COIN ID. Petición del identificativo de la moneda situada en la posición indicada por el dato. En este caso 001.
La respuesta consta de 006 datos en ascii: "EU005A". (Será la moneda de 5 céntimos de euro).
---------------------------------------------------------------------------------------------------------------------------

002 001 001 184 002 066-------001 006 002 000 069 085 048 049 048 065 139
Otra vez 184 REQUEST COIN ID. pero esta vez de la moneda 002. 
Y la respuesta otros 006 datos en ascii: "EU010A". (Será la moneda de 10 céntimos de euro).
--------------------------------------------------------------------------------------------------------------------------

(...)
Y se repiten varias tramas con la orden 184 REQUEST COIN ID. pidiendo el identificativo de las sucesivas monedas hasta la última posición 16.
La moneda 3="EU020A" (20céntimos de euro)
La moneda 4="EU050A" (50 céntimos de euro)
La moneda 5="EU100A" (100 céntimos de euro, es decir 1 euro)
La moneda 6="EU200A" (2 euros)
La moneda 7="......"
La moneda 8="......"
La moneda 9="......"
La moneda 10="......"
La moneda 11="......"
La moneda 12="......"
La moneda 13="......"
La moneda 14="......"
La moneda 15="TK    " (cuatro espacios después de TK)
La moneda 16="TK    "(cuatro espacios después de TK)

Lo de TK hace referencia a "Token" o algún tipo de ficha que el monedero puede reconocer y no es una moneda.
--------------------------------------------------------------------------------------------------------------------------

002 001 001 209 001 042-------001 004 002 000 004 004 004 004 233
El comando 209 REQUEST SORTER PATHS consulta al selector que canal de salida se le asigna a la moneda que indica el dato. En este caso 001. El selector Z6 puede manejar unas bobinas que modificarán el camino de salida de la moneda una vez aceptada pudiendo ser enviadas diferentes monedas a diferentes cajones.
Se responden 004 datos. Según preferencia serán enviadas al canal que se indique en primer lugar y si por algo no está permitido ese canal será desviada respectivamente al siguiente. En este caso los cuatro datos son el canal 004.
---------------------------------------------------------------------------------------------------------------------------

002 001 001 209 002 041-------001 004 002 000 003 003 004 004 235
Otra vez la orden 209 REQUEST SORTER PATHS pero esta vez se consulta sobre la moneda 002. La moneda 2 sale por el canal 003 y si está ocupado por el 004.
---------------------------------------------------------------------------------------------------------------------------

(...)
Y sucesivamente se van consultando los caminos de salida de las siguientes monedas.
La moneda 3 sale por el canal 3 y si está ocupado por el canal 4.
La moneda 4 sale por el canal 3 y si está ocupado por el canal 4.
La moneda 5 sale por el canal 2 y si está ocupado por el canal 4.
La moneda 6 sale por el canal 1 y si está ocupado por el canal 4.
---------------------------------------------------------------------------------------------------------------------------

002 001 001 209 007 036-------
002 001 001 209 008 035-------
(...)
Para las monedas 7, 8, 9, 10, 11, 12, 13, 14 no hay respuesta. Se pasa el tiempo y se consulta la siguiente.
---------------------------------------------------------------------------------------------------------------------------

002 001 001 209 015 028-------001 004 002 000 000 000 000 000 249
002 001 001 209 016 027-------001 004 002 000 000 000 000 000 249
El valor de canal igual a 0 significa canal por defecto. Que se modifica con el comando 189 Modify default sorter path, y se consulta con 188 Request default sorter path. Aquí sabemos que la moneda (o token en este caso) 15 y 16 van al canal por defecto, aunque no sepamos todavía cuál es.
----------------------------------------------------------------------------------------------------------------------------

 002 000 001 230 023-------001 002 002 000 255 255 253
230 REQUEST INHIBIT STATUS solicita información sobre la configuración de los bits de inhibición de monedas. Cada moneda está asociada a un bit de inhibición. Hay 16 monedas. Por lo tanto los bits de las 16 monedas ocupan dos bytes. Un 0 indica moneda inhibida. Un 1 indica moneda habilitada. Estos bits se pueden modificar con 231 Modify inhibit status. 
La respuesta son dos datos 255 255. Es decir todos 1. El primer byte son las monedas del 1 al 8. El segundo son las monedas del 9 al 16. La contestación del selector de monedas indica que todas las monedas están habilitadas. Tras un reset todos los bits valdrán 0.
----------------------------------------------------------------------------------------------------------------------------

 002 000 001 221 032-------001 001 002 000 255 253
221 REQUEST SORTER OVERRIDE STATUS consulta sobre qué canales de salida están permitidos. Podrían haber sido modificados con 222 Modify sorter override status. El dato en cuestión (aquí 255), es un byte en donde el bit 0 menos significativo indica si el canal 1 está permitido o no. El bit1 indica el canal 2 y así correlativamente. Un 1 indica permitido. Un 0 indica que no está permitido y la moneda será enviada a otro canal o al canal por defecto.
La respuesta 255 (todo 1) indica que todos los canales de salida están permitidos
---------------------------------------------------------------------------------------------------------------------------

002 000 001 188 065-------001 001 002 000 004 248
188 REQUEST DEFAULT SORTER PATH solicita información sobre el canal por el que saldrán las monedas por defecto. Esto puede programarse con la orden 189 Modify default sorter path. 
En este caso el canal de clasificación al que se encaminan las monedas por defecto es el 004.
---------------------------------------------------------------------------------------------------------------------------

002 000 001 229 024-------001 011 002 000 006 000 254 000 254 000 254 000 254 000 254 246
 229 READ BUFFERED CREDIT OR ERROR CODES los eventos que suceden de aceptación de monedas o de errores se guardan en un buffer de 10 bytes, indicando los últimos cinco sucesos. Así se puede consultar al selector a menor velocidad que la introducción de monedas y no perder información de créditos. Al añadirse un evento nuevo se perderá el último. Para saber que no se han perdido eventos se debería vigilar el contador de eventos. Cada vez que hay un evento nuevo el contador se incrementa en una unidad hasta 255. Después de 255 pasará a ser 1. Será 0 sólo después de un corte de alimentación o un reset.
El selector no acepta monedas hasta que recibe un primer comando 229. Luego tendrá que recibir otro antes de un segundo. Si no recibe otro antes el selector volverá a dejar de aceptar monedas. Y no volverá a aceptar hasta otro comando 229. 

La respuesta son 011 datos. El primero (aquí 006), es el contador de eventos. Desde que se le ha dado tensión al selector de monedas y se ha hecho esta consulta ha habido 6 eventos. Los últimos cinco se nos indica en parejas. El siguiente dato (aquí 000), será 0 si indica un error, y un número de 1 a 16 si se ha aceptado una moneda indicando de cual se trata. El siguiente dato (aquí 254),  indica el tipo de error si el dato anterior era 0 (aquí es este caso), o el canal por el que se ha clasificado la moneda si el dato anterior era una moneda del 1 al 16.
En este caso particular tenemos que ha habido 006 eventos desde que se ha encendido el selector. Los cinco últimos han sido 000 254. Es decir "un error", el 254 (mecanismo de recuperación activado).  Antes de monitorizar la comunicación e introducir una moneda, es verdad que he estado jugando con la palanca de recuperación y probablemente tuviese el selector con tensión.     
Algunos códigos de error posibles son:  
0 - evento vacío
1 - moneda rechazada (fuera de parámetros)
2 - moneda inhibida
5 - moneda rechazada (demasiado tiempo en ser analizada)
6 - demasiado tiempo es pasar la moneda por la salida
8 - dos monedas demasiado juntas
13-módulo sensor no funciona bien
14-atasco en detector de salida
20-activado el sistema antihilo
23-moneda demasiado rápida
127+n - moneda n inhibida por el registro de inhibiciones
254-mecanismo de recuperación activado
255-error no especificado
--------------------------------------------------------------------------------------------------------------------------

002 000 001 229 024-------001 011 002 000 006 000 254 000 254 000 254 000 254 000 254 246
Se sigue leyendo el buffer de créditos o eventos.
(...)
---------------------------------------------------------------------------------------------------------------------------

002 000 001 229 024-------001 011 002 000 007 001 004 000 254 000 254 000 254 000 254 238
Ha habido un evento nuevo (007). La moneda 001 a sido aceptada y clasificada por el canal 004. La moneda 1 habíamos visto que era la de 5 céntimos de euro.
--------------------------------------------------------------------------------------------------------------------------


002 000 001 229 024-------001 011 002 000 007 001 004 000 254 000 254 000 254 000 254 238
(...)
Y así, leyendo el buffer, sin eventos nuevos, hasta el final de la trama analizada...
---------------------------------------------------------------------------------------------------------------------------

  
 

DESCIFRAR TRAMA DE COMUNICACIÓN CCTALK

(EN) Decrypting cctalk communication frame. An example.
(FR) Décrypter trame de comunication cctalk. Un exemple.
(PT) Decifrar comunicação cctalk. Um exemplo.  
---------------------------------------------------------------------------------------------------------------------------------

PARA REPASAR: Si queréis podéis revisar otras entradas anteriores sobre el tema: El adaptador para conectar el bus ccTalk al pc y como obtuve los códigos que voy a intentar entender...
Sobre hopper Azkoyen buscando en la web por "protocolo cctalk hopper u-ii". 
Sobre selector de monedas buscando por "modular x6 cctalk".

Voy a tratar de interpretar los códigos ccTalk que he obtenido y mostrado en la entrada anterior.

Exponemos como resumen unas ideas a tener claras:

La comunicación con el protocolo ccTalk es half duplex y asíncrona. Las señales son como el RS232 pero con niveles de tensión TTL (5v para un 1 lógico, y 0v para un 0 lógico). Comúnmente 9600 baudios, 1 bit de start, 8 bits de datos, sin paridad y 1 bit de stop. El bus ccTalk sólo tiene una linea de datos. Que con el adaptador al pc, entrarán (se leerán) por Rx y saldrán (se transmiten) por Tx, pero en el bus cctalk estarán todos en la misma linea DATA. Ningún dispositivo cctalk enviará nada a la linea DATA si no se le ordena antes por el maestro. Todos estarán en modo "lectura" y "calladitos" hasta que toque responder a lo que la unidad central maestra mande. Momento éste, en que la unidad central, permanecerá "en silencio" y a la escucha de la respuesta.

La forma y estructura de un mensaje cctalk estándar es la siguiente:

[Dirección de destino] [Número de bytes de datos] [Dirección de origen] [Cabecera u orden] [Dato1] [Dato2]...[Dato N] [Checksum]

(También hay mensajes encriptados y con control de redundancia cíclica de 16 bits, pero aún no me he peleado con ellas)

Cada secuencia de comunicación mínima consta de dos tramas según este formato. Primero desde el maestro, indicándole algo al esclavo, y luego, la respuesta del esclavo. Si el esclavo no contesta se considerará un error y el maestro repetirá el  intento. Una comunicación correcta requiere de envío y respuesta.

[DIRECCIÓN DE DESTINO] Indica a que dispositivo va dirigido el mensaje. Pueden ser desde la 0 a la 255. Algunas son especiales. La 0 afecta a todos los dispositivos, a modo de llamada general, todos se dan por enterados. La 1 es siempre la dirección del control o dispositivo maestro. Desde la 2 a la 255 corresponde una a cada dispositivo. No debe de haber dos dispositivos en el mismo bus con la misma dirección. Ésta se configura por switches o por comandos. Aunque, esto ya no es obligatorio, dispositivos como un selector de monedas suele ser la dirección 2, y los pagadores 3, 4, y 5.

[NÚMEROS DE BYTES DE DATOS] Este byte indica el número de Datos (N) del mensaje. Si es 0, el mensaje no envía datos y el número total de bytes será cinco (dirección mensaje, nº de datos, dirección origen, cabecera, y checksum).

[DIRECCIÓN DE ORIGEN] Indica "quien" envía este mensaje.

[CABECERA] Cada número indica una orden específica a la que el dispositivo obedecerá. Hay algunas especiales: 0 ACK incida que el dispositivo ha realizado correctamente el comando; 5 NACK por algún error el comando no se ha realizado; 6 BUSY el dispositivo en cuestión está ocupado, y no puede obedecer en este momento.

[DATOS] Puede ser cualquier byte entre 0 y 255 y el significado dependerá del comando a ejecutar.

[CHECKSUM] Para comprobar que no ha habido errores se suman todos los bytes del mensaje (incluido el de checksum) y la suma deberá ser tal que los últimos 8 bits del resultado sea 0. (00 en hexadecimal)


------------------------------------------------------------------------------------------------------------------------------

Sabido lo anterior veamos qué conseguimos descifrar de la trama conseguida en su día y expuesta en una entrada anterior. Recordar que durante la trama se ha introducido una moneda de 2 euros, la máquina ha devuelto 1euro y 80 céntimos (1euro + 4 de 0.20euros) y ha jugado un crédito.

Los códigos están en hexadecimal.

El primer problema es saber en donde empieza la verdadera "conversación". Alguna lectura inicial puede ser fruto de picos de encendido de la máquina, los dispositivos ccTalk no hacen caso hasta que pase un tiempo desde que son alimentados (250 ms algún selector de azkoyen, 200 ms algún hopper...)

La primera ristra de datos es: FE 00 04 00 01 EC OF 01 01 04 00 00 FA 05 00 01 ...

Sabemos que han de ser como mínimo 5 bytes y todos juntos han de sumar un número que acabe en 00 en hexadecimal. Además el primer mensaje debería tener como dirección de origen a la máquina de control(01). El primer 01 en la tercera posición nos forma el mensaje 04 00 01 EC 0F cuyos bytes suman 100h. Olvidémonos entonces de FE 00 y comencemos con:

-------------------------

04 00 01 EC 0F

Para el dispositivo 04, se envían 00 datos, desde la cpu 01, con la orden EC (236 en decimal, LECTURA ESTADO DE OPTOS), y la suma de verificación 0F

Y la contestación:
01 01 04 00 00 FA

Para la cpu 01, se envía 01 dato, desde el dispositivo 04 (probablemente un hopper), con cabecera 00 (es una contestación de conformidad), el dato es 00 (00000000 en binario), y la suma de verificación o checksum FA.

Supongo un pagador de Azkoyen, que es del que he encontrado información en internet.

Analizando el dato: El bit0, menos significativo, corresponde al optoacoplador que detecta si el pagador está vacío (0 si está cortado el haz con monedas y uno si nada obstruye la luz del diodo emisor al receptor). El bit1 indica si el pagador está lleno. Los otros bits del 2 al 7 no se usan. Así que el dato devuelto podría ser: 00h=00000000b (hopper lleno de monedas), 02h=00000010b (hopper a media carga), y 03h=00000011b (hopper vacío). Una contestación de dato 01h=00000001b sería que está activo el sensor de vacío, por lo tanto vacío, pero al mismo tiempo cortado el haz del opto de lleno y por tanto lleno. El hopper o pagador no puede estar lleno y vacío al mismo tiempo y debería ser considerado por la cpu un error.

El caso que nos ocupa, el dato devuelto es 00, por lo tanto el hopper 04 está lleno o "¡no tiene optos!"

Luego se repiten la pregunta y respuesta para los dispositivos 05 y el 03 (que también suelen ser pagadores):

05 00 01 EC 0E---------01 01 05 00 00 F9 

03 00 01 EC 10---------01 01 03 00 00 FB

Y vemos, por la respuesta 00, que también llenos.

 ------------------------

03 00 01 A3 59-----------01 01 03 00 80 7B

Para el hopper 03, 0 datos, desde la cpu, A3 (163 en decimal, TEST HOPPER), y checksum.

El comando A3h=163d provoca el envío de información acerca de varios flags de error y operación del hopper. Los flags guardan información desde la última vez que se preguntaron, pasan la información y se reinicializan. Sólo envía un dato por lo que debe de tratarse de un hopper UII cctalk standard. Existe el hopper UII cctalk PLUS que respondería con dos datos.

Siendo 1=cierto y 0=falso, analizamos el dato  devuelto:

El bit0 indica corriente máxima absoluta excedida. El bit1 tiempo máximo de pago excedido. El bit2, motor girando en sentido contrario durante el último pago para eliminar un atasco. El bit3, intento de fraude de fotocélula, salida bloqueada durante el reposo. Sensor de moneda no detectado. El bit4, intento de fraude de fotocélula, detección de moneda en reposo. El bit5, fotocélula bloqueada permanentemente durante el pago. El bit6, no se utiliza. El bit7, pago inhabilitado.

Para la cpu 01, se devuelve 01 dato, desde el hopper 03, correctamente 00: el 80h=10000000b. Así que el hopper 03 le contesta a la cpu que tiene el pago inhabilitado.

------------------------

04 00 01 EC 0F---------01 01 04 00 00 FA

Vuelve a hacer una "lectura de estado de optos" del hopper 04 y éste le responde lo mismo

04 00 01 A3 58----------01 01 04 00 80 7A

Y un "test de hopper" 04 que también contesta: "inhabilitado".

-----------------------

05 00 01 EC 0E----------01 01 05 00 00 F9
03 00 01 EC 10-----------01 01 03 00 00 FB
05 00 01 A3 57-----------01 01 05 00 80 79
03 00 01 A3 59-----------01 01 03 00 80 7B
Y lo mismo con los hoppers 5 y 3.
-----------------------

(...)
Luego se pasa un buen rato haciendo lo mismo. Mientras no pasa nada chequea los hoppers continuamente.Ya en el siguiente bloque de la foto encontramos, en la quinta linea algo nuevo.

05 00 01 F2 08
Para el hopper 5, sin datos, ordenado por la cpu (01), orden F2 (242decimal=PETICIÓN Nº DE SERIE), y checksum.
Cada hopper tiene un número de serie de fábrica. Este número será necesario saberlo para ordenar un pago de monedas.
01 03 05 00 6B 8F 12 EB
El hopper 5 contesta a la cpu con tres datos que forman el número de serie. El primer dato es el menos significativo, y el tercero el más. Así que el número de serie es: 128F6Bhexadecimal=1216363decimal 
---------------------------

 05 00 01 A6 54----------01 04 05 00 00 00 00 00 F6
Para hopper 5, sin datos, la cpu (01), ordena A6(166decimal=CONSULTA DEL ESTADO DEL HOPPER), y checksum.
Para la cpu(01), con 4 datos, el hopper 5, responde (00): 
El primer dato serán los pagos hechos desde el último reset (del valor FFh=255d se pasa al 1, de manera que un 0 es que no se ha pagado nada desde un reset). El segundo dato será las monedas pendientes de pagar. El tercero, el número de monedas pagadas en el último pago (éste si estuviésemos pagando). Y el cuarto, el número de monedas pendientes de pagar en un pago anterior. La información se guarda en la EPROM del hopper aunque falle la alimentación. Podremos recuperar la información al reiniciar el pagador. Tras un reset los cuatro datos se ponen a cero. Este es nuestro caso aquí.
------------------------------- 

05 01 01 A4 A5 B0----------01 00 05 00 FA
Para el hopper 05, se le da un dato, desde la cpu(01), la orden A4(164decimal=HABILITAR HOPPER), el dato es A5, y el checksum. El comando A4h(164d) se debe utilizar para habilitar el pagador antes de pagar monedas con cualquier orden de pago. Si el dato que se envía es A5h se habilita el hopper. Si es distinto de A5 el hopper estará deshabilitado.
La segunda secuencia es el hopper que contesta, a la cpu, que la orden ha sido realizada con éxito (00).
----------------------------------

05 04 01 A7 6B 8F 12 01 42----------01 00 05 00 FA
Para el hopper 5, cuatro datos, desde la cpu(01), la orden A7h(167d PAGAR MONEDAS CON HOPPER). De los cuatro datos, los tres primeros datos son el número de serie que nos facilitó el comando F2, y que son necesarios para construir esta orden A7 y que el hopper pague la cantidad de monedas que indica el cuarto dato. En este caso una moneda.
Si se puede hacer el pago el hopper devuelve una trama de aceptación como en este caso y comienza a efectuar el pago hasta que extraiga todas las monedas indicadas, se detecte un vano máximo, se reciba una orden de cancelación, se detecte un error, o haya un reset o fallo de alimentación.
Si no se puede pagar por un error, porque el hopper esté ocupado con otra orden, o el código (nºserie) no sea correcto, éste devolverá una trama de reconocimiento negativo.
-------------------------------------

03 00 01 EC 10----------01 01 03 00 00 FB
Vuelve a hacer lectura de optos del hopper 3, e indica hopper lleno.
-------------------------------------

05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4
Después de ordenar el pago, se hace un seguimiento de este. Esta trama vuelve a pedir una A6h(166d CONSULTA DEL ESTADO DEL HOPPER). 01 pago ordenado desde el último reset (éste). 01 moneda pendiente de pagar. 00 monedas pagadas en este pago (así que no ha realizado todavía el pago ordenado) y 00 monedas pendientes de pagos anteriores.
Así que debe de estar pagando. Sigamos controlándolo.
--------------------------------------

05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4
Seguimos como estábamos, pendiente de pagar una moneda el hopper 5.
---------------------------------------

04 00 01 A3 58----------01 01 04 00 80 7A
Se chequea el hopper 4 (A3h=163d=TEST HOPPER) y el hopper contesta. Pago deshabilitado.
---------------------------------------

04 00 01 EC 0F----------01 01 04 00 00 FA
Lectura del estad de optos (ECh=236d). Hopper 4 lleno de monedas.
---------------------------------------


05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4      (dos veces)
Y seguimos pendientes del pago de una moneda del hopper 5.
--------------------------------------

03 00 01 EC 10----------01 01 03 00 00 FB
Lectura del estado de optos (ECh=236d). Hopper 3 lleno de monedas.
--------------------------------------

05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4
03 00 01 A3 59----------01 01 03 00 80 7B
05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4
04 00 01 EC 0F---------01 01 04 00 00 FA
05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4    (dos veces)
04 00 01 A3 58----------01 01 04 00 80 7A
03 00 01 EC 10----------01 01 03 00 00 FB
05 00 01 A6 54----------01 04 05 00 01 01 00 00 F4
Chequeando continuamente los hoppers sin novedades....
---------------------------------------

05 00 01 A6 54----------01 04 05 00 01 00 01 00 F4
Aquí hay un cambio en la respuesta. Los datos de respuesta del estado del hopper 5, que hasta ahora eran siempre 01 01 00 00, en este mensaje pasan a ser 01 00 01 00. Ya no hay monedas pendientes de pagar, y en el último pago se pagó una moneda. Por fin, el hopper 5 nos indica que ha pagado una moneda.
----------------------------------------

05 00 01 F2 08----------01 03 05 00 6B 8F 12 EB
La cpu vuelve a consultar el número de serie del hopper 5.
----------------------------------------

04 00 01 EC 0F----------01 01 04 00 00 FA
El hopper 4 sigue lleno.
----------------------------------------

05 01 01 A4 00 55----------01 00 05 10 FA
Se deshabilita el pago del hopper 5.
----------------------------------------

05 00 01 EC 0E----------01 01 05 00 00 F9
03 00 01 A3 59----------01 01 03 00 80 7B
Más chequeos del estado de los hoppers.
-----------------------------------------

03 00 01 F2 0A----------01 03 03 00 2B 90 0E 30
Consulta del número de serie del hopper 3. Este es 0E902Bh=954411d.
-----------------------------------------

03 00 01 A6 56----------01 04 03 00 00 00 00 00 F8
Consulta del estado del hopper 3. Sin pagos realizados ni pendientes desde el reset.
----------------------------------------

03 01 01 A4 A5 B2----------01 00 03 00 FC
Habilitar el hopper 3 para pagos.
-----------------------------------------

03 04 01 A7 2B 90 0E 01 87----------01 00 03 00 FC
Que el hopper 3 pague una moneda.
----------------------------------------

05 00 01 A3 57----------01 01 05 00 80 79
Y seguimos revisando fotocélulas del hopper 5.
----------------------------------------

03 00 01 A6 56-----------01 04 03 00 01 01 00 00 F6
Y también se sigue revisando como va el pago del hopper 3. Pendiente de pagar una moneda de una orden de pago.
----------------------------------------

04 00 01 EC 0F----------01 01 04 00 00 FA
03 00 01 A6 56----------01 04 03 00 01 01 00 00 F6
04 00 01 A3 58----------01 01 04 00 80 7A
05 00 01 EC 0E----------01 01 05 00 00 F9
03 00 01 A6 56----------01 04 03 00 01 01 00 00 F6  (tres veces)
04 00 01 EC 0F----------01 01 04 00 00 FA
03 00 01 A6 56----------01 04 03 00 01 01 00 00 F6
05 00 01 EC 0E----------01 01 05 00 00 F9
05 00 01 A3 57----------01 01 05 00 80 79
03 00 01 A6 56----------01 04 03 00 01 01 00 00 F6  (dos veces)
04 00 01 A3 58----------01 01 04 00 80 7A
03 00 01 A6 56----------01 04 03 00 01 01 00 00 F6
04 00 01 EC 0F----------01 01 04 00 00 FA
03 00 01 A6 56----------01 04 03 00 01 00 01 00 F6
Hasta aquí ha estado chequeando continuamente los hoppers y el pago del hopper 3. Aquí, por fin, el hopper 3 confirma que ha pagado una moneda.
------------------------------------------------------------

03 00 01 f2 0A----------01 03 03 00 2B 90 0E 30
La cpu consulta el número de serie del hopper 3 que es 0E902Bh=954411d.
-------------------------------------------------

05 00 01 EC 0E----------01 01 05 00 00 F9
03 00 01 A3 59----------01 01 03 00 00 FB
Vuelta a revisar el estado de los hoppers.
--------------------------------------------

03 00 01 F2 0A----------01 03 03 00 2B 90 0E 30
03 00 01 A6 56----------01 04 03 00 01 00 01 00 F6
03 01 01 A4 A5 B2----------01 00 03 00 FC
03 04 01 A7 2B 90 0E 03 85----------01 00 03 00 FC
03 00 01 A6 56----------01 04 03 00 02 03 00 00 F3
Vuelve a habilitar el pago del hopper 3, pero esta vez (segundo pago) le manda pagar 3 monedas.
Obsérvese que parece seguir siempre el mismo procedimiento.
1º pedir el nºde serie del hopper F2
2º observar el estado del pago A6
3º habilitar el hopper para pagar A4
4º ordenar el pago A7
5º estar pendiente del pago A6
6º y cuando finalmente se ha pagado inhabilitar el hopper para el pago A4
---------------------------------------------

04 00 01 A3 58----------01 01 04 00 80 7A
03 00 01 A6 56----------01 04 03 00 02 03 00 00 F3
04 00 01 EC 0F----------01 01 04 00 00 FA
05 00 01 A3 57----------01 01 05 00 80 79
Se sigue revisando. Hasta aquí nada nuevo.
-----------------------------------------------

03 00 01 A6 56----------01 04 03 00 02 02 01 00 F3
Aquí cambia algo la cosa. Es el segundo pago. Ya solo tiene 2 monedas pendientes de pago, porque ha pagado 1 y no debe nada de ningún pago anterior. Vemos que el hopper está pagando.
---------------------------------------------

05 00 01 EC 0E----------01 01 05 00 00 F9
03 00 01 A6 56----------01 04 03 00 02 01 02 00 F3
En este segundo pago del hopper 3 ya ha pagado 2 monedas y queda 1 por pagar.
--------------------------------------------



03 00 01 A6 56----------01 04 03 00 02 01 02 00 F3
03 00 01 A6 56----------01 04 03 00 02 00 03 00 F3
Se han pagado las tres monedas y no quedan pendientes.
--------------------------------------------

03 00 01 F2 0A----------01 03 03 00 2B 90 0E 30
04 00 01 EC 0F----------01 01 04 00 00 FA
03 01 01 A4 00 57----------01 00 03 00 FC
Inhabilita el hopper 3 para pagos. Ya  hemos acabado de pagar.
---------------------------------------------

Y desde aquí hasta el final ya se pasa todo el tiempo chequeando el estado de los hoppers. La máquina ya ha pagado una moneda del hopper 5 y cuatro del hopper 3 (en dos veces 1+3).


Todo corresponde con lo que me esperaba, salvo que no he encontrado el código de comunicación con el selector de monedas. Y ya he comentado, que he introducido una moneda de 2euros. Esto me ha extrañado, pero después de revisar el esquema eléctrico de la máquina, me he encontrado con que, no todos los dispositivos van unidos al mismo bus cctalk, como pensaba. Sino que, en esta máquina, el selector de monedas tiene su línea de comunicación cctalk propia con la cpu, los hoppers otra diferente y el lector de billetes también la suya propia, todas independientes. Para hacer el monitorizado de la comunicación yo he conectado a la linea de los hoppers, por eso únicamente aparece comunicación de pagos.

De todas formas me queda constatado que las cosas funcionan como yo había entendido, y aquí queda un rollo curioso para el que le interese el asunto.
He revisado un par de veces lo que escrito. Esta entrada es un poco densa y espero no haber metido la pata. Pero como siempre, ya sabéis que no os debéis fiar a ciegas. Aunque trato de ser exacto, muchas veces cometo errores, como todo el mundo. Mi afán en este blog es aprender yo mismo. Así que si detectáis algún fallo, o algo importante que aportar, me encantarían comentarios o emails.
Saludos.



(CONTINÚA CON:Otra entrada sobre trama cctalk de un selector de monedas)