HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r86:ac0656f4856d

SYNC

Jeandet Alexis -

r86:ac0656f4856d dev_alexis

parent child

Context file:

r86:ac0656f4856d

Collapse all files

examples/TEST_SIMULATOR/main.c +3 -3

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <bsp.h>
             #include <core.h>
             #include <bsp.h>
             #include <spi.h>
             #include <fat32.h>
             #include <ucdirent.h>
             #include <string.h>
             #include <unistd.h>
             #include <terminal.h>
             #include <stdarg.h>
             #include <malloc.h>
             extern streamdevice* __opnfiles__[];
             extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
             extern void test_address(LCD_t* LCD);
             extern void printRootClustersChain(FAT32fs* sdcard2FAT32part);
             char buffer[512];
             //void streamdevicePrint(streamdevice* dev, const char* format,...)
             //{
             //    char str_buffer[512]="";
             //    int i;
             //    va_list ap;
             //    va_start(ap,format);
             //    vasprintf(str_buffer,format,ap);
             //    va_end(ap);
             //    i=strlen(str_buffer);
             //    dev->ops->write(dev,(void*)str_buffer,1,i);
             //}
             int _write(int file, char *ptr, int len)
             {
                 if(file<__MAX_OPENED_FILES__ && __opnfiles__[file]!=NULL)
                 {
                     if(__opnfiles__[file]->ops->write(__opnfiles__[file],ptr,1,len)) return len;
                 }
                 return len;
             }
             int _write_r (struct _reent *r, int file, char * ptr, int len)
             {
                 return _write(file, ptr, len);
             }
             //int printf(const char *format,...)
             //{
             //    char str_buffer[512]="";
             //    for(int i =0;i<512;i++)str_buffer[i]='\0';
             //    int i;
             //    va_list ap;
             //    va_start(ap,format);
             //    vasprintf(str_buffer,format,ap);
             //    va_end(ap);
             //    i=strlen(str_buffer);
             //    __opnfiles__[1]->ops->write(__opnfiles__[1],(void*)str_buffer,1,i);
             //}
             void lcd_print()
             {
                 lcd0.paintFilRect(&lcd0,10,10,100,100,0,0,0x0F0F);
                // __opnfiles__[1]->ops->write(__opnfiles__[1],(void*)"hello",1,5);
             }
             void playFile(ucdirent* file,FAT32fs* part)
             {
                 extern volatile vs10XXDev audioCodec0;
                 char direntName[]="                                                                             \n";
                 uint32_t fileLba,nextLba;
                 int i=0;
                 fat32getdirentname(file,direntName);
                 //gpioset(LCD_BACKL);
                 printf("%s\n",direntName);
                 nextLba=fat32getdirentlba(file);
                 //printf("Streaming File\n");
                 //gpioclr(LCD_BACKL);
             }
             void listFiles()
             {
                 extern FAT32fs sdcard2FAT32part1,sdcard2FAT32part2,sdcard2FAT32part3,sdcard2FAT32part4;
                 ucdirent root;
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))
                 {
                     printf("Reading on SDCARD2 part1\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part1);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
                 gpioset(LED2);
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
                 {
                     printf("Reading on SDCARD2 part2\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part2);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
             }
             int libuc_main2()
             {
                 printRootClustersChain(&sdcard2FAT32part1);
             }
             int libuc_main()
             {
                 char in[255];
                 //lcd_print();
                 printf("hello world\n");
                 delay_100us(10000);
               //  streamdevicePrint(__opnfiles__[1],"test Hello %d %f \n",1234567,8.96);
-                lcd0.paintText(&lcd0,"A",10,100,&ComicSansMS_18,0x0);
+                listFiles();
-                while(1)test_address(&lcd0);
+               // lcd0.paintText(&lcd0,"A",10,100,&ComicSansMS_18,0x0);
-               // listFiles();
+               // while(1)test_address(&lcd0);
             //    while (scanf("%c",in))
             //    {
                     sleep(5);
             //    }
             }

libuc2.pro +1 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
             SUBDIRS +=      src/lib.pro \
-            		bsp\
+                            bsp \
             	 	examples

mkspecs/features/stm32f4/syscalls.c 0 -1

             #include <stdlib.h>
             #include <errno.h>
             #include <string.h>
             #include <sys/stat.h>
             #include <sys/types.h>
             #include <sys/times.h>
             #include <streamdevices.h>
             #include <string.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdint.h>
             #include <bsp.h>
-            #include <core.h>
             #undef errno
             #ifdef __cplusplus
             extern "C" {
             #endif
             extern int errno;
             extern int32_t __max_opened_files__;
             extern streamdevice* __opnfiles__[];
             extern int32_t* __fs_root__;
             extern int32_t __fs_root_size__;
             char *__env[1] = { 0 };
             char **environ = __env;
             int _exit()
             {
                 while(1)
                 {
                     delay_100us(10000);
                     gpioset(LED2);
                     delay_100us(10000);
                     gpioclr(LED2);
                 }
             }
             int _close(int file)
             {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     return __opnfiles__[file]->ops->close( __opnfiles__[file]);
                 }
                 return 0;
             }
             int _write(int file, char *ptr, int len)
             {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     if(__opnfiles__[file]->ops->write(__opnfiles__[file],ptr,1,len)) return len;
                 }
                 return len;
             }
             int _execve(char *name, char **argv, char **env) {
                 errno = ENOMEM;
                 return -1;
             }
             int _fork(void) {
                 errno = EAGAIN;
                 return -1;
             }
             int _fstat(int file, struct stat *st) {
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             int _getpid(void) {
                 return 1;
             }
             int _isatty(int file) {
                 return 1;
             }
             int _kill(int pid, int sig) {
                 errno = EINVAL;
                 return -1;
             }
             int _link(char *old, char *_new) {
                 errno = EMLINK;
                 return -1;
             }
             int _lseek(int file, int ptr, int dir) {
                 return 0;
             }
             #include <gpio.h>
             int _open(const char *name, int flags, int mode)
             {
                 if(!strncmp("UART", name, 4) && ((name[4] & 0x30)==0x30))
                 {
                     //uart_t* uart1 = malloc(sizeof(uart_t));
                     streamdevice* fd1 = malloc(sizeof(streamdevice));
                     uart_t uart=uartopen((name[4] & 0xF)-1);
                     if(uart!=-1);
                     {
                         uartmkstreamdev(uart,fd1);
                         int i=2;
                         while((i<__max_opened_files__) && (__opnfiles__[i]!=NULL))i++;
                         if(i!=__max_opened_files__)
                         {
                             __opnfiles__[i] = fd1;
                             return i;
                         }
                         else printf("Too much files opened\n\r");
                     }
                 }
                 return -1;
             }
             int _read(int file, char *ptr, int len) {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     if(__opnfiles__[file]->ops->read(__opnfiles__[file],ptr,1,len)) return len;
                 }
                 return 0;
             }
             caddr_t _sbrk(int incr) {
                 register char * stack_ptr __asm__ ("sp");
                 extern char end; /* Defined by the linker */
                 static char *heap_end;
                 char *prev_heap_end;
                 if (heap_end == 0) {
                     heap_end = &end;
                 }
                 prev_heap_end = heap_end;
                 if (heap_end + incr > stack_ptr) {
                     printf("Heap and stack collision\n");
                     //abort ();
                     while(1)
                     {
                         delay_100us(10000);
                         gpioset(LED2);
                         delay_100us(10000);
                         gpioclr(LED2);
                     }
                 }
                 heap_end += incr;
                 return (caddr_t) prev_heap_end;
             }
             int _stat(char *file, struct stat *st) {
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             int _times(struct tms *buf) {
                 return -1;
             }
             int _unlink(char *name) {
                 errno = ENOENT;
                 return -1;
             }
             int _wait(int *status) {
                 errno = ECHILD;
                 return -1;
             }
             int _read_r (struct _reent *r, int file, char * ptr, int len)
             {
                 r = r;
                 file = file;
                 ptr = ptr;
                 len = len;
                 _read(file,ptr,len);
                 errno = EINVAL;
                 return -1;
             }
             /***************************************************************************/
             int _lseek_r (struct _reent *r, int file, int ptr, int dir)
             {
                 r = r;
                 file = file;
                 ptr = ptr;
                 dir = dir;
                 return 0;
             }
             /***************************************************************************/
             int _write_r (struct _reent *r, int file, char * ptr, int len)
             {
                 return _write(file, ptr, len);
             }
             /***************************************************************************/
             int _close_r (struct _reent *r, int file)
             {
                 return 0;
             }
             /***************************************************************************/
             caddr_t _sbrk_r (struct _reent *r, int incr)
             {
                 register char * stack_ptr __asm__ ("sp");
                 extern char end; /* Defined by the linker */
                 static char *heap_end;
                 char *prev_heap_end;
                 if (heap_end == 0) {
                     heap_end = &end;
                 }
                 prev_heap_end = heap_end;
                 if (heap_end + incr > stack_ptr) {
                     printf( "Heap and stack collision\n");
                     //abort ();
                     while(1)
                     {
                         delay_100us(10000);
                         gpioset(LED2);
                         delay_100us(10000);
                         gpioclr(LED2);
                     }
                 }
                 heap_end += incr;
                 return (caddr_t) prev_heap_end;
             }
             /***************************************************************************/
             int _fstat_r (struct _reent *r, int file, struct stat * st)
             {
                 r = r;
                 file = file;
                 memset (st, 0, sizeof (* st));
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             /***************************************************************************/
             int _open_r(struct _reent *r,const char *name, int flags, int mode)
             {
                 return _open(name, flags, mode);
             }
             int _isatty_r(struct _reent *r, int fd)
             {
                 r = r;
                 fd = fd;
                 return 1;
             }
             #ifdef __cplusplus
             }
             #endif

examples/TEST_SIMULATOR/bin-simulator/TEST_SIMULATOR removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

examples/helloWorld/bin-simulator/helloWorld removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages