eprim安装程序电脑系统-win10安装eprime

1.求无向连通图的生成树（用c语言设计程序）

2.帮帮帮忙啊，求解关于nRF24L01程序,程序如下，我用了1602显示，

3.[Linux]编写一个简单的C语言程序，编写Makefile文件。

4.求一个nrf24l01模块简易收发程序，越简单越好，只传输一个数就可以了，单向传输 恳求

5.什么是Prim算法?

求无向连通图的生成树（用c语言设计程序）

不知道你要的是不是这个 完整实现如下： #define INFINITY 65535typedef int status;# include <stdio.h># include <stdlib.h># include <conio.h># include "string.h"# define maxlen 10typedef struct{ char vexs[maxlen][maxlen];/*顶点信息集合,我们用它来存入顶点名字*/ int vexnum,arcnum;/*顶点数和边数*/ int arcs[maxlen][maxlen];/*邻接矩阵*/}graph;//定位输入节点的名称int LocateVex(graph G,char u[maxlen]){int i;for(i=0;i<G.vexnum;++i) if(strcmp(u,G.vexs[i])==0) return i; return -1;} void prim(graph &g)/*最小生成树*/{ int i,j,k,min,w,flag; int lowcost[maxlen];/*权值*/ int closet[maxlen];/*最小生成树结点*/ char va[maxlen],vb[maxlen]; //初始化邻接矩阵 //printf("请输入顶点数和边数：\n"); //scanf("%d%d",&g.vexnum,&g.arcnum); g.vexnum=6; g.arcnum=10; printf("请输入顶点信息(我们这里指名字)：\n"); for(int j=0;j<g.vexnum;j++) scanf("%s",g.vexs[j]); for(i=0;i<g.vexnum;++i) for(j=0;j<g.vexnum;++j)//初始化邻接矩阵 { g.arcs[i][j]=INFINITY; //任意两个顶点间距离为无穷大。 }//for /*printf("请输入%d条弧的弧尾 弧头 权值（以空格为间隔)\n",g.arcnum); for(k=0;k<g.arcnum;++k) { scanf("%s%s%d%*c",va,vb,&w);//用%*c吃掉回车符 i=LocateVex(g,va); //注意，这里定义的是char va[5]，也就是说va是首地址 j=LocateVex(g,vb); g.arcs[i][j]=w; //无向网 g.arcs[j][i]=w; //无向网 }//for */ g.arcs[0][1]=6; g.arcs[1][0]=6; g.arcs[0][2]=1; g.arcs[2][0]=1; g.arcs[0][3]=5; g.arcs[3][0]=5; g.arcs[1][2]=5; g.arcs[2][1]=5; g.arcs[1][4]=3; g.arcs[4][1]=3; g.arcs[2][3]=5; g.arcs[3][2]=5; g.arcs[2][4]=6; g.arcs[4][2]=6; g.arcs[2][5]=4; g.arcs[5][2]=4; g.arcs[3][5]=2; g.arcs[5][3]=2; g.arcs[4][5]=6; g.arcs[5][4]=6; printf("最小生成树的边为:\n"); for(i=1;i<g.vexnum;i++) { lowcost[i]=g.arcs[0][i]; closet[i]=1; } closet[0]=0; //初始v1是属于集合U的，即设它是最小生成树中节点的一员 j=1; //V是顶点集合 for(i=1;i<g.vexnum;i++) { min=lowcost[j]; k=i; for(j=1;j<g.vexnum;j++) if(lowcost[j]<min&&closet[j]!=0) { min=lowcost[j]; k=j; //记录当前要加入集合U的节点号 }//if if(i==1) flag=0; else flag=closet[k]; //还没有加入集合U的节点的closet[]值是 //记录了上一次加入集合U的节点号 closet[k]=0; //将刚刚找到的点加入到集合U中 printf("(%s,%s),",g.vexs[k],g.vexs[flag]);//输出刚刚找到的最小生成树树枝 for(j=1;j<g.vexnum;j++) if(g.arcs[k][j]<lowcost[j]&&closet[j]!=0) { lowcost[j]=g.arcs[k][j]; //更新lowcost[]的值，且在还没有加入U集合的 //的closet[]中记录刚刚加入U集合的节点号以备 //下一循环中输出用 closet[j]=k; } }} int main(){graph g;prim(g);}

帮帮帮忙啊，求解关于nRF24L01程序,程序如下，我用了1602显示，

#include <reg52.h>

#include <intrins.h>

#define uint unsigned int

#define uchar unsigned char

#define TX_ADDR_WITDH 5//发送地址宽度设置为5个字节

#define RX_ADDR_WITDH 5

#define TX_DATA_WITDH 8

#define RX_DATA_WITDH 8

/******************************************************************

// nRF24L01指令格式：

*******************************************************************/

#define R_REGISTER 0x00 // 读寄存器

#define W_REGISTER 0x20 // 写寄存器

#define R_RX_PLOAD 0x61 // 读RX FIFO有效数据，1-32字节，当读数据完成后，数据被清除，应用于接收模式

#define W_TX_PLOAD 0xA0 // 写TX FIFO有效数据，1-32字节，写操作从字节0开始，应用于发射模式

#define FLUSH_TX 0xE1 // 清除TX FIFO寄存器，应用于发射模式

#define FLUSH_RX 0xE2 // 清除RX FIFO寄存器，应用于接收模式

#define REUSE_TX_PL 0xE3 // 重新使用上一包有效数据，当CE为高过程中，数据包被不断的重新发射

#define NOP 0xFF // 空操作，可以用来读状态寄存器

/******************************************************************

// nRF24L01寄存器地址

*******************************************************************/

#define CONFIG 0x00 // 配置寄存器

#define EN_AA 0x01 // “自动应答”功能寄存器

#define EN_RX_ADDR 0x02 // 接收通道使能寄存器

#define SETUP_AW 0x03 // 地址宽度设置寄存器

#define SETUP_RETR 0x04 // 自动重发设置寄存器

#define RF_CH 0x05 // 射频通道频率设置寄存器

#define RF_SETUP 0x06 // 射频设置寄存器

#define STATUS 0x07 // 状态寄存器

#define OBSERVE_TX 0x08 // 发送检测寄存器

#define CD 0x09 // 载波检测寄存器

#define RX_ADDR_P0 0x0A // 数据通道0接收地址寄存器

#define RX_ADDR_P1 0x0B // 数据通道1接收地址寄存器

#define RX_ADDR_P2 0x0C // 数据通道2接收地址寄存器

#define RX_ADDR_P3 0x0D // 数据通道3接收地址寄存器

#define RX_ADDR_P4 0x0E // 数据通道4接收地址寄存器

#define RX_ADDR_P5 0x0F // 数据通道5接收地址寄存器

#define TX_ADDR 0x10 // 发送地址寄存器

#define RX_PW_P0 0x11 // 数据通道0有效数据宽度设置寄存器

#define RX_PW_P1 0x12 // 数据通道1有效数据宽度设置寄存器

#define RX_PW_P2 0x13 // 数据通道2有效数据宽度设置寄存器

#define RX_PW_P3 0x14 // 数据通道3有效数据宽度设置寄存器

#define RX_PW_P4 0x15 // 数据通道4有效数据宽度设置寄存器

#define RX_PW_P5 0x16 // 数据通道5有效数据宽度设置寄存器

#define FIFO_STATUS 0x17 // FIFO状态寄存器

//*********************************************************************************

uchar sta; // 状态变量

#define RX_DR (sta & 0x40) // 接收成功中断标志

#define TX_DS (sta & 0x20) // 发射成功中断标志

#define MAX_RT (sta & 0x10) // 重发溢出中断标志

sbit CE=P2^0;

sbit IRQ=P2^5;

sbit CSN=P2^1;

sbit MOSI=P2^3;

sbit MISO=P2^4;

sbit SCK=P2^2;

sbit LED=P3^2;

uchar code TX_Addr[]={0x34,0x43,0x10,0x10,0x01};

uchar code TX_Buffer[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};

uchar RX_Buffer[RX_DATA_WITDH];

void _delay_us(uint x)

{

uint i,j;

for (j=0;j<x;j++)

for (i=0;i<12;i++);

}

void _delay_ms(uint x)

{

uint i,j;

for (j=0;j<x;j++)

for (i=0;i<120;i++);

}

void nRF24L01_Init(void)

{

_delay_us(2000);

CE=0;

CSN=1;

SCK=0;

IRQ=1;

}

uchar SPI_RW(uchar byte)

{

uchar i;

for(i=0;i<8;i++)

{

if(byte&0x80)

MOSI=1;

else

MOSI=0;

byte<<=1;

SCK=1;

if(MISO)

byte|=0x01;

SCK=0;

}

return byte;

}

uchar SPI_W_Reg(uchar reg,uchar value)

{

uchar status;

CSN=0;

status=SPI_RW(reg);

SPI_RW(value);

CSN=1;

return status;

}

uchar SPI_R_byte(uchar reg)

{

uchar status;

CSN=0;

SPI_RW(reg);

status=SPI_RW(0);

CSN=1;

return status;

}

uchar SPI_R_DBuffer(uchar reg,uchar *Dat_Buffer,uchar Dlen)

{

uchar reg_value,i;

CSN=0;

reg_value=SPI_RW(reg);

for(i=0;i<Dlen;i++)

{

Dat_Buffer[i]=SPI_RW(0);

}

CSN=1;

return reg_value;

}

uchar SPI_W_DBuffer(uchar reg,uchar *TX_Dat_Buffer,uchar Dlen)

{

uchar reg_value,i;

CSN=0;

reg_value=SPI_RW(reg);

for(i=0;i<Dlen;i++)

{

SPI_RW(TX_Dat_Buffer[i]);

}

CSN=1;

return reg_value;

}

void nRF24L01_Set_RX_Mode(void)

{

CE=0;//待机

SPI_W_DBuffer(W_REGISTER+TX_ADDR,TX_Addr,TX_ADDR_WITDH);

SPI_W_DBuffer(W_REGISTER+RX_ADDR_P0,TX_Addr,TX_ADDR_WITDH);

SPI_W_Reg(W_REGISTER+EN_AA,0x01);//auot ack

SPI_W_Reg(W_REGISTER+EN_RX_ADDR,0x01);

SPI_W_Reg(W_REGISTER+SETUP_RETR,0);

SPI_W_Reg(W_REGISTER+RX_PW_P0,RX_DATA_WITDH);

SPI_W_Reg(W_REGISTER+RF_CH,0);

SPI_W_Reg(W_REGISTER+RF_SETUP,0x07);//0db,lna

SPI_W_Reg(W_REGISTER+CONFIG,0x0f);

CE=1;

_delay_ms(5);

}

uchar nRF24L01_RX_Data(void)

{

//uchar i,status;

sta=SPI_R_byte(R_REGISTER+STATUS);

if(RX_DR)

{

CE=0;

SPI_R_DBuffer(R_RX_PLOAD,RX_Buffer,RX_DATA_WITDH);

//P3=RX_Buffer[0];

SPI_W_Reg(W_REGISTER+STATUS,0xff);

CSN=0;

SPI_RW(FLUSH_RX);

CSN=1;

return 1;

}

else

return 0;

}

void main(void)

{

uchar i;

P0=0xff;

P1=0xff;

P2=0xff;

P3=0xff;

_delay_us(1000);

nRF24L01_Init();

while(1)

{

nRF24L01_Set_RX_Mode();

_delay_ms(100);

if(nRF24L01_RX_Data())

{

LED=0;

//delay_ms(300);

}

else

LED=1;

}

}

这个是通过测试了的,您可以参考一下,没有用到中断,是用查询的方式,希望对你有帮助吧~!!

[Linux]编写一个简单的C语言程序，编写Makefile文件。

八 环境变量

8.1 查看环境变量

$ env ? 显示所有的环境变量设置

$ echo $ENV_VARIABLE ? 显示指定环境变量的设置

例：

$ echo $PATH

/bin:/etc:/usr/bin:/tcb/bin

8.2 设定环境变量

$ ENV_VARIABLE=XXX;export ENV_VARIABLE

例：

$ PATH=$PATH:$INFORMIXDIR/bin;export PATH ? 将环境变量PATH设定为原PATH值+$INFORMIXDIR/bin

8.3 取消环境变量设置

$ unset $ENV_VARIABLE

例：

$ set GZJ=gzj;export GZJ ? 设置环境变量GZJ

$ echo $GZJ

gzj ? 显示环境变量值

$ unset $GZJ ? 取消环境变量GZJ的设置

$ echo $GZJ

已取消

一 makefile规则

makefile是一个make的规则描述脚本文件，包括四种类型行：目标行、命令行、宏定义行和make伪指令行（如“include”）。makefile文件中注释以“#”开头。当一行写不下时，可以用续行符“\”转入下一行。

1.1 目标行

目标行告诉make建立什么。它由一个目标名表后面跟冒号“:”，再跟一个依赖性表组成。

例：

example: depfile deptarget

该目标行指出目标example与depfile和deptarget有依赖关系，如果depfile或deptarget有修改，则重新生成目标。

example1 example2 example3: deptarget1 deptarget2 depfile

该目标行指出目标名表中的example1、example2、example3这三个各自独立的目标是用相同的依赖列表和规则生成的。

clean:

空的依赖列表说明目标clean没有其他依赖关系。

目标行后续的以Tab 开始的行是指出目标的生成规则，该Tab字符不能以空格代替。例如：

example.o:example.c example.h

cc –c example.c

该例子指出目标example.o依赖于example.c和example.h。如果example.c或example.h其中之一改变了，就需要执行命令cc –c example.c重新生成目标example.o。

可以用文件名模式匹配来自动为目标生成依赖表，如：

prog: *.c

以下是一个简单的makefile的例子：

图 1 最简单的makefile例

make使用makefile文件时，从第一个目标开始扫描。上例中的第一个目标为all，所以目标clean不会自动被执行，可以通过命令make clean来生成目标。

1.2 命令行

命令行用来定义生成目标的动作。

在目标行中分号“;”后面的文件都认为是一个命令，或者一行以Tab制表符开始的也是命令。

如在上面的makefile例中，第三行以Tab字符开始的cc命令即是一个命令行，说明要生成hello应执行的命令。也可以写成：hello:hello.o;cc –c hello –L…

一般情况下，命令行的命令会在标准输出中回显出来，如对上面的makefile执行make时，标准输出如下：

cc -c hello.c

cc -o hello -L/usr/X11R6/lib -L/usr/lib -lXm -lXt -lX11 hello.o

cc -c hello1.c

cc -o hello1 -L/usr/X11R6/lib -L/usr/lib -lXm -lXt -lX11 hello1.o

如果不希望命令本身回显，可在命令前加@字符，如在上例中不希望回显cc –c hello.c和cc –c hello1.c，可修改makefile文件如下：

图 2 抑制回显的makefile例

对该makefile文件执行make时，标准输出如下：

cc -o hello -L/usr/X11R6/lib -L/usr/lib -lXm -lXt -lX11 hello.o

cc -o hello1 -L/usr/X11R6/lib -L/usr/lib -lXm -lXt -lX11 hello1.o

可以看出，命令行前有@字符的不回显。

1.3 宏定义行

在makefile中，可以使用宏定义减少用户的输入，例如上例中对hello和hello1的编译选项均为“-L/usr/X11R6/lib -L/usr/lib -lXm -lXt -lX11”，此时可以用宏来代替，如：

图 3 使用宏定义的makefile例

宏定义的基本语法是：

name=value

在定义宏时，次序不重要。宏不需要在使用前定义。如果一个宏定义多次，则使用最后一次的定义值。

可以使用“$”字符和“()”或“{}”来引用宏，例如：

cc –o hello.o $(CCFLS) hello.o

也可以将一个宏赋值给另一个宏，但这样的定义不能循环嵌套，如：

A=value1

B=value2

C=$(A) $(B)等价于C=value1 value2

1.4 伪指令

makefile大部分由宏定义行、命令行和目标行组成。第四种类型是make伪指令行。make伪指令没有标准化，不同的make可能支持不同的伪指令集，使得makefile有一定的不兼容性。如果要考虑移植性问题，则要避免使用make伪指令。但有一些伪指令，如include，由于使用比较多，很多不同make都提供该伪指令。

1.4.1 伪指令include

该伪指令类似C语言中的#include，它允许一次编写常用的定义并包括它。include伪指令必须在一行中，第一个元素必须是include，并且跟一个要包含的文件名，如：

include default.mk

1.4.2 伪指令“#”

“#”字符也是make的伪指令，它指出“#”后面的文件是注释，如：

PROGNAME=test # define macro

#don't modify this

二 后缀规则

2.1 双后缀规则

在前面的makefile例中有许多重复内容，例如，生成hello和hello1的命令类似，生成hello.o和hello1.o的命令也类似，除了编译或链接的文件不一样外，其它均相同，这时，我们就可以使用后缀规则。首先看一个双后缀的例子：

图 4 使用双后缀规则的makefile例

后缀规则使用特殊的目标名“.SUFFIXES”。

第一行中.SUFFIXES的依赖表为空，用来清除原有的后缀规则，因为.SUFFIXES可以在makefile中多次使用，每一次都将新的后缀规则加入以前的后缀规则中。

第二行中指定后缀规则为“.c .o”，即表示将所有的.c文件转换为.o文件。

第三行指定将.c文件转换成.o文件的方法。$(CC)为make的预定义宏，其默认值为cc，$<为特殊的宏，代替当前的源文件，即所有要编译的.c文件。

第六行指定目标hello和hello1的生成方法。$@为特殊的宏，代替当前的目标名，即hello和hello1，$@.o即为hello.o和hello1.o。

上例介绍的是双后缀规则，即它包含两个后缀，如.c.o，用来把一个C源文件编译为目标文件。双后缀规则描述如何由第一个后缀类型的文件生成第二个后缀类型的文件，例如：.c.o规则描述如何由.c文件生成.o文件。

2.2 单后缀规则

单后缀规则描述了怎样由指定后缀的文件生成由它基名为名字的文件。例如使用单后缀规则.c，可以由hello.c和hello1.c生成hello和hello1文件。例如将前面的makefile改为：

图 5 使用单后缀规则的makefile例

由于.c后缀规则为make标准后缀规则，make为其指定了相应的命令行，所以在makefile中可以不用再指定其目标生成的具体命令行。

下表是make提供的标准后缀规则。

表 1 make标准后缀规则

后缀规则 命令行

.c $(LINK.c) –o $@ $< $(LDLIBS)

.c.ln $(LINK.c) $(POUTPUT OPTPUT OPTION) –i $<

.c.o $(COMPILE.c) $(OUTPUT OPTION) $<

.c.a $(COMPILE.c) –o $% $<

$(AR) $(ARFLS) $@ $%

$(RM) $%

三 特殊目标

在后缀规则中使用了特殊目标.SUFFIXES，用来指定新增的后缀规则。make还提供了几个特殊目标来设置make的行为，下面为一些特殊的目标：

.IGNORE

make在执行命令行时，如果返回的是错误码，make的缺省动作是停止并退出。增加该目标后，make将忽略命令行返回的错误码，并继续执行后续的操作。

.SILENT

前面已经介绍过，make在执行命令行时会回显命令行内容，在命令行前增加“@”字符将抑制该命令行的回显。

如果增加该目标，所有的命令行不再回显，相当于在每个命令行前均增加了“@”字符。

.PRECIOUS

当收到一个信号或从shell命令返回非零的错误码时，make删除它所有已建立的文件。但有些文件即使出了错误，用户也不想让make删除，这些文件可以作为.PRECIOUS目标的参数。它可以在一个makefile中出现多次，每一次都累积文件列表。

.SUFFIXES

它为makefile指定新的后缀规则，新的后缀规则作为.SUFFIXES的依赖表给出。.SUFFIXES可以在一个makefile中多次使用，每一次都将新的后缀规则加入以前的后缀规则中，如果.SUFFIXES的依赖表为空，则设置后缀规则表为空。

四 特殊的宏

为简单使用规则，make提供了几个特殊的宏：

$@

整个当前目标名的值可以由宏“$@”来代替。

$<

当前的源文件由“$<”来代替。例如，在前面的例子中用到了$(CC) –c $<，其中的“$<”是所有要编译的.c文件。宏“$<”仅在后缀规则或.DEFAULT中有效。

$*

当前目标的基名由宏“$*”来代替。例如目标的名字是hello.o，则基名就是除去了后缀.o的hello。

以上介绍的特殊宏使用了make自身的规则，用户不可以改变。下表介绍了C中预定义的宏。

用途 宏 默认值

库文档汇编命令 AR ar

ARFLS rv

AS as

ALS

COMPILE.s $(AS) $(ALS) $(TARGET ARCH)

C编译器命令 CC cc

CFLS

CPPFLS

COMPILE.c $(CC) $(CFLS) $(CPPFLS) $(TARGET ARCH) –c

LINK.c $(CC) $(CFLS) $(CPPFLS) $(LDFLS) $(TARGET ARCH)

链接编辑器命令 LD ld

LDFLS

rm命令 RM rm

后缀列表 SUFFIXES .o .c .c~ .s .s~ .S .S~ .ln .f .f~ .F .F~ .l .mod .mod~ .sym

.def .def~ .p .p~ .r .r~ .y .y~ .h .h~ .sh .sh~ .cps .cps~

五 makefile的应用

当调用make时，它在当前目录下搜索文件名是“makefile”或“Makefile”的文件，并执行。

如果不想使用上述缺省文件，可以使用命令行中的“-f”来指定文件，如将编写的makefile命名为mklib，则指定为“make –f mklib”。

求一个nrf24l01模块简易收发程序，越简单越好，只传输一个数就可以了，单向传输 恳求

#include <reg51.h>

#include <intrins.h>

#include "api.h"

/*

*This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTYT;

*

*uart:9600BPS

*

*/

/***************************************************/

#define uchar unsigned char

#define TX_ADR_WIDTH 5 // 5 bytes TX(RX) address width

#define TX_PLOAD_WIDTH 20 // 20 bytes TX payload

uchar const TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01}; // Define a static TX address

uchar rx_buf[TX_PLOAD_WIDTH];

uchar tx_buf[TX_PLOAD_WIDTH];

uchar flag;

uchar rx_com_buffer[10];

uchar tx_com_buffer[10];

uchar i;

uchar accept_flag;

/**************************************************/

sbit CE = P1^6;

sbit CSN= P1^7;

sbit SCK= P1^4;

sbit MOSI= P1^5;

sbit MISO= P1^3;

sbit IRQ = P1^2;

sbit LED1= P3^7;

/**************************************************/

uchar bdata sta;

sbit RX_DR =sta^6;

sbit TX_DS =sta^5;

sbit MAX_RT =sta^4;

/**************************************************/

/**************************************************

Function: init_io();

Description:

flash led one time,chip enable(ready to TX or RX Mode),

Spi disable,Spi clock line init high

/**************************************************/

#define KEY 0xaa

void init_io(void)

{

CE=0; // chip enable

CSN=1; // Spi disable

SCK=0; // Spi clock line init high

}

/**************************************************/

/**************************************************

Function: Inituart();

Description:

set uart working mode

/**************************************************/

void Inituart(void)

{

SM0=0; //设置串行口工作方式为方式1。SM0=0,SM1=0为工作方式0.依次类推

SM1=1;

REN=1; //串行口接收允许。REN=0时，禁止接收。

TMOD=0x20; //定时器1工作方式2.

TH1=0xfd; //相应波特率设初值计算方法。 初值X=(256－11059200/(12*32*9600))

TL1=0xfd; //9600为你要设置的波特率。11059200为晶振频率。X的值最后要换算成16进制

TR1=1; //定时器T1开始工作,TR1=0,T1停止工作

}

/**************************************************/

/**************************************************

Function: init_int0();

Description:

enable int0 interrupt;

/**************************************************/

void init_int0(void)

{

EA=1;

EX0=1; // Enable int0 interrupt.

}

void delay_ms(unsigned int x)

{

unsigned int i,j;

i=0;

for(i=0;i<x;i++)

{

j=108;

while(j--);

}

}

/**************************************************/

/**************************************************

Function: SPI_RW();

Description:

Writes one byte to nRF24L01, and return the byte read

from nRF24L01 during write, according to SPI protocol

/**************************************************/

uchar SPI_RW(uchar byte)

{

uchar bit_ctr;

for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit

{

MOSI = (byte & 0x80); // output 'byte', MSB to MOSI

byte = (byte << 1); // shift next bit into MSB..

SCK = 1; // Set SCK high..

byte |= MISO; // capture current MISO bit

SCK = 0; // ..then set SCK low again

}

return(byte); // return read byte

}

/**************************************************/

/**************************************************

Function: SPI_RW_Reg();

Description:

Writes value 'value' to register 'reg'

/**************************************************/

uchar SPI_RW_Reg(BYTE reg, BYTE value)

{

uchar status;

CSN = 0; // CSN low, init SPI transaction

status = SPI_RW(reg); // select register

SPI_RW(value); // ..and write value to it..

CSN = 1; // CSN high again

return(status); // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: SPI_Read();

Description:

Read one byte from nRF24L01 register, 'reg'

/**************************************************/

BYTE SPI_Read(BYTE reg)

{

BYTE reg_val;

CSN = 0; // CSN low, initialize SPI communication...

SPI_RW(reg); // Select register to read from..

reg_val = SPI_RW(0); // ..then read registervalue

CSN = 1; // CSN high, terminate SPI communication

return(reg_val); // return register value

}

/**************************************************/

/**************************************************

Function: SPI_Read_Buf();

Description:

Reads 'bytes' #of bytes from register 'reg'

Typically used to read RX payload, Rx/Tx address

/**************************************************/

uchar SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)

{

uchar status,byte_ctr;

CSN = 0; // Set CSN low, init SPI tranaction

status = SPI_RW(reg); // Select register to write to and read status byte

for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)

pBuf[byte_ctr] = SPI_RW(0); // Perform SPI_RW to read byte from nRF24L01

CSN = 1; // Set CSN high again

return(status); // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: SPI_Write_Buf();

Description:

Writes contents of buffer '*pBuf' to nRF24L01

Typically used to write TX payload, Rx/Tx address

/**************************************************/

uchar SPI_Write_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)

{

uchar status,byte_ctr;

CSN = 0; // Set CSN low, init SPI tranaction

status = SPI_RW(reg); // Select register to write to and read status byte

for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) // then write all byte in buffer(*pBuf)

SPI_RW(*pBuf++);

CSN = 1; // Set CSN high again

return(status); // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: RX_Mode();

Description:

This function initializes one nRF24L01 device to

RX Mode, set RX address, writes RX payload width,

select RF channel, datarate & LNA HCURR.

After init, CE is toggled high, which means that

this device is now ready to receive a datapacket.

/**************************************************/

void RX_Mode(void)

{

CE=0;

SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Use the same address on the RX device as the TX device

SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0

SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0

SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 40

SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width

SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR

SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:RX. RX_DR enabled..

CE = 1; // Set CE pin high to enable RX device

// This device is now ready to receive one packet of 16 bytes payload from a TX device sending to address

// '3443101001', with auto acknowledgment, retransmit count of 10, RF channel 40 and datarate = 2Mbps.

}

/**************************************************/

/**************************************************

Function: TX_Mode();

Description:

This function initializes one nRF24L01 device to

TX mode, set TX address, set RX address for auto.ack,

fill TX payload, select RF channel, datarate & TX pwr.

PWR_UP is set, CRC(2 bytes) is enabled, & PRIM:TX.

ToDo: One high pulse(>10us) on CE will now send this

packet and expext an acknowledgment from the RX device.

/**************************************************/

void TX_Mode(void)

{

CE=0;

SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Writes TX_Address to nRF24L01

SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack

SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // Writes data to TX payload

SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0

SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0

SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...

SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 40

SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR

SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:TX. MAX_RT & TX_DS enabled..

CE=1;

}

/**************************************************/

/**************************************************

Function: check_ACK();

Description:

check if he "Data sent TX FIFO interrupt",if TX_DS=1,

all led light and after delay 100ms all led close

/**************************************************

void check_ACK()

{

uchar test;

test=SPI_Read(READ_REG+STATUS); // read register STATUS's

test=test&0x20; // check if he Data sent TX FIFO interrupt (TX_DS=1)

if(test==0x20) // TX_DS =1

{

P0=0x00; // turn on all led

delay100(); // delay 100ms

P0=0xff;

}

}

/**************************************************/

/**************************************************

Function: TxData();

Description:

write data x to SBUF

/**************************************************/

void TxData_com(void)

{

for(i=0;i<10;i++)

{

SBUF=tx_com_buffer[i]; // write data x to SBUF

while(TI==0);

TI=0;

}

accept_flag=0;

}

void TxData (uchar x)

{

SBUF=x; // write data x to SBUF

while(TI==0);

TI=0;

}

void RxData(void)

{

if(RI) // 是否有数据到来

{

RI = 0;

rx_com_buffer[i] = SBUF; // 暂存接收到的数据

i++;

if(i>10)

{

accept_flag=1;

i=0;

}

}

}

/**************************************************/

/**************************************************

Function: CheckButtons();

Description:

check buttons ,if he press,read the key values,

turn on led and transmit it; after transmition,

if received ACK, clear TX_DS interrupt and enter RX Mode;

turn off the led

/**************************************************/

/*void CheckButtons()

{

uchar Temp,xx,Tempi;

P0=0xff;

Temp=P0&KEY; //read key value from port P0

if (Temp!=KEY)

{

delay_ms(10);

Temp=P0&KEY; // read key value from port P0

if (Temp!=KEY)

{

xx=Temp;

Tempi=Temp>>1; // Left shift 4 bits

P0=Tempi; // Turn On the led

tx_buf[0]=Tempi; // Se to tx_buf[0]

TX_Mode(); // set TX Mode and transmitting

TxData(xx); // send data to uart

//check_ACK(); // if he acknowledgment from RX device,turn on all led

SPI_RW_Reg(WRITE_REG+STATUS,SPI_Read(READ_REG+STATUS)); // clear interrupt flag(TX_DS)

delay_ms(500);

P0=0xff; // Turn off the led

RX_Mode(); // set receive mode

while((P0&KEY)!=KEY);

}

}

} */

/**************************************************/

/**************************************************

Function: main();

Description:

control all subprogrammes;

/**************************************************/

void main(void)

{

uchar ia;

init_io(); // Initialize IO port

LED1=1;

Inituart(); // initialize 232 uart

RX_Mode(); // set RX mode

while(1)

{

RxData();

if(accept_flag==1)

{

LED1=0 ;

accept_flag=0;

for(ia=0;ia<5;ia++)

{

tx_buf[ia]=tx_com_buffer[ia];

}

TX_Mode();

SPI_RW_Reg(WRITE_REG+STATUS,SPI_Read(READ_REG+STATUS)); // clear interrupt flag(TX_DS)

delay_ms(100);

LED1=1;

RX_Mode();

}

if(!IRQ)

{

sta=SPI_Read(STATUS); // read register STATUS's value

if(RX_DR) // if receive data ready (RX_DR) interrupt

{

SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer;

for(ia=0;ia<5;ia++)

{

tx_com_buffer[ia]=rx_buf[ia];

}

LED1=0;

flag=0; // set flag=0

TxData_com();

LED1=1;

}

if(MAX_RT)

{

SPI_RW_Reg(FLUSH_TX,0);

}

SPI_RW_Reg(WRITE_REG+STATUS,0xff);// clear RX_DR or TX_DS or MAX_RT interrupt flag

IRQ=1;

RX_Mode();

}

}

}

什么是Prim算法?

Prim算法

Prim算法用于求无向图的最小生成树

设图G =（V，E），其生成树的顶点集合为U。

①、把v0放入U。

②、在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。

③、把②找到的边的v加入U集合。如果U集合已有n个元素，则结束，否则继续执行②。

其算法的时间复杂度为O(n^2)

Prim算法实现：

（1）集合：设置一个数组set[i](i=0,1,..,n-1),初始值为 0,代表对应顶点不在集合中（注意：顶点号与下标号差1）

（2）图用邻接阵表示，路径不通用无穷大表示，在计算机中可用一个大整数代替。

参考程序

/* Prim.c

Copyright (c) 2002, 2006 by ctu_85

All Rights Reserved.

*/

/* The impact of the situation of articulation point exists can be omitted in Prim algorithm but not in Kruskal algorithm */

#include "stdio.h"

#define maxver 10

#define maxright 100

int main()

{

int G[maxver][maxver],in[maxver]=,path[maxver][2];

int i,j,k,min=maxright;

int v1,v2,num,temp,status=0,start=0;

restart:

printf("Please enter the number of vertex(s) in the graph:\n");

scanf("%d",&num);

if(num>maxver||num<0)

{

printf("Error!Please reinput!\n");

goto restart;

}

for(j=0;j<num;j++)

for(k=0;k<num;k++)

{

if(j==k)

G[j][k]=maxright;

else

if(j<k)

{

re:

printf("Please input the right between vertex %d and vertex %d,if no edge exists please input -1:\n",j+1,k+1);

scanf("%d",&temp);

if(temp>=maxright||temp<-1)

{

printf("Invalid input!\n");

goto re;

}

if(temp==-1)

temp=maxright;

G[j][k]=G[k][j]=temp;

}

}

for(j=0;j<num;j++)

{

status=0;

for(k=0;k<num;k++)

if(G[j][k]<maxright)

{

status=1;

break;

}

if(status==0)

break;

}

do

{

printf("Please enter the vertex where Prim algorithm starts:");

scanf("%d",&start);

}while(start<0||start>num);

in[start-1]=1;

for(i=0;i<num-1&&status;i++)

{

for(j=0;j<num;j++)

for(k=0;k<num;k++)

if(G[j][k]<min&&in[j]&&(!in[k]))

{

v1=j;

v2=k;

min=G[j][k];

}

if(!in[v2])

{

path[i][0]=v1;

path[i][1]=v2;

in[v1]=1;

in[v2]=1;

min=maxright;

}

}

if(!status)

printf("We cannot deal with it because the graph is not connected!\n");

else

{

for(i=0;i<num-1;i++)

printf("Path %d:vertex %d to vertex %d\n",i+1,path[i][0]+1,path[i][1]+1);

}

return 1;

}

Prim算法。

设图G =（V，E），其生成树的顶点集合为U。

①、把v0放入U。

②、在所有u∈U，v∈V-U的边(u，v)∈E中找一条最小权值的边，加入生成树。

③、把②找到的边的v加入U集合。如果U集合已有n个元素，则结束，否则继续执行②。

其算法的时间复杂度为O(n^2)

参考程序

//Prim 算法 读入顶点数(n)、边数(m)，边的起始点和权值 用邻接矩阵储存

//例如

//7 12 (7个顶点12条边)

//1 2 2

//1 4 1

//1 3 4

//2 4 3

//2 5 10

//3 4 2

//4 5 7

//3 6 5

//4 6 8

//4 7 4

//5 7 6

//6 7 1

#include <stdio.h>

#include <string.h>

int main()

{

int m , n;

int a[201][201] , mark[201] , pre[201] , dist[201];

int s , t , w;

int i , j , k , min , tot;

freopen("Prim.txt" , "r" , stdin);

//读入数据

memset(a , 0 , sizeof(a));

scanf("%d %d" , &n , &m);

for (i = 0; i < m; i ++)

{

scanf("%d %d %d" , &s , &t , &w);

a[s][t] = w; a[t][s] = w;

}

//赋初值

memset(mark , 0 , sizeof(mark));

memset(pre , 0 , sizeof(pre));

memset(dist , 9999 , sizeof(dist));

dist[1] = 0;

//Prim

for (i = 1; i <= n; i ++)

{

min = 9999; k = 0;

for (j = 1; j <= n; j ++)

if ((mark[j] == 0) && (dist[j] < min)) {min = dist[j]; k = j;}

if (k == 0) break;

mark[k] = 1;

for (j = 1; j <= n; j ++)

if ((mark[j] == 0) && (a[k][j] < dist[j]) && (a[k][j] > 0))

{

dist[j] = a[k][j];

pre[j] = k;

}

}

tot = 0;

for (i = 1; i <= n; i ++) tot += dist[i];

printf("%d\n" , tot);

return 0;

}