srec_examples - En ligne dans le Cloud

PROGRAMME:

Nom

srec_examples - exemples d'utilisation de SRecord

DESCRIPTION

Le site de srec_cat la commande est très puissante, en raison de la possibilité de combiner les filtres d'entrée
de manière presque illimitée. Cette page de manuel en décrit quelques-uns.

Cette page de manuel décrit comment utiliser les différents fichiers d'entrée, filtres d'entrée et
générateurs. Mais ce ne sont que des exemples, pour plus de détails, voir le entrée_srec(1)
page de manuel.

Le site de Commandes Lignés Emplacements Aussi Long
Si vous êtes bloqué sur un système d'exploitation avec des limites de longueur de ligne de commande absurdement courtes,
certaines des commandes qui suivent peuvent être trop longues. Vous pouvez contourner ce handicap en
placer votre ligne de commande dans un fichier, disons fred.txt, puis dire srec_cat(1) pour lire ceci
fichier pour le reste de sa ligne de commande, comme ceci

srec_cat @fred.txt

Cela a aussi l'avantage de permettre des commentaires, vous permettant d'écrire votre ligne de commande
options sur plusieurs lignes, et même en retrait pour rendre la commande plus claire. commentaires
commencer à un "#» et s'étendre jusqu'à la fin de la ligne. Les lignes vides sont ignorées.

Bien sûr, vous pouvez toujours passer à Linux, qui est de moins en moins nul depuis plus de 27 ans.
ans maintenant.

Votre Exemples recherché
Si vous avez une manière intelligente d'utiliser SRecord, ou si vous avez résolu un problème difficile avec
SRecord, vous pouvez contribuer à cette page de manuel, la rendant plus utile pour tout le monde.
Envoyez votre exemple par e-mail à l'adresse e-mail à la fin de cette page de manuel.

CONVERSION DOSSIER FORMATS

La plus simple des choses srec_cat(1) peut faire est de convertir d'un format de fichier EPROM en
un autre. Veuillez garder à l'esprit, pendant que vous lisez cette section, que vous pouvez faire plusieurs de ces
les choses simultanément dans une seule commande. Ils sont seulement éclatés séparément pour les rendre
plus facile à comprendre.

Intel à Motorola
L'un des exemples les plus simples est la conversion de fichiers du format hexadécimal Intel en Motorola S‐
Format d'enregistrement :

srec_cat fichier intel -intel-o fichier srec

Notez que le spécificateur de format suit immédiatement le nom du fichier qu'il décrit.
Choisissez deux formats que SRecord comprend et il peut convertir entre eux.
(Sauf les sorties assembleur, BASIC, C et FPGA qui sont en écriture seule.)

Motorola à Intel
La conversion dans l'autre sens est tout aussi simple :

srec_cat fichier srec -o fichier intel -informations

Le format par défaut est le format Motorola S‐Record, il n'a donc pas besoin d'être spécifié après
le nom du fichier.

Différents Formes of le Béton Format
Il est malheureusement courant que certains programmeurs d'EPROM compliqués n'implémentent qu'une partie
de la spécification utilisée pour représenter leurs fichiers hexadécimaux. Par exemple, certains compilateurs
produire des données Motorola « s19 » (c'est-à-dire des enregistrements de données S1 avec des enregistrements de démarrage S9, 16 bits
champs d'adresse) ce qui serait bien sauf que certains programmeurs d'EPROM idiots insistent sur
Données Motorola « s37 » (c'est-à-dire enregistrements de données S3 avec enregistrements de démarrage S7, adresse 32 bits
des champs).

Il est possible de passer d'une forme Motorola à une autre en utilisant le -Longueur d'adresse
option:

srec_cat short.srec -o long.srec -address‐length=4

Cette commande dit d'utiliser des adresses de quatre octets (32 bits) en sortie.

Cette section s'applique également aux fichiers hexadécimaux Intel, car ils ont également la possibilité de sélectionner
à partir d'une variété de largeurs d'adresse. Pour convertir d'une forme Intel à une autre en utilisant le
même -Longueur d'adresse option:

srec_cat i32.hex -o i16.hex -address‐length=3

Cette commande dit d'utiliser des adresses segmentées de 16 bits « i20hex » en sortie. Une longueur d'adresse
de 4 est la valeur par défaut ("i32hex" adressage linéaire 32 bits), et une longueur d'adresse de 2 serait
demande d'adressage « i8hex » 16 bits.

Line Des longueurs
De temps en temps, vous rencontrerez un programmeur d'EPROM faible d'esprit qui ne peut pas faire face
avec de longues lignes de texte, ils supposent qu'il n'y aura jamais que 46 caractères par ligne et
barf quand ils voient les longueurs de ligne par défaut qui srec_cat(1) écrit (ou pire, obtenez une pile
gribouillage et crash).

La définition du format Motorola S-record autorise jusqu'à 255 octets de charge utile, ou lignes de
514 caractères, plus la fin de ligne. Tous les programmeurs EPROM devrait avoir suffisamment
grands tampons de ligne pour faire face à des enregistrements de cette taille. Peu le font.

L'option -line‐length peut être utilisée pour spécifier la longueur de ligne maximale (sans compter le
newline) à utiliser en sortie. Par exemple, des charges utiles de 16 octets pour Motorola hexadécimal

srec_cat long.srec -o short.s19 -line‐length=46

L'option de longueur de ligne interagit avec l'option de longueur d'adresse, donc un peu de bricolage pour
optimiser pour votre situation particulière de nombreux être nécessaires.

Sortie Bloquer Taille
De temps en temps, vous rencontrerez un ancien programmeur d'EPROM stupide qui ne peut pas
faire face à de longs enregistrements de données, ils supposent qu'il n'y aura jamais au plus 16 octets de
données par enregistrement, et barf lorsqu'ils voient les charges utiles de 32 octets par défaut qui srec_cat(1)
écrit (ou pire, le dépassement de la mémoire tampon provoque une promenade dans les hautes herbes qui gribouille sur votre
EPROM).

La définition du format hexadécimal Intel autorise jusqu'à 255 octets de données utiles par enregistrement. Tous
Programmeurs EPROM devrait disposer de tampons de données suffisamment grands pour gérer les enregistrements
gros. Bonne chance avec ça.

L'option -Output-Block-Size peut être utilisée pour spécifier la taille des données d'enregistrement à utiliser sur
sortir. Par exemple, Intel hex avec des charges utiles de 16 octets :

srec_cat long.srec -o short.hex -intel -obs=16

Attention à ne pas mettre le -obs option entre le nom du fichier de sortie et le format
spécificateur.

Just le Les données, Veuillez
Certains programmeurs d'EPROM bonehead ne peuvent gérer que les enregistrements de données et sont
incapable de gérer les enregistrements d'en-tête ou les enregistrements d'adresse de début d'exécution. Si tu as ça
problème, le -données uniquement L'option peut être utilisée pour supprimer à peu près tout sauf le
Les données. L'effet réel dépend du format, bien sûr, car certains n'ont pas ces
fonctionnalités de toute façon.

Le site de -données uniquement l'option est la main courte. Il y a quatre propriétés qui peuvent être -désactivé or
-enabled séparément. Voir le srec_cat(1) page de manuel pour une description du -désactivé et
-enabled options.

Par exemple, votre programmeur d'EPROM néandertal nécessite un hexadécimal Motorola avec des enregistrements d'en-tête
(S0), mais sans enregistrements de comptage de données (S5). Ne pas utiliser le -données uniquement l'option l'a vomit dessus
l'enregistrement de comptage de données, mais en utilisant le -données uniquement l'option l'a barf sur l'en-tête manquant
enregistrer. En utilisant le -disable=compte de données l'option laisserait l'enregistrement d'en-tête intact pendant que
suppression de l'enregistrement de comptage de données.

Date En-têtes
Le site de srec_cat(1) la commande essaie toujours de passer les enregistrements d'en-tête inchangés, chaque fois que
ils sont présents. Il essaie même de les préserver à travers les changements de format de fichier, à la limite
les formats de fichiers sont capables de.

S'il n'y a pas d'enregistrement d'en-tête de fichier et que vous souhaitez en ajouter un, ou si vous souhaitez écraser
un enregistrement d'en-tête de fichier existant, utilisez le -entête=un magnifique option. Vous devrez citer le
chaîne (pour l'isoler du shell) si elle contient des espaces ou des méta‐caractères du shell.

Internationaux Start Adresses
Le site de srec_cat(1) la commande essaie toujours de passer par les adresses de début d'exécution (généralement
apparaissant à la fin du fichier), lorsqu'ils sont présents. Ils sont ajustés le long
avec les enregistrements de données par le -décalage filtre. Il essaie même de les conserver dans tous les fichiers
changements de format, dans la limite des capacités des formats de fichiers.

S'il n'y a pas d'enregistrement d'adresse de début d'exécution et que vous souhaitez en ajouter un, ou si vous souhaitez
pour remplacer un enregistrement d'adresse de début d'exécution existant, utilisez le -exécution‐début‐
propos=nombre option.

Veuillez noter : l'adresse de début d'exécution est un concept différent de la première adresse dans
mémoire de vos données. Considérez-le comme une adresse « goto » à laquelle le moniteur doit accéder lorsque
la charge hexagonale est terminée. Si vous souhaitez modifier l'emplacement de départ de vos données en mémoire, utilisez le
-décalage filtre.

Fixation Sommes de contrôle
Certains développeurs de micrologiciels embarqués sont aux prises avec des outils farfelus qui produisent
des sommes de contrôle incorrectes, que les modèles les plus vigilants du programmeur EPROM n'accepteront pas.

Pour corriger les sommes de contrôle sur un fichier, utilisez le -ignorer les sommes de contrôle option. Par exemple:

srec_cat broken.srec -ignore-checksums -o fixed.srec

Les sommes de contrôle dans cassé.srec sont analysés (c'est encore et erreur s'ils sont absents) mais sont
pas vérifié. La résultante fix.srec le fichier a des sommes de contrôle correctes. Les -ignorer les sommes de contrôle
L'option ne s'applique qu'à l'entrée.

Cette option peut être utilisée sur n'importe quel format de fichier qui a des sommes de contrôle, y compris Intel hex.

Découverte Mystère Formats
Voir le Organisateur Ce que Format Is Cette? section ci-dessous pour savoir comment découvrir et convertir une EPROM mystère
charger les formats de fichiers.

BINARY DES DOSSIERS

Il est possible de convertir vers et à partir de fichiers binaires. Vous pouvez même mélanger des fichiers binaires et
d'autres formats ensemble dans le même srec_cat(1) commande.

Écriture binaire Documents officiels
La façon la plus simple de lire un fichier hexadécimal et de le convertir en fichier binaire ressemble à ceci :

srec_cat fred.hex -o fred.bin -binaire

Cela lit le fichier hexadécimal Motorola fred.srec et l'écrit au fred.bin comme cru
binaire.

Notez que les données sont placées dans le fichier binaire à l'offset d'octet spécifié par le
adresses dans le fichier hexadécimal. S'il y a des trous dans les données, ils sont remplis de zéro.
Ceci est, bien sûr, commun avec la sortie de l'éditeur de liens où le code est placé à partir d'un
place particulière dans la mémoire. Par exemple, lorsque vous avez une image qui commence à 0x100000,
le premier 1 Mo du fichier binaire de sortie sera égal à zéro.

Vous pouvez annuler automatiquement ce décalage à l'aide d'une commande comme

srec_cat fred.hex -offset − -adresse_minimale fred.hex -o fred.bin

La commande ci-dessus fonctionne en décalant le fred.hex fichier inférieur en mémoire par le moins
adresse dans le fred.hex les données du fichier.

Voir aussi srec_binaire(5) page de manuel pour plus de détails.

en cours binaire Documents officiels
La façon la plus simple de lire un fichier binaire et de le convertir ressemble à ceci

srec_cat fred.bin -binaire -o fred.srec

Cela lit le fichier binaire fred.bin et réécrit toutes ses données en tant que
Fichier Motorola S‐Record.

Souvent, ce binaire n'est pas exactement là où vous le voulez dans l'espace d'adressage, car il est
supposé résider à l'adresse zéro. Si vous devez le déplacer, utilisez le -décalage filtre.

srec_cat fred.bin -binary -offset 0x10000 -o fred.srec

Vous devez également éviter les « trous » de fichier qui sont remplis de zéro. Vous pouvez utiliser le -recadrer
filtre, vous pouvez utiliser le -vider filtrer si vous ne savez pas exactement où se trouvent les données.

srec_cat fred.bin -binary -unfill 0x00 512 -o fred.srec

La commande ci-dessus supprime les exécutions de zéro octet de 512 octets ou plus. Si votre
le fichier contient 1 Go d'octets zéro de début, cela va être lent, il peut être préférable d'utiliser
le dd(1) commande de trancher et de dés en premier.

ASSEMBLAGE DES DOSSIERS ENSEMBLE

Le site de srec_cat commande tire son nom de l'UNIX cat(1) commande, qui est l'abréviation de
« caténer » ou « adhérer ». Les srec_cat La commande joint les fichiers de chargement EPROM ensemble.

Tous In UN
Joindre des fichiers de chargement EPROM ensemble dans un seul fichier est simple, il suffit de nommer autant de fichiers sur
la ligne de commande selon vos besoins :

srec_cat fichier d'entrée1 fichier d'entrée2 -o fichier de sortie

Cet exemple concerne tous les fichiers Motorola S‐Record, car c'est le format par défaut. Vous pouvez
avoir plusieurs formats dans une seule commande, et srec_cat(1) fonctionnera toujours. Tu n'as même pas
doivent sortir le même format:

srec_cat fichier d'entrée1 -spectre fichier d'entrée2 -Needham
-o fichier de sortie -signétique

Ce sont tous des formats anciens, mais il n'est pas rare de devoir mélanger et assortir Intel
et Motorola dans un même projet.

Filtration Après Joindre
Il arrive parfois que vous souhaitiez joindre deux ensembles de données, puis appliquer un filtre
au résultat joint. Pour ce faire, vous utilisez des parenthèses.

srec_cat
'('
dans le fichier -exclure 0xFFF0 0x10000
-générer 0xFFF0 0xFFF8 -répéter la chaîne 'Bananas'
')'
-b-e-longueur 0xFFF8 4
-b-e-checksum-neg 0xFFFC 4 4
-o fichier de sortie

L'exemple de commande ci-dessus catalyse un fichier d'entrée (avec la zone de données générée exclue)
avec une chaîne constante. Cette entrée caténée est ensuite filtrée pour ajouter une longueur de 4 octets, et
une somme de contrôle de 4 octets.

Joindre De bout en bout
Trop souvent, les plages d'adresses dans les fichiers de chargement EPROM se chevauchent. Vous obtiendrez un
erreur s'ils le font. Si les deux fichiers commencent à partir de l'adresse zéro, car chacun va dans un
EPROM séparée, vous devrez peut-être utiliser le filtre offset :

srec_cat fichier d'entrée1
fichier d'entrée2 -décalage 0x80000
-o fichier de sortie

Parfois, vous voulez que les deux fichiers se suivent exactement, mais vous ne connaissez pas le
compenser à l'avance:

srec_cat fichier d'entrée1
fichier d'entrée2 -offset -maximum-addr fichier d'entrée1
-o fichier de sortie

Notez que là où était un nombre (0x80000) auparavant, il y a maintenant un calcul (-maximum‐
addr fichier d'entrée1). C'est possible la plupart des endroits où un nombre peut être utilisé (aussi -minimum‐addr et
-gamme).

CULTURE THE DONNEES

Il est possible de copier un fichier de chargement EPROM, en sélectionnant les adresses à conserver et les adresses à
Jeter.

Organisateur Ce que À Rester
Une activité courante consiste à recadrer vos données pour qu'elles correspondent à l'emplacement de votre EPROM. Votre éditeur de liens peut ajouter
d'autres déchets qui ne vous intéressent pas, par exemple à l'emplacement de la RAM. Dans cet exemple,
il y a une EPROM de 1 Mo à la limite des 2 Mo :

srec_cat dans le fichier -recadrer 0x200000 0x300000
-o fichier de sortie

La limite inférieure pour toutes les plages d'adresses est inclusive, la limite supérieure est exclusive. Si tu
soustrayez-les, vous obtenez le nombre d'octets.

Adresse Décalage
Il se peut que vous ayez un programmeur d'EPROM idiot, et il vomit si l'image EPROM
ne démarre pas à zéro. Pour savoir où est ne démarrer en mémoire, utilisez le
srec_info(1) commande :

$ srec_info exemple.srec
Format : Motorola S‐Record
En-tête : lien de chaîne d'outils extra‐whizz
Adresse de début d'exécution : 0x00200000
Données : 0x200000 - 0x32AAEF
$

Plutôt que de boucher le fichier de commandes de l'éditeur de liens, décalez simplement les adresses :

srec_cat dans le fichier -recadrer 0x200000 0x300000 -offset −0x200000
-o fichier de sortie

Notez que le décalage donné est négatif, il a pour effet de soustraire cette valeur de
toutes les adresses dans les enregistrements d'entrée, pour former les adresses d'enregistrement de sortie. Dans ce cas,
remettre l'image à zéro.

Cet exemple montre également comment les filtres d'entrée peuvent être enchaînés : d'abord le
recadrer puis le décalage, le tout en une seule commande, sans avoir besoin de fichiers temporaires.

Si tout ce que vous voulez faire est de décaler les données pour commencer à partir de l'adresse zéro, cela peut être
automatisé, vous n'avez donc pas besoin de connaître l'adresse minimale à l'avance, en utilisant srec_cat's
possibilité de calculer certaines choses sur la ligne de commande :

srec_cat dans le fichier -offset − -minimum-addr dans le fichier
-o fichier de sortie

Notez les espaces de part et d'autre du signe moins, ils sont obligatoires.

Organisateur Ce que À Jeter Extérieur
Il y a des moments où vous devez exclure une petite plage d'adresses d'un fichier de chargement EPROM,
plutôt que de vouloir conserver une petite plage d'adresses. Les -exclure le filtre peut être utilisé pour
Cet objectif.

Par exemple, si vous souhaitez exclure la plage d'adresses où le numéro de série d'un
le périphérique intégré est conservé, disons 0x20 octets à 0x100, vous utiliseriez une commande comme celle-ci :

srec_cat entrée.srec -exclude 0x100 0x120 -o sortie.srec

Le site de sortie.srec fichier aura un trou dans les données aux emplacements nécessaires.

Notez que vous pouvez avoir les deux -recadrer et -exclure sur la même ligne de commande, selon ce qui fonctionne
plus naturellement à votre situation.

Discontinu Adresse Pianos de cuisine
Les plages d'adresses ne doivent pas nécessairement être une seule plage, vous pouvez créer une plage d'adresses en utilisant
plus d'une seule paire.

srec_cat dans le fichier -recadrer 0x100 0x200 0x1000 0x1200
-o fichier de sortie

Ce filtre génère des données de 0x100..0x1FF et des données de 0x1000..0x1200 à transmettre
à travers, le reste est abandonné. C'est plus efficace que d'enchaîner un -recadrer et le
-exclure filtrer ensemble.

EN MOUVEMENT DES CHOSES AROUND

Il est également possible de modifier l'adresse des enregistrements de données, à la fois en avant et en arrière.
Il est également possible de réorganiser l'emplacement des enregistrements de données en mémoire.

Décalage Filtre
Le site de -décalage=nombre le filtre opère sur les adresses des enregistrements. Si le nombre est positif
les adresses se déplacent de plusieurs octets plus haut dans la mémoire, les valeurs négatives se déplacent vers le bas.

srec_cat dans le fichier -recadrer 0x200000 0x300000 -offset −0x200000
-o fichier de sortie

L'exemple ci-dessus déplace le bloc de données de 1 Mo à 0x200000 vers zéro (le décalage est
négatif) et supprime le reste des données.

Octet Swapping
Il y a des moments où les octets des données doivent être échangés, en convertissant entre gros
données endian et little-endian généralement.

srec_cat dans le fichier -échange d'octets 4 -o fichier de sortie

Cela inverse les octets en valeurs de 32 bits (4 octets). La valeur par défaut, si vous ne fournissez pas de largeur,
consiste à inverser les octets en valeurs de 16 bits (2 octets). Vous pouvez réellement utiliser n'importe quelle valeur étrange que vous
comme, il n'a même pas besoin d'être une puissance de 2. Peut-être que 64 bits (8 octets) peuvent être utiles
un jour.

binaire Sortie
Vous devez faire attention aux fichiers binaires en sortie, car les trous sont remplis de zéros.
Votre programme de 100 Ko au sommet de la mémoire adressée 32 bits créera un fichier de 4 Go. Voir
srec_binaire(5) pour savoir comment comprendre et éviter ce problème, généralement avec le -décalage filtre.

Scission an Image(s)
Si vous disposez d'un bus de données 16 bits, mais que vous utilisez deux EPROM 8 bits pour stocker votre firmware,
vous pouvez générer les images paires et impaires en utilisant le -Diviser filtre. En supposant que votre
le firmware est dans le firmware.hex fichier, utilisez ce qui suit :

srec_cat firmware.hex -split 2 0 -o firmware.even.hex
srec_cat firmware.hex -split 2 1 -o firmware.odd.hex

Cela donnera les deux images EPROM nécessaires. Notez que les adresses de sortie sont
divisé par le multiple divisé, donc si vos images EPROM sont à un décalage particulier (disons
0x10000, dans l'exemple suivant), vous devez supprimer le décalage, puis le remplacer...

srec_cat firmware.hex
-offset −0x10000 -split 2 0
-offset 0x10000 -o firmware.even.hex
srec_cat firmware.hex
-offset −0x10000 -split 2 1
-offset 0x10000 -o firmware.odd.hex

Notez comment la possibilité d'appliquer plusieurs filtres simplifie ce qui serait autrement beaucoup
scénario plus long.

Rayure
Une seconde utilisation pour le -Diviser le filtre est l'entrelacement de la mémoire.

Vous n'êtes pas obligé de diviser en parties d'un octet, vous pouvez choisir d'autres tailles. Il est courant de
voulez convertir des données larges de 32 bits en deux ensembles de données larges de 16 bits.

srec_cat firmware.hex -split 4 0 2 -o firmware.01.hex
srec_cat firmware.hex -split 4 2 2 -o firmware.23.hex

C'est relativement simple à comprendre, mais vous pouvez utiliser des rayures encore plus larges.

Dans cet exemple suivant, le matériel requiert que les blocs de 512 octets alternent entre 4
EPROM. La génération des 4 images se ferait comme suit :

srec_cat firmware.hex -split 0x800 0x000 0x200 -o firmware.0.hex
srec_cat firmware.hex -split 0x800 0x200 0x200 -o firmware.1.hex
srec_cat firmware.hex -split 0x800 0x400 0x200 -o firmware.2.hex
srec_cat firmware.hex -split 0x800 0x600 0x200 -o firmware.3.hex

Asymétrique Rayure
Un exemple plus particulier de striping est le microcontrôleur Microchip dsPIC33F, qui a un
modèle de stockage de mémoire étrange et ils sont capables de stocker 3 octets dans une adresse qui devrait
ne contiennent que 2 octets. Le résultat est un fichier hexadécimal qui a rempli de zéro l'octet supérieur (petit
endian), et toutes les adresses sont doublées par rapport à ce qu'elles sont dans la puce. Voici un
Exemple:

S1130000000102000405060008090A000C0D0E0098
S1130010101112001415160018191A001C1D1E00C8
S1130020202122002425260028292A002C2D2E00F8
S1130030303132003435360038393A003C3D3E0028

Pour se débarrasser des 00 octets de remplissage, en ne laissant que les 3/4 octets significatifs, vous utilisez également
le filtre divisé, avec son largeur argument, comme ceci :

srec_cat exemple.srec -split 4 0 3 -o no_dross.srec

Il en résulte un fichier avec les 00 octets de remplissage supprimés. Cela ressemble à ceci :

S113000000010204050608090A0C0D0E1011121451
S1130010151618191A1C1D1E2021222425262829EC
S11300202A2C2D2E30313234353638393A3C3D3E87

Remarquez que les adresses font également 3/4 de la taille. Vous pouvez inverser cela en utilisant le
-non divisé et -remplir=0 filtres

Unsplit Images
Le filtre non divisé peut être utilisé pour inverser les effets du filtre divisé. Notez que le
la plage d'adresses est étendue en laissant des trous entre les bandes. En utilisant toutes les rayures,
l'entrée complète est remontée, sans aucun trou.

srec_cat -o firmware.hex
firmware.even.hex -unsplit 2 0
firmware.odd.hex -unsplit 2 1

L'exemple ci-dessus inverse l'exemple précédent de bus de données 16 bits. En général, vous unsplit
avec les mêmes paramètres avec lesquels vous vous séparez.

REMPLISSAGE THE BLANCS

Souvent, les fichiers de chargement d'EPROM contiennent des "trous", des endroits où le compilateur et l'éditeur de liens ont fait
ne rien mettre. À certaines fins, c'est OK, et à d'autres fins, quelque chose doit
être fait sur les trous.

Le site de Niveau de remplissage Filtre
Il est possible de remplir les blancs là où vos données ne se trouvent pas. L'exemple le plus simple de
cela remplit toute l'EPROM :

srec_cat dans le fichier -remplir 0x00 0x200000 0x300000 -o fichier de sortie

Cet exemple remplit les trous, le cas échéant, avec des zéros. Vous devez spécifier une plage - avec un
Espace d'adressage 32 bits, le remplissage de tout génère majeur charger des fichiers.

Si vous souhaitez uniquement combler les lacunes de vos données, et ne souhaitez pas remplir l'intégralité de l'EPROM,
Essai:

srec_cat dans le fichier -remplir 0x00 -over dans le fichier -o fichier de sortie

Cet exemple démontre le fait que partout où une plage d'adresses peut être spécifiée, le
-plus de et -dans des options peuvent être utilisées.

Remplissage le Blanks
Il est courant de devoir "décharger" une image EPROM après l'avoir lue à partir d'une puce. D'habitude,
il aura eu tous les trous remplis de 0xFF (les zones de l'EPROM que vous ne programmez pas montrent
comme 0xFF lorsque vous les relisez).

Pour supprimer tous les octets 0xFF des données, utilisez ce filtre :

srec_cat dans le fichier -décharger 0xFF -o fichier de sortie

Cela éliminera tous les octets 0xFF, y compris ceux que vous vouliez réellement y inclure.
Il y a deux façons de traiter cela. Tout d'abord, vous pouvez spécifier une longueur d'exécution minimale au
dé-remplir :

srec_cat dans le fichier -unfill 0xFF 5 -o fichier de sortie

Cela dit que les exécutions de 1 à 4 octets de 0xFF sont OK, et qu'un trou ne doit être créé
pour les exécutions de 5 octets 0xFF ou plus d'affilée. La deuxième méthode consiste à remplir à nouveau le
écarts intermédiaires :

srec_cat fichier de sortie -remplir 0xFF -over fichier de sortie
-o fichier de sortie2

La méthode que vous choisissez dépend de vos besoins et de la forme des données dans votre EPROM.
Vous devrez peut-être combiner les deux techniques.

Adresse Autonomie Rembourrage
Certains formats de données ont une largeur de 16 bits et se remplissent automatiquement avec des octets 0xFF s'il est
nécessaire de remplir l'autre moitié d'un mot qui n'est pas dans les données. Si tu as besoin de
remplir avec une valeur différente, vous pouvez utiliser une commande comme celle-ci :

srec_cat dans le fichier -remplir 0x0A
-dans dans le fichier -range-remplissage 2
-o fichier de sortie

Cela donne au filtre de remplissage une plage d'adresses calculée à partir des détails du fichier d'entrée.
La plage d'adresses est l'ensemble des plages d'adresses couvertes par les données dans le dans le fichier, élargi
vers le bas (si nécessaire) au début de chaque sous‐plage à un multiple de 2 octets et étendu
vers le haut (si nécessaire) à la fin de chaque sous‐plage à un multiple de 2 octets. ça marche aussi
pour les multiples plus grands, comme les limites de page de 1 Ko de puces flash. Ce remplissage de plage d'adresses
fonctionne partout où une plage d'adresses est requise.

Niveau de remplissage avec DROITS D'AUTEUR
Il est possible de remplir des portions inutilisées de votre EPROM avec un message de copyright répétitif.
Quiconque essaie de rétroconcevoir vos EPROMs verra l'avis de droit d'auteur dans
leur éditeur hexadécimal.

Ceci est accompli avec deux sources d'entrée, l'une à partir d'un fichier de données et l'autre qui est
généré à la volée.

srec_cat dans le fichier
-générer '(' 0 0x100000 -moins -à l'intérieur dans le fichier ')'
-chaîne de répétition 'Copyright (C) 1812 Tchaïkovski. '
-o fichier de sortie

Remarquez la plage d'adresses pour la génération des données : elle prend la plage d'adresses de votre
EPROM, ici 1Mo à partir de 0, et en soustrait les plages d'adresses utilisées par
le fichier d'entrée.

Si vous voulez le scripter avec l'année en cours (car 1812 est un peu obsolète), utilisez
la capacité de substitution de sortie du shell (ticks arrière) :

srec_cat dans le fichier
-générer '(' 0 0x100000 -moins -à l'intérieur dans le fichier ')'
-repeat-string "Copyright (C) `date +%Y` Tchaïkovski. "
-o fichier de sortie

La chaîne spécifiée est répétée encore et encore, jusqu'à ce qu'elle ait rempli tous les trous.

obscurcissant avec Bruit
Parfois, vous voulez remplir vos images EPROM de bruit, pour cacher où les données réelles
s'arrête et démarre. Vous pouvez le faire avec le -remplissage aléatoire filtre.

srec_cat dans le fichier -remplissage aléatoire 0x200000 0x300000
-o fichier de sortie

Cela fonctionne exactement comme le -remplir filtre, mais utilise des nombres aléatoires au lieu d'un octet constant
valeur.

Niveau de remplissage et 16 bits Paroles
Lorsque le remplissage de l'image avec une valeur d'octet constante ne fonctionne pas et que vous avez besoin d'une constante
valeur de mot de 16 bits à la place, utilisez le -répéter les données générateur, qui prend un temps arbitrairement long
séquence d'octets à utiliser comme motif de remplissage :

srec_cat dans le fichier
-générateur '(' 0x200000 0x300000 -moins -à l'intérieur dans le fichier ')'
-répéter les données 0x1B 0x08
-o fichier de sortie

Remarquez comment la plage d'adresses du générateur évite à nouveau les plages d'adresses occupées par
le dans le fichierles données de. Vous devez vous-même obtenir le bon endian.

INSERTION CONSTANTE DONNEES

De temps en temps, vous voudrez insérer des données constantes ou des données non produites par votre
compilateur ou assembleur, dans vos images de chargement EPROM.

binaire Veux dire Littéral
Un moyen simple est d'avoir les informations souhaitées dans un fichier. Pour insérer le fichier
contenu littéralement, sans interprétation de format, utilisez le binaire format d'entrée :

srec_cat dans le fichier -binaire -o fichier de sortie

Il sera probablement nécessaire d'utiliser un compenser filtre pour déplacer les données là où vous
le veux réellement dans l'image:

srec_cat dans le fichier -binaire -décalage 0x1234 -o fichier de sortie

Il est également possible d'utiliser l'entrée standard comme source de données, ce qui se prête à
étant scénarisé. Par exemple, pour insérer la date et l'heure actuelles dans un fichier de chargement EPROM,
tu peux utiliser un tuyau :

rendez-vous | srec_cat - -bin -offset 0xFFE3 -o fichier de sortie

Le nom de fichier spécial « - » signifie lire à partir de l'entrée standard. La sortie du données
La commande comporte toujours 29 caractères et le décalage affiché la placera en haut d'un
Image EPROM de 64 Ko.

Répéter Une fois
Le site de Niveau de remplissage avec DROITS D'AUTEUR La section ci-dessus montre comment répéter une chaîne encore et encore. Nous
peut utiliser une seule répétition pour insérer une chaîne une seule fois.

srec_cat -generate 0xFFE3 0x10000 -repeat-string "`date`"
-o fichier de sortie

Remarquez comment la plage d'adresses pour la génération de données correspond exactement à la longueur du
données(1) taille de sortie. Vous pouvez, bien sûr, ajouter votre fichier d'entrée à ce qui précède srec_cat(1)
commande pour catégoriser votre image EPROM avec la date et l'heure.

Insertion A Long
Une autre possibilité est d'ajouter le numéro de commit Subversion à votre image EPROM. Dans ce
Par exemple, nous l'insérons dans une valeur little-endian de 4 octets à l'adresse 0x0008. Les
Le numéro de commit de Subversion est dans le $ version variable shell dans cet exemple :

srec_cat -generate 0x0008 0x000C -l-e-constant $version 4
dans le fichier -exclure 0x0008 0x000C
-o fichier de sortie

Notez que nous utilisons un filtre pour nous assurer qu'il y a un trou dans l'entrée où le numéro de version
va, juste au cas où l'éditeur de liens y mettrait quelque chose.

DONNEES A PROPOS THE DONNEES

Il est possible d'ajouter une variété de données sur les données à la sortie.

Sommes de contrôle
Le site de -big-endian-checksum-négatif filtre peut être utilisé pour additionner les données, puis insérer le
négatif de la somme dans les données. Cela a pour effet de faire la somme à zéro lorsque le
la somme de contrôle elle-même est additionnée, à condition que la largeur de la somme corresponde à la largeur de la valeur insérée.

srec_cat dans le fichier
-recadrer 0 0xFFFFFC
-random-fill 0 0xFFFFFC
-b-e-checksum-neg 0xFFFFFC 4 4
-o fichier de sortie

Dans cet exemple, nous avons une EPROM dans le plus petit mégaoctet de mémoire. Le filtre -crop
garantit que nous additionnons uniquement les données dans l'EPROM, et nulle part ailleurs. Les
-le filtre de remplissage aléatoire remplit tous les trous laissés dans les données avec des valeurs aléatoires. Enfin, le -b‐
Le filtre e-checksum-neg insère une somme de contrôle de 32 bits (4 octets) au format gros-boutiste dans le dernier
4 octets de l'image EPROM. Naturellement, il existe une version un peu endian de ce filtre car
Hé bien.

Votre code intégré peut vérifier l'EPROM à l'aide d'un code C similaire au suivant :

long non signé *begin = (long non signé *)0 ;
long non signé *end = (long non signé *)0x100000 ;
somme longue non signée = 0 ;
tandis que (début < fin)
somme += *commencer++;
si (somme != 0)
{
oops
}

Le site de -big-endian-checksum-bitnot le filtre est similaire, sauf que la somme sur la somme de contrôle
devrait donner une valeur de tout-un-bit (-1). Par exemple, en utilisant des shorts plutôt que des longs :

srec_cat dans le fichier
-recadrer 0 0xFFFFFE
-remplir 0xCC 0x00000 0xFFFFFE
-b-e-checksum-neg 0xFFFFFE 2 2
-o fichier de sortie

En supposant que vous ayez choisi le bon filtre endian, votre code intégré peut vérifier l'EPROM
en utilisant un code C semblable au suivant :

unsigned short *begin = (unsigned short *)0 ;
unsigned short *end = (unsigned short *)0x100000 ;
somme courte non signée = 0 ;
tandis que (début < fin)
somme += *commencer++;
si (somme != 0xFFFF)
{
oops
}

Il y a aussi -b-e-checksum-positif filtre, et un filtre little-endian correspondant, qui
insère la somme simple, et qui serait vérifiée en C à l'aide d'un test d'égalité.

srec_cat dans le fichier
-recadrer 0 0xFFFFFF
-remplir 0x00 0x00000 0xFFFFFF
-b-e-checksum-neg 0xFFFFFF 1 1
-o fichier de sortie

En supposant que vous ayez choisi le bon filtre endian, votre code intégré peut vérifier l'EPROM
en utilisant un code C semblable au suivant :

caractère non signé *begin = (car non signé *)0 ;
caractère non signé *end = (caractère non signé *)0xFFFFF;
somme de caractères non signée = 0 ;
tandis que (début < fin)
somme += *commencer++;
si (somme != *fin)
{
oops
}

Dans le cas du 8 bits, peu importe que vous utilisiez le big-endian ou le little-endian
filtre.

Aperçu Hex-Dump
Vous pouvez consulter la somme de contrôle de vos données, en utilisant le format de sortie « hex-dump ». C'est
utile pour consulter les valeurs calculées ou pour déboguer un srec_cat(1) commande avant
l'immortaliser dans un script.

srec_cat dans le fichier
-recadrer 0 0x10000
-remplir 0xFF 0x0000 0x10000
-b-e-checksum-neg 0x10000 4
-recadrer 0x10000 0x10004
-o - -hex-dump

Cette commande lit dans le fichier, fait la somme de contrôle des données et place la somme de contrôle à 0x10000,
recadre le résultat pour ne contenir que la somme de contrôle, puis imprime la somme de contrôle sur le
sortie standard dans un format de vidage hexadécimal classique. Le nom de fichier spécial « - » signifie
« la sortie standard » dans ce contexte.

Cyclique Redondance Contrôles
Les sommes de contrôle additives simples ont un certain nombre de limitations théoriques, liées aux erreurs
ils peuvent et ne peuvent pas détecter. Les méthodes CRC ont moins de problèmes.

srec_cat dans le fichier
-recadrer 0 0xFFFFFC
-remplir 0x00 0x00000 0xFFFFFC
-b-e-crc32 0xFFFFFC
-o fichier de sortie

Dans l'exemple ci-dessus, nous avons une EPROM dans le plus petit mégaoctet de mémoire. Les -recadrer une fonction filtre
garantit que nous additionnons uniquement les données dans l'EPROM, et nulle part ailleurs. Les -remplir
le filtre comble tous les trous laissés dans les données. Finalement, le -b-e-checksum-neg filtre insère un
Somme de contrôle de 32 bits (4 octets) au format big-endian dans les 4 derniers octets de l'image EPROM.
Naturellement, il existe également une version un peu endian de ce filtre.

La somme de contrôle est calculée à l'aide du CRC 32 bits standard de l'industrie. Parce que SRecord est
open source, vous pouvez toujours lire le code source pour voir comment cela fonctionne. Il y a beaucoup de non-
Les versions GPL de ce code disponibles sur Internet et adaptées à l'intégration dans
firmware propriétaire.

Un CRC 16 bits est également disponible.

srec_cat dans le fichier
-recadrer 0 0xFFFFFE
-remplir 0x00 0x00000 0xFFFFFE
-b-e-crc16 0xFFFFFE
-o fichier de sortie

La somme de contrôle est calculée à l'aide de la formule du CCITT. Parce que SRecord est open source, vous
peut toujours lire le code source pour voir comment cela fonctionne. Il existe de nombreuses versions non GPL de
ce code disponible sur Internet et adapté à l'intégration dans un micrologiciel propriétaire.

Vous pouvez consulter le CRC de vos données, en utilisant le format de sortie « hex-dump ».

srec_cat dans le fichier
-recadrer 0 0x10000
-remplir 0xFF 0x0000 0x10000
-b-e-crc16 0x10000
-recadrer 0x10000 0x10002
-o - -hex-dump

Cette commande lit dans le fichier, calcule le CRC des données et place le CRC à
0x10000, recadre le résultat pour ne contenir que le CRC, puis imprime la somme de contrôle sur le
sortie standard dans un format de vidage hexadécimal classique.

Où Is My Les données?
Il existe plusieurs propriétés de votre image EPROM que vous souhaiterez peut-être insérer dans le
revendre.

srec_cat dans le fichier -b-e-minimum 0xFFFE 2 -o fichier de sortie

L'exemple ci-dessus insère l'adresse minimale des données (faible eau) dans les données, comme
deux octets dans l'ordre gros-boutiste à l'adresse 0xFFFE. Cela inclut le minimum lui-même. Si
les données contiennent déjà des octets à l'adresse donnée, vous devez utiliser un filtre d'exclusion.
Le nombre d'octets par défaut est 4.

Il y a aussi -l-e-minimum filtre pour insérer des valeurs little-endian, et deux autres
filtres appelés -b‐e‐exclusif‐minimum et -l‐e‐exclusif‐minimum qui n'incluent pas le
minimum lui-même dans le calcul de l'adresse de données minimum.

srec_cat dans le fichier -b‐e‐maximal 0xFFFFFC 4 -o fichier de sortie

L'exemple ci-dessus insère l'adresse maximale des données (Élevée eau + 1, juste comme
plages d'adresses) dans les données, sous forme de quatre octets dans l'ordre gros-boutiste à l'adresse 0xFFFFFC.
Cela inclut le maximum lui-même. Si les données contiennent déjà des octets au
adresse, vous devez utiliser un -exclure filtre. Le nombre d'octets par défaut est 4.

Il y a aussi -l-e-maximum filtre pour insérer des valeurs little-endian, et deux autres
filtres appelés -b‐e‐exclusif‐maximum et -l‐e‐exclusif‐maximum qui n'incluent pas le
maximum lui-même dans le calcul de l'adresse de données maximale.

srec_cat dans le fichier -b‐e‐longueur 0xFFFFFC 4 -o fichier de sortie

L'exemple ci-dessus insère la longueur des données (Élevée eau + 1 - faible eau) dans le
données, sous forme de quatre octets dans l'ordre gros-boutiste à l'adresse 0xFFFFFC. Cela comprend la longueur
lui-même. Si les données contiennent déjà des octets à l'emplacement de longueur, vous devez utiliser un
-exclure filtre. Le nombre d'octets par défaut est 4.

Il y a aussi -l‐e‐longueur filtre pour insérer une longueur little-endian, et le -être-
longueur exclusive et -l‐e‐durée‐exclusive filtres qui n'incluent pas la longueur elle-même
dans le calcul.

Organisateur Ce que Format Is Cette?
Vous pouvez obtenir diverses informations sur un fichier de chargement d'EPROM en utilisant le srec_info(1)
commander. Par exemple:

$ srec_info exemple.srec
Format : Motorola S‐Record
Entête: "http://srecord.sourceforge.net/"
Adresse de début d'exécution : 00000000
Données : 0000 - 0122
0456 - 0FFF
$

Cet exemple montre que le fichier est un Motorola S‐Record. Le texte dans l'en-tête du fichier est
imprimé, avec l'adresse de début d'exécution. La dernière section indique l'adresse
plages contenant des données (la limite supérieure de chaque sous-plage est inexclusif, plutôt que le
exforme exclusive utilisée sur la ligne de commande.

$ srec_info un-fichier-bizarre.hex -devine
Format : Signetique
Données : 0000 - 0122
0456 - 0FFF
$

L'exemple ci-dessus devine le format du fichier de chargement de l'EPROM. Ce n'est pas infaillible mais c'est généralement
a raison. Vous pouvez utiliser -devine partout où vous donneriez un format explicite, mais il
tend à être plus lent et pour cette raison n'est pas recommandé. Aussi, pour la construction automatisée
systèmes, vous voulez des erreurs matérielles le plus tôt possible ; si un fichier n'est pas dans l'attendu
format, vous voulez qu'il vomisse.

MANGLAGE THE DONNEES

Il est possible de modifier les valeurs des octets de données de plusieurs manières.

srec_cat dans le fichier -et 0xF0 -o fichier de sortie

L'exemple ci-dessus effectue un ET au niveau du bit des octets de données avec le masque 0xF0. Les
les adresses des enregistrements sont inchangées. Je ne peux pas vraiment penser à une utilisation pour ce filtre.

srec_cat dans le fichier -ou 0x0F -o fichier de sortie

L'exemple ci-dessus effectue un OU au niveau du bit des octets de données avec les bits 0x0F. Les
les adresses des enregistrements sont inchangées. Je ne peux pas vraiment penser à une utilisation pour ce filtre.

srec_cat dans le fichier -x ou 0xA5 -o fichier de sortie

L'exemple ci-dessus effectue un OU exclusif au niveau du bit des octets de données avec les bits 0xA5.
Les adresses des enregistrements sont inchangées. Vous pouvez l'utiliser pour masquer le contenu de
votre EPROM.

srec_cat dans le fichier -pas -o fichier de sortie

L'exemple ci-dessus effectue un NOT au niveau du bit des octets de données. Les adresses des enregistrements sont
inchangé. La sécurité par l'obscurité ?

DROIT D'AUTEUR

srec_cat Version 1.58
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010, 2011 Peter Miller

Le site de srec_cat le programme est livré avec ABSOLUMENT AUCUNE GARANTIE ; pour plus de détails, utilisez le 'srec_cat
-Version Licence' commande. Ceci est un logiciel gratuit et vous pouvez le redistribuer
sous certaines conditions; pour plus de détails, utilisez le 'srec_cat -Version Licence' commande.

Utilisez srec_examples en ligne à l'aide des services onworks.net