Integrated Computer Engineering Stream

6 minute read

Published:

In this post, I talk about lessons I learnt in the Integrated Computer Engineering Stream.

Ideas and Concepts

I got some basic ideas about these kinds of stuff, especially in Object-Oriented Programming and Embedded System Programming. I divided those kinds of stuff into categories and I will share the experience.

Object-Oriented Programming (OOPS)

It was quite similar; we just concerned ourselves with some practical real-time scenarios unlike the typical examples provided. I was grateful to have such a good professor to nicely explain all the principles in an effective way for poor kids like me. I loved the way of teaching. Initially, when I started studying the class, it looked strange because most of the lessons and ideas were new to me, but later on, teaching with proper examples and practice questions helped me improve my OOPS skills.

Embedded Programming

This was strange at the beginning because, actually, I had no idea till I studied it deeply in the coming semesters. I will share the experience regarding that more deeply in the related parts. Keep Smiling.

Development and Improvement

Development deals with Object-Oriented Software Development, Embedded Databases, and Embedded Networks, while improvement deals with Industrial Computer Engineering and Software Engineering.

Development, though said to be the embedded one, had its basic contents explained with references to the generic one (OOPS). We were taught examples related to the real-time world, but we had a different way of representing the same thing found in OOAD for our Embedded Software Development.

Design Patterns: we all know there are 3 categories of design patterns, and we gained a better idea of these 3 kinds, especially with real-time examples such as Singleton, Observer, Abstract Factory, Builder, Proxy, etc. This was quite an interesting part of development, in addition to the generic study about design kinds of stuff with different diagrams at 4 phases of software development under the Unified Process.

When it comes to Improvement, we need to maintain a proper back-end, so we studied this during the OOSD time as an initial setup for our 3rd-semester project, and later, for the next semester, we had a deep study of it. There we studied Normal databases in depth and had some rough ideas on the embedded database (these are inbuilt within the application, no central server connection, and need some configuration to deal with central synchronization).

And Embedded Networks deals with Communication types Serial (SPI, I2C) and Parallel. Then we learned about Model-Based Design, Fault Hypothesis, Uncertainty, Real-time features (specifically OS implementation in real-time systems) as a second phase study of OOSD and third phase of PESP/ESD.

This is just an overview of the things I have learned. Specified topics for some of my favorites will be published soon.

Instrumentation Con-Trolls

Apart from the last two topics discussed above, this is different. I had undergone quite a learning process during this period of ICE, semester 5. By the end of the semester, I had learned two subjects, one is the control system and another is instrumentation.

Control System means generally a feedback system used to enhance the system performance by proper feedback of the values required. For ease of studies, these are dealt with in the S-Domain regardless of the usual time domain system.

General Open Loop System: Y = P X, where X is Input, Y is Output and P is Process.

In case of Feedback, it will change into Y = XP / (1 + P). If it has a function F, then 1 will be replaced with F. If it has control like PID Control, it will multiply by the control factor C and also P is replaced by PC, thus final Y = XPC / ( F + PC). This is the one-word summary of the control system. It doesn’t deal with MATHS, it deals with physical entities.

PID Control: Proportional (Kp) Integral (Ki) Deferential (Kd). This has the same meaning as maths, and it applies effectively to get control values.

Examples: To gain the necessary speed, we can apply proportional control, which proportionally increases the speed and lets us get into reference speed. But to stop at a particular distance we can’t exactly stop proportionally; for that case we need a differential control. And to have a better drive in all cases we need integral control.

If the error function is e, then the result after PID control will be,

U = Kp.e + Kip.e + Ki. Integration(e) + Kdd.Differentiation(e). Here U and e belong to s domain.

Phase and Gain Margin are two factors that determine the stability of the system: going outside these will be unstable, and between gain and phase is a little bit at normal, before Gain is the best region.

Fun with PLC

A quite interesting thing I learned during the 5th Semester in the Module CS3332: Industrial Instrumentation Control is PLC Programming. Here I have to express my experience specific to that and the problems I encountered regarding it.

Note this is just my writing, don’t rely on this for official conduct. This may be right or wrong.

PLC Programming can be done with different methodologies.

  1. Ladder Program
  2. Structured Text
  3. Functional Block Diagram
  4. Instruction List
Reference : http://www.ehow.com/list_7155812_plc-programming-methods.html

For us, we tried to get familiar with Ladder Program, which was quite easy, just drag and drop GUI techniques, but for big-level applications, it will be quite difficult; for every output required we need a lengthy ladder, while an instruction list or structured text can easily be achieved in a few lines. So the ladder is not good enough at all places.

Ladder Programming

It is generally based on components with GUI demonstration, and for executing each output one line of ladder is required. A set of lines is called a program, and at the start and end it has to stop with -| slashes like this, and finally it will look like a ladder; that is why they called it a Ladder program, not sure, I just heard it as so.

Tools Required for Ladder Programming: XCP Program tool and XC3- PLC can be used to do practicals efficiently with Ladder Programming.

These are just some basic ideas and concepts if time supports I will share ideas deeply from what I learned.

You May Also Enjoy

Time Complexity of Single-Source Shortest Path Algorithms

4 minute read

Published:

Graph data structures are widely used to represent different aspects of computer science (e.g., road networks). We can denote a graph as \(G = (V, E)\), where \(V\) represents the set of vertices (in the context of a road network, these represent intersections), and \(E\) represents the set of edges (representing road segments). We generally define \(n~(= |V|)\) as the number of vertices and \(m~(= |E|)\) as the number of edges to express the time and space complexity of graph algorithms. One such problem is single-source shortest path (SSSP), which is used to find the shortest path from a single node to all other nodes. For decades, Dijkstra’s algorithm has been the go-to method for solving this problem. The runtime of Dijkstra’s algorithm depends on the priority queue implementation and often has a complexity of \(O(m + n \log n)\). Read more

CPU/GPU/TPU Performance Comparison

7 minute read

Published:

I have implemented a simple comparison of performance on Google Colab CPU, GPU, and TPU as part of an assignment for COSC 6385 course at the University of Houston. Read more

Spectre Vulnerability Simulation

2 minute read

Published:

In this post, I share some details on my extension to a simple simulation for the Spectre attack as part of the assignment for COSC 6385 course at the University of Houston. Read more

Meltdown Vulnerability Simulation

5 minute read

Published:

I have implemented a simple simulation for the Meltdown vulnerability as part of the assignment for COSC 6385 course at the University of Houston. Read more