If this was me, I'd use an Odroid C4 (quad-core Amlogic S905X3) or Libre Computer La Frite, with a 8GB or 16GB EMMC module, and a capacitive or surface acoustic wave multi-touch display. Those two SBCs are way overpowered for a simple UI, but meh. I like SAW better than capacitive touch for industrial uses, as you can get displays with really tough surfaces (as in vandal-proof, even). (Touch points are detected using the changes in ultrasonic pulses propagating within the display material, when something comes to contact with the display. Really cool tech, but not new.)
For rotary knobs etc. that connect to the UI only, I'd use a simple microcontroller with native USB support handling the buttons and knobs, talking to the SBC via USB HID.
For the "firmware", I'd redo the full software stack (but I'm familiar with this stuff and have done it before). The basis would be upstream Debian, pared down to the absolute minimum. The user interface would be Python3 + Qt5 (for maintenance reasons), on top of EGLFS (
Qt for embedded Linux). Essentially, the init system would only start the necessary services – look at e.g. OpenWRT for how minimal that is –, and then (as a dedicated user, with a service supervisor that restarts the UI if it crashes (runit style, written in C). If the device is network-connected, I'd also install fail2ban as a matter of principle, and possibly tripwire, with support for external logging. All would be packaged Debian-style, for long-term maintenance reasons. (Not just to make maintenance and upgrades simpler, but also because it helps developer consider what things
need to be included in the packages, instead of tarballing their entire development environment up and telling future devs to use that as-is.)
For the communication with the actual instrument, I'd use the hardware serial ports with hardware flow control if possible; and very likely through a digital isolator like Si86xx series. It may not be
necessary, but it means the display-interface can be treated as a completely separate unit, and can make a big difference in long-term maintenance and development costs. On the display side, the Python3 UI would talk to a local C service process (instead of directly to the serial-connected instrument), to create an interface between different instruments and different UIs. Also, that same service daemon would handle commands and status requests via Ethernet. (This was the structure I suggested for a fusor project, for example; it modularizes the state monitoring and UI stuff also, so that the UI itself does not need to do e.g. logging, and can be developed as a separate module instead of as an integral part of each instrument.)
If you don't want to look for someone to do this for you, there are companies specializing in human-machine interfaces you can outsource this stuff to, for example Norwegian
Keytouch.
If you do get someone to do this for you, make sure the contract includes the requirement for maintaining full
documentation not only on the final products, but also the steps taken. If you intend to do business for more than five years, then at least half of the software side should be maintaining good documentation on the product development process; the worst thing that can happen, and usually does happen, is that in a few years, you end up maintaining a legacy codebase nobody has the time or ability to debug anymore, and you're just hoping that it'll work out. It is not just proof against someone getting hit by a bus, but also an indispensable problem-solving tool,
when something goes awry on the software side.