Learning paths available at Qt Academy for Qt Certification

 

Absolutely, Satyendra! Here's a blog article tailored for your audience, showcasing the learning paths available at Qt Academy for Qt Certification. You can publish this on LinkedIn, Medium, or your personal site to guide fellow engineers and learners.

---

🚀 Navigating Qt Certification: Learning Paths at Qt Academy

As the demand for cross-platform development continues to rise, Qt remains a powerhouse framework for building robust desktop, embedded, and mobile applications. Whether you're a seasoned developer or just starting your journey, Qt Academy offers structured, hands-on learning paths to help you master the framework and earn industry-recognized certifications.

🎯 Why Qt Certification Matters

Qt Certification validates your expertise in:

• Object-oriented design using Qt’s meta-object system
• GUI development with Qt Widgets and QML
• Event handling, signals and slots, and threading
• Internationalization, containers, and file I/O
• Best practices for scalable, maintainable code

For professionals working in automotive, industrial automation, or mobile platforms — like myself — Qt Certification is more than a badge. It’s a career accelerator.

---

🏫 Qt Academy: Your Guided Learning Hub

Qt Academy’s Learner Dashboard provides a personalized roadmap to certification. Once you sign in, you’ll find:

1. Qt Foundations Track

Perfect for beginners and intermediate developers, this track covers:

• Qt Creator IDE essentials
• Signals, slots, and event-driven architecture
• Qt containers and string handling
• Object model and memory management

💡 Ideal prep for the Qt Certified Developer – Foundation Level exam.

2. Advanced Qt Development

For those ready to go deeper:

• Multithreading and concurrency
• Model/View architecture
• Custom widgets and styles
• QML and Qt Quick for modern UIs

💡 Aligns with the Qt Certified Specialist and Advanced Developer certifications.

3. Embedded & Automotive Focus

Specialized modules for:

• Qt for MCUs and embedded Linux
• HMI design for automotive dashboards
• Performance optimization and deployment

💡 Great for engineers working with HIL systems, CAN protocols, or real-time interfaces.

---

🧪 Practice, Assess, Certify

Each learning path includes:

• Interactive lessons and quizzes
• Code challenges and labs
• Mock exams and certification prep

You can track your progress, revisit modules, and even earn digital badges along the way.

---

🌍 Global Recognition, Local Impact

Whether you're based in India, the EU, or anywhere else, Qt Certification from Qt Academy is globally recognized. It opens doors to roles in:

• Embedded systems engineering
• GUI development for industrial automation
• Automotive HMI design
• AI-integrated Qt applications

---

📝 Final Thoughts

As someone who’s worked extensively with QtC++, PyQt, and HIL testing, I can vouch for the value of structured learning. Qt Academy makes it easy to level up — whether you're preparing for your first certification or deepening your mastery.

Ready to start? Head over to the Qt Academy Learner Dashboard and choose your path.

---

Would you like me to format this for LinkedIn or add a personal intro about your own Qt journey? I’d be happy to tailor it further!

The Road Less Tested: How I Conquered the ISTQB CTFL Exam from Andhra Pradesh, India

ISTQB® Certified Tester Foundation Level-ITB

 There are moments in your career that feel like pivotal turning points – a moment when preparation meets opportunity, and self-doubt gives way to quiet triumph. For me, that moment arrived when I saw "Pass" flash across my screen after completing the ISTQB Certified Tester Foundation Level (CTFL) exam. And let me tell you, earning this certification, particularly through the Indian Testing Board (ITB), felt like a significant milestone right here from my base in Andhra Pradesh.

For many of us in the software industry, quality assurance is the bedrock upon which successful products are built. The CTFL isn't just a badge; it's a foundational understanding of what it truly means to deliver quality. My journey to this certification was a testament to persistent effort, strategic study, and perhaps, a healthy dose of stubbornness.

The Challenge Accepted

The CTFL syllabus is deceptively comprehensive. It covers everything from the fundamentals of testing and its lifecycle to static and dynamic techniques, test management, and tools. Each chapter builds upon the last, and the exam questions are notorious for their nuance – designed to catch out those who merely skimmed the surface. It wasn't about rote memorization; it was about understanding the essence of good testing.

My study routine involved:

• Deep Dives into the Syllabus: I treated the official ISTQB syllabus document like my holy grail. Reading it once wasn't enough; I went through it multiple times, highlighting, making notes, and drawing connections between chapters.

• Practice, Practice, Practice: Mock exams and sample questions were my best friends. Each incorrect answer became a learning opportunity. I didn't just note the right answer; I dissected why it was right and, crucially, why my initial choice was wrong. This iterative process solidified my understanding.

• Thinking Like a Tester: The biggest shift in my mindset was moving beyond theoretical definitions to practical application. I constantly asked myself, "How would this concept apply in a real-world project?" or "Why is this particular technique beneficial at this stage?"

The Exam Day Drama

Sitting for the exam, I booked a Pearson Vue certified test center in Vijayawada, added a travel task to test center from my base Guntur. The clock was ticking – 40 questions in a brisk 60 minutes. Every question felt like a mini-challenge, requiring sharp focus and quick recall. There were moments of genuine uncertainty, questions that seemed to have two equally plausible answers. This is where the practice came in handy, helping me quickly eliminate distractors and trust my gut. I meticulously managed my time, ensuring no single question consumed too much precious time.

When the final click registered and the results screen loaded, there was a palpable sense of anticipation. And then, there it was: "Pass." A wave of relief, followed by quiet satisfaction, washed over me. It wasn't just about ticking a box; it was about the growth, the deeper understanding, and the validation of my commitment to quality.

My Essential Advice for Aspiring CTFL Testers:

1. Embrace the Syllabus: It's your foundational text. Understand its structure and the interdependencies of its chapters.

2. Go Beyond Memorization: The exam tests comprehension. Focus on the "why" and "how" of testing principles and techniques, not just the "what."

3. Hone Your Time Management: Practice with timed mock exams. Learn to quickly identify questions you know and efficiently manage those that require more thought. Flag questions for review if needed.

4. Leverage Official Resources: Utilize the official sample exams and glossaries provided by ISTQB and ITB. They are tailored to the exam's style.

5. Stay Persistent: The journey can feel long, but consistency is key. Even short, focused study sessions can add up significantly.

Passing the ISTQB CTFL through ITB has not only enhanced my technical toolkit but has also reinforced my belief in continuous learning. It's a reminder that no matter where you are, with dedication and the right strategy, you can achieve your professional goals.

To all the aspiring testers out there, I say: you've got this. The world of quality awaits!

My Journey to Passing the NVIDIA Certified Associate: Generative AI LLMs Exam

 

 NVIDIA Certified Associate Generative AI LLMs Exam

Here is a story of my preparation and a summary of the tips I would give based on that "experience."

The NVIDIA Certified Associate: Generative AI LLMs exam had been on my radar for a while. As a developer working with AI, it felt like a crucial next step to validate my skills and show I wasn't just following tutorials but truly understood the ecosystem. I had heard a few things about it: it was tough, the time limit was tight, and it had a strong focus on NVIDIA's own tools. With those in mind, I dove into my preparation.

My first step was to find a solid study plan. I looked for a comprehensive video course but quickly realized they were a bit thin on the ground. Instead, I decided on a self-guided approach, using a mix of official NVIDIA documentation, blog posts from other developers who had passed, and my own hands-on projects.

I spent a lot of time on the NVIDIA Deep Learning Institute (DLI) website. Their free courses and workshops were invaluable, especially the ones on prompt engineering and building applications with LLMs. I also bought a mock exam from a third-party site. While the questions weren't identical to the real thing (maybe a 5-10% overlap), it was an excellent way to get a feel for the format and, most importantly, the intense time pressure. The real exam is 50 questions in just 60 minutes.

Exam Day: The Moment of Truth

When exam day arrived, I was nervous but felt well-prepared. I logged into the remote proctored session and started the clock. The first few questions were what I expected: basic concepts on transformers, activation functions, and general machine learning principles. But soon, the questions started to get more specific. I immediately realized two things:

1. The NVIDIA Ecosystem is Critical: There were multiple questions about what specific NVIDIA product to use for a given task. I saw questions on NVIDIA NeMo for building conversational AI, the Triton Inference Server for deployment, and TensorRT for model optimization. Knowing what each tool does and doesn't do was a major key to success.

2. Theory Meets Application: It wasn't enough to know what backpropagation was; I had to understand its purpose. A question on why an autoencoder is good for anomaly detection forced me to think beyond the definition and apply the concept. The question about the CPU-GPU bottleneck was another one that required practical, not just theoretical, knowledge.

I used the "flag for review" feature liberally. If a question required me to pause and think for more than a minute, I made an educated guess, flagged it, and moved on. This strategy was crucial, as I managed to get through all 50 questions with about five minutes to spare. I used that time to quickly revisit the questions I had flagged and double-check my answers. When I submitted the exam, I held my breath. A few seconds later, the screen refreshed, and I saw the "Pass" notification. Relief!

My Top 5 Tips for Passing the Exam

Based on my "experience," here are the most important tips I'd give to anyone preparing for this certification:

1. Master the NVIDIA Tools: This is non-negotiable. You must know the purpose of NeMo, TensorRT, and the Triton Inference Server. Understand what problem each one solves in the AI development lifecycle. For example, remember that Triton can serve models on both CPUs and GPUs, and TensorRT is for inference optimization, not training.

2. Understand Foundational Concepts Deeply: Go beyond memorizing definitions. Know why Transfer Learning is so powerful and when to use it. Understand the core function of the CLIP model and how it creates a shared embedding space for different data types.

3. Learn the RAG Workflow: The exam will likely have questions about Retrieval-Augmented Generation (RAG). Know the steps: chunking your data, embedding it, storing it in a vector database, and retrieving relevant context to augment your LLM's response.

4. Practice Time Management: Take mock exams to simulate the time pressure. The one-hour time limit is very real, and getting bogged down on a single question is the easiest way to fail. The best strategy is to answer what you know quickly and come back to the harder questions if you have time.

5. Focus on Trustworthy AI: This is a smaller but important section. Understand the core principles of ethical AI, like fairness, accountability, and transparency. A question about the purpose of a Trustworthy AI certification process might pop up.

The NVIDIA Certified Associate: Generative AI LLMs exam is a fantastic way to validate your skills in a rapidly evolving field. But let's be honest, studying for it can feel like navigating a maze with a blindfold on. When I decided to pursue this certification, I found that traditional video courses and structured materials were surprisingly sparse. So, I built my own study strategy, and in the end, it paid off. 

 My best advice is to read the question, make your most informed choice, and if you're not 100% sure, flag it and move on. The "review" feature is your best friend.

Concepts you need to nail:

1.  Prompting 

• Zero-Shot Prompting: You give the model a task or question without any examples, relying on its pre-existing knowledge to generate a response.
• One-Shot Prompting: You provide the model with a single example of an input-output pair within the prompt to guide its behavior.
• Few-Shot Prompting: You include a small number of input-output examples in the prompt, allowing the model to learn a pattern and produce a more accurate or formatted response.

2. The Importance of Transfer Learning Transfer learning is a recurring theme. Understand its goal—to take a model trained on one task and apply its learned features to a new, related task. This is the entire principle behind fine-tuning large language models (LLMs) to perform specific functions.

3. Recognize Common Bottlenecks One of the most practical questions was about a data bottleneck between the CPU and GPU. The correct answer to solve this is to increase the CPU core count. This ensures the CPU can feed data to the GPU fast enough to keep it utilized.

4. Know Your NVIDIA Product Ecosystem Don't confuse NVIDIA's products! I almost did. NVIDIA NeMo is the framework for building conversational AI models. Don't mix it up with Metropolis (for vision AI) or DeepStream (for streaming video).

5. How Autoencoders Detect Anomaly This was a tricky one. Autoencoders are excellent at anomaly detection because they are trained to reconstruct normal data. An anomaly—anything outside of the normal data distribution—results in a high reconstruction error because the model doesn't know how to rebuild it accurately. This high error is the signal for an anomaly.

6. TensorRT and Triton Inference Server You will likely see questions on these. Remember that Triton Inference Server is not limited to serving models on GPUs; it can also use CPUs. And TensorRT is an SDK for optimizing and deploying models for inference, not for training them.

A Question on Neural Networks -  BackPropagation 

Backpropagation, short for "backward propagation of errors," is a fundamental algorithm used to train artificial neural networks. It's the engine that allows a neural network to learn from its mistakes and improve its predictions over time.The training process for a neural network using backpropagation involves an iterative loop that repeats for many "epochs" (full passes through the training data):

1. Forward Pass: The network makes a prediction on the input data.

2. Loss Calculation: The error is calculated using a loss function.

3. Backward Pass (Backpropagation): The error is sent backward through the network. At each layer, the algorithm calculates how much each neuron's weights and biases contributed to the final error.

4. Weight Update (Gradient Descent): An optimization algorithm, most commonly Gradient Descent, uses the gradients calculated by backpropagation to update the network's weights and biases. The weights are adjusted in the direction that minimizes the loss.

This process of forward pass, loss calculation, backpropagation, and weight update is repeated thousands or millions of times until the network's performance reaches a satisfactory level, or the loss no longer significantly decreases.

The Relationship with Gradient Descent

It's common for people to confuse backpropagation with gradient descent, but they serve different, complementary roles.

• Backpropagation: The algorithm for calculating the gradients (the "how-to" guide for finding the error contribution of each weight).

• Gradient Descent: The optimization algorithm that uses the calculated gradients to actually update the weights (the "action" of adjusting the weights to reduce error).

In simple terms, backpropagation provides the information (the gradients), and gradient descent uses that information to make the necessary changes to the network. Together, they form the core of how modern deep learning models learn.

Passing this exam requires a solid understanding of both the theory and the practical applications of generative AI. By focusing on these core concepts and managing your time wisely, you've got a great shot at success. Good luck!

Question Format.

1. Which RAPIDS component is primarily used for GPU-accelerated tabular data manipulation?

• cuML
• cuGraph
• cuDF
• cuSignal

• Answer: C

Here is my certification Badge from Credly.

Copy, xCopy to an USB using Win Command Prompt.

How to Copy Files and directories using xcopy to a USB Using Windows Command Prompt (CMD).

Find out the drive letter of your USB flash drive

---------------------------------------------

command prompt: wmic logicaldisk where drivetype=2 get deviceid, volumename, description

Change to the drive from the above command output

Lets Say,and create a folder there

G:

mkkdir bkup

Copy Files and Folders from Source to Target

--------------------------------------------------

copy show.pptx to G:\bkup

use xcopy

-----------

xcopy "C:\Users\username\documents docs\" G:\ /e /h /

Shell Script to Run a Python Script ( Take Main.py and an Excel WorkBook as Inputs)

 #!/bin/bash

# Read Python and Excel Files as Inputs,Write Result to Excel Workbook.

helpFunction()

{

   echo ""

   echo "Usage: $0 -a Main.py -b Automation.xlsx "

   echo -e "\t-a Python Main Script File eg: main.py"

   echo -e "\t-b Excel Workbook eg: /home/user/PycharmProjects/Automation.xlsx"

 

   exit 1 # Exit script after printing help

}

while getopts "a:b:c:" opt

do

   case "$opt" in

      a ) parameterA="$OPTARG" ;;

      b ) parameterB="$OPTARG" ;;

     

      ? ) helpFunction ;; # Print helpFunction in case parameter is non-existent

   esac

done

# Print helpFunction in case parameters are empty

if [ -z "$parameterA" ] || [ -z "$parameterB" ]  

then

   echo "Some or all of the parameters are empty";

   helpFunction

fi

# Begin script in case all parameters are correct

echo "Given Python File: $parameterA"

echo "Given ExcelWorkbook File: $parameterB"

./venv/bin/python $parameterA $parameterB    

Parse PySerial Port Command And Its Response and Compare with Expected String(Mark as Pass/Fail in Excel WorkBook) Qualcomm MCU- Automotive

 # Opening serial ports

import io

import os

import re

import sys

import time

import serial

import openpyxl

# for sheet with timestamp

from datetime import datetime

from openpyxl.styles import colors

from openpyxl.styles import Color, PatternFill, Font, Border

print(sys.argv[0])  # prints python_script.py

# Serial Port Init Related

ser = serial.Serial('/dev/ttyUSB1', 115200) ## open serial port

print("Serial Instance Configuration: ", {ser}) ## check which port was really used

# opening the source excel file

#filename = "/home/user/PycharmProjects/readsepthread/Automation.xlsx"

filename = sys.argv[1] #sys.argv is a list in Python that contains all the 

                    #command-line arguments passed to the script

#print("xls_fileName", {filename})

# workbook instance

wb1 = openpyxl.load_workbook(filename, data_only=True)

# worksheet1 from the above workbook

ws1 = wb1.active #Active Worksheet that is opened 

# calculate total number of rows and columns in source excel file

mr = ws1.max_row

mc = ws1.max_column

print('total no of rows ', {mr}, 'total no of cols ', {mc})

# utility Methods

def _readline(self):

    eol = b'\r'

    leneol = len(eol)

    line = bytearray()

    while True:

        c = ser.read(1)

        if c:

            line += c

            if line[-leneol:] == eol:

                break

        else:

            break

    return bytes(line)

# utility Methods

def copytoNewSheet():

    print("copytoNewSheet Method")

    now = datetime.now()  # current date and time

    year = now.strftime("%Y")

    month = now.strftime("%m")

    day = now.strftime("%d")

    time = now.strftime("%H %M %S")

    # print("time:", time)

    date_time_sheet = now.strftime("%d %b %Y " + time)

    target = wb1.copy_worksheet(ws1)

    target.title = str(date_time_sheet)

    # saving the destination excel file

    wb1.save(str(filename))

    wb1.close()

# serial port Methods

def close_port():

    ser.close()   # close port

# serial port Methods

def open_port():

    if ser.isOpen():

        ser.close()

        ser.open()

        time.sleep(1)

        print('SA8295P_v2.1_ft0_ADP_Air_v1.0.1_UFS_NORMAL')

def rd_frm_xl_wrt_to_ser():

    ser.flush()

    # Writing to  port

    for row in ws1.iter_rows(min_row=2, max_row=mr, min_col=2, max_col=2, values_only=True):

        for cell in row:

            # print(cell)

            ser.write(str.encode(cell))

            ser.write(str.encode("\r"))

            time.sleep(1)

    time.sleep(1)

def rd_frm_ser_wrt_xls():

    # Reading from a serial port

    expected_output_LIST = []

    mr = ws1.max_row

    index_value = 1

    pairsofdata = " "

    MAINCOLLECTOR = []

    a = None

    b = None

    while True:

        try:

            print(f"Entering Iteration - {index_value}")

            if ser.inWaiting() >= 0:

                ourStr = ser.readline().decode('utf-8').strip() #Read Only single Line from Qualcomm Device Serial port

                print("ourStr: ", ourStr)

                #Strings Parsing and deriving needed string

                if not pairsofdata.endswith(" ~~ "):

                    pairsofdata = pairsofdata + ourStr + " ~~ "

                    continue

                pairsofdata = pairsofdata + ourStr

                print("This is the pair of data")

                print(pairsofdata)

                count = pairsofdata.count(" ~~ ")

                print("Count of Tildes:", count)

                if count == 1:

                    MAINLIST = pairsofdata.split(" ~~ ")

                    print("MAINLIST :", MAINLIST)

                   

                if len(MAINLIST) == 2:

                    ####### Extracting the second element from MAINLIST 

                    

                    expectedOutput = ws1.cell(row=index_value + 1, column=3).value

                    #this is the Command Reponse from Qualcomm Board. # response of commands such as ls, ps 

                    print("This is expected value:")

                    print(expectedOutput)

                    

                    if MAINLIST[1] == expectedOutput:

                        print(f"I have found the data {MAINLIST[1]}")

                        # update Result as Pass in to the column 4.

                        Res = ws1.cell(row=index_value + 1, column=4)

                        Res.value = 'Pass'

                        my_green = openpyxl.styles.colors.Color(rgb='00FF00')

                        my_fill = openpyxl.styles.fills.PatternFill(patternType='solid', fgColor=my_green)

                        Res.fill = my_fill

                        Reason = ws1.cell(row=index_value + 1, column=5)

                        Reason.value = 'Both the Actual output and Expected Output Matches,Hence TC is Pass.'

                    else:

                        # update Result as Fail in to the column 4.

                        Res = ws1.cell(row=index_value + 1, column=4)

                        Res.value = 'Fail'

                        my_red = openpyxl.styles.colors.Color(rgb='00FF0000')

                        my_fill = openpyxl.styles.fills.PatternFill(patternType='solid', fgColor=my_red)

                        Res.fill = my_fill

                        Reason = ws1.cell(row=index_value + 1, column=5)

                        reason_str = ('ExpectedOutput is: ', str(expectedOutput), 'Actual Output is: ', str(ourStr))

                        Reason.value = str(reason_str)

                    ####### Post Processing and clearing data

                    pairsofdata = " "

                    index_value += 1

                    if index_value == mr:

                        break

                    continue

                continue

            if index_value == mr + 15: # Lets have 15 total BSP commands (Increment this if you added more commands)

                break

            index_value += 1

        except Exception as e:

            print(" Interrupt Error is here  :-- ")

            print(e)

            break

    #Save the workbook A New Sheet with Date timestamp have been added.

    wb1.save(filename)

    #close workbook

    wb1.close()

 

if __name__ == '__main__':

    # Call all the API in serial manner.

    open_port()

    rd_frm_xl_wrt_to_ser()

    rd_frm_ser_wrt_xls()

    copytoNewSheet()

    close_port()

Read Write Serial Data (PySerial) Qualcomm QNX OS Board

# This is a sample Python script.
import io
import os
import re

import sys
import time
import serial
import openpyxl

# for sheet with timestamp
from datetime import datetime
from openpyxl.styles import colors
from openpyxl.styles import Color, PatternFill, Font, Border

print(sys.argv[0])  # prints python_script.py

# Serial Port Init Related
ser = serial.Serial('/dev/ttyUSB1', 115200)
print("Serial Instance Configuration: ", {ser})

# opening the source excel file

#filename = "/home/user/PycharmProjects/readsepthread/Automation.xlsx"
filename = sys.argv[1]
#print("xls_fileName", {filename})
# workbook instance

wb1 = openpyxl.load_workbook(filename, data_only=True)

# worksheet1 from the above workbook
ws1 = wb1.active

# calculate total number of rows and columns in source excel file

mr = ws1.max_row
mc = ws1.max_column

print('total no of rows ', {mr}, 'total no of cols ', {mc})


# utility Methods
def _readline(self):
    eol = b'\r'
    leneol = len(eol)
    line = bytearray()
    while True:
        c = ser.read(1)
        if c:
            line += c
            if line[-leneol:] == eol:
                break
        else:
            break
    return bytes(line)


# utility Methods
def copytoNewSheet():
    print("copytoNewSheet Method")
    now = datetime.now()  # current date and time

    year = now.strftime("%Y")

    month = now.strftime("%m")

    day = now.strftime("%d")

    time = now.strftime("%H %M %S")
    # print("time:", time)

    date_time_sheet = now.strftime("%d %b %Y " + time)
    target = wb1.copy_worksheet(ws1)
    target.title = str(date_time_sheet)
    # saving the destination excel file
    wb1.save(str(filename))
    wb1.close()


# serial port Methods
def close_port():
    ser.close()


# serial port Methods
def open_port():
    if ser.isOpen():
        ser.close()
        ser.open()
        time.sleep(1)
        print('SA8295P_v2.1_ft0_ADP_Air_v1.0.1_UFS_NORMAL')


def rd_frm_xl_wrt_to_ser():
    ser.flush()

    # Writing to  port
    for row in ws1.iter_rows(min_row=2, max_row=mr, min_col=2, max_col=2, values_only=True):
        for cell in row:
            # print(cell)
            ser.write(str.encode(cell))
            ser.write(str.encode("\r"))
            time.sleep(1)
    time.sleep(1)


def rd_frm_ser_wrt_xls():
    # Reading from a serial port
    expected_output_LIST = []

    mr = ws1.max_row
    index_value = 1
    pairsofdata = " "
    MAINCOLLECTOR = []
    a = None
    b = None
    while True:

        try:
            print(f"Entering Iteration - {index_value}")

            if ser.inWaiting() >= 0:

                ourStr = ser.readline().decode('utf-8').strip()
                print("ourStr: ", ourStr)

                if not pairsofdata.endswith(" ~~ "):
                    pairsofdata = pairsofdata + ourStr + " ~~ "
                    continue

                pairsofdata = pairsofdata + ourStr

                print("This is the pair of data")
                print(pairsofdata)

                count = pairsofdata.count(" ~~ ")
                print("Count of Tildes:", count)

                if count == 1:
                    MAINLIST = pairsofdata.split(" ~~ ")
                    print("MAINLIST :", MAINLIST)
                    print()
                if len(MAINLIST) == 2:

                    ####### Extracting the second element from MAINLIST

                    expectedOutput = ws1.cell(row=index_value + 1, column=3).value
                    print("This is expected value:")
                    print(expectedOutput)
                    if MAINLIST[1] == expectedOutput:

                        print(f"I have found the data {MAINLIST[1]}")
                        Res = ws1.cell(row=index_value + 1, column=4)

                        Res.value = 'Pass'

                        my_green = openpyxl.styles.colors.Color(rgb='00FF00')
                        my_fill = openpyxl.styles.fills.PatternFill(patternType='solid', fgColor=my_green)
                        Res.fill = my_fill

                        Reason = ws1.cell(row=index_value + 1, column=5)
                        Reason.value = 'Both the Actual output and Expected Output Matches,Hence TC is Pass.'

                    else:
                        Res = ws1.cell(row=index_value + 1, column=4)
                        Res.value = 'Fail'
                        my_red = openpyxl.styles.colors.Color(rgb='00FF0000')
                        my_fill = openpyxl.styles.fills.PatternFill(patternType='solid', fgColor=my_red)
                        Res.fill = my_fill
                        Reason = ws1.cell(row=index_value + 1, column=5)
                        reason_str = ('ExpectedOutput is: ', str(expectedOutput), 'Actual Output is: ', str(ourStr))
                        Reason.value = str(reason_str)

                    ####### Post Processing and clearing data
                    pairsofdata = " "
                    index_value += 1

                    if index_value == mr:
                        break
                    continue

                continue

            if index_value == mr + 15:
                break

            index_value += 1

        except Exception as e:
            print(" Interrupt Error is here  :-- ")
            print(e)
            break

    wb1.save(filename)
    wb1.close()


def rd_ln_by_ln():
    index_value = 1
    remoteIndexing = 0
    pairsofdata = " "
    MAINCOLLECTOR = []
    a = None
    b = None

    while True:
        print("index_value: ", index_value)
        CURRENT_COMMAND = ws1.cell(row=index_value + 1, column=2).value
        print("CURRENT_COMMAND:", CURRENT_COMMAND)
        NEXT_COMMAND = ws1.cell(row=index_value + 2, column=2).value
        print("NEXT_COMMAND:", NEXT_COMMAND)

        if ser.inWaiting() >= 0:
            ourStr = ser.readline().decode('utf-8').strip()
            print("ourStr: ", ourStr)

            if ourStr == CURRENT_COMMAND:
                print("SAME")
                index_value += 1
                continue

            if ourStr != NEXT_COMMAND:
                MAINCOLLECTOR.append(ourStr + "\n")
                remoteIndexing += 1

            index_value += 1
            ROW_NUMBER = index_value + 1 - remoteIndexing


if __name__ == '__main__':
    open_port()
    rd_frm_xl_wrt_to_ser()
    rd_frm_ser_wrt_xls()
    copytoNewSheet()
    close_port()