精华内容
下载资源
问答
  • Linux文件读写示例

    2015-08-26 12:06:59
    2. 上述两个函数第二个参数如果是1,那么返回值即实际传输长度,如果返回值是0,一般表示文件传完;如果返回值等于需要传输长度,那么正常;如果返回值小于指定传输长度,那么有可能是最后一次传输,因为到达文件尾...

    1. 对于fread或fwrite查看man手册,其中要注意返回值。

    2. 上述两个函数第二个参数如果是1,那么返回值即实际传输长度,如果返回值是0,一般表示文件传完;如果返回值等于需要传输长度,那么正常;如果返回值小于指定传输长度,那么有可能是最后一次传输,因为到达文件尾,也有可能是传输错误;

    如果第二个参数不是1,那么就不能通过返回值判断是否传输完,要通过对应库函数来判断是否到达文件尾。如果返回小于传输长度,有可能是正常、有可能发生错误,也要通过库函数检测。

    3. 示例源码如下:

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>


    /*
    Function : read data from the 2page.pdf,And write the date to write.pdf
    */




    char * readFileName = "./2page.pdf";
    char * writeFileName = "./write.pdf";


    #define BUFFER_SIZE 2048


    void main()
    {
    int readLengh = 0;
    int realReadLengh =0;
    int realWriteLengh =0;

    char buf[BUFFER_SIZE];
    memset(buf, 0, sizeof(buf));

    FILE *readFp = fopen(readFileName, "r");
    if(NULL == readFp) //if failed,fread and fwrite can't go on 
        { 
    printf("readFile open failed,exit!\n"); 
    exit(1);
        } 

    FILE *writeFp = fopen(writeFileName, "w");
    if(NULL == writeFp) //if failed,fread and fwrite can't go on 
        { 
    printf("writeFile open failed,exit!\n"); 
    exit(1);
        } 
    /*
    fread or fwrite does not distinguish between end-of-file and error, and callers must use feof(3)
    and ferror(3) to determine which occurred.
    */


    readLengh  = 1024;

    while(1)
    {
    realReadLengh = fread(buf,1,readLengh, readFp);//return value equals the number of bytes transferred only when the second parameter is 1.
    buf[realReadLengh] = '\0';
    printf("\nrealReadLengh=%d\nbuf=\n %s\n",realReadLengh,buf);
    if( realReadLengh >0 )
    {
    realWriteLengh = fwrite(buf,1,realReadLengh,writeFp);
    printf("\nrealWriteLengh=%d\nbuf=\n %s\n",realWriteLengh,buf);
    memset(buf, 0, sizeof(buf));
    continue;
    }
    else
    {
    printf("read end\n");
    exit(1);
    }

    }



    }














    展开全文
  • Linux 文件读写函数的使用方法

    千次阅读 2012-11-14 15:01:01
    Linux平台下对文件编程可以使用两类函数:(1)Linux操作系统文件API;(2)C语言I/O库函数。 前者依赖于Linux系统调用,后者实际上与操作系统是独立的,因为在任何操作系统下,使用C语言I/O库函数操作文件的方法...
    在Linux平台下对文件编程可以使用两类函数:(1)Linux操作系统文件API;(2)C语言I/O库函数。 前者依赖于Linux系统调用,后者实际上与操作系统是独立的,因为在任何操作系统下,使用C语言I/O库函数操作文件的方法都是相同的。本章将对这两种方法进行实例讲解。
     
    Linux的文件操作API涉及到创建、打开、读写和关闭文件。
      创建
    int creat(const char *filename, mode_t mode);
      参数mode指定新建文件的存取权限,它同umask一起决定文件的最终权限(mode&umask),其中umask代表了文件在创建时需要去掉的一些存取权限。umask可通过系统调用umask()来改变:
    int umask(int newmask);
      该调用将umask设置为newmask,然后返回旧的umask,它只影响读、写和执行权限。
      打开
    int open(const char *pathname, int flags);
    int open(const char *pathname, int flags, mode_t mode);
      open函数有两个形式,其中pathname是我们要打开的文件名(包含路径名称,缺省是认为在当前路径下面),flags可以去下面的一个值或者是几个值的组合:
    标志
    含义
    O_RDONLY
    以只读的方式打开文件
    O_WRONLY
    以只写的方式打开文件
    O_RDWR
    以读写的方式打开文件
    O_APPEND
    以追加的方式打开文件
    O_CREAT
    创建一个文件
    O_EXEC
    如果使用了O_CREAT而且文件已经存在,就会发生一个错误
    O_NOBLOCK
    以非阻塞的方式打开一个文件
    O_TRUNC
    如果文件已经存在,则删除文件的内容


      O_RDONLY、O_WRONLY、O_RDWR三个标志只能使用任意的一个。
      如果使用了O_CREATE标志,则使用的函数是int open(const char *pathname,int flags,mode_t mode); 这个时候我们还要指定mode标志,用来表示文件的访问权限。mode可以是以下情况的组合:
    标志
    含义
    S_IRUSR
    用户可以读
    S_IWUSR
    用户可以写
    S_IXUSR
    用户可以执行
    S_IRWXU
    用户可以读、写、执行
    S_IRGRP
    组可以读
    S_IWGRP
    组可以写
    S_IXGRP
    组可以执行
    S_IRWXG
    组可以读写执行
    S_IROTH
    其他人可以读
    S_IWOTH
    其他人可以写
    S_IXOTH
    其他人可以执行
    S_IRWXO
    其他人可以读、写、执行
    S_ISUID
    设置用户执行ID
    S_ISGID
    设置组的执行ID
      除了可以通过上述宏进行“或”逻辑产生标志以外,我们也可以自己用数字来表示,Linux总共用5个数字来表示文件的各种权限:第一位表示设置用户ID;第二位表示设置组ID;第三位表示用户自己的权限位;第四位表示组的权限;最后一位表示其他人的权限。每个数字可以取1(执行权限)、2(写权限)、4(读权限)、0(无)或者是这些值的和。例如,要创建一个用户可读、可写、可执行,但是组没有权限,其他人可以读、可以执行的文件,并设置用户ID位。那么,我们应该使用的模式是1(设置用户ID)、0(不设置组ID)、7(1+2+4,读、写、执行)、0(没有权限)、5(1+4,读、执行)即10705:
    open("test", O_CREAT, 10705);
      上述语句等价于:
    open("test", O_CREAT, S_IRWXU | S_IROTH | S_IXOTH | S_ISUID );
      如果文件打开成功,open函数会返回一个文件描述符,以后对该文件的所有操作就可以通过对这个文件描述符进行操作来实现。
      读写
      在文件打开以后,我们才可对文件进行读写了,Linux中提供文件读写的系统调用是read、write函数:
    int read(int fd, const void *buf, size_t length);
    int write(int fd, const void *buf, size_t length);
      其中参数buf为指向缓冲区的指针,length为缓冲区的大小(以字节为单位)。函数read()实现从文件描述符fd所指定的文件中读取length个字节到buf所指向的缓冲区中,返回值为实际读取的字节数。函数write实现将把length个字节从buf指向的缓冲区中写到文件描述符fd所指向的文件中,返回值为实际写入的字节数。
      以O_CREAT为标志的open实际上实现了文件创建的功能,因此,下面的函数等同creat()函数:
    int open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
      定位
      对于随机文件,我们可以随机的指定位置读写,使用如下函数进行定位:
    int lseek(int fd, offset_t offset, int whence);
      lseek()将文件读写指针相对whence移动offset个字节。操作成功时,返回文件指针相对于文件头的位置。参数whence可使用下述值:
      SEEK_SET:相对文件开头
      SEEK_CUR:相对文件读写指针的当前位置
      SEEK_END:相对文件末尾
      offset可取负值,例如下述调用可将文件指针相对当前位置向前移动5个字节:
    lseek(fd, -5, SEEK_CUR);
      由于lseek函数的返回值为文件指针相对于文件头的位置,因此下列调用的返回值就是文件的长度:
    lseek(fd, 0, SEEK_END);
      关闭
      当我们操作完成以后,我们要关闭文件了,只要调用close就可以了,其中fd是我们要关闭的文件描述符:
    int close(int fd);
      例程:编写一个程序,在当前目录下创建用户可读写文件“hello.txt”,在其中写入“Hello, software weekly”,关闭该文件。再次打开该文件,读取其中的内容并输出在屏幕上。
    #include
    #include
    #include
    #include
    #define LENGTH 100
    main()
    {
     int fd, len;
     char str[LENGTH];
     fd = open("hello.txt", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR); /* 创建并打开文件 */
     if (fd)
     {
      write(fd, "Hello, Software Weekly", strlen("Hello, software weekly")); /* 写入 Hello, software weekly字符串 */
      close(fd);
     }
     fd = open("hello.txt", O_RDWR);
     len = read(fd, str, LENGTH); /* 读取文件内容 */
     str[len] = '\0';
     printf("%s\n", str);
     close(fd);
    }
    编译并运行,执行结果如下图:

      3.C语言库函数
      C库函数的文件操作实际上是独立于具体的操作系统平台的,不管是在DOS、Windows、Linux还是在VxWorks中都是这些函数:
      创建和打开
    FILE *fopen(const char *path, const char *mode);
      fopen()实现打开指定文件filename,其中的mode为打开模式,C语言中支持的打开模式如下表:
    标志
    含义
    r, rb
    以只读方式打开
    w, wb
    以只写方式打开。如果文件不存在,则创建该文件,否则文件被截断
    a, ab
    以追加方式打开。如果文件不存在,则创建该文件
    r+, r+b, rb+
    以读写方式打开
    w+, w+b, wh+
    以读写方式打开。如果文件不存在时,创建新文件,否则文件被截断
    a+, a+b, ab+
    以读和追加方式打开。如果文件不存在,创建新文件
      其中b用于区分二进制文件和文本文件,这一点在DOS、Windows系统中是有区分的,但Linux不区分二进制文件和文本文件。
      读写
      C库函数支持以字符、字符串等为单位,支持按照某中格式进行文件的读写,这一组函数为:
    int fgetc(FILE *stream);
    int fputc(int c, FILE *stream);
    char *fgets(char *s, int n, FILE *stream);
    int fputs(const char *s, FILE *stream);
    int fprintf(FILE *stream, const char *format, ...);
    int fscanf (FILE *stream, const char *format, ...);
    size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
    size_t fwrite (const void *ptr, size_t size, size_t n, FILE *stream);
      fread()实现从流stream中读取加n个字段,每个字段为size字节,并将读取的字段放入ptr所指的字符数组中,返回实际已读取的字段数。在读取的字段数小于num时,可能是在函数调用时出现错误,也可能是读到文件的结尾。所以要通过调用feof()和ferror()来判断。
      write()实现从缓冲区ptr所指的数组中把n个字段写到流stream中,每个字段长为size个字节,返回实际写入的字段数。
      另外,C库函数还提供了读写过程中的定位能力,这些函数包括
    int fgetpos(FILE *stream, fpos_t *pos);
    int fsetpos(FILE *stream, const fpos_t *pos);
    int fseek(FILE *stream, long offset, int whence);
    等。
      关闭
      利用C库函数关闭文件依然是很简单的操作:
    int fclose (FILE *stream);
      例程:将第2节中的例程用C库函数来实现。
    #include
    #define LENGTH 100
    main()
    {
     FILE *fd;
     char str[LENGTH];
     fd = fopen("hello.txt", "w+"); /* 创建并打开文件 */
     if (fd)
     {
      fputs("Hello, Software Weekly", fd); /* 写入Hello, software weekly字符串 */
      fclose(fd);
     }
     fd = fopen("hello.txt", "r");
     fgets(str, LENGTH, fd); /* 读取文件内容 */
     printf("%s\n", str);
     fclose(fd);
    }
      4.小结

      Linux提供的虚拟文件系统为多种文件系统提供了统一的接口,Linux的文件编程有两种途径:基于Linux系统调用;基于C库函数。这两种编程所涉及到文件操作有新建、打开、读写和关闭,对随机文件还可以定位。本章对这两种编程方法都给出了具体的实例。



    Linux文件编程实例


    1. //捕获fopen调用中的错误   
    2. #include <stdio.h>   
    3. #include <errno.h>   
    4. #include <string.h>   
    5. #define MYFILE "missing.txt"   
    6. int main(  )   
    7.     {   
    8.         FILE* fin;   
    9.         fin=fopen( MYFILE,"r" );   
    10.         if( fin==(FILE*)NULL )   
    11.             {   
    12.                 printf( "%s: %s\n",MYFILE,strerror( errno ) );   
    13.                 exit( -1 );   
    14.                    
    15.             }   
    16.         fclose( fin );   
    17.         return 0;   
    18.            
    19.            
    20.     }   
    21.   
    22. /*数据的读写  
    23. 标准的I/O库提供了缓冲接口。有两个非常重要的属性:  
    24. 1、系统是分块进行读写的(一个块通常8KB)。字符I/O都写到FILE缓冲区中,  
    25.     这个缓冲区满的时候会自动写入介质;  
    26. 2、如果数据需要送到像控制台终端这样的交互设备,必须设置fflush或者非缓冲  
    27.    I/O  
    28. */  
    29. /********字符接口**********/  
    30. //fputc字符接口实例   
    31. #include <stdio.h>   
    32. #include <errno.h>   
    33. int main(  )   
    34.     {   
    35.         int i=0;   
    36.         FILE* fout;   
    37.         const char string[  ]={   
    38.             "This\r\nis a test\r\nfile.\r\n\0"  
    39.         };   
    40.         fout=fopen("inpfile.txt","w");   
    41.         if( fout==( FILE* )NULL )   
    42.         {   
    43.             printf( "%s: %s\n","inpfile.txt",strerror( errno ) );   
    44.             exit( -1 );   
    45.         }   
    46.         while( string[ i ]!=NULL )   
    47.             {   
    48.                 fputc( ( int )string[ i ],fout );   
    49.                 ++i;   
    50.             }   
    51.         fclose( fout );   
    52.         return 0;   
    53.     }   
    54. //fgetc字符接口实例   
    55. #include <stdio.h>   
    56. #include <errno.h>   
    57. int main(  )   
    58.     {   
    59.         FILE* fin;   
    60.         fin=fopen( "inpfile.txt","r" );   
    61.         if( fin==( FILE* )NULL )   
    62.             {   
    63.                 printf( "%s: %s\n","inpfile.txt",strerror( errno ) );   
    64.                 exit( -1 );   
    65.             }   
    66.         int i;   
    67.         while( (i=fgetc( fin ))&&i!=EOF )   
    68.             {   
    69.                 printf( "%c",(char)i );   
    70.                    
    71.             }   
    72.         return 0;   
    73.            
    74.     }   
    75. /*  
    76.   fputc(  )是向文件中写入数据;fgetc是从文件中读取数据  
    77.   总结:字符接口使用简单,但是效率不高,最好是在基于字符串的方法不可使用时才使用字符接口  
    78.  */  
    79. /************字符串接口************/  
    80. /*提供字符串读写函数4个。fputs和fgets是简单的字符串接口;  
    81.   fprintf和fscanf更复杂的接口,但提供了更多的功能。    
    82.  */  
    83. //相文件中写入变长字符串   
    84. #include <stdio.h>   
    85. #include <errno.h>   
    86. #include <stdlib.h>   
    87. #define LEN 80   
    88. int main(  )   
    89.     {   
    90.         char line[ LEN+1 ];   
    91.         FILE* fout;   
    92.         FILE* fin;   
    93.         //写入数据   
    94.         fout=fopen( "testfile.txt","w" );   
    95.         if( fout==( FILE* )NULL )   
    96.             {   
    97.                 printf( "%s: %s\n","testfile.txt",strerror( errno ) );   
    98.                 exit( -1 );   
    99.                    
    100.             }   
    101.            
    102.         fin=fdopen( 0,"r" ); //将fin与标准输入流绑定   
    103.         printf( "Please input some characters,end with CTRL+D:\n" );   
    104.         //CTRL+D结束输入   
    105.         while( ( fgets(line,LEN,fin) )!=NULL )   
    106.             {   
    107.                 fputs( line,fout );   
    108.                    
    109.             }   
    110.         fclose( fout );   
    111.         fclose( fin );   
    112.         //读取数据   
    113.         printf( "\nthe characters read from file is:\n" );   
    114.         char getLine[ LEN+1 ];   
    115.         fin=fopen( "testfile.txt","r" );   
    116.         if( fin==(FILE*)NULL )   
    117.             {   
    118.                 printf( "%s: %s\n","testfile.txt",strerror( errno ) );   
    119.                 exit( -1 );   
    120.             }   
    121.         fgets( getLine,LEN,fin );   
    122.         printf( "%s\n",getLine );   
    123.         fclose( fin );   
    124.            
    125.         return 0;   
    126.     }   
    127. /*fputs向文件中写入,fgets从文件中读取  
    128.   总结:要注意不可以同时读写同一个文件。  
    129.  */  
    130. //以ASCII格式输出结构体数据   
    131. #include <stdio.h>   
    132. #include <errno.h>   
    133. #define MAX_LINE 40   
    134. #define FILENAME "myfile.txt"   
    135. typedef struct  
    136. {   
    137.     int id;   
    138.     float x_coord;   
    139.     float y_coord;   
    140.     char name[ MAX_LINE+1 ];   
    141.        
    142. }MY_TYPE_T;   
    143. #define MAX_OBJECTS 3   
    144. /*Initialize an array of three objects*/  
    145. MY_TYPE_T objects[ MAX_OBJECTS ]={   
    146.     {0,1.5,8.3,"Frist-object"},   
    147.     {1,4.5,6.3,"Second-object"},   
    148.     {2,3.5,7.5,"Thrid-object"},   
    149. };   
    150. int main(  )   
    151.     {   
    152.         int i;   
    153.         FILE* fout;   
    154.         fout=fopen(FILENAME,"w" );   
    155.         if( fout==( FILE* )NULL )   
    156.             {   
    157.                 printf( "%s: %s\n",FILENAME,strerror( errno ) );   
    158.                 exit( -1 );   
    159.             }   
    160.         printf( "Writing...\n" );   
    161.         for( i=0;i<MAX_OBJECTS;++i )   
    162.             {   
    163.                 fprintf( fout,"%d %f %f %s\n",objects[ i ].id,objects[ i ].x_coord,   
    164.                          objects[ i ].y_coord,objects[ i ].name);   
    165.                    
    166.             }   
    167.         fclose( fout );   
    168.         printf("Write over\n");   
    169.         printf("Read from file\n");   
    170.         FILE* fin=fopen( FILENAME,"r" );   
    171.         if( fin==(FILE*)NULL )   
    172.             {   
    173.                 printf( "%s: %s\n",FILENAME,strerror( errno ) );   
    174.                 exit( -1 );   
    175.                    
    176.             }   
    177.         MY_TYPE_T objects;   
    178.         while( !feof(fin) )   
    179.             {   
    180.                 fscanf( fin,"%d %f %f %s\n",&objects.id,&objects.x_coord,   
    181.                         &objects.y_coord,&objects.name);   
    182.                 printf("%d %f %f %s\n",objects.id,objects.x_coord,   
    183.                        objects.y_coord,objects.name);   
    184.                    
    185.             }   
    186.         fclose( fin );   
    187.         return 0;   
    188.     }   
    189. /**************二进制文件的读写*****************/  
    190. /*使用fwirte、fread进行二进制文件的读写  
    191.   读写二进制文件的时候,要注意的重要问题是可移植性和字序问题。  
    192.   Intel采用小字节序,PowerPC和网络采用大字节序  
    193.  */  
    194. #include <stdio.h>   
    195. #include <errno.h>   
    196. #define MAX_LINE 40   
    197. #define FILENAME "myfile.bin"   
    198. typedef struct  
    199. {   
    200.     int id;   
    201.     float x_coord;   
    202.     float y_coord;   
    203.     char name[ MAX_LINE+1 ];   
    204.        
    205. }MY_TYPE_T;   
    206. #define MAX_OBJECTS 3   
    207. /*Initialize an array of three objects*/  
    208. MY_TYPE_T objects[ MAX_OBJECTS ]={   
    209.     {0,1.5,8.3,"Frist-object"},   
    210.     {1,4.5,6.3,"Second-object"},   
    211.     {2,3.5,7.5,"Thrid-object"},   
    212. };   
    213. int main(  )   
    214.     {   
    215.         int i;   
    216.         FILE* fout;   
    217.         fout=fopen(FILENAME,"w" );   
    218.         if( fout==( FILE* )NULL )   
    219.             {   
    220.                 printf( "%s: %s\n",FILENAME,strerror( errno ) );   
    221.                 exit( -1 );   
    222.             }   
    223.         printf( "Writing...\n" );   
    224.         fwrite( ( void* )objects,sizeof( MY_TYPE_T ),3,fout );   
    225.         fclose( fout );   
    226.         //使用fread/fseek/rewind读取二进制结构体数据   
    227.         printf( "Read from file\n" );   
    228.         MY_TYPE_T object;   
    229.         FILE* fin=fopen( FILENAME,"r" );   
    230.         if( fin==( FILE* )NULL )   
    231.             {   
    232.                 printf( "%s: %s\n",FILENAME,strerror( errno ) );   
    233.                 exit( -1 );   
    234.             }   
    235.         //定位到第三个结构体   
    236.         fseek( fin,( 2*sizeof( MY_TYPE_T ) ),SEEK_SET );   
    237.         fread( &object,sizeof( MY_TYPE_T ),1,fin );   
    238.         printf("%d %f %f %s\n",object.id,object.x_coord,   
    239.                object.y_coord,object.name);   
    240.            
    241.         fseek( fin,( 1*sizeof( MY_TYPE_T ) ),SEEK_SET );   
    242.         fread( &object,sizeof( MY_TYPE_T ),1,fin );   
    243.         printf("%d %f %f %s\n",object.id,object.x_coord,   
    244.                object.y_coord,object.name);   
    245.         //把文件指针复位到文件开头   
    246.         rewind( fin );   
    247.         fread( &object,sizeof( MY_TYPE_T ),1,fin );   
    248.         printf("%d %f %f %s\n",object.id,object.x_coord,   
    249.                object.y_coord,object.name);   
    250.         fclose( fin );   
    251.         return 0;   
    252.            
    253.     }   
    254. /************************************************/  
    255. /*  
    256.   总结:上面所有的函数都是有一些基本API来实现的。比如:open/read/write/fdopen/pread/pwrite.  
    257.   文件的输入输出API函数也可以用于管道和套接字。另外,文件和字符串操作是面向对象脚本语言的强项,如Ruby,Python.  
    258.  */ 


    展开全文
  • 1、打开spi设备文件 2、配置模数、速度、位数等 3、读写操作 4、关闭 spi.c #include <stdint.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <getopt.h> ...

    1、打开spi设备文件
    2、配置模数、速度、位数等
    3、读写操作
    4、关闭

    spi.c

    #include <stdint.h>
    #include <unistd.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <getopt.h>
    #include <fcntl.h>
    #include <sys/ioctl.h>
    #include <linux/types.h>
    #include <linux/spi/spidev.h>
    
    static int fd = 0;
    
    int spi_init(char *spi_dev,int mode,int nits,int speed)
    {
    	fd = open(spi_dev, O_RDWR);
    	if (fd < 0)
    	{
    		printf("[%s]:[%d] open spi file error\r\n", __FUNCTION__, __LINE__);
    		return -1;
    	}
    	//设置模式
    	ret = ioctl(fd, SPI_IOC_WR_MODE, &mode);
    	if (ret == -1)
    		pabort("can't set spi mode");
    
    	ret = ioctl(fd, SPI_IOC_RD_MODE, &mode);
    	if (ret == -1)
    		pabort("can't get spi mode");
    
    	//设置一次多少位
    	ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD, &bits);
    	if (ret == -1)
    		pabort("can't set bits per word");
    
    	ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD, &bits);
    	if (ret == -1)
    		pabort("can't get bits per word");
    
    	//设置最大速度
    	ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed);
    	if (ret == -1)
    		pabort("can't set max speed hz");
    
    	ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ, &speed);
    	if (ret == -1)
    		pabort("can't get max speed hz");
    
    	printf("spi mode: %d\n", mode);
    	printf("bits per word: %d\n", bits);
    	printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
    	return 0;
    }
    
    int spi_readwrte(unsigned char *txbuf, unsigned char *rxbuf, int len)
    {
    	struct spi_ioc_transfer tr =
    	 {
    		.tx_buf = (unsigned long *)txbuf,        //发送缓存区
    		.rx_buf = (unsigned long *)rxbuf,        //接收缓存区
    		.len = len/4,
    		.delay_usecs = delay,               //发送时间间隔
    		.speed_hz = speed,                  //总线速率
    		.bits_per_word = bits,              //收发的一个字的二进制位数
    	};
    
    	ret = ioctl(fd, SPI_IOC_MESSAGE(1), &tr);
    	if (ret < 1)
    		pabort("can't send spi message");
    
    	for (ret = 0; ret < len/4; ret++) 
    	{
    		if (!(ret % 6))
    			puts("");
    		printf("%.2X ", rx[ret]);
    	}
    	
    	return 0;
    }
    
    int spi_close()
    {
    	close(fd);
    	return 0;
    }
    

    main.c

    int main()
    {
    	unsigned char txbuf[] = "hello",rxbuf[50] = {0};
    	spi_init("/dev/spi1.0",SPI_CPHA|SPI_CPOL,int nits,short long speed);
    	spi_readwrte(txbuf,  rxbuf,5);
    	printf("spi rcv %x%x%x%x%x\n",rxbuf[0],rxbuf[1],rxbuf[2],rxbuf[3],rxbuf[4]);
    	spi_close();
    	return 0;
    }
    
    展开全文
  • 这里面的三个函数openlog, syslog, closelog是一套系统日志写入接口。另外那个vsyslog和syslog功能一样,只是参数格式不同。  通常,syslog守护进程读取三种格式的记录消息。此守护进程在启动时读一个配置文件。...

    syslog(),openlog(),closelog()


    这里面的三个函数openlog, syslog, closelog是一套系统日志写入接口。另外那个vsyslog和syslog功能一样,只是参数格式不同。
        通常,syslog守护进程读取三种格式的记录消息。此守护进程在启动时读一个配置文件。一般来说,其文件名为/etc/syslog.conf,该文件决定了不同种类的消息应送向何处。例如,紧急消息可被送向系统管理员(若已登录),并在控制台上显示,而警告消息则可记录到一个文件中。该机制提供了syslog函数,其调用格式如下 
    #include <syslog.h> 
    void openlog (char*ident,int option ,int facility); 
    void syslog(int priority,char*format,……) 
    void closelog();

        调用openlog是可选择的。如果不调用openlog,则在第一次调用syslog时,自动调用openlog。调用closelog也是可选择的,它只是关闭被用于与syslog守护进程通信的描述符。调用openlog 使我们可以指定一个ident,以后, 此ident 将被加至每则记录消息中。ident 一般是程序的名称(例如 ,cron ,ine 等)


    程序的用法示例代码如下:


    #include <syslog.h>
    int main(int argc, char **argv)
    {
        openlog("MyMsgMARK", LOG_CONS | LOG_PID, 0);
        syslog(LOG_DEBUG,
               "This is a syslog test message generated by program '%s'/n",
               argv[0]);
        closelog();
        return 0;
    }
     
    编译生成可执行程序后,运行一次程序将向/var/log/message文件添加一行信息如下:
            Feb 12 08:48:38 localhost MyMsgMARK[7085]: This is a syslog test message generated by program './a.out' 
     
    openlog及closelog函数说明
    此函数原型如下:
    void openlog(const char *ident, int option, int facility);
    此函数用来打开一个到系统日志记录程序的连接,打开之后就可以用syslog或vsyslog函数向系统日志里添加信息了。而closelog函数就是用来关闭此连接的。
    openlog的第一个参数ident将是一个标记,ident所表示的字符串将固定地加在每行日志的前面以标识这个日志,通常就写成当前程序的名称以作标记。第二个参数option是下列值取与运算的结果:LOG_CONS, LOG_NDELAY, LOG_NOWAIT, LOG_ODELAY, LOG_PERROR, LOG_PID,各值意义请参考man openlog手册:
           LOG_CONS
                  Write directly to system console if there is an error while sending to system logger.

           LOG_NDELAY
                  Open the connection immediately (normally, the connection is opened when the first message is logged).

           LOG_NOWAIT
                  Don’t  wait  for  child processes that may have been created while logging the message.  (The GNU C library does not create a
                  child process, so this option has no effect on Linux.)

           LOG_ODELAY
                  The converse of LOG_NDELAY; opening of the connection is delayed until syslog() is called.  (This is the  default,  and  need
                  not be specified.)

           LOG_PERROR
                  (Not in SUSv3.) Print to stderr as well.

           LOG_PID
                  Include PID with each message.
     
    第三个参数指明记录日志的程序的类型。

    syslog函数及参数
    syslog函数用于把日志消息发给系统程序syslogd去记录,此函数原型是:
    void syslog(int priority, const char *format, ...);
    第一个参数是消息的紧急级别,第二个参数是消息的格式,之后是格式对应的参数。就是printf函数一样使用。

    如果我们的程序要使用系统日志功能,只需要在程序启动时使用openlog函数来连接syslogd程序,后面随时用syslog函数写日志就行了。

    展开全文
  • 1. Linux中“一切皆文件” 在Linux系统中,一切皆文件文件类型根据其表示的意义,分为: 普通文件 设备文件:代表一个具体的硬件设备 管道文件、FIFO文件:具有特殊意义的文件,用于进程间通信; 套接字文件:...
  • DATE: 2019-9-20 1、参考 man-read man-lseek 简介几种系统调用函数...【c】文件操作函数:fprintf,fread,fwrite,fseek,ftell,fopen,fclose,fflush以及获取文件长度示例 3、系统调用函数:基本读写操作 3.1...
  • linux读写配置文件

    2013-11-25 14:10:07
    Linux中实现类似windows中获取配置文件函数GetProfileString。在读取配置文件时,window环境下,有GetProfileString函数,而Linux下则没有。网上找了⼀个能  实现其功能的函数,原理很简单。如下所示,基本...
  • 1.open内建打开文件函数 作为打开文件的“钥匙”,内建函数open()提供了初始化输入/输出(I/O)操作的通用结接口 成功打开文件后会返回一个文件对象,如果打开失败会引发一个错误 示例: file_object = open...
  • 5个函数原型: extern int open (__const char *__file, int __oflag, ...) __nonnull ((1)); extern ssize_t write (int __fd, __const void *__buf, size_t __n) __wur; extern ssize_t read (int __fd, void *__...
  • C# 读写Ini文件,全代码示例解析

    千次阅读 2018-04-02 10:04:40
    ini文件在Win95以前比较盛行,之后由于出册表等技术的出现,ini技术主键退居二线,不过对于一些小项目,读写ini文件还是很适用的。 Windows API提供了读写配置文件的操作,在C#程序中只要导入相应的API即可。例如...
  • C语言文件读写函数——fputc和fgetc

    千次阅读 2013-05-07 15:06:44
    了解了在C语言中如何打开文件后就可以正式进行文件读写操作了,文件根据类型又分为ASCII文件和二进制文件,我们首先从简单的入手,先看看ASCII文件(文本文件)是如何读取的。  ASCII文件(文本文件)中保存的是...
  • <br />把网上搜索的...默认为text方式   详细参考:http://blog.csdn.net/wanfustudio/archive/2007/09/14/1785131.aspx<br />  附录:自己写的使用fstream读写文件的两个函数 #include
  • 扩展文件大小示例,但是如果要真改变文件大小必须有I/O读写操作 无I/O示例的扩展???? 结果:原来大小是777,扩展111,lseek是888,但是文件大小还是777 加上I/O操作,即加个write 最重要的是,文件读写使用的是...
  • 系统调用中操作IO的函数,都是针对文件描述符的 通过文件描述符可以直接对相应的文件进行操作 如:open,close,write,read,ioctl等 文件IO与标准IO的权限对比 open函数 运行结果: 为什么文件描述符...
  • Linux下二进制方式读写文件

    千次阅读 2017-03-29 17:31:30
    由于接触Linux开发时间不长,开始询问度娘,度娘的回答是使用以wb方式打开文件后使用fwrite把数据写入文件,以rb方式打开文件后使用fread读出数据。下面详细介绍一下相关的函数极其使用说明。 需要用的头文件为stdio...
  • Linux下系统函数

    千次阅读 2018-12-05 16:42:16
    Linux下系统函数 rand()函数 获取02147483647(0RAND_MAX)之间的随机数。真随机需要srand()设置种子。一般用时间作为srand()的参数 #include&amp;lt;unistd.h&amp;gt; int rand(void) void srand(unsigned ...
  • linux编程里,有三个函数可以获取 文件的属性(包含了文件类型和文件权限等属性)。 三个函数的原型如下: #include int stat(const char *restrict pathname, struct stat *restrict buf); int fstat...
  • Linux x86汇编踩坑】文件读写 前言 linux文件是unix的文件处理方式,因此,无论linux文件是什么程序创建的,都可以作为连续的字节流进行访问,明确这一点是相当重要的。 文件调用号 首先看看几个关于...
  • linux下的内存映射函数mmap详解及示例代码
  • File读写文件

    千次阅读 2018-07-31 22:54:21
    File类中包含一些静态函数,用于读写文件。 1.文件路径 var path = Path.Combine(Environment.CurrentDirectory,"April.txt"); 2.读文件 ReadAllBytes 打开一个二进制文件,将文件内容读入一个字节数组,然后...
  • 队列头中包含了该队列的大量信息,包括消息队列的键值、用户ID、组ID、消息数目、读写进程ID等。其定义如下: struct msg_queue { struct ipc_perm q_perm; time_t q_stime; // last msgsnd time time_t q_rtime; ...
  • 一、ioctl 函数 ioctl用于向设备发控制和配置命令,有些命令也需要读写一些数据,但这些数据是不能用read/write读写的,称为Out-of-band数据。也就是说,read/write读写的数据是in-band数据,是I/O操作的主体,而...
  • ------------------------------------------------ #纯属个人理解,如有问题敬请谅解! #kernel version: 2.6.26 #Author: andy wang -------------------------... 在上文中讨论了VFS层是如何打开一个文件的,本文就
  • Linux系统编程】读写

    千次阅读 2019-11-08 10:10:56
    读写函数2.1 读写锁初始化2.2 读写锁销毁2.3 申请读锁2.4 申请写锁2.5 释放读写锁03. 读写锁应用示例04. 附录 01. 读写锁概述 当有一个线程已经持有互斥锁时,互斥锁将所有试图进入临界区的线程都阻塞住。但是...
  • Linux下unlink函数的使用

    万次阅读 2018-11-05 14:57:07
    一、头文件 #include&lt;unistd.h&gt; 二、函数原型 ...int unlink(const char *pathname);... 执行unlink()函数并不一定会真正的删除文件,它先会检查文件系统中此文件的连接数是否为1,如果不是...
  • Linux fcntl 函数详解

    千次阅读 2019-03-26 19:37:33
    fcntl是用来修改已经打开文件的属性的函数,包含5个功能: 复制一个已有文件描述符,功能和dup和dup2相同,对应的cmd:F_DUPFD、F_DUPFD_CLOEXEC。 当使用这两个cmd时,需要传入第三个参数...
  • Linux为程序中每个打开的文件分配一个文件描述符 文件描述符从0开始分配, 依次递增。 文件IO操作通过文件描述符来完成 当程序运行的时候,系统会默认打开3个流:标准输入、标准输出、标准错误,所对应的文件...
  • 文件I/O中的read、write、lseek函数详细分析,并给出示例及应用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,513
精华内容 12,205
关键字:

linux读写文件函数示例

linux 订阅