Modifying "RVAL" for an AI Record

[XavSPM]

Hello,

I'm doing some tests to familiarize myself with pythonSoftIOC.

In one of my tests, I wanted to modify "RVAL" of an AI record in order to use "ASLO" for value conversion. Unfortunately, I get an error.

Is it possible to do this with pythonSoftIOC?
Is there something I'm not doing correctly?

Xavier

Error return:

############################################################################
## EPICS 7.0.7.0
## Rev. 7.0.7.99.0.2
## Rev. Date 7.0.7.99.0.2
############################################################################
iocRun: All initialization complete
Python 3.12.1 (main, Dec  8 2023, 00:00:00) [GCC 13.2.1 20231205 (Red Hat 13.2.1-6)] on linux
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> NON : PULSING:AO Valeur : 99.0 Vrai : 603
ERROR:root:Exception when running dispatched callback
Traceback (most recent call last):
  File "/home/[email protected]/Projet/IOC/pulsing/V_Python/python3/lib64/python3.12/site-packages/softioc/asyncio_dispatcher.py", line 45, in async_wrapper
    await ret
  File "/home/[email protected]/Projet/IOC/pulsing/V_Python/ioc_pulseur.py", line 9, in update_ao
    ai.set_field('RVAL',str(ao.get_field('RVAL')))
  File "/home/[email protected]/Projet/IOC/pulsing/V_Python/python3/lib64/python3.12/site-packages/softioc/device.py", line 106, in set_field
    db_put_field(name, fields.DBF_STRING, addressof(data), 1)
  File "/home/[email protected]/Projet/IOC/pulsing/V_Python/python3/lib64/python3.12/site-packages/softioc/imports.py", line 24, in db_put_field
    return _extension.db_put_field(name, dbr_type, pbuffer, length)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: dbPutField failed for PULSING:AI.RVAL

My code :

from softioc import softioc, builder, asyncio_dispatcher
import asyncio

dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.SetDeviceName("PULSING")

async def update_ao(value, pv):
    print('NON : {0} Valeur : {1} Vrai : {2}'.format(pv, value, ao.get_field('RVAL')))
    ai.set_field('RVAL',str(ao.get_field('RVAL')))
    print('NON : {0} Valeur : {1} Vrai : {2}'.format(pv, ai.get(), ai.get_field('RVAL')))

ao = builder.aOut('AO',
                ASLO="0.1642",
                EGU="us", 
                DRVH="2820934519.356", 
                DRVL="0.1642", 
                PREC="4",
                on_update_name=update_ao)

ai = builder.aIn('AI', 
                ASLO="0.1642", 
                EGU="us", 
                HOPR="2820934519.356", 
                LOPR="0.1642", 
                PREC="4"
                )

builder.LoadDatabase()
softioc.iocInit(dispatcher)

#async def update():
#    while True:
#        ai.set(ai.get() + 1)
#        await asyncio.sleep(1)

#dispatcher(update)
softioc.interactive_ioc(globals())

[Araneidae]

There are a couple of issues here.

First of all, all channel access writes to In records are automatically disabled by pythonSoftIOC (by setting .DISA), because doing this is almost always a mistake ... as it is here!

Secondly, softIOC device ai/ao records do not use RVAL or any record scaling features, instead device support works directly on the underlying floating point value.

If you really want ai/ao records with value conversion support you can always use softioc.builder.records to create records without softIOC device support.

[XavSPM]

Hello,

Thank you for your explanation. I suspected that it was not possible, but I wanted a confirmation. Since the conversion worked with an ao, I was wondering if it could also work with an ai.

Therefore, it's better to implement a conversion in Python functions rather than through the underlying IOC. I will keep this in mind when designing my programs.

I wish you a happy holiday season.

Xavier

[Araneidae]

I'm surprised that you say the conversion worked with an ao record. I would expect the .ASLO field to simply be ignored, but writeable.

[XavSPM]

I can confirm that it works with an AO. You can test it with this piece of code:

from softioc import softioc, builder, asyncio_dispatcher
import asyncio

dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.SetDeviceName("PULSING")

async def update_ao(value, pv):
    print('NAM : {0} VAL : {1} RVAL : {2}'.format(pv, value, ao.get_field('RVAL')))

ao = builder.aOut('AO',
                ASLO="0.1642",
                EGU="us", 
                DRVH="2820934519.356", 
                DRVL="0.1642", 
                PREC="4",
                on_update_name=update_ao)

builder.LoadDatabase()
softioc.iocInit(dispatcher)
softioc.interactive_ioc(globals())

I find this function very useful, because in a program I want to use it to send information to an electronic board using the SPI protocol. And it guarantees that the value is an int_32.

A simple way of incorporating this into an ai would be to modify the set() function for an ai so that it writes to .RVAL. And set the default value to LINR="NO CONVERSION" so that, by default, VAL=RVAL. This solution would allow developers to modify LINR as required.

After that, I confess I didn't look at the code to see if it could be easily implemented.

[Araneidae]

Ah yes, I understand why you get the result you want with AO but not with AI. But ... don't do that, please!

PythonSoftIOC deliberately does not do conversions and takes care to bypass any conversions built into the record type: an AI or AO is the true floating point value that you are reading or writing to that record. Personally I feel that record level programming in EPICS is archaic!

If you want to do conversion for hardware IO, I think you have two choices:

1. Do the conversion in the driver support, in the IOC code itself. This is straightforward and Python is good at simple arithmetic.
2. Or, if you insist on doing the conversion in the EPICS layer, you can create a pair of records, for example:

   from softioc import softioc, builder, asyncio_dispatcher
   import asyncio
   
   dispatcher = asyncio_dispatcher.AsyncioDispatcher()
   builder.SetDeviceName("PULSING")
   
   async def update_raw_ao(value, pv):
       print('NAM : {0} VAL : {1}'.format(pv, value))
   
   ao = builder.records.ao('AO',
       ASLO="0.1642",
       EGU="us",
       DRVH="2820934519.356",
       DRVL="0.1642",
       PREC="4")
   
   raw_ao = builder.longOut('AO_RAW',
       DOL = ao.RVAL,
       OMSL = "closed_loop",
       on_update_name = update_raw_ao)
   ao.FLNK = raw_ao
   
   builder.LoadDatabase()
   softioc.iocInit(dispatcher)
   softioc.interactive_ioc(globals())

The same trick should work with ai: create a builder.records.ai instance to do the translation, and use a builder.longIn instance to read directly from the hardware.

[XavSPM]

Thank you for your feedback.

I share your opinion. I find it easier to convert the data within the Python script than through the record. I have conducted these tests to better grasp pythonSoftIOC and to understand its mechanics.

If I understand correctly, pythonSoftIOC offers the simplest possible record creation, and it is within the Python script that we design the various mechanisms for calculation, verification, and the security necessary for our use.

I will therefore focus on the first suggestion you offered me in order to stay in line with the philosophy of pythonSoftIOC.

Thank you for your help.

Xavier