Test measurement system and ai assistant generation method

Abstract

To provide a test measurement system and an AI assistant generation method that make an AI assistant more convenient.SOLUTION: A test measurement system includes: one or more test and measurement instruments 42, 44, and 46, including at least one test measurement instrument having one or more ports for connecting to a device under test (DUT); one or more memories including test measurement knowledge 14; and a generative artificial intelligence (AI) model connected to one or more test measurement instruments and one or more memories. One or more processors present a user interface with a prompt to a user; receive a request from the user that includes one or more tasks to be performed by the one or more test measurement instruments; access an application programming interface (API) of the generative AI model to convert the request into a command, transmit the command to the one or more test measurement instruments, and display output on the user interface.SELECTED DRAWING: Figure 3

Description

[Technical Field]

[0001] TECHNICAL FIELD This disclosure relates to artificial intelligence assistance, and more particularly to building artificial intelligence assistance for test and measurement equipment and environments. [Background technology]

[0002] There have been many advances in the technology surrounding artificial intelligence (AI) assistants. It is now technically possible to create AI assistants as applications. OpenAI, a US company, even maintains an app store for AI assistant extensions. To that end, OpenAI is adding extensions to its programming application programming interface (API) to allow AI assistants to add knowledge through prompts and files. OpenAI is also adding extensions to its programming API, enabling AI assistants to interact with local or web resources. This is a two-way connection, where actions are requested and responses are expected. OpenAI is also adding extensions to its programming API to allow AI assistants to add knowledge through files. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2024-20154 [Patent Document 2] Japanese Patent Application Publication No. 2023-55667 [Patent Document 3] Japanese Patent Application Laid-Open No. 2018-59912 Summary of the Invention [Problem to be solved by the invention]

[0004] A key aspect of making an AI assistant useful is providing abstraction and knowledge about the context in which the user is working, which may not be what existing large-scale language models (LLMs) have trained.

[0005] Additionally, some AI assistants are implemented as REPLs (Read / Evaluate / Print Loops), but this is not the only way to implement an AI assistant. [Means for solving the problem]

[0006] Embodiments of the present application relate to a method for building an artificial intelligence (AI) assistant focused on test and measurement (T&M) equipment. These embodiments also relate to a method for presenting a dynamic environment of a test environment using test and measurement equipment to the AI ​​assistant, thereby enabling a user to engage with the AI ​​assistant at a high level. [Brief explanation of the drawings]

[0007] [Figure 1] FIG. 1 shows a system diagram of one embodiment of a test and measurement system with an artificial intelligence (AI) assistant. [Figure 2] FIG. 2 shows an embodiment of a sequence diagram for starting the AI ​​assistant and initial prompts. [Figure 3] Figure 3 shows an example of a test set up using a computing device with an AI assistant. [Figure 4] FIG. 4 shows a system diagram of one embodiment of a test and measurement system with multiple instruments and an AI assistant. [Figure 5] Figure 5 shows an embodiment of a user response to a prompt from the AI ​​assistant and the AI ​​system response on the test and measurement instrument user interface. [Figure 6] Figure 6 shows the user interface with voice operation of the AI ​​assistant. [Figure 7] Figure 7 shows the user interface for instructing the AI ​​assistant to perform measurements. [Figure 8] Figure 8 shows the user interface with a split display showing the waveform and the Fast Fourier Transform (FFT) resulting from instructions to the AI ​​assistant. [Figure 9] Figure 9 shows the user interface of the test and measurement device after instructing the AI ​​Assistant to operate with the device on a different channel. [Figure 10] Figure 10 shows the user interface on the test and measurement device after the request and the response from the AI ​​assistant. [Figure 11] Figure 11 shows the result after the decoding process using the AI ​​assistant. [Figure 12] Figure 12 shows the user interface on the test device after receiving voice prompts in other languages. [Figure 13] Figure 13 shows the user interface on the test device after receiving voice prompts in other languages. [Figure 14] Figure 14 shows the user interface of the test and measurement instrument after receiving a request to save a screenshot. [Figure 15] Figure 15 shows an example of a waveform from a sampling oscilloscope. [Figure 16] Figure 16 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 17] Figure 17 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 18] Figure 18 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 19]Figure 19 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 20] Figure 20 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 21] Figure 21 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 22] Figure 22 shows the user interface through a series of interactions with the AI ​​assistant to take measurements using primitives and save the measurements. [Figure 23] Figure 23 shows the user interface for waveform selection and extending the measurement to another waveform. [Figure 24] Figure 24 shows the user interface for waveform selection and extending the measurement to another waveform. DETAILED DESCRIPTION OF THE INVENTION

[0008] While this disclosure describes OpenAI's APIs (Application Programming Interfaces) and technical details, the general functionality described in this disclosure applies to current and future assistant APIs. This disclosure is not specifically directed to OpenAI and its APIs. Other AI tools exist that have APIs that can be accessed, including, but not limited to, AlphaCode, GitHub / Microsoft Copilot, Duet AI, and Bard.

[0009] Currently, General Pre-trained Transforms (GPTs) and large-scale language models (LLMs) and related tools run in the cloud, at the edge, and even in the firmware of test and measurement equipment. Storing information in firmware balances the security of keeping all communications local with the ability to use the cloud to scale computations for faster, more accurate results and improved performance. Furthermore, the examples in the following description focus on the use of current GPT / LLM technology, which may include smaller, embedded LLMs in addition to larger, more well-known LLMs. However, similar behavior can be created using other tools, such as natural language processing (NLP) libraries, with other forms of machine learning. While the examples in the following description are specific to GPT / LLMs, limitation to these specific technologies is not intended or implied. Embodiments of the present application may be applied to a wide variety of current and future forms of generative AI technology.

[0010] Similarly, for ease of explanation and understanding, the following description uses the example of an oscilloscope AI assistant, but it should be understood that limitation to this type of device is not intended or implied. Instruments may include a wide variety of devices, including, but not limited to, oscilloscopes, waveform generators, function generators, digital multimeters, source measure units, spectrum analyzers, switches, etc. Generally, embodiments of the present application are applicable to any set of controllable instruments that can be used together to understand a device or environment, and can be automated using an embodiment of an assistant.

[0011] FIG. 1 illustrates the relationships among multiple entities in an embodiment of an AI assistant 10 interacting with a single instrument 18, such as an oscilloscope, such as a Tektronix® MSO58B oscilloscope. AI assistant 10 is comprised of a user-accessible software program that allows user 20 to simply interact with test and measurement equipment, such as instrument 18. User 20 launches and uses AI assistant 10, but before launching it, user 20 must configure it. As part of the configuration, AI assistant 10 receives test measurement general knowledge 14. The term “receiving” may include AI assistant 10 receiving a link to a repository or store of knowledge that AI assistant 10 can access as needed. Test measurement general knowledge 14 may include general information about many different types of test and measurement equipment and their operation, as well as test procedures, parameters, and target values ​​for many different standards. Instrument knowledge 16, as described above, includes information about specific instruments 18, such as oscilloscopes, arbitrary waveform or function generators, digital multimeters, source measure units, and many other known test and measurement devices.

[0012] As noted above, the test and measurement system shown in FIG. 1 has processing power to execute programs that both configure and operate the AI ​​assistant 10. The processor 21 may reside where the generative model 12 resides, such as on the instrument 18, a server or other cloud or edge device, or may reside at a location connected to a computing device accessed by a user. The dashed lines connecting the processors indicate the various locations where the processors reside. Processing tasks may be distributed throughout the system. Similarly, the test and measurement general knowledge 14 and the instrument knowledge 16 may reside in a common store 22, separate stores (e.g., 16), or on the instrument 18 itself.

[0013] In an embodiment of a test and measurement system including an AI assistant system, its elements include an AI assistant API (application programming interface) and generative model 12, general test and measurement knowledge 14, device-specific instrument knowledge 16, a user 20, and an instrument 18. In this example, the AI ​​assistant API 12 enables a programming language to interact with a generative AI model, such as a large language model (LLM) model. In some examples, this model may consist of an LLM model, possibly provided by a third party or created and fine-tuned by a user. In some examples, the knowledge blocks 14 and 16 contain information that provides context to the AI ​​assistant 10, but is not information the model may have previously learned. Knowledge may include files such as specifications or descriptions of the environment. Knowledge may also include a set of prompts with corresponding expected results. Knowledge blocks 14 may consist of a portion (e.g., a partition) of store 22, and instrument knowledge 16 may reside in memory on the instrument 18. Alternatively, both knowledge blocks may reside in store 22, which, like the AI ​​model, may reside in the instrument, on the cloud, or at the edge.

[0014] In some examples, a function is a set of one or more actions from instrument 18, typically backed by a program. A function's description, its arguments, and its return result are provided to AI assistant 10. A function is a way to provide dynamic knowledge, such as the state of an instrument, to AI assistant 10 or to request an action for AI assistant 10 to perform. In some examples, user 20 is a person or program that requests information or an action using a prompt. In some examples, instrument 18 is an oscilloscope, such as an 8-channel MSO58B oscilloscope. AI assistant 10 can interact with instrument 18 programmatically. In examples where AI assistant 10 interacts with instrument 18 programmatically, the oscilloscope is the target device of the dynamic knowledge or the target device of the action requested by AI assistant 10.

[0015] One or more instruments, such as instrument 18, may be assigned to AI Assistant 10 at startup. The assignment at startup may be configured so that AI Assistant 10 talks about the test and measurement environment that the user has created and with which AI Assistant 10 interacts.

[0016] In some examples, when writing a function to the AI ​​assistant 10, the user 20 can define the function name, what the function does, what the function returns, and a definition of each input argument of the function. In the following example, the user 20 uses a function decorator to extract the above information. In one embodiment, the function decorator creates the appropriate JSON (JavaScript Object Notation) for the AI ​​assistant 10. While JSON appears to apply only to Java, it is a language-independent text format. The JSON includes the function name, a doc string description that defines what the function does and what it returns, and a description of the arguments. These embodiments are not limited to a specific implementation using JSON. Other implementations may include vector databases and template libraries. The actual mechanism used depends on the language in which the AI ​​assistant 10 is implemented and the specifications of the underlying AI assistant API 12.

[0017] There are several scenarios where functions are useful in a test and measurement environment. Below is some example Python code that demonstrates determining the capabilities of an instrument, the actions to perform, the queries to the instrument, and the data returned. 1. Determining Instrument Performance @openai_function() def get_scopt_channel_count(scope) """ Returns the number of channels available on the oscilloscope. Oscilloscopes typically have 2, 4, or 8 channels, depending on the model. Since the number of channels is not the same for all oscilloscopes, this call must be made to find the correct number of channels. """ if connect: idn = scope.query('*IDN?') fields = idn.split(',') if(fields[1] == 'MSO58' or fields[1] =='MSO58B'): return "8" elif(fields[1]]== 'MSO56' or fields[1] == 'MSO56B'): return "6" elif(fields[1] == 'MSO54' or fields[1] =='MSO54B'): return "4" elif(fields[1]]== 'MSO66' or fields[1] == 'MSO66B'): return "6" elif(fields[1]]== 'MSO64' or fields[1] == 'MSO64B'): return "4" return "8" 2. Take action @openai_function(state="State to set the AWG output to. Options are on or off. If not specified, on is used.") def set_awg_state(scope,state = "ON"): """ This is the function used to set the output state of the AWG. The state is either on or off. """ try: if connect: scope.write(f":AFG:OUTPut:State {state}") outilfe.write(f"scope.write(':AFG:OUTPut:State {state}')\n") if verbose: print(f"set_awg_state({state}) - Success") return f"Success" except Exception as e: print(f"set_awg_state({state}) - Failed:" + str(e)) return "Failed: " + str(e) 3. Query the status @openai_function(channel="The channel to return the status for. The channel can be CH1, CH2, CH3, Ch4, CH5, CH6, CH7, or CH8, depending on the number of channels in your oscilloscope.") def get_scope_channel_state (scope, channel): """ Gets the state of a channel. The returned value is either on or off. """ try: if connect: return scope.query(f":SELECT:{channel}?") return "OFF" except: return f"Failed: {e}" After executing the above code, the system will return the relevant data.

[0018] Figure 2 shows a sequence diagram for launching the test measurement AI assistant described in Figure 1. In the sequence diagram in Figure 2, various elements of the system, including the instrument API, the instrument, and the user, interact with the AI ​​assistant. When the AI ​​assistant launches, it configures itself by loading or connecting to a generative AI model (sometimes called an AI model) at 23. As described above, the AI ​​assistant may use a "local" copy of the AI ​​model or a "remote" copy of the model residing in the cloud or on an edge device. The AI ​​assistant loads or links to general knowledge at 24, and the AI ​​assistant loads the assistant's configuration into the instrument API at 25. The AI ​​assistant then connects to the instrument through the instrument API at 26 and receives a response from the instrument at 27. The instrument uses the instrument API to create an instrument description at 28 and load the instrument knowledge at 29. The instrument then returns the instrument description and instrument knowledge to the AI ​​assistant at 30. At this point, the AI ​​assistant will inform the user that it has completed the setup and is waiting for a prompt from the user at 31.

[0019] The user inputs the desired action they want to perform using the instrument on the device under test (DUT). The AI ​​assistant then transparently converts this desired action into a function call and arguments and sends these to the instrument API at 32. The called function and arguments then reach the instrument at 34, which returns the returned function status and other information to the instrument API at 35, which sends the returned function status and information at 36. The AI ​​assistant then sends the response and desired information back to the user at 37. The user may then indicate receipt at 38, and this interaction may continue with further prompts at 39.

[0020] In some instances, the user's setup is more complex than a single instrument setup. The example of FIG. 3 may have three instruments, e.g., two instruments 42 and 44 and a signal source 46, such as a waveform generator. The AI ​​Assistant 10 may be configured to recognize multiple devices and their intended use upon startup. This configuration of the AI ​​Assistant 10 allows for a higher level of user interaction. Each instance of a device and standard constitutes a package, which the AI ​​Assistant 10 may manage, configure, and load into the test and measurement system.

[0021] The three instruments 42, 44, and 46 in FIG. 3 each individually communicate with the AI ​​assistant 10. Additionally, because the setup in FIG. 3 is part of a particular type of test environment, the AI ​​assistant 10 may be configured with additional knowledge and specifics about the particular type of test environment, such as general test measurement knowledge 14, specific knowledge of one of the instruments, or part of any of the individual stores, such as part of the central store 40 or a partition. The additional knowledge and specifics in store 30 provide sufficient knowledge to the AI ​​assistant 10, but this knowledge does not allow the user 20 to account for the instruments 42, 44, and 46, nor for aspects of the overall environment. Store 40 and store 22 in FIG. 1 may exist as a unified memory or may comprise separate memories, and one or both may reside in the cloud, on an edge device, or within the test and measurement equipment.

[0022] One advantage of using such an approach is that standardized functions and knowledge provided for one type of instrument, such as an oscilloscope, can be leveraged to interface with the AI ​​assistant across different models and even different manufacturers of equipment. Another advantage of making requests at a higher level is that the AI ​​assistant is inherently device-independent. Thus, the same prompts used on different devices will generally produce similar results, provided the substituted device has equivalent or better capabilities.

[0023] Interaction with an AI assistant doesn't have to be limited to text or voice. Another approach is to provide programmatic access to a configured environment. Programmatic access to a configured environment allows programmatic interaction with the device at a higher level. For example, if the prompt is "Turn on channel 2, set the trigger source to this channel, and turn off all unused channels," the user can translate this into code like this: Import pyvisa as visa rm = visa.ResourceManager() scope = rem.open_resource("GPIB0::1::INSTR") scope.write("SELECT:CH1 OFF") # turn off channel 1 scope.write("SELECT.CH2 ON") #turn on channel 2 scope.write("SELECT.CH3 OFF") #turn off channel 3 scope.write("SELECT.CH4 OFF") #turn off channel 4 scope.write("TRIGGER:A:EDGE:SOURCE CH2") # set the trigger source to channel 2

[0024] The code above is one way to programmatically interact with an oscilloscope. This code is for a specific make and model. If a different make or model of equipment is deployed in this environment, you may want to modify the code.

[0025] Interactions with the AI ​​assistant can be changed to the following device-independent code: import tek_assistant with tek_assistant.TekAssistant() as tek: tek.read_configuration() tek.request('Turn on channel 2, set the trigger source to this channel, and turn off all unused channels.')

[0026] Another advantage of using an AI assistant is its ability to respond to requests that do not involve specific knowledge of the API provided by the oscilloscope. Users can say what they want, and the AI ​​assistant performs the corresponding action. The AI ​​assistant is device manufacturer / model agnostic. The AI ​​assistant also makes it easier for users reviewing test results to understand the intent of the test. Users no longer need to reverse engineer the intent by reviewing the code that maps the intent to actions. The example above uses Python, but it can be implemented in many other ways, such as REST (Representational State Transfer).

[0027] 4 shows an example of an oscilloscope user interface 50. Prompt window 52 shows an example of a user prompt for the AI ​​assistant. Response window 54 shows a response from the AI ​​assistant, with the resulting waveform shown in waveform window 56. As response window 44 shows, the AI ​​assistant in these embodiments is laid out in a manner that allows the user to perform a task.

[0028] For purposes of brevity, subsequent figures may not show all of the various controls and other elements of the user interface, as shown in area 58, other than the waveform window and the prompt and response window. The absence of these elements in the user interface should not be interpreted as a negation of the absence of these components in subsequent figures; some may be included where relevant to the discussion.

[0029] Figures 5 through 14 illustrate the flexibility of AI assistants. They are not intended to be exhaustive, and no limitation to these specific examples is intended or implied.

[0030] Figure 5 shows the result of further interaction between the user and the AI ​​assistant. The user wishes to change the scale of the signal in Figure 4. In prompt window 52, ​​the user changes the waveform parameters, and the assistant responds in window 54. The resulting changes are displayed in waveform window 56.

[0031] Figure 6 shows a prompt the Assistant receives through the voice interface. The text in box 59 indicates "Voice Control." Additionally, the user previously requested that a 0.1 V offset be added to the sine wave shown in waveform window 56. The user states through the voice interface that the offset was incorrect. The Assistant apologizes and provides more detailed information in response window 54.

[0032] Figure 7 shows the result of a prompt requesting a measurement, which is displayed in the center of the user interface.

[0033] Figure 8 shows that the AI ​​assistant can display not only waveforms but also other items such as fast Fourier transforms (FFTs).

[0034] Prior to the image in Figure 9, the user had asked the AI ​​assistant to change the displayed channel to channel 2. This can be seen in box 60 in the bottom left. In Figure 9, the user has returned to using voice control and the instrument is operating on channel 2.

[0035] In Figure 10, the user changes the time base and requests the oscilloscope to trigger on channel 2, and the resulting waveform is shown.

[0036] In Figure 11, the user has requested that the signal be decoded as CAN (controller area network) Bus 2.0, and the oscilloscope displays the results as a second display below the waveform window.

[0037] Figure 12 shows another response from the AI ​​assistant. As can be seen in the prompt window, the user makes a request in German. They add a translation in parentheses, which is not displayed. The AI ​​assistant interprets the German, performs an action, and responds in German.

[0038] Figure 13 shows another example where the AI ​​assistant responds in the user's language and turns on another channel on the oscilloscope.

[0039] The AI ​​assistant can also perform operations from outside the instrument. In the user interface in Figure 14, the user requests that a screenshot of the user interface be saved to disk C: on the connected computing device. The above interface directly demonstrates the flexibility of using the AI ​​assistant.

[0040] Currently, using an AI assistant can be a slow process, partly due to the computing resources required to return a response, but also because some current LLMs are cloud-based, meaning the AI ​​assistant shares resources with thousands of other requests.

[0041] One optimization is that the AI ​​assistant may record the actions required to execute a given prompt for a particular system configuration, and the assistant can then cache the results, so that when a user uses the prompt in the same situation, they can repeat the executed and saved actions without involving the AI ​​assistant.

[0042] This approach may be similar to the just-in-time (JIT) compilation procedure that environments such as the Java Virtual Machine (JVM) and .Net use to improve performance. This caching approach also allows users to convert multiple prompts to multiple actions at once, since the saved actions for a prompt for a particular configuration are preserved across multiple runs. Subsequent runs can therefore be as fast as equivalent human-coded automation scripts.

[0043] Not all test environments are the same. In some instances, an AI assistant may be able to infer configuration based on the instruments connected to the workstation running the AI ​​assistant. However, if a user wants to interact with an AI assistant that is aware of the context of the test environment, some startup configuration may be required.

[0044] The settings may be as follows: config: name: "PCIe Gen3 x2" scope: - name: "Scope1" - make: "Tektronix" - model: "MDO58B" - connection: "TCPIP::192.168.1.19::INSTR" scope: - name: "Scope2" - make: "Tektronix" - model: "MDO58B" - connection: "TCPIP::192.168.1.23::INSTR" generator: - name: "Generator1" - make: "Tektronix" - model: "AWG5208" - connection: "TCPIP::192.168.1.25::INSTR"

[0045] Another configuration using a different set of instruments might be as follows: config: name: "PCIe Gen3 x2" description: "PCIeGen3 x2 Test Setup for Compliance Testing" scope: - name: "Scope1" - make: "Tektronix" - model: "MDO66B" - connection: "TCPIP::192.168.1.39::INSTR" scope: - name: "Scope2" - make: "Tektronix" - model: "DPO77002SX" - connection: "TCPIP::192.168.1.42::INSTR" generator: - name: "Generator1" - make: "Tektronix" - model: "AWG5208" - connection: "TCPIP::192.168.1.25::INSTR"

[0046] With a configuration like the one above, the AI ​​Assistant can look up instrument knowledge and function descriptions from existing libraries using make and model information. The connection string tells the underlying instrument API how to connect to that instrument for direct interaction using instrument-specific information. Each instance of the instrument is referenced by a specified name when interacting with the AI ​​Assistant. This information allows the AI ​​Assistant to interact directly with the instrument without having to guess the test configuration.

[0047] Having a predefined set of instrument knowledge and function definitions allows the AI ​​assistant to interact with a wide range of device types, enabling device-independent use. Having a predefined set of instrument knowledge and function definitions may be similar to standardized instrument drivers in existing automation environments.

[0048] AI assistants in the test and measurement domain are not limited to setting up and sequencing tests and displaying results. They can be created to create new, custom-made analysis algorithms based on descriptions. For example, the following text shows an example of a measurement specification based on the VESA (Video Electronics Standards Association) DisplayPort 1.2 specification: 3.2.4 Measurement Requirements For each level measurement, the following requirements must be met: Number of edges measured: >1000 The amplitude measurement is V s =MAX(V H ,V L ) is used. At this time, V H and V L has the following definition: V H is a high or "1" voltage mode for the last two UIs when three or more consecutive "1"s are sent. V L is a low or "0" voltage mode for the last two UIs when three or more consecutive "zeros" are transmitted. Voltage peak-to-peak = V H -V L

[0049] Figure 15 shows an example of the above measurement loaded onto a sampling oscilloscope.

[0050] Converting intent, such as a text describing a measurement, into a new measurement, as shown later in Figure 23, can be done by providing the AI ​​assistant with the correct knowledge and functions. However, the abstract concepts presented may be close to the type of user requirement. Therefore, a set of primitives may be presented by an oscilloscope and its functions. The term "primitive" in this application means a declarative statement, sometimes called built-in behavior, but is extensible.

[0051] The primitives that assemble the oscilloscope's functionality into measurements are relatively small. Primitives include pattern matching to a sequence of patterns or symbols, which form a set of multiple time ranges. Primitives include waveform database support in the form of mathematical expressions, including persistence across multiple acquisitions. Primitives include overlapping samples from multiple time ranges and storing them in the waveform database. Primitives include mapping screen time to unit intervals and mapping vertical values ​​to normalized values ​​for nominal 1s and 0s (NRZ) or levels 0 to 3 (PAM4). Primitives include allowing multiple named horizontal or vertical histograms using UI or normalized coordinates. Primitives include custom measurement formulas, such as Meas1 = Hist1 - Hist2. Primitives include storing and recalling mathematical operations or measurement-defined operations as newly named measurements. It should be noted that a user will likely need many more primitives, and the above primitives are intended as examples only, and embodiments of the present application can add more primitives as desired or needed.

[0052] Given a small set of such primitives, an AI assistant may be configured to translate the above test specification into reusable custom measurements. The primitives are similar to behaviors that can be configured in small scripts. The AI ​​assistant creates these small scripts so that the user does not have to write them, and the scripts can be saved.

[0053] These same primitives can be included as part of a reusable analytical component. Using the same primitives, this same assistant can define new measurements for any analytical component application. The definition can include custom user automation, automation tools, or instruments. In this way, users can use the AI ​​assistant to create reusable, savable scripts. Future uses of the script may not require the AI ​​assistant, providing a more economically viable option than using the AI ​​assistant for each instance.

[0054] Figures 16-24 show example primitives. Figure 16 shows a vector waveform being folded. Figures 17 and 18 show the bit pattern and inverse bit pattern of the waveform in Figure 16 at different scales. In some cases, the measurement being made may be statistical. For example, the user may need to look for a specific pattern to make a measurement. An example measurement is the amplitude of the bit following a transition bit after the bit has settled. To do this, the user could use three non-transition bits followed by a transition bit. As shown in the figures, the waveform is folded and displayed in a coordinate system of unit intervals both horizontally and vertically. Therefore, as shown in the figures, the waveform indicates the location of the transition bits.

[0055] Measurements are made of the amplitude of the waveform to the right of the transition bit. This involves the use of a histogram. Figure 19 shows a portion of the waveform after the second transition bit to a non-transition bit being selected for histogram 70, and Figure 20 shows another portion of the waveform after the second transition bit to a non-transition bit being selected for histogram 72.

[0056] The user can then include formulas to calculate the measurements. Figure 21 shows the inclusion of the formulas for the top and bottom histograms that generate the measurements, and Figure 22 shows the results. As mentioned above, the user can convert this formula, derived from the user's requirements, into a script and save it.

[0057] FIG. 23 shows the new waveform and FIG. 24 shows the application of the script to this new waveform, allowing the user to utilize previously saved histogram calculations, formulas and results.

[0058] The AI ​​assistant is not limited to setting and sequencing steps and displaying the results. There is also the potential to create new bespoke algorithms from descriptions. Returning to the DisplayPort 1.2 specification, the following text shows its pass / fail criteria: 3.2.5 Pass / Fail Criteria The peak-to-peak voltage falls within the following ranges: Output level 1: 0.34≦result≦0.46 Output level 2: 0.51≦result≦0.68 Output level 3: 0.69≦result≦0.92 Output level 4: 1.02≦result≦1.38 Nominal settings are 400, 600, 800, and 1200 millivolts peak-to-peak

[0059] This definition can also be supported by the instrument by allowing custom measurement formulas to add a pass / fail concept.

[0060] The system described in this disclosure may allow test specifications such as the following to be inserted directly into a program as text, or the system may convert the test specification into a prompt-friendly specification that is not simple code that can be executed directly.

[0061] For example, the following text shows part of the specification for one form of measurement in the DisplayPort 1.2 specification, which may include sections 3.2.4 and 3.2.5 above: As mentioned above, it is feasible to take DisplayPort measurement definitions and translate them into actions via an AI assistant, and this can be done without writing a single line of code. 3.2.1 Purpose of the study Evaluate the peak differential amplitude of the waveform to ensure the signal is not overdriven or underdriven. (Reference: Table 3-10 VESA DisplayPort Standard) 3.2.2 Interoperability Specifications The signal source is given a range of expected output power at each level setting that correlates to system budget factors such as cable loss, receiver eye minimum and maximum, etc. This test verifies that the system budget is adhered to. 3.2.3 Test conditions Testing must be performed for all supported differential voltage swings and at all supported bit rates without pre-emphasis. Test Pattern - PRBS7

[0062] An AI assistant can take something like a complete test specification for a measurement in one format and translate it into the commands necessary to execute actions. The test measurement system can do this translation without the user having to write a single line of code. Tailored to the test measurement environment, an AI assistant provides a high-level way for users to define what they want to accomplish, rather than detailed instructions for achieving their goals. When configured correctly, the resulting prompts to the AI ​​assistant are device, manufacturer, and model independent. Having test definitions that don't require porting when making minor configuration changes is extremely valuable. With an AI assistant, users don't need to know the programming details of their test measurement equipment. The AI ​​assistant may understand what the user wants to do and can translate that intent into actions. The AI ​​assistant can define new measurements that don't yet exist. Because AI assistants are programmatic, they have the advantage of being easy to read and write. Debugging is easier because if the user makes a request that the equipment cannot handle, the AI ​​assistant returns an appropriate message and can help resolve the request. AI assistants can be integrated into existing automation tools. AI assistants transform the test creation process from writing code to operating on specifications. The resulting test definitions are easier to tailor to requirements, easier to write, easier to verify, and easier to debug than code-based environments.

[0063] Aspects of the disclosed technology may operate on specially created hardware, firmware, digital signal processors, or specially programmed general-purpose computers, including processors that operate according to programmed instructions. The terms "controller" or "processor" herein contemplate microprocessors, microcomputers, ASICs, and dedicated hardware controllers, among others. Aspects of the disclosed technology may be implemented with computer-usable data and computer-executable instructions, such as one or more program modules, executed by one or more computers (including a monitoring module) or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc., which, when executed by a processor in a computer or other device, perform particular tasks or implement particular abstract data types. Computer-executable instructions may be stored in computer-readable storage media, such as hard disks, optical disks, removable storage media, solid-state memory, RAM, etc. Those skilled in the art will appreciate that the functionality of the program modules may be combined or distributed as desired in various embodiments. Furthermore, such functionality may be embodied in whole or in part in firmware or hardware equivalents, such as integrated circuits, field programmable gate arrays (FPGAs), etc. Certain data structures may be used to more effectively implement one or more aspects of the disclosed technology, and such data structures are considered within the scope of the computer-executable instructions and computer-usable data described herein.

[0064] The disclosed aspects may, in some cases, be implemented in hardware, firmware, software, or any combination thereof. The disclosed aspects may also be implemented as instructions carried by or stored on one or more computer-readable media, which may be read and executed by one or more processors. Such instructions may be referred to as a computer program product. As used herein, computer-readable media refers to any medium that can be accessed by a computing device. By way of example, and not limitation, computer-readable media may include computer storage media and communication media.

[0065] "Computer storage media" means any medium that can be used to store computer-readable information. By way of example and not limitation, computer storage media may include random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory and other memory technologies, compact disc read-only memory (CD-ROM), digital video disc (DVD) and other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage and other magnetic storage devices, and any other volatile or nonvolatile, removable or non-removable medium implemented in any technology. "Computer storage media" excludes signals themselves and transitory forms of signal transmission.

[0066] A communication medium means any medium usable for communicating computer-readable information. By way of example, and not limitation, communication media may include coaxial cable, fiber optic cable, air, or any other medium suitable for communicating electrical, optical, radio frequency (RF), infrared, acoustic, or other types of signals. Example

[0067] The following examples are provided to aid in understanding the technology disclosed in this application. Embodiments of the technology may include one or more of the examples described below, and any combination thereof.

[0068] Example 1 is a test measurement system, one or more test and measurement instruments, including at least one test and measurement instrument having one or more ports for connecting to a device under test (DUT); one or more memories containing test measurement knowledge; a generative artificial intelligence (AI) model connected to the one or more test and measurement devices and the one or more memories; One or more processors Equipped with the one or more processors: presenting a user interface with prompts to a user of the one or more test and measurement devices; receiving, through the user interface, a request from the user including one or more tasks to be performed by the one or more test and measurement instruments; accessing an application programming interface (API) of the generative AI model to translate the request into a command for the one or more test and measurement devices; transmitting the command to the one or more test and measurement devices; displaying an output from the one or more test and measurement devices on the user interface; and The one or more processors are configured to execute a program that causes the one or more processors to perform the steps of:

[0069] Example 2 is the test and measurement system of Example 1, wherein the one or more processors reside in one or more of the one or more test and measurement devices, a computing device connected to the test and measurement devices, a cloud server, and an edge server.

[0070] Example 3 is the test and measurement system of either Example 1 or Example 2, wherein the test and measurement knowledge includes one or more of general test and measurement information, information specific to the one or more test and measurement devices, standard information, and package information.

[0071] Example 4 is a test and measurement system according to any one of Examples 1 to 3, wherein the program causing the one or more processors to perform a process of sending the commands to the one or more test and measurement devices includes a program causing the one or more processors to perform a process of generating a list of functions to be called together with arguments of the functions.

[0072] Example 5 is the test and measurement device of Example 4, wherein the one or more processors are further configured to execute a program that causes the one or more processors to receive a status of the function from the one or more test and measurement devices and perform processing that enables the one or more test and measurement devices to display a result on the user interface.

[0073] Example 6 is the test and measurement system of any of Examples 1 to 5, wherein the one or more processors are further configured to execute a program that causes the one or more processors to perform processing to determine capabilities of the one or more test and measurement devices.

[0074] Example 7 is a test and measurement system according to any one of Examples 1 to 6, wherein the program causing the one or more processors to perform a process of sending the command to the one or more test and measurement devices includes a program causing the one or more processors to perform a process of sending a command to the one or more test and measurement devices that causes the one or more test and measurement devices to perform an action.

[0075] Example 8 is the test and measurement system of any of Examples 1 to 7, wherein the program causing the one or more processors to send the command to the one or more test and measurement devices includes a program causing the one or more processors to send a query regarding the status of execution of the command to the one or more test and measurement devices.

[0076] Example 9 is a test and measurement system of any of Examples 1 to 8, wherein the program that causes the one or more processors to process requests received from the user through the user interface includes a program that causes the one or more processors to process requests received through a voice interface.

[0077] Example 10 is the test and measurement system of any of Examples 1 to 9, wherein the one or more processors are further configured to process the request and the command for later access without using the generative AI model.

[0078] Example 11 is the test and measurement system of any of Examples 1 to 10, wherein the one or more processors are further configured to execute a program that performs processing to receive configuration information for the one or more test and measurement devices.

[0079] Example 12 is the test and measurement system of any of Examples 1 to 11, wherein the test and measurement knowledge includes primitives.

[0080] Example 13 is the test and measurement system of Example 12, wherein the one or more processors are further configured to execute a program that causes the one or more processors to receive user input for one or more measurements, create one or more measurements using primitives, and store the user input as a custom measurement.

[0081] Example 14 is a computer-implemented method for creating an artificial intelligence (AI) assistant for a test measurement environment, comprising: accessing an application programming interface of the generative AI model; generating a list of functions to call along with the arguments of those functions; providing the list of functions to be called and the arguments to a generative AI model; Loading general knowledge of test measurements into the generative AI model; connecting to one or more test and measurement devices; creating a description of each of the one or more test and measurement devices; loading specific knowledge about the one or more test and measurement devices into the generative AI model to create the AI ​​assistant; It is equipped with.

[0082] Example 15 is the computer-implemented method of example 14, comprising: receiving, via a user interface of one of the one or more test and measurement devices, a series of commands that cause the one of the test and measurement devices to perform actions; A process to generate a script that constitutes the series of commands above. Saving the script for further use without the need for the AI ​​assistant. It further comprises:

[0083] Example 16 is the computer-implemented method of any of Examples 14 or 15, comprising: receiving make and model information for the one or more test and measurement devices; using the make and model information to enable the AI ​​assistant to directly connect to the one or more test and measurement devices; It further comprises:

[0084] Example 17 is the computer-implemented method of any of Examples 14 to 16, further comprising: receiving a test specification; and converting the test specification into a script.

[0085] Additionally, the description of this application refers to specific features. It should be understood that the disclosure herein includes all possible combinations of these specific features. When a specific feature is disclosed in connection with a particular aspect or example, that feature can also be used in connection with other aspects and examples, to the extent possible.

[0086] Furthermore, when this application refers to a method having two or more defined steps or processes, these defined steps or processes may be performed in any order or simultaneously, unless the circumstances do not preclude this possibility.

[0087] All features disclosed in the specification, claims, abstract and drawings, and all steps in any disclosed method or process, may be combined in any combination, except where at least some of such features or steps are mutually exclusive combinations. Each feature disclosed in the specification, abstract, claims and drawings may be replaced by an alternative feature serving the same, equivalent or similar purpose, unless expressly stated otherwise.

[0088] While specific embodiments of the disclosed technology have been illustrated and described for purposes of illustration, it will be appreciated that various modifications can be made therein without departing from the spirit and scope of the invention. Accordingly, the disclosed technology should not be limited, except as by the appended claims. [Explanation of symbols]

[0089] 10. AI Assistant 12 Generative Model 14 General knowledge of test measurements 16 Measuring Instrument Knowledge 18 Measuring Instruments 20 users 21 processors 22 Common Store 40 Central Store 42 Measuring Instrument 1 44 Measuring Instrument 2 46 Signal supply device 1

Claims

1. 1. A test and measurement system comprising: one or more test and measurement instruments, including at least one test and measurement instrument having one or more ports for connecting to a device under test (DUT); one or more memories containing test measurement knowledge; a generative artificial intelligence (AI) model connected to the one or more test and measurement instruments and the one or more memories; one or more processors Equipped with the one or more processors presenting a user interface with prompts to a user of the one or more test and measurement devices; receiving, through the user interface, a request from the user including one or more tasks to be performed by the one or more test and measurement instruments; accessing an application programming interface (API) of the generative AI model to translate the request into commands for the one or more test and measurement devices; transmitting the command to the one or more test and measurement devices; displaying an output from the one or more test and measurement instruments on the user interface; a test and measurement system configured to execute a program that causes the one or more processors to perform the steps of:

2. 2. The test and measurement system of claim 1, wherein the test and measurement knowledge includes one or more of general test and measurement information, information specific to the one or more test and measurement devices, standards information, and package information.

3. a program for causing the one or more processors to perform a process of transmitting the command to the one or more test and measurement instruments, generating a list of functions to call along with the arguments of those functions; sending the functions and the commands to the one or more test and measurement devices; 2. The test and measurement system of claim 1, further comprising a program that causes said one or more processors to:

4. 2. The test and measurement system of claim 1, wherein the program causing the one or more processors to send the command to the one or more test and measurement devices includes a program causing the one or more processors to send a query regarding the status of execution of the command to the one or more test and measurement devices.

5. 2. The test and measurement system of claim 1, wherein the one or more processors are further configured to store the requests and commands for later access without using the generative AI model.

6. 10. The test and measurement system of claim 1, wherein the one or more processors are further configured to execute a program that processes to receive configuration information regarding the one or more test and measurement instruments.

7. the test measurement knowledge includes primitives; the one or more processors: receiving user input of one or more measurements; creating one or more measurements using the primitives; Storing the user input as a custom measurement.

2. The test and measurement system of claim 1, further configured to execute a program that causes the one or more processors to:

8. 1. A computer-implemented method for creating an artificial intelligence (AI) assistant for a test measurement environment, comprising: accessing an application programming interface of the generative AI model; generating a list of functions to call along with the arguments of those functions; providing the list of functions to be called and the arguments to a generative AI model; Loading general knowledge of test measurements into the generative AI model; connecting to one or more test and measurement devices; creating a description of each of the one or more test and measurement devices; loading specific knowledge about the one or more test and measurement devices into the generative AI model to create the AI ​​assistant; A computer-implemented method comprising:

9. receiving, via a user interface of one of the one or more test and measurement instruments, a series of commands that cause the one of the test and measurement instruments to perform actions; A process to generate a script that constitutes the series of commands above. Saving the script for further use without the need for the AI ​​assistant.

10. The computer-implemented method of claim 8, further comprising:

10. receiving make and model information for the one or more test and measurement devices; using the make and model information to enable the AI ​​assistant to directly connect to the one or more test and measurement devices; 10. The computer-implemented method of claim 8, further comprising:

Images