Puisqu'il n'y a aucun systeme physique permettant de signaler à la tete de lecture où commence un "NIBBLE" écrit sur la disquette, quand la dite tête de lecture lit un bit, il n'y a absolument aucun moyen de savoir si elle est positionnée au debut d'un octet valide sur la disquette... c'est même rarement le cas. En fait la synchronisation est fondée sur le fait qu'un nibble valide doit obligatoirement commencer par un 1 et jamais un 0, et, qu'en ayant ajouté deux 0 supplémentaires lors de l'écriture des nibbles de synchronisation, la lecture va ainsi "déraper" car on aura écrit des nibbles de synchronisation en 10 bits alors qu'on effectuera la lecture par groupes de 8 bits. En clair (les points sont là uniquement pour faciliter la lecture des bits): un nibble $FF écrit normalement en 32 cycles (4*8) sera représenté sur la disquette par 1111.1111 un nibble $FF écrit en 40 cycles sera représenté sur la disquette par 1111.1111.00 Parce qu'il y a deux zéros supplémentaire ce dernier $FF est dit "de synchronisation", l'explication suit....

	CULTURE GENERALE Wozniak a déclaré dans une interview a Anaheim (californie) le 17 avril 1983 qu'il avait eu l'idée de mettre le bit 7 obligatoirement à 1, pour définir des groupes de données, en s'inspirant du bit de stop utilisé par les liaisons RS232. (source : Jim Sather)

MAIS COMMENT CA MARCHE ? La lecture des bits sur la disquette se fait par groupe de 8. Immanquablement il y aura donc un moment ou certains de ces 0 se trouveront en tête de groupe et ils seront ignorés (car le bit 7 doit OBLIGATOIREMENT être à 1), ce qui permet ainsi de réaliser de synchroniser la lecture sur les valeurs ad hoc par "dérapage" de la lecture. L'explication technique de ce "dérapage" est donnée dans la rubrique"FONCTIONNEMENT DU LOGIC STATE SEQUENCER EN MODE READ" Le DATA REGISTER qui contient le nibble en cours de lecture n'a pas la bonne valeur immédiatement, la lecture est rapide mais cela ne relève pas de la magie non plus : C'est la raison même de l'instruction BPL que l'on trouve dans toutes les routines de lecture, cette instruction permet ainsi d'être sûr que le nibble lu et présent dans le registre de lecture commence bien par un 1. En écrivant un nombre suffisant de ces nibbles de synchronisation, les valeurs cherchées pourront être retrouvées et ce sont les routines de lecture qui vont devoir déterminer ce qu'il faut trouver... de là ces merveilleux systèmes de protection qui écrivent des valeurs non standard pour empêcher la copie. Voici donc la séquence normale de détection des valeurs recherchées :
LOOP	LDA $C08C,X
	BPL LOOP	; tant que le nibble ne commence pas par 1 on boucle
	CMP #$D5	; on fait le test ensuite de ce qui est recherché
	BNE LOOP	; si ce n'est pas $D5 on continue
Nota important : On n'essaye pas de lire les valeurs de synchronisation en tant que telles mais la premiere valeur ad hoc qui se trouve derrière. Supposons que vous cherchiez les valeurs $D5 $AA $96, premiers marqueurs d'un début de champ d'adresse, derrière cinq $FF de synchronisation. Sur votre disque vous aurez la suite FF FF FF FF FF D5 AA 96 etc... Comme les $FF sont des nibbles de synchronisation, ils sont écrits en 40 cycles et donc présentent tous normalement 2 extrabits (les deux zéros de fin), il y a en fait sur la disquette les bits suivants (les points . sont là pour faciliter la lecture des bits par groupe de 4 et localiser les extrabits)

1111.1111.00	1111.1111.00	1111.1111.00	1111.1111.00	1111.1111.00	1101.0100.	1010.1010.	1001.0101.
$FF et.00	$FF et.00	$FF et.00	$FF et.00	$FF et.00	$D5	$AA	$96

Ci dessous on repréesente ce flux de nibbles décomposés en bits. Comme dit plus haut les nibbles de synchronisation sont écrits en 40 cycles c'est pourquoi ils ont toujours les 2 zéros (les extrabits) derrière les 8 bits représentant leur propre valeur qui, pour d'évidentes raisons de simplification sont $FF soit 11111111. Mais attention certaines protections, pour éviter que les programmes de copie "intelligents" (bitcopiers) trouvent le début de piste par détection de ces $FF, mettent d'autres valeurs écrites en 32 cycles, donc sans ces deux extrabits et là le calcul de synchronisation devient un tantinet moins simple. Nota important : Dès que la synchronisation est obtenue, ELLE EST CONSERVEE JUSQU'A LA FIN DE LA LECTURE de l'objet lu (entête d'adresse ou secteur). ELLE N'EST PERDUE QU'EN CAS D'ERREUR DE MAGNETISATION !!! donc si votre disquette est abîmée.... où si vous êtes sur une zone de recouvrement (voir la rubrique "format d'une disquette") EXPLICATION DETAILLEE DE LA SYNCHRONISATION PAR L'EXEMPLE Il n'y a que 10 possibilités pour commencer la lecture Ci dessous vous avez donc le même flux representé 10 fois, et sous chaque flux on montre ce qui se passe au niveau de la lecture selon le premier bit lu par la tete de lecture. La ligne 1 c'est le cas ou la tete tombe immediatement sur le premier bit d'un octet de synchronisation, il va sans dire que la synchronisation est immediate. les étoiles (*) sous les bits indiquent que le mode lecture n'a encore pas commencé.     Quand la lecture commence effectivement, elle se fait :     soit par acceptation ("a" = accepté)     soit par ignorance ("I" = Ignoré) du bit rencontré. En rouge et magenta (les 'a') ce sont les 8 bits lus pour constituer un nibble, En jaune les extrabits qui peuvent être soit acceptés dans un nibble (a), soit ignorés à la lecture (I) quand ils sont en tête de nibble (qui doit toujours commencer par un 1 pour être valide, on ne le dira jamais assez) En vert gras le premier nibble synchronisé, les suivants sont obligatoirement synchronisés Les cas 9 et 10 sont les cas particuliers ou la tête tombe directement sur l'un ou l'autre des extrabits, ce qui revient quasiment au même que de tomber sur le 1er bit d'un nibble valide
CAS 1 (synchronisation immédiate)
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
a a a a a a a a I I Les deux 0 sont ignorés car un nibble doit commencer par 1...
Les nibbles valides lus sont les suivants :
	le 1er     1111 1111 =$FF le 2ème 1111 1111 =$FF et nous sommes synchronisés
CAS 2
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* a a a a a a a a I Le zéro est ignoré car un nibble doit commencer par 1... puis c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1111 1110 =$FE le 2ème 1111 1111 =$FF et nous sommes synchronisés
Comparez les cas 1 et 2 pour bien comprendre que les extrabits (dits de synchronisation) sont bien là pour être soit absorbés dans un nibble soit pour être ignorés. L'objectif recherché est d'avoir suffisament de nibbles avec ces zeros finaux pour faire "déraper" la lecture de telle façon que l'on soit obligatoirement synchronisé après un certain temps, qui dépendra de l'endroit où la tête de lecture commence à effectivement lire les transitions magnétiques de la disquette
CAS 3
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * a a a a a a a a Les deux extrabits ont été absorbés dans le nibble lu et maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1111 1100 =$FC le 2ème 1111 1111 =$FF et nous sommes synchronisés
Il est également important de comprendre que le programme de lecture n'essaye PAS de lire la valeur des nibbles de synchronisation mais RECHERCHE UNIQUEMENT UN NIBBLE VALIDE SPECIFIQUE dont il connaît la valeur, par exemple $D5 pour le premier nibble d'un champ adresse. Dans le cas présent la tête de lecture ne s'est pas posée au début du $FF qui a été écrit avec ses deux extrabits et pourtant on est synchronisé immédiatement comme si elle s'était posée au début du dit $FF !
CAS 4
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * a a a a a a a a a a a a a a a a I Maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1111 1001 =$F9 le 2ème 1111 1110 =$FE, le 3ème 1111 1111 =$FF et nous sommes synchronisés
CAS 5
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * a a a a a a a a a a a a a a a a Maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1111 0011 =$F3 le 2ème 1111 1100 =$FC, le 3ème 1111 1111 =$FF et nous sommes synchronisés
CAS 6
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * * a a a a a a a a a a a a a a a a a a a a a a a a I Maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1110.0111 =$E7 le 2ème 1111 1001 =$F9 , le 3ème 1111 1110 =$FE , le 4ème 1111 1111 =$FF et nous sommes synchronisés
CAS 7
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * * * a a a a a a a a a a a a a a a a a a a a a a a a Maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1100.1111 =$CF le 2ème 1111 0011 =$F3 , le 3ème 1111 1100 =$FC , le 4ème 1111 1111 =$FF et nous sommes synchronisés
CAS 8
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * * * * a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a a I Maintenant c'est Synchronisé
Les nibbles valides lus sont les suivants :
	le 1er     1001.1111 =$9F le 2ème 1110 0111 =$E7 , le 3ème 1111 1001 =$F9 , le 4ème 1111 1110 =$FE , le 5ème 1111 1111 =$FF et nous sommes synchronisés
CAS 9 (synchronisation quasi immédiate)
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * * * * * I I Maintenant c'est Synchronisé
Dans ce cas particulier (et le suivant) la tête de lecture ne détecte en fait rien car elle est "tombée" dans la zone des extrabits, qui sont donc ignorés purement et simplement. La synchronisation est quasi immédiate en ce sens que le premier nibble valide sera celui qui se trouve juste derrière ces deux extrabits, un bon gros $FF bien normal.
CAS 10 (synchronisation quasi immédiate)
1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 0 0
* * * * * * * * * I Maintenant c'est Synchronisé
Vous comprennez maintenant pourquoi il faut au minimum 4 $FF de synchronisation (cf. cas 8) avant d'écrire un marker d'entête, que ce soit du champ adresse ou du champ de données.(si l'on exclut le cas particulier des schémas de protection qui peuvent en mettre plus avec moins d'extrabits.) Vous allez sans doute vous dire "oui mais si la lecture commence ailleurs que sur les octets de synchronisation ? Comme dirait le cerveau de Baker Street "Elémentaire mon cher Watson, on ne peut pas se synchroniser tant que l'on ne passe pas sur ces fameux nibbles de synchronisation! Les marqueurs d'adresse ont d'ailleurs des valeurs dont la combinaison NE PEUT PAS se retrouver dans les données enregistrées dans chaque secteur, ce qui évite des tentatives de lecture quasi-infinies" !
Ce à quoi ce même cerveau fécond ajouterait "mais c'est d'ailleurs une astuce utilisée par certains schémas de protection que de modifier ces octets de synchronisation et le nombre d'extrabits..."			Cela donne des systèmes de protection très efficaces contre la copie, d'autant que l'on peut le faire avec des formats tout à fait normaux... et cela déroute tous les newbies qui se lancent dans le piratage