int sys_fstat(void * scallStructPtr) {
struct fstatSyscall s;
struct stat st;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct fstatSyscall), 0, (unsigned int *)&s);
fs_stat(&(cProc->openFiles[s.fd]->node), &st);
uputs(cProc, (size_t)s.buf, 0, 14, sizeof(struct stat), 0, (unsigned int *)&st);
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct fstatSyscall), 0, (unsigned int *)&s);
return 0;
}
int sys_stat(void * scallStructPtr) {
unsigned int fn_buf[1024];
struct stat st;
struct statSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct statSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.filename, 0, 14, 1024, 1, fn_buf);
k_stat(fn_buf, &st);
uputs(cProc, (size_t)s.buf, 0, 14, sizeof(struct stat), 0, (unsigned int *)&st);
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct statSyscall), 0, (unsigned int *)&s);
return 0;
}
int sys_dup2(void * scallStructPtr) {
int fd;
struct dup2Syscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct dup2Syscall), 0, (unsigned int *)&s);
if(!cProc->openFiles[s.oldfd] || s.newfd<0 || s.newfd>MAX_FILES_PER_PROC ) {
s.retval = -1;
goto sys_dup2_out;
}
if(s.oldfd == s.newfd) {
s.retval = s.newfd;
goto sys_dup2_out;
}
if(cProc->openFiles[s.newfd]) {
k_close(cProc->openFiles[s.newfd]);
}
cProc->openFiles[s.oldfd] = cProc->openFiles[s.oldfd];
cProc->openFiles[s.oldfd]->refcnt++;
s.retval = fd;
sys_dup2_out:
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct dup2Syscall), 0, (unsigned int *)&s);
return 0;
}
int sys_dup(void * scallStructPtr) {
int fd;
struct dupSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct dupSyscall), 0, (unsigned int *)&s);
if(!cProc->openFiles[s.oldfd]) {
s.retval = -1;
goto sys_dup_out;
}
for (fd = 0; fd < MAX_FILES_PER_PROC; fd++) {
if (!cProc->openFiles[fd]) {
break;
}
}
if (fd != MAX_FILES_PER_PROC) {
cProc->openFiles[fd] = cProc->openFiles[s.oldfd];
cProc->openFiles[fd]->refcnt++;
s.retval = fd;
goto sys_dup_out;
}
s.retval = -1;
sys_dup_out:
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct dupSyscall), 0, (unsigned int *)&s);
return 0;
}
/* TASK 2 */
static void vHookTask2( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
char led_status = 0;
unsigned long long old_time = vGetTimerValue();
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK2_DELAY );
/*
uputs("Task2 ");
uputs("knob: ");
uputi(task2_knob);
uputs(" inst: ");
uputi(getMiscVal());
uputs("\n");
*/
led_status = !led_status;
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, led_status);
uputs("Fire!\n");
}
}
// ================================= MAIN =================================
int main( void )
{
/* Configure the clocks, UART and GPIO. */
prvSetupHardware();
/* Start the tasks defined within the file. */
// arguments: hook, name, stack_size, hook_arguments, priority, return_handle, knob_handle, knob_min, knob_max, utility_scalar
// *Note: task_knob values are initialized to task_knob_min by task creation API
#ifdef USE_VARTOS
xTaskCreate( vHookTask2, "Task2", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask2, &task2_knob, 50, 500, 1);
//xTaskCreate( vHookTask3, "Task3", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask3, &task3_knob, 50, 500, 1);
#else
xTaskCreate( vHookTask2, "Task2", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask2);
//xTaskCreate( vHookTask3, "Task3", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask3);
#endif
/* Start the scheduler. */
// power function, temp function, desired lifetime (hours), battery capacity (mWh)
#ifdef USE_VARTOS
vTaskStartScheduler( getPowerConsumed , getTemperature , 100*24 , 600 );
#else
vTaskStartScheduler();
#endif
/* Will only get here if there was insufficient heap to start the
scheduler. */
uputs("INSUFFICIENT HEAP\n");
return 0;
}
int sys_pipe(void * scallStructPtr) {
struct pipeSyscall s;
int fd;
char newPath[100];
newPath[0] = 0;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct pipeSyscall), 0, (unsigned int *)&s);
k_mkfifo(newPath);
for (fd = 0; fd < MAX_FILES_PER_PROC; fd++) {
if (!cProc->openFiles[fd]) {
break;
}
}
if (fd != MAX_FILES_PER_PROC) {
cProc->openFiles[fd] = k_open(newPath, O_WRONLY);
s.pipefd[1] = fd;
}
for (; fd < MAX_FILES_PER_PROC; fd++) {
if (!cProc->openFiles[fd]) {
break;
}
}
if (fd != MAX_FILES_PER_PROC) {
cProc->openFiles[fd] = k_open(newPath, O_RDONLY);
s.pipefd[0] = fd;
}
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct pipeSyscall), 0, (unsigned int *)&s);
return 0;
}
/* TASK 2 */
static void vHookTask2( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
char led_status = 0;
vemu_regs d,p,c;
vemu_regs *dp,*pp,*cp,*tp;
vemu_sensors s;
dp = &d;
pp = &p;
cp = &c;
vemu_read_registers(cp);
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK3_DELAY );
tp = cp;
cp = pp;
pp = tp;
vemu_read_registers(cp);
vemu_read_sensors(&s);
vemu_delta(dp, cp, pp);
/*
uputs("Task2 ");
uputs("knob: ");
uputi(task2_knob);
uputs(" inst: ");
uputi(getMiscVal());
uputs("\n");
*/
led_status = !led_status;
GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_0, led_status);
uputs("\n--TASK3--\n");
uputs("\nA t: ");
uputi(dp->at);
uputs("\nA e: ");
uputi(dp->ae);
uputs("\nS t: ");
uputi(dp->st);
uputs("\nS e: ");
uputi(dp->se);
uputs("\nT : ");
uputi(s.t);
uputs("\nPa : ");
uputi(s.ap);
uputs("\nPs : ");
uputi(s.sp);
uputs("\ncounter : ");
uputi(getMiscVal());
}
}
/* TASK 3 */
static void vHookTask3( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK3_DELAY );
uputs("Task3 ");
uputs("knob: ");
uputi(task3_knob);
uputs(" inst: ");
uputi(getMiscVal());
uputs("\n");
for( i=0; i<task3_knob; i++){__asm__("nop");}
}
}
int sys_ioctl(void * scallStructPtr) {
unsigned int fn_buf[1024];
struct stat st;
struct ioctlSyscall s;
int retval;
size_t sz;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct ioctlSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.p, 0, 14, 1024, 0, fn_buf);
retval = k_ioctl(cProc->openFiles[s.fd], s.req, fn_buf, &sz);
s.retval = retval;
if(sz) {
uputs(cProc, (size_t)s.p, 0, 14, sz, 0, (unsigned int *)&st);
}
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct ioctlSyscall), 0, (unsigned int *)&s);
return 0;
}
/* TASK 2 */
static void vHookTask2( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
char led_status = 0;
unsigned long long old_time = vGetTimerValue();
vemu_regs d,p,c;
vemu_regs *dp,*pp,*cp,*tp;
vemu_sensors s;
dp = &d;
pp = &p;
cp = &c;
vemu_read_registers(cp);
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK2_DELAY );
uputs("Task2 ");
tp = pp;
pp = cp;
cp = tp;
vemu_read_registers(cp);
vemu_delta(dp, cp, pp);
led_status = !led_status;
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, led_status);
uputs("\nA t: ");
uputi(dp->at);
uputs("\nA e: ");
uputi(dp->ae);
uputs("\nS t: ");
uputi(dp->st);
uputs("\nS e: ");
uputi(dp->se);
uputs("\nT : ");
uputi(s.t);
uputs("\nPa : ");
uputi(s.ap);
uputs("\nPs : ");
uputi(s.sp);
}
}
// *******************************************************************************************************************************
// zeigt reihen eines clusters an, wird für ffls benötigt !
// es wird ab dem start sektor start_sec, der dazugehörige cluster angezeigt. geprüft wird ob es ein richtiger
// eintrag in der reihe ist (nicht gelöscht, nicht frei usw). die sektoren des clusters werden nachgeladen.
// die dateien werden mit namen und datei größe angezeigt.
// *******************************************************************************************************************************
void lsRowsOfClust (unsigned long int start_sec){
unsigned char row; // reihen
unsigned char sec=0; // sektoren
unsigned char tmp[12]; // tmp string zur umwandlung
do{
fat_loadSector(start_sec + sec); // sektoren des clusters laden
for(row=0;row<16;row++){ // geht durch reihen des sektors
fat_loadRowOfSector(row); // reihe eines sektors (auf dem puffer) laden
if( (file.attrib==0x20||file.attrib==0x10) && (file.name[0]!=0xE5 && file.name[0]!=0x00) ){
uputs(file.name);
uputc(' ');
ultoa(file.length,(char*)tmp,10);
uputs(tmp);
uputc('\n');
}
}
}while(++sec<fat.secPerClust);
}
int sys_mkfifo(void * scallStructPtr) {
unsigned int iobuf[1024];
struct mkfifoSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct mkfifoSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.path, 0, 14, 1024, 1, iobuf);
s.res = k_mkfifo(iobuf);
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct mkfifoSyscall), 0, (unsigned int *)&s);
return 0;
}
int sys_umount(void * scallStructPtr) {
unsigned int mount_point_path[512];
struct umountSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct umountSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.mount_point_path, 0, 14, 512, 1, mount_point_path);
s.res = k_umount((const char *)mount_point_path);
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct umountSyscall), 0, (unsigned int *)&s);
return 0;
}
void main(void){
uinit(); // uart initialisierung
uputs((unsigned char*)"\nBoot");
while (mmc_init() !=0){ //ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten
;
}
uputs((unsigned char*)"... ");
if(0==fat_initfat()){ //ist der Rückgabewert ungleich NULL ist ein Fehler aufgetreten
uputs((unsigned char*)"Ok\n"); // wenn auf dem terminal "Boot... OK" zu lesen ist, ist init ok. jetzt kann man schreiben/lesen
beispiele();
}
}
void read_meas( void )
{
uchar id[8], diff;
uchar s[30];
uchar i;
uint temp;
for( diff = SEARCH_FIRST; diff != LAST_DEVICE; )
{
diff = w1_rom_search( diff, id );
if( diff == PRESENCE_ERR )
{
uputsnl( "No Sensor found" );
break;
}
if( diff == DATA_ERR )
{
uputsnl( "Bus Error" );
break;
}
if( id[0] == 0x28 || id[0] == 0x10 ) // temperature sensor
{
uputs( "ID: " );
for( i = 0; i < 8; i++ ){
sprintf( s, "%02X ", id[i] );
uputs( s );
}
w1_byte_wr( READ ); // read command
temp = w1_byte_rd(); // low byte
temp |= (uint)w1_byte_rd() << 8; // high byte
if( id[0] == 0x10 ) // 9 -> 12 bit
temp <<= 3;
sprintf( s, " T: %04X = ", temp ); // hex value
uputs( s );
sprintf( s, "%4d.%01d�C", temp >> 4, (temp << 12) / 6553 ); // 0.1�C
uputsnl( s );
}
}
/* TASK 2 */
static void vHookTask2( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
char led_status = 0;
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK2_DELAY );
uputs("Task2 ");
uputs("knob: ");
uputi(task2_knob);
uputs(" inst: ");
uputi(getMiscVal());
uputs("\n");
for( i=0; i<task2_knob; i++){__asm__("nop");}
led_status = !led_status;
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0, led_status);
}
}
int sys_unlink(void * scallStructPtr) {
unsigned int iobuf[1024];
struct unlinkSyscall s;
struct stat st;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct unlinkSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.path, 0, 14, 1024, 1, iobuf);
k_stat(iobuf, &st);
if (S_ISDIR(st.st_mode)) {
s.res = -1;
} else {
s.res = k_unlink((const char *)iobuf);
}
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct unlinkSyscall), 0, (unsigned int *)&s);
return 0;
}
int sys_close(void * scallStructPtr) {
int fd;
struct closeSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct closeSyscall), 0, (unsigned int *)&s);
if ((s.fd >= 0) && (s.fd < MAX_FILES_PER_PROC)) {
if (cProc->openFiles[s.fd]) {
k_close(cProc->openFiles[s.fd]);
cProc->openFiles[s.fd] = 0;
s.fd = 0;
goto sys_close_out;
}
}
s.fd = -1;
sys_close_out:
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct closeSyscall), 0, (unsigned int *)&s);
return 0;
}
int sys_mknod(void * scallStructPtr) {
unsigned int iobuf[1024];
struct mknodSyscall s;
char type;
if(s.mode & S_IFCHR) {
type = 'c';
} else if(s.mode & S_IFBLK) {
type = 'b';
}
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct mknodSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.path, 0, 14, 1024, 1, iobuf);
s.res = k_mknod(iobuf,type,s.major,s.minor);
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct mknodSyscall), 0, (unsigned int *)&s);
return 0;
}
static void readPowTemp ( void *pvParameters ){
portTickType xLastExecutionTime = xTaskGetTickCount();
vemu_sensors s;
for( ;; )
{
// Enforce task frequency
vTaskDelayUntil( &xLastExecutionTime, READPOWTEMP_DELAY );
// read sensors
vemu_read_sensors(&s);
PowerModel.temps[PowerModel.num] = s.t;
PowerModel.ps[PowerModel.num] = s.sp;
PowerModel.pa[PowerModel.num] = s.ap;
// if points are collected, fit the models
if( ++PowerModel.num == POWER_MODEL_POINTS ){
// fit sleep power model
fitPsModel();
// fit active power model
fitPaModel();
// print results
uputs("\n\n<<< slope / offset : >>>\n");
uputi((int)(1000*PowerModel.psslope));
uputs("\n");
uputi((int)(1000*PowerModel.psoffset));
uputs("\n");
uputi((int)(1000*PowerModel.paslope));
uputs("\n");
uputi((int)(1000*PowerModel.paoffset));
uputs("\n");
// find optimal DC
PowerModel.optimalDC = findOptimalDC( PowerModel.lifetime_hours,
PowerModel.energy_joules );
uputs("optimal DC x 1000\n");
uputi((int)(1000*PowerModel.optimalDC));
uputs("\n");
// reset power model
PowerModel.num = 0;
// suspend our own operation until someone wakes us up
vTaskSuspend( NULL );
}
}
}
/* TASK 3 */
static void vHookTask3( void *pvParameters )
{
portTickType xLastExecutionTime = xTaskGetTickCount();
unsigned int i;
//char pin_status = 0;
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK3_DELAY );
/*
uputs("Task3 ");
uputs("knob: ");
uputi(task3_knob);
uputs(" inst: ");
uputi(getMiscVal());
uputs("\n");
*/
uputs("I'm task3, bitch!\n");
}
}
int sys_open(void * scallStructPtr) {
int fd;
unsigned int fn_buf[1024];
struct openSyscall s;
ugets(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct openSyscall), 0, (unsigned int *)&s);
ugets(cProc, (size_t)s.filename, 0, 14, 1024, 1, fn_buf);
for (fd = 0; fd < MAX_FILES_PER_PROC; fd++) {
if (!cProc->openFiles[fd]) {
break;
}
}
if (fd != MAX_FILES_PER_PROC) {
cProc->openFiles[fd] = k_open(fn_buf, s.mode);
s.mode = fd;
} else {
s.mode = -1;
}
uputs(cProc, (size_t)scallStructPtr, 0, 14, sizeof(struct openSyscall), 0, (unsigned int *)&s);
return 0;
}
// ================================= MAIN =================================
int main( void )
{
/* Configure the clocks, UART and GPIO. */
prvSetupHardware();
/* Start the tasks defined within the file. */
// arguments: hook, name, stack_size, hook_arguments, priority, return_handle, knob_handle, knob_min, knob_max, utility_scalar
// *Note: task_knob values are initialized to task_knob_min by task creation API
#ifdef USE_VARTOS
// VaRTOS-specific helper tasks
xTaskCreate( readPowTemp, "readPT", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handle_readPowTemp, NULL, 1,1,1 );
xTaskCreate( learnKnobTime, "learnKt", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handle_learnKnobTime, NULL, 1,1,1 );
xTaskCreate( checkErrors, "checkE", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handle_checkErrors, NULL, 1,1,1 );
// Generic tasks
xTaskCreate( vHookTask1, "Task1", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask1, &task1_knob, 50, 500, 1);
xTaskCreate( vHookTask2, "Task2", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask2, &task2_knob, 50, 500, 1);
#else
xTaskCreate( vHookTask1, "Task1", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask1);
xTaskCreate( vHookTask2, "Task2", configMINIMAL_STACK_SIZE, NULL, mainTASK_PRIORITY, &handleTask2);
#endif
/* Start the scheduler. */
// power function, temp function, desired lifetime (hours), battery capacity (mWh)
#ifdef USE_VARTOS
PowerModel.lifetime_hours = 140*24;
PowerModel.energy_joules = 2592;
vTaskStartScheduler( getPowerConsumed , getTemperature , rom_temp_model , 100*24 , 600 );
#else
vTaskStartScheduler();
#endif
/* Will only get here if there was insufficient heap to start the
scheduler. */
uputs("INSUFFICIENT HEAP\n");
return 0;
}
/* TASK 1 */
static void vHookTask1( void *pvParameters )
{
int taskid = *(int *)pvParameters;
portTickType xLastExecutionTime = xTaskGetTickCount();
vemu_regs curr, prev, delta;
//memset(&curr, 0, sizeof(vemu_regs));
//memset(&prev, 0, sizeof(vemu_regs));
//memset(&delta, 0, sizeof(vemu_regs));
vemu_regs *cp, *pp, *tp, *dp;
cp = &curr;
pp = &prev;
dp = δ
for( ;; )
{
/* Enforce task frequency */
vTaskDelayUntil( &xLastExecutionTime, TASK1_DELAY );
/* Update varEMU stats */
tp = pp;
pp = cp;
cp = tp;
vemu_read_state(cp);
vemu_delta(dp, cp, pp);
uputs("vVemuTask ");
uputi(taskid);
uputs(" ");
unsigned long long number = cp->total_cycles;
uputs("C: ");
uputi(number);
uputs(" ");
uputs("D: ");
uputi(dp->total_cycles);
uputs(" ");
uputs("S: ");
uputi(cp->slp_time);
uputs(" ");
uputs("D: ");
uputi(dp->slp_time);
uputs(" ");
uputs("AE: ");
uputi(cp->total_act_energy);
uputs(" ");
uputs("D: ");
uputi(dp->total_act_energy);
uputs(" ");
uputs("SE: ");
uputi(cp->slp_energy);
uputs(" ");
uputs("D: ");
uputi(dp->slp_energy);
uputs("\n");
}
}
void main() {
uputs("Hello, World! uputs is magic.\n");
}
