ORPIC

by Posted on

Orpic: acronyme pour « Or »i »c » et Raspberry « Pi« 

Ce projet va consister à développer un serveur WEB tournant sur Raspberry Pi (ou éventuellement autre machine Linux) permettant d’héberger des jeux pour Oric/ Oric Atmos au format TAP, puis de les convertir à la volée en fichier .wav, afin de les transférer vers l’Oric Atmos à partir de n’importe quel PC ou Smartphone
Ce projet se trouve sur Github

Principe

Ci dessous le principe d’Orpic

Installation

Introduction

Bien que le serveur Orpic puisse tourner sur n’importe quelle distribution Linux, je donne ici les recommandations pour l’installation cible: Raspberry

Prérequis sur Raspberry

Opération de base:

Une fois connecté sur votre Raspberry en ssh.

Installer un serveur ftp, afin de pouvoir transférer les fichiers .tap par la suite.

sudo apt-get install proftpd

Par la suite il sera possible de se connecter sur le serveur ftp avec par exemple le client Filezilla en spécifiant

  • Login : pi
  • Mot de Pass: raspberry

Git doit également être installé sur votre Raspberry

sudo apt-get install git-core

Installation Automatique

Il suffit de récupérer le fichier  »’orpic_install_update.sh »’ et de lancer la commande

source orpic_install_update.sh

Une fin l’installation ou l’update réalisée, il suffit de lancer le serveur

source orpic_run
(Avant de lancer cette commande vérifiez bien que l'environnement "venv" est bien activé.

Installation Pas à Pas

Récupérer la dernière version de Orpic

git clone https://github.com/ckl67/Orpic.git cd Orpic
     ou à travers un 
git pull

Puis se placer dans le répertoire Orpic/src

python3 -m venv venv
source venv/bin/activate
pip3 install -r requirements.txt

Finalement lancer le programme en vous mettant dans le répertoire src/webapp

nohup flask run

En Développement

Sous le répertoire lancer la commande

flask run

Et en lançant la page web : http://[Adresse de votre Raspberry]:8080/

Serveur Web en Python

Principe

Le serveur Web sera basé sur le présent article : Serveur Web Python avec Flask.

Fichiers en détail

Fichier: .flaskenv

FLASK_APP=web.py
FLASK_RUN_HOST=0.0.0.0
FLASK_RUN_PORT=8080
FLASK_ENV=development

Va configurer flask, pour indiquer qu’un : 

flask run

va lancer web.py

Fichier: web.py

from webapp import app

Cette instruction importe la variable app qui est membre du package webapp
==> Donc à fortiori va exécuter 

__init__.py

dans le package webapp

Fichier: webconfig.py

class Config(object):
WEBAPP_DEBUG_LEVEL = 0
WEBAPP_VERSION = "1.00"
TAP2WAV_VERSION = "1.12"
SECRET_KEY = 'Mon Secret se cache derrière'

Ce module rassemble toute la configuration de l’application

Package: webbapp

Ce répertoire est un package identifié à travers le présence du fichier :

__init__.py

Fichier : __init__.py

from flask import Flask
app = Flask(name)

Le script ci-dessus crée simplement l’objet d’application : app, en tant qu’instance de classe Flask importée du package flask.
La variable name transmise à la classe Flask est une variable prédéfinie Python, qui définie le nom du module dans lequel cette variable est utilisée.
Flask utilise l’emplacement du module passé ici, comme point de départ lorsqu’il doit charger des ressources fichiers.
C’est le point d’entrée pour l’URL du serveur Web

Comme: __init.py__ se trouve dans /src/webapp: ce sera le point d’entrée pour l’URL du site.

Autrement dit, le mappage de l’URL se fera sur le répertoire: /src/ webapp

Si une demande de

  • http://yourusername.pythonanywhere.com/static/images/something.png
    arrive, le système analysera les mappages de fichiers et recherchera un fichier
  • /home/votre nom d’utilisateur/votre site/static/images/something.png

Attention, à ne pas confondre avec l’application python, « web.py » qui elle prendra comme référence dans la répertoire /src.

app.config.from_object(Config)

Plutôt que de créer des Constantes de l’application à travers
app.config[‘..’] = ‘..’
Il est préférable de passer par un module externe webconfig.py
Par la suite nous pouvons appeler ces constante à travers
app.config[‘DEBUG’]

from webapp import routes

L’application importe ensuite le module routes
Le module routes est importé en bas et non en haut du script
L’importation inférieure est une solution de contournement aux importations circulaires !!
En effet, Le module routes a besoin d’importer la variable d’application « app » définie dans ce script

Fichier: routes.py

from flask import render_template
from webapp import app

@app.route('/')
def home():

Les itinéraires sont les différentes URL que l’application implémente.
Dans Flask, les gestionnaires des routes d’application sont écrits en tant que fonctions Python, appelées fonctions d’affichage.
Les fonctions d’affichage sont mappées sur une ou plusieurs URL de route afin que Flask sache quelle logique exécuter lorsqu’un client demande une URL donnée.

Fichier: common.py

Ce module python contient des fonctions diverses permettant de mener le projet à bien. Aussi bien des fonctions de conversions que des fonction de debug

Fichier : Forms

Permet de gérer les préférences.

Autres fichiers

Le fichier python routes.py se base sur l’ossature ./src /template/main.hml
Le fichier ./src /template/main.html se base sur le formatage ./src /static/style.css
Les fichiers .TAP se trouvent sous ./src /static/Tapes
Les conversion en audio se font dans le répertoire static/Audio/AudioTape

Debug

Le niveau de debug se fait en modifiant le fichier: webconfig.py

Module de conversion en C

Références

Cette article puise ses références dans différents articles sur l’Oric. Je ne pourrais pas les citer tous, tellement le sujet de l’Oric a été traité, ausculté, détaillé. Je ne citerai que les plus importants qui m’ont permis d’adapter la conversion « tap2wav »

tap2wav

Le module tap2wav va consister à convertir le fichier .Tap en fichier wav.

Le fichier source se trouve dans le répertoire ./src
La compilation se fait avec ./make
Le résultat de compilation est donnée dans ./bin
Pour valider la conversion tap2wav, j’utilise le répertoire /data

Utilisation : de tap2wav

Usage : 
Option -f : frequence 
   4 --> produces a 4800 Hz WAV file (Default) 
   8 --> produces a 8000 Hz WAV file 
   11 --> produces a 11025Hz WAV file  
   44 --> produces a 44100Hz WAV file  
Option -s : split output file 
    yes/y--------> Will split the .WAV files in as many files than .TAP file is containing programs
                   The output .WAV file will end with an index number 
    no/n---------> There will be only 'one' .WAV file containing all the program 
    yes/no/y/n --> A silence zone will be added at the end of the different parts 
Option -b : mean baud rate value 
    n  --> normal          : ~2000 Baud (default) for 4800Hz or 8000Hz or 11025Hz 
            l------------> : ~2500 Baud (default) for 44100Hz 
    f  --> fast            :                        
            |------------> : ~2500 Baud for  8000Hz  
            |------------> : ~3100 Baud for 11025Hz  
            l------------> : ~3400 Baud for 44100Hz  
Option -e : Empty duration in "seconds" (silence 0x80) in .wav file at: 
            -the end of the file  
            -between 2 secions in the .Tap file 
Option -v : version 
Option -h : help

Spécifications internes

Transmission

Principe de transmission UART Classique

Bien que l’ORIC n’a pas de circuit UART,
L’ORIC utilise le circuit 6522 : (entrée CS1) pour recevoir le signal envoyé par le lecteur de cassette)
le principe de transmission est néanmoins calqué sur une transmission classique: bit start, stop, parité et data.

Pour rappel, nous donnons un exemple de transmission à 8000 bauds (1 bit start, Code Ascii 0X61, 1 bit stop)

Transmission ORIC

Fichiers .TAP

Le fichiers TAP est l’image du code stocké en mémoire de l’ORIC. Le format du fichier est le suivant :

Ci-dessous, le fichier « Aigle d’or.tap »

Signal audio

Dans les années 80, et par évidemment son faible coût, le magnétocassette était la mémoire de masse privilégiée des ordinateurs. Le programme stocké sur cassette, était envoyé sur l’entrée audio.

Tape-In : entrée cassette, (tension crête 150mV) utilise le compteur de synchronisation du 6522, pour mesurer l’’amplitude des impulsions. IC3 est un double ampli-opérationnel qui convertit le signal audio en signal TTL. Le premier étage est un ampli tampon inversant le gain unitaire (entrée en broche 2 et sortie en broche 1). Le second étage est un amplificateur de réaction positive.

Pour info, pour une question de simulation, le LM358 a été remplacé par un LT1013. Autrement LTSpice ne convergeait pas correctement.

Format d’un bit

L’Oric accepte 2 vitesses

  • 300 baud (Slow)
  • 2400 baud (Fast)

Ces vitesses sont en fait de moyennes comme nous le verrons plus loin.
Nous nous intéresserons essentiellement au mode Fast

Une transmission de 2400 bits/seconde, correspond à une période d’échantillonnage : T de 1/(2T) = 1/2400 –> T = 208 us

Le codage retenu par Tangerine était

  • 2T pour émettre un 1 et
  • 3 T pour émettre un 0.

Le signal rendu par un magnétophone n’est pas rectangulaire, mais sinusoïdale. (Lié à la bande passante du support)

En conclusion, Le signal standard, en FAST

  • code un « 1 » par une sinusoïde d’une période de 416 µs (2 x une durée de 208µs), et
  • code un « 0 » par une sinusoïde d’une période de 624µs (3 x 208µs).

Schématiquement :

Lors de la lecture d’une bande, le VIA 6522 détecte une sinusoïde, envoie ensuite une « Interruption » à l’Oric, qui commencera à compter le temps entre celui-ci et le suivant (et ainsi de suite).
Ensuite, l’Oric compare cette durée à 512µs (qui est le milieu entre 416 et 624µs), et stocke un bit « 0 » pour une durée plus longue, ou un « 1 » pour une durée plus courte. Cette marge de 20% était utile avec les lecteurs de cassettes des années 80 fonctionnant à différentes vitesses.

Avec les lecteurs numériques actuels, nous pouvons tirer avantage de la bonne qualité audio et de la vitesse de lecture parfaite, ceci afin d’améliorer la vitesse de transmission. Basé sur la référence des articles citée ci-dessus, les résultats montrent que le minimum de la durée

  • d’un « 0 » est de 529µs et
  • d’un « 1 » est de 115µs.

Codage Échantillonnage

Ci-dessous le principe retenu pour le codage en fonction de la fréquence d’échantillonnage.

Nous laisserons en plus une marge de 23µs (1/44kHz)
Le tableau ci-dessous donne un aperçu des valeurs retenues jusqu’à une fréquence d’échantillonnage de 44100Hz

Ci-dessous la représentation entre une conversion à 48OOHz, 8000Hz (fast), 11025Hz(fast), 44100Hz(fast)

Format d’un octet

Le format d’un octet enregistré sur la bande magnétique est de la forme suivante

  • 1 bit de Start (« bit 0 » )
  • 8 bits de données inversées LSB-MSB
  • 1 bit de parité
  • 4 bits de stops (3,5 en réalité) (« bit 1″) Comme détaillé plus loin

Nous pouvons calculer la vitesse réelle en mode Fast, si on considère un octet « moyen » composé de 4×0 et de 4×1 ce qui donne:

  • 1 bit de Start (« bit 0 » )
  • 8 bits de données inversées LSB-MSB (4x « bit 0 » + 4x « bit 1 »)
  • 1 bit de parité –> 4×0+4×1 = 4 = pair = 1 (« bit 1 »)
  • 4 bits de stops (« bit 1 »)

C’est à dire : 9x « bits 1 » + 5x « bits 0 »

D’où la durée Moyenne pour transmettre 1 bit, en ramenant cette information au 1/14ième : (14 = 5+9)
Durée moyenne d’un bit : DMb = 1/14 * T * [ (2)*9 + (3)*5 ]
— >Baud Moyen avec Fe=48000 = 2000 bits/s

Dans le détail

Chaque octet du programme à enregistrer est formaté comme suit:

   ------------------------------------------------------------
   | 0 | b0 | b1 | b2 | b3 | b4 | b5 | b6 | b7 | p | 1 | 1 | 1 |
   -------------------------------------------------------------

Chacun de ces bits doit être écrit comme une onde sur bande.

Voici à quoi ressemble un bit «0» lorsqu’il est émis par l’oric en mode lent:

    |-----|     |-----|     |-----|     |-----|
          |-----|     |-----|     |-----|     |-----|

Quatre périodes à 1200 Hz!

Et voici un bit «1»:

    |--|  |--|  |--|  |--|  |--|  |--|  |--|  |--|
       |--|  |--|  |--|  |--|  |--|  |--|  |--|  |--|

huit périodes à 2400 Hz!

Notez que ces deux ondes durent 1/300 s, c’est pourquoi les gens parlent de la vitesse de 300 bauds en mode SLOW.
Maintenant, regardons la sortie en mode FAST.

Un bit «1» est une période de 2400 Hz:

    | - |
        | - |

mais un bit ‘0’ est bizarre

    | - |
        | ----- |

Soit une demi-période de 2400 Hz d’abord, puis une demi-période de 1200 Hz.

La conclusion est que l’oric ne sauvegarde pas et ne charge pas à 2400 bauds en mode FAST: Selon le nombre de 1 et de 0, la vitesse variera entre 1600 et 2400 bauds.

Pourquoi les ingénieurs de Tangerine n’ont pas choisi une vitesse plus rapide, disons 4800 bauds?
Tout simplement pour éviter une atténuation trop important du à la bande passante supportée par la bande audio. Une onde de 2400 Hz est déjà une très haute fréquence pour une bande audio.

Pourquoi à l’époque, Tangerine, n’ont pas choisi une période symétrique de 1600 Hz pour représenter le bit ‘0’ …
Tout simplement pour la réutilisation du code dans la ROM !

La routine de bas niveau détecte uniquement les fronts positifs (transitions de signal de 0 à 1) et le temps écoulé entre deux fronts positifs sert à déterminer si un «  0  » ou un Le bit «1» 

    | - |
        | - | , c'est un 1. S'il est plus long,
    | - |
        | ----- | en mode rapide, ou
    | ----- |
            | ----- | en mode lent (4 fois), c'est un 0.

Une erreur a été commise
Il y a une demi-période supplémentaire après chaque octet et il inverse la sortie de l’octet suivant!
Chaque octet impair est inversé
C’est-à-dire qu’un ‘1’ dans de tels octets est produit comme ceci:

       | - |
   | - |

et un ‘0’ (en mode FAST) comme ceci:

          | - |
  | ----- |

Pour rappel les routines de lecture ne détectent que les bords positifs?
Cela signifie que la routine obtient une entrée décalée.
Ci-dessous, une image montrant les périodes associées aux bits, à la fois lors de l’écriture et de la lecture:

      /------- three stop bits of previous byte
      |      /---- extra half period  /---- parity bit
      |      |   /---- start bit      |        /----- three stop bits
      |      |   |          /- data   |        |      /-- extra half period
  /-------\  |   |    /--------...    |    /-------\  |   |- start bit
| 1 | 1 | 1 | |  0  | 1 |  0  |    |  0  | 1 | 1 | 1 | |  0  |

|-| |-| |-| |-| |---| |-| |---|...   |---| |-| |-| |-| |-|   | ...
  |-| |-| |-| |-|   |-| |-|        |-|   |-| |-| |-| |-| |---|

| 1 | 1 | 1 | 1 |  0  | 1 |  0  |... |  0  | 1 | 1 | 1 |  0  |   =Input

Heureusement que l’entrée est correcte (en oubliant les bits d’arrêt)!
Ce demi-bit supplémentaire écrit se traduit par un bit supplémentaire pour chaque octet impair et disparaît pour chaque octet pair lors de la lecture !!

Tension pour les impulsions

Il ne reste plus qu’à choisir la tension, ou plutôt la valeur numérique pour représenter les tensions.

Application sur motif de synchro

DosBox + Euphoric

Principe

Euphoric est une émulateur de l’ORIC

Sur Ubuntu, il faut installer Dosbox
Pour automatiser le lancement de l’émulation de l’ORIC, trouvez le répertoire qui est caché .dosbox, éditer le fichier /.dosbox/dosbox-0.74
à la fin du fichier rajouter le code

[autoexec]
 Lines in this section will be run at startup.
 You can put your MOUNT lines here.
 keyb fr
 mount c:  /home/.../RPI/Orpic/Euphoric
 c:
 set ORIC=c:\
 euphoric.exe

Lancement Jeux

Les jeux doivent se trouver dans le répertoire tapes
Par la suite, il reste à taper CLOAD »nom du fichier » :

– CLOAD »AIGLE.TAP » ou
– CLOAD »AIGLE » ou 

Published by christian.klugesherz

2 Replies to “ORPIC”

Répondre à christian.klugesherz Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *