One of the advantages of the B9X Basic GUI Module is that a fairly sophisticated touchscreen push-to-talk application can be written in understandable B9X Basic. The Handie-Talkie program creates the user interface, connects to the B9X Voice Server, monitors the microphone and battery, controls speaker volume, handles push-to-talk, stores the connection settings, and processes touchscreen events.

Two Screens, One B9X Basic Application

The screens were created with the B9X Basic Screen Designer and are then controlled directly from B9X Basic. Each control is assigned an element number so the program can determine exactly which control the operator touched.

The Main Screen Is Created in B9X Basic

For example, the large Push To Talk button is created with a single B9X Basic display command:

result = displayAddRoundedButton(PTT_BUTTON, 41, 349, 239, 90, "Push To Talk", 4, 10);

The program uses the same approach for the microphone meter, battery meter, connection lamp, speaker-volume slider and other controls. A background bitmap stored in SPIFFS supplies the graphical background:

result = displayAddBmpFromFile(0, 0, 0, "/spiffs/background.bmp", 0);

This makes the user interface customizable. The supplied application is ready to use, but it can also become the starting point for a completely different B9X Basic communications application.

Connecting to the B9X Voice Server

The vConnect() function reads the Host, Port and Password directly from the configuration screen:

let host$=trim$(displayGetText$(TXT_HOST));
port=val(trim$(displayGetText$(TXT_PORT)));
let password$=trim$(displayGetText$(PTXT_PASSWORD));

The settings are saved in nonvolatile storage so they can be restored later:

retVal=setNVS("fHost", host$);
retVal=setNVS("fPort", str$(port));
retVal=setNVS("fPassword", password$);

The application then asks the VOIP system to connect to the B9X Voice Server:

retVal=voipConnect(host$, port, password$, "MYNODE", b9x_key2$);

for i=0 to 40 do
    retVal=voipIsConnected();

    if retVal==1 then
        retVal=voipStartListening();
        return 1;
    endif

    x=wait(250);
next

Push To Talk Really Is Push To Talk

The touchscreen produces events that can be retrieved with getDisplayMessage$(). The application examines those events to determine which control was operated.

When the operator presses the Push To Talk button, the application starts transmitting:

if event==B9X_DISPLAY_PRESSED then
    if number==PTT_BUTTON then
        isSending=1;
        retVal=voipStartSending();
    endif
endif

Releasing the button stops transmission:

if event==B9X_DISPLAY_RELEASED then
    if number==PTT_BUTTON then
        isSending=0;
        retVal=voipHaltSending();
    endif
endif

Live Microphone Level

While transmitting, the program retrieves the current microphone level and displays it on the vertical Mic meter:

micLevel=voipGetMicLevel();

if isSending==1 then
    retVal=displaySetValue(MICLEVEL_VBAR, micLevel);
else
    retVal=displaySetValue(MICLEVEL_VBAR, 0);
endif

This gives the operator immediate visual feedback while talking.

Speaker Volume From the Touchscreen

The speaker-volume control is a normal touchscreen slider. When its value changes, the new value is sent directly to the VOIP audio system:

if event==B9X_DISPLAY_VALUE_CHANGED then
    if number==SPKVOL_SLIDER then
        retVal=voipSetVolume(value);
    endif
endif

There is no separate settings application required. The touchscreen control and the audio system are tied together directly in the B9X Basic program.

Connection Status at a Glance

The program continually checks the Voice Server connection. The Connected lamp on the main screen follows the actual connection state:

retVal=voipIsConnected();

if retVal==1 then
    retVal=displaySetChecked(CONNECTED_LAMP, 1);
else
    retVal=displaySetChecked(CONNECTED_LAMP, 0);
endif

Battery Monitoring

Battery level is also updated continuously and displayed on the touchscreen:

let blevel=batteryLevel();
retVal=displaySetValue(BATTERY_VBAR, blevel);

The result is a radio-style interface where the operator can see the battery condition without leaving the main screen.

Automatic Display Dimming

The application even handles display power management. User interaction restores full brightness. After approximately ten seconds without a touchscreen event, the program reduces the display brightness:

if (getTicks(1)-ticks)>10000 then
    ticks=getTicks(1);
    retVal=displaySetBrightness(5);
endif

When another display message arrives, the program returns the display to full brightness:

ticks=getTicks(1);
retVal=displaySetBrightness(100);

The Event-Driven Main Loop

At the center of the application is a straightforward B9X Basic while loop. It updates the battery, connection indicator and microphone meter, then checks the display event queue for user activity.

The helper function getNthField$() extracts information from the display message so the application can obtain the element number, event type and current value.

let dmsg$=getDisplayMessage$();

if len(dmsg$)>0 then
    number=val(getNthField$(2, dmsg$));
    event=val(getNthField$(4, dmsg$));
    value=val(getNthField$(5, dmsg$));
endif

From there, ordinary B9X Basic if statements decide what the application should do.

What the Included Source Demonstrates