Model based design and automated code generation from Simulink targeted for TMS570 MCU

The Inverse Kinematics (IK) algorithms implemented in the open-source Orocos Kinematics and Dynamics Library (KDL) are arguably the most widely-used generic IK solvers worldwide. However, KDL's only joint-limit-constrained IK implementation, a pseudoinverse Jacobian IK solver, repeatedly exhibits false-negative failures on various humanoid platforms. In order to find a better IK solver for generic manipulator chains, a variety of open-source, drop-in alternatives have been implemented and evaluated for this paper. This article provides quantitative comparisons, using multiple humanoid platforms, between an improved implementation of the KDL inverse Jacobian algorithm, a set of sequential quadratic programming (SQP) IK algorithms that use a variety of quadratic error metrics, and a combined algorithm that concurrently runs the best performing SQP algorithm and the improved inverse Jacobian implementation. The best alternative IK implementation finds solutions much more often than KDL, is faster on average than KDL for typical manipulation chains, and (when desired) allows tolerances on each Cartesian dimension, further improving speed and convergence when an exact Cartesian pose is not possible and/or necessary.

Collision-free inverse kinematics of the redundant seven-link manipulator used in a cucumber picking robot

Lab 8 - Getting Familiar with Code Composer Studio

Automatic code generation for production automotive powertrain applications introduces many challenges for the tool vendor. Resource efficiency, reliability, and product process development issues need to be addressed. Automatic code generation used for rapid prototyping systems usually will not satisfy the requirements necessary for production oriented code generation. Some of the requirements critical to automatic code generation are not immediately obvious to a tool vendor who is not active in the user's industry. The purpose of this paper is to address some of the most common requirements for production automotive powertrain code generation.

The low-code approach is an important area of research being developed to improve the rapid creation and performance of software applications. This approach allows developers and users to easily create software applications through an interactive interface. Existing research shows that the low-code approach accelerates the development process in innovative ways, saves effort and time, and reduces code complexity. This study analyses and compares automatic code generation and transformation techniques in low-code platforms. The study analyses the contributions of automatic code generation and transformation to software engineering processes and evaluates the impact of these techniques on software product quality and development speed. The importance of the Model-Based Development (MBD) approach in automated code generation processes is highlighted. It is stated that MBD provides benefits such as speeding up the software development process and reducing errors by enabling automatic code generation from high-level abstract models. In the study, various literature studies were evaluated to examine the impact of automatic code generation and transformation techniques on the application development process. These studies have shown how automatic code generation and transformation techniques are applied, what results are achieved and what contributions these techniques make to the software development process. The results of the study show that automatic code generation and transformation techniques have a great impact on the application development process. In particular, the acceleration of the software development process, the reduction of errors and the ability to produce more effective and efficient software products are important benefits of these techniques. In addition, it has been found that this approach increases the success of software projects by enabling software developers to produce fast and accurate solutions in complex systems. In this context, the importance of automatic code generation and transformation techniques plays an important role in software development processes.

The deployment of a client–server-based distributed intelligent system involves application development in both the network domain and the device domain. In the network domain, an application server (typically in the cloud) is deployed to execute the network applications. In the device domain, several Internet of Things (IoT) devices may be configured as, for example, wireless sensor networks (WSNs), and interact with each other through the application server. Developing the network and the device applications are tedious tasks that are the major costs for building a distributed intelligent system. To resolve this issue, a low-code or no-code (LCNC) approach has been purposed to automate code generation. As traditional LCNC solutions are highly generic, they tend to generate excess code and instructions, which will lack efficiency in terms of storage and processing. Fortunately, optimization of automated code generation can be achieved for IoT by taking advantage of the IoT characteristics. An IoT-based distributed intelligent system consists of the device domain (IoT devices) and the network domain (IoT server). The software of an IoT device in the device domain consists of the Device Application (DA) and the Sensor Application (SA). Most IoT LCNC approaches provide code generation in the network domain. Very few approaches automatically generate the DA code. To our knowledge, no approach supports the SA code generation. In this paper, we propose DeviceTalk, an LCNC environment for the DA and the SA code development. DeviceTalk automatically generates the code for IoT devices to speed up the software development in the device domain for a distributed intelligent system. We propose the DeviceTalk architecture, design and implementation of the code generation mechanism for the IoT devices. Then, we show how a developer can use the DeviceTalk Graphical User Interface (GUI) to exercise LCNC development of the device software.

We introduce and examine the property of repeatability of inverse kinematics algorithms for mobile manipulators. Similarly to stationary manipulators, repeatability of mobile manipulators is defined by requiring that a closed path in the task space should be transformed by the inverse kinematics algorithm into a closed path in the configuration space. In a simply connected, singularity-free region of the task space, a necessary and sufficient condition for repeatability is derived as the integrability condition of a distribution associated with the inverse kinematics algorithm.

Analytical performance estimation during code generation on modern GPUs

Automated code generation has revolutionized software development, enabling developers to accelerate project timelines and reduce manual coding errors significantly. As reliance on these technologies grows, the inherent weaknesses of generated code become increasingly apparent. Recent studies have shown that code produced by AI is not inherently safer or of higher quality than human-written code, often replicating existing vulnerabilities. <p xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">To this end, we propose SECURECODER, which integrates Retrieval-Augmented Generation (RAG) with Common Weakness Enumeration (CWE). SECURECODER first utilizes the advanced reasoning capabilities of large language models (LLMs) to generate natural language descriptions of the code’s core business logic and functionality. Then, from a semantic perspective, it matches the requirements of the code generation task with the CWE descriptions through a multi-label classification process. Finally, based on the matched CWE, SECURECODER generates a list of security guidelines the code generation model must adhere to. Breaking down end-to-end code generation tasks into single-target tasks that LLMs excel at ensures that the generated code not only meets functional requirements but also adheres to best security practices, thereby enhancing the interpretability of the automated code generation process. After evaluating 2 programming languages and 7 LLMs on Coploit-generated code, SECURECODER has great generalization capability and could be applied to more programming languages and vulnerability types. SECURECODER could significantly decrease the security weakness in the AI-generated code and is able to mitigate more than 65% of vulnerabilities exposed to software developers. Compared to the baseline open-source LLMs, code vulnerabilities were reduced by at least 14% and the code business logic was not affected.

. This paper presents a multi-language and multi-environment generation of nonlinear finite element codes. The system consists of two major components. The Mathematica package AceGen is used for the symbolic derivation of formulae needed in numerical procedures and automatic code generation. The Computational Templates package is a collection of prearranged modules for the automatic creation of the interface between the finite element code and the finite element environment. The AceGen and the Computational Templates packages together enable multi-language and multi-environment generation of nonlinear finite element codes from the same symbolic description. The approach implemented in AceGen avoids the usual problem of uncontrollable growth of expressions by combining several techniques: symbolic and algebraic capabilities of Mathematica, an automatic differentiation technique, automatic code generation, simultaneous optimization of expressions; and theorem proving by stochastic evaluation of the expressions.

Lab 9 - DSP Integration Examples

In this study, inverse kinematics is solved for the European Robotic Arm. This robot is a type of space manipulator and has seven degrees of freedom. Forward and inverse kinematic is obtained by a new geometrical method. The limitations of robot workspace are calculated for robot joints and grippers. A geometrical inverse kinematic is presented for the first time, and the transferring process for various situations is developed to grasp the object at any position and orientation. Considering multiple missions, for robots in the transferring process, there isn’t a unit method to support all the situations and tasks in the inverse kinematic problem. To determine the workspace of robot, its geometry and object situation (orientation and position) are considered. To this end, using the suggested inverse kinematic algorithm, the target coordinate and orientations are obtained. In the presented inverse kinematic algorithm, an analytical method is used to derive the joint space variables in terms of workspace variables. The European Robotic Arm can move step by step from one target point to the next one. So, a general transferring algorithm is presented to realize the robot’s mission. In the presented algorithm, when the target is unreachable by the one-step operation, the transferring mission is utilized by the robot. Some simulation plans, to validate the proposed algorithms, indicate that the presented method works correctly.

The model-based approach has been widely applied to the design of software. However, most of these approaches depend on simulation and manual code implementation, which reduces the efficiency and quality of software. In this paper, we present a new model-based approach, which automatically generates the executable C++ code running on the popular Robot Operation System (ROS). Our approach consists of three phases: modeling, verification, and automatic code generation. In the modeling phase, the internal interaction behaviors of robot systems are modeled as a network of timed automata. In the verification phase, the safety requirements are formalized and verified. In the code generation phase, a code generation tool can generate executable C++ code from the verified timed automata model. It bridges the gap between the formal model and the error-prone system implementation. Compared with existing method, the code generator provides the abstractions and mapping of ROS instructions, which realize the seamless connection between the generated code and ROS. The tool also supports most of the complex structures and advanced features of timed automata such as timer, committed location, and synchronous action. For evaluation, a real-industrial robot application of grasping a cup is conducted using our model-based design method, and the generated code can be directly deployed and successfully accomplishes the grasping task.

UML is an industry standard abstraction language, which encompasses a wide range of structural and behavioural diagrams. It reduces the gap between the functional requirements and system design phase of the software development process. Automated code generation from UML reduces development time and enables effective communication between managers and developers. Our tool exploits the one to one mapping between structural diagrams and object oriented code. Behavioural diagrams like activity, sequence and state diagrams are merged into a single structural diagram for code generation. The UML design diagrams are converted to platform independent textual representation, XML Metadata Interchange (XMI). The XMI parser generates an abstract syntax tree (AST). A template matching algorithm is used to convert the AST to the Java code. The tool also enables code generation in a phased manner to implement and verify the features of each diagram. The evaluation of the tool is shown using a case study and the results are compared with existing open source code generation tools. The generated OO code is functional and executable.

Automatic code generation has been around for a long time, and the core technologies used are constantly evolving. Around application development work in the demand for high quality code generated rapidly, this paper proposes a automatic code generation method based on sequence generative adversarial network, the method adopts the adversarial learning thought, using LSTM as a generator, CNN as a discriminator, both through against each other to generate higher quality code samples. Experiment results show that this method can generate code automatically at the second level, and is significantly better than the existing methods in terms of generation rate and accuracy, which explores a new way of automatic code generation.