venerdì 11 febbraio 2022

JSon in Go

 Leggere Json in Go non e' esattamente banale perche' il linguaggio e' fortemente tipizzato

Se il tracciato record del Json e' fissato e' conosciuto si puo' fare un Unmarshal del tracciato altrimenti con Json dinamici o non conosciuti la situazione diventa piu' complessa

Partiamo da un Json complesso

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

 {
        "statusCode":200,
        "message":"OK",
        "dataValue":
            {
                "versionWS":"v1",
                "language":"it",
                "idUserSession":
                "wguest",
                "user":
                    {
                        "userId":27,
                        "userName":"G",
                        "userSurname":"G",
                        "idUserSession":"c4cefc3032e3f8e63f3ee320b81cf1d5"
                    }
            }
    }

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

per fare l'Unmarshal del Json si deve definire tramite Struct il tracciato record con indicato anche il tipo di variabile associata ad ogni campo...in questo campo essendoci piu' livelli si devono creare delle Struct intermedie per i livelli piu' interni. Da notare che le variabilenelle Struct hanno la prima lettera maiuscola per l'esportazione ed il tag Json corrispondente

Interessa arriva a leggere la proprieta' idUserSession dell'utente (si tratta di gestire una authorization da un servizio Restful)

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

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    UserId        int32  `json:"userId"`
    UserName      string `json:"userName"`
    UserSurname   string `json:"userSurname"`
    IdUserSession string `json:"idUserSession"`
}

type dataValue struct {
    VersionWS            string `json:"versionWS"`
    Language             string `json:"it"`
    IdUserSession        string `json:"idUserSession"`
    Wguest string `json:"wguest"`
    User                 User   `json:"user"`
}

type messaggio struct {
    StatusCode int32     `json:"statusCode"`
    Message    string    `json:"message"`
    DataValue  dataValue `json:"dataValue"`
}

func main() {
    b := []byte(`    {
        "statusCode":200,
        "message":"OK",
        "dataValue":
            {
                "versionWS":"v1",
                "language":"it",
                "idUserSession":"",
                "guest":"",
                "user":
                    {
                        "userId":27,
                        "userName":"G",
                        "userSurname":"G",
                        "idUserSession":"c"
                    }
            }
    }`)
    var mes messaggio
    json.Unmarshal(b, &mes)
    fmt.Println(mes.DataValue.User.IdUserSession)

}

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

fino a qui e' abbastanza lineare. Senza il tracciato record non si puo' fare Unmarshal di una Struct ma si deve passare attraverso una interface e gestire i vari livelli di map fino a trovare il valore richiesto


---------------------------------------------------------------------------
package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    b := []byte(`    {
        "statusCode":200,
        "message":"OK",
        "dataValue":
            {
                "versionWS":"v1",
                "language":"it",
                "idUserSession":"":
                "guest":"",
                "user":
                    {
                        "userId":27,
                        "userName":"G",
                        "userSurname":"G",
                        "idUserSession":"c"
                    }
            }
    }`)

    var dat map[string]interface{}

    if err := json.Unmarshal(b, &dat); err != nil {
        panic(err)
    }
    test := dat["dataValue"].(map[string]interface{})["user"]
    if rec, ok := test.(map[string]interface{}); ok {
        for key, val := range rec {
            if key == "idUserSession" {
                fmt.Printf(" %s = %s", key, val)
                fmt.Println()
            }

        }
    }

}

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



sabato 29 gennaio 2022

Setpixel su C64 (2)

 In un precedente post  avevo gia' affrontato il problema ...leggendo su codebase64 viene proposta una variante che usa delle tabelle di lookup per velocizzare il programma ma non viene presentato il codice completo. Questa e' una implementazione


.macro ClearScreen(screen, clearByte) {
lda #clearByte
ldx #0
!loop:
sta screen, x
sta screen + $100, x
sta screen + $200, x
sta screen + $300, x
sta screen + $400, x
sta screen + $500, x
sta screen + $600, x
sta screen + $700, x
sta screen + $800, x
sta screen + $900, x
sta screen + $a00, x
sta screen + $b00, x
sta screen + $c00, x
sta screen + $d00, x
sta screen + $e00, x
sta screen + $f00, x
sta screen + $1000, x
sta screen + $1100, x
sta screen + $1200, x
sta screen + $1300, x
sta screen + $1400, x
sta screen + $1500, x
sta screen + $1600, x
sta screen + $1700, x
sta screen + $1800, x
sta screen + $1900, x
sta screen + $1a00, x
sta screen + $1b00, x
sta screen + $1c00, x
sta screen + $1d00, x
sta screen + $1e00, x
sta screen + $1f00, x
inx
bne !loop-
}

.macro ClearColorRam(clearByte) {
lda #clearByte
ldx #0
!loop:
sta $0400, x
sta $0400 + $100, x
sta $0400 + $200, x
sta $0400 + $300, x
inx
bne !loop-
}


.macro Hires (){
lda $D018
//ora #%1000
ora #8
sta $D018 // VIC_ADDR + 24
}

.macro BMM (){
lda $D011
//ora #%100000
ora #32
sta $D011 // VIC_ADDR + 17
}


// costanti per la generazioni delle tabelle
// di lookup per calcolare la posizione del pixel
.const GFX_MEM = $2000

.const BitMask = $0a00
.const X_Table = $0b00
.const Y_Table_Lo = $0c00
.const Y_Table_Hi = $0d00

*=$0801 "Loader"
BasicUpstart($0810)


*=$0810 "Main" // SYS 2064

// generazione delle tabelle di lookup
ldx #$00
lda #$80
Loop1:
sta BitMask,x
ror
bcc Skip1
ror
Skip1:
tay
txa
and #%11111000
sta X_Table,x
tya
inx
bne Loop1

lda #<GFX_MEM // Can be replaced with a TXA if GFX_MEM is page aligned
Loop2:
ldy #$07
Loop3:
sta Y_Table_Lo,x
pha
SMC1:
lda #>GFX_MEM
sta Y_Table_Hi,x
pla
inx
dey
bpl Loop3
inc SMC1+1
clc
adc #$40
bcc Skip2
inc SMC1+1
Skip2:
cpx #8*25
bne Loop2

// ********************************************************
jsr $e544 // kernal clear screen
//:SetBorderColor(BLACK)
//:SetBackgroundColor(BLACK)


:Hires()
:BMM()

:ClearScreen($2000,0)
:ClearColorRam($3)



ldx #100 //posizione X del pixel
ldy #100 //posizione Y del pixel
jsr Plott

looper:
jmp looper
rts

Plott:
lda Y_Table_Hi,y
sta $fc
lda Y_Table_Lo,y
sta $fb

ldy X_Table,x
lda BitMask,x
ora ($fb),y
sta ($fb),y
rts





giovedì 27 gennaio 2022

Visual Code Assembler C64

Qualche tempo fa avevo provato CBM Prg Studio ma aveva diverse limitazioni (la prima fra tutte girare solo su Windows)



Per una soluzione multi piattaforma si puo' usare Visual Studio con l'estensione Kick Assembler 8-bit Retro Studio, Kick Assembler, Vice e C64 Debugger

Una volta installata la estensione si devono impostare nei settaggi del plugin le path dei vari componenti

Su Debian ho avuto diversi problemi con C64Debugger...installando la versione binaria viene generato il seguente errore 


sudo ln -sf libxcb-util.so.0 libxcb-util.so.1

il problema e' che la libreria non e' disponibile in apt e fare un symlink semplicemente blocca X al riavvio successivo

Per installare C64debugger da sorgenti si devono seguire i passi seguenti


apt install upx-ucl

git clone git://git.code.sf.net/p/c64-debugger/code c64-debugger-code
cd MTEngine

modificare Makefile aggiungendo -fcommon alle CFlags

make

Grandi poteri fanno grandi casini

 Stavo cercando di installare un software su Linux che viene distribuito in binario e che lamentava una versione di libxcb-util che ho disponibile in apt solo alla versione precedente


Speranzoso ho fatto un symlink con la release precedente ed ho per la prima volta visto questa schermata....libxcb-util e' una parte fondamentale di X ed ha inchiodato tutto  
Ripartito da Grub in recovery si deve prima riattivare a mano la rete (mi sono collegato via cavo) e poi ho forzato la reinstallazione della libreria

/etc/init.d/networking start
dhclient enp0s25
apt --reinstall install libxcb-util1




M5Stack StickC

Aggiornamento

************************************************************

sono riuscito a modificare lo sketch usando la modalita' deepsleep
per allungare la durata della batteria. Al primo avvio viene solo mostrato
la grafica al video...i boot seguenti fatti a seguito di wake up da deep sleep
viene avviata la tastiera BLE 
L'aspetto piu' critico e' stato quello di inserire un delay al riavvio perche' sono necessari
4 secondi per riavviare la riconnessione al Bluetooth e 4 secondi per l'invio del messaggio
(tempi piu' brevi portano a connessioni non affidabili)

#include <BleKeyboard.h>
#include <M5StickC.h>

RTC_DATA_ATTR int bootCount = 0;
BleKeyboard bleKeyboard;
String player = "1"; // set player 1 or player2
void setup() {
  ++bootCount;
  if (bootCount >1 )
    {
      delay(4000);
      bleKeyboard.begin();111
      delay(4000);
      if(bleKeyboard.isConnected()) {
              bleKeyboard.print("1");1
      }
      pinMode(10, OUTPUT);
      digitalWrite(10, LOW); // accende il led
      delay(100);
      digitalWrite(10, HIGH);
    }
    else
    {
    M5.begin();
    pinMode(10, OUTPUT); // red led
    digitalWrite(10, HIGH);
    
    M5.Lcd.setRotation(3);  
    pinMode(37, INPUT); 
  
    M5.Lcd.setTextSize(3);
    M5.Lcd.setCursor(5, 18);  
    M5.Lcd.print("Player "+player);
    delay(1000);
    M5.Axp.SetLDO2(false); // spenge lo schermo      
    }
    
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_37,0);//Configure GPIO37 as ext0 wake up source for low logic level
  esp_deep_sleep_start();
}
void loop() {
}

************************************************************


M5Stack Stickc e' un indossabile (piu' o meno) con a bordo un Esp 32 Pico programmabile

Ha una batteria da soli 80 mAh ed in condizioni normali resta acceso meno di 10 minuti...volevo trasformarlo in un pulsante remoto come tastiera BLE HID per comandare un PC 



Spengendo lo schermo e riducendo il clock a 80 MHz si puo' avere una durata della batteria di circa 75 minuti...ho provato a gestire la modalita' lightsleep dell'ESP32 ma con risultati non sempre affidabili. (non so se a causa di Esp32 o del controllo del widget bluetooth di Gnome su Debian che fa parecchi capricci....se avro' tempo provero' a migliorare)
#include <M5StickC.h>
#include <BleKeyboard.h>
BleKeyboard bleKeyboard;
int last_value = 0;
int cur_value = 0;
String player = "1"; // set player 1 or player2
void setup() {
bleKeyboard.begin();
setCpuFrequencyMhz(80); // downscale la frequenza da 240 a 80 Mhz
M5.begin();
pinMode(10, OUTPUT); // red led
digitalWrite(10, HIGH);
M5.Lcd.setRotation(3);
pinMode(37, INPUT);
M5.Lcd.setTextSize(3);
M5.Lcd.setCursor(5, 18);
M5.Lcd.print("Player "+player);
delay(1000);
M5.Axp.SetLDO2(false); // spenge lo schermo
}
void loop() {
M5.update();
delay(300); // per evitare la doppia pressione
cur_value = digitalRead(37);
if(cur_value != last_value){
if(cur_value==0){
if(bleKeyboard.isConnected()) {
bleKeyboard.print(player);
/*M5.Axp.SetLDO2(true);
M5.Lcd.fillScreen(RED);
delay(100);
M5.Lcd.fillScreen(BLACK);
M5.Axp.SetLDO2(false);*/
digitalWrite(10, LOW); // accende il led
delay(100);
digitalWrite(10, HIGH);
}
}
else{
}
last_value = cur_value;
}
}

Debugger integrato ESP32S3

Aggiornamento In realta' il Jtag USB funziona anche sui moduli cinesi Il problema risiede  nell'ID USB della porta Jtag. Nel modulo...