/* print a signed integer */
static void putd(const int d)
{
if (d >= 0) {
putu((unsigned int)d);
} else {
putchar('-'); /* negative sign */
putu((unsigned int)-d);
}
}
int xmitTest(void){
// initialize strings
char* myname;
myname = "Ashley Towne";
serial_init(9600);
// initialize LCD
LCD_init();
LCD_display_on();
set_output_device(2); // select LCD as output
// output to LCD
LCD_clear();
LCD_setpos(0,0);
printf("%s",myname);
LCD_setpos(1,0);
// output to terminal
set_output_device(1); // select UART as output device
printf("This goes to terminal\n"); // write to the screen
printf("%s\n", myname);
// loop
int foo = 0;
unsigned char mystr;
int ctr = 0;
while(ctr<10)
{
ctr = ctr + 1;
if (foo==0){mystr='0';}
else if(foo==1){mystr = '1';}
else if(foo==2){mystr = '2';}
else if(foo==3){mystr = '3';}
else if(foo==4){mystr = '4';}
else if(foo==5){mystr = '5';}
else if(foo==6){mystr = '6';}
else if(foo==7){mystr = '7';}
else if(foo==8){mystr = '8';}
else if(foo==9){
mystr = '9';
foo = -1;
}
set_output_device(2);
putu((char)(100+foo));
set_output_device(1);
LCD_char((char)(100+foo));
foo = foo + 1;
}
putu('z');
LCD_char('z');
putu(EOF);
return 1;
}
VOID
putu(
ULONG u
)
/*++
Routine Description:
Write an unsigned long to display
Arguments:
u - unsigned
Returns:
Nothing
--*/
{
if(u/10) {
putu(u/10);
}
pTextCharOut((UCHAR)((u%10)+'0'));
}
//
// output an unsigned long
//
VOID putu(__in ULONG u)
{
if(u / 10)
putu(u / 10);
UCHAR Value = static_cast<UCHAR>(u % 10) + '0';
ULONG Count;
ArcWrite(BlConsoleOutDeviceId,&Value,sizeof(Value),&Count);
}
int putd(long v)
{
int w = 0;
if (v < 0) {
w += putc('-');
v = -v;
}
w += putu(v);
return w;
}
int putf(double v, int prec)
{
int i, w = 0;
if (v < 0.0) {
w += putc('-');
v = -v;
}
w += putu(v);
w += putc('.');
for (i = 0; i < prec; ++i) {
v = v - (int)v;
v = v * 10;
w += putc('0' + (int)v + (i + 1 == prec && v - (int)v > .5));
}
return w;
}
int create_task(job_t job, void *arg, unsigned long period,
unsigned long delay, unsigned long prio_dead, int type, const char *name)
{
int i;
struct task *t;
for (i = 1; i < MAX_NUM_TASKS; ++i) /* skip task 0 (idle task) */
if (!taskset[i].valid)
break;
if (i == MAX_NUM_TASKS)
return -1;
t = taskset + i;
t->job = job;
t->arg = (arg == NULL ? t : arg);
t->name = name;
t->period = period;
t->releasetime = ticks + delay;
if (type == EDF) {
/* this is an EDF task
* priority is set to the absolute deadline of the first job
* a small absolute deadline yields a large priority */
if (prio_dead == 0)
return -1;
t->priority = prio_dead + t->releasetime;
t->deadline = prio_dead;
} else {
/* this is a fixed-priority task
* to be run in background if no other EDF job is pending */
t->priority = prio_dead;
t->deadline = 0;
}
t->released = 0;
init_task_context(t, i);
__memory_barrier();
irq_disable();
++num_tasks;
t->valid = 1;
irq_enable();
puts("Task ");
puts(name);
puts(" created, TID=");
putu(i);
putnl();
return i;
}
VOID putu(
ULONG u
)
/*++
Routine Description:
Write an unsigned long to display
Arguments:
u - unsigned
--*/
{
if (u/10)
putu(u/10);
putc((char)((u%10)+'0'));
}
int nvprintf(size_t size, const char *fmt, va_list ap)
{
u32 i;
return_val_if_fail(fmt != NULL, -1);
for (i = 0; i < size; i++) {
if (fmt[i] == '%') {
if ((i + 1) < size && fmt[i+1] != '%') {
char conv = fmt[i+1];
switch (conv) {
case 'c':
{
char c = va_arg(ap, char);
putchar(c);
i++;
break;
}
case 'u':
{
unsigned int u = va_arg(ap,
unsigned int);
putu(u);
i++;
break;
}
case 'x':
case 'X':
{
unsigned int x = va_arg(ap,
unsigned int);
putx(x);
i++;
break;
}
case 'd':
case 'i':
{
int d = va_arg(ap, int);
putd(d);
i++;
break;
}
case 'p':
{
void *p = va_arg(ap, void *);
putp(p);
i++;
break;
}
case 's':
{
const char *s = va_arg(ap, char *);
puts(s);
i++;
break;
}
}
}
} else {
//
// standard printf function with a subset of formating features supported.
//
// supported
// %d, %ld - signed short, signed long
// %u, %lu - unsigned short, unsigned long
// %c, %s - character, string
// %x, %lx - unsigned print in hex, unsigned long print in hex
// %wS,%wZ - unicode string
//
// does not do:
//
// - field width specification
// - floating point.
//
VOID BlPrint(__in PCHAR cp,...)
{
PVOID ap = Add2Ptr(&cp,sizeof(PCHAR),PVOID);
USHORT b = 0;
ULONG Count = 0;
ULONG DeviceId = BlConsoleOutDeviceId ? BlConsoleOutDeviceId : 1;
while(b = *cp ++)
{
if(b == '%')
{
USHORT c = *cp ++;
switch(c)
{
case 'c':
ArcWrite(DeviceId,ap,sizeof(UCHAR),&Count);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'd':
puti(*static_cast<PLONG>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'l':
{
USHORT d = *cp ++;
switch(d)
{
case 'd':
puti(*static_cast<PLONG>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'u':
putu(*static_cast<PUSHORT>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'x':
{
ULONG x = *static_cast<PULONG>(ap);
ULONG ZeroLength = (x < 0x10) + (x < 0x100) + (x < 0x1000) + (x < 0x10000) + (x < 0x100000) + (x < 0x1000000) + (x < 0x10000000);
while(ZeroLength --)
ArcWrite(DeviceId,"0",sizeof(UCHAR),&Count);
putx(x);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
}
break;
}
}
break;
case 's':
{
PCHAR String = *static_cast<PCHAR*>(ap);
ArcWrite(DeviceId,String,strlen(String),&Count);
ap = Add2Ptr(ap,sizeof(PCHAR),PVOID);
}
break;
case 'u':
putu(*static_cast<PUSHORT>(ap));
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
break;
case 'w':
{
USHORT d = *cp ++;
switch(d)
{
case 'S':
case 'W':
putwS(*static_cast<PUNICODE_STRING*>(ap));
ap = Add2Ptr(ap,sizeof(PUNICODE_STRING),PVOID);
break;
}
}
break;
case 'x':
{
USHORT x = *static_cast<PUSHORT>(ap);
ULONG ZeroLength = (x < 0x10) + (x < 0x100) + (x < 0x1000);
while(ZeroLength --)
ArcWrite(DeviceId,"0",sizeof(UCHAR),&Count);
putx(x);
ap = Add2Ptr(ap,sizeof(LONG),PVOID);
}
break;
default:
ArcWrite(DeviceId,&b,sizeof(UCHAR),&Count);
ArcWrite(DeviceId,&c,sizeof(UCHAR),&Count);
break;
}
}
else
{
if(!DbcsLangId || !GrIsDBCSLeadByte(cp[-1]))
{
ArcWrite(DeviceId,cp - 1,1,&Count);
}
else
{
ArcWrite(DeviceId,cp - 1,2,&Count);
cp += 1;
}
}
}
}
VOID
BlPrint(
PCHAR cp,
...
)
/*++
Routine Description:
Standard printf function with a subset of formating features supported.
Currently handles
%d, %ld - signed short, signed long
%u, %lu - unsigned short, unsigned long
%c, %s - character, string
%x, %lx - unsigned print in hex, unsigned long print in hex
Does not do:
- field width specification
- floating point.
Arguments:
cp - pointer to the format string, text string.
Returns:
Nothing
--*/
{
USHORT b,c,w,len;
PUCHAR ap;
ULONG l;
//
// Cast a pointer to the first word on the stack
//
ap = (PUCHAR)&cp + sizeof(PCHAR);
sc = ' '; // default padding char is space
//
// Process the arguments using the descriptor string
//
while (b = *cp++)
{
if (b == '%')
{
c = *cp++;
switch (c)
{
case 'd':
puti((long)*((int *)ap));
ap += sizeof(int);
break;
case 's':
BlPuts(*((PCHAR *)ap));
ap += sizeof (char *);
break;
case 'c':
putc(*((char *)ap));
ap += sizeof(int);
break;
case 'x':
w = *((USHORT *)ap);
len = ZLEN_SHORT(w);
while(len--) putc('0');
putx((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'u':
putu((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'l':
c = *cp++;
switch(c) {
case 'u':
putu(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'x':
l = *((ULONG *)ap);
len = ZLEN_LONG(l);
while(len--) putc('0');
putx(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'd':
puti(*((ULONG *)ap));
ap += sizeof(long);
break;
}
break;
default :
putc((char)b);
putc((char)c);
}
}
else
putc((char)b);
}
}
VOID
BlPrint(
PCHAR cp,
...
)
/*++
Routine Description:
Standard printf function with a subset of formating features supported.
Currently handles
%d, %ld - signed short, signed long
%u, %lu - unsigned short, unsigned long
%c, %s - character, string
%x, %lx - unsigned print in hex, unsigned long print in hex
Does not do:
- field width specification
- floating point.
Arguments:
cp - pointer to the format string, text string.
Returns:
Nothing
--*/
{
USHORT b,c,w,len;
PUCHAR ap;
ULONG l;
//
// Cast a pointer to the first word on the stack
//
ap = (PUCHAR)&cp + sizeof(PCHAR);
//
// Process the arguments using the descriptor string
//
while(b = *cp++) {
if(b == '%') {
c = *cp++;
switch (c) {
case 'd':
puti((long)*((int *)ap));
ap += sizeof(int);
break;
case 's':
TextStringOut(*((PCHAR *)ap));
ap += sizeof(char *);
break;
case 'c':
//
// Does not handle dbcs chars
//
pTextCharOut(*((char *)ap));
ap += sizeof(int);
break;
case 'x':
w = *((USHORT *)ap);
len = (USHORT)ZLEN_SHORT(w);
while(len--) pTextCharOut('0');
putx((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'u':
putu((ULONG)*((USHORT *)ap));
ap += sizeof(int);
break;
case 'w':
c = *cp++;
switch (c) {
case 'S':
case 'Z':
putwS(*((PUNICODE_STRING *)ap));
ap += sizeof(PUNICODE_STRING);
break;
}
break;
case 'l':
c = *cp++;
switch(c) {
case '0':
break;
case 'u':
putu(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'x':
l = *((ULONG *)ap);
len = (USHORT)ZLEN_LONG(l);
while(len--) pTextCharOut('0');
putx(*((ULONG *)ap));
ap += sizeof(long);
break;
case 'd':
puti(*((ULONG *)ap));
ap += sizeof(long);
break;
}
break;
default :
pTextCharOut((char)b);
pTextCharOut((char)c);
}
} else {
//
// Could be a double-byte char.
//
cp = TextCharOut(cp-1);
}
}
}
