找回密码
 立即注册
查看: 880|回复: 8

STC15F104W的串口是哪些引脚?

[复制链接]
  • 打卡等级:初来乍到
  • 打卡总天数:3
  • 最近打卡:2024-03-28 13:06:41

6

主题

7

回帖

66

积分

注册会员

积分
66
发表于 2024-1-17 09:22:26 | 显示全部楼层 |阅读模式
P3.0和P3.1可以做串口吗?
回复

使用道具 举报 送花

  • 打卡等级:以坛为家II
  • 打卡总天数:521
  • 最近打卡:2025-05-02 09:38:13

109

主题

1900

回帖

5214

积分

论坛元老

积分
5214
发表于 2024-1-17 09:39:06 | 显示全部楼层
我记得只能用于下载,不能用于用户串口通讯。
不过准确的话,还得看一下手册 。
回复 支持 反对

使用道具 举报 送花

  • 打卡等级:以坛为家II
  • 打卡总天数:521
  • 最近打卡:2025-05-02 09:38:13

109

主题

1900

回帖

5214

积分

论坛元老

积分
5214
发表于 2024-1-17 09:46:50 | 显示全部楼层
截图202401170946128202.jpg

没有涉及到串口的内容
回复 支持 反对

使用道具 举报 送花

  • 打卡等级:初来乍到
  • 打卡总天数:3
  • 最近打卡:2024-03-28 13:06:41

6

主题

7

回帖

66

积分

注册会员

积分
66
发表于 2024-1-17 09:55:44 | 显示全部楼层
xxkj*** 发表于 2024-1-17 09:46
没有涉及到串口的内容

谢谢,就是因为看手册上没有,才来问问看
回复 支持 反对

使用道具 举报 送花

  • 打卡等级:以坛为家II
  • 打卡总天数:415
  • 最近打卡:2025-04-30 09:58:34
已绑定手机

39

主题

2006

回帖

6843

积分

论坛元老

积分
6843
发表于 2024-1-17 10:08:50 | 显示全部楼层
选型表里面可以看到,STC15F1xx系列芯片没有串口功能
截图202401171008138042.jpg
回复 支持 反对

使用道具 举报 送花

  • 打卡等级:以坛为家II
  • 打卡总天数:521
  • 最近打卡:2025-05-02 09:38:13

109

主题

1900

回帖

5214

积分

论坛元老

积分
5214
发表于 2024-1-17 10:30:18 | 显示全部楼层
这型号还没有定时器1呢,这点也得注意,我有一次就因此掉坑的。

截图202401171030146084.jpg


回复 支持 反对

使用道具 举报 送花

  • 打卡等级:常住居民III
  • 打卡总天数:133
  • 最近打卡:2025-04-30 13:40:52

13

主题

65

回帖

594

积分

高级会员

积分
594
发表于 2024-1-17 10:59:53 | 显示全部楼层
15不是停产了吗
回复 支持 反对

使用道具 举报 送花

  • 打卡等级:以坛为家I
  • 打卡总天数:387
  • 最近打卡:2025-05-02 10:19:07
已绑定手机

8

主题

137

回帖

1049

积分

金牌会员

积分
1049
发表于 2024-1-17 11:09:02 | 显示全部楼层
2012年用STC15F104E做了一些485继电器控制小板,自己自制智能家居。

后面出了104W,就换了104W
后面又出了104WS,就自带串口了。

当时硬是用模拟串口做出来了,可以跑115200bps。

STC15F104W 模拟串口可跑115200bps.C (14.76 KB, 下载次数: 93)




  1. #include <reg52.h>                                                                                                                                //使用8052内核单片机
  2. #include <intrins.h>                                                                                                                        //使用_nop_();
  3. sbit IO1=P3^5;                                                                                                                                                //IO
  4. sbit IO2=P3^4;                                                                                                                                                //IO
  5. sbit IO3=P3^3;                                                                                                                                                //IO
  6. sbit DE_RE=P3^2;                                                                                                                                        //智能家居485总线流控方向,1发送,0接收
  7. sbit TX_IO=P3^1;                                                                                                                                        //模拟串口发送IO
  8. sbit RX_IO=P3^0;                                                                                                                                        //模拟串口接收IO
  9. sfr AUXR=0x8e;                                                                                                                                                //STC15F104E系列单片机特殊寄存器,控制定时器时钟来源频率
  10. sfr P3M0=0xb2;                                                                                                                                                //P3IO口工作模式
  11. sfr eeprom_data =0xc2;
  12. sfr eeprom_addh =0xc3;
  13. sfr eeprom_addl =0xc4;
  14. sfr eeprom_cmd  =0xc5;
  15. sfr eeprom_star =0xc6;
  16. sfr eeprom_cont =0xc7;
  17. bit sending,receing,stpbsed,bytereceived;                                        //发送中,接收中,接收完毕标志
  18. bit data_receive_enable;                                                                                //帧头判断成功,过零信号前一状态
  19. bit trig_count_enable1;                                                                                                                //过零信号到达启动计时
  20. bit trig_count_enable2;                                                                                                                //过零信号到达启动计时
  21. bit traic_1_on,traic_2_on;
  22. unsigned char rece_bit_count;                                                                                        //接收位计数变量
  23. unsigned char rece_pls_count;                                                                                        //接收脉冲计数变量
  24. unsigned char send_bit_count;                                                                                        //发送位计数变量
  25. unsigned char send_pls_count;                                                                                        //发送脉冲计数变量
  26. unsigned char receing_data;                                                                                                //正在接收着的临时数据
  27. unsigned char byte_need_to_send;                                                                        //要发送出去的字节
  28. unsigned char byte_received;                                                                                        //已收到的字节
  29. unsigned char zhen_tou[]={0xFF,0x00,0x55,0xAA,0x00,0xFF};//帧头字串
  30. unsigned char cast_tou[]={0xFF,0x00,0x55,0xAA,0xFF,0x00};//广播地址帧头
  31. unsigned char jie_shou[]={0x00,0x00,0x00,0x00,0x00,0x00};//接收的数据帧
  32. unsigned int code baud[]={0xa000,0xd000,0xe800,0xf400,0xfa00,0xfd00,0xfe00,0xff00,0xff25,0xff80,0xffc0};
  33.                                                                                                 //300-----600----1200---2400---4800---9600---14400--28800--33600--57600--115200
  34.                                                                                                 //smod=1@22.1184mhz,auxr|=0x80
  35. unsigned char count,checksum,temp;                                                                //处理数据帧字节计数,校验和,临时传递变量
  36. unsigned char etmp1,etmp2;                                                                                                //操作eeprom用的临时保存变量
  37. unsigned char verify,fr_num;                                                                                        //帧头核对及数据帧接收位置
  38. unsigned char com_bit_tick;                                                                                                //串口位节拍计时器,主要用作回包延时控制
  39. unsigned char trig_count1;                                                                                                        //移相触发延时变量
  40. unsigned char trig_count2;                                                                                                        //移相触发延时变量
  41. unsigned char brightness1,brightness2;                                                //可控硅亮度
  42. unsigned int  bootdelay,baud_index;                                                                //启动延时,波特率索引值
  43. //eeprom 命令:0空闲,1读字节,2写字节,3扇区擦除
  44. //写到eeprom_cont 寄存器的值:0x81,小于24MHz
  45. //eepROM 起始地址:0x0000,0x0000-0x01ff 第一扇区 0x0200-0x03ff第二扇区
  46. void close_eeprom(void);
  47. unsigned char read_eeprom(unsigned int addr);
  48. void write_eeprom(unsigned int addr,dat);
  49. void erase_eeprom(unsigned int addr);
  50. void send_byte(unsigned char byte_will_send);                        //发送一个字节
  51. unsigned char pack_ana(void);
  52. void set_baud(unsigned char index);
  53. void respond_packge(void);
  54. void execute_cmd(void);
  55. void byte_reced(void);
  56. void traic_on_off(void);
  57. void main(void)                                                                                                                                                //主程序
  58. {                                                                                                                                                                                                        //开始
  59.         unsigned long btn_push_count;
  60. P3=0XCF;
  61. AUXR=0xc0;                                                                                                                                                                //T0计时脉冲不分频,比传统8051快12倍
  62. P3M0=0X3c;//00111100
  63. TMOD=0X00;                                                                                                                                                                //16位自动重载模式,当TR0=0时向TH0,TL0写入数据将同时写入重载寄存器
  64. TH0=0xfd;                                                                                                                                                                        //重载值=65536-(定时器脉冲频率÷波特率÷3)
  65. TL0=0x00;                                                                                                                                                                        //溢出率=定时器脉冲频率÷(65536-重载值)
  66. TH1=0xFB;
  67. TL1=0xAE;                                                                                                                                                                        //50uS@22.1184mhz计数率
  68. TR0=1;                                                                                                                                                                                //启动定时器,模拟串口开始工作
  69. TR1=1;                                                                                                                                                                                //启动定时器,可控硅移相触发开始工作
  70. EA=1;                                                                                                                                                                                        //打开总中断
  71. ET0=1;                                                                                                                                                                                //打开定时器0中断
  72. ET1=1;                                                                                                                                                                                //打开定时器1中断
  73. PT0=1;                                                                                                                                                                                //优先保证定时器0中断,确保模拟串口的可靠性
  74. DE_RE=0;
  75.         bootdelay=15000;
  76.         etmp1=35;
  77.         while(--etmp1)
  78.         {
  79.         while(--bootdelay)
  80.           {
  81.                 byte_reced();
  82.                 }
  83.         }
  84.         baud_index=read_eeprom(0x0001);
  85.         set_baud(baud_index);
  86.         zhen_tou[4]=read_eeprom(0x0000);
  87.         zhen_tou[5]=~zhen_tou[4];
  88.         brightness1=read_eeprom(0x0200);
  89.         brightness2=read_eeprom(0x0201);
  90.         traic_on_off();
  91. while(1)                                                                                                                                                                        //主循环
  92.   {                                                                                                                                                                                                //主循环体开始
  93.         byte_reced();
  94.                 if(TX_IO==0)
  95.                 {
  96.                 while(TX_IO==0)
  97.                 {
  98.                         btn_push_count++;
  99.                 }
  100.                 if(btn_push_count>200000 && btn_push_count<500000){IO1=~IO1;}
  101.                 if(btn_push_count>500000 && btn_push_count<1500000){IO2=~IO2;}
  102.                 if(btn_push_count>1800000){IO3=~IO3;}
  103.                 btn_push_count=0;
  104.     }
  105.                 //send_byte(0X55);
  106.         }                                                                                                                                                                                                //主循环体结束
  107. }                                                                                                                                                                                                        //主程序结束
  108. void send_byte(unsigned char byte_will_send)                        //发送一个字节
  109. {                                                                                                                                                                                                        //函数开始
  110. byte_need_to_send=byte_will_send;                                                                        //传递要发送的数据
  111. send_pls_count=3;                                                                                                                                        //采样倍率3
  112. send_bit_count=8;                                                                                                                                        //8位数据一位停止
  113. TX_IO=0;                                                                                                                                                                        //发送起始位
  114. sending=1;                                                                                                                                                                //置标志位,中断程序开始发送该字节
  115. stpbsed=0;
  116. while(sending==1);                                                                                                                                                //等待数据发送完成
  117. }                                                                                                                                                                                                        //函数结束
  118. void timer0(void) interrupt 1                                                                                        //中断服务程序
  119. {                                                                                                                                                                                                        //函数开始
  120. //        IO3=!IO3;
  121. if(receing)                                                                                                                                                                //接收中?
  122.   {                                                                                                                                                                                                //接收中开始
  123.         if(--rece_pls_count==0)                                                                                                        //三次脉冲计数够了吗?
  124.           {                                                                                                                                                                                        //接收一位二进制位开始
  125.                 rece_pls_count=3;                                                                                                                        //脉冲计数辅助变量复位
  126.                 if(rece_bit_count)                                                                                                                //是在接收数据位还是停止位
  127.                   {                                                                                                                                                                                //接收数据位开始
  128.                   receing_data=receing_data>>1;                                                                //向右移一位,准备拼入一位二进制数据
  129.                   if(RX_IO==1){receing_data=receing_data|0x80;}//如果收到的是二进制位"1",则拼入最高位中
  130.                   rece_bit_count=rece_bit_count-1;                                                //已接收一位,接收位计数变量计数
  131.                   }                                                                                                                                                                                //接收数据位结束
  132.                 else                                                                                                                                                                        //如果已经收完8位数据
  133.                   {                                                                                                                                                                                //就开始接收停止位
  134.                         receing=0;                                                                                                                                        //本字节已接收完毕
  135.                         if(RX_IO==1)                                                                                                                                //停止位是"1"吗
  136.                           {                                                                                                                                                                        //是“1”
  137.                                 byte_received=receing_data;                                                                //将数据输出
  138.                                 bytereceived=1;
  139. //------------------------------------------------//知道了……
  140.                                 }                                                                                                                                                                        //数据输出处理完毕
  141.                         }                                                                                                                                                                                //停止位处理完毕
  142.                 }                                                                                                                                                                                        //接收一位二进制位结束
  143.         }                                                                                                                                                                                                //接收中处理结束
  144. else                                                                                                                                                                                        //还没收到停止位,不是正在接收状态
  145.   {                                                                                                                                                                                                //等待接收开始
  146.     if(RX_IO==0)                                                                                                                                        //是一个起始位到来吗
  147.     {                                                                                                                                                                                        //是.......
  148.           receing=1;                                                                                                                                                //开始接收
  149.           rece_pls_count=4;                                                                                                                        //置接收起始位脉冲数
  150.           rece_bit_count=8;                                                                                                                        //置接收二进制位数
  151.           }                                                                                                                                                                                        //起始位处理完毕
  152.         }                                                                                                                                                                                                //等待接收完毕
  153. //----------------------------------------------------------------------------------------
  154. if(sending)                                                                                                                                                                //是正在发送状态吗
  155.   {                                                                                                                                                                                                //是……
  156.         if(--send_pls_count==0)                                                                                                        //脉冲计数够了吗
  157.           {                                                                                                                                                                                        //够了……
  158.                 send_pls_count=3;                                                                                                                        //脉冲计数复位
  159.           if(send_bit_count)                                                                                                                //是在发送数据还是要发送停止位
  160.             {                                                                                                                                                                                //发送数据开始
  161.                   TX_IO=byte_need_to_send&0x01;                                                                //从最低位开始发送数据
  162.                   byte_need_to_send=byte_need_to_send>>1;                        //移动数据准备下一次发送
  163.                   send_bit_count=send_bit_count-1;                                                //已经发送了一位二进制数要记下来
  164.                   }                                                                                                                                                                                //发送数据结束
  165.           else                                                                                                                                                                        //数据已经发送完成
  166.             {                                                                                                                                                                                //发送停止位开始
  167.                         if(stpbsed)
  168.                           {
  169.                                 sending=0;                                                                                                                                //放下旗帜表示数据已经发送完成
  170.                                 }
  171.                   TX_IO=1;                                                                                                                                                //发送停止位
  172.                         stpbsed=1;
  173.                   }                                                                                                                                                                                //停止位发送完成
  174.                 }                                                                                                                                                                                        //一位二进制位处理完成
  175.         }                                                                                                                                                                                                //发送状态处理完成
  176. com_bit_tick--;                                                                                                                                                //串口位时间滴答向下
  177. }                                                                                                                                                                                                        //中断函数结束
  178. void timer1(void) interrupt 3                                                                                        //中断服务程序
  179. {
  180. if(IO3==0)                                                                                                                                                                //一个新的过零信号到来了吗
  181.   {
  182.         trig_count_enable1=1;
  183.         trig_count_enable2=1;
  184.         }
  185. if(traic_1_on==1)
  186.   {
  187.         IO2=0;
  188.         if(trig_count_enable1==1)
  189.           {
  190.                 trig_count1++;
  191.                 if(trig_count1>=brightness1)
  192.                   {
  193.                         trig_count_enable1=0;
  194.                         trig_count1=0;
  195.                         IO2=1;
  196.                         }
  197.                 }
  198.         }
  199. if(traic_2_on==1)
  200.   {
  201.         IO1=0;
  202.         if(trig_count_enable2==1)
  203.           {
  204.                 trig_count2++;
  205.                 if(trig_count2>=brightness2)
  206.                   {
  207.                         trig_count_enable2=0;
  208.                         trig_count2=0;
  209.                         IO1=1;
  210.                         }
  211.                 }
  212.         }
  213. }
  214. unsigned char pack_ana(void)
  215.   {
  216.         checksum=0;
  217.         for(count=0;count<6;count++)
  218.           {
  219.                         checksum=checksum+zhen_tou[count];
  220.                 }
  221.         for(count=0;count<5;count++)
  222.           {
  223.                         checksum=checksum+jie_shou[count];
  224.                 }
  225.         if(checksum==jie_shou[5])
  226.           {
  227.                 return(1);
  228.                 }
  229.         else
  230.           {
  231.                 return(0);
  232.                 }
  233.         }
  234. void set_baud(unsigned char index)
  235. {
  236.   if(index>10)                                                                                                                                                        //faild value
  237.         {
  238.         index=5;
  239.         }
  240.         TR0=0;                                                                                                                                                                                //启动定时器,模拟串口开始工作
  241.         TH0=baud[index]/256;                                                                                                                        //重载值=65536-(定时器脉冲频率÷波特率÷3)
  242.         TL0=baud[index]%256;                                                                                                                        //溢出率=定时器脉冲频率÷(65536-重载值)
  243.         TR0=1;                                                                                                                                                                                //启动定时器,模拟串口开始工作
  244.         baud_index=index;
  245. }
  246. void respond_packge(void)
  247. {
  248.     com_bit_tick=100;
  249.                 while(com_bit_tick!=0);
  250.                 DE_RE=1;                                                                                                                                                                                                                //置75176为发送模式
  251.                 checksum=0;
  252.                 for(count=0;count<6;count++)
  253.                   {
  254.                         temp=zhen_tou[count];
  255.                         send_byte(temp);
  256.                         checksum=checksum+temp;
  257.                         }
  258.                 for(count=0;count<5;count++)
  259.                   {
  260.                         checksum=checksum+jie_shou[count];
  261.                         }
  262.                 jie_shou[5]=checksum;
  263.                 for(count=0;count<6;count++)
  264.                   {
  265.                         send_byte(jie_shou[count]);
  266.                         }
  267.                 DE_RE=0;                                                                                                                                                                                                                //置75176为接收模式
  268. }
  269. void execute_cmd(void)
  270. {
  271.   if(jie_shou[0]==0x00)//断开继电器命令
  272.           {
  273.                 if(jie_shou[1]==0x00){IO1=0;}//关闭一号继电器
  274.                 if(jie_shou[1]==0x01){IO2=0;}//关闭二号继电器
  275.                 if(jie_shou[1]==0x02){IO3=0;}//关闭三号继电器
  276.                 if(jie_shou[4]==0x01){respond_packge();}
  277.                 }
  278.   if(jie_shou[0]==0x01)//接通继电器命令
  279.           {
  280.                 if(jie_shou[1]==0x00){IO1=1;}//闭合一号继电器
  281.                 if(jie_shou[1]==0x01){IO2=1;}//闭合二号继电器
  282.                 if(jie_shou[1]==0x02){IO3=1;}//闭合三号继电器
  283.                 if(jie_shou[4]==0x01){respond_packge();}
  284.                 }
  285.   if(jie_shou[0]==0x02)//查询继电器命令
  286.           {
  287.                 if(jie_shou[1]==0x00){if(IO1==1){jie_shou[2]=0x01;}else{jie_shou[2]=0x00;}}
  288.                 if(jie_shou[1]==0x01){if(IO2==1){jie_shou[2]=0x01;}else{jie_shou[2]=0x00;}}
  289.                 if(jie_shou[1]==0x02){if(IO3==1){jie_shou[2]=0x01;}else{jie_shou[2]=0x00;}}
  290.                 respond_packge();
  291.                 }
  292. //---------------------
  293.   if(jie_shou[0]==0x03)//设置可控硅1亮度命令
  294.           {
  295.                 brightness1=200-jie_shou[1];
  296.                 traic_on_off();
  297.                 if(jie_shou[4]==0x01){respond_packge();}
  298.                 }
  299.   if(jie_shou[0]==0x04)//设置可控硅2亮度命令
  300.           {
  301.                 brightness2=200-jie_shou[1];
  302.                 traic_on_off();
  303.                 if(jie_shou[4]==0x01){respond_packge();}
  304.                 }
  305. //---------------------
  306.   if(jie_shou[0]==0x05)//设置并保存可控硅1亮度命令
  307.           {
  308.                 IO1=IO2=traic_1_on=traic_2_on=0;
  309.                 brightness1=200-jie_shou[1];//计算亮度值
  310.                 etmp1=read_eeprom(0x0201);//读出第二通道可控硅亮度值进行保护
  311.                 erase_eeprom(0x0200);//擦除EEPROM
  312.                 write_eeprom(0x0200,brightness1);//写入新的第一通道可控硅值
  313.                 write_eeprom(0x0201,etmp1);//写回第二通道可控硅值
  314.                 traic_on_off();//判断是否启用可控硅控制
  315.                 if(jie_shou[4]==0x01){respond_packge();}
  316.                 }
  317.   if(jie_shou[0]==0x06)//设置并保存可控硅2亮度命令
  318.           {
  319.                 IO1=IO2=traic_1_on=traic_2_on=0;
  320.                 brightness2=200-jie_shou[1];
  321.                 etmp1=read_eeprom(0x0200);//读出第一通道可控硅亮度值进行保护
  322.                 erase_eeprom(0x0200);//擦除EEPROM
  323.                 write_eeprom(0x0201,brightness2);//写入新的第二通道可控硅值
  324.                 write_eeprom(0x0200,etmp1);//写回第一通道可控硅值
  325.                 traic_on_off();//判断是否启用可控硅控制
  326.                 if(jie_shou[4]==0x01){respond_packge();}
  327.                 }
  328. //---------------------
  329.   if(jie_shou[0]==0x10)//断开继电器命令,为了兼容485继电器模块的命令
  330.           {
  331.                 IO1=0;
  332.                 if(jie_shou[4]==0x01){respond_packge();}
  333.                 }
  334.   if(jie_shou[0]==0x11)//接通继电器命令,为了兼容485继电器模块的命令
  335.           {
  336.                 IO1=1;
  337.                 if(jie_shou[4]==0x01){respond_packge();}
  338.                 }
  339.   if(jie_shou[0]==0x12)//查询继电器命令,为了兼容485继电器模块的命令
  340.           {
  341.                 if(IO1==1)
  342.                   {
  343.                         jie_shou[1]=0x01;
  344.                         }
  345.                 else
  346.                   {
  347.                         jie_shou[1]=0x00;
  348.                         }
  349.                 respond_packge();
  350.                 }
  351. //---------------------
  352.         if(jie_shou[0]==0x15)//查询从机地址
  353.           {
  354.                 jie_shou[1]=read_eeprom(0x0000);
  355.                 jie_shou[2]=~jie_shou[1];
  356.                 respond_packge();
  357.                 }
  358.         if(jie_shou[0]==0x16)//修改从机地址
  359.           {
  360.                 etmp2=read_eeprom(0x0001);
  361.                 erase_eeprom(0x0000);
  362.                 write_eeprom(0x0000,jie_shou[1]);
  363.                 write_eeprom(0x0001,etmp2);
  364.                 zhen_tou[4]=jie_shou[1];
  365.                 zhen_tou[5]=~jie_shou[1];
  366.                 if(jie_shou[4]==0x01){respond_packge();}
  367.                 }
  368.         if(jie_shou[0]==0x18)//查询从机波特率
  369.           {
  370.                 jie_shou[1]=read_eeprom(0x0001);
  371.                 if(jie_shou[1]>10)
  372.                   {
  373.                         jie_shou[1]=5;
  374.                         }
  375.                 respond_packge();
  376.                 }
  377.         if(jie_shou[0]==0x17)//设置从机波特率
  378.           {
  379.                 if(jie_shou[1]>10)
  380.                   {
  381.                         jie_shou[1]=5;
  382.                         }
  383.                 etmp1=read_eeprom(0x0000);
  384.                 erase_eeprom(0x0000);
  385.                 write_eeprom(0x0000,etmp1);
  386.                 write_eeprom(0x0001,jie_shou[1]);
  387.                 set_baud(jie_shou[1]);
  388.                 if(jie_shou[4]==0x01){respond_packge();}
  389.                 }
  390. }
  391. void close_eeprom(void)
  392.   {
  393.         eeprom_cont=0;
  394.         eeprom_cmd=0;
  395.         eeprom_star=0;
  396.         eeprom_addh=0x80;
  397.         eeprom_addl=0x00;
  398.         }
  399. unsigned char read_eeprom(unsigned int addr)
  400.   {
  401.         unsigned char dat;
  402.         eeprom_cont=0x81;
  403.         eeprom_cmd=1;
  404.         eeprom_addl=addr&0xff;
  405.         eeprom_addh=addr>>8;
  406.         eeprom_star=0x5a;
  407.         eeprom_star=0xa5;
  408.         _nop_();
  409.         _nop_();
  410.         _nop_();
  411.         dat=eeprom_data;
  412.         close_eeprom();
  413.         return(dat);
  414.         }
  415. void write_eeprom(unsigned int addr,dat)
  416.   {
  417.         eeprom_cont=0x81;
  418.         eeprom_cmd=2;
  419.         eeprom_addl=addr&0xff;
  420.         eeprom_addh=addr>>8;
  421.         eeprom_data=dat;
  422.         eeprom_star=0x5a;
  423.         eeprom_star=0xa5;
  424.         _nop_();
  425.         _nop_();
  426.         _nop_();
  427.         close_eeprom();
  428.         }
  429. void erase_eeprom(unsigned int addr)
  430.   {
  431.         eeprom_cont=0x81;
  432.         eeprom_cmd=3;
  433.         eeprom_addl=addr&0xff;
  434.         eeprom_addh=addr>>8;
  435.         eeprom_star=0x5a;
  436.         eeprom_star=0xa5;
  437.         _nop_();
  438.         _nop_();
  439.         _nop_();
  440.         close_eeprom();
  441.         }
  442. void byte_reced(void)
  443.   {
  444.         if(bytereceived==1)
  445.           {
  446.                 bytereceived=0;
  447.                 if(data_receive_enable)
  448.                   {
  449.                         jie_shou[fr_num]=byte_received;
  450.                         fr_num++;
  451.                         if(fr_num>=6)
  452.                           {
  453.                                 data_receive_enable=0;
  454.                                 fr_num=0;
  455.                                 if(pack_ana()==1)
  456.                                   {
  457.                                         execute_cmd();
  458.                                         }
  459.                                 }
  460.                         }
  461.                 else
  462.                   {
  463.                   if( (zhen_tou[verify]==byte_received) || (cast_tou[verify]==byte_received))
  464.                     {
  465.                           verify++;
  466.                           if(verify>=6)
  467.                             {
  468.                                   data_receive_enable=1;
  469.                                         verify=0;
  470.                                   }
  471.                           }
  472.                   else
  473.                     {
  474.                           verify=0;
  475.                           data_receive_enable=0;
  476.                           if(zhen_tou[verify]==byte_received)
  477.                             {
  478.                                   verify=1;
  479.                                   }
  480.                           }
  481.                         }
  482. //------------------------------------------------//
  483.     }
  484.         }
  485. void traic_on_off(void)
  486.   {
  487.         if(brightness1>=200){brightness1=199;traic_1_on=0;}else{traic_1_on=1;}
  488.         if(brightness2>=200){brightness2=199;traic_2_on=0;}else{traic_2_on=1;}
  489.         if(traic_1_on==1 || traic_2_on==1){P3M0=0X36;}else{P3M0=0x3c;}
  490.         }
复制代码

回复 支持 反对

使用道具 举报 送花

  • 打卡等级:偶尔看看III
  • 打卡总天数:55
  • 最近打卡:2025-05-02 08:32:59

718

主题

1万

回帖

1万

积分

管理员

积分
15630
发表于 2024-1-17 16:17:27 | 显示全部楼层
用RMB0.59的可以仿真的 STC8G1K08-36I-SOP8
截图202401171615474304.jpg

截图202401171616126148.jpg


截图202401171616344020.jpg


最新数据手册下载
深圳国芯人工智能有限公司-产品_STC8G系列 (stcai.com)
回复 支持 反对

使用道具 举报 送花

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|深圳国芯人工智能有限公司 ( 粤ICP备2022108929号-2 )

GMT+8, 2025-5-2 22:10 , Processed in 0.155264 second(s), 106 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表