Logicielsmoto.com

Nous sommes le 26 Jan 2022, 09:39

Heures au format UTC + 1 heure




Poster un nouveau sujet Répondre au sujet  [ 11 messages ] 
Auteur Message
MessagePosté: 16 Fév 2021, 14:30 
Hors ligne

Inscription: 12 Fév 2021, 15:54
Messages: 36
Bonjour à tous,

heureux possesseur d'un MO5 depuis 1985, je possède l'interface "SD" réalisée par Daniel Coulom.
La petite bête fonctionne très bien et je me remets à programmer en assembleur dessus, mais à partir de mon linux (pour plus d'efficacité)

J'ai donc téléchargé "c6809" sur le site "puls".
Pas de souci, ça compile bien.
Avec les outils graphique de manipulation de FD de Daniel, je crée une disquette "à la main" à laquelle j'importe mon fichier .BIN.
Ensuite je convertis le FD en SD, toujours avec les outils de Daniel, et je bascule le tout sur mon MO5 : ça fonctionne.

Alternativement, je lance l'emultateur DCMOTO en mode MO5 avec l'image de la disquette FD, ça marche aussi parfaitement.

Seulement voilà, la production de la disquette FD c'est toujours par interface graphique, c'est pas très pratique et j'aurais aimé industrialiser la production de la disquette au format FD avec le BIN incorporé ainsi que la version "SD". Mais je ne crois pas que les outils de Daniel puissent se lancer en ligne de commande.

J'ai vu dans les outils de dev TO8 un générateur de disquette bootable qui déclenche automatiquement le BIN : ça me plait bien (surtout que c'est en Java et que c'est un langage que je connais "un peu").
Est-ce que cela fonctionnerait aussi sur MO5, même en mode SD ?

Au passage, je vais faire un peu de pub pour mon blog, il y a quelques petites choses "retro" dessus :
https://www.fxjavadevblog.fr/fr/

Bonne journée à tous.

_________________
Fan de Atari 2600, Thomson MO5, Thomson TO8, Atari STE.
Retro-Codeur à mes heures perdues. https://www.fxjavadevblog.fr


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 16 Fév 2021, 17:09 
Hors ligne

Inscription: 21 Avr 2019, 21:48
Messages: 237
Localisation: Var
Regarde dans l'archive que j'ai posté hier :
http://www.logicielsmoto.com/phpBB/viewtopic.php?f=3&t=620&start=15#p6749

il y a une classe dans les sources qui s'appelle FdUtil.java
Elle permet d'écrire à une position particulière (unité, piste, secteur) sur le fichier fd, plus d'autres choses ...
Il y a aussi une petite méthode pour produire le fichier sd correspondant.

Regarde aussi BuildDisk.java, je lance le compilo + écrit le binaire dans le fd.
Par contre je fais tout sans utiliser la FAT ;-) Il faut donc dans ton programme sauvegarder qq part les index disquette des données que tu veux lire. Il y a aussi les appels de routine pour lire la disquette mais c'est pour TO8

Pour le boot sur MO5 je ne sais pas si le fonctionnement est le même ... je laisse les experts répondre ;-)


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 16 Fév 2021, 19:39 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1538
Localisation: Brest
Moi ce que je fais via Makefile, c'est que je crée une diskette SAP vite [EDIT:vide, pas vite :) ] (sapfs -c disk.sap), que je peuple au fur et a mesure avec les binaires et données compilées (sapfs -a disk.sap TOTO.BIN TOTO.DAT). Ensuite je lance DCMoto sur le disk.sap, et il me crée un disk.fd à coté. Enfin je lance FD2SD.exe. Je ne fais ces deux dernières étapes que lors du packaging final. Durant la mise au point je reste sur le SAP car sapfs est utilisable en ligne de commande.

_________________
Good morning, that's a nice Tnetennba


Dernière édition par Samuel Devulder le 17 Fév 2021, 08:57, édité 1 fois.

Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 08:24 
Hors ligne
M. DCMOTO

Inscription: 06 Juin 2004, 08:23
Messages: 647
Localisation: Provence (France)
L'utilitaire dcfdutil n'était pas prévu au départ pour une utilisation en ligne de commande. Ses nombreuses fonctions et l'interface graphique le rendent un peu complexe.

Par contre si on se limite à
- l'insertion d'un fichier au format Thomson
- dans la face 0 d'une image de disquette 3"1/2 au format .fd ou .sd
- en ligne de commande
c'est extrêmement simple.
Je peux essayer de créer un outil spécifique.

Chaque développeur choisit la méthode qui lui convient le mieux. Pour ma part j'utilise l'assembleur A09. Il génère un fichier binaire simple (pas au format Thomson). Avec la fonction "Charger fichier binaire" de dcmoto je le charge en mémoire et je le copie dans un fichier .fd ou .sd par l'instruction SAVEM.


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 10:41 
Hors ligne

Inscription: 21 Aoû 2006, 09:06
Messages: 1538
Localisation: Brest
Ce qu'il serait carrément cool, serait de pouvoir monter une diskette FD thomson comme un disk virtuel PC à la façon de ImDisk.

_________________
Good morning, that's a nice Tnetennba


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 13:25 
Hors ligne

Inscription: 12 Fév 2021, 15:54
Messages: 36
Merci pour toutes vos réponses.

en fait effectivement ce qui m'intéresserait serait une utilitaire comme "sapfs" en ligne de commande mais pour générer un .fd et .sd.

Si on me dit où trouver de l'information sur la structure FAT et globalement de la structure d'un .FD, je suis preneur pour créer ce genre d'outils.

@bentoc : oui j'avais vu tes classes FdUtil et BuildDisk (d'ailleurs, bravo pour l'effort sur la javadoc qui va avec !)
Ca pourrait m'être très intéressant. @Daniel : Est-ce qu'une image SD Bootable est possible avec l'interface SD ? (j'imagine que oui)


@Daniel : j'avais tenté l'import "BIN" depuis l'interface de mise au point (F9) mais cela ne semblait avoir aucun effet sur la RAM après chargement
j'avais rien à l'adresse indiquée par mon BIN (org $6000).
Pour info j'ai procédé ainsi du coup : https://www.fxjavadevblog.fr/6809-thoms ... bly-linux/

En tout cas merci à tous, c'est cool de trouver des passionnés MO/TO !
J'avais un TO8 aussi, mais mon ex l'a viré à la déchetterie lors de notre séparation. J'ai quand même pu "sauver" mon MO5 et mon Atari ST
j'essaye de remettre la main sur un TO8 ou TO8D, mais c'est la misère, y'a plus rien de le "coincoin" ni sur "baybay" sauf à des prix prohibitifs !

_________________
Fan de Atari 2600, Thomson MO5, Thomson TO8, Atari STE.
Retro-Codeur à mes heures perdues. https://www.fxjavadevblog.fr


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 15:15 
Hors ligne
M. DCMOTO

Inscription: 06 Juin 2004, 08:23
Messages: 647
Localisation: Provence (France)
fxrobin a écrit:
j'avais tenté l'import "BIN" depuis l'interface de mise au point (F9) mais cela ne semblait avoir aucun effet sur la RAM après chargement
j'avais rien à l'adresse indiquée par mon BIN (org $6000).
Dans l'outil de mise au point, il faut donner l'adresse de chargement du fichier binaire.
Un fichier binaire simple, sans l'en-tête Thomson, ne contient pas d'adresse de chargement.


fxrobin a écrit:
Est-ce qu'une image SD Bootable est possible avec l'interface SD ?
Les fichiers .sd sont des images de disquettes Thomson. Si la disquette Thomson est bootable, le fichier .sd est bootable.
La majorité des démos et des jeux sont bootables, sinon il se lancent automatiquement par AUTO.BAT, ou manuellement par une commande BASIC.


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 15:36 
Hors ligne
M. DCMOTO

Inscription: 06 Juin 2004, 08:23
Messages: 647
Localisation: Provence (France)
Je n'ai pas trop le temps de développer un outil en ligne de commande pour importer un fichier Thomson dans une image de disquette au format .fd.
Par contre, si quelqu'un veut le faire, voici le code (extrait de dcfdutil) pour importer les fichiers d'un répertoire. On peut utiliser seulement la fonction d'importation d'un fichier, c'est encore plus simple.

Code:
/*****************************************************************************\
* IMPORT.C - Importation des fichiers d'un dossier                            *
* Auteur : Daniel Coulom - danielcoulom@gmail.com                             *
* Creation : Avril 2010                                                       *
\*****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include "dcfdutil.h"

//variables globales
FILE *fp;
char filename[256];
int filesize;
int newblock;

//variables externes
extern FILE *fdisk;
extern char *diskname;
extern char diskfilename[];
extern char folder[];
extern char fat[];
extern char cat[];
extern char string[];
extern int unite;
extern int type;
extern int unitsize;
extern int sectorsize;
extern int filesectorsize;
extern int blocksize;
extern int fatoffset;
extern int fatlength;
extern int catlength;
extern char cat_filename[];
extern char cat_comments[];
extern int cat_filetype;
extern int cat_datatype;
extern int cat_firstblock;
extern int cat_lastsectorsize;
extern int cat_flag;

//Allocation du premier bloc d'un fichier//////////////////////////////////////
void Firstalloc()
{
 int i, blockcount;
 blockcount = unitsize / blocksize;
 i = blockcount / 2;
 while(i < blockcount)
 {
  if((fat[i + 1] & 0xff) == 0xff) break;
  i = blockcount - i;
  if((fat[i + 1] & 0xff) == 0xff) break;
  i = blockcount + 1 - i;
 }
 newblock = i;
}

//Allocation des blocs suivants///////////////////////////////////////////////
void Nextalloc()
{
 int i, blockcount;
 i = newblock;
 blockcount = unitsize / blocksize;
 while(1)
 {
  if(i == 0) {Firstalloc(); return;}
  if((fat[i + 1] & 0xff) == 0xff) break;
  i--;
  if(i < blockcount / 2) continue;
  i += 2;
  if(i >= blockcount) {Firstalloc(); return;}
 }
 newblock = i;
}

//Mise a jour du catalogue////////////////////////////////////////////////////
int Updatecat(int n, int lastsectorsize)
//retour: 0=OK, negatif=fichier existant
{
 int i, n1, n2;
 //initialisation a blanc du filename thomson
 for(i = 0; i < 11; i++) cat_filename[i] = ' ';
 //determination de l'extension thomson
 for(n1 = strlen(filename); n1 >= 0; n1--) if(filename[n1] == '.') break;
 if(n1 < 0) n1 = strlen(filename);  //pas d'extension
 if(n1 > 8) n1 = 8;                 //le nom du fichier est <= 8
 for(i = 0; i < n1; i++) cat_filename[i] = filename[i]; //nom du fichier
 n2 = strlen(filename) - n1 - 1;    //longueur de l'extension
 if(n2 > 3) n2 = 3;
 for(i = 0; i < n2; i++) cat_filename[8 + i] = filename[n1 + i + 1];
 for(i = 0; i < 3; i++) string[i] = cat_filename[8 + i];
 string[3] = 0;
 //recherche d'existence du fichier dans le catalogue
 for(i = 0; i < 112; i++)
 if(memcmp(cat_filename, cat + 32 * i, 11) == 0) return -1;
 //determination du type de fichier
 cat_filetype = 2;
 if(strcasecmp(string, "BAS") == 0) cat_filetype = 0;
 if(strcasecmp(string, "BAT") == 0) cat_filetype = 0;
 if(strcasecmp(string, "DAT") == 0) cat_filetype = 1;
 if(strcasecmp(string, "ASC") == 0) cat_filetype = 1;
 if(strcasecmp(string, "TXT") == 0) cat_filetype = 1;
 //determination du type de donnees
 cat_datatype = 0;
 //attention: la determination du type de donnees n'est pas correcte
 //if(strcasecmp(string, "BAS") == 0) cat_datatype = 255;
 //if(strcasecmp(string, "BAT") == 0) cat_datatype = 255;
 if(strcasecmp(string, "DAT") == 0) cat_datatype = 255;
 if(strcasecmp(string, "ASC") == 0) cat_datatype = 255;
 if(strcasecmp(string, "TXT") == 0) cat_datatype = 255;
 //initialisation des autres champs
 for(i = 0; i < 15; i++) cat_comments[i] = 0;
 cat_flag = 0;
 cat_firstblock = newblock;
 cat_lastsectorsize = lastsectorsize;
 if(cat_lastsectorsize == 0) cat_lastsectorsize = filesectorsize;
 //ecriture dans le catalogue
 Putcat(n);
 //affichage du compte-rendu
 for(i = 0; i < 8; i++) string[i] = cat_filename[i];
 string[8] = ' ';
 for(i = 0; i < 3; i++) string[9 + i] = cat_filename[i + 8];
 string[12] = ' ';
 sprintf(string + 13, "%02x %02x  %02x %03x",
         cat_filetype, cat_datatype, cat_firstblock, cat_lastsectorsize);
 Display(string);
 return 0;
}

//Importation d'un bloc////////////////////////////////////////////////////////
void Importblock(int blocklength, int blocknumber)
{
 int i;
 int lastsectorlength;
 char buffer[blocklength];
 lastsectorlength = blocklength;
 for(i = 0; i < blocklength; i++) buffer[i] = 0;
 //secteurs complets
 for(i = 0; i < blocklength / sectorsize; i++)
 {
  fread(buffer + i * sectorsize, filesectorsize, 1, fp);
  lastsectorlength -= sectorsize;
 }
 //secteur incomplet
 if(lastsectorlength > 0) fread(buffer + i * sectorsize, lastsectorlength, 1, fp);
 //ecriture du bloc dans le fichier .fd
 fseek(fdisk, unite * unitsize + blocknumber * blocksize, SEEK_SET);
 fwrite(buffer, blocklength, 1, fdisk);
}

//Importation d'un fichier/////////////////////////////////////////////////////
void Importfile()
{
 int i, n;
 //int bloc;
 int nsectors;
 int nfullsectors;
 int incompletesectorsize;
 int nfullblocks;
 int blocksectors;
 int incompleteblocksectors;
 int currentblock;
 //ouverture du fichier
 strcpy(string, folder);
 strcat(string, filename);
 fp = fopen(string, "rb");
 if(fp == NULL) {Display(string); Erreur(2); return;}
 //taille du fichier
 fseek(fp, 0, SEEK_END);
 filesize = ftell(fp);
 fseek(fp, 0, SEEK_SET);
 //nombre de secteurs complets
 nfullsectors = filesize / filesectorsize;
 //taille du secteur incomplet
 incompletesectorsize = filesize - nfullsectors * filesectorsize;
 //nombre total de secteurs
 nsectors = nfullsectors;
 if(incompletesectorsize > 0) nsectors++;
 //nombre de blocs complets
 blocksectors = blocksize / sectorsize;
 nfullblocks = nsectors / blocksectors;
 //nombre de secteurs du bloc incomplet
 incompleteblocksectors = nsectors - nfullblocks * blocksectors;
 //allocation du premier bloc
 Firstalloc();
 if(newblock > 159) {Erreur(14); return;} //disquette pleine
 currentblock = newblock;
 //recherche place libre dans le catalogue
 for(n = 0; n < 112; n++)
 {
  if(cat[32 * n] == 0) break;
  if((cat[32 * n] & 0xff) == 0xff) break;
 }
 if(n > 111) {Erreur(14); return;} //disquette pleine
 //mise a jour du catalogue
 if(Updatecat(n, incompletesectorsize) < 0) {Display(filename); Erreur(15); return;}
 //ecriture des blocs complets (8 secteurs)
 for(i = 0; i < nfullblocks; i++)
 {
  //ecriture du bloc
  currentblock = newblock;
  Importblock(blocksize, currentblock);
  //allocation du prochain bloc
  fat[currentblock + 1] = 0; //pour ne pas reallouer le meme bloc
  Nextalloc();
  fat[currentblock + 1] = newblock;
 }
 //indicateur de fin en l'absence de bloc incomplet
 if(incompleteblocksectors == 0)
 {
  fat[currentblock + 1] = 0xc0 + blocksectors;
 }
 //ecriture eventuelle d'un bloc de fin incomplet
 if(incompleteblocksectors > 0)
 {
  currentblock = newblock;
  Importblock(incompleteblocksectors * sectorsize, currentblock);
  fat[currentblock + 1] = 0xc0 + incompleteblocksectors;
 }
 fclose(fp);
}

//Importation des fichiers d'un repertoire/////////////////////////////////////
void Import()
{
 DIR *dp;
 DIR *dummy;
 struct dirent *ep;
 int i;
 //controle
 sprintf(string, "Importation unite %i disquette ", unite);
 if(diskname != NULL) strcat(string, diskname + 1);
 Display(string);
 if(diskname == NULL) {Erreur(1); return;}
 //ouverture du fichier image de disquette
 fdisk = fopen(diskfilename, "rb+");
 if(fdisk == NULL) {Erreur(2); return;}
 //lecture FAT et DIR
 i = unite * unitsize + fatoffset;
 fseek(fdisk, 0, SEEK_END);
 if(i > ftell(fdisk)) {Erreur(10 + unite); return;}
 fseek(fdisk, i, SEEK_SET);
 fread(fat, fatlength, 1, fdisk);
 fread(cat, catlength, 1, fdisk);
 //choix du dossier
 if(ChoixDossier(0) < 0) {Erreur(9); return;}
 //boucle sur chaque fichier du dossier
 dp = opendir(folder);
 if(dp == NULL) {Erreur(3); return;}
 while((ep = readdir(dp)))
 {
  strcpy(filename, ep->d_name);
  if(filename[0] == '.') continue; //c'est un fichier supprime
  strcpy(string, folder);
  strcat(string, filename);
  dummy = opendir(string);
  if(dummy) {closedir(dummy); continue;} //c'est un repertoire
  Importfile();
 }
 closedir(dp);
 //ecriture fat et cat
 fseek(fdisk, unite * unitsize + fatoffset, SEEK_SET);
 fwrite(fat, fatlength, 1, fdisk);
 fwrite(cat, catlength, 1, fdisk);
 fclose(fdisk);
 Display("Fin de l'importation des fichiers du dossier");
}


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 17 Fév 2021, 16:27 
Hors ligne

Inscription: 12 Fév 2021, 15:54
Messages: 36
Super merci Daniel !

_________________
Fan de Atari 2600, Thomson MO5, Thomson TO8, Atari STE.
Retro-Codeur à mes heures perdues. https://www.fxjavadevblog.fr


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 08 Mar 2021, 09:18 
Hors ligne

Inscription: 24 Juil 2010, 16:08
Messages: 437
Localisation: France
Bonjour,

Vous pouvez trouver une implémentation d'un convertisseur sap->fd et fd->sd sur mon github: https://github.com/pulkomandy/thomson/tree/master/tools

J'utilise cela en ligne de commande sous Haiku (mais ça devrait compiler sans problème sous Linux également) pour tout faire depuis un makefile.


Haut
 Profil  
Répondre en citant le message  
MessagePosté: 08 Oct 2021, 14:43 
Hors ligne

Inscription: 12 Fév 2021, 15:54
Messages: 36
j'étais passé au travers de cette réponse.
Merci Pulkomandy !!!!!

_________________
Fan de Atari 2600, Thomson MO5, Thomson TO8, Atari STE.
Retro-Codeur à mes heures perdues. https://www.fxjavadevblog.fr


Haut
 Profil  
Répondre en citant le message  
Afficher les messages postés depuis:  Trier par  
Poster un nouveau sujet Répondre au sujet  [ 11 messages ] 

Heures au format UTC + 1 heure


Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 3 invités


Vous ne pouvez pas poster de nouveaux sujets
Vous ne pouvez pas répondre aux sujets
Vous ne pouvez pas éditer vos messages
Vous ne pouvez pas supprimer vos messages
Vous ne pouvez pas joindre des fichiers

Rechercher:
Aller à:  
cron
Développé par phpBB® Forum Software © phpBB Group
Traduction par phpBB-fr.com