Commit 0c2a3a4e authored by Pedro Henrique Kopper's avatar Pedro Henrique Kopper

Add barebones SCPI handling

parent 9440a974
# List of all the board related files.
BOARDSRC = $(ROOT)/board/board.c
BOARDSRC = ./board/board.c
# Required include directories
BOARDINC = $(ROOT)/board
BOARDINC = ./board
# Shared variables
ALLCSRC += $(BOARDSRC)
......
BSD 2-Clause License
Copyright (c) 2012-2018, Jan Breuer
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/*-
* BSD 2-Clause License
*
* Copyright (c) 2012-2018, Jan Breuer
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file scpi_error.c
* @date Thu Nov 15 10:58:45 UTC 2012
*
* @brief Error handling and storing routines
*
*
*/
#include <stdint.h>
#include "scpi/parser.h"
#include "scpi/ieee488.h"
#include "scpi/error.h"
#include "fifo_private.h"
#include "scpi/constants.h"
#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION
#define SCPI_ERROR_SETVAL(e, c, i) do { (e)->error_code = (c); (e)->device_dependent_info = (i); } while(0)
#else
#define SCPI_ERROR_SETVAL(e, c, i) do { (e)->error_code = (c); (void)(i);} while(0)
#endif
/**
* Initialize error queue
* @param context - scpi context
*/
void SCPI_ErrorInit(scpi_t * context, scpi_error_t * data, int16_t size) {
fifo_init(&context->error_queue, data, size);
}
/**
* Emit no error
* @param context scpi context
*/
static void SCPI_ErrorEmitEmpty(scpi_t * context) {
if ((SCPI_ErrorCount(context) == 0) && (SCPI_RegGet(context, SCPI_REG_STB) & STB_QMA)) {
SCPI_RegClearBits(context, SCPI_REG_STB, STB_QMA);
if (context->interface && context->interface->error) {
context->interface->error(context, 0);
}
}
}
/**
* Emit error
* @param context scpi context
* @param err Error to emit
*/
static void SCPI_ErrorEmit(scpi_t * context, int16_t err) {
SCPI_RegSetBits(context, SCPI_REG_STB, STB_QMA);
if (context->interface && context->interface->error) {
context->interface->error(context, err);
}
}
/**
* Clear error queue
* @param context - scpi context
*/
void SCPI_ErrorClear(scpi_t * context) {
#if USE_DEVICE_DEPENDENT_ERROR_INFORMATION
scpi_error_t error;
while (fifo_remove(&context->error_queue, &error)) {
SCPIDEFINE_free(&context->error_info_heap, error.device_dependent_info, false);
}
#endif
fifo_clear(&context->error_queue);
SCPI_ErrorEmitEmpty(context);
}
/**
* Pop error from queue
* @param context - scpi context
* @param error
* @return
*/
scpi_bool_t SCPI_ErrorPop(scpi_t * context, scpi_error_t * error) {
if (!error || !context) return FALSE;
SCPI_ERROR_SETVAL(error, 0, NULL);
fifo_remove(&context->error_queue, error);
SCPI_ErrorEmitEmpty(context);
return TRUE;
}
/**
* Return number of errors/events in the queue
* @param context
* @return
*/
int32_t SCPI_ErrorCount(scpi_t * context) {
int16_t result = 0;
fifo_count(&context->error_queue, &result);
return result;
}
static scpi_bool_t SCPI_ErrorAddInternal(scpi_t * context, int16_t err, char * info, size_t info_len) {
scpi_error_t error_value;
/* SCPIDEFINE_strndup is sometimes a dumy that does not reference it's arguments.
Since info_len is not referenced elsewhere caoing to void prevents unusd argument warnings */
(void) info_len;
char * info_ptr = info ? SCPIDEFINE_strndup(&context->error_info_heap, info, info_len) : NULL;
SCPI_ERROR_SETVAL(&error_value, err, info_ptr);
if (!fifo_add(&context->error_queue, &error_value)) {
SCPIDEFINE_free(&context->error_info_heap, error_value.device_dependent_info, true);
fifo_remove_last(&context->error_queue, &error_value);
SCPIDEFINE_free(&context->error_info_heap, error_value.device_dependent_info, true);
SCPI_ERROR_SETVAL(&error_value, SCPI_ERROR_QUEUE_OVERFLOW, NULL);
fifo_add(&context->error_queue, &error_value);
return FALSE;
}
return TRUE;
}
struct error_reg {
int16_t from;
int16_t to;
scpi_reg_val_t esrBit;
};
#define ERROR_DEFS_N 9
static const struct error_reg errs[ERROR_DEFS_N] = {
{-100, -199, ESR_CER}, /* Command error (e.g. syntax error) ch 21.8.9 */
{-200, -299, ESR_EER}, /* Execution Error (e.g. range error) ch 21.8.10 */
{-300, -399, ESR_DER}, /* Device specific error -300, -399 ch 21.8.11 */
{ 1, 32767, ESR_DER}, /* Device designer provided specific error 1, 32767 ch 21.8.11 */
{-400, -499, ESR_QER}, /* Query error -400, -499 ch 21.8.12 */
{-500, -599, ESR_PON}, /* Power on event -500, -599 ch 21.8.13 */
{-600, -699, ESR_URQ}, /* User Request Event -600, -699 ch 21.8.14 */
{-700, -799, ESR_REQ}, /* Request Control Event -700, -799 ch 21.8.15 */
{-800, -899, ESR_OPC}, /* Operation Complete Event -800, -899 ch 21.8.16 */
};
/**
* Push error to queue
* @param context
* @param err - error number
* @param info - additional text information or NULL for no text
* @param info_len - length of text or 0 for automatic length
*/
void SCPI_ErrorPushEx(scpi_t * context, int16_t err, char * info, size_t info_len) {
int i;
/* automatic calculation of length */
if (info && info_len == 0) {
info_len = SCPIDEFINE_strnlen(info, SCPI_STD_ERROR_DESC_MAX_STRING_LENGTH);
}
scpi_bool_t queue_overflow = !SCPI_ErrorAddInternal(context, err, info, info_len);
for (i = 0; i < ERROR_DEFS_N; i++) {
if ((err <= errs[i].from) && (err >= errs[i].to)) {
SCPI_RegSetBits(context, SCPI_REG_ESR, errs[i].esrBit);
}
}
SCPI_ErrorEmit(context, err);
if (queue_overflow) {
SCPI_ErrorEmit(context, SCPI_ERROR_QUEUE_OVERFLOW);
}
if (context) {
context->cmd_error = TRUE;
}
}
/**
* Push error to queue
* @param context - scpi context
* @param err - error number
*/
void SCPI_ErrorPush(scpi_t * context, int16_t err) {
SCPI_ErrorPushEx(context, err, NULL, 0);
return;
}
/**
* Translate error number to string
* @param err - error number
* @return Error string representation
*/
const char * SCPI_ErrorTranslate(int16_t err) {
switch (err) {
#define X(def, val, str) case def: return str;
#if USE_FULL_ERROR_LIST
#define XE X
#else
#define XE(def, val, str)
#endif
LIST_OF_ERRORS
#if USE_USER_ERROR_LIST
LIST_OF_USER_ERRORS
#endif
#undef X
#undef XE
default: return "Unknown error";
}
}
This diff is collapsed.
/*-
* BSD 2-Clause License
*
* Copyright (c) 2012-2018, Jan Breuer
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "fifo_private.h"
/**
* Initialize fifo
* @param fifo
*/
void fifo_init(scpi_fifo_t * fifo, scpi_error_t * data, int16_t size) {
fifo->wr = 0;
fifo->rd = 0;
fifo->count = 0;
fifo->data = data;
fifo->size = size;
}
/**
* Empty fifo
* @param fifo
*/
void fifo_clear(scpi_fifo_t * fifo) {
fifo->wr = 0;
fifo->rd = 0;
fifo->count = 0;
}
/**
* Test if fifo is empty
* @param fifo
* @return
*/
scpi_bool_t fifo_is_empty(scpi_fifo_t * fifo) {
return fifo->count == 0;
}
/**
* Test if fifo is full
* @param fifo
* @return
*/
scpi_bool_t fifo_is_full(scpi_fifo_t * fifo) {
return fifo->count == fifo->size;
}
/**
* Add element to fifo. If fifo is full, return FALSE.
* @param fifo
* @param err
* @param info
* @return
*/
scpi_bool_t fifo_add(scpi_fifo_t * fifo, const scpi_error_t * value) {
/* FIFO full? */
if (fifo_is_full(fifo)) {
return FALSE;
}
if (!value) {
return FALSE;
}
fifo->data[fifo->wr] = *value;
fifo->wr = (fifo->wr + 1) % (fifo->size);
fifo->count += 1;
return TRUE;
}
/**
* Remove element form fifo
* @param fifo
* @param value
* @return FALSE - fifo is empty
*/
scpi_bool_t fifo_remove(scpi_fifo_t * fifo, scpi_error_t * value) {
/* FIFO empty? */
if (fifo_is_empty(fifo)) {
return FALSE;
}
if (value) {
*value = fifo->data[fifo->rd];
}
fifo->rd = (fifo->rd + 1) % (fifo->size);
fifo->count -= 1;
return TRUE;
}
/**
* Remove last element from fifo
* @param fifo
* @param value
* @return FALSE - fifo is empty
*/
scpi_bool_t fifo_remove_last(scpi_fifo_t * fifo, scpi_error_t * value) {
/* FIFO empty? */
if (fifo_is_empty(fifo)) {
return FALSE;
}
fifo->wr = (fifo->wr + fifo->size - 1) % (fifo->size);
if (value) {
*value = fifo->data[fifo->wr];
}
fifo->count -= 1;
return TRUE;
}
/**
* Retrive number of elements in fifo
* @param fifo
* @param value
* @return
*/
scpi_bool_t fifo_count(scpi_fifo_t * fifo, int16_t * value) {
*value = fifo->count;
return TRUE;
}
/*-
* BSD 2-Clause License
*
* Copyright (c) 2012-2018, Jan Breuer
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file scpi_fifo.h
* @date Thu Nov 15 10:58:45 UTC 2012
*
* @brief basic FIFO implementation
*
*
*/
#ifndef SCPI_FIFO_H
#define SCPI_FIFO_H
#include "scpi/types.h"
#include "utils_private.h"
#ifdef __cplusplus
extern "C" {
#endif
void fifo_init(scpi_fifo_t * fifo, scpi_error_t * data, int16_t size) LOCAL;
void fifo_clear(scpi_fifo_t * fifo) LOCAL;
scpi_bool_t fifo_is_empty(scpi_fifo_t * fifo) LOCAL;
scpi_bool_t fifo_is_full(scpi_fifo_t * fifo) LOCAL;
scpi_bool_t fifo_add(scpi_fifo_t * fifo, const scpi_error_t * value) LOCAL;
scpi_bool_t fifo_remove(scpi_fifo_t * fifo, scpi_error_t * value) LOCAL;
scpi_bool_t fifo_remove_last(scpi_fifo_t * fifo, scpi_error_t * value) LOCAL;
scpi_bool_t fifo_count(scpi_fifo_t * fifo, int16_t * value) LOCAL;
#ifdef __cplusplus
}
#endif
#endif /* SCPI_FIFO_H */
/*-
* BSD 2-Clause License
*
* Copyright (c) 2012-2018, Jan Breuer
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @file scpi_ieee488.c
* @date Thu Nov 15 10:58:45 UTC 2012
*
* @brief Implementation of IEEE488.2 commands and state model
*
*
*/
#include "scpi/parser.h"
#include "scpi/ieee488.h"
#include "scpi/error.h"
#include "scpi/constants.h"
#include <stdio.h>
/**
* Update register value
* @param context
* @param name - register name
*/
static void regUpdate(scpi_t * context, scpi_reg_name_t name) {
SCPI_RegSet(context, name, SCPI_RegGet(context, name));
}
/**
* Update latching event register value based on bit transitions from 0 -> 1
* in the condition register
* @param context
* @param condReg - condition register name
* @param eventReg - event register name
*/
static void regUpdateEvent(scpi_t * context, scpi_reg_val_t oldCondVal, scpi_reg_val_t newCondVal, scpi_reg_name_t eventReg) {
SCPI_RegSet(context, eventReg, ((oldCondVal ^ newCondVal) & newCondVal) | SCPI_RegGet(context, eventReg));
}
/**
* Update STB register according to value and its mask register
* @param context
* @param val value of register
* @param mask name of mask register (enable register)
* @param stbBits bits to clear or set in STB
*/
static void regUpdateSTB(scpi_t * context, scpi_reg_val_t val, scpi_reg_name_t mask, scpi_reg_val_t stbBits) {
if (val & SCPI_RegGet(context, mask)) {
SCPI_RegSetBits(context, SCPI_REG_STB, stbBits);
} else {
SCPI_RegClearBits(context, SCPI_REG_STB, stbBits);
}
}
/**
* Get register value
* @param name - register name
* @return register value
*/
scpi_reg_val_t SCPI_RegGet(scpi_t * context, scpi_reg_name_t name) {
if ((name < SCPI_REG_COUNT) && context) {
return context->registers[name];
} else {
return 0;
}
}
/**
* Wrapper function to control interface from context
* @param context
* @param ctrl number of controll message
* @param value value of related register
*/
static size_t writeControl(scpi_t * context, scpi_ctrl_name_t ctrl, scpi_reg_val_t val) {
if (context && context->interface && context->interface->control) {
return context->interface->control(context, ctrl, val);
} else {
return 0;
}
}
/**
* Set register value
* @param name - register name
* @param val - new value
*/
void SCPI_RegSet(scpi_t * context, scpi_reg_name_t name, scpi_reg_val_t val) {
scpi_bool_t srq = FALSE;
scpi_reg_val_t mask;
scpi_reg_val_t old_val;
if ((name >= SCPI_REG_COUNT) || (context == NULL)) {
return;
}
/* store old register value */
old_val = context->registers[name];
/* set register value */
context->registers[name] = val;
/** @TODO: remove recutsion */
switch (name) {
case SCPI_REG_STB:
mask = SCPI_RegGet(context, SCPI_REG_SRE);
mask &= ~STB_SRQ;
if (val & mask) {
val |= STB_SRQ;
/* avoid sending SRQ if nothing has changed */
if (old_val != val) {
srq = TRUE;
}
} else {
val &= ~STB_SRQ;
}
break;
case SCPI_REG_SRE:
regUpdate(context, SCPI_REG_STB);
break;
case SCPI_REG_ESR:
regUpdateSTB(context, val, SCPI_REG_ESE, STB_ESR);
break;
case SCPI_REG_ESE:
regUpdate(context, SCPI_REG_ESR);
break;
case SCPI_REG_QUES:
regUpdateSTB(context, val, SCPI_REG_QUESE, STB_QES);
break;
case SCPI_REG_QUESE:
regUpdate(context, SCPI_REG_QUES);
break;
case SCPI_REG_QUESC:
regUpdateEvent(context, old_val, val, SCPI_REG_QUES);
break;
case SCPI_REG_OPER:
regUpdateSTB(context, val, SCPI_REG_OPERE, STB_OPS);
break;
case SCPI_REG_OPERE:
regUpdate(context, SCPI_REG_OPER);
break;
case SCPI_REG_OPERC:
regUpdateEvent(context, old_val, val, SCPI_REG_OPER);
break;
case SCPI_REG_COUNT:
/* nothing to do */
break;
}
/* set updated register value */
context->registers[name] = val;
if (srq) {
writeControl(context, SCPI_CTRL_SRQ, SCPI_RegGet(context, SCPI_REG_STB));
}
}
/**
* Set register bits
* @param name - register name
* @param bits bit mask
*/
void SCPI_RegSetBits(scpi_t * context, scpi_reg_name_t name, scpi_reg_val_t bits) {
SCPI_RegSet(context, name, SCPI_RegGet(context, name) | bits);
}
/**
* Clear register bits
* @param name - register name
* @param bits bit mask
*/
void SCPI_RegClearBits(scpi_t * context, scpi_reg_name_t name, scpi_reg_val_t bits) {
SCPI_RegSet(context, name, SCPI_RegGet(context, name) & ~bits);
}
/**
* Clear event register
* @param context
*/
void SCPI_EventClear(scpi_t * context) {
/* TODO */
SCPI_RegSet(context, SCPI_REG_ESR, 0);
}
/**
* *CLS - This command clears all status data structures in a device.
* For a device which minimally complies with SCPI. (SCPI std 4.1.3.2)
* @param context
* @return
*/
scpi_result_t SCPI_CoreCls(scpi_t * context) {
SCPI_EventClear(context);
SCPI_ErrorClear(context);
SCPI_RegSet(context, SCPI_REG_OPER, 0);
SCPI_RegSet(context, SCPI_REG_QUES, 0);
return SCPI_RES_OK;
}
/**
* *ESE
* @param context
* @return
*/
scpi_result_t SCPI_CoreEse(scpi_t * context) {
int32_t new_ESE;
if (SCPI_ParamInt32(context, &new_ESE, TRUE)) {
SCPI_RegSet(context, SCPI_REG_ESE, (scpi_reg_val_t) new_ESE);
return SCPI_RES_OK;
}
return SCPI_RES_ERR;
}
/**
* *ESE?
* @param context
* @return
*/
scpi_result_t SCPI_CoreEseQ(scpi_t * context) {
SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_ESE));
return SCPI_RES_OK;
}
/**
* *ESR?
* @param context
* @return
*/
scpi_result_t SCPI_CoreEsrQ(scpi_t * context) {
SCPI_ResultInt32(context, SCPI_RegGet(context, SCPI_REG_ESR));
SCPI_RegSet(context, SCPI_REG_ESR, 0);
return SCPI_RES_OK;
}
/**
* *IDN?
*
* field1: MANUFACTURE