How to link toolchain to qtcreator (download toolchain in linaro)

1. Download Toolchain 
https://www.linaro.org/downloads/

2. Click on Tools at the top of the Qtcreator -> build& run 

3. Set up the Cmake. (This is just a skip. I won't use it even if I set it up.)
Press "Add…" and set as below (based on default path when installing the toolchain)
Path : /usr/local/oecore-x86_64/sysroots/x86_64-oesdk-linux/usr/bin/cmake

4. Click Debuggers -> "Add…" and add as below
Path: /usr/local/oecore-x86_64/sysroots/x86_64-oesdk-linux/usr/bin/aarch64-gnu-linux/aarch64-gnu-linux-gdb



5. Compiler -> "Add…" and add C++(g++) / C(gcc)
c++ compiler path : /usr/local/oecore-x86_64/sysroots/x86_64-oesdk-linux/usr/bin/aarch64-gnu-linux/aarch64-gnu-linux-g++
c compiler path: /usr/local/oecore-x86_64/sysroots/x86_64-oesdk-linux/usr/bin/aarch64-gnu-linux/aarch64-gnu-linux-gcc




6. Select Qt versions -> "Add…" and select qmake in toolcain




7. Select "Kits" -> Set to the same value as below
Device type: Generic linux device
sysroot: /usr/local/oecore-x86_64/sysroots/aarch64-gnu-linux
compiler: 5.Compiler
debugger: 4.debugger
qt: 6.qmake
cmake : /usr/bin/cmake


8. Input Command in Command
$ sudo -s

modify bashrc (add command)
$ vi ~/.bashrc
.…
alias qtcreator='source /usr/local/oecore-x86_64/environment-setup-aarch64-gnu-linux;
/opt/Qt5.10.0/Tools/QtCreator/bin/qtcreator'
...

And save 
$source ~/.bashrc

9. When running Qt, you must always run qtcreator as command from the terminal to build... I don't know why.


#QT #QtCreator #Qmake #C++ #C #Linux #Embedded #Download Toolchain  #toolchain #Linaro

RAII(Resource Acquisition Is Initialization)

Resource acquisition is initialization (RAII) is a programming idiom used in several object-oriented languages to describe a particular language behavior.

RAII (Resource Acquisition Is Initialization) is one of the famous design patterns.

The technique was developed for exception-safe resource management in C++ during 1984–89, primarily by Bjarne Stroustrup and Andrew Koenig.

RAII patterns are important techniques for preventing leakage in languages such as C++ that require developers to directly manage resources.

Example (https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization)

The following C++11 example demonstrates usage of RAII for file access and mutex locking:

#include <fstream>

#include <iostream>

#include <mutex>

#include <stdexcept>

#include <string>

void WriteToFile(const std::string& message) {

  // |mutex| is to protect access to |file| (which is shared across threads).

  static std::mutex mutex;

// Lock |mutex| before accessing |file|.

  std::lock_guard<std::mutex> lock(mutex);

// Try to open file.

  std::ofstream file("example.txt");

  if (!file.is_open()) {

    throw std::runtime_error("unable to open file");

  }

// Write |message| to |file|.

  file << message << std::endl;

// |file| will be closed first when leaving scope (regardless of exception)

  // mutex will be unlocked second (from lock destructor) when leaving scope

  // (regardless of exception).

}

<Ref : https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization>

#RAII #Resource Acquisition Is Initialization #C++ #mutex #Memory leakage #std::auto_ptr

How to install docker in Ubuntu linux system

How to install docker in Ubuntu linux system

Install Docker

$ curl -fsSL https://get.docker.com/ | sudo sh

Install Docker Compose

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.25.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Docker Compose Permission

$ sudo chmod 777 /usr/local/bin/docker-compose

Command (  ${xxxx} <- input your info )

Root permission

$ sudo usermod -aG docker <NAME>

Docker Image Command

Download Image

docker pull ${IMAGE:Version}

$ docker pull ubuntu:latest

Run Docker Image

docker run ${IMAGE:Version}

$ docker run ubuntu:latest

Build Docker Image

$ docker build

Show Downloaded Docker Image

$ docker images

Remove Docker Image

$ docker rmi ${IMAGE:Version}

Remove All Docker Image

$ docker rmi ${docker images -q}

Show Running Docker Image(Container) List

$ docker ps

Restart Docker image

$ docker restart

Container Command

Stop Running Container

docker stop ${CONTAINER ID}

$ docker stop ${CONTAINER ID}

Remove Container

$ docker rm <CONTAINER ID>

Remove All Container

$ docker rm $(docker ps -a -q)

Show Detailed Container Infomation

$ docker container inspect <CONTAINER ID>

Show Container volume

$ docker volume ls

#docker #linux docker #install docker

Signal Handling Example (linux C/C++)

Signal Handling Example (linux C/C++)

#include <iostream>

#include <stdio.h>

#include <signal.h>

#include <stdlib.h>

#include <fstream>

class TestClass{

public:

    static void handle_signal(int signal);

};

void TestClass::handle_signal(int signal) {

    //char *signalName;

    std::string signalName = "";

    sigset_t pending;

    switch(signal) {

        case SIGHUP:

            signalName = "SIGHUP";

            break;

        case SIGINT:

            signalName = "SIGINT";

            break;

        case SIGTERM:

            signalName = "SIGTERM";

            break;

        case SIGQUIT:

            signalName = "SIGQUIT";

            break;

        case SIGKILL:

            signalName = "SIGKILL";

            break;

        default:

            printf("Caught unknown signal: %d\n", signal);

            return;

    }

    //실행하고 싶은 함수        

    std::ofstream outFile("./output.txt", std::ios::app);

    printf("Linux signal occurred. signal[%d] : name[%s]\n", signal, signalName.c_str());

    std::string str(std::string("Linux signal occurred. signal[") + std::to_string(signal) + "] signal Name["+ std::string(signalName) + "]");

    outFile << str << std::endl;

    outFile.close();

    //exit(0);

}

int main(int argc, char* arv[]) {

    TestClass *A = new TestClass();

    struct sigaction signalhandler;

    //stack_t sigstk; //for seg.fault

    //if ((sigstk.ss_sp = (char *)//malloc(SIGSTKSZ*2))==NULL) {

    //fprintf(stderr, "can't alloc alt stack\n");

    //}

    //sigstk.ss_size = SIGSTKSZ*2;

    //sigstk.ss_flags = 0;

    //if(sigaltstack(&sigstk, (stack_t *) 0) < 0) {

    //perror("sigaltstack");

    //}

    signalhandler.sa_handler = &TestClass::handle_signal;

    sigemptyset(&signalhandler.sa_mask);

    signalhandler.sa_flags = SA_RESETHAND | SA_ONSTACK;

    sigaction(SIGSEGV, &signalhandler,NULL);

    sigaction(SIGHUP, &signalhandler,NULL);

    sigaction(SIGINT, &signalhandler,NULL);

    sigaction(SIGTERM, &signalhandler,NULL);

    sigaction(SIGQUIT, &signalhandler,NULL);

    sigaction(SIGKILL, &signalhandler,NULL);

    while(1) {

    }

    return 1;

}

#Signal #Signal Handling #Signal Handler #C #C++ #Linux #Embedded