C Language Development Example for MC68332

[Getintegral]

I am currently trying to develop MC68332 using C language, but I am confused about where to start and cannot find relevant information and routines. Can someone provide me with routines and information？
 I will appreciate any help.  Thank you.

[Bio_TICFSL]

Hello,

 

Developing for the 

Motorola MC68332 in C starts with understanding its core peripherals (like the Timer Processor Unit, Queued Serial Module, ADC, I/O), using a suitable C compiler (like GCC for 68k/Motorola), and leveraging header files for register access (often provided by chip vendor tools or generated from datasheets) to directly manipulate hardware, focusing on memory-mapped I/O and interrupt handling; look for vendor SDKs (like Motorola's old ones) or open-source projects using similar chips for examples

1. Get the Datasheet & Reference Manual: The MC68332 Reference Manual (from Motorola/Freescale) is your Bible; find it on sites like ESIEE.
2. Choose Your Toolchain:
   • Compiler: GCC for Motorola 68k (m68k-elf-gcc) is a common choice for embedded systems, say experts at embedded.com.
   • Debugger/Programmer: GDB with OpenOCD or specific hardware debuggers for flashing/debugging are essential.
3. Understand Memory-Mapped I/O: C interacts with hardware via memory addresses. You'll use pointers to these addresses to control peripherals (e.g., volatile unsigned int *TPU_CONTROL = (volatile unsigned int *)0x...;).
4. Find Hardware Abstraction Layers (HALs): Look for example code for similar 68k chips (like MC68HC11/12) or community projects on GitHub/SourceForge that provide basic drivers. 

Core Concepts & Routines (Conceptual Examples)

• Initialization:
  c

  #include <m68332.h> // Hypothetical header file
  void init_gpio(void) {
      // Example: Set Port B pin 0 as output
      DDRB |= 0x01; // Data Direction Register B, bit 0
      PORTB &= ~0x01; // Set Port B pin 0 low
  }
  

• Timer (TPU) Example (Simplified):
  • Configure TPU registers (base address usually 0x100000).
  • Use TPU_CONTROL to start a channel in output mode for PWM or timing.
• Interrupts:
  • Set up the Interrupt Control Module (ICM).
  • Write an Interrupt Service Routine (ISR):
    c

    void __attribute__((interrupt)) my_timer_isr(void) {
        // Clear interrupt flag
        INT_STATUS_REG |= TIMER_INT_FLAG;
        // Your interrupt code here (e.g., toggle LED)
    }
    

• Serial (QSM) for Debug/Output:
  • Configure Baud Rate, Data Bits, etc., in QSM registers.
  • Write a putchar function using QSM_DATA_REG for sending bytes.

Where to Find Routines & Info

• Vintage Microcontroller Forums: Microcontroller.com Forums
• GitHub: Search for MC68332, 68k embedded, 68332 C examples.
• Old Motorola/Freescale Sites: Look for legacy SDKs or application notes.
• University Projects: Search for "MC68332 lab exercises" or "68k microcontroller projects" on university sites (like the ESIEE link)

Regards

[TomE]

That's a very good answer. I get about 80% of that by typing the original poster's query into Google (so he could have started with that, or at least told us that he had already done that).

Google also found me this, which is very worth reading:

https://www.nxp.com/docs/en/application-note/M68331_332TUT.pdf

As well as telling me that this chip was originally made in the late 1980's. Let's say 1990. That's 36 YEARS ago! That's the same age as Tim Berners-Lee's invention of HTML and about 4 years prior to the Web being started anywhere. So no web back then, so nowhere to easily publish data sheets or software. Way back then, all we had were BOOKS. We read them from cover to cover and started coding. Fortunately the chips were simple enough that we could read all of them and pretty much understand the chip, unlike modern 5,000 page manuals that just list the registers and don't tell you what to do with them. The books also gave worked code examples.

So don't expect to find something like a Teensy or PIC Development System that you load onto a PC, plug in a cheap development board and go. Any development boards went EOL 30 years ago, and any development system makes necessary assumptions about what else is on the development board (RAM, EPROM and so on).

Do you want a project to blink a LED, run a full web stack from a hard disk, or something in between? The answer to that gives different solutions to whatever your project is.

I'd suggest asking Google "list of 68000 rtos" and then see if you can find something "complete" (compiler, samples, debugger drivers) in that list. Google finds eCos, RTEMS, FreeRTES etc.

Way back then we wrote the code, compiled and linked, generated a HEX file and then used an EPROM Programmer to burn the code into an EPROM (not EEPROM, not FLASH), then plugged that into the board and watched it fail. Then we had to erase the EPROM under a UV light and start again. We usually used a logic analyser to follow the instructions one at a time until we got the thing blinking a LED, then got it up to printing, then we used debug prints to debug the code. The MC68332 is one of the first chips to have a Debug Port (BDM), but then you have  to find a debug pod. You could start by searching PEMicro to see what they have to support it:

https://www.pemicro.com/forums/forum_topic.cfm?forum_id=8&forum_topic_id=4855

The above is from 11 years ago, and you need a "USB-ML-Universal FX" that costs US$600. Except it supported the M68K 11 years ago, but doesn't support it NOW. Why not? If P&E were to still support that chip, they'd need working systems in their labs to test against, and keeping 30 year old test rigs going (together with development systems and compilers and PCs running Windows 95 to run that on) is a very big ask where they wouldn't have any customers to pay for this work now.

A more recent question:

https://www.pemicro.com/forums/forum_topic.cfm?forum_id=8&forum_topic_id=8957

Tom