本帖最后由 神之觉醒 于 2013-9-30 18:06 编辑

天气有点暗 相机噪点多 照不清楚, 开闪光看起来不自然  额


刚装好,还木有接线,摆个样子自嗨一下[s:427]  


硬件搞定之后, 后面就好玩了[s:433]  


未来 电路可能还会有改动

本帖最后由 神之觉醒 于 2013-9-30 18:28 编辑

室内太暗,开闪光照两张

本帖最后由 神之觉醒 于 2013-10-2 22:42 编辑

刚才看着机器发呆，在想程序+.+  -   为了达到装X的效果~开机进一段自检程序然后进开机画面(可能再放个设置文件加载程序，关机时候保存的)再进操作界面~  就这么办[s:427]  

我好感动...........................楼主这样的人能出现在中国就是奇迹.......

你这个简直就是艺术品

神之觉醒 发表于 2013-9-30 18:27
室内太暗,开闪光照两张

我说lz啥时候写个纯硬件cpu教程？上高中了，没太多时间从头研究咯

本帖最后由 神之觉醒 于 2013-10-16 01:44 编辑

想想也是...都走到这步了, 如果把这个DIY电脑写成一本<<教你用门电路自制计算机>>的书 并且还有软件支持,只要按书中说的把电路搭建起来调试好,然后接上显示器、键盘鼠标、音响、网线，然后可以运行配套程序, 游戏、计算器、文件管理、WEB服务器、WEB浏览器、音乐播放、编译器。。。。把这个做完之后，你就什么都明白了的感觉，是这本书要达到的目的~  。。。。。。又YY勒。。。。我。。。。擦  =  =~ 希望能搞定 实践中不断学习吧~ 虽然很多路我都亲自走通了，但是感觉前面的路还是很迷茫，   虽然一点也不专业，但是破破烂烂的做出个可运行的系统(硬件软件)还是很爽的[s:427]

神之觉醒 发表于 2013-10-16 01:30
想想也是...都走到这步了, 如果把这个DIY电脑写成一本的书 并且还有软件支持,只要按书中说的把电路搭建起来 ...

过程最重要，只要你在折腾的过程中享受了，那就达到目的了，不论最后的结果是什么。
其实真的很羡慕你有那么多时间和精力来折腾喜欢的东西。。。

擦咧 更新到造主机箱了吗..
求问楼主, 造CPU, 写编译器, 网络协议, VGA显示什么的这些基础原理都是看什么书?

年轻有时间就是好，要不用三极管分立元件搭个usb模块

本帖最后由 神之觉醒 于 2013-12-1 10:54 编辑

10班陈大葱22号 发表于 2013-11-28 09:24
擦咧 更新到造主机箱了吗..
求问楼主, 造CPU, 写编译器, 网络协议, VGA显示什么的这些基础原理都是看什么 ...

造CPU可以看那个计算机原理的视频教程, 什么大学的我忘了... 是个年轻的女老师讲课, 视频找不到..可能已经删掉,  其实我也没看完,  然后再看那个<<新编微机原理及接口技术>>耿仁义主编,里面有8086CPU讲解和8086汇编,逻辑电路我是看<<数字逻辑>>汉泽西 张欣主编,这个我在图书馆借的,也不知道这个书算不算"好", 反正能学到东西----CPU总线\汇编\数字电路, 还有摆渡谷歌的大学生毕设论文 电路设计神马的, 然后就明白了...  在+上之前玩过单片机...

编译器就好办....懂C懂汇编懂机器码,就会明白编译器原理~  按照自己需要看情况搞(其实我i是乱搞)...

网络协议TCP/IP之前不懂感觉很复杂,但是搜索了一些网络视频教程和文章看之后,就能大概了解工作机制, 并且搜索到以太帧、IP、TCP、HTTP数据结构定义,  然后配合实践清ARP记录或PING目标或登个网站或下载东西用Wireshark抓包分析, 就能完全了解, 并且会知道如何编程制造兼容这个网络协议的程序机制,和其他主机或服务器沟通..

VGA显示我也是搜了大量文章看, 主要是看重点, VGA显示要用到哪条信号线等这些问题都可以很方便的搜索到, 知道了信号线的作用,然后就要了解控制时序, 当然也要继续搜...   学习研究之后并且配合实践发现,某些时序要精确符合, 然后行显示区可以按自己的需要控制显示.

总的来说,不是死板的看某本书就能明白一切, 而是按自己的需求去搜索各篇文章,在其中找到自己需要的东西就行了, 通过学习研究之后, 你可以看情况定义某些东西.....~知道我的意思吧~~

很复杂  

出套件!

打心底佩服。。

本帖最后由 神之觉醒 于 2014-2-21 21:42 编辑

机器一直在吃灰尘, 程序在去年11月初就停止了编写, 因为编译器偷懒乱搞的原因, 让程序编写比较困难,进度慢, 这段时间边工作边构思一个简单的C编译器, 估计已构思完成70%,  问题在不断的解决, 这几天拍了段运行之前简单程序的视频.

视频地址:  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

点击此处查看视频

楼主写教程吧。。太强大了

我想知道这堆IC花了多少钱？

引用 理工力量:
我想知道这堆IC花了多少钱？

几块钱......

此鸡的简单C编译器准备搞定!!  嗨爆....还差baeak continue sizeof  常量和常量计算,  再调试优化下生成代码先  就可以玩了[s::funk:][s:20]下面乱写测试..

鸡动得睡不着觉了...靠!= =!

引用 神之觉醒:
此鸡的简单C编译器准备搞定!!  嗨爆....还差baeak conrinue sizeof  常量和常量计算,  再调试优化下生成代码先  就可以玩了下面乱写测试..

晕死  else控制语句发现了个BUG...

好NB的样子。。。

编译器准备优化完成...代码代码...   全部完整文件后面弄得差不多了再发上来

发几张旧图~~

这部鸡的大概架构...

[s::lol]这台炮灰机的炮灰C编译器搞定之后一定要写几个吊一点的应用程序刷刷[s::funk:]

又过了1年 时间真快[s::funk:]

编译器设计时候的随手草稿..翻出来看有点感觉..拍几张上来给你们看看[s:;P] 乱7八糟,,这些只是草稿不全部是实际情况

硬件设计的草搞...- - 乱七八糟..仅供观赏

刚把二元式CPU指令生成程序弄好...
下面是需要编写的二元式CPU指令程序-  完全一比一对应的,-  感觉是编译器里面最蛋疼之一 纯体力活, 今天刚全部优化完成
不同类型之间要转换  然后再套接同类型的运算..  不然的话...=  =

1.传送
------------------------------
CPU寄存器传送:
_ACC = 常量 ok
_R1 = 常量 ok
_R2 = 常量 ok
_R3 = 常量 ok
_ACC = _ACC ok
_R1 = _ACC ok
_R2 = _ACC ok
_R3 = _ACC ok
_RAM = _ACC ok
_ACC = _RAM ok
_R1 = _RAM ok
_R2 = _RAM ok
_R3 = _RAM ok
_C = 常量 ok
_Z = 常量 ok
_BIT0 = 常量 ok
_BIT1 = 常量 ok
_BIT2 = 常量 ok
_BIT3 = 常量 ok
_BIT4 = 常量 ok
_BIT5 = 常量 ok
------------------------------
变量传送:
常量为 常量\立即数\指针常量(XXXX数组)
_ACC = char int16 int32 ok
_R1 = char int16 int32 ok
_R2 = char int16 int32 ok
_R3 = char int16 int32 ok
_ACC = 待修改跳转地址 ok
char = _ACC ok
char = char ok
int16 = 常量 ok
int16 = 无符号ACC ok
int16 = 有符号ACC ok
int16 = int16 int32 ok
int32 = 常量 ok
int32 = _ACC ok
int32 = 有符号ACC ok
int32 = 无符号int16 ok
int32 = 有符号int16 ok
int32 = int32 ok

----------------------------------
变量指针指向内容传送(*p或p[?]):
_ACC = char指针指向内容 ok
int16 = int16指针指向内容 ok
int32 = int32指针指向内容 ok
char指针指向内容 = _ACC ok
int16指针指向内容 = int16 int32 ok
int32指针指向内容 = int32 ok
int16指针指向内容 = 常量 ok
int32指针指向内容 = 常量 ok
----------------------------------

2.加法
----------------------------------
CPU寄存器加法:
ACC = ACC + R1 或 R1 + ACC ok
----------------------------------
变量和变量加法:
ACC = ACC + char 或 char + ACC ok
ACC = char + char ok
char = ACC + char 或 char + ACC ok
char = char + char 或 int16 + int16 或 int32 + int32 ok
int16 = int16 + int16 或 int32 + int32   ok
int32 = int32 + int32 ok

char指针 = char指针 + char/ACC 或 char/ACC + char指针 ok
char指针 = char指针 + int16/int32 或 int16/int32 + char指针 ok
int16指针 = int16指针 + char/ACC 或 char/ACC + int16指针 ok
int16指针 = int16指针 + int16/int32 或 int16/int32 + int16指针 ok
int32指针 = int32指针 + char/ACC 或 char/ACC + int32指针 ok
int32指针 = int32指针 + int16/int32 或 int16/int32 + int32指针 ok

变量和常量加法:
ACC = ACC + 常量 或 常量 + ACC ok
char = ACC + 常量 或 常量 + ACC ok
ACC = char + 常量 或 常量 + char ok
char = char + 常量 或 常量 + char 或 int16 + 常量 或 常量 + int16 或
int32 + 常量 或 常量 + int32 ok
int16 = int16 + 常量 或 常量 + int16 或 int32 + 常量 或 常量 + int32 ok
int32 = int32 + 常量 或 常量 + int32 ok
char指针 = char指针常量 + char/ACC 或 char/ACC + char指针常量 ok
char指针 = char指针常量 + int16/int32 或 int16/int32 + char指针常量 ok
int16指针 = int16指针常量 + char/ACC 或 char/ACC + int16指针常量 ok
int16指针 = int16指针常量 + int16/int32 或 int16/int32 + int16指针常量
ok
int32指针 = int32指针常量 + char/ACC 或 char/ACC + int32指针常量 ok
int32指针 = int32指针常量 + int16/int32 或 int16/int32 + int32指针常量
ok
----------------------------------

3.减法
----------------------------------
CPU寄存器减法:
ACC = ACC - R1 ok
----------------------------------
变量和变量减法:
ACC = ACC - char 或 char - ACC ok
ACC = char - char ok
char = ACC - char 或 char - ACC ok
char = char - char 或 int16 - int16 或 int32 - int32 ok
int16 = int16 - int16 或 int32 - int32 ok
int32 = int32 - int32 ok

char指针 = char指针 - char/ACC ok
char指针 = char指针 - int16/int32 ok
int16指针 = int16指针 - char/ACC ok
int16指针 = int16指针 - int16/int32 ok
int32指针 = int32指针 - char/ACC ok
int32指针 = int32指针 - int16/int32 ok

变量和常量减法:
ACC = ACC - 常量 或 常量 - ACC ok
char = ACC - 常量 或 常量 - ACC ok
ACC = char - 常量 或 常量 - char ok
char = char - 常量 或 常量 - char 或 int16 - 常量 或 常量 - int16 或
int32 - 常量 或 常量 - int32 ok
int16 = int16 - 常量 或 常量 - int16 或 int32 - 常量 或 常量 - int32 ok
int32 = int32 - 常量 或 常量 - int32 ok

char指针 = char指针常量 - char/ACC ok
char指针 = char指针常量 - int16/int32 ok
int16指针 = int16指针常量 - char/ACC ok
int16指针 = int16指针常量 - int16/int32 ok
int32指针 = int32指针常量 - char/ACC ok
int32指针 = int32指针常量 - int16/int32 ok
----------------------------------

4.与
----------------------------------
CPU寄存器与:
ACC = ACC & R1 或 R1 & ACC ok
----------------------------------
变量和变量与:
ACC = ACC & char 或 char & ACC ok
ACC = char & char ok
char = ACC & char 或 char & ACC ok
char = char & char 或 int16 & int16 或 int32 & int32 ok
int16 = int16 & int16 或 int32 & int32 ok
int32 = int32 & int32 ok

变量和常量与:
ACC = ACC & 常量 或 常量 & ACC ok
char = ACC & 常量 或 常量 & ACC ok
ACC = char & 常量 或 常量 & char ok
char = char & 常量 或 常量 & char 或 int16 & 常量 或 常量 & int16 或
int32 & 常量 或 常量 & int32 ok
int16 = int16 & 常量 或 常量 & int16 或 int32 & 常量 或 常量 & int32 ok
int32 = int32 & 常量 或 常量 & int32 ok

----------------------------------
5.或
----------------------------------
CPU寄存器或:
ACC = ACC | R1 或 R1 | ACC ok
----------------------------------
变量和变量或:
ACC = ACC | char 或 char | ACC ok
ACC = char | char ok
char = ACC | char 或 char | ACC ok
char = char | char 或 int16 | int16 或 int32 | int32 ok
int16 = int16 | int16 或 int32 | int32 ok
int32 = int32 | int32 ok

变量和常量或:
ACC = ACC | 常量 或 常量 | ACC ok
char = ACC | 常量 或 常量 | ACC ok
ACC = char | 常量 或 常量 | char ok
char = char | 常量 或 常量 | char 或 int16 | 常量 或 常量 | int16 或
int32 | 常量 或 常量 | int32 ok
int16 = int16 | 常量 或 常量 | int16 或 int32 | 常量 或 常量 | int32 ok
int32 = int32 | 常量 或 常量 | int32 ok

----------------------------------
6.异或
----------------------------------
CPU寄存器异或:
ACC = ACC ^ R1 或 R1 ^ ACC ok
----------------------------------
变量和变量异或:
ACC = ACC ^ char 或 char ^ ACC ok
ACC = char ^ char ok
char = ACC ^ char 或 char ^ ACC ok
char = char ^ char 或 int16 ^ int16 或 int32 ^ int32 ok
int16 = int16 ^ int16 或 int32 ^ int32 ok
int32 = int32 ^ int32 ok

变量和常量异或:
ACC = ACC ^ 常量 或 常量 ^ ACC ok
char = ACC ^ 常量 或 常量 ^ ACC ok
ACC = char ^ 常量 或 常量 ^ char ok
char = char ^ 常量 或 常量 ^ char 或 int16 ^ 常量 或 常量 ^ int16 或
int32 ^ 常量 或 常量 ^ int32 ok
int16 = int16 ^ 常量 或 常量 ^ int16 或 int32 ^ 常量 或 常量 ^ int32 ok
int32 = int32 ^ 常量 或 常量 ^ int32 ok
----------------------------------

7.非
----------------------------------
CPU寄存器非:
ACC = ~ACC ok
----------------------------------
变量非:
char = ~char 或 ~int16 或 ~int32 ok
int16 = ~int16 或 ~int32 ok
int32 = ~int32 ok
----------------------------------

8.乘法
----------------------------------
变量和变量乘法:
ACC = 无符号char * 无符号ACC 或 无符号ACC * 无符号char ok
char = 无符号char * 无符号ACC 或 无符号ACC * 无符号char ok
ACC = 无符号char * 无符号char ok
char = 无符号char * 无符号char ok
int16 = 无符号int16 * 无符号int16 ok
int32 = 无符号int32 * 无符号int32 ok
ACC = 有符号char * 有符号ACC 或 有符号ACC * 有符号char ok
char = 有符号char * 有符号ACC 或 有符号ACC * 有符号char ok
ACC = 有符号char * 有符号char ok
char = 有符号char * 有符号char ok
int16 = 有符号int16 * 有符号int16 ok
int32 = 有符号int32 * 有符号int32 ok
----------------------------------
变量和常量乘法:
ACC = 无符号ACC * 常量 或 常量 * 无符号ACC ok
char = 无符号ACC * 常量 或 常量 * 无符号ACC ok
ACC = 无符号char * 常量 或 常量 * 无符号char ok
char = 无符号char * 常量 或 常量 * 无符号char ok
int16 = 无符号int16 * 常量 或 常量 * 无符号int16 ok
int32 = 无符号int32 * 常量 或 常量 * 无符号int32 ok
ACC = 有符号ACC * 常量 或 常量 * 有符号ACC ok
char = 有符号ACC * 常量 或 常量 * 有符号ACC ok
ACC = 有符号char * 常量 或 常量 * 有符号char ok
char = 有符号char * 常量 或 常量 * 有符号char ok
int16 = 有符号int16 * 常量 或 常量 * 有符号int16 ok
int32 = 有符号int32 * 常量 或 常量 * 有符号int32 ok
----------------------------------
9.除法
----------------------------------
变量和变量除法:
ACC = 无符号char / 无符号ACC 或 无符号ACC / 无符号char ok
char = 无符号char / 无符号ACC 或 无符号ACC / 无符号char ok
ACC = 无符号char / 无符号char ok
char = 无符号char / 无符号char ok
int16 = 无符号int16 / 无符号int16 ok
int32 = 无符号int32 / 无符号int32 ok
ACC = 有符号char / 有符号ACC 或 有符号ACC / 有符号char ok
char = 有符号char / 有符号ACC 或 有符号ACC / 有符号char ok
ACC = 有符号char / 有符号char ok
char = 有符号char / 有符号char ok
int16 = 有符号int16 / 有符号int16 ok
int32 = 有符号int32 / 有符号int32 ok
----------------------------------
变量和常量除法:
ACC = 无符号ACC / 常量 或 常量 / 无符号ACC ok
char = 无符号ACC / 常量 或 常量 / 无符号ACC ok
ACC = 无符号char / 常量 或 常量 / 无符号char ok
char = 无符号char / 常量 或 常量 / 无符号char ok
int16 = 无符号int16 / 常量 或 常量 / 无符号int16 ok
int32 = 无符号int32 / 常量 或 常量 / 无符号int32 ok
ACC = 有符号ACC / 常量 或 常量 / 有符号ACC ok
char = 有符号ACC / 常量 或 常量 / 有符号ACC ok
ACC = 有符号char / 常量 或 常量 / 有符号char ok
char = 有符号char / 常量 或 常量 / 有符号char ok
int16 = 有符号int16 / 常量 或 常量 / 有符号int16 ok
int32 = 有符号int32 / 常量 或 常量 / 有符号int32 ok
----------------------------------

10.取余
----------------------------------
变量和变量取余:
ACC = 无符号char % 无符号ACC 或 无符号ACC % 无符号char ok
char = 无符号char % 无符号ACC 或 无符号ACC % 无符号char ok
ACC = 无符号char % 无符号char ok
char = 无符号char % 无符号char ok
int16 = 无符号int16 % 无符号int16 ok
int32 = 无符号int32 % 无符号int32 ok
ACC = 有符号char % 有符号ACC 或 有符号ACC % 有符号char ok
char = 有符号char % 有符号ACC 或 有符号ACC % 有符号char ok
ACC = 有符号char % 有符号char ok
char = 有符号char % 有符号char ok
int16 = 有符号int16 % 有符号int16 ok
int32 = 有符号int32 % 有符号int32 ok
----------------------------------
变量和常量取余:
ACC = 无符号ACC % 常量 或 常量 % 无符号ACC ok
char = 无符号ACC % 常量 或 常量 % 无符号ACC ok
ACC = 无符号char % 常量 或 常量 % 无符号char ok
char = 无符号char % 常量 或 常量 % 无符号char ok
int16 = 无符号int16 % 常量 或 常量 % 无符号int16 ok
int32 = 无符号int32 % 常量 或 常量 % 无符号int32 ok
ACC = 有符号ACC % 常量 或 常量 % 有符号ACC ok
char = 有符号ACC % 常量 或 常量 % 有符号ACC ok
ACC = 有符号char % 常量 或 常量 % 有符号char ok
char = 有符号char % 常量 或 常量 % 有符号char ok
int16 = 有符号int16 % 常量 或 常量 % 有符号int16 ok
int32 = 有符号int32 % 常量 或 常量 % 有符号int32 ok
----------------------------------

11.左右移位
----------------------------------
变量被移数和变量移数左右移位:
char = char << ACC/char/int16/int32 ok
int16 = int16 << ACC/char/int16/int32 ok
int32 = int32 << ACC/char/int16/int32 ok
char = 无符号char >> ACC/char/int16/int32 ok
int16 = 无符号int16 >> ACC/char/int16/int32 ok
int32 = 无符号int32 >> ACC/char/int16/int32 ok
char = 有符号char >> ACC/char/int16/int32 ok
int16 = 有符号int16 >> ACC/char/int16/int32 ok
int32 = 有符号int32 >> ACC/char/int16/int32 ok
----------------------------------
变量被移数和常量移数左右移位:
char = char << 常量 ok
int16 = int16 << 常量 ok
int32 = int32 << 常量 ok
char = 无符号char >> 常量 ok
int16 = 无符号int16 >> 常量 ok
int32 = 无符号int32 >> 常量 ok
char = 有符号char >> 常量 ok
int16 = 有符号int16 >> 常量 ok
int32 = 有符号int32 >> 常量 ok
----------------------------------

12.关系运算(生成待修改出口地址的条件跳转指令)
----------------------------------
变量和变量关系运算:

待修改跳转地址 = 无符号char > 无符号ACC 或 无符号ACC > 无符号char  ok
待修改跳转地址 = 无符号char < 无符号ACC 或 无符号ACC < 无符号char  ok
待修改跳转地址 = 无符号char == 无符号ACC 或 无符号ACC == 无符号char ok
待修改跳转地址 = 无符号char != 无符号ACC 或 无符号ACC != 无符号char ok
待修改跳转地址 = 无符号char >= 无符号ACC 或 无符号ACC >= 无符号char ok
待修改跳转地址 = 无符号char <= 无符号ACC 或 无符号ACC <= 无符号char ok
待修改跳转地址 = 无符号char > 无符号char ok
待修改跳转地址 = 无符号char < 无符号char ok
待修改跳转地址 = 无符号char == 无符号char ok
待修改跳转地址 = 无符号char != 无符号char ok
待修改跳转地址 = 无符号char >= 无符号char ok
待修改跳转地址 = 无符号char <= 无符号char ok
待修改跳转地址 = 无符号int16 > 无符号int16 ok
待修改跳转地址 = 无符号int16 < 无符号int16 ok
待修改跳转地址 = 无符号int16 == 无符号int16 ok
待修改跳转地址 = 无符号int16 != 无符号int16 ok
待修改跳转地址 = 无符号int16 >= 无符号int16 ok
待修改跳转地址 = 无符号int16 <= 无符号int16 ok
待修改跳转地址 = 无符号int32 > 无符号int32 ok
待修改跳转地址 = 无符号int32 < 无符号int32 ok
待修改跳转地址 = 无符号int32 == 无符号int32 ok
待修改跳转地址 = 无符号int32 != 无符号int32 ok
待修改跳转地址 = 无符号int32 >= 无符号int32 ok
待修改跳转地址 = 无符号int32 <= 无符号int32 ok

待修改跳转地址 = 有符号char > 有符号ACC 或 有符号ACC > 有符号char ok
待修改跳转地址 = 有符号char < 有符号ACC 或 有符号ACC < 有符号char ok
待修改跳转地址 = 有符号char == 有符号ACC 或 有符号ACC == 有符号char ok
待修改跳转地址 = 有符号char != 有符号ACC 或 有符号ACC != 有符号char ok
待修改跳转地址 = 有符号char >= 有符号ACC 或 有符号ACC >= 有符号char ok
待修改跳转地址 = 有符号char <= 有符号ACC 或 有符号ACC <= 有符号char ok
待修改跳转地址 = 有符号char > 有符号char ok
待修改跳转地址 = 有符号char < 有符号char ok
待修改跳转地址 = 有符号char == 有符号char ok
待修改跳转地址 = 有符号char != 有符号char ok
待修改跳转地址 = 有符号char >= 有符号char ok
待修改跳转地址 = 有符号char <= 有符号char ok
待修改跳转地址 = 有符号int16 > 有符号int16 ok
待修改跳转地址 = 有符号int16 < 有符号int16 ok
待修改跳转地址 = 有符号int16 == 有符号int16 ok
待修改跳转地址 = 有符号int16 != 有符号int16 ok
待修改跳转地址 = 有符号int16 >= 有符号int16 ok
待修改跳转地址 = 有符号int16 <= 有符号int16 ok
待修改跳转地址 = 有符号int32 > 有符号int32 ok
待修改跳转地址 = 有符号int32 < 有符号int32 ok
待修改跳转地址 = 有符号int32 == 有符号int32 ok
待修改跳转地址 = 有符号int32 != 有符号int32 ok
待修改跳转地址 = 有符号int32 >= 有符号int32 ok
待修改跳转地址 = 有符号int32 <= 有符号int32 ok
---------------------------------------------------------
变量和常量关系运算:

待修改跳转地址 = _C == 0 ok
待修改跳转地址 = _C == 1 ok
待修改跳转地址 = _Z == 0 ok
待修改跳转地址 = _Z == 1 ok
待修改跳转地址 = _A == 0 ok
待修改跳转地址 = _A == 1 ok
待修改跳转地址 = _C != 0 ok
待修改跳转地址 = _C != 1 ok
待修改跳转地址 = _Z != 0 ok
待修改跳转地址 = _Z != 1 ok
待修改跳转地址 = _A != 0 ok
待修改跳转地址 = _A != 1 ok
待修改跳转地址 = 无符号ACC > 常量 或 常量 > 无符号ACC ok
待修改跳转地址 = 无符号ACC < 常量 或 常量 < 无符号ACC ok
待修改跳转地址 = 无符号ACC == 常量 或 常量 == 无符号ACC ok
待修改跳转地址 = 无符号ACC != 常量 或 常量 != 无符号ACC ok
待修改跳转地址 = 无符号ACC >= 常量 或 常量 >= 无符号ACC ok
待修改跳转地址 = 无符号ACC <= 常量 或 常量 <= 无符号ACC ok
待修改跳转地址 = 无符号char > 常量 或 常量 > 无符号char ok
待修改跳转地址 = 无符号char < 常量 或 常量 < 无符号char ok
待修改跳转地址 = 无符号char == 常量 或 常量 == 无符号char ok
待修改跳转地址 = 无符号char != 常量 或 常量 != 无符号char ok
待修改跳转地址 = 无符号char >= 常量 或 常量 >= 无符号char ok
待修改跳转地址 = 无符号char <= 常量 或 常量 <= 无符号char ok
待修改跳转地址 = 无符号int16 > 常量 或 常量 > 无符号int16 ok
待修改跳转地址 = 无符号int16 < 常量 或 常量 < 无符号int16 ok
待修改跳转地址 = 无符号int16 == 常量 或 常量 == 无符号int16 ok
待修改跳转地址 = 无符号int16 != 常量 或 常量 != 无符号int16 ok
待修改跳转地址 = 无符号int16 >= 常量 或 常量 >= 无符号int16 ok
待修改跳转地址 = 无符号int16 <= 常量 或 常量 <= 无符号int16 ok
待修改跳转地址 = 无符号int32 > 常量 或 常量 > 无符号int32 ok
待修改跳转地址 = 无符号int32 < 常量 或 常量 < 无符号int32 ok
待修改跳转地址 = 无符号int32 == 常量 或 常量 == 无符号int32 ok
待修改跳转地址 = 无符号int32 != 常量 或 常量 != 无符号int32 ok
待修改跳转地址 = 无符号int32 >= 常量 或 常量 >= 无符号int32 ok
待修改跳转地址 = 无符号int32 <= 常量 或 常量 <= 无符号int32 ok

待修改跳转地址 = 有符号ACC > 常量 或 常量 > 有符号ACC ok
待修改跳转地址 = 有符号ACC < 常量 或 常量 < 有符号ACC ok
待修改跳转地址 = 有符号ACC == 常量 或 常量 == 有符号ACC ok
待修改跳转地址 = 有符号ACC != 常量 或 常量 != 有符号ACC ok
待修改跳转地址 = 有符号ACC >= 常量 或 常量 >= 有符号ACC ok
待修改跳转地址 = 有符号ACC <= 常量 或 常量 <= 有符号ACC ok
待修改跳转地址 = 有符号char > 常量 或 常量 > 有符号char ok
待修改跳转地址 = 有符号char < 常量 或 常量 < 有符号char ok
待修改跳转地址 = 有符号char == 常量 或 常量 == 有符号char ok
待修改跳转地址 = 有符号char != 常量 或 常量 != 有符号char ok
待修改跳转地址 = 有符号char >= 常量 或 常量 >= 有符号char ok
待修改跳转地址 = 有符号char <= 常量 或 常量 <= 有符号char ok
待修改跳转地址 = 有符号int16 > 常量 或 常量 > 有符号int16 ok
待修改跳转地址 = 有符号int16 < 常量 或 常量 < 有符号int16 ok
待修改跳转地址 = 有符号int16 == 常量 或 常量 == 有符号int16 ok
待修改跳转地址 = 有符号int16 != 常量 或 常量 != 有符号int16 ok
待修改跳转地址 = 有符号int16 >= 常量 或 常量 >= 有符号int16 ok
待修改跳转地址 = 有符号int16 <= 常量 或 常量 <= 有符号int16 ok
待修改跳转地址 = 有符号int32 > 常量 或 常量 > 有符号int32 ok
待修改跳转地址 = 有符号int32 < 常量 或 常量 < 有符号int32 ok
待修改跳转地址 = 有符号int32 == 常量 或 常量 == 有符号int32 ok
待修改跳转地址 = 有符号int32 != 常量 或 常量 != 有符号int32 ok
待修改跳转地址 = 有符号int32 >= 常量 或 常量 >= 有符号int32 ok
待修改跳转地址 = 有符号int32 <= 常量 或 常量 <= 有符号int32 ok

看到此贴被楼主鸡动得睡不着觉了...

期待最终教程！

编译器今日进度...#define和#include搞定   再搞点好玩的功能上去先..

编译器已经完成...正在测试中..这个8192的32位数组写进去再读出来要1秒....蛋疼...
编译器直接生成BIN文件  我现在这部电脑系统64位的 ROM烧写器驱动不支持...只能用另一台机开烧写器了

引用 神之觉醒:
编译器已经完成...正在测试中..这个8192的32位数组写进去再读出来要1秒....蛋疼...
编译器直接生成BIN文件  我现在这部电脑系统64位的 ROM烧写器驱动不支持...只能用另一台机开烧写器了

啥时出教程和套件呢

引用 eeprom:
啥时出教程和套件呢

教程一言难尽...其实复杂也不复杂简单也不简单, 我觉得自己不适合写教程- -   但是我尽力尝试写, 写教程也消耗时间, 如果真正的有兴趣,现在网络上面很多资源都非常好都可以学习研究;  套件这个问题我也考虑的. 如果我把现在这台机弄成套件PCB成本会很高, 也失去了DIY的精神, 成本高商业化味道神魔的(除非你真的非常有需要可以私我).....未来如果出套件的话我会往低成本和简洁方面搞,符合发烧友或爱好者需求;  现在这台机的编译器和硬件都已经完成, 我现在要做的就是把本机各个硬件用编译器测试通, 并且运行一些程序来玩玩先,  同时也刷到了很多经验,  然后就可以正式发布本机的软件和硬件了, 然后你有兴趣的话可以按照说明和图纸DIY就OK, DIY的过程可以学习到很多东西的, 这是最好的教程;  - -其实我水平渣渣 万一不小心被我洗脑就麻烦...
另外简洁的商品套件尝试设计中.[s::lol] ,目前指令的格式和安排已经设计得差不多了,  如果出来的话 配套说明应用肯定会有

现在这台机准备运行前面第1页讲到的HTTP服务器测试一下,  前面那个单片机RAM内存有限只能运行5个并发连接, 1个TCP连接表52字节..  我看看放到这台机来能弄到多少并发连接不爆炸~~~

引用 神之觉醒:
教程一言难尽...其实复杂也不复杂简单也不简单, 我觉得自己不适合写教程- -   但是我尽力尝试写, 写教程也消耗时间, 如果真正的有兴趣,现在网络上面很多资源都非常好都可以学习研究;  套件这个问题我也考虑的. 如果我把现在这台机弄成套...

大神再发一次完整的说明和图纸呗？之前的太乱了，我一直关注你的这个项目呢！

引用 eeprom:
大神再发一次完整的说明和图纸呗？之前的太乱了，我一直关注你的这个项目呢！

现在正在努力的测试...谢谢关注!!! 测试完我整理下就发上来。[s::kiss:]
刚刚改好HTTP服务器。 准备开始运行。。
[s:;P] 嗨爆！！！

引用 神之觉醒:
现在正在努力的测试...谢谢关注!!! 测试完我整理下就发上来。
刚刚改好HTTP服务器。 准备开始运行。。
嗨爆！！！

[s::funk:]并发超出爆炸了没

引用 eeprom:
并发超出爆炸了没

正在测试  速度好慢- -  总速度才10多KB   优化看看能不能提高- -  ping命令空载的时候可以到7毫秒  一负载延时就增加..

等下开一晚上传输 看看文件会不会出错- -稳定性

传个1M多的文件里面总概率性的有几个字节出错- - 但是PC机那边数据包效验又通过  奇怪.... 怀疑SPI电平转换的三极管延时过大  拆了把SD卡的SPI总线接到没有三极管电平转换的接口看看

蛋疼死了  问题还没解决

怀疑2.0版SPI收发器干扰大,又重新设计了一个3.0吊炸天增强版SPI收发器,.......问题还是没有解决... 刚刚把CPU降频问题解决[s::lol]   电路差不多都检查完...又检查程序...又检查编译器........ 搞残我了..

引用 神之觉醒:
怀疑2.0版SPI收发器干扰大,又重新设计了一个3.0吊炸天增强版SPI收发器,.......问题还是没有解决... 刚刚把CPU降频问题解决   电路差不多都检查完...又检查程序...又检查编译器........ 搞残我了..

亮瞎眼[s::lol]

原来CPU跑25MHZ不稳定..然后换成16MHZ跑一天了. 稳定..   到时找个22MHZ和24MHZ的晶振试一下..  等下上服务器测试视频
2.0版SPI收发器

3.0版SPI收发器和2.0版SPI收发器对比

3.0版SPI收发器

3.0版SPI收发器设计草稿

3.0版SPI收发器实际电路

该死的LIAN通。。。竟然给我内网IP。。。不然就可以全球服务了