Miscellaneous Projects » Core testing infrastructure

/*

 * Send a tone and write received data to a file on SIMCom SIM7100E.

 *

 * Format is PCM 16bit, 8kHz, Mono, LE

 * https://lists.freedesktop.org/archives/modemmanager-devel/2016-April/002904.html

 *

 * Send 640 bytes every 40ms, as per

 * http://simcom.ee/documents/SIM5360/SIM5360_USB_AUDIO_Application_Note_V1.01.pdf 

 *

 * Copyright 2018 Purism SPC

 *

 * SPDX-License-Identifier: GPL-3.0-or-later

 *

 * Written by Bob Ham <bob.ham@puri.sm>

 */

/*

 * To compile:

 *

 *   make simcom-tone

 *

 * To use, first on the AT command TTY, /dev/ttyUSB2:

 *

 *   ATD0123456789;

 *   OK

 *   AT+CPCMREG=1

 *   OK

 *

 * Then run this program:

 *

 *   ./simcom-tone /dev/ttyUSB4 recording.raw

 *

 * Answer the call, speak a bit, hang up.  Hit Ctrl+C to end

 * simcom-tone.

 *

 * To listen to the recording, something like this is expected to

 * work:

 *

 *   aplay -r 8000 -f S16_LE -c 1 recording.raw

 *

 */

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdint.h>

#include <sys/time.h>

#include <stdbool.h>

#define FRAME_LEN	640

#define US_PER_MS	1000

#define PERIOD_US	(40 * US_PER_MS)

static const struct timeval TIME_PERIOD = { 0, PERIOD_US };

static const struct timeval TIME_ZERO = { 0, 0 };

static int prepare_frame (void *frame, size_t len)

{

  static const uint16_t TONE_SAMPLES[2] = { 0, 0xFFFF };

  const size_t FRAME_SAMPLES = len / sizeof(uint16_t);

  size_t i;

  uint16_t *samples = frame;

  for (i = 0; i < FRAME_SAMPLES; ++i)

    {

      samples[i] = TONE_SAMPLES[i % 2];

    }

}

static ssize_t checked_write(int fd, const void *buf,

			     size_t count, const char *desc)

{

  ssize_t write_len;

  write_len = write (fd, buf, count);

  if (write_len == -1)

    {

      fprintf (stderr, "Error writing to %s: %s\n",

	       desc, strerror (errno));

      return -1;

    }

  if (write_len != count)

    {

      fprintf (stderr,

	       "Short write of %zi bytes to %s (should be %i)\n",

	       write_len, desc, count);

      return -1;

    }

  return 0;

}

static int write_frame (int fd, void *frame)

{

  ssize_t err;

  err = checked_write (fd, frame, FRAME_LEN, "audio port");

  if (err == 0)

    {

      fprintf (stderr, "Wrote frame\n");

    }

  return err;

}

static int read_block (int device, int recording)

{

  uint8_t block[1600];

  ssize_t read_len;

  read_len = read (device, block, sizeof(block));

  if (read_len == -1)

    {

      fprintf (stderr, "Error reading: %s\n",

	       strerror (errno));

      return -1;

    }

  fprintf (stderr, "Read %zi (block size %zu)\n",

	   read_len, sizeof(block));

  return (int) checked_write (recording, block, read_len,

			      "recording file");

}

static struct timeval calc_wait (struct timeval *next_write)

{

  struct timeval now;

  gettimeofday (&now, NULL);

  if (timercmp (next_write, &now, >))

    {

      struct timeval wait;

      timersub (next_write, &now, &wait);

      return wait;

    }

  return TIME_ZERO;

}

static int do_wait(int fd, struct timeval *wait_time,

		   bool *read_ready, bool *write_ready)

{

  bool need_write;

  fd_set rfds, wfds;

  fd_set *wfdsp;

  int retval;

  FD_ZERO(&rfds);

  FD_SET(fd, &rfds);

  need_write = !timercmp(wait_time, &TIME_ZERO, !=);

  if (need_write)

    {

      fprintf (stderr, "Waiting indefinitely (wait time: %u secs, %u usecs)\n",

	       (unsigned) wait_time->tv_sec,

	       (unsigned) wait_time->tv_usec);

      wait_time = NULL;

      wfdsp = &wfds;

      FD_ZERO(wfdsp);

      FD_SET(fd, wfdsp);

    }

  else

    {

      wfdsp = NULL;

      fprintf (stderr, "Waiting %u secs, %u usecs\n",

	       (unsigned) wait_time->tv_sec,

	       (unsigned) wait_time->tv_usec);

    }

  retval = select (fd + 1, &rfds, wfdsp, NULL, wait_time);

  if (retval == -1)

    {

      fprintf (stderr, "Error waiting for audio data: %s\n",

	       strerror (errno));

      return -1;

    }

  if (FD_ISSET (fd, &rfds))

    {

      *read_ready = true;

    }

  if (need_write && FD_ISSET (fd, wfdsp))

    {

      *write_ready = true;

    }

  return retval;

}

static void add_period (struct timeval *next_write)

{

  struct timeval old = *next_write;

  timeradd (&old, &TIME_PERIOD, next_write);

}

static int loop(int device, int recording)

{

  uint8_t frame[FRAME_LEN];

  struct timeval next_write, wait_time;

  int ret;

  bool read_ready, write_ready;

  prepare_frame (frame, FRAME_LEN);

  ret = write_frame (device, frame);

  if (ret == -1)

    {

      return -1;

    }

  gettimeofday (&next_write, NULL);

  add_period (&next_write);

  for (;;)

    {

      wait_time = calc_wait (&next_write);

      write_ready = read_ready = false;

      ret = do_wait (device, &wait_time, &read_ready, &write_ready);

      if (ret == -1)

	{

	  return -1;

	}

      if (read_ready)

	{

	  ret = read_block (device, recording);

	  if (ret == -1)

	    {

	      return -1;

	    }

	}

      if (write_ready)

	{

	  ret = write_frame (device, frame);

	  if (ret == -1)

	    {

	      return -1;

	    }

	  add_period (&next_write);

	}

    }

}

int checked_open (const char *filename, int flags)

{

  int fd;

  fd = open (filename, flags, 0644);

  if (fd == -1)

    {

      fprintf (stderr, "Error opening `%s': %s",

	       filename, strerror (errno));

    }

  return fd;

}

int main(int argc, char **argv)

{

  const char *device_name, *recording_name;

  int device, recording;

  if (argc < 3)

    {

      fprintf (stderr, "Usage: %s <device> <recording file>\n", argv[0]);

      return 1;

    }

  device_name = argv[1];

  recording_name = argv[2];

  device = checked_open (device_name, O_RDWR);

  if (device == -1)

    {

      return 1;

    }

  recording = checked_open (recording_name, O_WRONLY|O_CREAT|O_TRUNC);

  if (recording == -1)

    {

      return 1;

    }

  loop (device, recording);

  close (device);

  close (recording);

  return 0;

}