实训课cc2530

#include<ioCC2530.h>
#include<string.h>
#define MAXLEN 100

typedef unsigned char uchar;
typedef unsigned int uint;

char TxData[MAXLEN];//存储发送的字符串
//延时函数
void delay_ms(uint n)
{
  uint i,j;
  for(i=0;i<n;i++)
  {
    for(j=0;j<600;j++);
  }
}
//串口初始化
void uart_init()
{
  //通用的IO设置成外设功能 
  //1、PERCFG ：外设控制寄存器
  //2、P0SEL ：端口 0 功能选择寄存器
  PERCFG = 0X00;
  P0SEL  = 0X0C;
  P2DIR &= (~(0X3<<6));              // 也可以去与（0X00FFFFFF） 这是设置优先级
  //串口部分
    U0CSR |= 0X80;//UART0 control
    U0GCR |= 11;   //BAUD_E[4:0] 波特率
    U0BAUD = 216;   //另外一个小数点波特率设置
    UTX0IF = 0; //中断关闭 无中断 （接收要用时候开启）
}
//send function 
void send(char *str)
{
  /*while(*str)// *str = '\0' 相当于 0；
  {
      U0DBUF = *str++;//use U0BUF To Save string
    while(UTX0IF == 0);
      UTX0IF = 0;
  }*/
  int i=0;
  for (i=0;i<36;i++)
  {
      U0DBUF = str[i];//use U0BUF To Save string
    while(UTX0IF == 0);
      UTX0IF = 0;
  }
}

//recieve function
/*
void recieve(char *str)
{}
*/
uchar cmd[36]={0xdd,0x07,0x24,0x00,0x04};//风扇
uchar cmd1[36]={0xdd,0x07,0x24,0x00,0x08};//关风扇
uchar cmd2[36]={0xdd,0x07,0x24,0x00,0x00};//开灯
uchar cmd3[36]={0xdd,0x07,0x24,0x00,0x01};//关灯
uchar cmd4[36]={0xdd,0x07,0x24,0x00,0x02};//蜂鸣器
uchar cmd5[36]={0xdd,0x07,0x24,0x00,0x03};//关蜂鸣器
/*
      send(cmd);
      delay_ms(3000);
      send(cmd1);//0000 1000
      delay_ms(5000);
      send(cmd);
      delay_ms(3000);
*/
int main( void )
{
  CLKCONCMD &= ~0X40;//设置系统时钟源 32MHZ;
  while(CLKCONSTA & 0X40);//判断第6位是否为零；
  CLKCONCMD &= ~0X47;
  
  //setSystemClk32MHZ();
  
  uart_init();
  while(1){
    send(cmd2);
    delay_ms(1000);
    send(cmd3);
    delay_ms(1000);
      
  }
}

1、函数
    1、概念：
        完成特定功能的代码模块，其程序代码要求独立，通常有返回值。
    2、定义函数的语法结构：
        数据类型 函数名(<形参列表>)
        {
            代码语句;
            return ;
        }
        注意：
            1、数据类型 为函数返回值的类型。
            2、函数名必须符合标识符的命名规则。
            3、形参列表：根据具体功能（函数体中是否需要外部数据）决定是否需要定义形参。
            4、{}大括号称为函数体
            5、如果函数的数据类型为 void, 但是可以 用 return;返回
            6、如果函数的定义区域在函数调用之后，
                那么该函数必须在头文件或者调用之前声明。
                    声明的语法结构： 数据类型 函数名(<形参列表>);
            7、函数的声明或定义都必须是在全局区，不能在局部。
            
    3、函数的调用：
        1、如果函数有返回值，该返回值对程序后续代码有意义：
                变量名 = 函数名(<实参列表>);
        2、函数无返回值：
                函数名(<实参列表>);
            
    4、函数参数传递：
        1、值传递(复制传递)：形参不能改变实参的内容。将实参的数值复制到 形参的空间。
        2、地址传递：形参可以改变实参的内容。将实参的地址值复制到 形参的空间。
        
字符串处理函数
    1、求长度
        函数原型：
            int strlen(void *s);
        头文件：
            #include <string.h>
        参数：
            s：字符串（字符数组）首地址
        返回值：
            成功：返回值字符串长度
            
*** 指针函数：函数返回值为指针类型。
    2、字符串的拷贝
        函数原型：
            char *strcpy(char *dest, const char *src);
        头文件：
            #include <string.h>
        参数：
            dest：目标字符串首地址
            src ：源字符串首地址
        返回值：
            成功：返回 dest
            失败：返回 NULL
    3、字符串的设置函数，常用来做字符串的  清零操作
        函数原型：
            void memset(void *s, int c, size_t n);
        头文件：
            #include <string.h>
        参数:
            s：待设置的字符串首地址
            c：设置成的数值（0~9）
            n：设置的字节数
        返回值：
            暂无
            
    4、字符串的拼接函数
        函数原型：
            void strcat(char *s1, char *s2);
        功能：
            将s2中的数组拼接到 s1地址上数据的末尾
        头文件：
            #include <string.h>
        参数:
            s1：字符数组首地址
            s2：字符数组首地址
        返回值：
            成功：返回 s1这个首地址
            失败：返回 NULL
            
    5、字符串的比较函数
        函数原型：
            int strcmp(char *s1, char *s2);
        头文件：
            #include <string.h>
        参数：
            s1：字符串1的首地址
            s2：字符串2的首地址
        返回值：
            <0：表示s1 < s2
            =0：表示s1 = s2
            >0：表示s1 > s2
            
    6、字符串的查找函数
        函数原型：
            char *strstr(char *s1, char *s2);
        功能：
            在s1字符串中查找 s2子串。
        头文件：
            #include <string.h>
        参数：
            s1：较长的字符串
            s2：子串
        返回值：
            成功：返回s2首字母在s1中的地址。
            失败：NULL
    
        
文件IO：
    1、对文件进行输入或输出
    2、linux中一切皆为文件。要操控硬件就必须对硬件的设备文件进行IO操作。
    
    3、文件描述符：
        1、系统最小的、未用的非负整数。
        2、是内核向进程返回的标识符（标识正在操作的文件）
        3、所有文件IO操作都围绕文件描述符进行。
        4、打开一个终端，系统默认打开了三个硬件设备
            （标准输入 0、标准输出 1、标准错误输出 2）
            
    4、文件IO操作流程：
        1、打开（或创建打开） open
        2、数据的读或者写 read\write
        3、关闭被打开的文件 close
        
    5、接口函数
        1、函数原型：
            int open(const char *path, int oflag, mode_t mode);
            功能：
                以oflag方法操作 path对应的文件
            头文件：
                #include <sys/types.h>
                #include <fcntl.h>
            参数：
                path：要操作的文件名（可包含路径）
                oflag：操作方式：只读(O_RDONLY)、只写(O_WRONLY)、读写(O_RDWR)
                                | O_CREAT(文件不存在就创建)
                mode：文件的存根权限（8进制表示），只有当O_CREAT出现时才生效。
            返回值：
                成功：返回文件描述符
                失败：返回-1，并设置错误信息
        2、函数原型：
            ssize_t write(int fd, const void *buf, size_t n);
            功能：
                将 buf 地址上的前 n个字节数据，写入fd 对应的文件中。
            头文件：
                #include <unistd.h>
            参数：
                fd：文件描述符，open成功的返回值
                buf：数据的来源首地址
                n：写入的字节数
            返回值：
                成功：返回实际写入的字节数
                失败：返回-1，并设置错误信息
                
        3、函数原型：
            ssize_t read(int fd, const void *buf, size_t n);
            功能：
                从fd对应的文件中读取 前 n个字节到 buf地址上。
            头文件：
                #include <unistd.h>
            参数：
                fd：文件描述符，open成功的返回值
                buf：存储数据的首地址
                n：读取的字节数
            返回值：
                成功：
                    0：表示读取到了文件末尾
                    >0: 表示实际读取到的字节数
                失败：返回-1，并设置错误信息
            
            
               DAY4

Linux下面的多进程，多线程。

---

#include<stdio.h>
#include<pthread.h>// 进程分裂要用的头文件
int vlu1,vlu2;//定义全局变量

pthread_mutex_t mutex;//进程锁

void *thread1(void *agr)
{
    int count = 0;
    while(1)
    {
        count++;
        pthread_mutex_lock(&mutex);
        vlu1=count%10;
        vlu2=count%10;
        pthread_mutex_unlock(&mutex);
    }
}
void *thread2(void *agr)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        if(vlu1 != vlu2)
            printf("vlu1: %d,vlu2: %d\n",vlu1,vlu2);
        pthread_mutex_unlock(&mutex);
    }
}
int main()
{
    pthread_t tid1,tid2;
    
    //init mutex;
    pthread_mutex_init(&mutex,NULL);//进程锁初始化

    if(pthread_create(&tid1,NULL,thread1,NULL) < 0)
    {
        printf("tid1 failed!\n");
        return -1;
    }
    pthread_detach(tid1);

    if(pthread_create(&tid2,NULL,thread2,NULL) < 0)
    {
        printf("tid2 failed!\n");
        return -1;
    }
    pthread_detach(tid2);

    while(1);
    return 0;
}