Stringhe in C

Mi sono rimesso a studiare un po' di C

--------------------------------------------
#include <stdio.h>
#include <stdlib.h>

#include <string.h>


//calcola la lunghezza di una stringa 
// con un ciclo for ed i puntatori
int strlen_for(char *s)
{
    int n;
    for(n=0; *s!='\0'; s++)
        n++;
    return n+1;
}

//calcola la lunghezza di una stringa 
// con un ciclo while ed i puntatori
//il trucco di fine ciclo e' che 
// il terminatore di una stringa in C 
// e' 0 che corrisponde anche alla condizione
// False 

void print_for(char *s)
{
    for (; *s; s++)
        printf("%c",*s);

    printf("\n");
}

// stampa una stringa
void print_while(char *s)
{
    while(*s){
        printf("%c",*s);
        s++;
        }
    printf("\n");
}

//crea una nuova stringa di una lunghezza non predefinita
char *new_string(int lunghezza)
{
    char *transi = malloc(lunghezza + 1);
    memset(transi, 'a', lunghezza);
    transi[lunghezza] = 0;
    return transi;
}

// concatena due stringhe
char *concatena(char *uno, char*due)
{
    //printf("%i\n",sizeof(uno));


    char *transi = malloc(sizeof(uno)+sizeof(due) + 1);
    int contatore = 0;
     for (; *uno; uno++)
     {
        transi[contatore] = *uno;
        contatore++;
     }
     for (; *due; due++)
     {
        transi[contatore] = *due;
        contatore++;
     }
    transi[contatore] = 0;

    return transi;
}


// taglia una stringa
char *taglia(char *stringa,int caratteri)
{
    stringa[caratteri] = 0;
    return stringa;

}

int main()
{
    char *a = "chiara";
    char b[5] = "luca";
    print_for(a);
    print_while(a);
    int lung = strlen_for(b);
    printf("%i\n",lung);

    char *nuova_stringa = new_string(10);
    print_for(nuova_stringa);

    char *nome = "Luca";
    char *cognome = "Innocenti";
    char *unione = concatena(nome,cognome);
    print_for(unione);

    char *tagliato = taglia(unione,5);
    print_for(tagliato);
    printf("%i\n",sizeof(tagliato)+1);

    //array di puntatori
    char *elementi[] = {"Luca", "Innocenti", "Firenze"};

    print_for(elementi[0]);
    print_for(elementi[2]);



    return 0;
}

6502 RetroShield

Ho provato un progetto interessante... in pratica invece di emulare un processore con RetroShield viene accoppiato ad una Arduino Mega un vero processore 6502 (puo' montare anche uno z80) su cui vengono realmente eseguite le istruzioni senza emulazione software

Il clock e' molto piu' basso rispetto al 6502 puro (circa 10 volte piu' lento ovvero 100 KHz) ma la cosa divertente e' che si puo' emulare un Apple 1 con un apposito sketch Arduino con inclusi nel firmware Apple Basic 1 e Woz Monitor (l'interfaccia avviene sulla porta seriale come terminale)

Per accedere al basic si attende il prompt dopo una CPU Reset e si digita

E000R

per rientrare al Basic

E2B3R

per effettuare il dump della memoria del programma in basic
004A.00FF
0800.0FFF
.

L'aspetto che lascia piu' interdetti e' il basic di Apple I e' altrimenti conosciuto come Integer Basic perche' sono ammessi solo numeri interi come variabili compresi tra -32.768 3 e 32767. Inoltre il nome delle variabili puo' essere solo una lettera o una lettera ed un numero. Tanto per dare un'idea il manuale originale era di 14 pagine

Resuscitare un telefono Vernee

Un telefono Android di marca Vernee era andato in modalita' bootloader e quando mi e' arrivato  oramai non aveva piu' batteria perche' il proprietario non lo aveva spento

Nonostante avere tenuto il telefono in carica per piu' di un giorno non presentava segni di vita..a questo punto il dispositivo e' stato smontato per staccare fisicamente la batteria (un tentativo come un altro). La batteria era collegata da una flat con connettore a pressione ed e' stato facile disconnetterla. A telefono aperto e' stato semplice verificare (anche per la presenza di due comode piazzole) che la tensione della batteria era di circa 3.2 V e nonostante il cavo USB di alimentazione la batteria non veniva ricaricata.

Leggendo su internet e' emerso che il voltaggio aveva raggiunto un livello tale che il circuito di ricarica impediva la ricarica stessa...E' stato quindi collegata un cavo USB alle due piazzole ed la batteria e' stata alimentata a 5V dal cavo USB fino a quando non ha raggiunto i 3.6 V. Dopo di cio' il circuito di ricarica e' entrato in azione ed il telefono e' ripartito in bootloader senza problemi (l'origine del problema era un corruzione del sistema Android)...un reset alle impostazioni di fabbrica (con menu ovviamente in cinese) ed il telefono e' ripartito.

Probabilmente avere lasciato il telefono in modalita' bootloader ha impedito ad Android di evitare l'eccessivo scaricamento della batteria e probabilmente non ci sono dispositivi hardware immediatamente collegati alla batteria (come accade nelle LiPo vendute singolarmente)

TSC_DEADLINE error su Lenovo X1 Carbon e Debian

Il mio Lenovo mi dava sempre al boot un errore di TSC_DEADLINE e pensavo che fosse necessario aggiornare il BIOS (cosa che per pigrizia e per paura di rendere inutilizzabile il computer non ho mai fatto)

Ho scoperto che basta aggiungere il seguente pacchetto

apt-get install intel-microcode

per risolvere il problema

USB seriale su STM32 Nucleo F302RB

Per inviare dati seriali sulla porta USB (collegata ad STLink) si devono prima attivare i pin tramite Cube MX e si devono configurare i parametri di trasmissione di USART2 (in questo caso 9600 8N1)

       
fatto cio' si apre il progetto e si trova gia' configurata la porta huart2 su cui trasmettere un buffer di caratteri

char buffer[12];

..........

HAL_UART_Transmit(&huart2,buffer,strlen(buffer),HAL_MAX_DELAY);
char newline[2] = "\r\n";
HAL_UART_Transmit(&huart2,(uint8_t *) newline,2,HAL_MAX_DELAY);

Linux Windows Subsystem ed XOrg

Una delle limitazioni piu' significative di Linux Subsystem su Windows 10 e' quella di avere di default sostanzialmente la sola consolle.
Tale limitazione puo' essere superata in due modi differenti

1) Metodo con windows manager completo

Si installano un X Server per Windows come XMing o VcXsrv

dalla shell si inserisce il comando (oppure lo si include in bashrc)

export DISPLAY=:0.0

si installa poi con apt il pacchetto XFCE

apt-get install xfce4

si apre quindi il programma XLaunch  selezionando FullScreen o One Large Window, e premendo in successiione Next. Al termine si ritorna alla shell e si digita

xfce4-session

3) Metodo a singola applicazione

a differenza del caso precedente invece di aprire window manager si possono eseguire singole applicazioni come xterm (quindi dopo export DISPLAY=:0.0 e dopo aver lanciato XLaunch ) si puo' digitare per esempio

xterm

STM32F103C8T6 Blue Pill Blink

La scheda si basa su un Cortex M3 a 72 MHz e 32 bit con 20Kb di ram statica, 64 Kb di flash memory. Tensione di riferimento e' a 3.3 V ma alcuni pin permettono anche tensioni massime di 5 V

Nonostante disponga di una porta USB la programmazione avviene tramite ST Link esterno che deve essere collegato ai 4 pin sul lato corto (oppure usando un seriale TTL TX su A10 e RX su A9). In realta' e' possibile flashare un boot loader che permette la programmazione via USB e la compatilibita' con Arduino IDE perdendo pero' spazio di memoria (circa 20 Kb)

Proviamo adesso a programmmare il classisvo blink

Da questo schema si vede che il led integrato e' collegato alla porta GPIO C13. Attenzione ...rispetto ad una Arduino la numerazione dei Pin e' diffetente...ci sono piu' pin 13 per esempio PB13, PC13 perche' ci sono piu' porte GPIO

Si apre CubeMX e i crea un progetto selezionando selezionando STM32F103C8Tx ed attivando il il clock su HCE Crystal reconator e PC13 come GPIO Output e denominandolo  LED

Si genera il codice e si apre SW4STM32 e si modifica main.c come indicato

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

 while (1)

  {

    /* USER CODE END WHILE */

  HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);

  HAL_Delay(5000);

    /* USER CODE BEGIN 3 */

  }

  /* USER CODE END 3 */

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

Qui arriva la parte un po' complicata....se si effettua un semplice build and run si ottiene il seguente errore

Open On-Chip Debugger 0.10.0+dev-00021-g524e8c8 (2019-04-12-08:48)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
srst_only separate srst_nogate srst_open_drain connect_assert_srst
Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
adapter speed: 8000 kHz
adapter_nsrst_delay: 100
Info : clock speed 8000 kHz
Info : STLINK v2 JTAG v34 API v2 SWIM v7 VID 0x0483 PID 0x3748
Info : using stlink api v2
Info : Target voltage: 3.142412
Info : Unable to match requested speed 8000 kHz, using 4000 kHz
Info : Stlink adapter speed set to 4000 kHz
Info : STM32F103C8Tx.cpu: hardware has 6 breakpoints, 4 watchpoints
Info : Listening on port 3333 for gdb connections
Error: timed out while waiting for target halted
TARGET: STM32F103C8Tx.cpu - Not halted
in procedure 'program'
in procedure 'reset' called at file "embedded:startup.tcl", line 500
in procedure 'ocd_bouncer'

embedded:startup.tcl:476: Error: ** Unable to reset target **
in procedure 'program'
in procedure 'program_error' called at file "embedded:startup.tcl", line 501
at file "embedded:startup.tcl", line 476


il trucco  sta nel premere il pulsante di reset della scheda, lanciare Run e circa un seconda dopo che inizia a lampeggiare STLink si deve rilasciare  il tasto di reset

il messaggio di corretto carivamente e;' il segiente

Open On-Chip Debugger 0.10.0+dev-00021-g524e8c8 (2019-04-12-08:48)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
srst_only separate srst_nogate srst_open_drain connect_assert_srst
Info : The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD
adapter speed: 8000 kHz
adapter_nsrst_delay: 100
Info : clock speed 8000 kHz
Info : STLINK v2 JTAG v34 API v2 SWIM v7 VID 0x0483 PID 0x3748
Info : using stlink api v2
Info : Target voltage: 3.129153
Info : Unable to match requested speed 8000 kHz, using 4000 kHz
Info : Stlink adapter speed set to 4000 kHz
Info : STM32F103C8Tx.cpu: hardware has 6 breakpoints, 4 watchpoints
Info : Listening on port 3333 for gdb connections
target halted due to debug-request, current mode: Thread 
xPSR: 0x01000000 pc: 0x08000c50 msp: 0x20005000
Info : Unable to match requested speed 8000 kHz, using 4000 kHz
Info : Stlink adapter speed set to 4000 kHz
Info : Unable to match requested speed 8000 kHz, using 4000 kHz
adapter speed: 4000 kHz
** Programming Started **
auto erase enabled
Info : device id = 0x20036410
Info : flash size = 64kbytes
target halted due to breakpoint, current mode: Thread 
xPSR: 0x61000000 pc: 0x2000003a msp: 0x20005000
wrote 4096 bytes from file Debug/blue_piull.elf in 0.264664s (15.114 KiB/s)
** Programming Finished **
** Verify Started **
target halted due to breakpoint, current mode: Thread 
xPSR: 0x61000000 pc: 0x2000002e msp: 0x20005000
verified 3404 bytes in 0.072038s (46.145 KiB/s)
** Verified OK **
** Resetting Target **
target halted due to breakpoint, current mode: Thread 
xPSR: 0x61000000 pc: 0x2000002e msp: 0x20005000
shutdown command invoked

A questo punto si preme nuovamente il tasto reset per mandare in esecuzione il programma

Android Go su RedMi Go

Visto che oramai i telefoni costano una fortuna e perdere un Google Pixel francamente mi avrebbe alterato ho preso un RedMi, un telefono di fascia bassa (1Gb di Ram, Gb di storage), con installato Android Go, una versione di Oreo 8.1 priva di animazioni e cianfrusaglie varie con Google Apps apposite (tipo GMail Go, Maps Go.....)

Con una cinquantina di euro cosa volevo sperare di piu'??

Progetto Tre : Inclinometro MEMS

Progetto dismesso: pubblicato a futura memoria

Di tubi inclinometrici ne esistono di varie dimensioni e materiali. La caratteristica sono le 4 scanalature a 90° per fare scendere la sonda

I tubi sono giuntati tramite manicotti. Nel caso di tubi in alluminio i manicotti sono giuntati con rivetti

La posizione dei rivetti non e' predefissata (basta che non cada sulle scanalature). Cio' comporta anche che i rivetti sporgano all'interno del tubo

Le dimesioni del tubo sono riportate nel disegno CAD (fatto con DraftSight)

Per creare la sonda inclinometrica il primo tentativo e' stato quello di una scatola con 4 denti per scivolare nelle scanalature (Disegni effettuati con FreeCad e visualizzazione in MeshLab)

Corpo

Chiusura superiore

In realta' la scelta e' stata scartata quasi subito per la necessita' di avere un meccanismo a molla che permetta di aderire al tubo (mantenendo lo scivolamento). Una idea successiva e' stata quella di inserire lamelle in acciaio armonico (in funzione di molla) per permettere lo scivolamento e garantire la stabilita'



Questa e' una sonda inclinometrica commerciale

CubeMX e SW4STM32 AC6

Per creare un progetto STM32 si parte da CubeMX con New Project e selezionando la scheda di sviluppo

e' piu' comodo usare il tab board selector al posto di MCU/MPU  selector

Se la scheda e' ancora stato scaricato il pacchetto di configurazione della scheda il software effettua il download. Una volta scaricato il pacchetto nel repository di CubeMX saranno presenti anche degli esempi per l'utilizzo della scheda

Per esempio su Windows il repository si trova in

C:\Users\PC\STM32Cube\Repository\

mentre gli esempi sono nelle sottodirectory ordinate per classe di scheda

C:\Users\PC\STM32Cube\Repository\STM32Cube_FW_F7_V1.15.0\Projects\STM32746G-Discovery\Examples

Gli esempi vengono presentati in diverse directory a seconda dell'IDE (quindi usando AC6 si usera' la directory SW4STM32)

Prima di premere il pulsante Generate Code si deve selezionare Toolchain/IDE a SW4STM32

successivamente si deve copiare il percorso della Project Location

A questo punto si puo' aprire SW4STM32 e aprire il progetto da Open File from File System selezionando la directory

In SW4STM32 si possono importare anche librerie in C standard. Nel progetto basta trascinare i file nel ramo del progetto e poi settare la nuova path nelle proprieta' del progetto (nel caso di esempio mini-gmp, una versione ridotta di GMPLib)...ovviamente se si vogliono importare librerie binarie queste devono essere gia' compilate per ARM

FN Keys su Surface 1

Un piccolo promemoria per me stesso : per abilitare i tasti  funzione Fn su Surface 1 si deve premere il tasto Fn+Blocco Maiuscole

Alpine Linux

Alla ricerca di una distro Linux leggera ho voluto fare una prova con Alpine Linux

Per l'installazione sono partito dalla versione extended

All'avvio della iso si digita root e senza password ci si trova al prompt. Per iniziare la configurazione si digita

configure-alpine
(i comandi di configurazione iniziano tutti con setup-* come per esempio setup-ntp)

si accede alla scelta del layout di tastiera, la configurazione della rete, la nuova password di root, la timezone, un eventuale proxy ed il servizio NTP. Si configura poi il repository (l'opzione di default ricerca il repository piu' veloce). Si sceglie poi il disco dove effettuare l'installazione (si indica come "sda", "sdb"....) e poi il tipo di utilizzo (normalmente si seleziona "sys")

il packet manager si chiama apk i cui comandi base sono

apk update
apk upgrade
apk add ......
apk del .......
apk search .....

di default e' abilitato solo il repository main, per attivare il community si deve editare con vi il file /etc/apk/repositories (I repositories edge sono considerati di sviluppo con modalita' rolling release)

per installare Xorg si usa

setup-xorg-base

ragionevolmente la prima volta che si lancia startx Xorg crasha per mancanza di configurazione del window manager

Si lancia quindi

apk search xf86-video 

per cercare il driver della propria scheda video e si installa (per esempio) con

apk add xf86-video-vesa

si prosegue con

apk add xf86-input-mouse xf86-input-keyboard xf86-input-evdev
apk add xfce4 xfce4-terminal 
apk add faenza-icon-theme tango-icon-theme
rc-service dbus start
rc-update add dbus

si lancia quindi la configurazione di Xorg

Xorg -configure

e si lancia startx per accedere ad X

come opzione a XFCE ci sono altri window manager gia' disponibili come Gnome, Mate ed Awesome

Per quanto riguarda Awesome ho trovato non possibile installare aterm mentre funziona correttamente xterm


per installare il compilatore gcc e gli strumenti di sviluppo si usa

apk add build-base

documentazione puo' essere trovata a questo link

Arduino Uno blink con Atmel Studio 7

Nota
Nonostante l'uso di Atmel Studio non e' possibile effettuare il debug step by step del programma a meno che di non usare un debugger esterno (come Atmel ICE) del costo di circa 100 euro (esistono in vendita dei dispositivi tipo AVRISP Mkii che pero' risultano essere solo dei programmatori e non dei debuggers)

Negli STM32 con STLink invece si ha gia' a disposizione un  programmatore debugger a basso costo (pochi euro)
----------------------------------------------------------

Atmel Studio 7 si puo' scaricare dal seguente link

Si crea un progetto GCC C Executable

e si seleziona ATMega 328p

si  va al menu Tools/External tools

Si aggiunge un nuovo tool editando Command ed argomenti con (si deve avere gia' installato Arduino IDE e si fa puntare alle directory)

C:\Program Files (x86)\Arduino\hardware\tools\avr/bin/avrdude 

-C"C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf" -v -patmega328p -carduino -PCOM11 -b115200 -D -Uflash:w:"$(ProjectDir)Debug\$(TargetName).hex":i 

a questo punto si puo' editare main.c con il seguente codice (la programmazione avviene in C)

--------------------------------------
#define F_CPU 16000000UL  //frequenza del processore

#include <avr/io.h>
#include <util/delay.h>


int main(void)
{
DDRB |= 0B00100000;
    while (1) 
    {
PORTB |= 0B00100000;
_delay_ms(1000);
PORTB &= 0B11011111;
_delay_ms(500);
    }
}

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

si compila con Build Solution (tasto F7) e si fa l'upload  su Arduino Uno  con Tools/Arduino Uno Bootloader

Ma cosa vuol dire il codice sopra riportato. Si fa riferimento al Data Sheet di AVR Mega328p

DDRB (Data Direction Register= indica come settare le porte digitali (la sigla B indica le porte digitali da 8 a 13, C indica i pin analogici e D indica le porte digitali da 0 a 7) se in lettura od in scrittura

PORTB  invece come settare o leggere la porta

DDRB |= 0B00100000; imposta la porta DDB5 come output (fa un OR sul valore della porta stessa con una maschera)

ma come mai proprio la porta DDB5....perche' nella Arduino Uno e' collegata al Pin D13 a cui e' collegato il led 

dopo di cio' con PORTB (ed una serie di AND ed OR con una maschera binaria) viene settato il valore di DDB5 (e quindi del pin D13) a 0 ed 1

il corrispondente sketch Arduino e' ovviamente

--------------------------------------
void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);  
  delay(1000);                     
  digitalWrite(LED_BUILTIN, LOW);    
  delay(500);                      
}
--------------------------------------

una differenza evidente e' che il codice compilato Arduino IDE e' di 930 bytes mentre il codice C con Atmel Studio e' di soli 176 bytes

Touch GPIO su ESP32

Stavo pensando di crearmi uno strumento musicale con una Arduino ma avevo bisogno di un interruttore capacitivo ..stavo per comprarmi una decina di questi componenti (un paio di euro di costo ciascuno)

quando ho scoperto che la ESP-WROOM-32 ha ben 10 pin GPIO che possono essere utilizzati come interruttori capacitativi

il codice per abilitare un pin GPIO come capacitivo e' il seguente
-----------------------------------------------------------
void setup() {
 Serial.begin(115200);

}

void loop() {
  Serial.println(touchRead(4));
  delay(100);

}
-----------------------------------------------------------

Abilitando il plotter seriale della Arduino IDE si vede che il valore on/off non e' assoluto...e' quindi necessario tarare una soglia

Il valore alto e' quando il pin non e' toccato, il valore basso e' quando il pin e' toccato dalla mano

Kiss FFT

------------------------------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include <kiss_fft.h>
#include <tools/kiss_fftr.h>


#define NUM_FFT 256

int main()
{

float samples[NUM_FFT];


// si crea un segnale fittizio
for (int i = 0; i < NUM_FFT; i++) {
    samples[i] = sin(i*0.1);
    // con questo incremento si che i varia da 0 a 25.6 rad
    // ovvero circa 4 volte 2pigreco (ovvero 4 circonferenze)


}

    int isinverse = 1;
    kiss_fft_scalar zero;
    memset(&zero,0,sizeof(zero));
    kiss_fft_cpx fft_in[NUM_FFT];
    kiss_fft_cpx fft_out[NUM_FFT];
    kiss_fft_cpx fft_reconstructed[NUM_FFT];
    kiss_fftr_cfg fft = kiss_fftr_alloc(NUM_FFT ,0 ,0,0);
    kiss_fftr_cfg ifft = kiss_fftr_alloc(NUM_FFT,isinverse,0,0);

// azzera le matrici
for (int i = 0; i < NUM_FFT; i++) {
    fft_in[i].r = zero;
    fft_in[i].i = zero;
    fft_out[i].r = zero;
    fft_out[i].i = zero;
    fft_reconstructed[i].r = zero;
    fft_reconstructed[i].i = zero;
}

//inserisce i campioni nella parte reale della matrice di input
for (int i = 0; i < NUM_FFT; i++) {
     fft_in[i].r = samples[i];
     fft_in[i].i = zero;
     fft_out[i].r = zero;
     fft_out[i].i = zero;
 }

 kiss_fftr(fft, (kiss_fft_scalar*) fft_in, fft_out);
 kiss_fftri(ifft, fft_out, (kiss_fft_scalar*)fft_reconstructed);

// calcolo della potenza
for (int i = 0; i < NUM_FFT/2; i++) {
    samples[i] = sqrt((fft_out[i].i*fft_out[i].i)+(fft_out[i].i*fft_out[i].i))/(NUM_FFT*2);
    printf("%.6f\n\r", samples[i]);

}

    printf("Terminato!\n\r");
    return 0;
}

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

Dato input

Potenza

Segnale ricostruito