frontend.c File Reference

#include <stdio.h>
#include "midas.h"
#include <termios.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>

Go to the source code of this file.

Functions
INT	vacuum_gauge_read (char *pevent, INT off)
INT	frontend_early_init ()
INT	pre_begin_of_run ()
INT	poll_event (INT source[], INT count, BOOL test)
INT	interrupt_configure (INT cmd, INT source[], PTYPE adr)
INT	frontend_init ()
INT	frontend_exit ()
INT	frontend_loop ()
INT	begin_of_run (INT run_number, char *error)
INT	end_of_run (INT run_number, char *error)
INT	pause_run (INT run_number, char *error)
INT	resume_run (INT run_number, char *error)

Variables
INT	crate_number =10
HNDLE	hDB
HNDLE	hKey
int	size
char *	frontend_name = "VacuumMonitor"
char *	frontend_file_name = __FILE__
BOOL	frontend_call_loop = TRUE
INT	display_period = 1000
INT	max_event_size = 10000
INT	max_event_size_frag = 5 * 1024 * 1024
INT	event_buffer_size = 10 * 10000
static int	vacuum
static struct termios	vacuum_config
static struct timeval	vac_timeout
static fd_set	vac_ready
static const char	vacuum_port [] = "/dev/ttyS0"
static const	resp_size = 256
static char	resp [256]
static int	missed_reads
static const char	NUL = '\x00'
static const char	ACK = '\x06'
static const char	NAK = '\x15'
static const char	ENQ = '\x05'
static const char	ETX = '\x03'
static const char	LF = '\n'
static const char	CR = '\r'
static const char	EOM [] = "\n\r"
static const char	INQ_MODE [] = "PR1\r\n"
static const char	CONT_MODE [] = "COM,1\r\n"
static const char	SETPNT_STAT [] = "SPS\r\n"
static const char	SETPNT_1 [] = "SP1\r\n"
static const char	SETPNT_2 [] = "SP2\r\n"
BANK_LIST	vacuum_bank_list []
EQUIPMENT	equipment []

Function Documentation

INT begin_of_run	(	INT	run_number,
		char *	error
	)

Definition at line 267 of file frontend.c.

References readout_module::bor, diag_print(), i, num_periodic_modules, num_trigger_modules, status, and SUCCESS.

{
   return CM_SUCCESS;
}

INT end_of_run	(	INT	run_number,
		char *	error
	)

Definition at line 274 of file frontend.c.

References diag_print(), readout_module::eor, i, num_periodic_modules, num_trigger_modules, status, and SUCCESS.

{
   return CM_SUCCESS;
}

INT frontend_early_init

(

void

)

Definition at line 118 of file frontend.c.

{
  return CM_SUCCESS;
}

INT frontend_exit

(

void

)

Definition at line 253 of file frontend.c.

References readout_module::exit, i, num_periodic_modules, num_trigger_modules, and SUCCESS.

{
  return CM_SUCCESS;
}

INT frontend_init

(

void

)

Definition at line 139 of file frontend.c.

References ACK, hDB, i, readout_module::init, INQ_MODE, missed_reads, num_periodic_modules, num_trigger_modules, odb_get_int(), printf(), resp, run_state, status, SUCCESS, vac_ready, vac_timeout, vacuum, vacuum_config, and vacuum_port.

                    {
  int ret, err;
  cm_get_experiment_database(&hDB, NULL);

  // Open serial port for vacuum
  vacuum = open(vacuum_port, O_RDWR | O_NOCTTY);
  printf("Opening vacuum gauge port...");
  if (vacuum < 0) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Error opening vacuum gauge (errno %d)", err);
    return FE_ERR_HW;
  }
  printf("done.\n");
  printf("Getting current serial port attributes...");
  ret = tcgetattr(vacuum, &vacuum_config);
  if (ret < 0) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Error getting vacuum gauge serial port attributes (errno %d)", err);
    return FE_ERR_HW;
  }
  printf("done.\n");

  /**********************************************************/
  /*** Serial Modes ***/
  /* Disable everything */
  vacuum_config.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR |
                             IGNPAR | INLCR | INPCK | ISTRIP |
                             IUCLC  | IXANY | IXOFF | IXON   |
                             PARMRK);
  vacuum_config.c_oflag &= ~(OPOST);
  vacuum_config.c_cflag &= ~(CLOCAL | CREAD  | CSIZE | CSTOPB |
                             HUPCL  | PARENB | PARODD);
  vacuum_config.c_lflag &= ~(ECHO   | ECHOE  | ECHOK | ECHONL |
                             ICANON | IEXTEN | ISIG  | NOFLSH |
                             TOSTOP | XCASE);
  /* Input */
  // Nothing.
  /* Output */
  // Nothing.
  /* Local */
  vacuum_config.c_cflag |= CLOCAL;        // Do not become owner of device?
  vacuum_config.c_cflag |= CREAD;         // Enable reading
  vacuum_config.c_cflag |= (CSIZE & CS8); // 8-bit bytes
  cfsetispeed(&vacuum_config, B9600);     // Default baudrate for vacuum is 9600
  cfsetospeed(&vacuum_config, B9600);     // Default baudrate for vacuum is 9600
  /* Control */
  vacuum_config.c_cc[VTIME] = 10;         // Interbyte timeout of 1 sec
  vacuum_config.c_cc[VMIN]  = 28;         // Longest msg is 2 measurements, 28 chars
  /*** Timeout ***/
  vac_timeout.tv_sec = 1;                 // Timeout to check if buffer is ready to read is 1 sec
  vac_timeout.tv_usec = 0;                // And 0 microseconds
  /**********************************************************/

  // Apply the attributes
  printf("Setting new serial port attributes...");
  ret = tcsetattr(vacuum, TCSAFLUSH, &vacuum_config); // Flush the output, discard input, and apply changes
  if (ret < 0) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Error setting vacuum gauge serial port attributes (errno %d)", err);
    return FE_ERR_HW;
  }
  printf("done.\n");

  // Tell the vacuum gauge to await an inquiry
  printf("Setting vacuum gauge to measurement request mode...");
  ret = write(vacuum, INQ_MODE, sizeof(INQ_MODE)-1);
  if (ret < 0) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Error writing to vacuum gauge to set inquire mode (errno %d)", errno);
    return FE_ERR_HW;
  }
  printf("done.\n");
  printf("Checking vacuum acknowledgement...");

  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);  
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Vacuum gauge did not acknowledge measurement request mode (nothing received)");
    return FE_ERR_HW;
  }
  ret = read(vacuum, resp, 3);
  if (ret < 0) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Vacuum gauge did not acknowledge measurement request mode (errno %d)", errno);
    return FE_ERR_HW;
  } else if (resp[0] != ACK) {
    err = errno;
    printf("failed!\n");
    cm_msg(MERROR, "vacuum_gauge_init",
           "Vacuum gauge did not acknowledge measurement request mode (something other than ACK received)");
    return FE_ERR_HW;
  }
  printf("done.\n");

  missed_reads = 0;

  return CM_SUCCESS;
}

INT frontend_loop

(

void

)

Definition at line 260 of file frontend.c.

References consider_start(), FE_END_BLOCK, FE_NEED_STOP, i, num_trigger_modules, run_state, status, stop_cycle(), SUCCESS, and TRUE.

{
  return CM_SUCCESS;
}

INT interrupt_configure	(	INT	cmd,
		INT	source[],
		PTYPE	adr
	)

Definition at line 132 of file frontend.c.

{
   return 1;
};

INT pause_run	(	INT	run_number,
		char *	error
	)

Definition at line 281 of file frontend.c.

References SUCCESS.

{
   return CM_SUCCESS;
}

INT poll_event	(	INT	source[],
		INT	count,
		BOOL	test
	)

Definition at line 128 of file frontend.c.

{
   return 1;
};

INT pre_begin_of_run

(

)

Definition at line 123 of file frontend.c.

{
  return CM_SUCCESS;
}

INT resume_run	(	INT	run_number,
		char *	error
	)

Definition at line 288 of file frontend.c.

References SUCCESS.

{
   return CM_SUCCESS;
}

INT vacuum_gauge_read	(	char *	pevent,
		INT	off
	)

Definition at line 295 of file frontend.c.

References ACK, ENQ, i, INQ_MODE, missed_reads, NUL, printf(), resp, SETPNT_1, SETPNT_2, SETPNT_STAT, status, vac_ready, vac_timeout, and vacuum.

                                             {

  // Work variables
  static int    i;                   // Looping
  static int    ret,           err;  // Error reporting
  static INT    stat;                // Temperaroy status holder for print statements
  // All of the numbers we're measuring
  static INT   *status;              // Status of gauge
  static BOOL  *sp1,          *sp2;  // Set points on or off
  static float *sp1l,         *sp1h; // First set point lower and upper trigger
  static float *sp2l,         *sp2h; // Second set point lower and upper trigger
  static float *pres;                // Pressure reading
  // And their corresponding strings (with terminating NULL)
  // Status:         1 character
  // Measurements:  10 characters
  static char  status_str[1+1];
  static char  sp1_str[1+1],   sp2_str[1+1];
  static char  sp1l_str[10+1], sp1h_str[10+1];
  static char  sp2l_str[10+1], sp2h_str[10+1];
  static char  pres_str[10+1];
  // Null terminate for conversion to numbers
  status_str[1] = NUL;
  sp1_str[1] = NUL; sp2_str[1] = NUL;
  sp1l_str[10] = NUL; sp1h_str[10] = NUL;
  sp2l_str[10] = NUL; sp2h_str[10] = NUL;
  pres_str[10] = NUL;

  // Keep track of erroneous calls to this function. Reset at end.
  missed_reads++;

  /*** Get status of set points ***/
  // Set mode (status)
  ret = write(vacuum, SETPNT_STAT, sizeof(SETPNT_STAT)-1);
  if (ret < 0) {
    err = errno;
    printf("Error writing to vacuum gauge to enable set point request mode (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not acknowledge set point request mode (nothing received)\n");
    return 0;
  }
  ret = read(vacuum, resp, 3);
  if (ret < 0) {
    err = errno;
    printf("Vacuum gauge did not acknowledge set point request mode (errno %d)\n", err);
    return 0;
  } else if (resp[0] != ACK) {
    printf("Vacuum gauge did not acknowledge set point request mode (something other than ACK received)\n");
    return 0;
  }
  // Request set points
  ret = write(vacuum, &ENQ, sizeof(ENQ));
  if (ret < 0){
    err = errno;
    printf("Error writing to vacuum gauge to request status of set points (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not send status of set points.\n");
    return 0;
  }
  ret = read(vacuum, resp, 9);
  if (ret < 0) {
    err = errno;
    printf("Error reading status of set points from vacuum gaige (errno %d)\n", err);
    return 0;
  } else if (ret != 9) {
    printf("Received incorrect response size (expected 9, received %d)", ret);
    return 0;
  }
  // Record status
  sp1_str[0] = resp[0];
  sp2_str[0] = resp[2];

  /*** Get set point values ***/
  /* SP1 */
  // Set mode
  ret = write(vacuum, SETPNT_1, sizeof(SETPNT_1)-1);
  if (ret < 0) {
    err = errno;
    printf("Error writing to vacuum gauge to enable set point request mode (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not acknowledge set point request mode (nothing received)\n");
    return 0;
  }
  ret = read(vacuum, resp, 3);
  if (ret < 0) {
    err = errno;
    printf("Vacuum gauge did not acknowledge set point request mode (errno %d)\n", err);
    return 0;
  } else if (resp[0] != ACK) {
    printf("Vacuum gauge did not acknowledge set point request mode (something other than ACK received)\n");
    return 0;
  }
  // Request set points
  ret = write(vacuum, &ENQ, sizeof(ENQ));
  if (ret < 0){
    err = errno;
    printf("Error writing to vacuum gauge to request status of set points (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not send status of set points.\n");
    return 0;
  }
  ret = read(vacuum, resp, 25);
  if (ret < 0) {
    err = errno;
    printf("Error reading status of set points from vacuum gaige (errno %d)\n", err);
    return 0;
  } else if (ret != 9) {
    printf("Received incorrect response size (expected 25, received %d)\n", ret);
    return 0;
  }
  if (resp[0] != '1') {
    printf("Received incorrect set point value (expect 1, received %c)\n", resp[0]);
    return 0;
  }
  for (i = 0; i < 10; i++) {
    sp1l_str[i] = resp[i + 2];
    sp1h_str[i] = resp[i + 13];
  }
  /* SP2 */
  // Set mode
  ret = write(vacuum, SETPNT_2, sizeof(SETPNT_2)-1);
  if (ret < 0) {
    err = errno;
    printf("Error writing to vacuum gauge to enable set point request mode (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not acknowledge set point request mode (nothing received)\n");
    return 0;
  }
  ret = read(vacuum, resp, 3);
  if (ret < 0) {
    err = errno;
    printf("Vacuum gauge did not acknowledge set point request mode (errno %d)\n", err);
    return 0;
  } else if (resp[0] != ACK) {
    printf("Vacuum gauge did not acknowledge set point request mode (something other than ACK received)\n");
    return 0;
  }
  // Request set points
  ret = write(vacuum, &ENQ, sizeof(ENQ));
  if (ret < 0){
    err = errno;
    printf("Error writing to vacuum gauge to request status of set points (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not send status of set points.\n");
    return 0;
  }
  ret = read(vacuum, resp, 25);
  if (ret < 0) {
    err = errno;
    printf("Error reading status of set points from vacuum gaige (errno %d)\n", err);
    return 0;
  } else if (ret != 9) {
    printf("Received incorrect response size (expected 25, received %d)\n", ret);
    return 0;
  }
  if (resp[0] != '2') {
    printf("Received incorrect set point value (expect 2, received %c)\n", resp[0]);
    return 0;
  }
  for (i = 0; i < 10; i++) {
    sp2l_str[i] = resp[i + 2];
    sp2h_str[i] = resp[i + 13];
  }
  
  /*** Get pressure and status of gauge ***/
  // Set mode
  ret = write(vacuum, INQ_MODE, sizeof(INQ_MODE)-1);
  if (ret < 0) {
    err = errno;
    printf("Error writing to vacuum gauge to set inquire mode (errno %d)\n", err);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);  
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Vacuum gauge did not acknowledge measurement request mode (nothing received)\n");
    return 0;
  }
  ret = read(vacuum, resp, 3);
  if (ret < 0) {
    err = errno;
    printf("Vacuum gauge did not acknowledge measurement request mode (errno %d)\n", errno);
    return 0;
  } else if (resp[0] != ACK) {
    err = errno;
    printf("Vacuum gauge did not acknowledge measurement request mode (something other than ACK received)\n");
    return 0;
  }  
  // Request pressure
  ret = write(vacuum, &ENQ, sizeof(ENQ));
  if (ret < 0) {
    printf("Cannot write to vacuum gauge to request measurement (errno %d)", errno);
    return 0;
  }
  FD_ZERO(&vac_ready);
  FD_SET(vacuum, &vac_ready);
  select(FD_SETSIZE, &vac_ready, NULL, NULL, &vac_timeout);
  if(!FD_ISSET(vacuum, &vac_ready)) {
    printf("Nothing to be read from vacuum gauge");
    return 0;
  }
  ret = read(vacuum, resp, 15);
  if (ret < 0) {
    printf("Cannot read from vacuum gauge to get requested reading (errno %d)", errno);
    return 0;
  } else if (ret != 15) {
    printf("Received incorrect size response (expected 15, received %d)", ret);
    return 0;
  }
  status_str[0] = resp[0];
  for (i = 0; i < 10; i++) {
    pres_str[i] = resp[i + 4];
  }

  // Record in banks
  bk_init(pevent);
  bk_create(pevent, "PRS0", TID_INT, &status);
  *status++ = atoi(status_str); stat = *status;
  bk_close(pevent, status);
  bk_create(pevent, "PRM0", TID_FLOAT, &pres);
  *pres++ =   atof(pres_str);
  bk_close(pevent, pres);
  bk_create(pevent, "SP1S", TID_BOOL, &sp1);
  *sp1++ =    atoi(sp1_str);
  bk_close(pevent, sp1);
  bk_create(pevent, "SP2S", TID_BOOL, &sp2);
  *sp2 =      atoi(sp2_str);
  bk_close(pevent, sp2);
  bk_create(pevent, "SP1L", TID_FLOAT, &sp1l);
  *sp1l =     atof(sp1l_str);
  bk_close(pevent, sp1l);
  bk_create(pevent, "SP1H", TID_FLOAT, &sp1h);  
  *sp1h =     atof(sp1h_str);
  bk_close(pevent, sp1h);
  bk_create(pevent, "SP2L", TID_FLOAT, &sp2l);
  *sp2l =     atof(sp2l_str);
  bk_close(pevent, sp2l);
  bk_create(pevent, "SP2H", TID_FLOAT, &sp2h);
  *sp2h =     atof(sp2h_str);
  bk_close(pevent, sp2h);
  
  // Report on bad status
  
  switch (stat) {
  case 0:                                                                break;
  case 1:  printf("Vacuum gauge under range.\n");                        break;
  case 2:  printf("Vacuum gauge over range.\n");                         break;
  case 3:  printf("Vacuum gauge error.\n");                              break;
  case 4:  printf("Vacuum gauge off.\n");                                break;
  case 5:  printf("Vacuum gauge not attached.\n");                       break;
  case 6:  printf("Vacuum gauge unidentifiable.\n");                     break;
  default: printf("Vacuum gauge unknown status (status %d)\n", *status); break;
  }

  // Had a succesful read.
  missed_reads = 0;

  return bk_size(pevent);
}

Variable Documentation

const char ACK = '\x06'

static

Definition at line 58 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

const char CONT_MODE[] = "COM,1\r\n"

static

Definition at line 66 of file frontend.c.

const char CR = '\r'

static

Definition at line 63 of file frontend.c.

INT crate_number =10

Definition at line 17 of file frontend.c.

INT display_period = 1000

Definition at line 36 of file frontend.c.

const char ENQ = '\x05'

static

Definition at line 60 of file frontend.c.

Referenced by vacuum_gauge_read().

const char EOM[] = "\n\r"

static

Definition at line 64 of file frontend.c.

EQUIPMENT equipment[]

Initial value:

= {
   {"VacuumMonitor",       
     { 24, 0,              
       "SYSTEM",           
       EQ_PERIODIC,        
       0,                  
       "MIDAS",            
       TRUE,               
       RO_ALWAYS | RO_ODB, 
       10000,              
       0,                  
       0,                  
       0,                  
       "", "", "", },
    vacuum_gauge_read,     
    NULL, NULL, 
    vacuum_bank_list,
   },

   {""}
}

Definition at line 88 of file frontend.c.

const char ETX = '\x03'

static

Definition at line 61 of file frontend.c.

INT event_buffer_size = 10 * 10000

Definition at line 45 of file frontend.c.

BOOL frontend_call_loop = TRUE

Definition at line 33 of file frontend.c.

char* frontend_file_name = __FILE__

Definition at line 30 of file frontend.c.

char* frontend_name = "VacuumMonitor"

Definition at line 28 of file frontend.c.

HNDLE hDB

Definition at line 19 of file frontend.c.

HNDLE hKey

Definition at line 20 of file frontend.c.

const char INQ_MODE[] = "PR1\r\n"

static

Definition at line 65 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

const char LF = '\n'

static

Definition at line 62 of file frontend.c.

INT max_event_size = 10000

Definition at line 39 of file frontend.c.

INT max_event_size_frag = 5 * 1024 * 1024

Definition at line 42 of file frontend.c.

int missed_reads

static

Definition at line 55 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

const char NAK = '\x15'

static

Definition at line 59 of file frontend.c.

const char NUL = '\x00'

static

Definition at line 57 of file frontend.c.

Referenced by vacuum_gauge_read().

char resp[256]

static

Definition at line 54 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

const resp_size = 256

static

Definition at line 53 of file frontend.c.

const char SETPNT_1[] = "SP1\r\n"

static

Definition at line 68 of file frontend.c.

Referenced by vacuum_gauge_read().

const char SETPNT_2[] = "SP2\r\n"

static

Definition at line 69 of file frontend.c.

Referenced by vacuum_gauge_read().

const char SETPNT_STAT[] = "SPS\r\n"

static

Definition at line 67 of file frontend.c.

Referenced by vacuum_gauge_read().

int size

Definition at line 21 of file frontend.c.

fd_set vac_ready

static

Definition at line 51 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

struct timeval vac_timeout

static

Definition at line 50 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

int vacuum

static

Definition at line 48 of file frontend.c.

Referenced by frontend_init(), and vacuum_gauge_read().

BANK_LIST vacuum_bank_list[]

Initial value:

= {
  { "PRS0", TID_INT,   1, NULL },
  { "PRM0", TID_FLOAT, 1, NULL },
  { "SP1S", TID_BOOL,  1, NULL },
  { "SP2S", TID_BOOL,  1, NULL },
  { "SP1L", TID_FLOAT, 1, NULL },
  { "SP1H", TID_FLOAT, 1, NULL },
  { "SP2L", TID_FLOAT, 1, NULL },
  { "SP2H", TID_FLOAT, 1, NULL },
  { "" },
}

Definition at line 74 of file frontend.c.

struct termios vacuum_config

static

Definition at line 49 of file frontend.c.

Referenced by frontend_init().

const char vacuum_port[] = "/dev/ttyS0"

static

Definition at line 52 of file frontend.c.

Referenced by frontend_init().