DIY Electronic projects - Embedded

McObjects eXtremeDB/rt 2.0

Mon, 08 Dec 2025 19:33:13 +0000

Na zadnjem skupu KG2025 je bilo malo reči i o McObject i eXtremeDB bazi podataka kao uvod u jedno poglavljnje specializovanih embedded baza podataka za male IoT/Edge uredjaje.

U nastavku priča sa oficialnog ST-ovg blog o tome kako se eXtremeDB baza podataka može efikasno upotrebiti na STM32 single/dual core procesorima za asimetrično (opciono i simetrično) procesiranje.

Tema je dosta široka i vezana je generalno za baze podataka ali za razliku od dosta drugih konkuretnih proizovda eXtremeDB je jedini RDBMS koji je potpuno prilagodljiv do najjmanjeg detalja, jezgro baze je konfigurabilno i sve ostalo povezano sa tim, može a i ne mora da se koristi SQL (istovremeno je SQL/NoSQL), tablice mogu da se prave u compile-time, vektorske veze i pointeri, replikacija i sve ostalo sto moderne baze imaju samo ova jedino radi na EMBEDDED platformama kako treba i ima izuzetne perfomanse sa podrškom za time-critical operacije.

eXtremeDB je komercialni proizvod, sastoji se od paketa usluga, SDK za razvoj sa/bez source-code za izabranu platformu/jezik (C, Go, Python, C# itd) i opciono (vrlo stručne) tehničke porške.
SDK pordžava sko sve arhitekture procesora i odprilike je jedina baza na tržištu koja pored klasičnih *nix/Win OS može da radi dodatno i na RTOS (ZephyrOS, freeRTOS) ili čak bare-metal!

eXtremeDB/rt 2.0, All the reasons why embedded systems need a database, now with persistence
https://blog.st.com/extremedb/

Shared-Data-in-AMP-configurations-June-2025.jpg (Size: 67,24 KB / Downloads: 37)

RGB 7-segment LED displej

Thu, 04 Jul 2024 12:15:27 +0000

RGB_7seg.jpg (Size: 68,3 KB / Downloads: 24)

Da li je ko radio sa RGB 7-segmentnim displejima ? Zanima me kakav drajver je najzgodnije koristiti za ovo, ako neko ima
konkretna iskustva ?
Sve skupa ce pokretati neki STM32, tako da nije problem ni PWM, ili eventalno neki IC sa SPI komunikacijom, koji bi imao sve sto treba upakovano...

Celeron compact flash

Wed, 17 Mar 2021 08:46:30 +0000

Pozdrav drugari, HELP WANTED!
Radi se o sledećem.
Komp je sa Celeronom sa 2GB RAMa (maximum). Na matičnoj postoji Compact Flash konektor za boot device i ništa više!
Ni SATA ni IDE. USB konektor na ploči ne postoji, samo pinčići da se nabode neki kabl sa USB A konektorima pa da se pristupi. Priključio spoljni CD i bootujem sa njega, dakle radi.
Ima i Touch Panel 15" u portret orijentaciji.

Potrebno je napraviti embedded sistem. Šta predlažete?

1 CF card 4 (8) GB i Volumio? Da li Volumio podržava Touch i portret orijentaciju?

2 Windows 7 embedded? Da li CF zbog ograničenog broja R/W ciklusa odgovara ovoj nameni? Koji kapacitet CFa je potreban za WIN 7? Ima li neke cake kod instaliranja Win 7 na CF karticu? Nije li Celeron slab za Win 7?

Da li postoji neki HDD ili SSD sa compact flash konektorom? Adapter da se HDD (SSD) ubode u compact flash?
Da li je primenjiv CF to SD adapter. Da li SD kartica može da bude boot medijum?
Kakvi su oni HDDovi iz iPoda? (1,8 ") mogu li da se ubodu u CF? Mislim na CF hard diskove. npr MK8007GAH CF Hard Drive

Ima li neko na probu takav disk? Ili skršen iPod?

Pisanje modula za NGINX

Tue, 03 Nov 2020 12:51:53 +0000

Evo jeda tema koja mozda nekome nekada moze da zatreba.

Imao sam potrebu da nekoliko RPi-a trebaju da razmenjuju izmedju sebe relativno malu kolicinu podataka (<1KB) ali relativno cesto (do 25 puta u sekundi) u lokalnoj mrezi (nema internet/gateway).

Posle vise pokusaja kako to da resim odlucio sam se da izaberem NGINX (HTTP protokol) koji se pokazao kao uzezetno robustan, pouzdan i veoma veoma brz.
Samo mali podsetnik, NGINX web server gura odprilike 50% kopletnog interneta na svetu ukljucujuci i ovaj nas forum, to je veoma ozbiljno napisan software!

Pre ovoga sam pokusavao da resim to sa *nix soketima, stalna veza koja pljucka te podatke ali se ispostavilo da je prilicno slozeno da se "izhendluju" sve potrebne situacije oko toga, radi ali je sklono zaglupljivanju.

Dakle izbor je pao na NGINX i varijanta da se napravi poseban modul za njega kako bih dobio na brzini procesiranja i to uvezano preko "deljene memorije" (/dev/shm), bez i jednog FILE I/O, dakle da sve radi iz memorije ...

I napravio sam tako, relativno je prosto da se odradi, sve se moze spakovati u jednu C skriptu i jedan konfiguracioni fajl za sam modul.

Naravno neophodno je da osposobite okruzenje za prevodjenje celog NGINX source code-a + instalirati zavisne biblioteke (zlib, OpenSSL opciono, i jos nesto zaboravih sta) i konfigurisati build skriptu da povuce i source za taj nas modul.
Dodatno je potrebno samo podesiti nginx.conf da "slusa" na odredjenoj IP : PORT i postaviti "rutu" da "gadja" nas nov modul.

Na ovoj adresi ima primer sa source-code za "hello_world_module":
https://github.com/perusio/nginx-hello-world-module

E sad, drugi deo price je "klient", sta tu sad staviti ali na srecu tu nisam imao mnogo nedoumica bar kada je HTTP u pitanju i za te potrebe sam iskoristio libCurl, cuvena biblioteka koja je isto jako dugo u upotrebi i to je "proverena stvar", sa tim nema brige.

Zakljucak, NGINX za server i libCurl za klienta radi odlicno. Dobio sam rezultate reda 1-2ms za potrebno vreme procesiranja celog upita (slanje upita i citanje odgovora) sto meni zavrsava posao a oslonio sam se na proverene/poznate biblioteke koje se lako implementiraju.

Koga interesuju vise detalja oko ovoga neka slobodno pita ...

COM port sniffer za WIN10

Thu, 16 Apr 2020 07:00:50 +0000

Treba da na brzinu pregledam neku komunikaciju na COM portu a sve što sam imao u tu svrhu mi sada ne radi zbog isteka licenci ili win10. Da li neko ima free rešenje?

Asinhrono citanje sa USB-serial problem | Android/Java

Mon, 30 Mar 2020 19:00:31 +0000

Pozdrav,

imam dosta glup problem ali ne znam kako da ga resim.

U pitanju je Android/Java i citanje sa seriskog USB porta.

Problem je manje vise klasika, treba da primimim paket podataka koji je na zalost promenljive duzine. U samom paketu ima i informaciji o duzini (treci i cetvrti bajt). Paket uvek ima i start sekvencu (0xDA 0xDA, prvi i drugi bajt)

Samo primanje se radi preko registrovane callback funkcije u nekom svom posebnom thread-u. Sve je to na nivou neke biblioteke viseg nivoa (baziranoj na Android API - Java).

Moj code samo stigne na kraju u tu callback funkciju i na meni je dalja obrada, za sad printam sta je to stiglo.

Evo prakticno "prepiska" izmedju Android-a i tog seriskog uredjaja i linija gde nastaje problem. Problem je 3. i 4. linija koja u stvari mora da bude jedan paket.

Quote:1. 2020-03-30 19: 42 :19.957 1887-1887/com.example: TX >>> DA DA 00 06 00 01 02 0A 0B 1E
2. 2020-03-30 19: 42 :19.975 1887-1931/com.example: RX <<< DA DA 00 0A 00 01 02 0A 0C 38 00 00 01 14
3. 2020-03-30 19: 42 :22.002 1887-1931/com.example: RX <<< DA DA 00 0A 00 01 02 0A
4. 2020-03-30 19: 42 :22.018 1887-1931/com.example: RX <<< 0A 37 00 00 01 15
5. 2020-03-30 19: 42 :22.354 1887-1931/com.example: RX <<< DA DA 00 06 00 01 02 0A 14 27

Treba da "rekonstrusem" paket, da spojim te delove koji su primljeni iz dva puta u jedan da bih mogao dalje da procesiram.

Mozete da predlozite i resenje u nekom pseudo codu, samo da vidim logiku kako to sve da odradim.

Moj repo sa Android glTF Viewer

Fri, 24 Jan 2020 17:13:46 +0000

Da podelim sa vama moj novi repoziturijum sa Android aplikacijom za pregled 3D modela u glTF formatu.

https://github.com/mikikg/AndroidJgltfViewer

U pitanju je portovana desktop verzija biblioteke jglTF koju su izvorno pisali momci iz Khronos (OpenGL) grupe za Android okruzenje sa embedded verzijom OpenGL-a tj OpenGL ES 3.

Probajte, testirajte, starujte, lajkujte, pitajte ...

Pisanje kernel modula - Linux Kernel Module Programming

Sun, 14 Jun 2015 19:53:57 +0000

Ovih dana sam experimentisao malo sa pisanjem Linux kernel modula (device driver) i dostavljam ovde jedan prost primer kao osnovu - skeleton.

Ovde pokazujem jedan primer za "Character Device" (suprotno od "Block Device") driver, parce dinamickog programa koji se ucitava u kernel i koji operise sa tkz seriskim tipovima uredjaja, npr raznim komunikacioni portovi poput RS232, I2C, USB i slicno.
Primetice te da nije uradjena fizicka komunikacija vec je ceo drajver napravljen kao "fake", tj moze u njega da se upisuje i posle da se iscitavaju podaci, kao da imamo prikacenu neku serisku memoriju od 100 bajtova ("virtual_device").

Razvojno okruzenje je Linux Debian 8 sa potrebnim paketima (gcc, make, linux-headers …)

hello.c C++ source code (zanemarite PHP, iskorisceno za forum samo za highligh sintakse)

PHP Code:
/**********************************************************
***********************************************************
hello.c
***********************************************************
***********************************************************/

#include  //MUST
#include  //MUST
#include  //to pass params
#include  //File system operations, read/write, open/close device drivers
#include  //characher device driver
#include  //used to access semaphores; sunchronization behaviors
#include  //copy_to_user; copy_from_user

//other variables
struct cdev *mcdev; //my charachter device
int major_number; //will store our major number - extracted from dev_t using macro - mknod /directory/files c major minor
int ret; //used to hold return values of functions; this is because kernel stack is very small so declare variables all over the pass in our module functions eats up the stack very fast
dev_t dev_num; // hold major naumber that kernel give us; name --> apears in /proc/devices

#define DEVICE_NAME "mikidev"

//structure for device
struct fake_device {
    char data[100];
    struct semaphore sem;
} virtual_device;


//***********************************************************/
//***********************************************************/
//***********************************************************/

//pass the params (not used now)
int my_param = 0;
module_param(my_param, int, S_IRUSR | S_IWUSR);


//***********************************************************/
//********************** device operation  ******************/
//***********************************************************/

//called on device_file open
//inode reference to the file on disk
//and contains information about the file
//struct files is represents an abstract open file
int device_open (struct inode *inode, struct file *filp) {

    //only allow one process to open this device by using semaphore as mutual exclusive lock - mutex
    if (down_interruptible(&virtual_device.sem) != 0) {
        printk(KERN_ALERT "%s: could not lock device during open", DEVICE_NAME);
        return -1;
    }

    printk(KERN_INFO "mikidev: opened device");
    return 0;

}

ssize_t device_read (struct file* filp, char* bufStoreData, size_t bufCount, loff_t* curOffset) {
    //take the kernel space (device) to user space (process)
    //copy_to_user (destiantion, source, sizeToTransfer)
    printk(KERN_INFO "%s: Reading from device", DEVICE_NAME);
    ret = copy_to_user(bufStoreData, virtual_device.data, bufCount);
    return ret;
}

ssize_t device_write (struct file* filp, const char* bufSourceData, size_t bufCount, loff_t* curOffset) {
    //send data from user to kernel
    //copy_from_user (destiantion, source, sizeToTransfer)
    printk(KERN_INFO "%s: Writng to device", DEVICE_NAME);
    ret = copy_from_user(virtual_device.data, bufSourceData, bufCount);
    return ret;
}

int device_close(struct inode *inode, struct file *filp) {
    //by calling up, whic is opposite of down for semaphore, we realease the mutex we obtained ad device open
    //this has the effect of allowing other process to use the device now
    up(&virtual_device.sem);
    printk(KERN_INFO "%s: closed device", DEVICE_NAME);
    return 0;
}

//tell the kernel which functions to call when user operates on our device file
struct file_operations fops = {
    .owner = THIS_MODULE, //prevent unloading of this module when operations are in use
    .open = device_open, //points to method to call when opening the device
    .release = device_close, //points to method to call when closing the device
    .write = device_write, //points to method to call when writing the device
    .read = device_read //points to method to call when reading the device
};


//***********************************************************/
//********************** module operation *******************/
//***********************************************************/
static int driver_init (void) {
    
    //register our device with the system: a two step process
    //step 1 use dynamic alloacation to assign our device a major number 
    // -- alloc_chrdev_region (dev_t*, uint fminor, uint count, char* name)
    ret = alloc_chrdev_region (&dev_num, 0,1, DEVICE_NAME);
    if (ret < 0) {//alert time kernel functions return negatives, there is an error
        printk(KERN_ALERT "%s: faild to allocate a major number", DEVICE_NAME);
        return ret; //propagate error
    }
    
    major_number = MAJOR(dev_num); //extract the major number and store into our variables (MACRO)
    printk(KERN_INFO "%s: major number is %d", DEVICE_NAME, major_number);
    printk(KERN_INFO "\tuse \"mknod /dev/%s c %d 0\" for device file", DEVICE_NAME, major_number); //dmesg
    
    mcdev = cdev_alloc(); //create our cdev structure, initialize our cdev
    mcdev->ops = &fops; //struct file_operations
    mcdev->owner = THIS_MODULE;

    //now we created cdev, we have to add it to the kernel
    //int cdev_add(struct cdev* dev, dev_t num, unsigned int count)
    ret = cdev_add(mcdev, dev_num, 1);
    if (ret < 0) { //always check errors
        printk(KERN_ALERT "%s: unable to add cdev to kernel", DEVICE_NAME);
        return ret;
    }
    
    //initialise our semaphore
    sema_init (&virtual_device.sem, 1); //initial values of one
    
    return 0;
}

static void driver_exit (void) {

    //unregister evrything in reverse order
    cdev_del(mcdev);
    
    unregister_chrdev_region(dev_num, 1);
    printk(KERN_ALERT "%s: unloaded module", DEVICE_NAME);

}

//***********************************************************/
//********************** init *******************************/
//***********************************************************/
//inform the kernel where to start and stop with our module/driver
module_init (driver_init);
module_exit (driver_exit);

MODULE_AUTHOR("A. Markovic");
MODULE_DESCRIPTION("My first kernel module");
MODULE_LICENSE("GPL"); 

Makefile (skripta za utomatsko kompajliranje)

PHP Code:
obj-m := hello.o


KERNEL_DIR = /usr/src/linux-headers-$(shell uname -r)

all:
    $(MAKE) -C $(KERNEL_DIR) SUBDIRS=$(PWD) modules
    
clean:
    rm -rf *.o *.ko *.mod.* *.symvers *.order 

U ovom Makefile vidite da se poziva hederi za trenutni OS na kome radite ali ako tu explicitno navedete neku drugu verziju hedera, recimo specificnu za RPi, moze bez problema da se iskompalira i za druge procesore.

Koga ovo bude interesovalo neka slobodno postavi pitanja

Sve ovo je opisano u odlicnom YT tutorialu (8 delova):
https://www.youtube.com/watch?v=-O6GsrmOUgY

Nakon uspesnog kompajliranja (poziva se "make"), treba da dobijete hello.ko fajl koji predstavlja sam driver.
Drajver se ucitava u kernel sa komandom "insmod hello.ko";
Tokom ucitavanja sam drajver ce ispisati nekoliko poruka i te poruke mogu da se vide u syslog (dmesg);
Iskljucivanje / deaktivacija drajvera se radi komandom "rmmod hello".

hello.c (Size: 5,71 KB / Downloads: 1)