Nabble - MicroControllers - hc12

RE: HCS12 SCI Flash Programming Help

2009-11-06T01:41:46Z

Hi,

Below, the vector interrupt table I use for DP256...
Note the address I put it is 0xff80, not 0xef80...
I use ICC12 too, and it run OK for interrupt.
When I used DP256, I often write some functions in RAM, but I never change
the vector table address, just switched RAM to 0xd000 with NoIce debugger.

Hope this helps.

Best regards.
Joel

//*********************************************************
// change the address if your vector starts elsewhere
// Processeur 9S12DP256 : vecteurs interruptions en 0xff80
#pragma abs_address:0xFF80

void (*interrupt_vectors[])(void) =
{
// to cast a constant, say 0xb600, use (void (*)())0xb600
// Tous les vecteurs interrupt occupent 2 octets consécutifs. Ainsi
// l'adresse de la routine d'interruption RTI est définie aux
// adresses $FFF0-$FFF1
ISR_NonDeveloppe, // Reserved $FF80
ISR_NonDeveloppe, // Reserved $FF82
ISR_NonDeveloppe, // Reserved $FF84
ISR_NonDeveloppe, // Reserved $FF86
ISR_NonDeveloppe, // Reserved $FF88
ISR_NonDeveloppe, // Reserved $FF8A
ISR_NonDeveloppe, // $FF8C PWM Emergency Shutdown
ISR_NonDeveloppe, // $FF8E Port P Interrupt
ISR_NonDeveloppe, // $FF90 MSCAN 4 Transmit
ISR_NonDeveloppe, // $FF92 MSCAN 4 Receive
ISR_NonDeveloppe, // $FF94 MSCAN 4 Error
ISR_NonDeveloppe, // $FF96 MSCAN 4 Wake-up
ISR_NonDeveloppe, // $FF98 MSCAN 3 Transmit
ISR_NonDeveloppe, // $FF9A MSCAN 3 Receive
ISR_NonDeveloppe, // $FF9C MSCAN 3 Error
ISR_NonDeveloppe, // $FF9E MSCAN 3 Wake-up
ISR_NonDeveloppe, // $FFA0 MSCAN 2 Transmit
ISR_NonDeveloppe, // $FFA2 MSCAN 2 Receive
ISR_NonDeveloppe, // $FFA4 MSCAN 2 Error
ISR_NonDeveloppe, // $FFA6 MSCAN 2 Wake-up
ISR_NonDeveloppe, // $FFA8 MSCAN 1 Transmit
ISR_NonDeveloppe, // $FFAA MSCAN 1 Receive
ISR_NonDeveloppe, // $FFAC MSCAN 1 Error
ISR_NonDeveloppe, // $FFAE MSCAN 1 Wake-up
ISR_NonDeveloppe, // $FFB0 MSCAN 0 Transmit
ISR_NonDeveloppe, // $FFB2 MSCAN 0 Receive
ISR_NonDeveloppe, // $FFB4 MSCAN 0 Error
ISR_NonDeveloppe, // $FFB6 MSCAN 0 Wake-up
ISR_NonDeveloppe, // $FFB8 Flash
ISR_NonDeveloppe, // $FFBA EEPROM
ISR_NonDeveloppe, // $FFBC SPI2
ISR_NonDeveloppe, // $FFBE SPI1
ISR_NonDeveloppe, // $FFC0 IIC Bus
ISR_NonDeveloppe, // $FFC2 BDLC
ISR_NonDeveloppe, // $FFC4 CRG Self Clock Mode
ISR_NonDeveloppe, // $FFC6 CRG PLL Lock

ISR_NonDeveloppe, // $FFC8 Pulse Acc B Overflow
ISR_TimerModulus, // $FFCA Modulus Down Counter
Underflow

ISR_NonDeveloppe, // $FFCC Port H Interrupt
ISR_NonDeveloppe, // $FFCE Port J Interrupt
ISR_NonDeveloppe, // $FFD0 ATD1
ISR_NonDeveloppe, // $FFD2 ATD0
ISR_Sci1, // $FFD4 SCI1
ISR_Sci0, // $FFD6 SCI0

ISR_NonDeveloppe, // $FFD8 SPI0
ISR_NonDeveloppe, // $FFDA Pulse Acc A Input Edge
ISR_NonDeveloppe, // $FFDC Pulse Acc A Overflow

ISR_NonDeveloppe, // $FFDE Timer Overflow
ISR_Timer7, // $FFE0 Timer Channel 7
ISR_Timer6, // $FFE2 Timer Channel 6
ISR_Timer5, // $FFE4 Timer Channel 5
ISR_Timer4, // $FFE6 Timer Channel 4
ISR_Timer3, // $FFE8 Timer Channel 3
ISR_Timer2, // $FFEA Timer Channel 2
ISR_Timer1, // $FFEC Timer Channel 1
ISR_Timer0, // $FFEE Timer Channel 0
ISR_Rti, // $FFF0 Real Time
Interrupt
ISR_NonDeveloppe, // $FFF2 IRQ
ISR_NonDeveloppe, // $FFF4 XIRQ
ISR_NonDeveloppe, // $FFF6 SWI
ISR_NonDeveloppe, // $FFF8 Unimplement Instr. Trap
ISR_NonDeveloppe, // $FFFA COP failure reset
ISR_NonDeveloppe, // $FFFC Clock monitor fail reset
_start, // $FFFE Reset
};

-----Message d'origine-----
De : 68HC12@... [mailto:68HC12@...] De la part de
jssimbe
Envoyé : vendredi 6 novembre 2009 02:29
À : 68HC12@...
Objet : [68HC12] HCS12 SCI Flash Programming Help

I'm using and HCS12 with icc12 compiler. I'm using SCI1 to communicate to a
touch screen LCD. This program loads the LCD GUI. When I try loading the
program into flash, it doesn't work. When I'm not using flash, the program
works fine and GUI is loaded on the screen. When I flash the board, I
include the vectors_dp256 file and set the abs_address to 0xef80. Any help
would be greatly appreciated. Thanks.

HCS12 SCI Flash Programming Help

2009-11-05T17:28:40Z

I'm using and HCS12 with icc12 compiler. I'm using SCI1 to communicate to a touch screen LCD. This program loads the LCD GUI. When I try loading the program into flash, it doesn't work. When I'm not using flash, the program works fine and GUI is loaded on the screen. When I flash the board, I include the vectors_dp256 file and set the abs_address to 0xef80. Any help would be greatly appreciated. Thanks.

#include <mc9s12dp256.h>
#include <stdio.h>

#ifndef TDRE
#define TDRE 0x80
#endif
#ifndef RDRF
#define RDRF 0x20
#endif
#ifndef OR
#define OR 0x08
#endif

void main (){

sc_init();
loadscreen();
}

void sc_init(){

SCI1BDL = 0x4E; // 19200 Baud Rate
SCI1BDH = 0x00;
SCI1CR1 = 0x00;
SCI1CR2 = 0x2C;
SCI1SR1 = 0xA8;
}

void outchar(data1){ // Function to send commands

while(!(SCI1SR1 & TDRE)){};
SCI1DRL = data1;
}

void loadscreen (){ //loads GUI

outchar(0x10);
outchar(0x02);
outchar(0x3E);
outchar(0x00);
outchar(0x50);

}

Re: Re: Dragon Board 12 Serial Communication C code Help

2009-11-01T08:51:35Z

> Tom Almy writes on 10:57 AM 10/31/2009
>This struck me as particularly strange since I've been mixing pointers
>and arrays since 1980 (when I first used C) and have never caused any
>kind of damage! In fact you really need to mix the two to get maximum
>leverage from the language.

Technically "Hello World" mixes an array used with printf which takes
a pointer.

>1. You have to declare arrays to allocate memory since I think most of
>us can agree that malloc has no
>business in embedded programming of small microcontrollers.

Agree.

>2. It is generally more efficient to walk through an array using
>pointers rather than indexing.

Yes. I might not be wrong to say it's always more efficient.

>3. Array and pointer parameters are basically identical since the
>array is passed by reference and the pointer is passed by value. They
>can be used interchangeably.

Yes. The one place that can burn you because of this is sizeof used
on an argument to a function with an array type:

void function(char buffer[32])
{
int i = sizeof buffer; // This is NOT 32 but sizeof (char *)
}

However, this isn't going to cause "damage" because this error would
fall out quickly in testing.

>4. The comment "the only time a problem will occur is when a pointer
>and array are used in different modules (one public and the other
>externed)" isn't an issue if using header files with extern
>declarations for all global variables is practiced. This will catch
>the definition being different than the declaration.

I agree. It shouldn't be an issue, but since it can be done, it is a
problem when it is. I've seen a lot of programmer's code over the
years and there's a lot of "quick extern" declarations that are
included in the C file and not a header file. It's not a good
practice but it's still pretty common.

Bill

Re: Counting 1's in 16 bit word

2009-10-31T13:56:01Z

Hmm, for some reason I'm not getting about half of the posts here in my inbox, including this one I discovered by going to the yahoo site.

--- In 68HC12@..., Andrei Chichak <groups@...> wrote:
>
> Ah, clever, I like the != 0 trick. You must be from Oregon.
>
> Did you notice the bug in the Spanish code?
>
> A

His program:
ldx #00
ldy #08
ciclo lsrd
bcc cero
inx
cero dey
bne ciclo

The count, 8, should of course be 16. However it does run faster that way. :-)

Re: Re: Dragon Board 12 Serial Communication C code Help

2009-10-31T08:57:45Z

On Oct 31, 2009, at 7:54 AM, Bill_CT wrote:

> --- In 68HC12@..., Andrei Chichak <groups@...> wrote:
>>
>>
>> On 2009-October-28, at 11:06 PM, Bill Auerbach wrote:
>>>>> Andrei Chichak writes on 02:20 AM 10/28/2009
>>>>> In the definition of encode - either use pointers or arrays, don't
>>>>> intermix. Use void encode( char out[]) instead. What you have
>>>>> would
>>>>> probably cause all kinds of damage.
>
> You say "probably cause all kinds of damage". Before anyone here
> thinks that's a really bad thing and it means they are doing
> something wrong, perhaps you should back this statement with
> something concrete. Show us a case that causes "all kinds of
> damage". If you can't, please don't put your gloom and doom
> programming rules out on a public forum where beginners may be
> trying to learn correct programming practices.

This struck me as particularly strange since I've been mixing pointers
and arrays since 1980 (when I first used C) and have never caused any
kind of damage! In fact you really need to mix the two to get maximum
leverage from the language.

1. You have to declare arrays to allocate memory since I think most of
us can agree that malloc has no
business in embedded programming of small microcontrollers.
2. It is generally more efficient to walk through an array using
pointers rather than indexing.
3. Array and pointer parameters are basically identical since the
array is passed by reference and the pointer is passed by value. They
can be used interchangeably.
4. The comment "the only time a problem will occur is when a pointer
and array are used in different modules (one public and the other
externed)" isn't an issue if using header files with extern
declarations for all global variables is practiced. This will catch
the definition being different than the declaration.

Tom Almy
Tualatin, Oregon USA
Internet: tom@...
Website: almy.us

Re: Dragon Board 12 Serial Communication C code Help

2009-10-31T07:54:36Z

--- In 68HC12@..., Andrei Chichak <groups@...> wrote:
>
>
> On 2009-October-28, at 11:06 PM, Bill Auerbach wrote:
> >> > Andrei Chichak writes on 02:20 AM 10/28/2009
> >> >In the definition of encode - either use pointers or arrays, don't
> >> >intermix. Use void encode( char out[]) instead. What you have would
> >> >probably cause all kinds of damage.

You say "probably cause all kinds of damage". Before anyone here thinks that's a really bad thing and it means they are doing something wrong, perhaps you should back this statement with something concrete. Show us a case that causes "all kinds of damage". If you can't, please don't put your gloom and doom programming rules out on a public forum where beginners may be trying to learn correct programming practices.

> >> There is no harm to use pointers and arrays and no damage results
> >> from doing so. They are equivalent - the only time a problem will
> >> occur is when a pointer and array are used in different modules (one
> >> public and the other externed).
> >>
> >> Bill
> >
>> Remember, the program will only be read twice after you write it,
>> once by the compiler (and it doesn't care what you do), and the poor
>> sod that has to maintain it.

It's a much larger concern and problem if the maintainer doesn't know the fundamental properties and semantics of the language.

Re: Re: Dragon Board 12 Serial Communication C code Help

2009-10-29T19:23:32Z

On 2009-October-28, at 11:06 PM, Bill Auerbach wrote:

>> > Andrei Chichak writes on 02:20 AM 10/28/2009
>> >In the definition of encode - either use pointers or arrays, don't
>> >intermix. Use void encode( char out[]) instead. What you have would
>> >probably cause all kinds of damage.
>>
>> There is no harm to use pointers and arrays and no damage results
>> from doing so. They are equivalent - the only time a problem will
>> occur is when a pointer and array are used in different modules (one
>> public and the other externed).
>>
>> Bill
>
> Remember, the program will only be read twice after you write it,
> once by the compiler (and it doesn't care what you do), and the poor
> sod that has to maintain it.

[Non-text portions of this message have been removed]

Re: Re: Dragon Board 12 Serial Communication C code Help

2009-10-28T22:06:40Z

> Andrei Chichak writes on 02:20 AM 10/28/2009
>In the definition of encode - either use pointers or arrays, don't
>intermix. Use void encode( char out[]) instead. What you have would
>probably cause all kinds of damage.

There is no harm to use pointers and arrays and no damage results
from doing so. They are equivalent - the only time a problem will
occur is when a pointer and array are used in different modules (one
public and the other externed).

Bill

Re: Dragon Board 12 Serial Communication C code Help

2009-10-28T07:10:20Z

As stated by others it is folly to use malloc/free in simple embedded systems. The best solution is to implement asynchronous static ring buffers for rx/tx with timeout error reporting (see http://www.seattlerobotics.org/encoder/200009/sciint11.c for an asynch example without timeouts). In the case where the output is fixed I wouldn't even bother with a buffer.

#ifndef bit
#define bit(x) (1 << (x))
#endif

void put_char(char c) {
while((SCI0SR1 & bit(7)) == 0);
SCI0DRL = c;
}

void put_s(char* s) {
// Assumes char pointer is a zero terminated array (string)
while(*s)
put_char(*s++);
}

const char *message = "Hello World";
const char *test_str = "tes0";

void main(void) {
sci_init(); // usual sci setup for baudrate, etc.
put_s(message);
while(1) {
put_s(test_str);
}
}

If the output is variable, the addition of the something like the following can be useful. The obvious danger of using this function is the ease of overflowing the buffer. Beware also that compiler implementations of this are typically not re-entrant so don't call it from inside an ISR or thread.

#include <stdio.h>

void myPrintf(char *format, ...) {
char buffer[BUF_SIZE];
va_list stArgList;

va_start(stArgList, format);
vsprintf(buffer, format, stArgList);
va_end(stArgList);
put_s(buffer);
}

-rob

>
> #include "sci.h"
>
> int main(void);
> void encode(char *out);
>
> int main(void)
> {
> char* head = "Hello World"; // declare first print statement
> char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char
>
> SCI_Init(9600,0); //Startup serial port 0(under LCD) at 9600 BAUD
> SCI_OutStatus(1); // Is it clear to send (buffer empty)
> SCI_OutString(head,0); // print "Hello World" to serial port (WORKS !!)
>
> while(1)
> {
> if(SCI_OutStatus(0))// Is it clear to send (buffer empty)
> {
> encode(outData);//,out.throt,out.heading); // build output
> SCI_OutString(outData,0); // print out put to serial port
> }
> }
> return 0;
> }
>
> void encode(char *out) // take in pointer and fill with chars
> {
> out[0] = 't';
> out[1] = 'e';
> out[2] = 's';
> out[3] = 0;
> }

Re: Re: Dragon Board 12 Serial Communication C code Help

2009-10-27T23:20:54Z

Okay, let's take a look at the output and the evidence and make some
wild ass guesses.

You can assume that SCI_OutString is okay since 1) the "Hello World"
comes out okay and 2) it is what is known as gospel code - written by
a god like being and written in a book.

Next, in your message you say "then print tes repeatedly". Well, it
isn't printing tes (plural of T??) it is printing double quotes.
Nowhere in your code do you have a buffer that should be holding a ".
So we can assume that either encode() isn't working properly (but by
inspection it is pretty simple), or when you call SCI_OutString, you
are using a garbage pointer and it is printing random stuff.

In the definition of encode - either use pointers or arrays, don't
intermix. Use void encode( char out[]) instead. What you have would
probably cause all kinds of damage.

Now, the character " has the hex value 0x22, so what you are printing
looks like 22222222222222222... in hex, with no 0x00 to terminate the
string, so it's going to print a whole bunch of it. It is quite hard
to determine what you are printing since you are in an infinite loop.
The data could be 0x2200, which would print out a single ", but since
it is in an infinite loop you would get """"""""""""""""""""""""""".

Running your code through lint showed that if malloc failed you would
have outData getting set to NULL. This would be a pointer to location
0. Encode would try and alter locations 0, 1, 2 and 3. Then you print
the string at location 0. The zero page of an HC12 is internal
registers. So you would set PORTA to 0x74, PORTB to 0x65, DDRA to
0x73, DDRB to 0x00, then print them out as a string.

If you are running some sort of a bootloader/monitor/debugger it is
possible to move the registers and possibly put FLASH down in the zero
page, or uninitialized RAM. It's really hard to predict what is going
to get printed.

Either way, you are printing a location that IS a long string of hex
0x22. We can see that from the output.

First, alter your code to have:

No infinite loop until you get a bit of control.

Fix encode as above.

char outData[5];
Then, use SCI_OutChar(outData[0]); and make sure that you are getting
a 't'. This would make sure that encode is working properly.

Fix the malloc call so that the syntax is expressing what you actually
want and check the return code. Use SCI_OutString to print an error
message if malloc returns NULL.

If you really want to use malloc, use SCI_OutUHex((int)outData) and
take a look at where outData is pointing. I'm pretty sure that you
will find a whole bunch of 0x22 at that location.

From the 10 commandments: Thou shalt run lint frequently and study
its pronouncements with care, for verily its perception and judgement
oft exceed thine.
From the MISRA guidelines: Don't use pointers.

Andrei

---------------------
Andrei Chichak

Systems Developer
CBF Systems Inc.
4-038 NINT Innovation Centre
11421 Saskatchewan Drive
Edmonton, Alberta
Canada
T6G 2M9

Phone: 780-628-2072
Skype: andrei.chichak

[Non-text portions of this message have been removed]

Re: Dragon Board 12 Serial Communication C code Help

2009-10-27T19:39:33Z

Zach,

The code for the serial port looks OK, although for production code it would benefit from a code review.

SCI_OutStatus(1); // Is it clear to send (buffer empty)

This returns the status, so as is in main does nothing. Since SCI_OutString checks the SCI status for each character, testing the status before the call isn't needed anyway.

The following might work (I don't have a running system or I would run it).

Bill
-------------
int main(void)
{
char* head = "Hello World"; // declare first print statement
char outData[5]; // make room for 5 char

SCI_Init(9600,0); //Startup serial port 0(under LCD) at 9600 BAUD
SCI_OutStatus(1); // Is it clear to send (buffer empty)
SCI_OutString(head,0); // print "Hello World" to serial port (WORKS !!)

while(1)
{
if(SCI_OutStatus(0))// Is it clear to send (buffer empty)
{
encode(outData);//,out.throt,out.heading); // build output
SCI_OutString(outData,0); // print out put to serial port
}
}
return 0;
}

void encode(char *out) // take in pointer and fill with chars
{
out[0] = 't';
out[1] = 'e';
out[2] = 's';
out[3] = 0;
}

--- In 68HC12@..., zach.r.long@... wrote:
>
> Thanks everyone, your comments on not using malloc make sense for this system, however I am still left with the issue of incorrect output, and the thought of how that pointer works if it is never assigned to memory. Not to get side tracked, if anyone has any working examples of printing variable data to the serial port I would be very interested in seeing it, since this is the goal of this series of post.
>
>
> Thank You,
>
> Zach
>

Re: Dragon Board 12 Serial Communication C code Help

2009-10-27T18:39:06Z

Thanks everyone, your comments on not using malloc make sense for this system, however I am still left with the issue of incorrect output, and the thought of how that pointer works if it is never assigned to memory. Not to get side tracked, if anyone has any working examples of printing variable data to the serial port I would be very interested in seeing it, since this is the goal of this series of post.

Thank You,

Zach

Re: Dragon Board 12 Serial Communication C code Help

2009-10-26T23:25:59Z

I agree that malloc failed and it is passing back 0 to indicate that
it failed, and you are using that as an address of your string.

Please have some empathy for the programmer that has to figure out
your bugs. Check your return codes, don't use malloc, calloc, realloc,
global variables, GOTOs, or "magic numbers".

A

On 2009-October-26, at 11:01 PM, Bill Auerbach wrote:
>
> Furthermore, for this series of processors or smaller and generally
> in embedded systems, avoid malloc and free.
>

[Non-text portions of this message have been removed]

Re: Dragon Board 12 Serial Communication C code Help

2009-10-26T22:01:58Z

> Edward Karpicz writes on 12:51 AM 10/27/2009
>Probably malloc didn't succeed
>
>char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char
>
>BTW comment is wrong, should be make room for 5 pointers to char

Both points are good.

Furthermore, for this series of processors or smaller and generally
in embedded systems, avoid malloc and free. These smaller processors
are just not that good at supporting dynamic memory. For a Freescale
PowerPC with 100's of MB of memory - fine, dynamic memory using
malloc and free can be used. But you must always consider that
memory can fragment and requests for memory can fail over long runs
of the program (malloc returns NULL on error).

I'm not looking for a big debate on malloc/free in an embedded
system. On a system with less than 32MB of RAM, I just don't do it - ever.

Bill

>Edward
>
>----- Original Message -----
>From: <<mailto:zach.r.long%40gmail.com>zach.r.long@...>
>To: <<mailto:68hc12%40yahoogroups.com>68hc12@...>
>Sent: Monday, October 26, 2009 10:26 PM
>Subject: [68HC12] Dragon Board 12 Serial Communication C code Help
>
> > Hello all, I am hoping someone has some incite as to what I am doing wrong
> > here, I figure it is a small problem but I am out of ideas. This is just a
> > test to figure out how to pass char * through methods. The code should
> > print Hello World to the serial port which it does, then print tes
> > repeatedly, which it does not, rather the output is as follows:
> >
> > Hello World"""""""""""""""""""""""""""""""""""""""""""""""""""""""
> > """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
> >
> > Here is the code, also below is the sci.c and sci.h that do the actually
> > serial communication.
> >
> > Thank You in advanced !
> >
> > Zach Long
> >
> > MAIN:
> >
> > #include "sci.h"
> >
> > int main(void);
> > void encode(char *out);
> >
> > int main(void)
> > {
> > char* head = "Hello World"; // declare first print statement
> > char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char
> >
> > SCI_Init(9600,0); //Startup serial port 0(under LCD) at 9600 BAUD
> > SCI_OutStatus(1); // Is it clear to send (buffer empty)
> > SCI_OutString(head,0); // print "Hello World" to serial port (WORKS !!)
> >
> > while(1)
> > {
> > if(SCI_OutStatus(0))// Is it clear to send (buffer empty)
> > {
> > encode(outData);//,out.throt,out.heading); // build output
> > SCI_OutString(outData,0); // print out put to serial port
> > }
> > }
> > return 0;
> > }
> >
> > void encode(char *out) // take in pointer and fill with chars
> > {
> > out[0] = 't';
> > out[1] = 'e';
> > out[2] = 's';
> > out[3] = 0;
> > }
> >
> > SCI include:
> >
> > // filename ******************* SCI.H **************************
> > // Jonathan W. Valvano 1/29/04
> >
> > // This example accompanies the books
> > // "Embedded Microcomputer Systems: Real Time Interfacing",
> > // Brooks-Cole, copyright (c) 2000,
> > // "Introduction to Embedded Microcomputer Systems:
> > // Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002
> >
> > // Copyright 2004 by Jonathan W. Valvano,
> <mailto:valvano%40mail.utexas.edu>valvano@...
> > // You may use, edit, run or distribute this file
> > // as long as the above copyright notice remains
> > // Modified by EE345L students Charlie Gough && Matt Hawk
> > // Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
> > // Modified by Zachary Long Oct 16, 2009 (setup for Dragon Board 12 9600
> > BAUD, use of both serial ports enabled)
> >
> > //How To
> > /*
> > Each method has an unsigned int port parameter, this specifices the
> > serial port
> > the method will act on. Dragon Board 12: Serial port under LCD (top) =
> > 0, Serial port near power plug (bottom) = 1
> > */
> >
> > // standard ASCII symbols
> > #define CR 0x0D
> > #define LF 0x0A
> > #define BS 0x08
> > #define ESC 0x1B
> > #define SP 0x20
> > #define DEL 0x7F
> >
> > //-------------------------SCI_Init------------------------
> > //-------------------------SCI_Init------------------------
> > // Initialize Serial port SCI
> > // Input: baudRate is tha baud rate in bits/sec
> > // Output: none
> > // SCIBDL = 24000000/(16 x BR)
> > // baudRate = 2400 bits/sec SCIBDL=625
> > // baudRate = 4800 bits/sec SCIBDL=313
> > // baudRate = 9600 bits/sec SCIBDL=156
> > // baudRate = 19200 bits/sec SCIBDL=78
> > // assumes a module clock frequency of 4 MHz
> > // sets baudRate to 9600
> > void SCI_Init(unsigned short baudRate,unsigned int port);
> >
> > //-------------------------SCI_InStatus--------------------------
> > // Checks if new input is ready, TRUE if new input is ready
> > // Input: unsigned int port
> > // Output: TRUE if a call to InChar will return right away with data
> > // FALSE if a call to InChar will wait for input
> > char SCI_InStatus(unsigned int port);
> >
> > //-------------------------SCI_InChar------------------------
> > // Wait for new serial port input, busy-waiting synchronization
> > // Input: unsigned int port
> > // Output: ASCII code for key typed
> > char SCI_InChar(unsigned int port);
> >
> > void SCI_InString(char* string,unsigned short max,unsigned int port); //
> > Reads in a String of max length
> >
> > //----------------------SCI_InUDec-------------------------------
> > // InUDec accepts ASCII input in unsigned decimal format
> > // and converts to a 16 bit unsigned number
> > // valid range is 0 to 65535
> > // Input: unsigned int port
> > // Output: 16-bit unsigned number
> > // If you enter a number above 65535, it will truncate without an error
> > // Backspace will remove last digit typed
> > unsigned short SCI_InUDec(unsigned int port);
> >
> > //---------------------SCI_InUHex----------------------------------------
> > // Accepts ASCII input in unsigned hexadecimal (base 16) format
> > // Input: unsigned int port
> > // Output: 16-bit unsigned number
> > // No '$' or '0x' need be entered, just the 1 to 4 hex digits
> > // It will convert lower case a-f to uppercase A-F
> > // and converts to a 16 bit unsigned number
> > // value range is 0 to FFFF
> > // If you enter a number above FFFF, it will truncate without an error
> > // Backspace will remove last digit typed
> > unsigned short SCI_InUHex(unsigned int port);
> >
> > //-----------------------SCI_OutStatus----------------------------
> > // Checks if output data buffer is empty, TRUE if empty
> > // Input: unsigned int port
> > // Output: TRUE if a call to OutChar will output and return right away
> > // FALSE if a call to OutChar will wait for output to be ready
> > char SCI_OutStatus(unsigned int port);
> >
> > //-------------------------SCI_OutChar------------------------
> > // Wait for buffer to be empty, output 8-bit to serial port
> > // busy-waiting synchronization
> > // Input: 8-bit data to be transferred, unsigned int port
> > // Output: none
> > void SCI_OutChar(char data,unsigned int port);
> >
> > //-----------------------SCI_OutUDec-----------------------
> > // Output a 16-bit number in unsigned decimal format
> > // Input: 16-bit number to be transferred, unsigned int port
> > // Output: none
> > // Variable format 1-5 digits with no space before or after
> > void SCI_OutUDec(unsigned short,unsigned int port);
> >
> > //-------------------------SCI_OutString------------------------
> > // Output String (NULL termination), busy-waiting synchronization
> > // Input: pointer to a NULL-terminated string to be transferred, unsigned
> > int port
> > // Output: none
> > void SCI_OutString(char *pt,unsigned int port);
> >
> > //--------------------------SCI_OutUHex----------------------------
> > // Output a 16 bit number in unsigned hexadecimal format
> > // Input: 16-bit number to be transferred, unsigned int port
> > // Output: none
> > // Variable format 1 to 4 digits with no space before or after
> > void SCI_OutUHex(unsigned short,unsigned int port);
> >
> >
> >
> > // filename *************** SCI.C ******************************
> > // Simple I/O routines to 9S12C32 serial port
> > // Jonathan W. Valvano 1/29/04
> >
> > // This example accompanies the books
> > // "Embedded Microcomputer Systems: Real Time Interfacing",
> > // Brooks-Cole, copyright (c) 2000,
> > // "Introduction to Embedded Microcomputer Systems:
> > // Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002
> >
> > // Copyright 2004 by Jonathan W. Valvano,
> <mailto:valvano%40mail.utexas.edu>valvano@...
> > // You may use, edit, run or distribute this file
> > // as long as the above copyright notice remains
> > // Modified by EE345L students Charlie Gough && Matt Hawk
> > // Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
> > // Modified by Steven Lamb April 28, 2004 (minor changes for g++)
> > // Modified by Zachary Long Oct 16, 2009 (serial init (9600)updated, use
> > of both serial ports enabled)
> >
> >
> > //How To
> > /*
> >
> > */
> >
> > #include "hcs12.h" // io register map
> > #include "SCI.h"
> > #define RDRF 0x20 // Receive Data Register Full Bit
> > #define TDRE 0x80 // Transmit Data Register Empty Bit
> >
> >
> > //-------------------------SCI_Init------------------------
> > // Initialize Serial port SCI
> > // Input: baudRate is tha baud rate in bits/sec
> > // Output: none
> > // SCIBDL = 24000000/(16 x BR)
> > // baudRate = 2400 bits/sec SCIBDL=625
> > // baudRate = 4800 bits/sec SCIBDL=313
> > // baudRate = 9600 bits/sec SCIBDL=156
> > // baudRate = 19200 bits/sec SCIBDL=78
> > // assumes a module clock frequency of 4 MHz
> > // sets baudRate to 9600
> > void SCI_Init(unsigned short baudRate, unsigned int port)
> > {
> > switch(port)
> > {
> > case 0:
> > {
> > SCI0BDH = 0;
> > switch(baudRate)
> > {
> > case 2400: SCI0BDL=625; break;
> > case 4800: SCI0BDL=313; break;
> > case 9600: SCI0BDL=156; break;
> > case 19200: SCI0BDL=78; break;
> > default: SCI0BDL = 156 ; // 9600
> > }
> > break;
> >
> > SCI0CR1 = 0;
> > /* bit value meaning
> > 7 0 LOOPS, no looping, normal
> > 6 0 WOMS, normal high/low outputs
> > 5 0 RSRC, not appliable with LOOPS=0
> > 4 0 M, 1 start, 8 data, 1 stop
> > 3 0 WAKE, wake by idle (not applicable)
> > 2 0 ILT, short idle time (not applicable)
> > 1 0 PE, no parity
> > 0 0 PT, parity type (not applicable with PE=0)
> > */
> >
> > SCI0CR2 = 0x0C;
> > /* bit value meaning
> > 7 0 TIE, no transmit interrupts on TDRE
> > 6 0 TCIE, no transmit interrupts on TC
> > 5 0 RIE, no receive interrupts on RDRF
> > 4 0 ILIE, no interrupts on idle
> > 3 1 TE, enable transmitter
> > 2 1 RE, enable receiver
> > 1 0 RWU, no receiver wakeup
> > 0 0 SBK, no send break
> > */
> > break;
> > }
> > case 1:
> > {
> > SCI1BDH = 0;
> > switch(baudRate)
> > {
> > case 2400: SCI1BDL=625; break;
> > case 4800: SCI1BDL=313; break;
> > case 9600: SCI1BDL=156; break;
> > case 19200: SCI1BDL=78; break;
> > default: SCI1BDL = 156 ; // 9600
> > }
> > break;
> >
> > SCI1CR1 = 0;
> > /* bit value meaning
> > 7 0 LOOPS, no looping, normal
> > 6 0 WOMS, normal high/low outputs
> > 5 0 RSRC, not appliable with LOOPS=0
> > 4 0 M, 1 start, 8 data, 1 stop
> > 3 0 WAKE, wake by idle (not applicable)
> > 2 0 ILT, short idle time (not applicable)
> > 1 0 PE, no parity
> > 0 0 PT, parity type (not applicable with PE=0)
> > */
> >
> > SCI1CR2 = 0x0C;
> > /* bit value meaning
> > 7 0 TIE, no transmit interrupts on TDRE
> > 6 0 TCIE, no transmit interrupts on TC
> > 5 0 RIE, no receive interrupts on RDRF
> > 4 0 ILIE, no interrupts on idle
> > 3 1 TE, enable transmitter
> > 2 1 RE, enable receiver
> > 1 0 RWU, no receiver wakeup
> > 0 0 SBK, no send break
> > */
> > break;
> > }
> > }
> > }
> >
> >
> > //-------------------------SCI_InChar------------------------
> > // Wait for new serial port input, busy-waiting synchronization
> > // Input: int port
> > // Output: ASCII code for key typed
> > char SCI_InChar(unsigned int port)
> > {
> > switch(port)
> > {
> > case 0:
> > while((SCI0SR1 & RDRF) == 0){};
> > return(SCI0DRL);
> > break;
> > case 1:
> > while((SCI1SR1 & RDRF) == 0){};
> > return(SCI1DRL);
> > break;
> > }
> > }
> >
> > //-------------------------SCI_OutChar------------------------
> > // Wait for buffer to be empty, output 8-bit to serial port
> > // busy-waiting synchronization
> > // Input: 8-bit data to be transferred
> > // Output: none
> > void SCI_OutChar(char data,unsigned int port)
> > {
> > switch(port)
> > {
> > case 0:
> > while((SCI0SR1 & TDRE) == 0){};
> > SCI0DRL = data;
> > break;
> > case 1:
> > while((SCI1SR1 & TDRE) == 0){};
> > SCI1DRL = data;
> > break;
> > }
> > }
> >
> > //-------------------------SCI_InStatus--------------------------
> > // Checks if new input is ready, TRUE if new input is ready
> > // Input: unsigned int port
> > // Output: TRUE if a call to InChar will return right away with data
> > // FALSE if a call to InChar will wait for input
> > char SCI_InStatus(unsigned int port)
> > {
> > switch(port)
> > {
> > case 0:
> > return(SCI0SR1 & RDRF);break;
> > case 1:
> > return(SCI1SR1 & RDRF);break;
> > }
> > }
> > //-----------------------SCI_OutStatus----------------------------
> > // Checks if output data buffer is empty, TRUE if empty
> > // Input: unsigned int port
> > // Output: TRUE if a call to OutChar will output and return right away
> > // FALSE if a call to OutChar will wait for output to be ready
> > char SCI_OutStatus(unsigned int port)
> > {
> > switch(port)
> > {
> > case 0:
> > return(SCI0SR1 & TDRE);
> > break;
> > case 1:
> > return(SCI1SR1 & TDRE);
> > break;
> > }
> > }
> >
> >
> > //-------------------------SCI_OutString------------------------
> > // Output String (NULL termination), busy-waiting synchronization
> > // Input: pointer to a NULL-terminated string to be transferred, unsigned
> > int port
> > // Output: none
> > void SCI_OutString(char *pt,unsigned int port)
> > {
> > while(*pt){
> > SCI_OutChar(*pt,port);
> > pt++;
> > }
> > }
> >
> > //----------------------SCI_InUDec-------------------------------
> > // InUDec accepts ASCII input in unsigned decimal format
> > // and converts to a 16 bit unsigned number
> > // valid range is 0 to 65535
> > // Input: unsigned int port
> > // Output: 16-bit unsigned number
> > // If you enter a number above 65535, it will truncate without an error
> > // Backspace will remove last digit typed
> > unsigned short SCI_InUDec(unsigned int port)
> > {
> > unsigned short number=0, length=0;
> > char character;
> > character = SCI_InChar(port);
> > while(character!=CR) // accepts until carriage return input
> > {
> > // The next line checks that the input is a digit, 0-9.
> > // If the character is not 0-9, it is ignored and not echoed
> > if((character>='0') && (character<='9'))
> > {
> > number = 10*number+(character-'0'); // this line overflows if
> > above 65535
> > length++;
> > SCI_OutChar(character,port);
> > }
> > // If the input is a backspace, then the return number is
> > // changed and a backspace is outputted to the screen
> > else if((character==BS) && length)
> > {
> > number /= 10;
> > length--;
> > SCI_OutChar(character,port);
> > }
> > character = SCI_InChar(port);
> > }
> > return number;
> > }
> >
> >
> > //-----------------------SCI_OutUDec-----------------------
> > // Output a 16-bit number in unsigned decimal format
> > // Input: 16-bit number to be transferred, unsigned int port
> > // Output: none
> > // Variable format 1-5 digits with no space before or after
> > void SCI_OutUDec(unsigned short n,unsigned int port)
> > {
> > // This function uses recursion to convert decimal number
> > // of unspecified length as an ASCII string
> > if(n >= 10){
> > SCI_OutUDec(n/10,port);
> > n = n%10;
> > }
> > SCI_OutChar(n+'0',port); /* n is between 0 and 9 */
> > }
> >
> >
> >
> > //---------------------SCI_InUHex----------------------------------------
> > // Accepts ASCII input in unsigned hexadecimal (base 16) format
> > // Input: unsigned int port
> > // Output: 16-bit unsigned number
> > // No '$' or '0x' need be entered, just the 1 to 4 hex digits
> > // It will convert lower case a-f to uppercase A-F
> > // and converts to a 16 bit unsigned number
> > // value range is 0 to FFFF
> > // If you enter a number above FFFF, it will truncate without an error
> > // Backspace will remove last digit typed
> > unsigned short SCI_InUHex(unsigned int port){
> > unsigned short number=0, digit, length=0;
> > char character;
> > character = SCI_InChar(port);
> > while(character!=CR){
> > digit = 0x10; // assume bad
> > if((character>='0') && (character<='9')){
> > digit = character-'0';
> > }
> > else if((character>='A') && (character<='F')){
> > digit = (character-'A')+0xA;
> > }
> > else if((character>='a') && (character<='f')){
> > digit = (character-'a')+0xA;
> > }
> > // If the character is not 0-9 or A-F, it is ignored and not echoed
> > if(digit<=0xF ){
> > number = number*0x10+digit;
> > length++;
> > SCI_OutChar(character,port);
> > }
> > // Backspace outputted and return value changed if a backspace is inputted
> > else if(character==BS && length){
> > number /=0x10;
> > length--;
> > SCI_OutChar(character,port);
> > }
> > character = SCI_InChar(port);
> > }
> > return number;
> > }
> >
> > //--------------------------SCI_OutUHex----------------------------
> > // Output a 16 bit number in unsigned hexadecimal format
> > // Input: 16-bit number to be transferred, unsigned int port
> > // Output: none
> > // Variable format 1 to 4 digits with no space before or after
> > void SCI_OutUHex(unsigned short number,unsigned int port){
> > // This function uses recursion to convert the number of
> > // unspecified length as an ASCII string
> > if(number>=0x10) {
> > SCI_OutUHex(number/0x10,port);
> > SCI_OutUHex(number%0x10,port);
> > }
> > else if(number<0xA){
> > SCI_OutChar(number+'0',port);
> > }
> > else{
> > SCI_OutChar((number-0x0A)+'A',port);
> > }
> > }
> >
> > //------------------------SCI_InString------------------------
> > // This function accepts ASCII characters from the serial port
> > // and adds them to a string until a carriage return is inputted
> > // or until max length of the string is reached.
> > // It echoes each character as it is inputted.
> > // If a backspace is inputted, the string is modified
> > // and the backspace is echoed
> > // InString terminates the string with a null character
> > // -- Modified by Agustinus Darmawan + Mingjie Qiu --
> > void SCI_InString(char *string,unsigned short max,unsigned int port)
> > {
> > int length=0;
> > char character;
> > character = SCI_InChar(port);
> > while(character!=CR)
> > {
> > if(character==BS)
> > {
> > if(length)
> > {
> > string--;
> > length--;
> > SCI_OutChar(BS,port);
> > }
> > }
> > else if(length<max)
> > {
> > *string++=character;
> > length++;
> > SCI_OutChar(character,port);
> > }
> > character = SCI_InChar(port);
> > }
> > *string = 0;
> > }
> >
> >
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
>
>

[Non-text portions of this message have been removed]

Re: Dragon Board 12 Serial Communication C code Help

2009-10-26T21:51:58Z

Probably malloc didn't succeed

char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char

BTW comment is wrong, should be make room for 5 pointers to char

Edward

----- Original Message -----
From: <zach.r.long@...>
To: <68hc12@...>
Sent: Monday, October 26, 2009 10:26 PM
Subject: [68HC12] Dragon Board 12 Serial Communication C code Help

> Hello all, I am hoping someone has some incite as to what I am doing wrong
> here, I figure it is a small problem but I am out of ideas. This is just a
> test to figure out how to pass char * through methods. The code should
> print Hello World to the serial port which it does, then print tes
> repeatedly, which it does not, rather the output is as follows:
>
> Hello World"""""""""""""""""""""""""""""""""""""""""""""""""""""""
> """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
>
> Here is the code, also below is the sci.c and sci.h that do the actually
> serial communication.
>
> Thank You in advanced !
>
> Zach Long
>
> MAIN:
>
> #include "sci.h"
>
> int main(void);
> void encode(char *out);
>
> int main(void)
> {
> char* head = "Hello World"; // declare first print statement
> char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char
>
> SCI_Init(9600,0); //Startup serial port 0(under LCD) at 9600 BAUD
> SCI_OutStatus(1); // Is it clear to send (buffer empty)
> SCI_OutString(head,0); // print "Hello World" to serial port (WORKS !!)
>
> while(1)
> {
> if(SCI_OutStatus(0))// Is it clear to send (buffer empty)
> {
> encode(outData);//,out.throt,out.heading); // build output
> SCI_OutString(outData,0); // print out put to serial port
> }
> }
> return 0;
> }
>
> void encode(char *out) // take in pointer and fill with chars
> {
> out[0] = 't';
> out[1] = 'e';
> out[2] = 's';
> out[3] = 0;
> }
>
> SCI include:
>
> // filename ******************* SCI.H **************************
> // Jonathan W. Valvano 1/29/04
>
> // This example accompanies the books
> // "Embedded Microcomputer Systems: Real Time Interfacing",
> // Brooks-Cole, copyright (c) 2000,
> // "Introduction to Embedded Microcomputer Systems:
> // Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002
>
> // Copyright 2004 by Jonathan W. Valvano, valvano@...
> // You may use, edit, run or distribute this file
> // as long as the above copyright notice remains
> // Modified by EE345L students Charlie Gough && Matt Hawk
> // Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
> // Modified by Zachary Long Oct 16, 2009 (setup for Dragon Board 12 9600
> BAUD, use of both serial ports enabled)
>
> //How To
> /*
> Each method has an unsigned int port parameter, this specifices the
> serial port
> the method will act on. Dragon Board 12: Serial port under LCD (top) =
> 0, Serial port near power plug (bottom) = 1
> */
>
> // standard ASCII symbols
> #define CR 0x0D
> #define LF 0x0A
> #define BS 0x08
> #define ESC 0x1B
> #define SP 0x20
> #define DEL 0x7F
>
> //-------------------------SCI_Init------------------------
> //-------------------------SCI_Init------------------------
> // Initialize Serial port SCI
> // Input: baudRate is tha baud rate in bits/sec
> // Output: none
> // SCIBDL = 24000000/(16 x BR)
> // baudRate = 2400 bits/sec SCIBDL=625
> // baudRate = 4800 bits/sec SCIBDL=313
> // baudRate = 9600 bits/sec SCIBDL=156
> // baudRate = 19200 bits/sec SCIBDL=78
> // assumes a module clock frequency of 4 MHz
> // sets baudRate to 9600
> void SCI_Init(unsigned short baudRate,unsigned int port);
>
> //-------------------------SCI_InStatus--------------------------
> // Checks if new input is ready, TRUE if new input is ready
> // Input: unsigned int port
> // Output: TRUE if a call to InChar will return right away with data
> // FALSE if a call to InChar will wait for input
> char SCI_InStatus(unsigned int port);
>
> //-------------------------SCI_InChar------------------------
> // Wait for new serial port input, busy-waiting synchronization
> // Input: unsigned int port
> // Output: ASCII code for key typed
> char SCI_InChar(unsigned int port);
>
> void SCI_InString(char* string,unsigned short max,unsigned int port); //
> Reads in a String of max length
>
> //----------------------SCI_InUDec-------------------------------
> // InUDec accepts ASCII input in unsigned decimal format
> // and converts to a 16 bit unsigned number
> // valid range is 0 to 65535
> // Input: unsigned int port
> // Output: 16-bit unsigned number
> // If you enter a number above 65535, it will truncate without an error
> // Backspace will remove last digit typed
> unsigned short SCI_InUDec(unsigned int port);
>
> //---------------------SCI_InUHex----------------------------------------
> // Accepts ASCII input in unsigned hexadecimal (base 16) format
> // Input: unsigned int port
> // Output: 16-bit unsigned number
> // No '$' or '0x' need be entered, just the 1 to 4 hex digits
> // It will convert lower case a-f to uppercase A-F
> // and converts to a 16 bit unsigned number
> // value range is 0 to FFFF
> // If you enter a number above FFFF, it will truncate without an error
> // Backspace will remove last digit typed
> unsigned short SCI_InUHex(unsigned int port);
>
> //-----------------------SCI_OutStatus----------------------------
> // Checks if output data buffer is empty, TRUE if empty
> // Input: unsigned int port
> // Output: TRUE if a call to OutChar will output and return right away
> // FALSE if a call to OutChar will wait for output to be ready
> char SCI_OutStatus(unsigned int port);
>
> //-------------------------SCI_OutChar------------------------
> // Wait for buffer to be empty, output 8-bit to serial port
> // busy-waiting synchronization
> // Input: 8-bit data to be transferred, unsigned int port
> // Output: none
> void SCI_OutChar(char data,unsigned int port);
>
> //-----------------------SCI_OutUDec-----------------------
> // Output a 16-bit number in unsigned decimal format
> // Input: 16-bit number to be transferred, unsigned int port
> // Output: none
> // Variable format 1-5 digits with no space before or after
> void SCI_OutUDec(unsigned short,unsigned int port);
>
> //-------------------------SCI_OutString------------------------
> // Output String (NULL termination), busy-waiting synchronization
> // Input: pointer to a NULL-terminated string to be transferred, unsigned
> int port
> // Output: none
> void SCI_OutString(char *pt,unsigned int port);
>
> //--------------------------SCI_OutUHex----------------------------
> // Output a 16 bit number in unsigned hexadecimal format
> // Input: 16-bit number to be transferred, unsigned int port
> // Output: none
> // Variable format 1 to 4 digits with no space before or after
> void SCI_OutUHex(unsigned short,unsigned int port);
>
>
>
> // filename *************** SCI.C ******************************
> // Simple I/O routines to 9S12C32 serial port
> // Jonathan W. Valvano 1/29/04
>
> // This example accompanies the books
> // "Embedded Microcomputer Systems: Real Time Interfacing",
> // Brooks-Cole, copyright (c) 2000,
> // "Introduction to Embedded Microcomputer Systems:
> // Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002
>
> // Copyright 2004 by Jonathan W. Valvano, valvano@...
> // You may use, edit, run or distribute this file
> // as long as the above copyright notice remains
> // Modified by EE345L students Charlie Gough && Matt Hawk
> // Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
> // Modified by Steven Lamb April 28, 2004 (minor changes for g++)
> // Modified by Zachary Long Oct 16, 2009 (serial init (9600)updated, use
> of both serial ports enabled)
>
>
> //How To
> /*
>
> */
>
> #include "hcs12.h" // io register map
> #include "SCI.h"
> #define RDRF 0x20 // Receive Data Register Full Bit
> #define TDRE 0x80 // Transmit Data Register Empty Bit
>
>
> //-------------------------SCI_Init------------------------
> // Initialize Serial port SCI
> // Input: baudRate is tha baud rate in bits/sec
> // Output: none
> // SCIBDL = 24000000/(16 x BR)
> // baudRate = 2400 bits/sec SCIBDL=625
> // baudRate = 4800 bits/sec SCIBDL=313
> // baudRate = 9600 bits/sec SCIBDL=156
> // baudRate = 19200 bits/sec SCIBDL=78
> // assumes a module clock frequency of 4 MHz
> // sets baudRate to 9600
> void SCI_Init(unsigned short baudRate, unsigned int port)
> {
> switch(port)
> {
> case 0:
> {
> SCI0BDH = 0;
> switch(baudRate)
> {
> case 2400: SCI0BDL=625; break;
> case 4800: SCI0BDL=313; break;
> case 9600: SCI0BDL=156; break;
> case 19200: SCI0BDL=78; break;
> default: SCI0BDL = 156 ; // 9600
> }
> break;
>
> SCI0CR1 = 0;
> /* bit value meaning
> 7 0 LOOPS, no looping, normal
> 6 0 WOMS, normal high/low outputs
> 5 0 RSRC, not appliable with LOOPS=0
> 4 0 M, 1 start, 8 data, 1 stop
> 3 0 WAKE, wake by idle (not applicable)
> 2 0 ILT, short idle time (not applicable)
> 1 0 PE, no parity
> 0 0 PT, parity type (not applicable with PE=0)
> */
>
> SCI0CR2 = 0x0C;
> /* bit value meaning
> 7 0 TIE, no transmit interrupts on TDRE
> 6 0 TCIE, no transmit interrupts on TC
> 5 0 RIE, no receive interrupts on RDRF
> 4 0 ILIE, no interrupts on idle
> 3 1 TE, enable transmitter
> 2 1 RE, enable receiver
> 1 0 RWU, no receiver wakeup
> 0 0 SBK, no send break
> */
> break;
> }
> case 1:
> {
> SCI1BDH = 0;
> switch(baudRate)
> {
> case 2400: SCI1BDL=625; break;
> case 4800: SCI1BDL=313; break;
> case 9600: SCI1BDL=156; break;
> case 19200: SCI1BDL=78; break;
> default: SCI1BDL = 156 ; // 9600
> }
> break;
>
> SCI1CR1 = 0;
> /* bit value meaning
> 7 0 LOOPS, no looping, normal
> 6 0 WOMS, normal high/low outputs
> 5 0 RSRC, not appliable with LOOPS=0
> 4 0 M, 1 start, 8 data, 1 stop
> 3 0 WAKE, wake by idle (not applicable)
> 2 0 ILT, short idle time (not applicable)
> 1 0 PE, no parity
> 0 0 PT, parity type (not applicable with PE=0)
> */
>
> SCI1CR2 = 0x0C;
> /* bit value meaning
> 7 0 TIE, no transmit interrupts on TDRE
> 6 0 TCIE, no transmit interrupts on TC
> 5 0 RIE, no receive interrupts on RDRF
> 4 0 ILIE, no interrupts on idle
> 3 1 TE, enable transmitter
> 2 1 RE, enable receiver
> 1 0 RWU, no receiver wakeup
> 0 0 SBK, no send break
> */
> break;
> }
> }
> }
>
>
> //-------------------------SCI_InChar------------------------
> // Wait for new serial port input, busy-waiting synchronization
> // Input: int port
> // Output: ASCII code for key typed
> char SCI_InChar(unsigned int port)
> {
> switch(port)
> {
> case 0:
> while((SCI0SR1 & RDRF) == 0){};
> return(SCI0DRL);
> break;
> case 1:
> while((SCI1SR1 & RDRF) == 0){};
> return(SCI1DRL);
> break;
> }
> }
>
> //-------------------------SCI_OutChar------------------------
> // Wait for buffer to be empty, output 8-bit to serial port
> // busy-waiting synchronization
> // Input: 8-bit data to be transferred
> // Output: none
> void SCI_OutChar(char data,unsigned int port)
> {
> switch(port)
> {
> case 0:
> while((SCI0SR1 & TDRE) == 0){};
> SCI0DRL = data;
> break;
> case 1:
> while((SCI1SR1 & TDRE) == 0){};
> SCI1DRL = data;
> break;
> }
> }
>
> //-------------------------SCI_InStatus--------------------------
> // Checks if new input is ready, TRUE if new input is ready
> // Input: unsigned int port
> // Output: TRUE if a call to InChar will return right away with data
> // FALSE if a call to InChar will wait for input
> char SCI_InStatus(unsigned int port)
> {
> switch(port)
> {
> case 0:
> return(SCI0SR1 & RDRF);break;
> case 1:
> return(SCI1SR1 & RDRF);break;
> }
> }
> //-----------------------SCI_OutStatus----------------------------
> // Checks if output data buffer is empty, TRUE if empty
> // Input: unsigned int port
> // Output: TRUE if a call to OutChar will output and return right away
> // FALSE if a call to OutChar will wait for output to be ready
> char SCI_OutStatus(unsigned int port)
> {
> switch(port)
> {
> case 0:
> return(SCI0SR1 & TDRE);
> break;
> case 1:
> return(SCI1SR1 & TDRE);
> break;
> }
> }
>
>
> //-------------------------SCI_OutString------------------------
> // Output String (NULL termination), busy-waiting synchronization
> // Input: pointer to a NULL-terminated string to be transferred, unsigned
> int port
> // Output: none
> void SCI_OutString(char *pt,unsigned int port)
> {
> while(*pt){
> SCI_OutChar(*pt,port);
> pt++;
> }
> }
>
> //----------------------SCI_InUDec-------------------------------
> // InUDec accepts ASCII input in unsigned decimal format
> // and converts to a 16 bit unsigned number
> // valid range is 0 to 65535
> // Input: unsigned int port
> // Output: 16-bit unsigned number
> // If you enter a number above 65535, it will truncate without an error
> // Backspace will remove last digit typed
> unsigned short SCI_InUDec(unsigned int port)
> {
> unsigned short number=0, length=0;
> char character;
> character = SCI_InChar(port);
> while(character!=CR) // accepts until carriage return input
> {
> // The next line checks that the input is a digit, 0-9.
> // If the character is not 0-9, it is ignored and not echoed
> if((character>='0') && (character<='9'))
> {
> number = 10*number+(character-'0'); // this line overflows if
> above 65535
> length++;
> SCI_OutChar(character,port);
> }
> // If the input is a backspace, then the return number is
> // changed and a backspace is outputted to the screen
> else if((character==BS) && length)
> {
> number /= 10;
> length--;
> SCI_OutChar(character,port);
> }
> character = SCI_InChar(port);
> }
> return number;
> }
>
>
> //-----------------------SCI_OutUDec-----------------------
> // Output a 16-bit number in unsigned decimal format
> // Input: 16-bit number to be transferred, unsigned int port
> // Output: none
> // Variable format 1-5 digits with no space before or after
> void SCI_OutUDec(unsigned short n,unsigned int port)
> {
> // This function uses recursion to convert decimal number
> // of unspecified length as an ASCII string
> if(n >= 10){
> SCI_OutUDec(n/10,port);
> n = n%10;
> }
> SCI_OutChar(n+'0',port); /* n is between 0 and 9 */
> }
>
>
>
> //---------------------SCI_InUHex----------------------------------------
> // Accepts ASCII input in unsigned hexadecimal (base 16) format
> // Input: unsigned int port
> // Output: 16-bit unsigned number
> // No '$' or '0x' need be entered, just the 1 to 4 hex digits
> // It will convert lower case a-f to uppercase A-F
> // and converts to a 16 bit unsigned number
> // value range is 0 to FFFF
> // If you enter a number above FFFF, it will truncate without an error
> // Backspace will remove last digit typed
> unsigned short SCI_InUHex(unsigned int port){
> unsigned short number=0, digit, length=0;
> char character;
> character = SCI_InChar(port);
> while(character!=CR){
> digit = 0x10; // assume bad
> if((character>='0') && (character<='9')){
> digit = character-'0';
> }
> else if((character>='A') && (character<='F')){
> digit = (character-'A')+0xA;
> }
> else if((character>='a') && (character<='f')){
> digit = (character-'a')+0xA;
> }
> // If the character is not 0-9 or A-F, it is ignored and not echoed
> if(digit<=0xF ){
> number = number*0x10+digit;
> length++;
> SCI_OutChar(character,port);
> }
> // Backspace outputted and return value changed if a backspace is inputted
> else if(character==BS && length){
> number /=0x10;
> length--;
> SCI_OutChar(character,port);
> }
> character = SCI_InChar(port);
> }
> return number;
> }
>
> //--------------------------SCI_OutUHex----------------------------
> // Output a 16 bit number in unsigned hexadecimal format
> // Input: 16-bit number to be transferred, unsigned int port
> // Output: none
> // Variable format 1 to 4 digits with no space before or after
> void SCI_OutUHex(unsigned short number,unsigned int port){
> // This function uses recursion to convert the number of
> // unspecified length as an ASCII string
> if(number>=0x10) {
> SCI_OutUHex(number/0x10,port);
> SCI_OutUHex(number%0x10,port);
> }
> else if(number<0xA){
> SCI_OutChar(number+'0',port);
> }
> else{
> SCI_OutChar((number-0x0A)+'A',port);
> }
> }
>
> //------------------------SCI_InString------------------------
> // This function accepts ASCII characters from the serial port
> // and adds them to a string until a carriage return is inputted
> // or until max length of the string is reached.
> // It echoes each character as it is inputted.
> // If a backspace is inputted, the string is modified
> // and the backspace is echoed
> // InString terminates the string with a null character
> // -- Modified by Agustinus Darmawan + Mingjie Qiu --
> void SCI_InString(char *string,unsigned short max,unsigned int port)
> {
> int length=0;
> char character;
> character = SCI_InChar(port);
> while(character!=CR)
> {
> if(character==BS)
> {
> if(length)
> {
> string--;
> length--;
> SCI_OutChar(BS,port);
> }
> }
> else if(length<max)
> {
> *string++=character;
> length++;
> SCI_OutChar(character,port);
> }
> character = SCI_InChar(port);
> }
> *string = 0;
> }
>
>
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>

Dragon Board 12 Serial Communication C code Help

2009-10-26T13:26:49Z

Hello all, I am hoping someone has some incite as to what I am doing wrong here, I figure it is a small problem but I am out of ideas. This is just a test to figure out how to pass char * through methods. The code should print Hello World to the serial port which it does, then print tes repeatedly, which it does not, rather the output is as follows:

Hello World"""""""""""""""""""""""""""""""""""""""""""""""""""""""
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

Here is the code, also below is the sci.c and sci.h that do the actually serial communication.

Thank You in advanced !

Zach Long

MAIN:

#include "sci.h"

int main(void);
void encode(char *out);

int main(void)
{
char* head = "Hello World"; // declare first print statement
char* outData =(char*) malloc (sizeof (char*)* 5); // make room for 5 char

SCI_Init(9600,0); //Startup serial port 0(under LCD) at 9600 BAUD
SCI_OutStatus(1); // Is it clear to send (buffer empty)
SCI_OutString(head,0); // print "Hello World" to serial port (WORKS !!)

while(1)
{
if(SCI_OutStatus(0))// Is it clear to send (buffer empty)
{
encode(outData);//,out.throt,out.heading); // build output
SCI_OutString(outData,0); // print out put to serial port
}
}
return 0;
}

void encode(char *out) // take in pointer and fill with chars
{
out[0] = 't';
out[1] = 'e';
out[2] = 's';
out[3] = 0;
}

SCI include:

// filename ******************* SCI.H **************************
// Jonathan W. Valvano 1/29/04

// This example accompanies the books
// "Embedded Microcomputer Systems: Real Time Interfacing",
// Brooks-Cole, copyright (c) 2000,
// "Introduction to Embedded Microcomputer Systems:
// Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002

// Copyright 2004 by Jonathan W. Valvano, valvano@...
// You may use, edit, run or distribute this file
// as long as the above copyright notice remains
// Modified by EE345L students Charlie Gough && Matt Hawk
// Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
// Modified by Zachary Long Oct 16, 2009 (setup for Dragon Board 12 9600 BAUD, use of both serial ports enabled)

//How To
/*
Each method has an unsigned int port parameter, this specifices the serial port
the method will act on. Dragon Board 12: Serial port under LCD (top) = 0, Serial port near power plug (bottom) = 1
*/

// standard ASCII symbols
#define CR 0x0D
#define LF 0x0A
#define BS 0x08
#define ESC 0x1B
#define SP 0x20
#define DEL 0x7F

//-------------------------SCI_Init------------------------
//-------------------------SCI_Init------------------------
// Initialize Serial port SCI
// Input: baudRate is tha baud rate in bits/sec
// Output: none
// SCIBDL = 24000000/(16 x BR)
// baudRate = 2400 bits/sec SCIBDL=625
// baudRate = 4800 bits/sec SCIBDL=313
// baudRate = 9600 bits/sec SCIBDL=156
// baudRate = 19200 bits/sec SCIBDL=78
// assumes a module clock frequency of 4 MHz
// sets baudRate to 9600
void SCI_Init(unsigned short baudRate,unsigned int port);

//-------------------------SCI_InStatus--------------------------
// Checks if new input is ready, TRUE if new input is ready
// Input: unsigned int port
// Output: TRUE if a call to InChar will return right away with data
// FALSE if a call to InChar will wait for input
char SCI_InStatus(unsigned int port);

//-------------------------SCI_InChar------------------------
// Wait for new serial port input, busy-waiting synchronization
// Input: unsigned int port
// Output: ASCII code for key typed
char SCI_InChar(unsigned int port);

void SCI_InString(char* string,unsigned short max,unsigned int port); // Reads in a String of max length

//----------------------SCI_InUDec-------------------------------
// InUDec accepts ASCII input in unsigned decimal format
// and converts to a 16 bit unsigned number
// valid range is 0 to 65535
// Input: unsigned int port
// Output: 16-bit unsigned number
// If you enter a number above 65535, it will truncate without an error
// Backspace will remove last digit typed
unsigned short SCI_InUDec(unsigned int port);

//---------------------SCI_InUHex----------------------------------------
// Accepts ASCII input in unsigned hexadecimal (base 16) format
// Input: unsigned int port
// Output: 16-bit unsigned number
// No '$' or '0x' need be entered, just the 1 to 4 hex digits
// It will convert lower case a-f to uppercase A-F
// and converts to a 16 bit unsigned number
// value range is 0 to FFFF
// If you enter a number above FFFF, it will truncate without an error
// Backspace will remove last digit typed
unsigned short SCI_InUHex(unsigned int port);

//-----------------------SCI_OutStatus----------------------------
// Checks if output data buffer is empty, TRUE if empty
// Input: unsigned int port
// Output: TRUE if a call to OutChar will output and return right away
// FALSE if a call to OutChar will wait for output to be ready
char SCI_OutStatus(unsigned int port);

//-------------------------SCI_OutChar------------------------
// Wait for buffer to be empty, output 8-bit to serial port
// busy-waiting synchronization
// Input: 8-bit data to be transferred, unsigned int port
// Output: none
void SCI_OutChar(char data,unsigned int port);

//-----------------------SCI_OutUDec-----------------------
// Output a 16-bit number in unsigned decimal format
// Input: 16-bit number to be transferred, unsigned int port
// Output: none
// Variable format 1-5 digits with no space before or after
void SCI_OutUDec(unsigned short,unsigned int port);

//-------------------------SCI_OutString------------------------
// Output String (NULL termination), busy-waiting synchronization
// Input: pointer to a NULL-terminated string to be transferred, unsigned int port
// Output: none
void SCI_OutString(char *pt,unsigned int port);

//--------------------------SCI_OutUHex----------------------------
// Output a 16 bit number in unsigned hexadecimal format
// Input: 16-bit number to be transferred, unsigned int port
// Output: none
// Variable format 1 to 4 digits with no space before or after
void SCI_OutUHex(unsigned short,unsigned int port);

// filename *************** SCI.C ******************************
// Simple I/O routines to 9S12C32 serial port
// Jonathan W. Valvano 1/29/04

// This example accompanies the books
// "Embedded Microcomputer Systems: Real Time Interfacing",
// Brooks-Cole, copyright (c) 2000,
// "Introduction to Embedded Microcomputer Systems:
// Motorola 6811 and 6812 Simulation", Brooks-Cole, copyright (c) 2002

// Copyright 2004 by Jonathan W. Valvano, valvano@...
// You may use, edit, run or distribute this file
// as long as the above copyright notice remains
// Modified by EE345L students Charlie Gough && Matt Hawk
// Modified by EE345M students Agustinus Darmawan + Mingjie Qiu
// Modified by Steven Lamb April 28, 2004 (minor changes for g++)
// Modified by Zachary Long Oct 16, 2009 (serial init (9600)updated, use of both serial ports enabled)

//How To
/*

*/

#include "hcs12.h" // io register map
#include "SCI.h"
#define RDRF 0x20 // Receive Data Register Full Bit
#define TDRE 0x80 // Transmit Data Register Empty Bit

//-------------------------SCI_Init------------------------
// Initialize Serial port SCI
// Input: baudRate is tha baud rate in bits/sec
// Output: none
// SCIBDL = 24000000/(16 x BR)
// baudRate = 2400 bits/sec SCIBDL=625
// baudRate = 4800 bits/sec SCIBDL=313
// baudRate = 9600 bits/sec SCIBDL=156
// baudRate = 19200 bits/sec SCIBDL=78
// assumes a module clock frequency of 4 MHz
// sets baudRate to 9600
void SCI_Init(unsigned short baudRate, unsigned int port)
{
switch(port)
{
case 0:
{
SCI0BDH = 0;
switch(baudRate)
{
case 2400: SCI0BDL=625; break;
case 4800: SCI0BDL=313; break;
case 9600: SCI0BDL=156; break;
case 19200: SCI0BDL=78; break;
default: SCI0BDL = 156 ; // 9600
}
break;

SCI0CR1 = 0;
/* bit value meaning
7 0 LOOPS, no looping, normal
6 0 WOMS, normal high/low outputs
5 0 RSRC, not appliable with LOOPS=0
4 0 M, 1 start, 8 data, 1 stop
3 0 WAKE, wake by idle (not applicable)
2 0 ILT, short idle time (not applicable)
1 0 PE, no parity
0 0 PT, parity type (not applicable with PE=0)
*/

SCI0CR2 = 0x0C;
/* bit value meaning
7 0 TIE, no transmit interrupts on TDRE
6 0 TCIE, no transmit interrupts on TC
5 0 RIE, no receive interrupts on RDRF
4 0 ILIE, no interrupts on idle
3 1 TE, enable transmitter
2 1 RE, enable receiver
1 0 RWU, no receiver wakeup
0 0 SBK, no send break
*/
break;
}
case 1:
{
SCI1BDH = 0;
switch(baudRate)
{
case 2400: SCI1BDL=625; break;
case 4800: SCI1BDL=313; break;
case 9600: SCI1BDL=156; break;
case 19200: SCI1BDL=78; break;
default: SCI1BDL = 156 ; // 9600
}
break;

SCI1CR1 = 0;
/* bit value meaning
7 0 LOOPS, no looping, normal
6 0 WOMS, normal high/low outputs
5 0 RSRC, not appliable with LOOPS=0
4 0 M, 1 start, 8 data, 1 stop
3 0 WAKE, wake by idle (not applicable)
2 0 ILT, short idle time (not applicable)
1 0 PE, no parity
0 0 PT, parity type (not applicable with PE=0)
*/

SCI1CR2 = 0x0C;
/* bit value meaning
7 0 TIE, no transmit interrupts on TDRE
6 0 TCIE, no transmit interrupts on TC
5 0 RIE, no receive interrupts on RDRF
4 0 ILIE, no interrupts on idle
3 1 TE, enable transmitter
2 1 RE, enable receiver
1 0 RWU, no receiver wakeup
0 0 SBK, no send break
*/
break;
}
}
}

//-------------------------SCI_InChar------------------------
// Wait for new serial port input, busy-waiting synchronization
// Input: int port
// Output: ASCII code for key typed
char SCI_InChar(unsigned int port)
{
switch(port)
{
case 0:
while((SCI0SR1 & RDRF) == 0){};
return(SCI0DRL);
break;
case 1:
while((SCI1SR1 & RDRF) == 0){};
return(SCI1DRL);
break;
}
}

//-------------------------SCI_OutChar------------------------
// Wait for buffer to be empty, output 8-bit to serial port
// busy-waiting synchronization
// Input: 8-bit data to be transferred
// Output: none
void SCI_OutChar(char data,unsigned int port)
{
switch(port)
{
case 0:
while((SCI0SR1 & TDRE) == 0){};
SCI0DRL = data;
break;
case 1:
while((SCI1SR1 & TDRE) == 0){};
SCI1DRL = data;
break;
}
}

//-------------------------SCI_InStatus--------------------------
// Checks if new input is ready, TRUE if new input is ready
// Input: unsigned int port
// Output: TRUE if a call to InChar will return right away with data
// FALSE if a call to InChar will wait for input
char SCI_InStatus(unsigned int port)
{
switch(port)
{
case 0:
return(SCI0SR1 & RDRF);break;
case 1:
return(SCI1SR1 & RDRF);break;
}
}
//-----------------------SCI_OutStatus----------------------------
// Checks if output data buffer is empty, TRUE if empty
// Input: unsigned int port
// Output: TRUE if a call to OutChar will output and return right away
// FALSE if a call to OutChar will wait for output to be ready
char SCI_OutStatus(unsigned int port)
{
switch(port)
{
case 0:
return(SCI0SR1 & TDRE);
break;
case 1:
return(SCI1SR1 & TDRE);
break;
}
}

//-------------------------SCI_OutString------------------------
// Output String (NULL termination), busy-waiting synchronization
// Input: pointer to a NULL-terminated string to be transferred, unsigned int port
// Output: none
void SCI_OutString(char *pt,unsigned int port)
{
while(*pt){
SCI_OutChar(*pt,port);
pt++;
}
}

//----------------------SCI_InUDec-------------------------------
// InUDec accepts ASCII input in unsigned decimal format
// and converts to a 16 bit unsigned number
// valid range is 0 to 65535
// Input: unsigned int port
// Output: 16-bit unsigned number
// If you enter a number above 65535, it will truncate without an error
// Backspace will remove last digit typed
unsigned short SCI_InUDec(unsigned int port)
{
unsigned short number=0, length=0;
char character;
character = SCI_InChar(port);
while(character!=CR) // accepts until carriage return input
{
// The next line checks that the input is a digit, 0-9.
// If the character is not 0-9, it is ignored and not echoed
if((character>='0') && (character<='9'))
{
number = 10*number+(character-'0'); // this line overflows if above 65535
length++;
SCI_OutChar(character,port);
}
// If the input is a backspace, then the return number is
// changed and a backspace is outputted to the screen
else if((character==BS) && length)
{
number /= 10;
length--;
SCI_OutChar(character,port);
}
character = SCI_InChar(port);
}
return number;
}

//-----------------------SCI_OutUDec-----------------------
// Output a 16-bit number in unsigned decimal format
// Input: 16-bit number to be transferred, unsigned int port
// Output: none
// Variable format 1-5 digits with no space before or after
void SCI_OutUDec(unsigned short n,unsigned int port)
{
// This function uses recursion to convert decimal number
// of unspecified length as an ASCII string
if(n >= 10){
SCI_OutUDec(n/10,port);
n = n%10;
}
SCI_OutChar(n+'0',port); /* n is between 0 and 9 */
}

//---------------------SCI_InUHex----------------------------------------
// Accepts ASCII input in unsigned hexadecimal (base 16) format
// Input: unsigned int port
// Output: 16-bit unsigned number
// No '$' or '0x' need be entered, just the 1 to 4 hex digits
// It will convert lower case a-f to uppercase A-F
// and converts to a 16 bit unsigned number
// value range is 0 to FFFF
// If you enter a number above FFFF, it will truncate without an error
// Backspace will remove last digit typed
unsigned short SCI_InUHex(unsigned int port){
unsigned short number=0, digit, length=0;
char character;
character = SCI_InChar(port);
while(character!=CR){
digit = 0x10; // assume bad
if((character>='0') && (character<='9')){
digit = character-'0';
}
else if((character>='A') && (character<='F')){
digit = (character-'A')+0xA;
}
else if((character>='a') && (character<='f')){
digit = (character-'a')+0xA;
}
// If the character is not 0-9 or A-F, it is ignored and not echoed
if(digit<=0xF ){
number = number*0x10+digit;
length++;
SCI_OutChar(character,port);
}
// Backspace outputted and return value changed if a backspace is inputted
else if(character==BS && length){
number /=0x10;
length--;
SCI_OutChar(character,port);
}
character = SCI_InChar(port);
}
return number;
}

//--------------------------SCI_OutUHex----------------------------
// Output a 16 bit number in unsigned hexadecimal format
// Input: 16-bit number to be transferred, unsigned int port
// Output: none
// Variable format 1 to 4 digits with no space before or after
void SCI_OutUHex(unsigned short number,unsigned int port){
// This function uses recursion to convert the number of
// unspecified length as an ASCII string
if(number>=0x10) {
SCI_OutUHex(number/0x10,port);
SCI_OutUHex(number%0x10,port);
}
else if(number<0xA){
SCI_OutChar(number+'0',port);
}
else{
SCI_OutChar((number-0x0A)+'A',port);
}
}

//------------------------SCI_InString------------------------
// This function accepts ASCII characters from the serial port
// and adds them to a string until a carriage return is inputted
// or until max length of the string is reached.
// It echoes each character as it is inputted.
// If a backspace is inputted, the string is modified
// and the backspace is echoed
// InString terminates the string with a null character
// -- Modified by Agustinus Darmawan + Mingjie Qiu --
void SCI_InString(char *string,unsigned short max,unsigned int port)
{
int length=0;
char character;
character = SCI_InChar(port);
while(character!=CR)
{
if(character==BS)
{
if(length)
{
string--;
length--;
SCI_OutChar(BS,port);
}
}
else if(length<max)
{
*string++=character;
length++;
SCI_OutChar(character,port);
}
character = SCI_InChar(port);
}
*string = 0;
}

Re: Re: Machine code relative offsets

2009-10-23T06:37:24Z

No, rr is relative to the address of instruction (or address of the first
byte of instruction) that follows immediately after dbne. If we add label
Next like this:

>> > Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
>> > bra Update ;20 03
>> > Not_gtr inc Count ;72 B6 1C
>> > Update iny ;02
>> > dbne a,Again ;04 30 F3 <--- rr = $F3
>> > = -$0D
Next
>> > swi ;

, then rr will equal Next - Again. There are thirteen bytes between Again
and Next. rr is negative because target label is above the 'next' (Again is
at more lower address than Next).

Edward

----- Original Message -----
From: "AlD" <al_delgado@...>
To: <68HC12@...>
Sent: Wednesday, October 21, 2009 20:39
Subject: [68HC12] Re: Machine code relative offsets

> Thanks, do I include the byte(s) for the instruction after the dbne, in
> this case for the swi instruction or stop with the 3 bytes of the dbne?
>
> --- In 68HC12@..., "Edward Karpicz" <karpicz@...> wrote:
>>
>> rr=F3 in dbne has most significant bit set, which means rr displacement
>> is
>> negative, F3 = -0D. 13 bytes from Again label to location after dbne (swi
>> instruction).
>>
>> The rest can be found in CPU12/(S)/(SX) reference manuals.
>>
>> Edward
>>
>>
>> ----- Original Message -----
>> From: "AlD" <al_delgado@...>
>> To: <68HC12@...>
>> Sent: Wednesday, October 21, 2009 11:07
>> Subject: [68HC12] Machine code relative offsets
>>
>>
>> >I am trying to understand how assembly is translated into machine code.
>> >I
>> >understand how to get the machine coding formats but I'm not sure how to
>> >calculate 'rr' in all cases. For the example below 'bra' is 20 rr or 20
>> >03,
>> >I know that the relative offset is 03 (to get past the two bytes
>> >required
>> >by the 'inc' instruction)to get to the 'iny' instruction.
>> >
>> > But I'm not sure why the rr = F3 for the 'dbne' instruction, how does
>> > that
>> > relative offset get me to the Again label?
>> >
>> >
>> > Dissassembled code for program:
>> > [CODE] org $600
>> > ldy #Array ;CD B6 15
>> > ldaa #N ;86 07
>> > clr 7,y ;69 47
>> > Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
>> > bra Update ;20 03
>> > Not_gtr inc Count ;72 B6 1C
>> > Update iny ;02
>> > dbne a,Again ;04 30 F3
>> > swi ;
>> >
>> > Array fdb 8,7,2
>> > N equ 7
>> > Count rmb 1[/CODE]
>> >
>> >
>> >
>> > ------------------------------------
>> >
>> > Yahoo! Groups Links
>> >
>> >
>> >
>> >
>>
>
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>
>

Re: xdp512 pwm issue

2009-10-21T12:56:40Z

Hi,

I can usually muddle through on debugging issues but I can't figure this
one out and would appreciate it if anyone has seen something similar and
can offer some advice. In my test program the PWME bit I have set is
getting cleared unexpectedly when I call a sci routine to read an input
buffer. The PWME register is cleared after executing the first
instruction of the sci routine. I'm stumped. In the following NoICE
screen dumps you can see address 0x300 (PWME) change from 0x04 to 0x00
after the sci call. The only thing I can think of is that the page
switch is causing grief. My compiler is ICCV712.

pwm_err_0.jpg <http://www.robmilne .ca/webfm_ send/50>
pwm_err_1.jpg <http://www.robmilne .ca/webfm_ send/51>

-rob

I solved this and removed the original post - I hoped the email packager
would ignore it since it was only up for 1/2 hour. As most bugs are in
retrospect it was a 'stupid' bug. I forgot that I had an ISR monitoring
the optical encoder for no movement and it disabled the pwm (I was
testing pwm independent of any motor feedback). As luck would have it,
the write to PWME coincided with a page switch.

[Non-text portions of this message have been removed]

Re: Machine code relative offsets

2009-10-21T10:39:55Z

Thanks, do I include the byte(s) for the instruction after the dbne, in this case for the swi instruction or stop with the 3 bytes of the dbne?

--- In 68HC12@..., "Edward Karpicz" <karpicz@...> wrote:

>
> rr=F3 in dbne has most significant bit set, which means rr displacement is
> negative, F3 = -0D. 13 bytes from Again label to location after dbne (swi
> instruction).
>
> The rest can be found in CPU12/(S)/(SX) reference manuals.
>
> Edward
>
>
> ----- Original Message -----
> From: "AlD" <al_delgado@...>
> To: <68HC12@...>
> Sent: Wednesday, October 21, 2009 11:07
> Subject: [68HC12] Machine code relative offsets
>
>
> >I am trying to understand how assembly is translated into machine code. I
> >understand how to get the machine coding formats but I'm not sure how to
> >calculate 'rr' in all cases. For the example below 'bra' is 20 rr or 20 03,
> >I know that the relative offset is 03 (to get past the two bytes required
> >by the 'inc' instruction)to get to the 'iny' instruction.
> >
> > But I'm not sure why the rr = F3 for the 'dbne' instruction, how does that
> > relative offset get me to the Again label?
> >
> >
> > Dissassembled code for program:
> > [CODE] org $600
> > ldy #Array ;CD B6 15
> > ldaa #N ;86 07
> > clr 7,y ;69 47
> > Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
> > bra Update ;20 03
> > Not_gtr inc Count ;72 B6 1C
> > Update iny ;02
> > dbne a,Again ;04 30 F3
> > swi ;
> >
> > Array fdb 8,7,2
> > N equ 7
> > Count rmb 1[/CODE]
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
> >
>

xdp512 pwm issue

2009-10-21T07:56:51Z

Re: Counting 1's in 16 bit word

2009-10-21T04:48:29Z

http://graphics.stanford.edu/~seander/bithacks.html
<http://graphics.stanford.edu/%7Eseander/bithacks.html>

--
Dr. Nicholas Merriam
nmerriam@...
~|~|~ Rapita Systems Ltd.
http://www.rapitasystems.com/
Tel: +44 (0)1904 56 7747 Fax: +44 (0)1904 56 7719

Visit Rapita Systems at MAE09 (Military & Aerospace Electronics).
November 10th 2009 (Reading, UK)
http://www.RapitaSystems.com/events/MAE09

RE: Machine code relative offsets

2009-10-21T02:06:04Z

The inc instruction is 3 bytes. Yes, rr = F3 for the dbne instruction is correct.

A formula which might help: PCnew = PCbranch + len(branch) + rr

Or learn to count forwards and backwards in hexadecimal with zero being the first byte of the instruction after the branch.

Emmett Redd Ph.D. mailto:EmmettRedd@...
Professor (417)836-5221
Department of Physics, Astronomy, and Materials Science
Missouri State University Fax (417)836-6226
901 SOUTH NATIONAL Lab (417)836-3770
SPRINGFIELD, MO 65897 USA Dept (417)836-5131

"In theory there is no difference between theory and practice. In practice there is." -- Yogi Berra or Jan van de Snepscheut

________________________________________
From: 68HC12@... [68HC12@...] On Behalf Of AlD [al_delgado@...]
Sent: Wednesday, October 21, 2009 3:07 AM
To: 68HC12@...
Subject: [68HC12] Machine code relative offsets

I am trying to understand how assembly is translated into machine code. I understand how to get the machine coding formats but I'm not sure how to calculate 'rr' in all cases. For the example below 'bra' is 20 rr or 20 03, I know that the relative offset is 03 (to get past the two bytes required by the 'inc' instruction)to get to the 'iny' instruction.

But I'm not sure why the rr = F3 for the 'dbne' instruction, how does that relative offset get me to the Again label?

Dissassembled code for program:
[CODE] org $600
ldy #Array ;CD B6 15
ldaa #N ;86 07
clr 7,y ;69 47
Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
bra Update ;20 03
Not_gtr inc Count ;72 B6 1C
Update iny ;02
dbne a,Again ;04 30 F3
swi ;

Array fdb 8,7,2
N equ 7
Count rmb 1[/CODE]

------------------------------------

Yahoo! Groups Links

http://docs.yahoo.com/info/terms/

Re: Machine code relative offsets

2009-10-21T01:49:28Z

rr=F3 in dbne has most significant bit set, which means rr displacement is
negative, F3 = -0D. 13 bytes from Again label to location after dbne (swi
instruction).

The rest can be found in CPU12/(S)/(SX) reference manuals.

Edward

----- Original Message -----
From: "AlD" <al_delgado@...>
To: <68HC12@...>
Sent: Wednesday, October 21, 2009 11:07
Subject: [68HC12] Machine code relative offsets

>I am trying to understand how assembly is translated into machine code. I
>understand how to get the machine coding formats but I'm not sure how to
>calculate 'rr' in all cases. For the example below 'bra' is 20 rr or 20 03,
>I know that the relative offset is 03 (to get past the two bytes required
>by the 'inc' instruction)to get to the 'iny' instruction.
>
> But I'm not sure why the rr = F3 for the 'dbne' instruction, how does that
> relative offset get me to the Again label?
>
>
> Dissassembled code for program:
> [CODE] org $600
> ldy #Array ;CD B6 15
> ldaa #N ;86 07
> clr 7,y ;69 47
> Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
> bra Update ;20 03
> Not_gtr inc Count ;72 B6 1C
> Update iny ;02
> dbne a,Again ;04 30 F3
> swi ;
>
> Array fdb 8,7,2
> N equ 7
> Count rmb 1[/CODE]
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>
>

Machine code relative offsets

2009-10-21T01:07:10Z

I am trying to understand how assembly is translated into machine code. I understand how to get the machine coding formats but I'm not sure how to calculate 'rr' in all cases. For the example below 'bra' is 20 rr or 20 03, I know that the relative offset is 03 (to get past the two bytes required by the 'inc' instruction)to get to the 'iny' instruction.

But I'm not sure why the rr = F3 for the 'dbne' instruction, how does that relative offset get me to the Again label?

Dissassembled code for program:
[CODE] org $600
ldy #Array ;CD B6 15
ldaa #N ;86 07
clr 7,y ;69 47
Again brclr 0,y %11110000, Not_gtr ;0F 40 F0 02
bra Update ;20 03
Not_gtr inc Count ;72 B6 1C
Update iny ;02
dbne a,Again ;04 30 F3
swi ;

Array fdb 8,7,2
N equ 7
Count rmb 1[/CODE]

Re: Counting 1's in 16 bit word

2009-10-20T21:15:00Z

Ah, clever, I like the != 0 trick. You must be from Oregon.

Did you notice the bug in the Spanish code?

A

On 2009-October-20, at 10:09 PM, Tom Almy wrote:

> No, there is a fundamental difference -- your algorithm (and Angel
> Castillo's) iterate 16 times, while mine only iterates while the value
> is non-zero.
>
> I'm also sure that AID is a student (students are most likely to ask
> questions like this), so I went no further than suggesting an
> approach.
>
> Tom Almy
> Tualatin, Oregon USA
> Internet: tom@...
> Website: almy.us
>
> On Oct 20, 2009, at 7:46 PM, Andrei Chichak wrote:
>
> > That's what I said.
> >
> > BTW, don't let on that this is for a course or people will get
> really
> > rude, tell you to read the book, and complain that they aren't
> getting
> > a portion of your marks.
> >
> > A
> >
> > On 2009-October-20, at 7:19 PM, Tom Almy wrote:
> >
> >> Try this:
> >> 1. Set count to 0
> >> 2, Shift value right
> >> 3. if carry flag set increment count
> >> 4. if value is non-zero, go back to step 2
> >>
> >> Tom Almy
> >> Tualatin, Oregon USA
> >> Internet: tom@...
> >> Website: almy.us
> >>
> >> On Oct 20, 2009, at 3:55 PM, AlD wrote:
> >>
> >>> I am trying to count the number of 1's in a sixteen bit word for
> >>> MC68HC12. The only way I can think of is to use 16 BITA
> >>> instructions, one for each bit location, then increment a
> counter. I
> >>> suspect there is a more elegant way to do this. Could someone
> share
> >>> their ideas with me.
> >>>
> >>>
> >>>
> >>> ------------------------------------
> >>>
> >>> Yahoo! Groups Links
> >>>
> >>>
> >>>
> >>>
> >>
> >>
> >
> > ---------------------
> > Andrei Chichak
> >
> > Systems Developer
> > CBF Systems Inc.
> > 4-038 NINT Innovation Centre
> > 11421 Saskatchewan Drive
> > Edmonton, Alberta
> > Canada
> > T6G 2M9
> >
> > Phone: 780-628-2072
> > Skype: andrei.chichak
> >
> >
> >
> > [Non-text portions of this message have been removed]
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
> >
>
>

---------------------
Andrei Chichak

Systems Developer
CBF Systems Inc.
4-038 NINT Innovation Centre
11421 Saskatchewan Drive
Edmonton, Alberta
Canada
T6G 2M9

Phone: 780-628-2072
Skype: andrei.chichak

[Non-text portions of this message have been removed]

Re: Counting 1's in 16 bit word

2009-10-20T21:09:09Z

No, there is a fundamental difference -- your algorithm (and Angel
Castillo's) iterate 16 times, while mine only iterates while the value
is non-zero.

I'm also sure that AID is a student (students are most likely to ask
questions like this), so I went no further than suggesting an approach.

Tom Almy
Tualatin, Oregon USA
Internet: tom@...
Website: almy.us

On Oct 20, 2009, at 7:46 PM, Andrei Chichak wrote:

> That's what I said.
>
> BTW, don't let on that this is for a course or people will get really
> rude, tell you to read the book, and complain that they aren't getting
> a portion of your marks.
>
> A
>
> On 2009-October-20, at 7:19 PM, Tom Almy wrote:
>
>> Try this:
>> 1. Set count to 0
>> 2, Shift value right
>> 3. if carry flag set increment count
>> 4. if value is non-zero, go back to step 2
>>
>> Tom Almy
>> Tualatin, Oregon USA
>> Internet: tom@...
>> Website: almy.us
>>
>> On Oct 20, 2009, at 3:55 PM, AlD wrote:
>>
>>> I am trying to count the number of 1's in a sixteen bit word for
>>> MC68HC12. The only way I can think of is to use 16 BITA
>>> instructions, one for each bit location, then increment a counter. I
>>> suspect there is a more elegant way to do this. Could someone share
>>> their ideas with me.
>>>
>>>
>>>
>>> ------------------------------------
>>>
>>> Yahoo! Groups Links
>>>
>>>
>>>
>>>
>>
>>
>
> ---------------------
> Andrei Chichak
>
> Systems Developer
> CBF Systems Inc.
> 4-038 NINT Innovation Centre
> 11421 Saskatchewan Drive
> Edmonton, Alberta
> Canada
> T6G 2M9
>
> Phone: 780-628-2072
> Skype: andrei.chichak
>
>
>
> [Non-text portions of this message have been removed]
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>
>

Re: Counting 1's in 16 bit word

2009-10-20T19:46:18Z

That's what I said.

BTW, don't let on that this is for a course or people will get really
rude, tell you to read the book, and complain that they aren't getting
a portion of your marks.

A

On 2009-October-20, at 7:19 PM, Tom Almy wrote:

> Try this:
> 1. Set count to 0
> 2, Shift value right
> 3. if carry flag set increment count
> 4. if value is non-zero, go back to step 2
>
> Tom Almy
> Tualatin, Oregon USA
> Internet: tom@...
> Website: almy.us
>
> On Oct 20, 2009, at 3:55 PM, AlD wrote:
>
> > I am trying to count the number of 1's in a sixteen bit word for
> > MC68HC12. The only way I can think of is to use 16 BITA
> > instructions, one for each bit location, then increment a counter. I
> > suspect there is a more elegant way to do this. Could someone share
> > their ideas with me.
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
> >
>
>

Re: Counting 1's in 16 bit word

2009-10-20T18:39:06Z

Great, just what I was looking for, makes sense.

--- In 68HC12@..., Angel Castillo <eltachonder@...> wrote:

>
> si el dato a evaluar esta en el doble acumlador D
> y el coneo de unos en Ix
>
> ldx #00
> ldy #08
> ciclo lsrd
> bcc cero
> inx
> cero dey
> bne ciclo
>
>
> 2009/10/20 AlD <al_delgado@...>
>
> > I am trying to count the number of 1's in a sixteen bit word for MC68HC12.
> > The only way I can think of is to use 16 BITA instructions, one for each bit
> > location, then increment a counter. I suspect there is a more elegant way to
> > do this. Could someone share their ideas with me.
> >
> >
> >
> > ------------------------------------
> >
> > Yahoo! Groups Links
> >
> >
> >
> >
>
>
> [Non-text portions of this message have been removed]
>

Re: Counting 1's in 16 bit word

2009-10-20T18:19:38Z

Try this:
1. Set count to 0
2, Shift value right
3. if carry flag set increment count
4. if value is non-zero, go back to step 2

Tom Almy
Tualatin, Oregon USA
Internet: tom@...
Website: almy.us

On Oct 20, 2009, at 3:55 PM, AlD wrote:

> I am trying to count the number of 1's in a sixteen bit word for
> MC68HC12. The only way I can think of is to use 16 BITA
> instructions, one for each bit location, then increment a counter. I
> suspect there is a more elegant way to do this. Could someone share
> their ideas with me.
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>
>

Re: Counting 1's in 16 bit word

2009-10-20T17:44:55Z

Thanks, but I'm just learning assembly so I have to do it in assembly, any ideas?

--- In 68HC12@..., Andrei Chichak <groups@...> wrote:

>
> INT8U i, count;
>
> count = 0;
> for (i = 0; i < 16; i++) {
> if ((val %2) != 0) {
> count++;
> }
> val >> 1;
> }
>
> Paid programmers have a budget of 50 lines of assembly. I wouldn't
> blow my budget on something as simple as this.
>
> A
>
>
> On 2009-October-20, at 4:55 PM, AlD wrote:
>
> > I am trying to count the number of 1's in a sixteen bit word for
> > MC68HC12. The only way I can think of is to use 16 BITA
> > instructions, one for each bit location, then increment a counter. I
> > suspect there is a more elegant way to do this. Could someone share
> > their ideas with me.
> >
> >
>
> ---------------------
> Andrei Chichak
>
> Systems Developer
> CBF Systems Inc.
> 4-038 NINT Innovation Centre
> 11421 Saskatchewan Drive
> Edmonton, Alberta
> Canada
> T6G 2M9
>
> Phone: 780-628-2072
> Skype: andrei.chichak
>
>
>
> [Non-text portions of this message have been removed]
>

Re: Counting 1's in 16 bit word

2009-10-20T17:34:45Z

si el dato a evaluar esta en el doble acumlador D
y el coneo de unos en Ix

ldx #00
ldy #08
ciclo lsrd
bcc cero
inx
cero dey
bne ciclo

2009/10/20 AlD <al_delgado@...>

> I am trying to count the number of 1's in a sixteen bit word for MC68HC12.
> The only way I can think of is to use 16 BITA instructions, one for each bit
> location, then increment a counter. I suspect there is a more elegant way to
> do this. Could someone share their ideas with me.
>
>
>
> ------------------------------------
>
> Yahoo! Groups Links
>
>
>
>

[Non-text portions of this message have been removed]

Re: Counting 1's in 16 bit word

2009-10-20T16:04:35Z

INT8U i, count;

count = 0;
for (i = 0; i < 16; i++) {
if ((val %2) != 0) {
count++;
}
val >> 1;
}

Paid programmers have a budget of 50 lines of assembly. I wouldn't
blow my budget on something as simple as this.

A

On 2009-October-20, at 4:55 PM, AlD wrote:

> I am trying to count the number of 1's in a sixteen bit word for
> MC68HC12. The only way I can think of is to use 16 BITA
> instructions, one for each bit location, then increment a counter. I
> suspect there is a more elegant way to do this. Could someone share
> their ideas with me.
>
>

---------------------
Andrei Chichak

Systems Developer
CBF Systems Inc.
4-038 NINT Innovation Centre
11421 Saskatchewan Drive
Edmonton, Alberta
Canada
T6G 2M9

Phone: 780-628-2072
Skype: andrei.chichak

[Non-text portions of this message have been removed]

Counting 1's in 16 bit word

2009-10-20T15:55:46Z

I am trying to count the number of 1's in a sixteen bit word for MC68HC12. The only way I can think of is to use 16 BITA instructions, one for each bit location, then increment a counter. I suspect there is a more elegant way to do this. Could someone share their ideas with me.

update on free HCS12(X) tools

2009-10-07T06:28:18Z

Greetings from Technological Arts! I'd like to let everyone in the HCS12(X) community know about several free development tools that have been released recently. This announcement will be especially interesting to those who are not using C or assembler.

Several months ago, programmer David Armstrong released a FIG-Forth compiler and IDE for the 9S12XDP (http://mamoru.tbreesama.googlepages.com/). In the process of developing it, Dave ported the Serial Monitor of Freescale AN2548 to the 9S12XDP512, and created an enhanced version of our free Windows-hosted uBug12x user interface, supporting loading and simple debugging functions. Both the Serial Monitor and uBug12x are available from http://support.technologicalarts.ca/docs/Adapt9S12X/Code/. The uBug12x manual is available here: http://www.technologicalarts.ca/shop/documentation/63-debugging-tools/132-ubug12x-user-manual.html. Dave also worked with Dirk Heisswolf to enhance his HC(S)12 IDE for Linux, found here: http://home.arcor.de/hotwolf/ I think special recognition should go to both Dave and Dirk for all the effort they have put into perfecting these excellent tools!

Several years ago, when Freescale was about to launch the 9S12C family, we commissioned GenerExe (creator of XPad tools: a "design, simulation, programming, documentation suite" for HC11 and other MCUs) to develop an object-based multi-tasking programming language for the Freescale MOD912C32 (the 32-pin DIP module that we developed-- now called NanoCore12). Unfortunately, due to other obligations, that software development went on the proverbial "back burner". However, we have now decided to make it freely available to 9S12C users, on www.nqBASIC.com. We hope you'll find it useful!

Another recent development is an MCU-resident BASIC programming environment created by Rich Testardi. Rich was 2nd-place winner in Freescale's "Can Your Badge Do This?" contest last year. Over the past few months, we have worked extensively with Rich to port his StickOS BASIC to run on 9S12DP512, and make a number of enhancements. We have dubbed the 9S12 version soBASIC, and it can be found at www.soBASICsoEasy.com.

Finally, in February of this year, Frank Voorburg, of Feaser LLC, released a port of the open-source Eclipse IDE for HC11 & HC12 GNU C/C++. It can be found at http://www.feaser.com/store/eclipse_m6811.php

As we have been for the past 15 years, Technological Arts is still committed to supporting the HC11/HCS12(X) user community. Your comments and suggestions are always welcome!

Best regards,
Carl Barnes
www.technologicalarts.com
Evaluate * Educate * Embed

SPI Communication between TMS470 and MC9S08SG16/32

2009-10-05T00:18:57Z

Hi,

I am new to this embedded field and i need a basic idea on this.
Let me explain my requirment....My main Micro is TMS470 and Slave MC9S08SG I need to flash an Image from Main Micro to Slave using SPI protocol.

Please help me how to proceed any share ur ideas with me...

Thanks,