精华内容
参与话题
问答
  • 新唐单片机选型pdf

    2018-10-10 14:52:25
    新唐单片机选型,里面包含了几乎所有新唐单片机型号的选型。可以作为选型参考
  • 玩转新唐单片机

    2018-10-19 21:53:26
    学习新塘单片机使用资料 玩转新唐M0/M4
  • 新唐M0单片机IAP,该文档介绍IAP的概念和用法,以及ISP与IAP的区别,适用于新唐任何支持IAP的Cortex-m0系列
  • 新唐单片机I91200程序demo,
  • 新唐单片机模拟IIC

    2019-08-07 16:53:42
    发一个新唐M051单片机的 IIC使用的程序: #include “SmartM_M0.h” #define DEBUGMSG printf #define EEPROM_SLA 0xA0 #define EEPROM_WR 0x00 #define EEPROM_RD 0x01 #define I2C_CLOCK 13 #define PAGE_SIZE 8 /...

    新唐新唐单片机模拟IIC

    #define SCL PA0
    #define SDA PA1
    #define NACK 1
    #define ACK 0
    
    #define INA220_CONFIG_REGISTER			0x00
    #define INA220_SHUNT_VOLTAGE_REGISTER 	0x01
    #define INA220_BUS_VOLTAGE_REGISTER		0x02
    #define INA220_POWER_REGISTER			0x03
    #define INA220_CURRENT_REGISTER			0x04
    #define INA220_CALIBRATION_REGISTER		0X05
    //配置引脚
    void anolog_iic_init(void)
    {
    	GPIO_SetMode(PA, BIT0, GPIO_PMD_OUTPUT);
        GPIO_SetMode(PA, BIT1, GPIO_PMD_QUASI);
    }
    //iic起始信号
    void anolog_iic_start(void)
    {
    	SCL = 1;
    	SDA = 1;
    	TIMER_Delay(TIMER3,4);
    	
    	SDA = 0;
    	TIMER_Delay(TIMER3,4);
    	
    	SCL = 0;
    }
    //iic停止信号
    void anolog_iic_stop(void)
    {
    	SCL = 0;
    	SDA = 0;
    	TIMER_Delay(TIMER3,4);
    	
    	SCL = 1;
    	TIMER_Delay(TIMER3,4);
    	
    	SDA = 1;
    }
    //等待应答
    uint8_t anolog_iic_wait_ack(void)
    {
    	uint8_t i = 0;
    	SDA = 1;
    	TIMER_Delay(TIMER3,4);
    	
    	SCL = 1;
    	TIMER_Delay(TIMER3,4);
    	
    	while(SDA){
    		i++;
    		DEBUG("wait %d ...\n",i);
    		if(i > 250){
    			anolog_iic_stop();
    			return NACK;
    		}
    	}
    	
    	SCL = 0;
    	TIMER_Delay(TIMER3,4);
    	
    	return ACK;
    }
    //主机发送NACK应答
    void anolog_iic_send_nack(void)
    {
    	SCL = 1;
    	SDA = 1;
    	TIMER_Delay(TIMER3,4);
    	SCL = 0;
    }
    //主机发送ACK应答
    void anolog_iic_send_ack(void)
    {
    	SCL = 1;
    	SDA = 0;
    	TIMER_Delay(TIMER3,4);
    	SCL = 0;
    }
    //iic往从机写一个字节
    void anolog_iic_send_byte(uint8_t byte)
    {
    	uint8_t i = 0;
    	DEBUG("iic send 0x%02x\n",byte);
    	for(i = 0; i<8; i++){
    		SCL = 0;
    		TIMER_Delay(TIMER3,4);
    		if(byte&(1<<(7-i)))
    			SDA = 1;
    		else
    			SDA = 0;
    		TIMER_Delay(TIMER3,4);
    		
    		SCL = 1;
    		TIMER_Delay(TIMER3,4);
    	}
    	
    	SCL = 0;
    	SDA = 1;
    }
    //iic从从机读一个字节
    uint8_t anolog_iic_read_byte(uint8_t ack_flag)
    {
    	uint8_t i = 0, data = 0;
    	
    	SDA = 1;
    	SCL = 0;
    	TIMER_Delay(TIMER3,4);
    	
    	for(i = 0; i<8; i++){
    		SCL = 1;
    		TIMER_Delay(TIMER3,4);
    		data <<=1;
    		
    		data |= SDA;
    		TIMER_Delay(TIMER3,4);
    		
    		SCL = 0;
    		TIMER_Delay(TIMER3,4);
    	}
    	
    	if(ack_flag == ACK)
    		anolog_iic_send_ack();
    	else
    		anolog_iic_send_nack();
    	
    	DEBUG("iic read 0x%02x\n",data);
    	return data;
    }
    
    
    //写
    	anolog_iic_start();
    	anolog_iic_send_byte(slave_addr<<1);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(INA220_CONFIG_REGISTER);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(ina220_config_data[0]);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(ina220_config_data[1]);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_stop();
    	
    	anolog_iic_start();
    	anolog_iic_send_byte(slave_addr<<1);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(INA220_CALIBRATION_REGISTER);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(ina220_calibration_data[0]);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_send_byte(ina220_calibration_data[1]);
    	if(ACK != anolog_iic_wait_ack())
    		return;
    	anolog_iic_stop();
    
    //读
    	anolog_iic_start();
    	anolog_iic_send_byte(slave_addr<<1);
    	if(ACK != anolog_iic_wait_ack())
    		return -1;
    	anolog_iic_send_byte(reg_addr);
    	if(ACK != anolog_iic_wait_ack())
    		return -1;
    	
    	anolog_iic_start();
    	anolog_iic_send_byte((slave_addr<<1)|0x01);
    	if(ACK != anolog_iic_wait_ack())
    		return -1;
    	val = anolog_iic_read_byte(ACK);
    	//if(ACK != anolog_iic_wait_ack())
    	//	return -1;
    	val = (val<<8) + anolog_iic_read_byte(NACK);
    
    展开全文
  • 新唐单片机开发记录

    千次阅读 2019-07-04 08:55:14
    1.使用keil调试过程中,不可以开启看门狗,不然会报错:nu_Link ice:cmderror-get register data error 2.官方方法,没有深入尝试,目前的解决方法是,kill掉所有的端点,再退出调试 µVISION: Error: ...

    1.使用keil调试过程中,不可以开启看门狗,不然会报错:nu_Link ice:cmderror-get register data error

     

    2.官方方法,没有深入尝试,目前的解决方法是,kill掉所有的端点,再退出调试

    µVISION: Error: Encountered an improper argument


    Information in this knowledgebase article applies to:

    • MDK-ARM Version 5.x

    SYMPTOM

    Under some circumstances, an error dialog with the text Encountered an improper argument might show up when you exit a debug session. If this happens, µVision needs to be terminated with the Windows Task Manager. In most cases, customers with Asian Windows versions are affected by this issue when Asian characters are used in the project path.

    CAUSE

    The µVision 5 debugger is currently not able to process DWARF debug information which contains folder or file names with UTF-8 characters.

    RESOLUTION

    Use only ASCII characters in the folder and file names of your project and all your source files and libraries.

    SEE ALSO

    展开全文
  • 新唐单片机项目总结

    2017-08-24 14:18:00
    最近做了两个单片机项目,新唐的029和mini58ZDE的MCU,都是cortex-M0,一个厂家所以API基本一致,大致了解了串口中断及定时器功能以及ADC采样相关的编程内容。 4G项目即mini58zde,主要是从GPS中读数据然后从另外一...
    最近做了两个单片机项目,新唐的029和mini58ZDE的MCU,都是cortex-M0,一个厂家所以API基本一致,大致了解了串口中断及定时器功能以及ADC采样相关的编程内容。
    4G项目即mini58zde,主要是从GPS中读数据然后从另外一个串口转发出去
     
     
    GPS模块  ------ 串口1接收 ----数据处理组包 -----串口0发送------上位机
     
    GPS模块是不断地有数据来,数据格式为
    $GNRMC,014053.00,A,3205.65222,N,11853.26056,E,0.038,,030817,,,D,V*18
    $GNGGA,014053.00,3205.65222,N,11853.26056,E,2,14,0.81,52.6,M,3.1,M,,*41
    $GNGSA,A,3,01,09,11,16,08,30,28,,,,,,1.36,0.81,1.09,1*0A
    $GNGSA,A,3,03,07,08,01,02,04,13,,,,,,1.36,0.81,1.09,4*08
    $GPGSV,4,1,16,01,47,176,41,04,12,058,,07,66,274,,08,55,026,30,0*63
    $GPGSV,4,2,16,09,10,223,30,10,03,059,28,11,72,198,46,16,16,098,45,0*6F
    $GPGSV,4,3,16,17,02,245,23,22,05,152,18,23,02,197,,27,23,049,18,0*65
    $GPGSV,4,4,16,28,17,303,37,30,36,311,29,42,43,137,42,50,43,137,42,0*67
    $BDGSV,3,1,10,01,48,143,43,02,37,232,39,03,53,196,43,04,33,121,35,0*78
    $BDGSV,3,2,10,05,16,252,,07,76,112,44,08,69,219,44,10,74,327,,0*7E
    $BDGSV,3,3,10,13,43,220,42,17,50,110,,0*75
    $GNTXT,1,1,01,ANTENNA OPEN*3B
    主要处理的数据是GNRMC和GNGGA,用了状态机的方法判断前面GMRMC/GNGGA之后直接判断是否是 ‘*’,因为逐个判断状态太多,很复杂而且容易出错,读取到 * 之后,再读校验位,校验成功的话,将数据拷贝到 处理缓冲区置标志位,在主程序中检测标志位,然后处理数据,更新数据
    串口0 既要接受命令也要返回数据,串口0的数据接受为固定长度的,在这里也使用了状态机,提取出命令码之后,将命令码写到命令队列中,这样就能及时响应下一个命令,不用死等,数据接收与数据处理独立运行,不会造成高耦合的现象
     
    串口0 接收数据提取命令码---------压入命令队列 POP(中断中实现)
     
    串口1 接受提取有效数据-------------更新GPS数据结构体(中断中实现)
     
    主程序 读取命令队列----------------出列PUSH ,根根不同的命令将GPS数据组包通过串口0发出去。
    主程序中使能看门狗,使用定时器喂狗。
    开发中遇到的一些问题:
    1.设计思路有问题,没理清流程,一开始以为接受到命令码马上处理,造成串口0一直要等待
    2.看门狗操作寄存器是写保护,要先解保护才能操作,厂家给的示例不对,造成看门狗使能失败,喂狗失败。
    3.状态机使用出错,状态太多,两条命令混合处理,造成代码混乱,很难理清。
    4.铁塔协议花了很久才明白是怎么一回事,要多看代码才行。
    5.内部时钟的配置,要根据实际情况来,没有外部时钟就不能用,
     
    029电源控制模块:
    电源充放电管理的一个小模块,几个条件限制充放电
    低于5度不充电,电压低于6.1V或者放电时间到了20MIN不放电
    使用了GPIO的中断 确定什么时候开始放电,电源关闭,下降沿触发,电池开始放电。重新上电,上升沿,电池可以开始充电。代码很简单主要是ADC采样还有定时器中断的问题,
    电压和温度都是通过ADC采样转换实现的,使用内部温度,一个管脚配置成温度传感器,然后进行ADC采样,电压基准源采用的是3.3V,这个项目没有串口,打印会造成很多异常,debug下正常但正常跑起来却有问题,所以调试时尽量少用或者不用printf,整个程序很简单,就是控制GPIO口
     
    开发中遇到的一些问题:
    1.添加printf造成程序异常,定时器异常
    2.一上电就进行ADC采样不对,电压还没有升上来,采样的值很小,等待10ms之后采样值就对了
    3.float 数据计算及比较要注意
    void UART1_RT_STATE(uint8_t u8InChar)
    {
    		uint8_t	TempBuf[3]= {0};
    		uint8_t	CheckSum = 0;
    					switch(x_RecvState)
    				 { 
    					 case WaitingForHeads:
    						 if(u8InChar == '$')
    						 {
    							 UART1_Rx_buff[0] = u8InChar;
    								x_RecvState = WaitingForG;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForG:
    						 if(u8InChar == 'G')
    						 {
    							 UART1_Rx_buff[1] = u8InChar;
    							 x_RecvState = WaitingForN;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForN:
    					 if(u8InChar == 'N')
    						 {
    							 UART1_Rx_buff[2] = u8InChar;
    							 x_RecvState = WaitingForG_R;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForG_R:
    							if(u8InChar == 'G')
    						 {
    							 UART1_Rx_buff[3] = u8InChar;
    							 x_RecvState = WaitingForG_2;
    						 }
    							else if(u8InChar == 'R')
    						 {
    							 UART1_Rx_buff[3] = u8InChar;
    							 x_RecvState = WaitingForM;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForG_2:
    							if(u8InChar == 'G')
    						 {
    							 UART1_Rx_buff[4] = u8InChar;
    							 x_RecvState = WaitingForA;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForM:
    							if(u8InChar == 'M')
    						 {
    							 UART1_Rx_buff[4] = u8InChar;
    							 x_RecvState = WaitingForC;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForC:
    							if(u8InChar == 'C')
    						 {
    							 UART1_Rx_buff[5] = u8InChar;
    							 x_RecvState = WaitingForRs;
    							 rcv_count = 6;
    							 gps_flag = RMC;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForA:
    							if(u8InChar == 'A')
    						 {
    							 UART1_Rx_buff[5] = u8InChar;
    							 x_RecvState = WaitingForGs;
    							  rcv_count = 6;
    							 gps_flag = GGA;
    						 }
    						 else
    						 {
    							 x_RecvState = WaitingForHeads;
    							 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 }
    						 break;
    					 case WaitingForRs:	
    							if(u8InChar != '*')
    						 {
    							 UART1_Rx_buff[rcv_count++] = u8InChar;
    							 if(rcv_count > 65)
    							 {
    									x_RecvState = WaitingForHeads;
    									memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    							 }
    							 else
    							 x_RecvState = WaitingForRs;
    						 }
    						 else
    						 {
    							 if(rcv_count != 65)
    							 {
    								 if(rcv_count == 37)
    								 {		 
    									 gps_flag = NOUSE;
    									 DATA_ANY = 1;
    								 }
    									x_RecvState = WaitingForHeads;
    									memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    							 }	
    							else
    							{
    						 	  UART1_Rx_buff[rcv_count++] = u8InChar;								
    							  x_RecvState = WaitingForChsum_1;
    							}
    						 }	 
    						 break;
    					 case WaitingForGs:	
    							if(u8InChar != '*')
    						 {
    							 UART1_Rx_buff[rcv_count++] = u8InChar;
    							 if(rcv_count > 68)
    							 {
    									x_RecvState = WaitingForHeads;
    									memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    							 }
    							 else
    							 x_RecvState = WaitingForGs;
    						 }
    						 else
    						 {
    							 if(rcv_count != 68)
    							 {
    								 if(rcv_count == 36)
    								 {		 
    									 gps_flag = NOUSE;
    									 DATA_ANY = 1;
    								 }
    									x_RecvState = WaitingForHeads;
    									memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    							}	
    							else
    							{
    									UART1_Rx_buff[rcv_count++] = u8InChar;								
    									x_RecvState = WaitingForChsum_1;
    							}
    						 }	 
    						 break;
    	
    					 case WaitingForChsum_1:
    	//								printf("gf = %d\n",gps_flag);
    
    							 UART1_Rx_buff[rcv_count++] = u8InChar;
    							 x_RecvState = WaitingForChsum_2;
    								break;
    					 case WaitingForChsum_2:
    							TempBuf[0]= UART1_Rx_buff[rcv_count-1];
    							TempBuf[1]=u8InChar;
    							TempBuf[2]=0;
    							CheckSum=strtoul(TempBuf,NULL,16);
    							UART1_Rx_buff[rcv_count++] = u8InChar;
    					 		Checkret = GpsChecksum(CheckSum);					 
    							 x_RecvState = WaitingForEnd_1;
    							break;
    
    					 case WaitingForEnd_1:
    							if(u8InChar == 0xD)
    						 {
    							 UART1_Rx_buff[rcv_count++] = u8InChar;
    							 x_RecvState = WaitingForHeads;
    							 if(Checkret)
    							 {
    								 #if 0
    								if(gps_flag == GGA)
    							P13 = 1;
    						if(gps_flag == RMC)
    							P13 = 0;
    						#endif
    									memcpy(UART1_Pr_buff,UART1_Rx_buff,rcv_count);						
    								  Checkret = 0;
    								  DATA_ANY = 1;
    							 }
    						 }
    						 x_RecvState = WaitingForHeads;
    						 rcv_count = 0;
    						 memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 break;
    					 default:
    						 rcv_count = 0;
    						 	x_RecvState = WaitingForHeads;
    							memset(UART1_Rx_buff,0,sizeof(UART1_Rx_buff));
    						 break;
    					 }			 
    }
    

      

    转载于:https://www.cnblogs.com/yinseyingji/p/7422815.html

    展开全文
  • SPIFlash W25Q64 新唐单片机程序

    热门讨论 2014-01-21 17:37:15
    SPIFlash W25Q64 新唐单片机程序 可读,可写, 基本的操作
  • 新唐单片机N76E003AD原理图和封装。说明:单片机封装为TSSOP-20,资源包括原理图和封装,请详细阅读后下载。
  • 最新的选型指南,多增加了nuc123、nuc200系列,其他系列flash和SRAM都有所增大
  • 新唐单片机keil驱动问题

    千次阅读 2017-01-10 18:12:18
    1:新唐单片机keil编译工具,资料都可以在新唐官网下载。keil驱动软件要安装在keil安装的目录下,今天安装了很久,一直提示不成功,就是因为驱动Nu-link driver 没有安装到keil安装目录下。  2:刚开始项目选用M...

    1:新唐单片机keil编译工具,资料都可以在新唐官网下载。keil驱动软件要安装在keil安装的目录下,今天安装了很久,一直提示不成功,就是因为驱动Nu-link driver 没有安装到keil安装目录下。 

    2:刚开始项目选用M0518LC2AE单片机(36K FLASH),后来因程序存储区不够,又选用M0518LD2AE单片机(68K FLASH)。但keil编译时提示选用芯片的容量不够,keil重启无效,最后keil卸载后重装可以。

    展开全文
  • 单片机入门学习笔记6:新唐单片机N76E003 学习新唐单片机是从2018年3月开始的,之前一点也不懂这一块单片机,之后脉络变的越来越清晰。 由于N76E003档次太低,新塘科技官方的管脚配置,芯片选型……都没有这一块...
  • 新唐单片机N76E003 控制两路直流电机 加3呼吸灯 有时序
  • 里面一共有两个文件,一个是单片机手册,一个是所有资源的相关例程文件。
  • 新唐单片机 ICP 史上最全教程 新唐单片机 ICP烧录教程 目录 新唐单片机 ICP 史上最全教程 1、ICP软件安装 2、连接设备 3、设备供电 4、开启软件 5、欢迎界面 6、补充事项 7、建立连接,单击连接按键,...
  • 利用 CAN总线技术解决楼宇电梯控制问题 根据市场调查报告指出 2017 年全球楼宇电梯的新安装量约为 82 万套,已安装的存量则约为 1400 万套。伴随全球都市化集中程度的增加,公寓大厦的建置量亦随之攀升,推升了楼宇...
  • void Read_2556(unsigned char channel) { unsigned int i = 0; channel //通道 控制位为7-4位 Vaa=0; //电压值初始为0 CS_2556_H; //先禁止所有功能 CLK_2556_L; //在CS置低前将CLK置低 ... Delay
  • 51官方资料,专业公司翻译,51单片机设计必备.每个设计细节都有解释.
  • 新唐51单片机----挖坑

    2019-12-09 16:34:07
    1、定时器3中断与串口0中断冲突 开启了串口0中断,同时开启了定时器3中断,串口0中断处理函数如下: void SerialPort0_ISR(void) interrupt 4 { if (RI==1) //这个中断时接收跟发送共用的 ...
  • 最近在开发新唐单片机,所以整理了一下烧录软件,分享给大家!希望能够帮到大家,少走一点弯路!
  • 新唐N76e003 单片机程序分析

    千次阅读 2018-05-19 10:21:16
    在Function_define.h文件#ifdef FOSC_160000 // if Fsys = 16MHz #define TIMER_DIV12_VALUE_10us 65536-13 //13*12/16000000 = 10 uS, // Timer divider = 12 for TM0/TM1 #define TIMER_DIV12_VALUE_...
  • ;测试PWM5输出端口P0.3,LED闪烁端口是P1.5;以下是汇编代码;功能寄存器定义SFRS EQU 91HTA EQU 0C7HPWMCON0 EQU 0D8HPWMCON1 EQU 0DFHCKCON EQU 08EHPWMPL EQU 0D9HPWMPH EQU 0D1HPWM0L EQU ...
  • 新唐(Nuvoton)8051单片机开发指南

    万次阅读 2018-08-20 15:20:32
    官网:新唐(Nuvoton) 8位8051系列-N76E003AT20(兼容STM8S003F3P6) 第三方资料:N76E003开发板用户手册.pdf 二、开发环境搭建 用户指南UM_NuTiny-SDK-N76E003_EN_Rev1.01.pdf 安装 Keil C-51 ...
  • 因为我选择了全部擦除再下载的原因,如果选择只擦除要下载程序需要的空间就不会出现被复位了。其更改设置在

空空如也

1 2 3 4 5 ... 20
收藏数 461
精华内容 184
关键字:

新唐单片机