blocks|key|2989879|text|如果您可以节省256字节的额外代码大小，查找表可能是在68HCS12上反转字节的最有效的方法。但我很确定这不是你的讲师所期望的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2989880|对于“正常”的解决方案，请单独考虑数据位。旋转和平移允许您移动比特。对于第一种解决方案，隔离8位(使用逐位“与”运算)，将它们移动到其目标位置(移位、旋转……)，然后再次将它们组合在一起(使用逐位“或”运算)。这不是最有效或最简单的实现，但您应该首先专注于获得正确的结果--优化可以等待。|2989881|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If you can spare the 256 bytes extra code size, a lookup table is probably the most efficient way to reverse a byte on a 68HCS12. But I am pretty sure this is not what your instructor is expecting.

For the "normal" solution, consider the data bits individually. Rotates and shifts allow you to move bits around. For a first solution, isolate the eight bits (with bitwise "and" operations), move them to their destination positions (shifts, rotates...), then combine them together again (with bitwise "or" operations). This will not be the most efficient or simplest implementation, but you should first concentrate on getting a correct result -- optimization can wait.

blocks|key|922304|text|提示:如果你做移位，一位被移出，一个零(可能)被移入。那个移出的比特去了哪里？您需要将其移入目标寄存器或内存地址的另一端。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|922305|我确信25年前，我可以在没有汇编程序的情况下用Z80机器码做到这一点:)|922306|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Hints: If you do a shift, one bit gets shifted out and a zero (probably) gets shifted in. Where does that shifted out bit go to? You need to shift that in to the other end of the destination register or memory address.

I'm sure that 25 years ago I could do this in Z80 machine code without an assembler :)

blocks|key|922225|text|将两个寄存器视为位堆栈。如果一次移动一个比特到另一个比特，会发生什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|922226|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider two registers as stacks of bits. What happens if you move one bit at a time from one to another?

blocks|key|4589235|text|当你做右移位时，最低有效位进入进位标志。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4589236|进行轮换时，进位标志用于填充结果的空位(LSB表示ROL，MSB表示ROR)。|4589237|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When you do a right shift, what was the least significant bit goes into the carry flag.

When you do a rotate, the carry flag is used to fill in the vacated bit of the result (LSB for a ROL, MSB for a ROR).

blocks|key|1813753|text|最重要的是，FIrst为你需要做的事情找出了算法。把它表达成伪代码，或者C语言，或者简单的英语，或者图表，或者你喜欢的任何东西。一旦你清除了这个概念上的障碍，实际的实现应该是相当简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1813754|您的CPU可能具有允许您移位和/或旋转寄存器的指令，可能包括进位标志作为附加位。这些说明将非常有用。|1813755|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

FIrst of all work out the algorithm for doing what you need to do. Express it as pseudo code or C or plain English or diagrams or whatever you are comfortable with. Once you have cleared this conceptual hurdle the actual implementation should be quite simple.

Your CPU probably has instructions which let you shift and/or rotate a register, perhaps including the carry flag as an additional bit. These instructions will be very useful.

blocks|key|922479|text|例如，如果在al中包含字节数，则最简单的方法是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|922480|mov+al,+10101110
mov+ecx,+8|code-block|syntax|javascript|922481|我们在ecx+for循环中放入8|922482|mov+ebx,+0+|922483|在bl中，我们会有结果，我们会制作ebx，只是为了看看什么会发生得更好。|922484|loop1:
sal+al,+1;+++++++++++|922485|在进位标志中，现在你有了左数的最后一位|922486|rcr+bl,+1;+++++++++++|922487|现在在bl中添加进位中已有的内容。|922488|loop+loop1|922489|仅此而已|922490|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

For example, if you have in al the byte number the easiest way is

<pre><code>mov al, 10101110
mov ecx, 8
</code></pre>

we put 8 in ecx for loop

<pre><code>mov ebx, 0 
</code></pre>

In bl we will havee the result, we will make ebx, only to see what happens better

<pre><code>loop1:
sal al, 1; 
</code></pre>

In carry flag now you have the last bit from left

<pre><code>rcr bl, 1; 
</code></pre>

now you add in bl what you have in carry

<pre><code>loop loop1
</code></pre>

and that's all

blocks|key|1810801|text|这是一个评论，但我想！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1810802|为了节省256字节表的空间，您可以使用一个16字节表，一次包含4位(半字节)的值。然后，算法将是|1810803|revval=(revdigit[inval&0x0f]<<4)%7C
++++++++revdigit[inval>>4];|code-block|syntax|javascript|1810804|如果我是一个教授，我肯定会喜欢这两个部分，一个移位在索引中，另一个在索引之外。|1810805|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This was a comment but I thought WTH!

To save space over the 256 byte table you can have a 16 byte table containing the values for four bits (nibbles) at a time. The algorithm then would be

<pre><code>revval=(revdigit[inval&amp;0x0f]&lt;&lt;4)|
 revdigit[inval&gt;&gt;4];
</code></pre>

If I were a prof I'd certainly like the two parts where one shift is in the indexing and the other outside.

blocks|key|922436|text|我还不得不为大学编程这个位(8位)。下面是我是如何做到的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|922437|MOV+AL,+10001011B+;set+the+value+to+test
MOV+CL,+7
MOV+DH,+1
MOV+DL,+0

loop1:+PUSH+AX
AND+AL,+DH+
PUSH+CX
MOV+CL,+DL
SHR+AL,+CL
POP+CX
MOV+BH,+AL
SHL+BH,CL
OR+CH,BH
DEC+CL
INC+DL
SHL+DH,+1
POP+AX
CMP+DL,+8
JE+END
JMP+LOOP1

END:|code-block|syntax|javascript|922438|我没有注释它，所以它是这样工作的:+DH是一个像first+time一样在字节中遍历的1：00000001；second+time00000010等等。当你使用AL创建AND时，你会得到0或者像100或10000这样的东西，你必须将它向右移动才能得到0或1。然后，将其放入BH并移位到所需位置，即字节0为7，字节1为6，依此类推。然后OR到我们的最终结果，INC和DEC什么是必要的。不要忘记条件跳转，并为下一次循环弹出AX+:)|offset|length|style|CODE|922439|结果将以CH。|922440|entityMap^0|0|0|17|1|19|8|1T|8|2C|3|2L|1|2P|3|2T|5|3H|1|3J|1|46|1|48|1|4C|1|4E|1|4N|2|4Y|3|52|3|5U|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]|$I|1J|J|1K|K|L]|$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]|$I|1P|J|1Q|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1R|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|P|$]]

I had also to program this bit reverse for the university (for 8 bits). Here is how I did:

<pre><code>MOV AL, 10001011B ;set the value to test
MOV CL, 7
MOV DH, 1
MOV DL, 0

loop1: PUSH AX
AND AL, DH 
PUSH CX
MOV CL, DL
SHR AL, CL
POP CX
MOV BH, AL
SHL BH,CL
OR CH,BH
DEC CL
INC DL
SHL DH, 1
POP AX
CMP DL, 8
JE END
JMP LOOP1

END:
</code></pre>

I didn't commented it so here is how it works:
DH is a <code>1</code> which travels in the byte like first time: <code>00000001</code>; second time <code>00000010</code>and so on. When you make an <code>AND</code> with the AL you get <code>0</code> or something like <code>100</code>or <code>10000</code> you have to shift that to the right to get it as <code>0</code> or <code>1</code>.
Then, put it in BH and shift to the desired position which is <code>7</code>for byte <code>0</code>, <code>6</code>for byte <code>1</code>and so on. Then <code>OR</code> to our final result and <code>INC</code> and <code>DEC</code> what is necessary. Do not forget the conditional jumps and to pop <code>AX</code> for the next loop :)

Result will be in CH.

blocks|key|4589568|text|下面的代码使用了旋转和移位。我使用英特尔x86语法，请参阅右侧的解释：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4589569|++++mov+cx,+8+++++++++++;+we+will+reverse+the+8+bits+contained+in+one+byte
loop:+++++++++++++++++++;+while+loop
++++ror+di++++++++++++++;+rotate+`di`+(containing+value+of+the+first+argument+of+callee+function)+to+the+Right+in+a+non-destructive+manner
++++adc+ax,+ax++++++++++;+shift+`ax`+left+and+add+the+carry,+the+carry+is+equal+to+1+if+one+bit+was+rotated+from+0b1+to+MSB+from+previous+operation
++++dec+cx++++++++++++++;+Decrement+cx
++++jnz+short+loop++++++;+Jump+if+cx+register+Not+equal+to+Zero+else+end+loop+and+return+ax|code-block|syntax|javascript|4589570|我使用dec指令而不是sub，因为它只需要一个字节，而sub需要3个字节。最重要的是，编译器似乎总是通过选择dec而不是sub来进行优化。|4589571|编辑:还要注意，rcl+ax+(3字节)，而adc+ax,+0+(2字节)后跟shl+ax+(2字节)的等价物效率较低。请看下面的评论，非常感谢Peter+Cordes的见解。|offset|length|style|CODE|4589572|entityMap^0|0|0|0|8|6|M|9|13|6|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

The following code make use of rotations and shift. I use Intel x86 syntax, see explanations on the right side:

<pre><code> mov cx, 8 ; we will reverse the 8 bits contained in one byte
loop: ; while loop
 ror di ; rotate `di` (containing value of the first argument of callee function) to the Right in a non-destructive manner
 adc ax, ax ; shift `ax` left and add the carry, the carry is equal to 1 if one bit was rotated from 0b1 to MSB from previous operation
 dec cx ; Decrement cx
 jnz short loop ; Jump if cx register Not equal to Zero else end loop and return ax
</code></pre>

I use dec instruction instead of sub, because it takes one byte only while sub takes 3 bytes. On top of that compilers seem to always optimize by choosing dec over sub.

edit: Also note that <code>rcl ax</code> (3 bytes), while equivalent of <code>adc ax, 0</code> (2 bytes) followed by <code>shl ax</code> (2 bytes) is less efficient.
See comments below, many thanks to Peter Cordes for his insights.

I'm in a microprocessors class and we are using assembly language in Freescale CodeWarrior to program a 68HCS12 micro controller. Our assignment this week is to revers a byte, so if the byte was 00000001, the output would be 10000000, or 00101011 to 11010100. We have to use assembly language, and were told we could use rotates and shifts (but not limited to!) to accomplish this task. I'm really at a loss as to where I should start.

Bit-reverse a byte on 68HC12

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我在上微处理器的课，我们正在用飞思卡尔CodeWarrior的汇编语言来编写68HCS12微控制器的程序。我们本周的任务是反转一个字节，因此如果字节是00000001，则输出将是10000000，或00101011到11010100。我们必须使用汇编语言，并且被告知我们可以使用旋转和移位(但不限于！)来完成这项任务。我真的不知所措，不知道该从哪里开始。

问位反转68HC12上的一个字节
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问位反转68HC12上的一个字节EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问位反转68HC12上的一个字节
EN