Files in TI-89

 TiOs non ha un vero e proprio file system ma permette comunque di salvare file dati sul calcolatore

Per esempio si puo' usare il programma TiGraph per generare delle note

Il file non sara' identificato dal nome ma dalla "variabile" associata

Una volta trasferito il file sulla calcolatrice sono tilp2 si puo' aprire la nota con il text editor

E' possibile usare dei folder ma in questo caso si e' usata la root che in TiOs viene definita main ed il file compare automaticamente aprendo la finestra del menu variabile

altirmenti si possono generare dei file custom da codice. La cosa interessante e' che i file su TiOs non sono compatibili con la versione PC. Per esempio un semplice file testo ha un header ed un tag di chiusura (OTH_TAG) 

//https://technoplaza.net/programming/lesson10.php

#define USE_TI89

#include <stdlib.h>

#include <stdio.h>

#include <estack.h>

int _main(void)

{

const int dimx = 50, dimy = 50;

FILE *fp = fopen ("example2", "wb");

fprintf(fp, "P6\n%d %d\n255\n", dimx, dimy);

fputs("luca",fp);

fputc (0, fp);

fputs ("HSC", fp);

fputc (0, fp);

fputc (OTH_TAG, fp);

fclose (fp);

return 0;

}

TI-89 scrittura diretta in memoria video

 Oltre a poter usare un buffer per generare grafica si puo' avere anche la scrittura diretta in memoria video sulla TI-89 puntando all'indirizzo 0x4C00

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <math.h>

#include <kbd.h>

char * reale = (char *) 0x4C00;

int c;

void setpixel(int x, int y)

{

int yc = 30*y;

int xc = (int)floor(x/8);

int xd = 1<<(7-(x % 8));

reale[yc+xc]=xd;

}

void pulisci(void)

{

for (c=0;c<3840;c++)

{

reale[c]=0;

}

}

int _main(void)

{

pulisci();

for (c=0;c<80;c++){

setpixel(c,c);

}

ngetchx();

return 0;

}

Schermo virtuale su TI-89

Una delle cose divertenti con la TI-89 e' di avere il controllo completo dell'hardware con l'accesso diretto alla memoria video

La memoria dello schermo LCD inizia a 0x4C00

Si puo' fare puntare lo schermo virtuale ad una zona di memoria e poterla trattare con i comandi grafici (ogni byte di memoria contiene l'informazione di 8 pixels) 

dopo aver creato il buffer video si puo' copiarlo sulla vera memoria video per mostrare il risultato

attenzione: nonostante la TI-89 abbia uno schermo di dimensione 160x100 il codice funziona solo con le dimensione di 240x128 ovvero le dimensioni della TI-92 (la sorella maggiore)

#define USE_TI89

#define SAVE_SCREEN // Save/Restore LCD Contents

#include <stdlib.h>

#include <stdio.h>

#include <graph.h>

#include <kbd.h>

#include <string.h>

int _main(void)

{

char virtual[LCD_SIZE];

//PortSet ((void *) 0x4C00, 239, 127);

int i;

for (i=1;i<50;i++)

{

DrawPix(i,i,A_NORMAL);

}

ngetchx();

memcpy (LCD_MEM, virtual, LCD_SIZE);

ngetchx();

PortRestore();

return 0;

}

Apriltag 3 48h12

Per vedere se c'era un motivo per scegliere una diversa famiglia di Apriltag rispetto al 36h11 ho provato la famiglia consigliata 48h12 (che rientra nelle custom) 

La standard deviation su circa 200 misure (un giorno) e' stata dello 0.25% (1.15 cm ad una distanza di 4.6 m) con un lievissimo miglioramento rispetto alle prove precedenti

ps : per usare la famiglia Custom48h12 si deve modificare il codice del file di esempio

Lora32 come scheda di rete

Un po ' di tempo fa avevo sperimentato l'uso del protocollo AX25 usando Lora  con in moduli SX1278

Questa volta provo ad usare Lora32 Lilygo con il software di RNode

Per prima cosa si deve impostare un ambiente virtuale in Python (in Debian non permette di fare pip al di fuori di in venv) per installare 

pip install rns

rnodeconf --autoinstall

(per la Lilygo Lora32 che ho usato io l'opzione della scheda e' la numero 3)

rnodeconf /dev/ttyuUSB0 -T --freq 868000000 --bw 125000 --txp 2 --sf 7 --cr 5

(qui si impostano sulle schede le impostazione di trasmissione Lora)

per configurare il dispositivo come una scheda di rete wireless si usa tncattach 

tncattach /dev/ttyUSB0 115200 -d --noipv6 --noup --mtu 572

La configurazione puoà essere come punto punto 

ifconfig tnc0 10.0.0.1 pointopoint 10.0.0.2

(ovviamente scambiando gli indirizzi sulle due schede)

oppure multi punto (ma e' decisamente piu' lenta

tncattach /dev/ttyUSB0 115200 -d -e --noipv6 --mtu 554 --ipv4 10.91.0.1/24

per le prove che ho fatto il sistema e' lento ma in ogni caso in una punto punto si riesce ad interagire in modo discreto con una sessione SSH

TI-89 Mandelbrot

 Ho scoperto per puro caso che le calcolatrici Texas Instruments TI-89 (e parenti) hanno al proprio interno un processore della classe 68000 e che possono essere programmate, oltre che in TI-Basic, anche in C...proviamo un po'

Il compilatore C che ho usato si trova a questo link https://github.com/debrouxl/gcc4ti

esistono versioni meno aggiornate ma non sono cosi' complete

Per compilare si va in /trunk/tigcc-linux/scripts e si lancia ./Install

si impostano poi le variabili di ambiente

export TIGCC=/usr/local/share/gcc4ti/

export PATH=$PATH:$TIGCC/bin

il codice di questo post e' ripreso dal precedente post 

le differenze sono :

1) la funzione main in TIGCC si chiama _main (underscore main)

2) sono necessari gli include di stdio e kbd anche se di fatto non sono richiamati dal codice

#define USE_TI89 // produce all types of files

//#define USE_TI92PLUS

//#define USE_V200

#include <stdio.h> // standard ANSI C input/output support

#include <kbd.h>

#include <tigcclib.h>

#define FIXEDPT_WBITS 4

#define WIDTH 160

#define HEIGHT 100

#include "fixedptc.h"

void _main(void) {

ClrScr();

int j,k,i;

float test;

fixedpt Re,Im,DRe,DIm;

fixedpt X,Y,DUE;

fixedpt XN,YN,YNN;

fixedpt A,B;

Re = fixedpt_rconst(-2.00390625); //finestra reale tra -2 e +0.5

Im = fixedpt_rconst(-1.205); //finestra immaginaria tra -1.2 e 1.2

DRe = fixedpt_rconst(0.015625); //2.5/160

DIm = fixedpt_rconst(0.024); // 2.4/100

DUE = fixedpt_rconst(2.0);

A = Re;

for (j=0;j<WIDTH;j++)

{

A = fixedpt_add(A,DRe);

B = Im;

for (k=0;k<HEIGHT;k++)

{

B = fixedpt_add(B,DIm);

X = fixedpt_rconst(0.0);

Y = fixedpt_rconst(0.0);

for (i=0;i<=127;i++)

{

XN=fixedpt_sub(fixedpt_mul(X,X),fixedpt_mul(Y,Y))+A; // (x*x) - (y*y) + A

YN=fixedpt_mul(X,Y); // x*y

YNN=fixedpt_mul(DUE,YN); // 2*x*y

YN=YNN + B; // 2*x*y*+B

test = fixedpt_tofloat(fixedpt_mul(XN,XN) + fixedpt_mul(YN,YN)); //(XN*XN)+(YN*YN)

if (test > 4.0)

{

//png.plot(j,k,1.0,1.0,1.0);

if (i%2) DrawPix(j,k,A_NORMAL);

break;

}

X = XN;

Y = YN;

}

}

}

}

tigcc -O2 -o timand timand.c 

il file binario avra' una estensione .89z (nel caso si compile di per TI-92 sara' .92z)

Per il trasferimento dell'eseguibile tramite cavo USB ho usato il programma TILP funzionante su Linux impostando Direct Link

Una volta trasferito il codice sul dispositivo si puo' eseguire digitando il nome del fie per esempio se il nome del file e' timand come se fosse una funzione ...per esempio timand()

In alcuni casi la calcolatrice puo' non mostrare la linea di comando ma le icone..in questo caso si preme il tasto MODE si scrolla in basso fino all'opzione APP Desktop e se seleziona OFF

Se non si vuole usare un dispositivo fisico si puo' usare l'emulatore TIEmu. In questo caso per caricare l'eseguibile e' sufficiente premere il tasto F10 e selezionare il flie .89z

Hacking camping wifi

Al campegggio il servizio Wifi era gratuito ma il portale captivo era impostato per un limite di banda dopo la quale non potevi navigare fino al giorno successivo

la soluzione e' stata semplicemente quella di impostare il Mac Address della scheda wireless su Random. Ogni volta che arrivavo al limite di banda consumata mi e' bastato spengere e riaccendere il WiFi per assumere un nuovo Mac Address e continuare a navigare