I misunderstood.
I guess it depends a lot on how much and how often you’re reading from the PIDE data blocks. The main reason reading directly from an instruction like that is generally not a good idea is because it blocks the Ignition driver from efficiently reading the data. Each element of each PIDE will be its’ own read operation. While normal UDTs with all of their members exposed with read/write access can be read with a single read operation. If you’re reading, say 90% of a block all the time and you need to read it fast, it’s going to present more of a problem than if you’re only calling up most of that data in a configuration view and you have it in a leased tag group. What’s really going to make the difference is how many of those PIDE members are going to need to be visible on a screen at the same time.
In my experience, the numbers you’re most interested in are the Process Variable, the Setpoint, and the Output. Usually these tags are separate from the PIDE tags anyway. So in that case, I’d set up Ignition to read those external tags instead of the actual PIDE members. The rest of it, the gains, deadband, etc., those aren’t typically values you put front-and-center. So for those, you can theoretically put them in a leased tag group where they’re read very slowly when no bindings are active, and then read more quickly when they are. Keep in mind though, leased tags aren’t a magic bullet and carry their own set of problems. Switching scan rates can take up to 8 seconds, and if you put all of these tags in a single device connection, you could see huge delays in responsiveness when you pull up the relevant view. That may actually be fine if they’re just settings the user changes. You can perhaps set the tag group to read after write, so that any changed values will be read back immediately. Again, there are pitfalls involved with that method, too, so be careful.
There's a few ways to tackle it. Honestly, the simplest way may be to create another AOI just for bridging Ignition and the PIDE instruction. You would create a UDT with only what you need in your Ignition project. You then create a parameterized subroutine (which would be my preference since it’d be more memory-efficient. You wouldn’t need a set of internal tags for every single instance), or an AOI that reads and writes data between an instance of that UDT and the PIDE elements themselves. Then you set up Ignition to only read and write with the UDT you created. You gain all the comms efficiency that way.