ນີ້ແມ່ນຄໍາສັ່ງ srec_examples ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
srec_examples - ຕົວຢ່າງຂອງວິທີການໃຊ້ SRecord
ລາຍລະອຽດ
ໄດ້ srec_cat ຄໍາສັ່ງແມ່ນມີອໍານາດຫຼາຍ, ເນື່ອງຈາກຄວາມສາມາດໃນການສົມທົບການກັ່ນຕອງການປ້ອນຂໍ້ມູນ
ໃນວິທີການເກືອບບໍ່ຈໍາກັດ. ຫນ້າຄູ່ມືນີ້ອະທິບາຍບາງສ່ວນຂອງພວກເຂົາ.
ຫນ້າຄູ່ມືນີ້ອະທິບາຍວິທີການນໍາໃຊ້ໄຟລ໌ປ້ອນຂໍ້ມູນຕ່າງໆ, ການກັ່ນຕອງການປ້ອນຂໍ້ມູນແລະການປ້ອນຂໍ້ມູນ
ເຄື່ອງປັ່ນໄຟ. ແຕ່ເຫຼົ່ານີ້ແມ່ນພຽງແຕ່ຕົວຢ່າງ, ສໍາລັບລາຍລະອຽດຄົບຖ້ວນສົມບູນ, ເບິ່ງ srec_input(1)
ຫນ້າຄູ່ມື.
ໄດ້ ຄໍາສັ່ງ ເສັ້ນ ມີ ເກີນໄປ Long
ຖ້າຫາກວ່າທ່ານກໍາລັງ marooned ໃນລະບົບປະຕິບັດການທີ່ມີຂໍ້ຈໍາກັດຄວາມຍາວຂອງເສັ້ນຄໍາສັ່ງສັ້ນ absurdly,
ບາງຄໍາສັ່ງທີ່ປະຕິບັດຕາມອາດຈະຍາວເກີນໄປ. ທ່ານສາມາດໄດ້ຮັບປະມານພິເສດນີ້ໂດຍ
ວາງເສັ້ນຄໍາສັ່ງຂອງທ່ານໃນໄຟລ໌, ເວົ້າ fred.txt, ແລະຫຼັງຈາກນັ້ນບອກ srec_cat(1) ການອ່ານນີ້
ໄຟລ໌ສໍາລັບສ່ວນທີ່ເຫຼືອຂອງເສັ້ນຄໍາສັ່ງຂອງມັນ, ເຊັ່ນນີ້
srec_cat @fred.txt
ນີ້ຍັງມີຂໍ້ໄດ້ປຽບຂອງການອະນຸຍາດໃຫ້ຄໍາເຫັນ, ຊ່ວຍໃຫ້ທ່ານຂຽນເສັ້ນຄໍາສັ່ງຂອງທ່ານ
ທາງເລືອກໃນໄລຍະຫຼາຍເສັ້ນ, ແລະແມ້ກະທັ້ງ indenting ເພື່ອເຮັດໃຫ້ຄໍາສັ່ງຈະແຈ້ງຫຼາຍ. ຄຳເຫັນ
ເລີ່ມຕົ້ນທີ່ "#” ແລະຂະຫຍາຍໄປໃນຕອນທ້າຍຂອງເສັ້ນ. ເສັ້ນຫວ່າງຖືກລະເລີຍ.
ແນ່ນອນ, ເຈົ້າສາມາດອັບເກຣດເປັນ Linux ໄດ້ສະເໝີ, ເຊິ່ງໄດ້ດູດໜ້ອຍກວ່າ 27 ປີ
ປີນີ້.
ຂອງທ່ານ ຕົວຢ່າງ ຕ້ອງການ
ຖ້າຫາກວ່າທ່ານມີວິທີການທີ່ສະຫຼາດຂອງການນໍາໃຊ້ SRecord, ຫຼືໄດ້ແກ້ໄຂບັນຫາຍາກທີ່ມີ
SRecord, ທ່ານສາມາດປະກອບສ່ວນເຂົ້າໃນຫນ້າຄູ່ມືນີ້, ເຮັດໃຫ້ມັນເປັນປະໂຫຍດຫຼາຍສໍາລັບທຸກຄົນ.
ສົ່ງຕົວຢ່າງຂອງທ່ານໃນອີເມວໄປຫາທີ່ຢູ່ອີເມວໃນຕອນທ້າຍຂອງຫນ້າຄູ່ມືນີ້.
ການປ່ຽນແປງ ເອກະສານ ຮູບແບບ
ງ່າຍທີ່ສຸດຂອງສິ່ງທີ່ srec_cat(1) ສາມາດເຮັດໄດ້ແມ່ນການປ່ຽນຈາກຫນຶ່ງຮູບແບບໄຟລ໌ EPROM ກັບ
ອື່ນ. ກະລຸນາຈື່ໄວ້, ໃນຂະນະທີ່ທ່ານອ່ານພາກນີ້, ທີ່ທ່ານສາມາດເຮັດໄດ້ຫຼາຍຢ່າງ
ສິ່ງພ້ອມໆກັນໃນຄໍາສັ່ງດຽວ. ເຂົາເຈົ້າພຽງແຕ່ແຍກອອກແຍກຕ່າງຫາກເພື່ອເຮັດໃຫ້ເຂົາເຈົ້າ
ເຂົ້າໃຈງ່າຍກວ່າ.
Intel to Motorola
ຫນຶ່ງໃນຕົວຢ່າງທີ່ງ່າຍດາຍທີ່ສຸດແມ່ນການປ່ຽນໄຟລ໌ຈາກຮູບແບບ Intel hex ກັບ Motorola S-
ຮູບແບບການບັນທຶກ:
srec_cat ໄຟລ໌ Intel -intel -o srec-file
ໃຫ້ສັງເກດວ່າຕົວລະບຸຮູບແບບທັນທີປະຕິບັດຕາມຊື່ຂອງໄຟລ໌ທີ່ມັນກໍາລັງອະທິບາຍ.
ເລືອກຮູບແບບໃດກໍໄດ້ສອງຮູບແບບທີ່ SRecord ເຂົ້າໃຈ, ແລະມັນສາມາດປ່ຽນລະຫວ່າງພວກມັນທັງໝົດໄດ້.
(ຍົກເວັ້ນຕົວປະກອບ, ພື້ນຖານ, C ແລະ FPGA ຜົນໄດ້ຮັບທີ່ຂຽນເທົ່ານັ້ນ.)
Motorola to Intel
ການປ່ຽນທາງອື່ນແມ່ນງ່າຍດາຍເຊັ່ນດຽວກັນ:
srec_cat srec-file -o ໄຟລ໌ Intel -intel
ຮູບແບບເລີ່ມຕົ້ນແມ່ນຮູບແບບ Motorola S-Record, ສະນັ້ນມັນບໍ່ຈໍາເປັນຕ້ອງລະບຸໄວ້ຫຼັງຈາກນັ້ນ
ຊື່ໄຟລ໌.
ທີ່ແຕກຕ່າງກັນ ຮູບຮ່າງ of ໄດ້ Same ຮູບແບບ
ມັນເປັນເລື່ອງທີ່ໜ້າເສຍໃຈທີ່ນັກຂຽນໂປລແກລມ EPROM ບາງຄົນປະຕິບັດພຽງແຕ່ສ່ວນໜຶ່ງເທົ່ານັ້ນ
ຂອງສະເພາະທີ່ໃຊ້ເພື່ອເປັນຕົວແທນຂອງໄຟລ໌ hex ຂອງພວກເຂົາ. ຕົວຢ່າງ, ບາງ compilers
ຜະລິດ "s19" ຂໍ້ມູນ Motorola (ນັ້ນແມ່ນ, ບັນທຶກຂໍ້ມູນ S1 ກັບບັນທຶກການເລີ່ມຕົ້ນ S9, 16 bit.
address fields) ເຊິ່ງຈະເປັນ OK ຍົກເວັ້ນບາງ blockhead EPROM programmers instant on
“s37” ຂໍ້ມູນ Motorola (ນັ້ນແມ່ນ, S3 data records with S7 start records, 32 bit address.
ທົ່ງນາ).
ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນຈາກຮູບຮ່າງຂອງ Motorola ໄປຫາຮູບແບບອື່ນໂດຍໃຊ້ - ຄວາມຍາວທີ່ຢູ່
ຕົວເລືອກ:
srec_cat short.srec -o long.srec -address-length=4
ຄໍາສັ່ງນີ້ບອກວ່າຈະໃຊ້ສີ່ byte (32-bit) addresses on output.
ພາກນີ້ຍັງໃຊ້ກັບໄຟລ໌ Intel hex, ຍ້ອນວ່າພວກເຂົາ, ເຊັ່ນດຽວກັນ, ມີຄວາມສາມາດໃນການເລືອກ
ຈາກຄວາມກວ້າງຂອງທີ່ຢູ່ທີ່ຫຼາກຫຼາຍ. ເພື່ອປ່ຽນຈາກຮູບຮ່າງຂອງ Intel ໄປເປັນຮູບແບບອື່ນໂດຍໃຊ້
ດຽວກັນ - ຄວາມຍາວທີ່ຢູ່ ຕົວເລືອກ:
srec_cat i32.hex -o i16.hex -address-length=3
ຄໍາສັ່ງນີ້ບອກວ່າຈະໃຊ້ “i16hex” 20-bit segmented addresses on output. ຄວາມຍາວທີ່ຢູ່
ຂອງ 4 ແມ່ນຄ່າເລີ່ມຕົ້ນ (“i32hex” 32-bit linear addressing), ແລະຄວາມຍາວທີ່ຢູ່ຂອງ 2 ຈະ.
ຮ້ອງຂໍ "i8hex" 16-bit ທີ່ຢູ່.
ອອນໄລນ໌ ຄວາມຍາວ
ບາງຄັ້ງເຈົ້າຈະພົບກັບນັກຂຽນໂປລແກລມ EPROM ທີ່ມີຈິດໃຈອ່ອນແອທີ່ບໍ່ສາມາດຮັບມືໄດ້
ດ້ວຍແຖວຕົວໜັງສືຍາວ, ພວກເຂົາເຈົ້າສົມມຸດວ່າຈະມີພຽງແຕ່ 46 ຕົວອັກສອນຕໍ່ແຖວ
barf ເມື່ອພວກເຂົາເຫັນຄວາມຍາວຂອງເສັ້ນເລີ່ມຕົ້ນ srec_cat(1) ຂຽນ (ຫຼືຮ້າຍແຮງກວ່າເກົ່າ, ເອົາ stack ເປັນ
scribble ແລະ crash).
ນິຍາມຮູບແບບຂອງ Motorola S-record ອະນຸຍາດໃຫ້ໂຫຼດໄດ້ເຖິງ 255 bytes ຂອງ payload, ຫຼືສາຍຂອງ
514 ຕົວອັກສອນ, ບວກກັບການຢຸດແຖວ. ໂປລແກລມ EPROM ທັງໝົດ ຄວນ ມີພຽງພໍ
buffers ເສັ້ນຂະຫນາດໃຫຍ່ເພື່ອຮັບມືກັບບັນທຶກຂະຫນາດໃຫຍ່ນີ້. ບໍ່ຫຼາຍປານໃດເຮັດ.
ທາງເລືອກ -line-length ອາດຈະຖືກນໍາໃຊ້ເພື່ອລະບຸຄວາມຍາວເສັ້ນສູງສຸດ (ບໍ່ລວມທັງການ
newline) ເພື່ອນໍາໃຊ້ໃນການຜະລິດຕະພັນ. ຕົວຢ່າງ, 16 byte payloads ສໍາລັບ Motorola hex
srec_cat long.srec -o short.s19 -line-length=46
ທາງເລືອກຄວາມຍາວຂອງເສັ້ນພົວພັນກັບທາງເລືອກຂອງຄວາມຍາວທີ່ຢູ່, ສະນັ້ນບາງ tinkering ກັບ
ປັບຕົວໃຫ້ເໝາະສົມກັບສະຖານະການສະເພາະຂອງເຈົ້າຫຼາຍສົມຄວນ.
ຜົນຜະລິດ Block ເລືອກຂະຫນາດ
ທຸກໆຄັ້ງທີ່ເຈົ້າຈະພົບກັບນັກຂຽນໂປລແກລມ EPROM ເກົ່າແກ່ທີ່ເຮັດບໍ່ໄດ້
ຮັບມືກັບການບັນທຶກຂໍ້ມູນທີ່ຍາວນານ, ພວກເຂົາເຈົ້າສົມມຸດວ່າຈະມີພຽງແຕ່ຫຼາຍທີ່ສຸດ 16 bytes ຂອງ
ຂໍ້ມູນຕໍ່ບັນທຶກ, ແລະ barf ໃນເວລາທີ່ພວກເຂົາເຈົ້າເຫັນຄ່າເລີ່ມຕົ້ນ 32 byte payloads ວ່າ srec_cat(1)
ຂຽນ (ຫຼືຮ້າຍແຮງກວ່າເກົ່າ, buffer over-run ເຮັດໃຫ້ເກີດການຍ່າງຫຍ້າສູງທີ່ scribbles ສຸດຂອງທ່ານ
EPROM).
ຄໍານິຍາມຮູບແບບ Intel hex ອະນຸຍາດໃຫ້ເຖິງ 255 bytes ຂອງ payload ຂໍ້ມູນຕໍ່ບັນທຶກ. ທັງໝົດ
ໂປລແກລມ EPROM ຄວນ ມີ buffers ຂໍ້ມູນຂະຫນາດໃຫຍ່ພຽງພໍເພື່ອຮັບມືກັບບັນທຶກນີ້
ໃຫຍ່. ໂຊກດີກັບສິ່ງນັ້ນ.
ຕົວເລືອກ -Output-Block-Size ອາດຈະຖືກນໍາໃຊ້ເພື່ອກໍານົດຂະຫນາດຂໍ້ມູນບັນທຶກທີ່ຈະໃຊ້
ຜົນຜະລິດ. ຕົວຢ່າງ, Intel hex ກັບ 16 byte payloads:
srec_cat long.srec -o short.hex -intel -obs=16
ຈົ່ງລະມັດລະວັງບໍ່ໃຫ້ໃສ່ - obs ທາງເລືອກລະຫວ່າງຊື່ໄຟລ໌ຜົນຜະລິດແລະຮູບແບບ
ຕົວລະບຸ.
ພຽງແຕ່ ໄດ້ ຂໍ້ມູນ, ກະລຸນາ
ມີບາງນັກຂຽນໂປລແກລມ EPROM ກະດູກທີ່ພຽງແຕ່ສາມາດຮັບມືກັບບັນທຶກຂໍ້ມູນ, ແລະມີ
ບໍ່ສາມາດຮັບມືກັບການບັນທຶກສ່ວນຫົວ ຫຼືການບັນທຶກທີ່ຢູ່ເລີ່ມຕົ້ນ. ຖ້າເຈົ້າມີອັນນີ້
ບັນຫາ, ໄດ້ - ຂໍ້ມູນເທົ່ານັ້ນ ທາງເລືອກສາມາດຖືກນໍາໃຊ້ເພື່ອສະກັດກັ້ນທຸກສິ່ງທຸກຢ່າງຍົກເວັ້ນ
ຂໍ້ມູນ. ຜົນກະທົບຕົວຈິງແມ່ນຂຶ້ນກັບຮູບແບບ, ແນ່ນອນ, ເພາະວ່າບາງຄົນບໍ່ມີສິ່ງເຫຼົ່ານີ້
ລັກສະນະໃດກໍ່ຕາມ.
ໄດ້ - ຂໍ້ມູນເທົ່ານັ້ນ ທາງເລືອກແມ່ນມືສັ້ນ. ມີສີ່ຄຸນສົມບັດທີ່ອາດຈະເປັນ - ຄົນພິການ or
-enabled ແຍກຕ່າງຫາກ. ເບິ່ງ srec_cat(1) ຫນ້າຜູ້ຊາຍສໍາລັບລາຍລະອຽດຂອງ - ຄົນພິການ ແລະ
-enabled ຕົວເລືອກ
ຕົວຢ່າງ, ໂປຣແກມ neanderthal EPROM ຂອງທ່ານຕ້ອງການ Motorola hex ທີ່ມີບັນທຶກ header
(S0), ແຕ່ບໍ່ມີການນັບຂໍ້ມູນ (S5) ບັນທຶກ. ບໍ່ໄດ້ໃຊ້ - ຂໍ້ມູນເທົ່ານັ້ນ ທາງເລືອກມີມັນ barf ສຸດ
ການບັນທຶກການນັບຂໍ້ມູນ, ແຕ່ການນໍາໃຊ້ - ຂໍ້ມູນເທົ່ານັ້ນ ທາງເລືອກທີ່ມີມັນ barf ໃນຫົວທີ່ຂາດຫາຍໄປ
ບັນທຶກ. ການນໍາໃຊ້ -disable=ການນັບຂໍ້ມູນ ທາງເລືອກຈະເຮັດໃຫ້ການບັນທຶກ header intact ໃນຂະນະທີ່
ສະກັດກັ້ນການບັນທຶກການນັບຂໍ້ມູນ.
ຂໍ້ມູນ Headers
ໄດ້ srec_cat(1) ຄໍາສັ່ງສະເຫມີພະຍາຍາມທີ່ຈະຜ່ານການບັນທຶກສ່ວນຫົວບໍ່ມີການປ່ຽນແປງ, ທຸກຄັ້ງ
ເຂົາເຈົ້າມີຢູ່. ມັນຍັງພະຍາຍາມຮັກສາພວກມັນໃນທົ່ວການປ່ຽນແປງຮູບແບບໄຟລ໌, ເຖິງຂອບເຂດຈໍາກັດ
ຮູບແບບໄຟລ໌ແມ່ນສາມາດ.
ຖ້າຫາກວ່າບໍ່ມີການບັນທຶກສ່ວນຫົວຂອງໄຟລ໌ແລະທ່ານຕ້ອງການທີ່ຈະເພີ່ມຫນຶ່ງ, ຫຼືທ່ານຕ້ອງການທີ່ຈະ override
ການບັນທຶກ header ໄຟລ໌ທີ່ມີຢູ່ແລ້ວ, ໃຊ້ - ຫົວ=string ທາງເລືອກ. ທ່ານຈະຈໍາເປັນຕ້ອງໄດ້ອ້າງເຖິງ
string (ເພື່ອ insulate ຈາກ shell) ຖ້າມັນມີຊ່ອງຫວ່າງຫຼື shell meta-ຕົວອັກສອນ.
ການບໍລິຫານ ເລີ່ມຕົ້ນ ທີ່ຢູ່
ໄດ້ srec_cat(1) ຄໍາສັ່ງສະເຫມີໄປພະຍາຍາມທີ່ຈະຜ່ານທີ່ຢູ່ເລີ່ມຕົ້ນການປະຕິບັດ (ໂດຍປົກກະຕິ
ເກີດຂຶ້ນໃນຕອນທ້າຍຂອງໄຟລ໌), ທຸກຄັ້ງທີ່ເຂົາເຈົ້າມີຢູ່. ເຂົາເຈົ້າໄດ້ຖືກປັບຕາມ
ກັບບັນທຶກຂໍ້ມູນໂດຍ - ຊົດເຊີຍ ການກັ່ນຕອງ. ມັນຍັງພະຍາຍາມຮັກສາພວກມັນໃນທົ່ວໄຟລ໌
ການປ່ຽນແປງຮູບແບບ, ການຈໍາກັດຮູບແບບໄຟລ໌ແມ່ນສາມາດຂອງ.
ຖ້າຫາກວ່າບໍ່ມີການປະຕິບັດການບັນທຶກທີ່ຢູ່ເລີ່ມຕົ້ນແລະທ່ານຕ້ອງການທີ່ຈະເພີ່ມຫນຶ່ງ, ຫຼືທ່ານຕ້ອງການ
ເພື່ອ override ບັນທຶກທີ່ຢູ່ເລີ່ມຕົ້ນຂອງການປະຕິບັດທີ່ມີຢູ່ແລ້ວ, ໃຫ້ໃຊ້ - ການເລີ່ມຕົ້ນການປະຕິບັດ
ທີ່ຢູ່=ຈໍານວນ ທາງເລືອກ.
ກະລຸນາບັນທຶກ: ທີ່ຢູ່ເລີ່ມຕົ້ນການປະຕິບັດເປັນແນວຄວາມຄິດທີ່ແຕກຕ່າງກັນກ່ວາທີ່ຢູ່ທໍາອິດໃນ
ຄວາມຊົງຈໍາຂອງຂໍ້ມູນຂອງທ່ານ. ຄິດວ່າມັນເປັນທີ່ຢູ່ "goto" ທີ່ຈະໂດດໄປຫາໂດຍຕິດຕາມກວດກາໃນເວລາທີ່
ການໂຫຼດ hex ແມ່ນສໍາເລັດ. ຖ້າທ່ານຕ້ອງການປ່ຽນບ່ອນທີ່ຂໍ້ມູນຂອງທ່ານເລີ່ມຕົ້ນຢູ່ໃນຫນ່ວຍຄວາມຈໍາ, ໃຫ້ໃຊ້ປຸ່ມ
- ຊົດເຊີຍ ຕົວກອງ
ການແກ້ໄຂ ກວດສອບ
ບາງນັກພັດທະນາເຟີມແວທີ່ຝັງຢູ່ແມ່ນ saddled ກັບເຄື່ອງມື featherbrained ທີ່ຜະລິດ
checksums ທີ່ບໍ່ຖືກຕ້ອງ, ເຊິ່ງຕົວແບບທີ່ລະມັດລະວັງຫຼາຍຂອງໂປລແກລມ EPROM ຈະບໍ່ຍອມຮັບ.
ເພື່ອແກ້ໄຂ checksums ໃນໄຟລ໌, ໃຫ້ໃຊ້ - ignore-checksums ທາງເລືອກ. ຍົກຕົວຢ່າງ:
srec_cat break.srec -ignore-checksums -o fixed.srec
ເຊັກsums ໃນ break.srec ແມ່ນ parsed (ມັນຍັງແລະຜິດພາດຖ້າຫາກວ່າພວກເຂົາເຈົ້າແມ່ນບໍ່ມີ) ແຕ່ແມ່ນ
ບໍ່ໄດ້ກວດກາ. ຜົນໄດ້ຮັບ fixed.srec ໄຟລ໌ມີ checksums ທີ່ຖືກຕ້ອງ. ໄດ້ - ignore-checksums
ທາງເລືອກພຽງແຕ່ນໍາໃຊ້ກັບການປ້ອນຂໍ້ມູນ.
ຕົວເລືອກນີ້ອາດຈະຖືກໃຊ້ໃນທຸກຮູບແບບໄຟລ໌ທີ່ມີ checksums, ລວມທັງ Intel hex.
ຄົ້ນພົບ Mystery ຮູບແບບ
ເບິ່ງ ແມ່ນຫຍັງ ຮູບແບບ Is ນີ້ບໍ? ພາກສ່ວນ, ຂ້າງລຸ່ມນີ້, ສໍາລັບວິທີການຄົ້ນພົບແລະປ່ຽນຄວາມລຶກລັບ EPROM
ໂຫຼດຮູບແບບໄຟລ໌.
ໄບນາຣີ ເອກະສານ
ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນເປັນແລະຈາກໄຟລ໌ຖານສອງ. ທ່ານຍັງສາມາດປະສົມໄຟລ໌ຄູ່ແລະ
ຮູບແບບອື່ນໆຮ່ວມກັນໃນອັນດຽວກັນ srec_cat(1) ຄໍາສັ່ງ.
ລາຍລັກອັກສອນ ຖານສອງ ໄຟ
ວິທີທີ່ງ່າຍທີ່ສຸດຂອງການອ່ານໄຟລ໌ hex ແລະປ່ຽນມັນເປັນໄຟລ໌ຖານສອງເບິ່ງຄືນີ້:
srec_cat fred.hex -o fred.bin -binary
ນີ້ອ່ານໄຟລ໌ Motorola hex fred.srec ແລະຂຽນມັນອອກໄປຫາ fred.bin ເປັນວັດຖຸດິບ
ຖານສອງ.
ໃຫ້ສັງເກດວ່າຂໍ້ມູນຖືກຈັດໃສ່ໃນໄຟລ໌ຄູ່ຢູ່ທີ່ການຊົດເຊີຍ byte ທີ່ລະບຸໄວ້ໂດຍ
ທີ່ຢູ່ໃນໄຟລ໌ hex. ຖ້າມີຂຸມໃນຂໍ້ມູນພວກເຂົາເຕັມໄປດ້ວຍສູນ.
ນີ້ແມ່ນ, ແນ່ນອນ, ທົ່ວໄປກັບຜົນໄດ້ຮັບຂອງຕົວເຊື່ອມຕໍ່ທີ່ລະຫັດຖືກວາງໄວ້ເລີ່ມຕົ້ນທີ່ a
ສະຖານທີ່ໂດຍສະເພາະໃນຄວາມຊົງຈໍາ. ຕົວຢ່າງ, ເມື່ອເຈົ້າມີຮູບພາບເລີ່ມຕົ້ນທີ່ 0x100000,
1MB ທຳອິດຂອງໄຟລ໌ໄບນາຣີຜົນຜະລິດຈະເປັນສູນ.
ທ່ານສາມາດຍົກເລີກການຊົດເຊີຍນີ້ໂດຍອັດຕະໂນມັດໂດຍໃຊ້ຄໍາສັ່ງເຊັ່ນ
srec_cat fred.hex -offset − -minimum-addr fred.hex -o fred.bin
ຄໍາສັ່ງຂ້າງເທິງນີ້ເຮັດວຽກໂດຍການຊົດເຊີຍ fred.hex ໄຟລ໌ໃນຫນ່ວຍຄວາມຈໍາຫນ້ອຍລົງຫນ້ອຍທີ່ສຸດ
ທີ່ຢູ່ໃນ fred.hex ຂໍ້ມູນໄຟລ໌.
ເບິ່ງອີກ srec_binary(5) ຫນ້າຜູ້ຊາຍສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ.
ອ່ານ ຖານສອງ ໄຟ
ວິທີທີ່ງ່າຍທີ່ສຸດຂອງການອ່ານໄຟລ໌ຖານສອງແລະການປ່ຽນມັນເບິ່ງຄືນີ້
srec_cat fred.bin -binary -o fred.srec
ນີ້ອ່ານໄຟລ໌ສອງ fred.bin ແລະຂຽນຂໍ້ມູນທັງໝົດຂອງມັນກັບຄືນມາອີກຄັ້ງເປັນ
ໄຟລ໌ Motorola S-Record.
ເລື້ອຍໆ, ໄບນາຣີນີ້ບໍ່ແມ່ນບ່ອນທີ່ທ່ານຕ້ອງການຢູ່ໃນພື້ນທີ່ທີ່ຢູ່, ເພາະວ່າມັນແມ່ນ
ສົມມຸດວ່າອາໄສຢູ່ສູນ. ຖ້າທ່ານຕ້ອງການຍ້າຍມັນໄປໃຊ້ - ຊົດເຊີຍ ຕົວກອງ
srec_cat fred.bin -binary -offset 0x10000 -o fred.srec
ນອກນັ້ນທ່ານຍັງຈໍາເປັນຕ້ອງໄດ້ຫຼີກເວັ້ນການ "ຮູ" ໄຟລ໌ທີ່ເຕັມໄປດ້ວຍສູນ. ທ່ານສາມາດນໍາໃຊ້ໄດ້ - ການປູກພືດ
ການກັ່ນຕອງ, ທ່ານສາມາດນໍາໃຊ້ໄດ້ - ບໍ່ຕື່ມ ການກັ່ນຕອງຖ້າທ່ານບໍ່ຮູ້ວ່າຂໍ້ມູນນັ້ນຢູ່ໃສ.
srec_cat fred.bin -binary -unfill 0x00 512 -o fred.srec
ຄໍາສັ່ງຂ້າງເທິງນີ້ລົບການແລ່ນຂອງສູນໄບຕ໌ທີ່ມີຄວາມຍາວ 512 ໄບຕ໌ຫຼືດົນກວ່ານັ້ນ. ຖ້າເຈົ້າ
ໄຟລ໌ມີ 1GB ຂອງສູນໄບຕ໌ຊັ້ນນໍາ, ນີ້ຈະຊ້າ, ມັນອາດຈະດີກວ່າທີ່ຈະໃຊ້
ໄດ້ dd(1) ຄໍາສັ່ງທີ່ຈະຊອຍແລະ dice ກ່ອນ.
ເຂົ້າຮ່ວມ ເອກະສານ TOGETHER
ໄດ້ srec_cat ຄໍາສັ່ງເອົາຊື່ຂອງມັນມາຈາກ UNIX cat(1) ຄໍາສັ່ງ, ທີ່ສັ້ນສໍາລັບການ
"catenate" ຫຼື "ເຂົ້າຮ່ວມ". ໄດ້ srec_cat ຄໍາສັ່ງເຂົ້າຮ່ວມ EPROM ໂຫລດໄຟລ໌ຮ່ວມກັນ.
ທັງຫມົດ In ຫນຶ່ງ
ການເຂົ້າຮ່ວມ EPROM ໂຫຼດໄຟລ໌ເຂົ້າຮ່ວມກັນເປັນໄຟລ໌ດຽວແມ່ນງ່າຍດາຍ, ພຽງແຕ່ຕັ້ງຊື່ຫຼາຍໄຟລ໌
ເສັ້ນຄໍາສັ່ງຕາມທີ່ທ່ານຕ້ອງການ:
srec_cat infile1 infile2 -o outfile
ຕົວຢ່າງນີ້ແມ່ນໄຟລ໌ Motorola S-Record ທັງໝົດ, ເພາະວ່ານັ້ນແມ່ນຮູບແບບເລີ່ມຕົ້ນ. ເຈົ້າສາມາດ
ມີຫຼາຍຮູບແບບໃນຄໍາສັ່ງດຽວ, ແລະ srec_cat(1) ຍັງຈະເຮັດວຽກ. ເຈົ້າບໍ່ແມ້ແຕ່
ຕ້ອງອອກຮູບແບບດຽວກັນ:
srec_cat infile1 - spectrum infile2 - ເນດແຮມ \
-o outfile - ສັນຍາລັກ
ເຫຼົ່ານີ້ແມ່ນຮູບແບບເກົ່າແກ່ທັງຫມົດ, ແນວໃດກໍ່ຕາມມັນບໍ່ເປັນເລື່ອງແປກທີ່ຈະຕ້ອງໄດ້ປະສົມແລະຈັບຄູ່ Intel
ແລະຮູບແບບ Motorola ໃນໂຄງການດຽວ.
ການກັ່ນຕອງ ຫຼັງຈາກ ເຂົ້າຮ່ວມ
ມີເວລາທີ່ທ່ານຕ້ອງການເຂົ້າຮ່ວມສອງຊຸດຂໍ້ມູນຮ່ວມກັນ, ແລະຫຼັງຈາກນັ້ນນໍາໃຊ້ຕົວກອງ
ກັບຜົນໄດ້ຮັບທີ່ເຂົ້າຮ່ວມ. ເພື່ອເຮັດສິ່ງນີ້, ໃຊ້ວົງເລັບ.
srec_cat \
'(' \
infile - ບໍ່ລວມ 0xFFF0 0x10000 \
-ສ້າງ 0xFFF0 0xFFF8 -repeat-string 'ກ້ວຍ' \
')' \
-b-e-ຄວາມຍາວ 0xFFF8 4 \
-b-e-checksum-neg 0xFFFC 4 4 \
-o outfile
ຄໍາສັ່ງຕົວຢ່າງຂ້າງເທິງ catenates ໄຟລ໌ input (ກັບພື້ນທີ່ຂໍ້ມູນທີ່ສ້າງຂຶ້ນບໍ່ລວມ)
ດ້ວຍສາຍຄົງທີ່. ຫຼັງຈາກນັ້ນ, ວັດສະດຸປ້ອນ catenated ນີ້ຈະຖືກກັ່ນຕອງເພື່ອເພີ່ມຄວາມຍາວ 4-byte, ແລະ
checksum 4-byte.
ເຂົ້າຮ່ວມ ສິ້ນສຸດ
ເລື້ອຍໆຊ່ວງທີ່ຢູ່ໃນໄຟລ໌ໂຫລດ EPROM ຈະທັບຊ້ອນກັນ. ທ່ານຈະໄດ້ຮັບ
ຜິດພາດຖ້າພວກເຂົາເຮັດ. ຖ້າທັງສອງໄຟລ໌ເລີ່ມຕົ້ນຈາກທີ່ຢູ່ສູນ, ເພາະວ່າແຕ່ລະຄົນເຂົ້າໄປໃນ a
EPROM ແຍກຕ່າງຫາກ, ທ່ານອາດຈະຕ້ອງໃຊ້ຕົວກອງຊົດເຊີຍ:
srec_cat infile1 \
infile2 - ຊົດເຊີຍ 0x80000 \
-o outfile
ບາງຄັ້ງທ່ານຕ້ອງການສອງໄຟລ໌ປະຕິບັດຕາມເຊິ່ງກັນແລະກັນຢ່າງແທ້ຈິງ, ແຕ່ວ່າທ່ານບໍ່ຮູ້ວ່າ
ຊົດເຊີຍລ່ວງໜ້າ:
srec_cat infile1 \
infile2 -offset -maximum-addr infile1 \
-o outfile
ສັງເກດເຫັນວ່າບ່ອນທີ່ເປັນຕົວເລກ (0x80000) ກ່ອນ, ປະຈຸບັນມີການຄິດໄລ່ (-maximum-.
ສິ່ງເສບຕິດ infile1). ອັນນີ້ເປັນໄປໄດ້ສ່ວນໃຫຍ່ທີ່ຕົວເລກອາດຈະຖືກນໍາໃຊ້ (ຍັງ -minimum-addr ແລະ
-range).
ການປູກພືດ ການ ຂໍ້ມູນ
ມັນເປັນໄປໄດ້ທີ່ຈະຄັດລອກໄຟລ໌ໂຫລດ EPROM, ເລືອກທີ່ຢູ່ທີ່ຈະຮັກສາແລະທີ່ຢູ່ໄປຫາ
ຖິ້ມ.
ແມ່ນຫຍັງ To ໃຫ້ເກັບຮັກສາ
ກິດຈະກໍາທົ່ວໄປແມ່ນການຕັດຂໍ້ມູນຂອງທ່ານໃຫ້ກົງກັບສະຖານທີ່ EPROM ຂອງທ່ານ. ຕົວເຊື່ອມຕໍ່ຂອງທ່ານອາດຈະເພີ່ມ
ຂີ້ເຫຍື້ອອື່ນໆທີ່ເຈົ້າບໍ່ສົນໃຈ, ຕົວຢ່າງ: ທີ່ຕັ້ງ RAM. ໃນຕົວຢ່າງນີ້,
ມີ 1MB EPROM ຢູ່ເຂດແດນ 2MB:
srec_cat infile - ການປູກພືດ 0x200000 0x300000 \
-o outfile
ຂອບເຂດຕ່ໍາສໍາລັບຂອບເຂດທີ່ຢູ່ທັງຫມົດແມ່ນລວມ, ຂອບເຂດເທິງແມ່ນສະເພາະ. ຖ້າເຈົ້າ
ລົບພວກມັນ, ທ່ານໄດ້ຮັບຈໍານວນ bytes.
ທີ່ຢູ່ Offset
ພຽງແຕ່ເປັນໄປໄດ້, ທ່ານມີໂປລແກລມ EPROM ຂີ້ຮ້າຍ, ແລະມັນ barfs ຖ້າຮູບພາບ EPROM
ບໍ່ໄດ້ເລີ່ມຕົ້ນທີ່ສູນ. ເພື່ອຊອກຮູ້ວ່າຢູ່ໃສ ບໍ່ ເລີ່ມຕົ້ນໃນຄວາມຊົງຈໍາ, ການນໍາໃຊ້
srec_info(1) ຄໍາສັ່ງ:
$ srec_info example.srec
ຮູບແບບ: Motorola S-Record
ສ່ວນຫົວ: extra-whiz tool chain linker
ທີ່ຢູ່ເລີ່ມຕົ້ນຂອງການປະຕິບັດ: 0x00200000
ຂໍ້ມູນ: 0x200000 - 0x32AAEF
$
ແທນທີ່ຈະເອົາໄຟລ໌ຄໍາສັ່ງຂອງຕົວເຊື່ອມຕໍ່, ພຽງແຕ່ຊົດເຊີຍທີ່ຢູ່:
srec_cat infile - ການປູກພືດ 0x200000 0x300000 -offset −0x200000 \
-o outfile
ໃຫ້ສັງເກດວ່າການຊົດເຊີຍທີ່ໃຫ້ແມ່ນ ກະທົບທາງລົບ, ມັນມີຜົນກະທົບຂອງການລົບມູນຄ່ານັ້ນຈາກ
ທີ່ຢູ່ທັງຫມົດໃນບັນທຶກການປ້ອນຂໍ້ມູນ, ເພື່ອປະກອບເປັນທີ່ຢູ່ການບັນທຶກຜົນຜະລິດໄດ້. ໃນກໍລະນີນີ້,
ການປ່ຽນຮູບພາບກັບຄືນໄປບ່ອນສູນ.
ຕົວຢ່າງນີ້ຍັງສະແດງໃຫ້ເຫັນວິທີການການກັ່ນຕອງການປ້ອນຂໍ້ມູນອາດຈະຖືກຕ່ອງໂສ້ເຂົ້າກັນ: ທໍາອິດ
ການປູກພືດແລະຫຼັງຈາກນັ້ນຊົດເຊີຍ, ທັງຫມົດໃນຫນຶ່ງຄໍາສັ່ງ, ໂດຍບໍ່ມີການຕ້ອງການສໍາລັບໄຟລ໌ຊົ່ວຄາວ.
ຖ້າຫາກວ່າທັງຫມົດທີ່ທ່ານຕ້ອງການຈະເຮັດແມ່ນການຊົດເຊີຍຂໍ້ມູນທີ່ຈະເລີ່ມຕົ້ນຈາກທີ່ຢູ່ສູນ, ນີ້ສາມາດເປັນ
ອັດຕະໂນມັດ, ດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງຮູ້ທີ່ຢູ່ຂັ້ນຕ່ໍາລ່ວງຫນ້າ, ໂດຍການນໍາໃຊ້ srec_cat's
ຄວາມສາມາດໃນການຄິດໄລ່ບາງຢ່າງໃນເສັ້ນຄໍາສັ່ງ:
srec_cat infile -offset - -ຕໍາ່ສຸດທີ່ -addr infile \
-o outfile
ໃຫ້ສັງເກດຊ່ອງຫວ່າງທັງສອງຂ້າງຂອງເຄື່ອງໝາຍລົບ, ພວກມັນຈຳເປັນ.
ແມ່ນຫຍັງ To ຖິ້ມ ທັນທີ
ມີບາງຄັ້ງທີ່ທ່ານຈໍາເປັນຕ້ອງຍົກເວັ້ນຂອບເຂດທີ່ຢູ່ນ້ອຍໆຈາກໄຟລ໌ໂຫລດ EPROM,
ແທນທີ່ຈະຕ້ອງການຮັກສາຂອບເຂດທີ່ຢູ່ນ້ອຍໆ. ໄດ້ - ຍົກເວັ້ນ ການກັ່ນຕອງອາດຈະຖືກນໍາໃຊ້ສໍາລັບ
ຈຸດປະສົງນີ້.
ຕົວຢ່າງ, ຖ້າທ່ານຕ້ອງການຍົກເວັ້ນຂອບເຂດທີ່ຢູ່ບ່ອນທີ່ຫມາຍເລກລໍາດັບຂອງ an
ອຸປະກອນຝັງຖືກເກັບຮັກສາໄວ້, ເວົ້າວ່າ 0x20 bytes ຢູ່ 0x100, ທ່ານຈະໃຊ້ຄໍາສັ່ງເຊັ່ນນີ້:
srec_cat input.srec -ຍົກເວັ້ນ 0x100 0x120 -o output.srec
ໄດ້ output.srec ໄຟລ໌ຈະມີຮູຢູ່ໃນຂໍ້ມູນໃນສະຖານທີ່ທີ່ຈໍາເປັນ.
ໃຫ້ສັງເກດວ່າທ່ານສາມາດມີທັງສອງ - ການປູກພືດ ແລະ - ຍົກເວັ້ນ ໃນເສັ້ນຄໍາສັ່ງດຽວກັນ, ອັນໃດກໍ່ຕາມທີ່ເຮັດວຽກ
ຫຼາຍທໍາມະຊາດສໍາລັບສະຖານະການຂອງທ່ານ.
ການຢຸດເຊົາການ ທີ່ຢູ່ ຊ່ວງ
ຊ່ວງທີ່ຢູ່ບໍ່ຈຳເປັນຕ້ອງເປັນໄລຍະດຽວ, ທ່ານສາມາດສ້າງຊ່ວງທີ່ຢູ່ໄດ້ໂດຍໃຊ້
ຫຼາຍກ່ວາຄູ່ດຽວ.
srec_cat infile - ການປູກພືດ 0x100 0x200 0x1000 0x1200 \
-o outfile
ການກັ່ນຕອງນີ້ສົ່ງຜົນໃຫ້ຂໍ້ມູນຈາກ 0x100..0x1FF ແລະຂໍ້ມູນຈາກ 0x1000..0x1200 ຜ່ານໄປ.
ໂດຍຜ່ານ, ສ່ວນທີ່ເຫຼືອແມ່ນຫຼຸດລົງ. ນີ້ແມ່ນປະສິດທິພາບຫຼາຍກ່ວາລະບົບຕ່ອງໂສ້ a - ການປູກພືດ ແລະຫນຶ່ງ
- ຍົກເວັ້ນ ການກັ່ນຕອງຮ່ວມກັນ.
ຍ້າຍ ສິ່ງຂອງ ອ້ອມຂ້າງ
ມັນຍັງເປັນໄປໄດ້ທີ່ຈະປ່ຽນທີ່ຢູ່ຂອງບັນທຶກຂໍ້ມູນ, ທັງດ້ານຫນ້າແລະດ້ານຫລັງ.
ມັນຍັງສາມາດຈັດລຽງຄືນບ່ອນທີ່ບັນທຶກຂໍ້ມູນຖືກວາງໄວ້ໃນຫນ່ວຍຄວາມຈໍາ.
Offset ການກັ່ນຕອງ
ໄດ້ -offset=ຈໍານວນ ການກັ່ນຕອງດໍາເນີນການກ່ຽວກັບທີ່ຢູ່ຂອງບັນທຶກ. ຖ້າຕົວເລກເປັນບວກ
ທີ່ຢູ່ຍ້າຍທີ່ຫຼາຍ bytes ສູງຂຶ້ນໃນຫນ່ວຍຄວາມຈໍາ, ຄ່າລົບຍ້າຍຕ່ໍາ.
srec_cat infile - ການປູກພືດ 0x200000 0x300000 -offset −0x200000 \
-o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ຍ້າຍບລັອກ 1MB ຂອງຂໍ້ມູນຢູ່ທີ່ 0x200000 ລົງໄປຫາສູນ (ການຊົດເຊີຍແມ່ນ
ກະທົບທາງລົບ) ແລະຍົກເລີກຂໍ້ມູນສ່ວນທີ່ເຫຼືອ.
ໄບຕ໌ ແລກປ່ຽນປະສົບ
ມີບາງຄັ້ງທີ່ໄບຕ໌ໃນຂໍ້ມູນຕ້ອງຖືກແລກປ່ຽນ, ປ່ຽນລະຫວ່າງໃຫຍ່-
ປົກກະຕິແລ້ວຂໍ້ມູນ endian ແລະ little-endian.
srec_cat infile -byte-swap 4 -o outfile
ອັນນີ້ປີ້ນກັບ bytes ໃນຄ່າ 32 bit (4 bytes). ຄ່າເລີ່ມຕົ້ນ, ຖ້າທ່ານບໍ່ສະຫນອງຄວາມກວ້າງ,
ແມ່ນການປີ້ນ bytes ໃນຄ່າ 16 bit (2 bytes). ທ່ານສາມາດນໍາໃຊ້ທີ່ແທ້ຈິງຄຸນຄ່າ weird ໃດ
ເຊັ່ນວ່າ, ມັນບໍ່ຈໍາເປັນຕ້ອງເປັນພະລັງງານຂອງ 2. ບາງທີ 64 bits (8 bytes) ອາດຈະເປັນປະໂຫຍດ.
ມື້ຫນຶ່ງ.
ຖານສອງ ຜົນຜະລິດ
ທ່ານຈໍາເປັນຕ້ອງໄດ້ສັງເກດເບິ່ງອອກສໍາລັບໄຟລ໌ຖານສອງໃນຜົນຜະລິດ, ເນື່ອງຈາກວ່າຂຸມແມ່ນເຕັມໄປດ້ວຍສູນ.
ໂປລແກລມ 100kB ຂອງທ່ານຢູ່ເທິງສຸດຂອງຫນ່ວຍຄວາມຈໍາ 32-bit ຈະເຮັດໃຫ້ໄຟລ໌ 4GB. ເບິ່ງ
srec_binary(5) ສໍາລັບວິທີການເຂົ້າໃຈແລະຫຼີກເວັ້ນບັນຫານີ້, ປົກກະຕິແລ້ວກັບ - ຊົດເຊີຍ ຕົວກອງ
ການແບ່ງປັນ an ຮູບພາບ
ຖ້າທ່ານມີລົດເມຂໍ້ມູນ 16-bit, ແຕ່ທ່ານກໍາລັງໃຊ້ EPROM ສອງ 8-bit ເພື່ອຖືເຟີມແວຂອງທ່ານ,
ທ່ານສາມາດສ້າງຮູບພາບຄູ່ແລະຄີກໂດຍການນໍາໃຊ້ -SPlit ການກັ່ນຕອງ. ສົມມຸດວ່າຂອງເຈົ້າ
firmware ແມ່ນຢູ່ໃນ firmware.hex ໄຟລ໌, ໃຊ້ດັ່ງຕໍ່ໄປນີ້:
srec_cat firmware.hex -split 2 0 -o firmware.even.hex
srec_cat firmware.hex -split 2 1 -o firmware.odd.hex
ນີ້ຈະສົ່ງຜົນໃຫ້ທັງສອງຮູບພາບ EPROM ທີ່ຈໍາເປັນ. ໃຫ້ສັງເກດວ່າທີ່ຢູ່ຜົນຜະລິດແມ່ນ
ແບ່ງອອກໂດຍການແບ່ງປັນຫຼາຍ, ດັ່ງນັ້ນຖ້າຮູບພາບ EPROM ຂອງເຈົ້າຢູ່ໃນການຊົດເຊີຍສະເພາະ (ເວົ້າ
0x10000, ໃນຕົວຢ່າງຕໍ່ໄປນີ້), ທ່ານຈໍາເປັນຕ້ອງເອົາ offset, ແລະຫຼັງຈາກນັ້ນທົດແທນມັນ ...
srec_cat firmware.hex \
-offset −0x10000 -ແຍກ 2 0 \
-offset 0x10000 -o firmware.even.hex
srec_cat firmware.hex \
-offset −0x10000 -ແຍກ 2 1 \
-offset 0x10000 -o firmware.odd.hex
ໃຫ້ສັງເກດວ່າຄວາມສາມາດໃນການນໍາໃຊ້ຕົວກອງຫຼາຍເຮັດໃຫ້ງ່າຍໃນສິ່ງທີ່ຖ້າບໍ່ດັ່ງນັ້ນຈະມີຫຼາຍ
script ທີ່ຍາວກວ່າ.
ລອກ
ການນໍາໃຊ້ຄັ້ງທີສອງສໍາລັບການ -SPlit ການກັ່ນຕອງແມ່ນແຖບຄວາມຊົງຈໍາ.
ທ່ານບໍ່ ຈຳ ເປັນຕ້ອງແບ່ງອອກເປັນຂະ ໜາດ ກວ້າງ, ທ່ານສາມາດເລືອກຂະ ໜາດ ອື່ນໆໄດ້. ມັນເປັນເລື່ອງທົ່ວໄປທີ່ຈະ
ຕ້ອງການປ່ຽນຂໍ້ມູນກວ້າງ 32-ບິດເປັນສອງຊຸດຂອງຂໍ້ມູນກວ້າງ 16-ບິດ.
srec_cat firmware.hex -split 4 0 2 -o firmware.01.hex
srec_cat firmware.hex -split 4 2 2 -o firmware.23.hex
ນີ້ແມ່ນຂ້ອນຂ້າງເຂົ້າໃຈງ່າຍ, ແຕ່ທ່ານສາມາດນໍາໃຊ້ເສັ້ນດ່າງກວ້າງກວ່າ.
ໃນຕົວຢ່າງຕໍ່ໄປນີ້, ຮາດແວຮຽກຮ້ອງໃຫ້ບລັອກ 512-byte ສະລັບກັນລະຫວ່າງ 4
EPROMs. ການສ້າງ 4 ຮູບພາບຈະເຮັດໄດ້ດັ່ງຕໍ່ໄປນີ້:
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
Asymmetric ລອກ
ຕົວຢ່າງທີ່ແປກປະຫຼາດກວ່າຂອງການລອກລອກແມ່ນ microcontroller Microchip dsPIC33F, ທີ່ມີ
ຮູບແບບການເກັບຮັກສາຄວາມຊົງຈໍາ weird ແລະພວກເຂົາເຈົ້າສາມາດເກັບຮັກສາ 3 bytes ໃນທີ່ຢູ່ທີ່ຄວນຈະ
ມີພຽງ 2 bytes. ຜົນໄດ້ຮັບແມ່ນໄຟລ໌ hex ທີ່ມີສູນເຕັມ byte ເທິງ (ພຽງເລັກນ້ອຍ
endian), ແລະທີ່ຢູ່ທັງຫມົດແມ່ນເພີ່ມຂຶ້ນສອງເທົ່າຈາກສິ່ງທີ່ພວກເຂົາຢູ່ໃນຊິບ. ນີ້ແມ່ນ
ຍົກຕົວຢ່າງ:
S1130000000102000405060008090A000C0D0E0098
S1130010101112001415160018191A001C1D1E00C8
S1130020202122002425260028292A002C2D2E00F8
S1130030303132003435360038393A003C3D3E0028
ເພື່ອກໍາຈັດ 00 padding bytes, ໃຫ້ພຽງແຕ່ 3/4 bytes ທີ່ສໍາຄັນ, ທ່ານຍັງໃຊ້
ການກັ່ນຕອງແບ່ງປັນ, ມີການເພີ່ມເຕີມຂອງຕົນ width ການໂຕ້ຖຽງ, ເຊັ່ນນີ້:
srec_cat example.srec -split 4 0 3 -o no_dross.srec
ອັນນີ້ເຮັດໃຫ້ໄຟລ໌ທີ່ມີ 00 padding bytes ຖືກລຶບອອກ. ມັນເບິ່ງຄືວ່ານີ້:
S113000000010204050608090A0C0D0E1011121451
S1130010151618191A1C1D1E2021222425262829EC
S11300202A2C2D2E30313234353638393A3C3D3E87
ສັງເກດວິທີການທີ່ຢູ່ 3/4 ຂະຫນາດ, ເຊັ່ນດຽວກັນ. ທ່ານສາມາດ reverse ນີ້ໂດຍໃຊ້
- ບໍ່ແບ່ງປັນ ແລະ -fill=0 ຕົວກອງ
ການແຍກ ຮູບພາບ
ການກັ່ນຕອງ unsplit ອາດຈະຖືກນໍາໃຊ້ເພື່ອກັບຄືນຜົນກະທົບຂອງການກັ່ນຕອງແຍກ. ໃຫ້ສັງເກດວ່າ
ໄລຍະທີ່ຢູ່ໄດ້ຖືກຂະຫຍາຍອອກໂດຍເຮັດໃຫ້ຮູລະຫວ່າງເສັ້ນດ່າງ. ໂດຍການນໍາໃຊ້ເສັ້ນດ່າງທັງຫມົດ,
ວັດສະດຸປ້ອນທີ່ສົມບູນໄດ້ຖືກປະກອບຄືນໃໝ່, ໂດຍບໍ່ມີຮູ.
srec_cat -o firmware.hex \
firmware.even.hex -unsplit 2 0 \
firmware.odd.hex -unsplit 2 1
ຕົວຢ່າງຂ້າງເທິງນີ້ກົງກັນຂ້າມກັບຕົວຢ່າງລົດເມຂໍ້ມູນ 16-bit ທີ່ຜ່ານມາ. ໂດຍທົ່ວໄປ, ທ່ານ unsplit
ກັບຕົວກໍານົດການດຽວກັນທີ່ທ່ານແບ່ງປັນກັບ.
FILLING ການ ບລັອກ
ເລື້ອຍໆໄຟລ໌ໂຫລດ EPROM ຈະມີ "ຮູ" ຢູ່ໃນພວກມັນ, ບ່ອນທີ່ລວບລວມແລະຕົວເຊື່ອມຕໍ່ເຮັດ
ບໍ່ໃສ່ຫຍັງ. ສໍາລັບຈຸດປະສົງບາງຢ່າງນີ້ແມ່ນ OK, ແລະສໍາລັບຈຸດປະສົງອື່ນໆບາງສິ່ງບາງຢ່າງຕ້ອງ
ຈະເຮັດໄດ້ກ່ຽວກັບຂຸມ.
ໄດ້ ຕື່ມຂໍ້ມູນໃສ່ ການກັ່ນຕອງ
ມັນເປັນໄປໄດ້ທີ່ຈະຕື່ມຂໍ້ມູນໃສ່ຊ່ອງຫວ່າງທີ່ຂໍ້ມູນຂອງທ່ານບໍ່ໄດ້ນອນ. ຕົວຢ່າງທີ່ງ່າຍດາຍທີ່ສຸດຂອງ
ນີ້ຕື່ມຂໍ້ມູນໃສ່ EPROM ທັງໝົດ:
srec_cat infile -ຕື່ມ 0x00 0x200000 0x300000 -o outfile
ຕົວຢ່າງນີ້ຕື່ມຂໍ້ມູນໃສ່ຂຸມ, ຖ້າມີ, ມີສູນ. ທ່ານຕ້ອງລະບຸຂອບເຂດ - ກັບ a
ພື້ນທີ່ທີ່ຢູ່ 32-bit, ຕື່ມຂໍ້ມູນທຸກຢ່າງທີ່ສ້າງ huge ໂຫຼດໄຟລ໌.
ຖ້າທ່ານຕ້ອງການຕື່ມຊ່ອງຫວ່າງໃນຂໍ້ມູນຂອງທ່ານ, ແລະບໍ່ຕ້ອງການຕື່ມຂໍ້ມູນ EPROM ທັງຫມົດ,
ລອງ:
srec_cat infile -ຕື່ມ 0x00 -over infile -o outfile
ຕົວຢ່າງນີ້ສະແດງໃຫ້ເຫັນເຖິງຄວາມຈິງທີ່ວ່າບ່ອນໃດກໍ່ຕາມຂອບເຂດທີ່ຢູ່ອາດຈະຖືກລະບຸ, the
- ເກີນ ແລະ - ພາຍໃນ ທາງເລືອກອາດຈະຖືກນໍາໃຊ້.
ບໍ່ໄດ້ຕື່ມ ໄດ້ ເປົ່າຫວ່າງ
ມັນເປັນເລື່ອງປົກກະຕິທີ່ຈະຕ້ອງ "ບໍ່ຕື່ມ" ຮູບພາບ EPROM ຫຼັງຈາກທີ່ທ່ານອ່ານມັນອອກຈາກຊິບ. ປົກກະຕິແລ້ວ,
ມັນຈະມີຂຸມທັງຫມົດເຕັມໄປດ້ວຍ 0xFF (ພື້ນທີ່ຂອງ EPROM ທີ່ທ່ານບໍ່ໄດ້ສະແດງໂຄງການ.
ເປັນ 0xFF ເມື່ອທ່ານອ່ານພວກມັນຄືນ).
ເພື່ອກໍາຈັດທຸກ 0xFF bytes ໃນຂໍ້ມູນ, ໃຊ້ຕົວກອງນີ້:
srec_cat infile -unfil 0xFF -o outfile
ນີ້ຈະກໍາຈັດ ທັງຫມົດ 0xFF bytes, ລວມທັງອັນທີ່ເຈົ້າຕ້ອງການຢູ່ໃນນັ້ນ.
ມີສອງວິທີທີ່ຈະຈັດການກັບເລື່ອງນີ້. ກ່ອນອື່ນ ໝົດ, ທ່ານສາມາດ ກຳ ນົດຄວາມຍາວຂອງການແລ່ນຕໍ່າສຸດເພື່ອ
ຍົກເລີກການຕື່ມ:
srec_cat infile -unfil 0xFF 5 -o outfile
ນີ້ບອກວ່າການແລ່ນ 1 ຫາ 4 ໄບຕ໌ຂອງ 0xFF ແມ່ນ OK, ແລະວ່າຄວນສ້າງຂຸມເທົ່ານັ້ນ.
ສໍາລັບການແລ່ນ 5 ຫຼືຫຼາຍກວ່າ 0xFF bytes ຕິດຕໍ່ກັນ. ວິທີທີສອງແມ່ນການຕື່ມຂໍ້ມູນໃສ່
ຊ່ອງຫວ່າງລະຫວ່າງກາງ:
srec_cat outfile - ຕື່ມ 0xFF -over outfile \
-o outfile2
ວິທີທີ່ທ່ານເລືອກແມ່ນຂຶ້ນກັບຄວາມຕ້ອງການຂອງທ່ານ, ແລະຮູບຮ່າງຂອງຂໍ້ມູນໃນ EPROM ຂອງທ່ານ.
ທ່ານອາດຈະຈໍາເປັນຕ້ອງໄດ້ສົມທົບທັງສອງເຕັກນິກ.
ທີ່ຢູ່ ລະດັບ ແຜ່ນຮອງ
ບາງຮູບແບບຂໍ້ມູນມີຄວາມກວ້າງ 16 ບິດ, ແລະຕື່ມຂໍ້ມູນດ້ວຍ 0xFF bytes ໂດຍອັດຕະໂນມັດຖ້າມັນເປັນ
ມີຄວາມຈໍາເປັນເພື່ອຕື່ມຂໍ້ມູນໃສ່ເຄິ່ງຫນຶ່ງຂອງຄໍາທີ່ບໍ່ມີຢູ່ໃນຂໍ້ມູນ. ຖ້າທ່ານຕ້ອງການ
ຕື່ມມູນຄ່າທີ່ແຕກຕ່າງກັນ, ທ່ານສາມາດນໍາໃຊ້ຄໍາສັ່ງເຊັ່ນນີ້:
srec_cat infile - ຕື່ມ 0x0A \
- ພາຍໃນ infile -range-padding 2 \
-o outfile
ນີ້ເຮັດໃຫ້ການກັ່ນຕອງການຕື່ມຂອບເຂດທີ່ຢູ່ຄໍານວນຈາກລາຍລະອຽດຂອງໄຟລ໌ປ້ອນຂໍ້ມູນ.
ຊ່ວງທີ່ຢູ່ແມ່ນຂອບເຂດທີ່ຢູ່ທັງໝົດທີ່ກວມເອົາໂດຍຂໍ້ມູນໃນ infile, ຂະຫຍາຍ
ລົງລຸ່ມ (ຖ້າຈໍາເປັນ) ໃນຕອນເລີ່ມຕົ້ນຂອງແຕ່ລະໄລຍະຍ່ອຍເປັນ 2 byte ຫຼາຍແລະຂະຫຍາຍ
ຂຶ້ນໄປ (ຖ້າຈໍາເປັນ) ໃນຕອນທ້າຍຂອງແຕ່ລະໄລຍະຍ່ອຍໄປຫາຫຼາຍ 2 byte. ນີ້ຍັງເຮັດວຽກ
ສໍາລັບການຄູນຂະຫນາດໃຫຍ່, ເຊັ່ນ: ຂອບເຂດຫນ້າ 1kB ຂອງຊິບແຟດ. ໄລຍະທີ່ຢູ່ນີ້ padding
ເຮັດວຽກຢູ່ບ່ອນໃດກໍໄດ້ທີ່ຕ້ອງການຂອບເຂດທີ່ຢູ່.
ຕື່ມຂໍ້ມູນໃສ່ ກັບ ລິຂະສິດ
ມັນເປັນໄປໄດ້ທີ່ຈະຕື່ມຂໍ້ມູນທີ່ບໍ່ໄດ້ໃຊ້ຂອງ EPROM ຂອງທ່ານດ້ວຍຂໍ້ຄວາມລິຂະສິດທີ່ຊ້ໍາກັນ.
ທຸກຄົນທີ່ພະຍາຍາມປີ້ນກັບວິສະວະກອນ EPROMs ຂອງເຈົ້າແມ່ນຈະເຫັນແຈ້ງການລິຂະສິດໃນ
ບັນນາທິການ hex ຂອງພວກເຂົາ.
ນີ້ແມ່ນສໍາເລັດດ້ວຍສອງແຫຼ່ງປ້ອນຂໍ້ມູນ, ຫນຶ່ງຈາກໄຟລ໌ຂໍ້ມູນ, ແລະຫນຶ່ງທີ່ເປັນ
ສ້າງຂຶ້ນໃນການບິນ.
srec_cat infile \
-generate '(' 0 0x100000 -minus -within infile ')' \
-repeat-string 'ລິຂະສິດ (C) 1812 Tchaikovsky. ' \
-o outfile
ສັງເກດເຫັນໄລຍະທີ່ຢູ່ສໍາລັບການຜະລິດຂໍ້ມູນ: ມັນໃຊ້ເວລາໄລຍະທີ່ຢູ່ຂອງເຈົ້າ
EPROM, ໃນກໍລະນີນີ້ 1MB ເລີ່ມຈາກ 0, ແລະລົບຈາກມັນລະດັບທີ່ຢູ່ທີ່ໃຊ້ໂດຍ
ໄຟລ໌ປ້ອນຂໍ້ມູນ.
ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະສະບັບນີ້ກັບປີປະຈຸບັນ (ເນື່ອງຈາກວ່າ 1812 ລ້າສະໄຫມເລັກນ້ອຍ) ໃຫ້ນໍາໃຊ້
ການທົດແທນຜົນຜະລິດຂອງແກະ (ຫມາຍຕິກກັບຄືນ) ຄວາມສາມາດ:
srec_cat infile \
-generate '(' 0 0x100000 -minus -within infile ')' \
-repeat-string "ລິຂະສິດ (C) `date +%Y` Tchaikovsky." \
-o outfile
ສະຕຣິງທີ່ລະບຸໄວ້ແມ່ນເຮັດຊ້ໍາອີກຄັ້ງ, ຈົນກວ່າມັນຈະເຕັມຂຸມທັງຫມົດ.
ສັບສົນ ກັບ ສຽງ
ບາງຄັ້ງທ່ານຕ້ອງການຕື່ມຮູບພາບ EPROM ຂອງທ່ານດ້ວຍສິ່ງລົບກວນ, ເພື່ອປົກປິດບ່ອນທີ່ຂໍ້ມູນທີ່ແທ້ຈິງ
ຢຸດແລະເລີ່ມຕົ້ນ. ທ່ານສາມາດເຮັດສິ່ງນີ້ໄດ້ກັບ - ການຕື່ມຂໍ້ມູນແບບສຸ່ມ ຕົວກອງ
srec_cat infile - ຕື່ມຂໍ້ມູນແບບສຸ່ມ 0x200000 0x300000 \
-o outfile
ມັນເຮັດວຽກຄືກັນກັບ -ຕື່ມ ການກັ່ນຕອງ, ແຕ່ໃຊ້ຕົວເລກສຸ່ມແທນທີ່ຈະເປັນ byte ຄົງທີ່
ມູນຄ່າ.
ຕື່ມຂໍ້ມູນໃສ່ ກັບ 16-ບິດ ຄໍາສັບຕ່າງໆ
ເມື່ອຕື່ມຮູບພາບດ້ວຍຄ່າຄົງທີ່ byte ບໍ່ເຮັດວຽກ, ແລະທ່ານຕ້ອງການຄົງທີ່
ຄ່າ 16-bit ແທນ, ໃຊ້ - ຊ້ຳຄືນຂໍ້ມູນ generator, ເຊິ່ງໃຊ້ເວລາເປັນ arbitrarily ຍາວ
ລໍາດັບຂອງ bytes ເພື່ອໃຊ້ເປັນຮູບແບບການຕື່ມ:
srec_cat infile \
-generator '(' 0x200000 0x300000 -ລົບ -ພາຍໃນ infile ')' \
- ຂໍ້ມູນຊ້ຳຄືນ 0x1B 0x08 \
-o outfile
ສັງເກດເຫັນວ່າໄລຍະທີ່ຢູ່ຂອງເຄື່ອງກໍາເນີດໄຟຟ້າອີກເທື່ອຫນຶ່ງຫລີກລ້ຽງຂອບເຂດທີ່ຢູ່ທີ່ຖືກຄອບຄອງໂດຍ
ໄດ້ infileຂໍ້ມູນຂອງ. ທ່ານຕ້ອງໄດ້ຮັບ endian-ness ຖືກຕ້ອງຕົວທ່ານເອງ.
ການແຊກໃສ່ ໝັ້ນ ຄົງ ຂໍ້ມູນ
ຈາກເວລາໃດຫນຶ່ງທີ່ທ່ານຈະຕ້ອງການທີ່ຈະໃສ່ຂໍ້ມູນຄົງທີ່, ຫຼືຂໍ້ມູນທີ່ບໍ່ໄດ້ຜະລິດໂດຍຂອງທ່ານ
compiler ຫຼື assembler, ເຂົ້າໄປໃນຮູບພາບການໂຫຼດ EPROM ຂອງທ່ານ.
ຖານສອງ ຫມາຍຄວາມວ່າ ຮູ້ຫນັງສື
ວິທີທີ່ງ່າຍດາຍຫນຶ່ງແມ່ນມີຂໍ້ມູນທີ່ຕ້ອງການໃນໄຟລ໌. ເພື່ອໃສ່ໄຟລ໌
ເນື້ອໃນທີ່ຮູ້ຫນັງສື, ໂດຍບໍ່ມີການຕີຄວາມຫມາຍຮູບແບບ, ໃຊ້ binary ຮູບແບບການປ້ອນຂໍ້ມູນ:
srec_cat infile -binary -o outfile
ມັນອາດຈະເປັນສິ່ງທີ່ຈໍາເປັນທີ່ຈະໃຊ້ ຊົດເຊີຍ ການກັ່ນຕອງເພື່ອຍ້າຍຂໍ້ມູນໄປບ່ອນທີ່ທ່ານ
ຕົວຈິງແລ້ວຕ້ອງການມັນຢູ່ໃນຮູບພາບ:
srec_cat infile -binary -offset 0x1234 -o outfile
ມັນຍັງເປັນໄປໄດ້ທີ່ຈະໃຊ້ວັດສະດຸປ້ອນມາດຕະຖານເປັນແຫຼ່ງຂໍ້ມູນ, ເຊິ່ງໃຫ້ຕົວເອງ
ກຳລັງຂຽນບົດ. ຕົວຢ່າງ, ເພື່ອໃສ່ວັນທີແລະເວລາປະຈຸບັນເຂົ້າໄປໃນໄຟລ໌ໂຫລດ EPROM,
ທ່ານສາມາດນໍາໃຊ້ທໍ່:
ວັນທີ | srec_cat - -bin -offset 0xFFE3 -o outfile
ຊື່ໄຟລ໌ພິເສດ “-” ຫມາຍເຖິງການອ່ານຈາກວັດສະດຸປ້ອນມາດຕະຖານ. ຜົນຜະລິດຂອງ ວັນ
ຄໍາສັ່ງແມ່ນສະເຫມີໄປມີຄວາມຍາວ 29 ຕົວອັກສອນ, ແລະການຊົດເຊີຍທີ່ສະແດງໃຫ້ເຫັນຈະວາງໄວ້ເທິງຂອງ a
ຮູບ 64KB EPROM.
ຊ້ ຳ ເມື່ອໃດທີ່
ໄດ້ ຕື່ມຂໍ້ມູນໃສ່ ກັບ ລິຂະສິດ ພາກສ່ວນ, ຂ້າງເທິງ, ສະແດງວິທີການເຮັດເລື້ມຄືນ string ເລື້ອຍໆ. ພວກເຮົາ
ສາມາດໃຊ້ການຊ້ໍາດຽວເພື່ອໃສ່ສະຕຣິງພຽງແຕ່ຄັ້ງດຽວ.
srec_cat -ສ້າງ 0xFFE3 0x10000 -repeat-string "`date`" \
-o outfile
ສັງເກດເຫັນວ່າໄລຍະທີ່ຢູ່ສໍາລັບການຜະລິດຂໍ້ມູນກົງກັບຄວາມຍາວຂອງຂໍ້ມູນແນວໃດ
ວັນ(1) ຂະຫນາດຜົນຜະລິດ. ທ່ານສາມາດ, ແນ່ນອນ, ເພີ່ມໄຟລ໌ປ້ອນຂໍ້ມູນຂອງທ່ານໃສ່ຂ້າງເທິງ srec_cat(1)
ຄໍາສັ່ງເພື່ອກໍານົດຮູບພາບ EPROM ຂອງທ່ານພ້ອມກັບວັນທີແລະເວລາ.
ການແຊກ A Long
ຄວາມເປັນໄປໄດ້ອີກຢ່າງຫນຶ່ງແມ່ນການເພີ່ມຕົວເລກສັນຍາການໂຄ່ນລົ້ມລົງໃສ່ຮູບພາບ EPROM ຂອງທ່ານ. ໃນນີ້
ຕົວຢ່າງ, ພວກເຮົາກໍາລັງໃສ່ມັນ aa 4-byte little-endian value at address 0x0008. ໄດ້
ຈໍານວນຄໍາຫມັ້ນສັນຍາການໂຄ່ນລົ້ມແມ່ນຢູ່ໃນ $ຮຸ່ນ ຕົວແປຂອງ shell ໃນຕົວຢ່າງນີ້:
srec_cat -generate 0x0008 0x000C -l-e-constant $version 4 \
infile - ບໍ່ລວມ 0x0008 0x000C \
-o outfile
ຈົ່ງຈື່ໄວ້ວ່າພວກເຮົາໃຊ້ຕົວກອງເພື່ອຮັບປະກັນວ່າມີຂຸມຢູ່ໃນວັດສະດຸປ້ອນບ່ອນທີ່ຫມາຍເລກຮຸ່ນ
ໄປ, ພຽງແຕ່ໃນກໍລະນີທີ່ຕົວເຊື່ອມຕໍ່ໃສ່ບາງສິ່ງບາງຢ່າງຢູ່ທີ່ນັ້ນ.
ຂໍ້ມູນ ກ່ຽວກັບ ການ ຂໍ້ມູນ
ມັນເປັນໄປໄດ້ທີ່ຈະເພີ່ມຄວາມຫລາກຫລາຍຂອງຂໍ້ມູນກ່ຽວກັບຂໍ້ມູນເຂົ້າໃນຜົນຜະລິດ.
ກວດສອບ
ໄດ້ -big-endian-checksum-ລົບ ການກັ່ນຕອງອາດຈະຖືກນໍາໃຊ້ເພື່ອສະຫຼຸບຂໍ້ມູນ, ແລະຫຼັງຈາກນັ້ນໃສ່
ລົບຂອງຜົນລວມເຂົ້າໄປໃນຂໍ້ມູນ. ນີ້ມີຜົນກະທົບຂອງການລວມສູນໃນເວລາທີ່
checksum ຕົວຂອງມັນເອງແມ່ນລວມເຂົ້າກັນ, ໃຫ້ຄວາມກວ້າງລວມກົງກັບຄວາມກວ້າງຂອງມູນຄ່າທີ່ໃສ່.
srec_cat infile \
- ການປູກພືດ 0 0xFFFFFC \
- ຕື່ມຂໍ້ມູນແບບສຸ່ມ 0 0xFFFFFC \
-b-e-checksum-neg 0xFFFFFC 4 4 \
-o outfile
ໃນຕົວຢ່າງນີ້, ພວກເຮົາມີ EPROM ໃນ megabyte ຕ່ໍາສຸດຂອງຫນ່ວຍຄວາມຈໍາ. ການກັ່ນຕອງການປູກພືດ
ໃຫ້ແນ່ໃຈວ່າພວກເຮົາພຽງແຕ່ສະຫຼຸບຂໍ້ມູນພາຍໃນ EPROM, ແລະບໍ່ແມ່ນບ່ອນອື່ນ. ໄດ້
-random-fill filter ຕື່ມຂໍ້ມູນໃສ່ຮູທີ່ເຫຼືອຢູ່ໃນຂໍ້ມູນດ້ວຍຄ່າສຸ່ມ. ໃນທີ່ສຸດ, -b.
e-checksum-neg filter ໃສ່ checksum 32 bit (4 byte) ໃນຮູບແບບ big-endian ໃນຮູບແບບສຸດທ້າຍ
4 bytes ຂອງຮູບ EPROM. ຕາມທໍາມະຊາດ, ມີສະບັບ endian ພຽງເລັກນ້ອຍຂອງການກັ່ນຕອງນີ້ເປັນ
ດີ.
ລະຫັດຝັງຂອງທ່ານສາມາດກວດສອບ EPROM ໂດຍໃຊ້ລະຫັດ C ທີ່ຄ້າຍຄືກັບຕໍ່ໄປນີ້:
unsigned long *begin = (unsigned long *)0;
unsigned long *end = (unsigned long *)0x100000;
unsigned long sum = 0;
ໃນຂະນະທີ່ (ເລີ່ມຕົ້ນ <ສິ້ນສຸດ)
sum += *ເລີ່ມຕົ້ນ++;
ຖ້າ (ລວມ != 0)
{
ອຸ່ຍ
}
ໄດ້ -big-endian-checksum-bitnot ການກັ່ນຕອງແມ່ນຄ້າຍຄືກັນ, ຍົກເວັ້ນວ່າສະຫຼຸບຫຼາຍກວ່າ checksum
ຄວນໃຫ້ຄ່າຂອງທັງໝົດ-one-bits (−1). ສໍາລັບຕົວຢ່າງ, ການນໍາໃຊ້ສັ້ນແທນທີ່ຈະຍາວ:
srec_cat infile \
- ການປູກພືດ 0 0xFFFFFE \
- ຕື່ມ 0xCC 0x00000 0xFFFFFE \
-b-e-checksum-neg 0xFFFFFE 2 2 \
-o outfile
ສົມມຸດວ່າທ່ານເລືອກຕົວກອງ endian-ness ທີ່ຖືກຕ້ອງ, ລະຫັດຝັງຂອງທ່ານສາມາດກວດເບິ່ງ EPROM
ການນໍາໃຊ້ລະຫັດ C ຄ້າຍຄືກັນກັບດັ່ງຕໍ່ໄປນີ້:
unsigned short *begin = (unsigned short *)0;
unsigned short *end = (unsigned short *)0x100000;
unsigned short sum = 0;
ໃນຂະນະທີ່ (ເລີ່ມຕົ້ນ <ສິ້ນສຸດ)
sum += *ເລີ່ມຕົ້ນ++;
ຖ້າ (ລວມ != 0xFFFF)
{
ອຸ່ຍ
}
ນອກນັ້ນຍັງມີ -b-e-checksum-ບວກ ການກັ່ນຕອງ, ແລະຕົວກອງນ້ອຍ-endian ທີ່ກົງກັນ, ເຊິ່ງ
ໃສ່ຜົນລວມທີ່ງ່າຍດາຍ, ແລະອັນໃດຈະຖືກກວດສອບໃນ C ໂດຍໃຊ້ການທົດສອບຄວາມສະເໝີພາບ.
srec_cat infile \
- ປູກພືດ 0 0xFFFFFF \
- ຕື່ມ 0x00 0x00000 0xFFFFFF \
-b-e-checksum-neg 0xFFFFFF 1 1 \
-o outfile
ສົມມຸດວ່າທ່ານເລືອກຕົວກອງ endian-ness ທີ່ຖືກຕ້ອງ, ລະຫັດຝັງຂອງທ່ານສາມາດກວດເບິ່ງ EPROM
ການນໍາໃຊ້ລະຫັດ C ຄ້າຍຄືກັນກັບດັ່ງຕໍ່ໄປນີ້:
unsigned char *begin = (unsigned char *)0;
unsigned char *end = (unsigned char *)0xFFFFF;
unsigned char sum = 0;
ໃນຂະນະທີ່ (ເລີ່ມຕົ້ນ <ສິ້ນສຸດ)
sum += *ເລີ່ມຕົ້ນ++;
ຖ້າ (sum != *end)
{
ອຸ່ຍ
}
ໃນກໍລະນີ 8-bit, ມັນບໍ່ສໍາຄັນວ່າທ່ານໃຊ້ big-endian ຫຼື little-endian
ຕົວກອງ
ດ່ວນ Hex-Dump
ທ່ານສາມາດເບິ່ງ checksum ຂອງຂໍ້ມູນຂອງທ່ານ, ໂດຍໃຊ້ຮູບແບບຜົນຜະລິດ "hex-dump". ນີ້ແມ່ນ
ເປັນປະໂຫຍດສໍາລັບການເບິ່ງຄ່າທີ່ຄິດໄລ່, ຫຼືສໍາລັບການ debugging an srec_cat(1) ຄໍາສັ່ງກ່ອນ
immortalizing ມັນຢູ່ໃນສະຄິບ.
srec_cat infile \
- ການປູກພືດ 0 0x10000 \
- ຕື່ມ 0xFF 0x0000 0x10000 \
-b-e-checksum-neg 0x10000 4 \
- ການປູກພືດ 0x10000 0x10004 \
-o - -hex-dump
ຄໍາສັ່ງນີ້ອ່ານຢູ່ໃນໄຟລ໌, checksums ຂໍ້ມູນແລະວາງ checksum ຢູ່ 0x10000,
ປູກພືດຜົນໃຫ້ມີພຽງແຕ່ checksum, ແລະຫຼັງຈາກນັ້ນພິມ checksum ເທິງ
ຜົນຜະລິດມາດຕະຖານໃນຮູບແບບ dump hexadecimal ຄລາສສິກ. ຊື່ໄຟລ໌ພິເສດ "-" ຫມາຍຄວາມວ່າ
"ຜົນຜະລິດມາດຕະຖານ" ໃນສະພາບການນີ້.
ວົງຈອນ Redundancy ການກວດສອບ
checksums ເພີ່ມເຕີມງ່າຍດາຍມີຈໍານວນຂອງຂໍ້ຈໍາກັດທາງທິດສະດີ, ທີ່ຈະເຮັດກັບຄວາມຜິດພາດ
ພວກເຂົາເຈົ້າສາມາດແລະບໍ່ສາມາດກວດພົບ. ວິທີການ CRC ມີບັນຫາຫນ້ອຍລົງ.
srec_cat infile \
- ການປູກພືດ 0 0xFFFFFC \
- ຕື່ມ 0x00 0x00000 0xFFFFFC \
-b-e-crc32 0xFFFFFC \
-o outfile
ໃນຕົວຢ່າງຂ້າງເທິງ, ພວກເຮົາມີ EPROM ໃນ megabyte ຕ່ໍາສຸດຂອງຫນ່ວຍຄວາມຈໍາ. ໄດ້ - ການປູກພືດ ການກັ່ນຕອງ
ໃຫ້ແນ່ໃຈວ່າພວກເຮົາພຽງແຕ່ສະຫຼຸບຂໍ້ມູນພາຍໃນ EPROM, ແລະບໍ່ແມ່ນບ່ອນອື່ນ. ໄດ້ -ຕື່ມ
ການກັ່ນຕອງຕື່ມຂໍ້ມູນໃສ່ຮູທີ່ເຫຼືອຢູ່ໃນຂໍ້ມູນ. ສຸດທ້າຍ, ໄດ້ -b-e-checksum-neg ການກັ່ນຕອງໃສ່ a
32 bit (4 byte) checksum ໃນຮູບແບບ big-endian ໃນ 4 bytes ສຸດທ້າຍຂອງຮູບ EPROM.
ຕາມທໍາມະຊາດ, ມີສະບັບ endian ພຽງເລັກນ້ອຍຂອງການກັ່ນຕອງນີ້ເຊັ່ນດຽວກັນ.
checksum ຖືກຄິດໄລ່ໂດຍໃຊ້ CRC 32-bit ມາດຕະຖານອຸດສາຫະກໍາ. ເນື່ອງຈາກວ່າ SRecord ແມ່ນ
open source, ເຈົ້າສາມາດອ່ານລະຫັດແຫຼ່ງໄດ້ຕະຫຼອດເວລາເພື່ອເບິ່ງວ່າມັນເຮັດວຽກແນວໃດ. ມີຈໍານວນຫຼາຍທີ່ບໍ່ແມ່ນ
ຮຸ່ນ GPL ຂອງລະຫັດນີ້ມີຢູ່ໃນອິນເຕີເນັດ, ແລະເຫມາະສົມສໍາລັບການຝັງຢູ່ໃນ
ເຟີມແວທີ່ເປັນເຈົ້າຂອງ.
ນອກນັ້ນຍັງມີ 16-bit CRC ທີ່ມີຢູ່.
srec_cat infile \
- ການປູກພືດ 0 0xFFFFFE \
- ຕື່ມ 0x00 0x00000 0xFFFFFE \
-b-e-crc16 0xFFFFFE \
-o outfile
checksum ຖືກຄິດໄລ່ໂດຍໃຊ້ສູດ CCITT. ເນື່ອງຈາກວ່າ SRecord ເປັນແຫຼ່ງເປີດ, ທ່ານ
ສາມາດອ່ານລະຫັດແຫຼ່ງເພື່ອເບິ່ງວ່າມັນເຮັດວຽກໄດ້ແນວໃດ. ມີຫຼາຍລຸ້ນທີ່ບໍ່ແມ່ນ GPL ຂອງ
ລະຫັດນີ້ມີຢູ່ໃນອິນເຕີເນັດ, ແລະເຫມາະສົມສໍາລັບການຝັງຢູ່ໃນເຟີມແວທີ່ເປັນເຈົ້າຂອງ.
ທ່ານສາມາດເບິ່ງ CRC ຂອງຂໍ້ມູນຂອງທ່ານ, ໂດຍໃຊ້ຮູບແບບຜົນຜະລິດ "hex-dump".
srec_cat infile \
- ການປູກພືດ 0 0x10000 \
- ຕື່ມ 0xFF 0x0000 0x10000 \
-b-e-crc16 0x10000 \
- ການປູກພືດ 0x10000 0x10002 \
-o - -hex-dump
ຄໍາສັ່ງນີ້ອ່ານຢູ່ໃນໄຟລ໌, ຄິດໄລ່ CRC ຂອງຂໍ້ມູນແລະວາງ CRC ຢູ່
0x10000, ຕັດຜົນໄດ້ຮັບເພື່ອໃຫ້ມີ CRC ເທົ່ານັ້ນ, ແລະຫຼັງຈາກນັ້ນພິມ checksum ເທິງ.
ຜົນຜະລິດມາດຕະຖານໃນຮູບແບບ dump hexadecimal ຄລາສສິກ.
ບ່ອນທີ່ Is My ຂໍ້ມູນ?
ມີຫຼາຍຄຸນສົມບັດຂອງຮູບພາບ EPROM ຂອງທ່ານທີ່ທ່ານອາດຈະຕ້ອງການທີ່ຈະໃສ່ເຂົ້າໄປໃນ
ຂໍ້ມູນ.
srec_cat infile -b-e-ຂັ້ນຕ່ຳ 0xFFFE 2 -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ໃສ່ທີ່ຢູ່ຕໍາ່ສຸດທີ່ຂອງຂໍ້ມູນ (ຕ່ໍາ ນ້ໍາ) ເຂົ້າໄປໃນຂໍ້ມູນ, ເປັນ
ສອງ bytes ໃນຄໍາສັ່ງ big-endian ທີ່ຢູ່ 0xFFFE. ນີ້ປະກອບມີຕໍາ່ສຸດທີ່ຕົວຂອງມັນເອງ. ຖ້າ
ຂໍ້ມູນມີໄບຕ໌ຢູ່ໃນທີ່ຢູ່ທີ່ລະບຸໄວ້ແລ້ວ, ທ່ານຈໍາເປັນຕ້ອງໃຊ້ຕົວກອງຍົກເວັ້ນ.
ຈຳນວນຂອງໄບຕ໌ຕັ້ງໄວ້ເປັນ 4.
ນອກນັ້ນຍັງມີ -l-e-ຕໍາ່ສຸດ ການກັ່ນຕອງສໍາລັບການໃສ່ຄ່າ little-endian, ແລະອີກສອງອັນ
ການກັ່ນຕອງເອີ້ນວ່າ -b-e-exclusive-ຕໍ່າສຸດ ແລະ -l-e-exclusive-ຕໍາ່ສຸດທີ່ ທີ່ບໍ່ປະກອບມີ
ຕໍາ່ສຸດທີ່ຕົວຂອງມັນເອງໃນການຄິດໄລ່ທີ່ຢູ່ຂໍ້ມູນຕໍາ່ສຸດທີ່.
srec_cat infile -b-e-ສູງສຸດ 0xFFFFFC 4 -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ໃສ່ທີ່ຢູ່ສູງສຸດຂອງຂໍ້ມູນ (ສູງ ນ້ໍາ + 1, ຄືກັນກັບ
ຊ່ວງທີ່ຢູ່) ເຂົ້າໄປໃນຂໍ້ມູນ, ເປັນສີ່ bytes ໃນຄໍາສັ່ງ big-endian ທີ່ທີ່ຢູ່ 0xFFFFFC.
ນີ້ປະກອບມີສູງສຸດຂອງມັນເອງ. ຖ້າຂໍ້ມູນມີໄບຕ໌ຢູ່ແລ້ວ
ທີ່ຢູ່, ທ່ານຈໍາເປັນຕ້ອງໃຊ້ - ຍົກເວັ້ນ ການກັ່ນຕອງ. ຈຳນວນຂອງໄບຕ໌ຕັ້ງໄວ້ເປັນ 4.
ນອກນັ້ນຍັງມີ -l-e-ສູງສຸດ ການກັ່ນຕອງສໍາລັບການໃສ່ຄ່າ little-endian, ແລະອີກສອງອັນ
ການກັ່ນຕອງເອີ້ນວ່າ -b-e-exclusive-ສູງສຸດ ແລະ -l-e-exclusive-ສູງສຸດ ທີ່ບໍ່ປະກອບມີ
ສູງສຸດຂອງມັນເອງໃນການຄິດໄລ່ທີ່ຢູ່ຂໍ້ມູນສູງສຸດ.
srec_cat infile -b-e-length 0xFFFFFC 4 -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ໃສ່ຄວາມຍາວຂອງຂໍ້ມູນ (ສູງ ນ້ໍາ + 1 − ຕ່ໍາ ນ້ໍາ) ເຂົ້າໄປໃນ
ຂໍ້ມູນ, ເປັນສີ່ bytes ໃນຄໍາສັ່ງ big-endian ທີ່ຢູ່ 0xFFFFFC. ນີ້ປະກອບມີຄວາມຍາວ
ຕົວຂອງມັນເອງ. ຖ້າຂໍ້ມູນມີໄບຕ໌ຢູ່ບ່ອນຕັ້ງຄວາມຍາວ, ເຈົ້າຕ້ອງໃຊ້ອັນ
- ຍົກເວັ້ນ ການກັ່ນຕອງ. ຈຳນວນຂອງໄບຕ໌ຕັ້ງໄວ້ເປັນ 4.
ນອກນັ້ນຍັງມີ -l-e-ຄວາມຍາວ ການກັ່ນຕອງສໍາລັບການໃສ່ຄວາມຍາວພຽງເລັກນ້ອຍ-endian, ແລະ -b-e-
ຄວາມຍາວສະເພາະ ແລະ -l-e-exclusive-length ຕົວກອງທີ່ບໍ່ປະກອບມີຄວາມຍາວຂອງມັນເອງ
ໃນການຄິດໄລ່.
ແມ່ນຫຍັງ ຮູບແບບ Is ນີ້ບໍ?
ທ່ານສາມາດໄດ້ຮັບຄວາມຫຼາກຫຼາຍຂອງຂໍ້ມູນກ່ຽວກັບໄຟລ໌ການໂຫຼດ EPROM ໂດຍການນໍາໃຊ້ srec_info(1)
ຄໍາສັ່ງ. ຍົກຕົວຢ່າງ:
$ srec_info example.srec
ຮູບແບບ: Motorola S-Record
ສ່ວນຫົວ: "http://srecord.sourceforge.net/"
ທີ່ຢູ່ເລີ່ມຕົ້ນຂອງການປະຕິບັດ: 00000000
ຂໍ້ມູນ: 0000 - 0122
0456 - 0FFF
$
ຕົວຢ່າງນີ້ສະແດງໃຫ້ເຫັນວ່າໄຟລ໌ແມ່ນ Motorola S-Record. ຂໍ້ຄວາມຢູ່ໃນສ່ວນຫົວຂອງໄຟລ໌ແມ່ນ
ພິມ, ພ້ອມກັບທີ່ຢູ່ເລີ່ມຕົ້ນການປະຕິບັດ. ພາກສຸດທ້າຍສະແດງໃຫ້ເຫັນທີ່ຢູ່
ຊ່ວງທີ່ມີຂໍ້ມູນ (ຂອບເຂດເທິງຂອງແຕ່ລະໄລຍະຍ່ອຍແມ່ນ inລວມ, ແທນທີ່ຈະກ່ວາ
exຮູບແບບສະເພາະທີ່ໃຊ້ໃນແຖວຄໍາສັ່ງ.
$ srec_info some-weird-file.hex - ເດົາ
ຮູບແບບ: Signetics
ຂໍ້ມູນ: 0000 - 0122
0456 - 0FFF
$
ຕົວຢ່າງຂ້າງເທິງນີ້ຄາດເດົາຮູບແບບໄຟລ໌ໂຫລດ EPROM. ມັນບໍ່ແມ່ນຄວາມຜິດພາດແຕ່ມັນປົກກະຕິແລ້ວ
ໄດ້ຮັບມັນຖືກຕ້ອງ. ທ່ານສາມາດນໍາໃຊ້ - ເດົາ ທຸກບ່ອນທີ່ເຈົ້າຈະໃຫ້ຮູບແບບທີ່ຊັດເຈນ, ແຕ່ມັນ
ແນວໂນ້ມທີ່ຈະຊ້າກວ່າແລະສໍາລັບເຫດຜົນນັ້ນບໍ່ໄດ້ຖືກແນະນໍາ. ນອກຈາກນີ້, ສໍາລັບການກໍ່ສ້າງອັດຕະໂນມັດ
ລະບົບ, ທ່ານຕ້ອງການຄວາມຜິດພາດຍາກໄວເທົ່າທີ່ຈະໄວໄດ້; ຖ້າໄຟລ໌ບໍ່ຢູ່ໃນທີ່ຄາດໄວ້
ຮູບແບບ, ທ່ານຕ້ອງການມັນ barf.
ການຈັດການ ການ ຂໍ້ມູນ
ມັນເປັນໄປໄດ້ທີ່ຈະປ່ຽນຄ່າຂອງ bytes ຂໍ້ມູນໃນຫຼາຍວິທີ.
srec_cat infile -ແລະ 0xF0 -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ປະຕິບັດ AND ຂອງໄບຕ໌ຂໍ້ມູນເລັກນ້ອຍທີ່ສະຫລາດກັບຫນ້າກາກ 0xF0. ໄດ້
ທີ່ຢູ່ຂອງບັນທຶກບໍ່ປ່ຽນແປງ. ຕົວຈິງແລ້ວຂ້ອຍບໍ່ສາມາດຄິດເຖິງການນໍາໃຊ້ຕົວກອງນີ້.
srec_cat infile -ຫຼື 0x0F -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ປະຕິບັດ OR ຂອງໄບຕ໌ຂໍ້ມູນທີ່ມີຄວາມສະຫລາດເລັກນ້ອຍດ້ວຍ 0x0F bits. ໄດ້
ທີ່ຢູ່ຂອງບັນທຶກບໍ່ປ່ຽນແປງ. ຕົວຈິງແລ້ວຂ້ອຍບໍ່ສາມາດຄິດເຖິງການນໍາໃຊ້ຕົວກອງນີ້.
srec_cat infile -xor 0xA5 -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ປະຕິບັດ OR ສະເພາະຂອງ bytes ຂໍ້ມູນທີ່ມີ 0xA5 bits.
ທີ່ຢູ່ຂອງບັນທຶກບໍ່ປ່ຽນແປງ. ທ່ານສາມາດນໍາໃຊ້ນີ້ເພື່ອເຮັດໃຫ້ຜິດພາດເນື້ອໃນຂອງ
EPROM ຂອງທ່ານ.
srec_cat infile - ບໍ່ -o outfile
ຕົວຢ່າງຂ້າງເທິງນີ້ປະຕິບັດບໍ່ສະຫລາດເລັກນ້ອຍຂອງໄບຕ໌ຂໍ້ມູນ. ທີ່ຢູ່ຂອງບັນທຶກແມ່ນ
ບໍ່ປ່ຽນແປງ. ຄວາມປອດໄພໂດຍຄວາມມືດ?
COPYRIGHT
srec_cat 1.58 Version
ສະຫງວນລິຂະສິດ (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
2010, 2011 Peter Miller
ໄດ້ srec_cat ໂຄງການມາພ້ອມກັບການຮັບປະກັນຢ່າງແທ້ຈິງ; ສໍາລັບລາຍລະອຽດ, ການນໍາໃຊ້ 'srec_cat
-VERSion ໃບອະນຸຍາດ' ຄໍາສັ່ງ. ນີ້ແມ່ນຊອບແວຟຣີແລະທ່ານຍິນດີຕ້ອນຮັບທີ່ຈະແຈກຢາຍມັນ
ພາຍໃຕ້ເງື່ອນໄຂສະເພາະໃດຫນຶ່ງ; ສໍາລັບລາຍລະອຽດ, ການນໍາໃຊ້ 'srec_cat -VERSion ໃບອະນຸຍາດ' ຄໍາສັ່ງ.
ໃຊ້ srec_examples ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
