Getting Started with QUARC - Webinar

Getting started with QUARC®, Quanser's real-time rapid control prototyping software? Or want to learn more about how it can simplify your controls teaching and research? Then join Quanser online on Tuesday, January 28, 2014 at 2 PM EST to get an assistance and answers from Quanser engineers.

In the webinar "Getting Started with QUARC Rapid Control Prototyping Software ", Michel Lévis, Quanser Applications Engineer will demonstrate how using QUARC, you can easily:

• Interface with hardware to obtain readings
• Build a simple PD-based controller to control the position of the servo load shaft
• Perform stability analysis and LQR design 
• Validate the system performance in simulation and implement a balance controller on the actual system

Register today - the spots are limited!

How QUARC Helps Professors Advance Their Research

What is the key advantage that professors get from using QUARC^® rapid control prototyping software in their research? It’s simple - speed. QUARC allows them to accelerate design and achieve their research goals in much less time, whether they’re working in haptics, robotics, unmannedvehicles or other related areas.

The fact is QUARC seamlessly integrates with Simulink^® and takes the traditional design-to-implementation interface toolset to new levels. As a result, researchers experience more functionality and more development flexibility, all geared towards improved real-time testing and performance.

All around the world, academic researchers are using QUARC to quickly turn ideas into prototypes, saving themselves months, and in some cases years, of development time. In today’s time and budget-constrained academic research environment, that’s an advantage of major proportions.

Read on and learn how some professors are advancing their research at a rapid pace by using QUARC. 

Design complex control processes with ease

“We develop control algorithms for a rehabilitation robot designed and manufactured by Quanser. The device is designed to help stroke survivors perform upper limb movement therapy exercises. We are especially interested in using robotically-captured records of patients’ motions to accurately measure their motor performance, enabling clinicians to design optimal therapy interventions that will help maximize recovery.

Using QUARC, University of Alberta researcher Matthew Dyck was able to quickly develop control algorithms for a rehabilitation robot designed to help  stroke survivors perform upper limb movement therapy exercises.  (Photo courtesy of University of Alberta)

Our robot and its associated sensors are programmed, monitored, and controlled entirely through QUARC. QUARC makes it possible for us to design complex control solutions with ease, and enables us to fine-tune those algorithms in real time as they are implemented on physical hardware.

QUARC rapidly accelerates the process of translating an idea into a tangible, functioning prototype. Through its high-level programming environment, QUARC enables engineers to focus on designing innovative solutions rather than troubleshooting programming errors. QUARC’s advanced functionalities have both simplified and supercharged our real-time, hardware-in-the-loop programming and offline simulations.” 

- Matthew Dyck, E.I.T., M.Sc. Student, Electrical and Computer Engineering, University of Alberta, Canada

A tremendous help for research in distributed sensing systems

“QUARC's support of TCP/IP has been a tremendous help for our research. It allowed us to develop a distributed sensing system that isn't dependent on expensive I/O hardware or DAQ boards. Further, this allows for safety-critical redundancy when we are doing vehicle control tests.”

- Professor Sean Brennan, Mechanical and Nuclear Engineering, Penn State University, USA

Flexibility and ease of development in autonomous flight systems research

“We are using the Quanser Qball to conduct research into a number of areas. First, we are looking at designing cooperative flight and sightline controllers for practical laser wireless power transfer. We are building a laser transceiver to mount on the Qball and a ground-based laser pointer. Another area is using the Qball to demonstrate the effectiveness of nonlinear flight stabilization controllers for constrained flight in atmospheric turbulence. We chose Quanser for our lab for a number of reasons, but primarily because of the flexibility and ease of development provided by QUARC.”

- Professor David Anderson, MAST Lab and Aerospace Science Research Division, University of Glasgow, UK

Gather information quickly

“The computational speed and the communication speed between the Quanser Q8 data acquisition board and the QUARC environment is excellent, and completely fulfilled our needs. So we were able to gather information quickly, learn what worked and didn't work, then implement the necessary rapid design changes to the controller.”

- Professor Marcia O’Malley, Department of Mechanical Engineering, Rice University, USA

Faster development and a clearer control sequence

“Our lab is developing haptic devices and VR systems. Conventionally, we use VC++ and OpenGL to develop the control system and the visual interface. With Q8 and QUARC, I can now do the same thing faster and the control sequence is much clearer than before.”

- Yi Yang, Ph.D Student, Human Machine Interaction & Robotics, Beihang University, China

Students can implement new algorithms quickly

“QUARC interfaces very easily with Simulink. It's excellent in terms of rapid prototyping and it's also very good in terms of research work where you have students working through Simulink. It forces students to be in some ways better programmers than they are. Let's face it, some mechanical engineers don't necessarily like writing code, but now they have this ability to generate real time code by basically developing a Simulink model and then compiling it into real time code. Students can also implement new algorithms fast because they do not need to develop their own haptic system, but only to integrate additional blocks into an existing Simulink model. That certainly makes life much easier.”

- Professor Daniela Constaninescu, Department of Mechanical Engineering, University of Victoria, Canada

If we had been aware of QUARC when we began, we could have saved two years

“QUARC has made our programming faster and more robust. More importantly, it allowed us to move forward quickly by unifying our old and new programming platforms.”

“By understanding two different programming languages, QUARC helped us to prototype the system and produced a working simulation very, very quickly. In one week we installed QUARC, took the interactive tutorial available online from Quanser and used QUARC successfully to do rapid prototyping of the experiment. It just worked as we intended it to. We did high level programming of the robot's vision-based controller very quickly and accurately. If we had been aware of QUARC when we began this assistive robotic project, it would have sped up our work a great deal. We could have saved two years.”

- Professor Aman Behal, Electrical Engineering and Computer Science, University of Central Florida, USA

To find out how a wide range of blocksets in QUARC 2.3 are tailored for researchers, click here.

How QUARC Helps Students Understand Controls Better

Ask professors why QUARC^®  rapid control prototyping software is so effective in helping students understand control design and their answers highlight all the major benefits it brings to the learning process. 

QUARC is easy for students to use and designed to save them great amounts of development time. Working in conjunction with Simulink^® , it allows students to draw a controller, generate code, and run it in real time, all without digital signal processing, or without writing a single line of code.  As Professor YangQuan Chen of Utah State University has observed, “Using QUARC, students can control physical systems in no time.”

By using QUARC, students will spend less time coding, achieve quicker and better results and experience a deeper learning experience. 

Because QUARC integrates seamlessly with the Simulink software that most students are already using, it allows them to test their existing Simulink models in real time on their PC or external hardware, or easily integrate hardware-in-the-loop experiments as well, resulting a deeper learning experience. In the end, QUARC means students can spend less time coding, achieve quicker and better results, and concentrate on gaining a better grasp of control concepts.

Engineering professors around the world are using QUARC to help their students understand controls.  Here’s what some of them have told us about their experiences:

 "Think through problems, skip the tedium"

Because of the time my students can save using QUARC, they can actually design something that will work within the time frame of an undergraduate degree. They can really focus on the important control aspects. They are learning by thinking through problems, doing the exploratory work, practising the theory while skipping the tedium - like hand-coding. Without QUARC, they wouldn't have a hope of completing a project, in my opinion.

  - Professor David Wang, Electrical and Computer Engineering, 

   University of Waterloo, Canada

"Real-time control becomes extremely easy" 

"As an instructor, I always use MATLAB  and Simulink in my teaching, and then students can use their Simulink knowledge to easily interface with Quanser's QUARC software with which real-time control becomes extremely easy. In less than a one hour session, all undergraduate students (who have no prior experience in real-time control) could learn how to build a simple control loop, and obtain successful experimental results.

  - Professor Rifat Sipahi, Department of Mechanical and Industrial Engineering, 

   Northeastern University, USA

"Improves the learning experience"

QUARC software is designed so that most fundamental work is done, allowing the students to focus more on the control design theory and less on the workings of MATLAB /Simulink thus improving the learning experience.

  - Professor Wen-Hua Chen, Aeronautical and Automotive Engineering, 

   Loughborough University, UK

"QUARC  offers numerous functional and user-friendly features"

We have been quite pleased with using Quanser real-time control systems for both teaching and research within the past 8 years. QUARC offers numerous functional and user-friendly features. QUARC is seamlessly integrated with MATLAB  and Simulink, provides the means for rapid model compilation and evaluation, and allows for multi-rate simulation, to name a few. In a nutshell, QUARC is a low-cost yet reliable and powerful real-time control system solution, suitable for our everyday needs in controls and robotics.

  -Professor Keyvan Hashtrudi-Zaad, Electrical and Computer Engineering, 

   Queen’s University, Canada

"Students control physical systems in no time"

Students like to work with Quanser equipment. It is easy for them to get started. They just follow the wiring procedure and everything else is just mouse-clicking. Using Quanser’s rapid control prototyping and real-time software, QUARC they can control physical systems in no time.

  - Professor YangQuan Chen, Electrical and Compute Engineering, 

   Utah State University, USA

From WinCon to QUARC 2.3: the Evolution of Real-Time Control

Quanser’s QUARC® rapid control prototyping software was specifically designed to extend Simulink’s capabilities. It does so by allowing engineers to run Simulink models seamlessly in real-time on real hardware. Naturally QUARC 2.3, the new version of QUARC that will be released shortly, will feature full compatibility with the new MATLAB^®/Simulink^® R2012a and R2012b.  

Quanser will soon release QUARC 2.3 control software, which will offer
full compatibility with the new MATLAB^®/Simulink^® R2012a and R2012b.

Researchers and teaching professors in a variety of disciplines can implement virtually any control algorithm using QUARC. They can teach control concepts using Quanser equipment; conduct research with it on Quanser equipment; even do research with customized or third party equipment thanks to the advanced functionality and customized blocksets.

Professors and students alike can work with tremendous ease and efficiency, since they will spend less time coding and more time on high-level designing and testing.

Faster Design and Prototyping

An excellent example of this ease and efficiency comes from Professor Daniela Constaninescu, of the Mechanical Engineering Department of the University of Victoria in Canada. 

For her work developing a cooperative haptic rehabilitation exercise, Professor Constantinescu chose to use QUARC and Simulink with Quanser’s Haptic Wand device.  QUARC software allowed her research team to design a real-time controller quickly and made the communication with her C++ - based simulation engine easy.

A researcher at the University of Victoria performs a haptic cooperation experiment using Quanser’s Haptic Wand device and QUARC® control software. Both the hardware and software were reliable, time-saving tools that helped Professor Constantinescu advance her haptic research.

“QUARC interfaces very easily with Simulink”, says Professor Constantinescu. “It's excellent in terms of rapid control prototyping and it's also very good in terms of research work where you have students working through Simulink. It forces students to be in some ways better programmers than they are.”  As she pointed out, not all mechanical engineers like writing code. “But now they have this ability to generate real-time code by basically developing a Simulink model and then compiling it into real-time code. Students can also implement new algorithms fast because they do not need to develop their own haptic system, but only to integrate additional blocks into an existing Simulink model. That certainly makes life much easier.”

From WinCon 1.0 to QUARC 2.3: a History of Accelerating Design

QUARC’s history began over twenty years ago when Dr.Jacob Apkarian, Quanser’s Founder and Chief Technology Officer, wanted to develop a graphical way of implementing feedback control design in Windows® through pre-drawn block diagrams. He assigned that task to his Chief Scientist, Dr. Dan Madill and WinCon 1.0 was born. “This was in the days before the existence of MATLAB’s Simulink simulation program, recalls Dr. Madill. “When MATLAB did release Simulink, there was still no way to do real-time coding. So we then created WinCon 2.0, which when integrated with Simulink, automatically generated control code and ran it in real-time.”

“WinCon worked well with successive versions of Windows but as time went on and technical possibilities expanded, we were running into a variety of limitations. In addition, the WinCon code building on top of earlier Windows code was getting complicated.” The Quanser software development team took the opportunity to completely redesign WinCon, expand its scope, and integrate it more closely with Simulink. They also gave it a new name: QUARC.

A Real-Time Revolution In Controls

Among the goals developed for QUARC software was a high degree of compatibility with current and future versions of MATLAB/Simulink.  QUARC works with virtually any operating system/platform (Windows, QNX, Linux) and uses a “wrapper layer” that abstracts the OS so that, in terms of coding, every OS looks the same. “That leads to a consistent user experience,” says Dr. Madill.

All this makes QUARC a real-time control revolution: extremely versatile, portable, flexible and verifiable. It is a seamless way of running simulations and achieving real-time control. As a result, students can learn control concepts faster and better; researchers can test their theories in real-time, drastically reducing development time and cost; and real-world devices are perfected sooner and fast-tracked to market.

There’s Even More To The QUARC Story

Watch for more upcoming QUARC blog posts.  We will give you some examples of how QUARC has helped professors teach controls to students and take you on an around-the-world tour to see how QUARC has helped professors and engineers in industry conduct research.

You can learn more about QUARC using an online Interactive Tutorial.  Or request a free 30 day trial version of QUARC 2.3.

See you next time! 

QUARC® Helps Researchers Bridge The Language Barrier and Grow

If you’re a MATLAB®/Simulink® user who is considering upgrading your research lab, it may be prudent to take some time to thoroughly review your short term and long term project goals. What is the state of your lab right now?  Are students engaged, motivated and excited about your lab? Where do you want it to be in the future?

Quanser’s experiments could definitely be part of a modular, incremental, budget-friendly solution.  But don’t overlook another valuable building block to accelerating your research and moving it forward: Quanser’s QUARC® control design software. QUARC works seamlessly with MATLAB/Simulink and offers you deep capabilities that are rarely fully exploited. 

Professor Aman Behal of the University of Central Florida's Electrical Engineering Department is a case in point. He took advantage of QUARC's Rapid Control Prototyping capability to save programmers months of development time because it bridges the gap between your simulations developed in MATLAB/Simulink and the real-time controller required to drive real hardware.

 Dr. Behal and his research assistant found that QUARC control software's ability to link

"incompatible" programming languages saved them many months of costly development time.

Because QUARC proved such a timesaver for Professor Behal, he began to consider how some of Quanser’s other building blocks – hardware such as the Rotary Servo systems – can be utilized in his other capacity as a teacher.

For more details on Professor Behal’s experience with Quanser and with QUARC, click here.

Host Blocks in QUARC 2.2

In our previous blogs we introduced some of the new features of the now-released version 2.2 of our QUARC control software. Today, let's have a look at the Host Blocks in QUARC 2.2:

Redesigned Host Peripheral Framework

In previous versions, QUARC supported the use of peripherals connected to the host interacting with models running on either host or target. In QUARC 2.2, this feature has been updated by introducing a new framework to enhance usability and performance.

Features included in this new framework:

•  A new Host Initialize block,
• Updated blocks for devices, such as keyboard, mouse and game controller,
• The ability to use host devices with remote targets even without Simulink running on the host,
• The option of restricting the use of host devices to a single window on the host rather than the entire desktop.

Host Initialize Block

The Host Initialize, similar to HIL Initialize, is introduced to work as a hub for configurations and settings of the peripherals on the host PC.

Host Keyboard Block

In the previous versions, interacting with multiple keys by using the Host Keyboard blocks could lead to a messy pile of Host Keyboard blocks occupying the entire screen as the old block only processes one key per block. Thanks to the updated framework, this situation becomes history. By defining the list of keys in the block parameters dialog, the block reads the state of the specified virtual keys on the host and outputs a vector of boolean values to indicate whether or not the keys are pressed at the current sampling instant. Also, it can read the state of more than one key at the same time. Please watch the video clip in the Host Device Usage Restriction section below to see how this block works.

Host Mouse Block

The updated Host Mouse Block brings more functionality into the equation. On top of the absolute coordinates and button monitoring functions offered in the previous version, it also supports scroll wheel state monitoring (Windows Vista or later), output mouse coordinates in pixels, in screen percentage, or high resolution count.

Controlling Remote Targets With Host Devices Without Simulink Running on the Host

A new client program Host Peripheral Client has been added into QUARC 2.2 to support the use of host peripherals without Simulink running. This program monitors host devices and communicates with the Host Initialize block running on a QUARC target. This application can be run manually via its menu item under the Start/Quanser/QUARC menu, or automatically when interfacing to the model through Simulink.

Host Device Usage Restriction

The input from host peripherals can be restricted to a window instead of the entire desktop. By checking the "Use a window instead of entire desktop" option in the Host Initialize block, a special "peripheral client window" will open when the model is started (or the Host Peripheral Client application is started). Actions from host peripherals will only be recognized when this window is the active window. Otherwise they are ignored. This feature can be useful for taking advantage of the mouse as a host device, for example, because it allows button clicks and mouse movement outside the peripheral client window to be treated normally and be ignored by the model.  

NEW CAN bus support in QUARC 2.2!

Controller Area Network (aka CAN bus) is an industrial standard and communication protocol originally developed by Bosch in the 1980s to interface the various subsystems used in the automotive industry. Today, CAN is used in many real-world systems including automotive, medical, industrial automation, avionics systems, and marine systems. For example, a modern automobile may have dozens of different electro-mechanical subsystems that need to talk to one another, including the engine control unit, power steering unit, powertrain control unit, any many more.

In a nutshell, CAN is a multidrop serial bus. Devices like sensors and actuators typically interface to the CAN bus via an embedded processor and CAN controller. Every "node" on the CAN bus is able to transmit data on the bus and read data from the bus. Each message transmitted on the bus has an 11-/29-bit message ID, and when multiple nodes are trying to transmit at the same time, arbitration (who gets priority to send their message on the bus) is decided by this ID. This allows devices and controllers (nodes) on the CAN bus to publish data according to unique IDs that other nodes on the CAN bus can read.

In QUARC 2.1 there was limited CAN support via a Peak CAN USB block. The Peak CAN USB block interfaced with a USB CAN bus device from Peak System Gmbh, but the support was limited to this one device. In QUARC 2.2 that block has been replaced with the new Peak CAN block.

The new Peak CAN block in QUARC gives you CAN bus access using any of the CAN interface devices made by Peak System GmbH., including USB, PCI, PCI-express, PC/104, and many other form factors. Any device by Peak System GmbH. that supports the PCAN-Basic API is supported by this block. Simply by selecting the CAN device type in the block parameters gives you the same, uniform interface to connect your QUARC-powered controller to the CAN bus.

We are already making use of this new CAN support in QUARC to interface with advanced robotics and autonomous vehicles. Let us know how you think you can use CAN bus in your research applications! Happy CAN'ing!

Cameron

QUARC 2.2: 64-bit Platform Support for Enhanced Performance

In our August post about the soon-to-be-released QUARC 2.2 control software, I spoke about the significant reduction in model build time you could look forward to. Now I'd like to highlight another exciting new feature of QUARC 2.2: 64-bit platform support for the Microsoft Windows 7 operating system. This will result in greatly enhanced performance matched to the capabilities of the new 64-bit PCs. In other words, you will soon be able to build models and run Quanser hardware in Windows 64-bit.

Migrating or upgrading to QUARC 2.2 is even more worthwhile because we are offering it in both 32- and 64-bit versions. Your 32- or 64-bit computer will auto-select the right version. Should you be using two different targets - one a 32-bit and the other a 64-bit - there's still no problem. The QUARC host PC will be able to compile (or cross-compile, as the case may be) your model as required for each Windows target, be it a 32-bit or 64-bit. Searching for a 32-bit Windows 7 OS will be a thing of the past.

QUARC 2.2 has undergone extensive testing on the 64-bit Windows 7 system, and its release date is just around the corner. As a result, you can definitely look forward to overall improved performance and an enhanced user experience very soon.

QUARC 2.2: Significant reduction of model build time

The release of QUARC 2.2 control design software is imminent and highly anticipated throughout the control education and research community. In this post I want to introduce one of the long-awaited new features – one that should increase your anticipation even further, because it will greatly facilitate your teaching and research.

Linux Verdex Target Cross-Compilation on Host Means Much Shorter Build Time

Researchers and engineers alike have greatly appreciated QUARC’s thorough support on Gumstix Verdex, even though it could take several minutes to build a complicated model for a Verdex target. The reason why building a model took so much time was that the source code was being downloaded onto the board and built natively by the on-board ARM processor, which is not nearly as powerful as a modern CPU.

In this new release we bring an LLVM-based cross-compiler into QUARC and allow you to build code for Linux Verdex Target on your Windows host PC. By utilizing the computational power of current PCs, building time is reduced significantly. Unless you actually want to take a coffee break every time you build a model on Verdex, you’ll appreciate this new feature.

The following video clip shows the significant speed difference between the two compilers (on QUARC 2.1 and QUARC 2.2) in building the Sine and Scope Demo for the Verdex target (the one on the right side is QUARC 2.2 with the LLVM-based cross-compiler). As you'll see, the QUARC 2.2 compiler takes only 40 seconds to build its model, while the 2.1 compiler, at 120 seconds, takes three times longer.

Quanser's UVS users will be able to benefit immediately from the much faster compilation times achieved by the cross-compiler we developed and included in QUARC 2.2. The Verdex target is used in our unmanned vehicle systems (UVS) including the Qbot, Qball, HiQ, and the upcoming Quanser Ground Vehicle QGV, which we demonstrated at the recent ASEE 2011 and ACC 2011 Conferences.

Stay tuned for upcoming posts on some of the other new and very exciting advanced features of the soon-to-be released QUARC 2.2 control design software.

Click here for more information about QUARC.

Hands-on opportunity to master QUARC

Would you prefer your students focus on control design theory, rather than tedious code writing? Are you looking for a tool to accelerate your research? If your answer to either of these questions is "yes", you should consider QUARC, Quanser's control design software. You can learn more about the software on our website, but how difficult would it be for you or your students to actually master it and use it to its full potential?

Based on the experience of Dr. Rifat Sipahi from Northeastern University, you don't need to worry: "As an instructor, I always use MATLAB and Simulink in my teaching," he told us. "Then students can use their Simulink knowledge to easily interface with Quanser's QUARC, with which real-time control becomes extremely easy. In less than an hour, all undergraduate students who had no prior experience in real-time control could learn how to build a simple control loop and obtain successful experimental results."

For more evidence of just how easy it is to learn & use QUARC, take the new QUARC Interactive Tutorial (QIT), an online simulation of the software that gives you an overview of how QUARC works and how it can handle all sorts of tasks, from basic to advanced. Mr. Q, your animated guide, will demonstrate all the features and capabilities of the software and will even let you try it. With his help you can create the programming yourself and see the results, even if you don't have MATLAB or Simulink installed on your computer. Just try it! And if you have any questions, get in touch with our engineers - the very people who developed QUARC in the first place.

Stateflow with QUARC

At Quanser I am always looking to find new ways to make it easier to use our variety of products. As I developed controllers for the Quanser Qball-X4 Unmanned Aerial Vehicle (UAV) I found myself building large, complex models in order to create sophisticated, autonomous controllers. Designing a fully-autonomous controller for a complex system such as a UAV requires many considerations and safety checks to ensure the system operates safely and as it should. For example, at the start of a mission there are various initialization procedures and safety checks that occur. Then, the vehicle enters into a controlled takeoff. Next, the vehicle executes the various tasks that make up its mission. And finally, the vehicle performs a landing and power down.

These complex sequences of operating modes and transitions between modes requires careful planning and design. The most suitable design structure for this would be a state machine. Well, as I found out first hand, Simulink (although great for realt-time control) is not the best tool for designing state machines. Thankfully, The MathWorks has a blockset called Stateflow, which allows you to insert state machine charts directly into a Simulink model. The Stateflow chart gives you a graphical design environment different from Simulink and designed for state machine development.

Using Stateflow, I can develop state machines easily and quickly. Stateflow also supports code generation (with Stateflow Coder), so that I can generate code and download it to my target of choice (e.g., Gumstix with QUARC). I can also see graphically at run time the execution of the state machine and which states are currently active. Stateflow expands on the traditional Mealy/Moore state machines and provides useful tools such as temporal operators, Embedded MATLAB Functions, Simulink Functions, variables, events, and support for C-code.

In my application, the Qball UAV mission controller, I chose to divide my model into two parts: Stateflow chart and Simulink controller (although the Stateflow chart resides within the Simulink model as a block). In my Stateflow chart I put all of my state machine logic, operating mode/state, temporal operations, safety checks, etc. In my Simulink controller I build my continuous time controllers, plants, communications, and hardware-in-the-loop interfacing. This is just my preferred design methodology. This allows me to decouple my state machine and safety checks from the Simulink model, which makes extending and maintaining the model a whole lot easier. Now, my controller is not burdened with safety checks and operating mode checks dispersed throughout the model since it is all concentrated in my Stateflow chart.

In my final design, I have my main state machine that allows me to arm and disarm the Qball, schedule autonomous tasks such as waypoint tracking, automatically handle transitions between TAKEOFF, FLY, and LAND operating modes, and also concurrently monitor various safety checks. If at any time a safety check fails or timeout occurs, a LAND event is generated that forces a transition from a FLY state to a LAND state so that the Qball is forced to land.

At Quanser we see possibilities for using Stateflow in so many of our applications: haptics and telerobotics, unmanned aerial and ground vehicles, simulations and 3D visualization, rehabilitation robots, communications, large-scale integrated systems, vision-based tracking and localization, and many more. I would encourage anyone to take a look at Stateflow and try to find innovative ways to use it in Quanser experiments. Good luck!

Cameron

QUARC Software at the Heart of a Unique Subterranean Lab

Quanser is a proud partner of a unique research project underway in Canada. Toronto Rehab, Canada's largest academic health sciences centre is home to one of the world's most advanced rehabilitation facilities - Intelligent Design for Adaptation, Participation and Technology (iDAPT). The centerpiece of iDAPT is the Challenging Environment Assessment Lab (CEAL), a huge subterranean research lab with a hydraulic motion simulator where researchers can study interactions between people and their environment. To simulate different conditions, such as icy sidewalk, researchers will use large chambers that can be lifted on and off the simulator. Several Canadian companies mentioned in a recent press release lent their expertise to develop CEAL. Quanser's contribution lays right at the heart of the system: Quanser's real-time control software QUARC controls the simulator itself, enables integration of all instruments and ensures safety of the whole system. All signals from the measurement

devices - motion capture camera, force plates etc. are routed through QUARC. High performance and flexibility of QUARC's Stream API and Hardware-In-The-Loop API allow for rapid integration of all these different components. QUARC also monitors and controls all simulation systems in real time and is responsible for real-time reaction models that dictate responses of various interfaces, including the simulator, the treadmill, the visual display and the audio cueing systems. For example, to create a fall scenario on the instrumented stairs, the reaction model might specify that as soon as the participant exerts a particular force on a particular step, the simulator will be accelerated rapidly. The latency of this process, from measurement system output to simulation system input is less than 25ms.

"The power of QUARC, with Quanser's engineering support," said Dr. Geoff Fernie, Toronto Rehab's Vice President in the interview earlier this year "enabled us to create a flexible development environment for researchers to implement sophisticated real-time experiments, using a large scale 11-ton, 6-DOF motion platform and high-performance audio-visual rendering system. "

To discuss your unique research lab needs, contact info@quanser.com

What Do You Get with a QUARC 2.0 Demo License

Have you tried QUARC 2.0, the latest version of our rapid control prototyping software? You can easily get a free 30 days license which allows you to run the built-in demos even without the hardware, or build and run your own real-time control models in Simulink.

The built-in demos will:
- Introduce you to the basic QUARC features and integration with Simulink
- Show you how to use Quanser's Hardware-In-The-Loop (HIL) framework
- Demonstrates QUARC communication capabilities based on Quanser's Stream API framework
- Explain and show dynamic reconfiguration capabilty
- Present some of the third-party devices you can interface to with QUARC
- Walk you through the possible QUARC 3D Visualization features
- Help you get familiar with QUARC MATLAB functions, such as I/O operations, communications using the Quanser protocol-independent Stream API, or automating QUARC operations from a MATLAB script, etc.

Let's look at some of them a bit closer:
QUARC Communication Demos
One of the demos consists of two Simulink models: a server and a client. It demonstrates how to use the Basic Communication Blockset from the QUARC Targets Library to establish a connection between two Simulink models.

QUARC Visualization Demos
The QUARC Visualization demos demonstrate a wide range of features, including loading of a mesh and texture and displaying it in the standalone Quanser 3D viewer. You will learn how to animate and create a hierarchical relationship between the body and the propeller of an airplane or how to use the QUARC Visualization blocks with dummy actors to simplify actor animation.
We have created a Visualization of a KUKA KR5 sixx R850 Robot, so you can control it virtually, without having the actual robot in your lab.

QUARC MATLAB Demos
One of the demos demonstrates a Simulink model and a MATLAB GUI created using the GUIDE application. The MATLAB GUI can be used to build, start and stop the QUARC model in addition to perform real-time plotting and online parameter tuning on the model.

QUARC Model Referencing Demo
This demo showcases QUARC's ability to support the model referencing feature from Simulink

But it is always best to try it for yourself - so don't hesitate and ask for your free 30 days demo license here. You can also contact one of our Academic Solutions Specialists that will walk you through the QUARC's features and capabilities during a personal, one-on-one live demo. Click here to request it.

Quanser 6-DOF Open-Architecture Robot

Quanser is presenting it's latest DENSO 6-axis articulated robot. The term 'articulated' is used for robots that consist of rotary/revolute joints. These joints are linked to each other in a serial configuration. The first three joints form an anthropomorphic arm while the second three form a wrist robot. This enables the robot to position and orient its end-effector within a large workspace, similarly to a human arm that can access any position and orientation within its reach, except that it has an extra joint.

This 6-Axis robot is open-architecture, powered by our real-time software, QUARC. QUARC's blocksets along with MATLAB/Simulink provide the user with an advanced user-friendly environment which facilitates and accelerates real-time programming of this robotic manipulator.

Quanser's DENSO 6-DOF Open-Architecture Robot has a wide and still growing range of applications, such as tele-operation tasks. It can be used in a robot-assisted surgery as an instrument holder or as a guidance system adding more precision and dexterity to the operation. Another medical applications in rehabilitation and nursing assistance come to mind as well.

In addition to medical applications, Quanser's DENSO 6-DOF Open-Architecture robot can be mounted on an unmanned vehicle as a camera/tool holder in an autonomous or semi-autonomous mission. Again, it can be tele-operated as a robotic manipulator, helping in remote or hazardous environments such as bomb disposal or mine sweeping scenarios. Users can also program the robot to do accurate automated tasks repeatedly in short cycle times. For instance, it can be programmed for such industrial tasks as assembling, welding, cutting, injection, and extraction.

Quanser's DENSO 6-DOF Open-Architecture robot has its place in university engineering labs: Using QUARC, this industrial robot can be rapidly interfaced in a fully open-architecture scenario. That makes it a perfect system to teach mechatronics, robotics, and mechanics. Plus, you can use it for research and development - for instance as a part of a humanoid robot combined with artificial intelligence.

In the above video we are using our high definition haptic device as a master robot to control the motions of the 6-Axis robot in the Cartesian workspace. This is called a bilateral teleoperation setup where the forces and torques at the tip of the robot are measured and applied back to the operator through the haptic device. In order to control the ball on my racket as it bounces up and down, I use the force feedback and apply a scaled motion command. The robot control loop is running at 8kHz while the force/torque sensing is at the rate of 10kHz. The robot is incredibly fast and precise. As a next step, we plan to play a real ping-pong match between robot and human, so stay tuned for this exciting video!

Quanser robot is made to be programmed by humans to assist humans with high speeds and accuracy.

QUARC: Hard-Real-Time Performance with QNX Neutrino

QUARC supports a continually increasing number of targets. A "target" is a combination of operating system and processor for which QUARC can generate code from a Simulink diagram. The target is also where the QUARC-generated code runs. Targets constitute one of QUARC’s four pillars as described in one of the previous post. The best deterministic hard-real-time performance with QUARC is currently achieved when running the model on a QNX Neutrino target, taking advantage of the QNX Real-Time Operating System (RTOS) industry-proven technology.

The upcoming QUARC 2.1 now supports the latest QNX Neutrino, version 6.4.1. This updated support has actually been demonstrated by QNX Software Systems (QSS) themselves at the QNX booth at the Embedded World 2010 Exhibition & Conference show in Nuremberg, Germany, at the beginning of March 2010. The QNX demonstration used QUARC to run Quanser’s SRV02-based Rotary Self-Erecting Inverted Pendulum experiment equipped with a slipring in order to allow for unlimited and unhindered (due to the elimination of cables) base rotation.



The corresponding QUARC controller robustly runs in hard-real-time under QNX at a 1-kHz sample rate (i.e., 1-ms sampling interval) while communicating to a custom Flash/OpenGL-based user interface (GUI) using the Quanser Stream API (to get the updated sensor data in realtime). More information about our Stream API can be found in the QUARC: Communication Capabilities and Framework article. In addition, the Quanser Target API is also used to start/stop the QUARC control model from the QNX custom demo application. The hardware platform used for this demonstration consists of a x86 system configured by QSS to run with both Windows and QNX by means of using RTS Hypervisor. The QUARC-based controller used the RTOS system timer and has proven itself to be very stable during the 3-day Embedded World conference.

Additionally the Quanser 3D Viewer can be launched in Windows to offer a virtual 3D realistic representation of the actual system being run by QUARC.



This results in a 3D animation depicting the actual system, running in parallel, and mirroring in real-time the exact behavior of the real system. More information about this QUARC feature can be found in the QUARC: Virtual Plant Demo - SRV02 Self-Erecting Inverted Pendulum blog post.

Based on this success, Quanser is currently actively investigating supporting additional QUARC targets such as QNX PowerPC (PPC) systems as well as other possible embedded architectures.

Quanser Stream API: Powerful and Flexible Communication

The Quanser Stream API, on which QUARC Stream blocks are based, offers a flexible and communication-protocol-indent framework. It allows to carry out standard communication not only between QUARC models, but also between a QUARC model and an external third-party application (e.g. graphical user interface - GUI), or even between two external third-party applications. This feature is of great importance in various research applications where software integration, design and integration of GUI and distributed control are needed.

The Stream API is independent of the development environment and is currently fully implemented in C/C++, .NET languages, MATLAB and LabVIEW. It can be readily extended to other languages and environments as required. This makes any Quanser Stream protocol accessible from and to external applications.

The QUARC communication framework, using the Quanser Stream API, follows the well-established client/server communication mechanism implemented in either a blocking I/O mode (i.e. asynchronous I/O in a separate thread) or non-blocking I/O mode (i.e. synchronous I/O in the model current thread). The Quanser Stream communication framework is open and structured to readily accommodate and integrate new communication protocols as required. At present, the Quanser Stream API has communication protocols available for the operating systems that QUARC can target, such as Windows (32-bit XP and Vista), QNX and Linux ARM (gumstix). The Stream API also allows for switching from one communication protocol to another by only changing the Uniform Resource Identifier (URI) string defining the new protocol to be used. The rest of the blocks or functions used in the communication remain untouched!

QUARC: Virtual Plant Demo - SRV02 Self-Erecting Inverted Pendulum

True to Quanser’s learning-by-doing philosophy, the QUARC built-in demonstrations, as previously described in our QUARC: Learning By Doing post, have now been augmented in QUARC 2.0.

Amongst other added features, QUARC 2.0 includes a demonstration of Quanser’s first Virtual Plant (VP), consisting of a realistic visual and dynamic representation of Quanser’s actual SRV02 Self-Erecting Inverted Pendulum Control Challenge system. This built-in VP example simulates the dynamics and control of the corresponding Quanser actual plant and animates the experiment in full 3D realism in real-time. As usual with Quanser’s experiments, the closed-loop controller is fully open-architecture and implemented in Simulink, with all the system parameters being accessible and tunable.

Request a free demo license now. Here's what you can expect - watch this video and read on!
(video also available on YouTube)

Starting the model automatically opens the QUARC standalone 3D visualization window. The pendulum is initially in the downward position. The controller then uses an energy-based swing-up control scheme to swing the pendulum back and forth until it is close to the upright position. Once the pendulum is sufficiently close to upright and is not moving too quickly, the controller switches to a balancing control algorithm to maintain the pendulum in the vertical position. Once the pendulum is being balanced, the rotary arm is commanded using a generated square wave and the controller continues to balance the pendulum in the upright position, despite the movement of the supporting arm. Notice how the controller exhibits non-minimum phase behaviour to ensure that the pendulum does not fall when moving to the next arm position; in other words, it gives the arm an impulse in the wrong direction to get the pendulum leaning before moving the arm to the correct orientation.

If you have taken QUARC 2.0 for a test drive, you probably noticed how it can now act as a Virtual Plant Simulator (VPS) without hardware and also without Real-Time Workshop (RTW) (as the VP can be run in Simulink normal simulation mode)! Real-time operation is achieved by using the QUARC System Timebase block.

This demonstration also serves as another example of the powerful visualization capabilities provided with QUARC 2.0, including inheritance, specular lighting and fog. As a reminder, the QUARC 2.0 visualization module has been previously showcased in our Visualize Your Simulation and Quanser Visualization Blocks posts.

So what other best way is there to start the new year than to ask for a QUARC 2.0 demo license, try all these new possibilities firsthand and see it for yourself?

QUARC: The QuaRC Tetralogy

In the past few months we talked about the new features and strengths of QUARC 2.0, the new version of our popular control systems design and development software. The diagram below succinctly captures QUARC’s characteristic strengths - and some of Quanser’s domains of expertise - and illustrates QUARC’s four pillars.

Namely, the QUARC tetralogy consists of:

1. A visual programming tool, like Simulink. As a Rapid Control Prototyping (RCP) tool that provides full open-architecture, this is what QUARC fully integrates with and generates real-time code from. This visual programming tool is used as a flexible development platform and to maximize user friendliness.


2. Multiple target Operating Systems (OS). The target OS, be it either a pseudo- or hard-real-time operating system is where the QUARC-generated code is run. Currently, QUARC models run under 32-bit Windows, Linux, QNX, and INtime (to be available soon).
   
   QuaRC-generated models are optimized for robust and real-time (i.e., deterministic) performance, by strictly adhering, for example, to a true multi-rate and multi-threaded design, or by taking advantage of multi-core CPUs (CPU affinity support).


3. Hardware interfacing. QUARC allows interfacing to actual hardware in a real-time fashion by utilizing the Quanser’s HIL API and by supporting a growing number of third-party devices.
   
   The Quanser’s Hardware-In-the-Loop (HIL) API is a generic, card-independent, and extensible API. It is detailed in our QuaRC: Hardware-In-the-Loop (HIL) Card Support and HIL API post.
   
   As a complement to the HIL API, QuaRC also supports a wide variety of third-party-vendor sensors, devices, and robots, as described in our QuaRC: Third-Party Device Support article.


4. Communication capabilities. QUARC implements a very flexible and powerful communication framework that allows for carrying out standard communication not only between QuaRC models, but also and especially between a QuaRC model and an external third-party application.
   
   The cornerstone of QuaRC’s communication capabilities is the Quanser’s Stream API, which is a generic, protocol-independent, and extensible communication API. Please refer to the QuaRC: Communication Capabilities and Framework article for a more detailed description.

QUARC: Third-Party Device Support

In addition to being able to access hardware via Hardware-In-the-Loop (HIL) cards by using the familiar Simulink environment, as described in previous blog post, QuaRC also allows users to interact directly with third-party devices in a real-time fashion.

QUARC supports a wide variety of third-party-vendor devices, which can be categorized essentially into 3 main device families:

1. Sensors & Human Interface Devices (HIDs)


2. Haptic input devices


3. Robot arms

This support goes above and beyond Quanser’s very own devices as well as the standard PC peripherals, like keyboards, mice, game controllers (i.e., joysticks), or force-feedback game controllers, that QUAC also supports.

Also the nature of the interface used by any one of the QUARC-supported devices to connect to a QUARC target system (e.g., Windows 32-bit PC, QNX PC, Linux Gumstix Verdex) is almost as diverse as the types of devices supported. The interfaces used include, but are not limited to, USB, FireWire (IEEE 1394), serial (e.g., RS-232, TTL, SPI), PS2, and network (e.g., TCP/IP, UDP, ARCNET, bluetooth).

We are often asked what the actual devices currently supported by QUARC exactly are. Even though this list is continuously growing, the following summarizes the third-party devices to which Simulink-compatible blocks are offered by our upcoming version of QUARC, QUARC 2.0.

However, a device supported under one QuaRC target (e.g., 32-bit Windows) might not be supported for another QuaRC target (e.g., Linux), due to, for example, connectivity or third-party driver compatibility issues. Any QuaRC target restriction is specified in-between square brackets below.

QUARC 2.0 supports the following sensors and Human Interface Devices (HIDs).

• NaturalPoint OptiTrack motion capture and tracking camera system [win32 only]


• Point Grey Research (PGR) camera, e.g., Dragonfly2, Firefly MV [win32 only]


• GPS sensors, e.g., NMEA and Ublox


• Nintendo Wiimote [win32 only]


• SparkFun Electronics SerAccel triple-axis RS-232 accelerometer

QUARC 2.0 also supports the following haptic (i.e., position sensing and force feedback) input devices.

• SensAble PHANTOM Omni (6-DOF sensing, 3-DOF actuated), [win32 only]


• SensAble PHANTOM Desktop (6-DOF sensing, 3-DOF actuated), [win32 only]


• SensAble PHANTOM Premium devices (6-DOF sensing, 3-DOF actuated), [win32 only]


• SensAble PHANTOM Premium 6DOF devices (6-DOF), [win32 only]


• Novint Falcon (3-DOF), [win32 only]

QUARC supports the following multiple-DOF serial robot arms and robotic devices as well. By doing so, QUARC makes these robots Open Architecture (OA), which is to say that their Cartesian or joint position or rate commands can be individually set, as configured in your Simulink diagram, together with any customized advanced robotic control schemes.

• KUKA robots, e.g., KUKA KR 5 sixx R850 (6-DOF)


• Mitsubishi PA10 (6- or 7-DOF), [win32 only]


• Thermo CRS A465 (6-DOF)


• Thermo CRS CataLyst (CAT5) (5-DOF)


• Schunk Gripper (1-DOF industrial robotic end-effector), [win32 only]

QUARC is designed to meet the continually-increasing demand for interactive systems. For example, the power of QUARC is really harnessed when users easily couple one of its supported haptic input devices to one of its supported robot arms and quickly setup, in a Simulink diagram, a fully customizable teleoperation system.

Please stay tuned for announcements on additional third-party device support as well as for added QUARC support for Quanser’s very own new and exciting products, like the novel Quanser USB-Qbit and QPID boards.

Visualize Your Simulation

Watch the short video in which Derek Wight, Quanser's Engineering Manager for Electronics describes how you can turn your simulation into a 3D graphical scene using powerful OpenGL-based visualization blocks of Quanser's real-time control software QuaRC:



Read more about the visualization tools in QUARC from Derek here