zXc developments

Safe Interrupt Enable / Disable

Shawn — Mon, 24 May 2010 21:41:53 +0000

Having trouble switching from cooperative tasking? One of the easiest oversights is your “sei” and “cli” sections.

The diagram below shows how you can run into problems within the critical sections of code. In this example when the memory allocation ends the interrupts are enabled with “cli” removing the critical section around the linked list manager. Once this happens RTI ISR fires and switches in thread 2. This example shows thread 2 popping an item from this list breaking the flow inside of thread 1.

To solve this problem we use a counting semaphore that allows us to keep track of the depth of the critical section.

unsigned int CriticalDepth = 0;
 
void DisableInterrupts( void )
{
   asm volatile("sei");
   ++CriticalDepth;
}
 
void EnableInterrupts( bool force )
{
   --CriticalDepth;
 
   if( CriticalDepth < 1 || force )
   {
      CriticalDepth = 0;
      asm volatile("cli");
   }
}

Threading

Shawn — Thu, 29 Apr 2010 19:23:46 +0000

Threading allows functions to execute concurrently. The example below shows two threads switching between running and sleeping. As the RTI ISR executes it takes the current process off the schedule (list of processes) and switches in the next process on the schedule. Once all processes have been removed from the schedule the “Scheduler” steps in and creates a new schedule.

Cooperative multitasking allows for threads to switch themselves out of processing during down time. Below is an example of this. If you find problems with the code please let me know with a comment.

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned int size_t;
 
#define THREADMAX 16
#define STACKSIZE 0x200
 
void* threads[THREADMAX];
unsigned int threadcount;
void* _stackpointer;
 
struct sStack
{
    //GCC Stack Vars
    u16 xy; //Soft Register XY
    u16 z; //Soft Register Z
    u16 tmp; //Register Backup Pointer
    u16 frame; //Frame Pointer
 
    //HC12 Stack Vars
    u8 CCR; //Condition Code Register
    u8 A; //Accumulator A
    u8 B; //Accumulator B
    u16 X; //Index Register X
    u16 Y; //Index Register Y
    u16 PC; //Program Counter (Starts at functions address)
    u16 RS; //Return Service
};
 
void Spawn(void* function, void* callback)
{
    void* newstack = Allocate(STACKSIZE);
    sStack* sp = (sStack*)((u16)newstack + (u16)STACKSIZE - sizeof(sStack));
 
    sp->xy = 0x0000;
    sp->z = 0x0000;
    sp->tmp = 0x0000;
    sp->frame = 0x0000;
    sp->CCR = 0xC0;
    sp->A = 0x00;
    sp->B = 0x00;
    sp->X = 0x0000;
    sp->Y = 0x0000;
    sp->PC = (u16)function;
    sp->RS = (u16)callback;
 
    if( threadcount < THREADMAX )
    {
        threads[threadcount++] = sp;
    }
}
 
//
void __attribute__((interrupt)) Switch_RTI_ISR(void) 
{
    asm volatile("sei"); //Set interrupt mask
 
    //Save off the stack pointer
    asm volatile("LDX #_stackpointer");
    asm volatile("STS 0, X");
    threads[current] = _stackpointer;
 
    //Schedule the next thread
    current += 1;
    current %= threadcount;
 
    //Load the next stack pointer
    _stackpointer = threads[current];
    asm volatile("LDX #_stackpointer");
    asm volatile("LDS 0, X");
 
    CRGFLG |= 0x80; //Real Time Interrupt Flag 
    asm volatile("cli"); //Enable Interrupts
}
 
//More of a bootloader that sets up variables
void Main(void)
{ 
    //Disable Interrupts
    asm volatile("sei");
 
    //Spawn Threads
    threadcount = 0; //Init
    Spawn((void*)Thread1, 0x4000);
    Spawn((void*)Thread2, 0x4000);
 
    //Setup Thread Swap
    *(void(**)())0x3FF0 = Swith_RTI_ISR;
    asm volatile("cli");
 
    while(1)
    {
        asm volatile("swi");
    }
}
 
void Thread1(void)
    while(1)
    { 
        Print("Thread 1");
        Pause(500);
        asm volatile("swi");
    }
}
 
void Thread2(void)
{
    while(1)
    { 
        Print("Thread 2");
        Pause(500);
        asm volatile("swi");
    }
}

Missing FFXI-Garuda?

Shawn — Fri, 16 Apr 2010 22:08:51 +0000

If anyone is here looking for FFXI-Garuda.com post a comment and I’ll bring it back online.

Hex Memory Dump

Shawn — Fri, 16 Apr 2010 17:46:57 +0000

Here is a nice looking hex dump for those interested.

ADDR | B0 B1 B2 B3 B4 B5 B6 B7  B8 B9 BA BB BC BD BE BF | 0123456789ABCDEF
=====|==================================================|=================
0000 | FF D8 FF E0 00 10 4A 46  49 46 00 01 02 01 00 48 | ......JFIF.....H
0010 | 00 48 00 00 FF ED 0A 96  50 68 6F 74 6F 73 68 6F | .H......Photosho
0020 | 70 20 33 2E 30 00 38 42  49 4D 04 04 07 43 61 70 | p 3.0.8BIM...Cap

/******************************************************************************
  Hex Memory Dump
     Usage: Dump a block of memory to the display.
    Output: <0xMLOC> |   | 
******************************************************************************/
void Memory_Dump(void* block, size_t size)
{
  char ASCII[] = "0123456789ABCDEF";
  unsigned int i = 0;
  unsigned int j = 0;
 
  PrintString("\nMemory Dump of ");
  PrintHex((unsigned int)block);
 
  //Trim the request to only high bytes
  block = (char*)((unsigned int)0xFFF0 & (unsigned int)block);
 
  //If you the length was 0 display at least one line
  if(size == 0)
  {
    size = 1;
  }
 
  //For each location starting from the block and going the length  
  PrintString("\nADDR | B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF | 0123456789ABCDEF");
  PrintString("\n=====|==================================================|=================");
  for( ; i < = size ; ++i )
  {
    //Display the memory location in hex
    PrintCharacter('\n');
    PrintHex((unsigned int)block+i, 4);
    PrintString(" | ");
 
    //Display the byte in hex
    j = i;
    for(; j <= i + 0xF ; ++j )
    {
      //Take the location adds the offset remove the lower byte, shift it down and convert to ASCII
      PrintCharacter(ASCII[((*(unsigned char*)((unsigned int)block+(unsigned int)j))&0xF0)>>4]);
      //Take the location adds the offset remove the upper byte and convert to ASCII
      PrintCharacter(ASCII[(*(unsigned char*)((unsigned int)block+(unsigned int)j))&0x0F]);
 
      PrintCharacter(' ');
 
      // After 8 bytes place a space for readability
      if( j == i + 0x7 )
      {  
        PrintCharacter(' ');
      }
    }    
 
    //Display the char values of the location
    PrintString("| ");
    j = i;
    for(; j < = i + 0xF ; ++j )
    {
      //If the current is a backspace, return, or tab display a space
      if(  *(unsigned char*)((unsigned int)block+(unsigned int)j) >= 0x8 
        && *(unsigned char*)((unsigned int)block+(unsigned int)j) < = 0xD )
      {
        PrintCharacter(' ');
      }
      else
      {
        PrintCharacter(*(unsigned char*)((unsigned int)block+(unsigned int)j));
      }
    }
 
    //Increment the current location
    i += 0xF;
  }
  PrintCharacter('\n');
}

HC12 Read String or Char

Shawn — Wed, 07 Apr 2010 23:40:02 +0000

Use this to read a string on the HC12. What this function does is check to see if there is an available character in the HC12′s Serial Communication Interface Port 0 Data Register. If you need to use this function with 9bit values the function needs to be adjusted to incorporate SC0DRH. Similarity if you would like to use Port 1 change SC0 to SC1.

UPDATE: I added the single char version because thats more basic.

/*******************************************
    Get Character
         Usage:    Get a character from the serial port
          Exit:    Returns the char from the input
*******************************************/
char Read(void)
{
    //Wait for the Receive Data Register Full Flag of SC0SR1
    while((SC0SR1 & 0x20) == 0)
    {
        //Yield or Wait        
    }
 
    //Read the Data Register
    char input = SC0DRL;
 
    //Echo
    Print(input);
 
    //Return value
    return input;
}
 
 
/*******************************************
  Get String
    Usage: Gets a string from the serial
    Enter: Buffer address and max buffer size.
     Exit: True on Overflow, False on Return Key
*******************************************/
bool Read(char* buffer, unsigned int size)
{
    char input = '\0';
    unsigned int i = 0;
    while ( i < size )
    {        
        //Wait for the Receive Data Register Full Flag of SC0SR1
        while((SC0SR1 & 0x20) == 0)
        {
            //Yield or Wait        
        }
 
        //Read the Data Register
        input = SC0DRL;
 
        if ( input == 0x08 && i > 0 )
        {
            //Delete
            buffer[i--] = '\0';
        }
        else if ( input == 0x0D )
        {
            //Enter
            buffer[i] = '\0';
            return false;
        }
        else
        {
            buffer[i++] = input;
        }
        //Echo
        Print(input);
    }
    return true;
}

ExtUSB AV Cable

Shawn — Sun, 17 Jan 2010 10:56:15 +0000

A – USB Ground
B – +5V allows phone to suck 1000mA to charge faster
C – +USB Data Line
D – -USB Data Line
E – +5V @ 1000mA (If you only have 500mA ground B)
1 – Video Out
2 – Audio Right
3 – Ground (Video Sense)
4 – No connection otherwise you loose video
5 – Audio Ground
6 – Audio Left
Shield – Ground / Cable Shield

MON12 Jump Table

Shawn — Wed, 30 Dec 2009 20:54:41 +0000

This is the jump table from the CML12S-DP256 v2.7F. Use this if you want to access MON12 functionality inside of your programs.

Command	Address
AUTO	CB EB
BR	C8 EF
BULK	C9 AD
ERASE	C9 AD
CALL	CD 1E
BF	CA BB
FILL	CA BB
EEMOD	CA 5C
GO	CD 82
HELP	CD 17
?	CD 17
LOAD	CF 19
MD	C9 B6
MM	CB 2E
MB	CB 2E
MW	CB 87
MOVE	CC 6F
COPY	CC 6F
NOAUTO	CC 26
OFFSET	D0 9B
P	CD 70
RD	C1 70
RM	D0 DF
STOPAT	CE 50
TRACE	CE 16
VERIFY	CF 12

HC12 Build you’r own Character

Shawn — Sun, 20 Dec 2009 01:53:23 +0000

Using code from the manufacturer Axiom and several data sheets to figure out what they are talking about I finally found how to send your own character to the CGRAM (Character Generator RAM).

This applies to the CML-9S12DP256 from Axiom with the add on LCD module (Fema CM204P-SGR1) running on a SPLC780D controller.

Really the application is quite simple all you need to do is send a command for the address of a CGRAM location.

Then send a string of characters to the string that describe the character that you want to generate.

Character Hex Array
Each character has 5bits across starting from the right and 8 rows down.
or from Left to Right, Top to Bottom

0bXXXXX
0bXXXXX
0bXXXXX
0bXXXXX
0bXXXXX
0bXXXXX
0bXXXXX
0bXXXXX

Additional Characters

char alien[] = {0x16,0x0F,0x05,0x07,0x07,0x05,0x0F,0x16,'\0'};
SendCommand(0x40 /* +8 per Character */);
SendString(alien);
 
SendCommand(0x80)
SendCharacter(0x00 /* +1 per Character */);

Verilog RS Latch

Shawn — Sat, 12 Dec 2009 18:50:01 +0000

Quick example accomplishing an RS Latch with Verilog Data Flow.

module rs_latch( q, qn, s, r );
 
        input s, r;
        output q, qn;
 
        assign qn = ~( s & q );
        assign q  = ~( r & qn );
 
endmodule

Value to Hex String

Shawn — Mon, 03 Aug 2009 01:50:12 +0000

Ever needed to print out a hex string but needed a converter. Probably not because its build into most string classes. Though if you can’t use a string class then you might just need something like this.

void ToHex( char character, char* buffer )
{
        char ASCII[] = "0123456789ABCDEF";
        buffer[0] = ASCII[(character & 0xF0)>>4];
        buffer[1] = ASCII[ character & 0x0F];
        buffer[2] = '\0';
}