---

Opening a generic link to a calculator connected by serial

Opening a generic link can be useful if you want to implement your own custom protocol for your CASIO calculator, and do not want to deal with system-specific complexities Cahute has already implemented.

In order to open a link to a calculator plugged in over serial in order to use the link medium access functions, the steps are the following:

1. Create a context using cahute_create_context().

2. Open the link using cahute_open_serial_link() with the CAHUTE_SERIAL_PROTOCOL_NONE flag.

3. Profit!

4. Call cahute_close_link() to close the link.

5. Call cahute_destroy_context() to destroy the context.

The functions you can use with generic links are described in Link medium access related function declarations.

An example program that uses generic links to read two characters, then write two characters, is the following:

/* Compile using: gcc use-generic-serial-link.c `pkg-config cahute --cflags --libs`. */

#include <stdio.h>
#include <cahute.h>

int main(void) {
    cahute_context *context;
    cahute_link *link = NULL;
    cahute_u8 buf[2];
    int err, ret = 1;

    err = cahute_create_context(&context);
    if (err) {
        fprintf(
            stderr,
            "cahute_create_context() has returned error %s.\n",
            cahute_get_error_name(err)
        );
        return 1;
    }

    err = cahute_open_serial_link(
        context,
        &link,
        CAHUTE_SERIAL_PROTOCOL_NONE,
        "/dev/ttyUSB0",
        0
    );
    if (err) {
        fprintf(
            stderr,
            "cahute_open_serial_link() has returned %s.\n",
            cahute_get_error_name(err)
        );
        goto fail;
    }

    buf[0] = 'A';
    buf[1] = 'B';

    err = cahute_send_on_link(link, buf, 2);
    if (err) {
        fprintf(
            stderr,
            "cahute_send_on_link() has returned %s.\n",
            cahute_get_error_name(err)
        );
        goto fail;
    }

    err = cahute_receive_on_link(link, buf, 2, 0, 0);
    if (err) {
        fprintf(
            stderr,
            "cahute_receive_on_link() has returned %s.\n",
            cahute_get_error_name(err)
        );
        goto fail;
    }

    printf("Received characters are the following: %c%c\n", buf[0], buf[1]);

    ret = 0;

fail:
    if (link)
        cahute_close_link(link);

    cahute_destroy_context(context);
    return 0;
}

In order to test this, you will need a USB/serial cable and an add-in such as Serial monitor. Once the cable plugged into both the computer and the calculator[1], if you run the program:

1. You will see the two characters AB appear on your calculator.

2. You can type in two other characters, e.g. CD, on your calculator.

3. The two characters you typed on the calculator will appear on the host.

An example output of the program is the following:

[2024-09-01 01:42:12    cahute info] set_serial_params_to_link_medium: Setting serial parameters to 9600N1.
[2024-09-01 01:42:12    cahute info] open_link_from_medium: Using Generic (serial) over Serial (POSIX).
[2024-09-01 01:42:12    cahute info] open_link_from_medium: Playing the role of sender / active side.
[2024-09-01 01:42:16    cahute info] receive_on_link_medium: Read 2 bytes in 383ms (after waiting 2746ms).
Received characters are the following: CD
[2024-09-01 01:42:16    cahute info] close_link: Closing the link.

[1]

You may need to adapt the path from the program to match the one present on your host system, such as /dev/ttyUSB1 or /dev/cu.something.