Home

Chameleon PIC User Manual Ver 1 ().

1. KEY MAKE BREAK KEY MAKE BREAK KEY MAKE BREAK A LC F0 1C 9 46 F0 46 54 54 32 32 OE INSERT 70 70 C 21 F0 21 4E F0 4E HOME 6C EO F0 6C D 23 F0 23 55 FO 55 PG UP EO 7D EO F0 7D E 24 F0 24 N 5D F0 5D DELETE EO 71 EO F0 71 F 2B F0 2B BKSP 66 F0 66 END 69 69 G 34 34 SPACE 29 29 PG DN E0 7A EO F0 7A H 33 F0 33 TAB OD F0 0D U ARROW 75 75 I 43 F0 43 CAPS 58 F0 58 L ARROW EO 6B EO F0 6B J 3B L SHFT 12 FO 12 D ARROW 72 72 K 42 42 L CTRL 14 FO 14 R ARROW E0 74 E0 FO 74 L 4B 4B L GUI EO 1F 1 NU 77 77 ALT 11 11 4 4 N 31 F0 31 R SHFT 59 F0 59 KP 7C F0 7C O 44 44 CTRL 14 14 7 7 4 40 GUI 27 27 79 79 15 15 ALT 11 11 5 5 2D 20 APPS 2F E0 FO 2F 71 71 S 1B F0 1B ENTER 5A F0 5A KP 0 70 F0 70 T 2 2 ESC 76 76 1 69 69 U 3C 3C F1 05 05 2 72 72 2 2 2 06 06 3 7 W 1D F0 1D F3 04 F0 04 KP 4 6B 6B X 22 F0 22 FA OC F0 0C KP 5 73 EO 73 35 35 5 03 03 6 74 74 2 1 1 F6 0B F0 0
2. a 205 27 0 CHAMELEON HANDS ON PROGRAMMING TUTORIALS AND DEMOS 206 27 1 Setup to Compile the Demos and Tutorials cscccscscsssssssssssscssscssscnscssccsccsecssccsscsssessscssssssssesssesecssecsseeseessecsscssessossscssses 206 27 1 1 Differences Between the MPLAB and Bootloader Demos 206 27 1 2 Setup tor MPLAB Version of Demos e nee e etie eU He repe teri epi be ree re eh 206 27 1 3 Setup for TextPad Bootloader Version of Demos 207 27 13 Setting the Chameleon Hardware Up oeste eee ee eiat REN e ee Ee e ee 207 28 1 Graphics DEMOS E 207 28 17D NTSC Printing Demo o nette died she os teased dee He E en Hare coe ete teet ree tet e d eases E rede eres 207 28 1 2 NTSC Glowing Top Bottom Overscan Demo 209 28 1 3 NTSC Smooth Scrolling Tilemap Demo 210 28 1 4 Printing s oto steer me te tcr SE RU oes cb be cb eden eed eere Mele berto de EE RUE ee 213 28 1 5 Dual NTSC VGA Printing Demo ottenere ert tet ttti etse vede rine eei 215 28 1 6 V GA Star Field Demo uento e Fre te i EUER ub Ie ns Eee D 216 j r M 218 29511 Sound D MO 5 T
3. 196 24 0 KEYBOARD LIBRARY MODULE PRIMER enne nnne nennen nn nnn nnne nnn 198 24 1 Header File Contents 198 24 2 API Listing Reference 199 24 3 API Functional Declarations csscssssscsscssscssssssscsssscessssssssesssesssssescessessossssensssssnesssssessossossosssssnessssnessesscssosssssnsssssnessesoess 200 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 25 0 MOUSE LIBRARY MODULE 201 25 1 A Brief Mouse Primer AE ENEE 202 25 2 Header File Contents 202 25 3 APL Listing SST SES EEs S ES rr EEr E SE aS S 202 25 3 API Functional Declarations sisaan aoaie a EEE TEETE EE A A EE A AS 203 26 0 PROPELLER LOCAL PORT MODULE 204 26 1 Header File Contents isdn reatie EEA AE EEE EEA ESES 204 26 2 API Listing Refetence 204 26 3 API Functional Declarations eiwir
4. Program Memory Origin 0 00 Length 0x14c00 section address length PC units length bytes dec text 0xc00 x3392 x4d5b 19803 const 0x3f92 0x26 Oa 5 dinit 0x3fb8 0x104 0x186 390 isr 0x40bc 0x2 3 Total program memory used bytes ju dob 720253 150 Data Memory Origin 0x800 Length 0x2000 section address alignment gaps total length dec nbss 0x800 0 0 10 268 ndata 0x90c 0 0x4c 76 118 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit nbss 0x958 0 ndata 0x95e 0 0x4 4 data 0x962 0 0x48 72 dconst 0x9aa 0 0x32 50 data 0x9dc 0 0x34 52 dconst 0 10 0 0 8 8 data 0 18 0 dconst Oxala 0 A 2 data 0 1 0 eee 17 Total data memory used bytes 0x21e 542 Dynamic Memory Usage region address maximum length dec heap 0 0 0 stack Oxale Oxlde2 7650 Maximum dynamic memory bytes 0 19 2 7650 ALL_DEV_STUFF Real Chamel eon C Code C BootLoader Bi nV Hel loWorl d pi c30 bi n2hex exe program cof ALL_DEV_STUFF Real Chamel eon C Code PI C BootLoaderBin HelloWorld gt FlashProg exe i COM20 program hex Reading Target Device ID Found C24H 128GP502 ID 0x067d Reading HexFile Reading Target Pcia ac MU ESTNE B comes us CRUS MIR NT S oe MIS TENDRE Done Tool completed successfully The key thing to look for is the Programming Device status and the
5. 8 data low8 data high8 Commands that only require 8 bits of data or operand only use the first data byte commands that require 2 bytes use both the low and high The bottom line is all commands only are 3 bytes so you can t send a string or something large you have to design your commands so they are simple and can be constructed with only 2 bytes of data at most Thus most commands are atomic in nature For example there is no print string command there is only a print character command but by stringing a collection of print chars together at the master client side you can print a string All the commands are designed with this in mind The drivers for each of the media devices were selected based on functionality and popularity There are definitely better drivers for many of the devices For example more robust graphics drivers or more advanced sound drivers etc However this default driver isn t about using the best but more about system integration Thus drivers that are easy to interface to and easy to control with a simply subset of commands where used In the sections below we will cover the exact drivers used but the point is they were chosen more or less for ease of use and user base 130 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 16 3 Another view of the complete system dataflow model CORE 1 1 AVRIPIC Processor SEE gt go
6. Version Control Find in Files Executing CAProgram Files Microchip MPLAB C30 bin pic30 bin2hex exe CACHAM PICiDemosYDemo cof Loaded C CHAM_PIC Demos Demo cof Debug build of project C CHAM_PIC Demos Demo mcp succeeded Language tool versions pic30 as exe v3 12 pic3 gcc exe v3 12 pic30 Id exe v3 12 pic30 ar exe v3 12 Preprocessor symbol _DEBUG is defined Sat Oct 17 00 51 26 2009 BUILD SUCCEEDED Eam s The output window displays the build status as shown in Figure 15 42 If all the files were added to the project properly the build window will indicate BUILD SUCCEEDED after a few seconds from when you choose Make The final output is a binary file we will now load into the Chameleon PIC 15 1 4 1 Loading the binary into the Chameleon PIC using the PICkit 2 If you purchased or already own the 2 hardware programmer you will use it now to load the binary hex file into the Chameleon PIC 16 Bit If you own a different programmer such as the MPLAB ICD 2 or the new MPLAB ICD 3 the steps are very similar however consult your user manual for proper directions 104 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Before we can load the binary into the PIC24 processor we must connect the programmer to the Chameleon PIC as shown in Figure 15 43 Notice that it requires use of the extra male right angle pin connector This is needed to interface the female PICkit
7. eese eee eee esses enean enses enses tensions tasto senses tuse sa estas enses ense nae 248 35 1 1 Chameleon BASIC by David Betz 248 35 12 Crate It by JT Cook sisi Ree RERO CHEER RR RENE RIDGE 249 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Epilog From Intel 4004 to the Multiprocessing Multicore Chameleon cassssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssesssssesesssesseees 249 APPENDIX A SCHEMAT G gend ede aac ded a even ada deua onn 250 APPENDIX B MICROCHIP PIC24HJ PINOUT nne nnne n nna n nnne nna a anna nnn 252 APPENDIX C BOARD LAYOUT AND HEADERS nennen nnn n anna 253 APPENDIX D USING THE PIC IN STAND ALONE nere nennen 254 APPENDIX E USING THE PROPELLER IN STAND ALONE MODE 254 APPENDIX F PORTING HYDRA AND PARALLAX DEVELOPMENT BOARD APPLICATIONS TO THE e d 255 APPENDIX RUNNING ON THE MAC AND 255 APPENDIX OVERCLOCKING THE PIC AND PROPELLER eene 258 H 1 Overclocking the Propeller Microcontroller
8. seta tuse tasse tasas enses ense nae 258 H 2 Overclocking the PIC24HJ Microcontroller eese tasas ta sesto sensns esa sse 258 APPENDIX I ASCII BINARY HEX OCTAL UNIVERSAL LOOKUP TABLES 259 APPENDIX J ANSI TERMINAL 261 Examples eder iege erbe Pe e 262 10 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 0 0 Introduction and Origins Welcome to the Hardware Programming Manual for the Chameleon PIC 16 Bit Development Kit This is a light hearted non censored no holds barred manual If you find technical errors or have comments simply write them down in a file and please send them to us at support nurve net or post on our forums and we will continue to merge them into this working document The document contains two main sections Hardware Manual This is a fast and furious circuit description of the Chameleon PIC 16 Bit Board s dual processor implementation around the Microchip PIC24HJ128GP502 and Parallax Propeller processors The PIC24HJ chip is 16 bit single cycle instruction in most cases supporting 16 bit math multiplication and division It has 128K of FLASH and 8K of SRAM We are running it at 40 MHz on the Chameleon The Parallax Propeller chip is used for media processing and runs at
9. 0 07 00000000000 20000000000 eee 9009090000000000 200000000000000 0 0000000000000 OI PD j Oaar ui Ow CO OOOO0CO00010 OQooooo0o0000020 The Chameleon PIC 16 Bit or simply the Chameleon PIC is developed around the Microchip PIC 16 Bit 24HJ128GP502 28 Pin DIP Figure 1 0 shows an image of the Chameleon PIC 16 Bit annotated The Chameleon PIC has the following hardware features 28 Pin DIP Package version of the PIC24HJ runs at 40 MHz Parallax Propeller multicore processor 32K RAM 32K ROM QFP 44 Pin package running at 80 MHz per core with 64K Byte serial EEPROM for program storage 2x required memory Video and Audio Out Ports HD15 Standard VGA Out Port Single PS 2 Keyboard and mouse Port Single 9V DC power in with regulated output of 5 0V 500mA and 3 3V 500 mA on board to support external peripherals and components the PIC24 and Propeller are at 3 3V Removable XTALs to support faster speeds and experimenting with various reference clocks Expansion headers that exposes I O power clocking for both the PIC and Propeller USB UART built in with Mini B connector 6 PIN ISP In System Programming interface compatible with Microchip PICKit2 as well as other 3 party programmers 1 MByte of SPI FLASH storage chip that can be used as local storage or a full FAT file system Break Away experimenter
10. 173 21 1 Header File Contents 174 2 2 1415 174 21 3 API Functional Declarations ssscccssscsscsssssssnssssssscessessesssssnessssnesccssessossessnssessnessssnescossssssossnessssnessessessossossnssessnessesooss 174 22 0 GFX LIBRARY MODULE PRIMER oc icisccisseseccseeetsacescrsnsesuendewcdsasdesncusndeacducedeanenandecddewndessaneeaees 176 22 1 GFX Driver Architectural Overview eee ee eee esee ee sesta atten sten 177 22 11 GFX Driver Register Interface ne erp ere on RR RD HIERHER EE E ETUR EE De ERU rire ER Ep Eurer ba 181 22 2 Header File Contents 182 22 3 API 6 185 22 4 API Functional Declarations assornir aidien rn er ai 186 23 0 SOUND LIBRARY MODULE 195 23 1 Header File Contents Overview eee ee eee eese sees eene tesis thats tassa tuse tasse ta EES Sensoa s eta sene ta sene oeio oos sosta senes tns en 196 PA 93 MS BEI RELL ONCE mA ER M 196 23 3 API Functional Declarations eese
11. 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 28 3 NTSC smooth scrolling demo ii 3 39 gt 49 oe gt f se sos L JE um EE LI EM NN Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description NTSC version smooth scrolls array of space invaders Main Source File CHAM PIC NTSC SMOOTH SCROLL DEMO 901 C Additional Files Required CHAM PIC SYSTEM V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC NTSC DRV V010 c h CHAM PIC GFX DRV VO010 c h General Requirements Video port connected to NTSC TV monitor Controls Required None Technical Overview This demo uses the vertical scroll register to scroll an array of tiles space invader characters up and down If we wanted to we could scroll the image continuously by course scrolling after each smooth scroll thru the scanlines 0 7 of each character Below is an excerpt that shows the space invader rendering code and the smooth scrolling main loop NTSC ClearScreen basic white NTSC Color 0 d aw a matrix of space invaders with extended characters y20 y lt 6 yet X 0 x lt NUM SPACE I NVADERS PER ROW x wir ior f or position next invader NTSC_SetXY x 2 SPACE I NVADERS ORIGIN X 2 SPACE I NVADERS ORI GI N Y draw next invader NTSC Term Char SPACE NVADERS CH
12. Keyboard Unload Function Prototype int Keyboard Load void Description Keyboard Load simply loads the keyboard driver into a core on the Propeller If a keyboard driver is already running this function will have no effect Returns 1 Example s Start the keyboard driver Keyboard Load Function Prototype int Keyboard GotKey void Description Keyboard GoiKey tests if a key is available for reading returns 1 key ready 0 no key ready Example s Test if a key has been pressed 200 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit if Keyboard Got Key 1 do something E HE ena T Function Prototype int Keyboard Key void Description Keyboard Key reads the next keycode out of the keyboard buffer returns 0 if no key is available Example s Read the key out of the queue and do something if Keyboard GotKey read key key Keyboard Key do something with hey Il end if key ready Function Prototype int Keyboard State int key Description Keyboard State tests if keycode key is depressed 1 or released 0 and returns the values Example s Testif right arrow is down test for scancode right arrow if ODE 0xC1E6 do something i Pb end li 25 0 Mouse Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on
13. Read reads the pins of the input port that are set as inputs pins set as outputs are invalid Returns the pin data Example s Setthe port to all input and read the port PropPort SetDir 0x00 inputs PropPort Read Function Prototype int PropPort Write int data8 Description Write writes data8 to the port I Os that are set as inputs ignore the bits in those positions Returns 1 Example s Write the binary patterns for 0 255 on the port at 10 millisecond intervals PropPort SetDir OxFF for dae lt 0595 PropPort Write data DELAY MS 10 I end for data 205 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 27 0 Chameleon Hands On Programming Tutorials and Demos Either you spent the past couple days reading up to this section or you cheated and skipped here No matter how you got here finally it s time to see some actual code and the Chameleon PIC 16 bit in action First some ground rules Every tutorial was designed to show off some aspect of the Chameleon PIC s hardware or a particular library Tutorials are not designed to be mind blowing or amazing they are designed to show you how to use each system and are very simple to get you started Chameleon s API is far from bug free There are probably lots of little bugs that haven t found so beware However the APIs don t really do much
14. ii n HH Aust TX 78732 Te 5122062209 Fax 912 206 0599 ausporttearve net i H i i 29 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit WwWw CHAMELEON DEV COM m sti AVMY JVIZ NOITINWNVH ONI LEY AEE AS INI QND UIA 155 855514 SO EU gu LU AY o o w o w e N PE IA CIE 4 atJ Pa 1 2 2 cae FLASH a Bins 2014 2 1 DIGITAL ET S D 06 Da 04 2 R31 PROP PORT 6 SPI Mix ca i LIE 2PROM 8 PROP OFP 44 E AMELEON PIC 16 19 12 11 10 9 14 A 1 Pritt bea VID AREF GND 013012 011010 09 4 g 7 ca WR are DIGITAL 1 05 TX GEL RESET MIN I EF SB 9 1 ZV DC TP 30 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 2 0 5 0V amp 3 3V Power Supplies Figure 2 1 The Chameleon PIC power supply design VIN 5 0V 500 mA Main Supply U1 TITLV1117 50 PWR IN 9 12V 0 1uf Tantalum 33vCC GND yw LED 3 3V 500 mA Main Supply Main Power Switch and Supply Summer U2 sw TITLV1117 33 PWR SWITCH R1 330 5VCC REG 012 USB 5VOUT GND The Chameleon PIC system has a duel 3 3V 5 0V power supply system that is feed by a single 9V DC unreg
15. now add 1 ES the upper 4 bit nibble allow wrap around rather than clamp on color so 15 gt 0 Color color 4 L lt 4 y write it back ottom Overscan Color color Function Prototype int GFX Set Top Overscan Oolor int col Description GFX Set Top Overscan Color sets the top overscan color to col where col is in normal Propeller color format chroma 4 bit chroma enable 1 bit luma 3 bit Returns 1 Example s Read the current color and increment the chroma portion of the color upper 4 bits 1 retrieve the color int color GFX Get Bottom Overscan Color now add 1 to the 4 bit nibble allow wrap around rather than clamp on color so 15 gt 0 color color 1 lt lt finally write it back GFX Set Bottom Overscan Color color 23 0 Sound Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media drivers all the API functions do including the sound is expose some of the base
16. packet is only 3 bytes But let s keep exploring the general idea of RPCs and some strategies that might help you later as you update modify the default drivers shipped with the Chameleon 16 3 1 ASCII or Binary Encoded RPCs When designing an RPC system you can make it really complex or really simple The main idea is that you want to be able to call functions in another process processor machine Decisions have to be made about the RPC protocol and how you are going to do things There are no rules for RPC calls unless you are using a Windows Linux Sun etc machine and want to use one of the official OS s RPC call APIs When you design your own RPC protocol it s up to you In our case it s tempting to make RPC calls ASCII based and human readable This of course eats bandwidth and is slower than binary However since it is human readable the RPC calls take a format that look more like commands rather than strings of bytes representing data Thus one model might be to use ASCII format which would be easy to use and remember for a human Now the next step up would be to still use ASCII formatted data that is human readable but to make it more abstract For example instead of having a command like this NTSC Print Hello We might encode NTSC as a single number and the command Print as another number and then the Hello would stay as is 25 0 Hello As you can see this version of the ASCII protocol is much sma
17. 64 12 2 5 Em 66 12 2 6 Reading Mouse Movement ncc ee Ie i e SEE Rer ete o Pec 66 13 0 THE V O HEADERS iaiia 67 14 0 AUDIO HARDWARE ew mc id D CX RR Fu sw DX Rv 69 14 1 A Little Background on Low Pass Filters EE stuff ecce e eee sees etes ette enses etna sense tuse ta seta sete sete aetas sense ena 70 T4 T 1 Pulse Code Modulation etie tet ci ie tet at a ede tete te Droite pen 71 14 1 2 Frequency Modulation Pe EON er RSS 72 14 1 3 Pulse PWM ja hte ete D e RE 72 15 0 INSTALLING THE TOOLCHAINS MPLAB TEXTPAD AND PROPELLER IDE 79 15 1 MICROCHIP S MPLAB IDE TOOLCHAIN 79 15 1 1 Installing MPLAB IDE 8 xx Optional ssscssssssssssssssssscsscssssscsssnsssssnescesesessssessnessssnescessessssessnssesssessessessessessnessssneseesooss 81 15 1 2 Installing the PICkit2 Hardware and Software Optional sesessossesoosseseosoesessossesoessescosoesessossesoessesoesoesessossesoossesoessesessosseses 85 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 15 1 3 Installing Microchip s MPLAB C compiler for PIC24 MCUS ssssssscsssssssssesenssssnsscssssssessssssesssssesscssessssssssessssneseesooss
18. 218 30 1 Device 220 30 11 Keyboard Demo x tetro temere 220 30 1 2 Mouse ASCH Paint Demo a eret te 222 31 1 Serial FLASH and Port Device Demo ssscccsssssccccsssscccssscccsssscccessssccesnssscesssacccessnaccsessceccssacccessnsccscssceccsssscecessnaes 224 30 1 1 Propeller Local Port LED Blinker Demo itte n mte ttt Rei e i ee re Rr nie 225 31 12 Serial RS 232 Communications 227 31 1 3 FLASH Memory Demo with XModem Protocol Bonus Example eese nennen 232 X Modem Protocols reai heh erede quiere dinem e iet etie cie ipee e 233 Sending X Modem Files from the PC e nenne tree thee then tren nenne enne enne n rennen nenne ten oe a teen teen entente nennt 237 UABTrUHAUnn 242 33 1 Developing Your Own Propeller Drivers eese eese eene eee ee nete neta etta stats toss tone ease ease ease ta seta sete stesse sesso s seas seas e eaae en 242 33 1 1 Adding SPIN Driver Support for the Status LED 244 31 1 2 Adding PIC Support at the Client Master Side sss ener trennen trennen eren enne 246 34 1 Advanced Concepts and Ideas PR Ssss 248 35 1 Demo Coder Applications Games and Languages
19. e B RESn 33M CC Sere NID WAIN SRI 551 01919191919 i IOC SPI SSOn 91019 2 L Referring to the figure there are two 8 pin I O headers on the bottom of the board A single 16 pin header on the right and finally the 8 bit Propeller local port The Propeller local port is discussed elsewhere so let s concentrate on the other 3 headers First off on the Chameleon PIC version specifically we tried to match the Chameleon AVR which is similar to the Arduino signal names to the same pins so programs written for Chameleon AVR and Arduinos that use digital I O would work with little modification Similarly we used the same naming conventions for the signals such as Dn for digital I Os and AINn for analog inputs However the Chameleon PIC does not quite have the same number of analog inputs and so substitutions had to be made and a few extra signals mostly on the larger 16 pin header on the right have been added Signals such as the multiple power sources as well as the SPI multiplexer chip selects SPI SS1n and SPI_SSOn respectively and D14 and repeat of D8 Figure 13 2 below illustrates the electrical design of the headers themselves laid out as they are on the PCB 67 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 13 2 VO headers electrical design J7 GND GND RESn 33VCC 5 5VCC 1 GND 3 GND Arduino Compatible I O VIN CONN SIL8 J6 SP
20. infinite loop t on VGA terminal screen On Oy m_Print Hello World slow thi DELAY MS 10 h I end while ie down a bit so we can read the text I end main First it should be amazing to you that in a few lines of code you are generating a VGA color text display Reviewing the code the program starts waits for the Propeller to boot don t forget to do this then the call to clear the screen and we enter the main while loop Here a redundant call to set the color is made and the text is printed to the VGA terminal with VGA Term that s it Summary This demo shows how easy it is to get VGA terminal like text output going on the Chameleon 214 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 28 1 5 Dual NTSC VGA Printing Demo One of the cool things about the NTSC and VGA terminal tile drivers is they have the exact same base features Which means that porting your code to work on NTSC or VGA is usually a matter of changing API prefix function names from NTSC to VGA and vice versa Of course the advanced gaming tile engine support is only for the NTSC driver however no one is stopping you from using or making a more advanced VGA driver on the Propeller simply choose not to this time around In any case this demo is just a Hello World demo that prints both on the NTSC and VGA monitors at the same time to show you how easy this is Figu
21. All the required files can of course be found in the Source directory on the DVD which you should have already copied onto your hard drive located here DVD ROM CHAM SOURCE 30 1 1 Keyboard Demo This demo uses the keyboard API to communicate with a local PS 2 keyboard plugged into the PS 2 port via the Propeller s keyboard driver Make sure to plug your keyboard into the Chameleon and get a good connection and make sure the lt NUM LOCKs etc keys are released and not in the down position The demo prints keys on the screen as you hit them along with their codes Also the demo has a little bit of fun code it has a little password finder The program has a state machine that is hunting for the token morpheous from the movie The Matrix if you type this in lower case the program will print something out Figure 30 1 shows the demo in action 220 Figure 30 1 Keyboard demo in action Press keys on local keyboard Key Code Welcome NEO ficcess Granted Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Echos the local PS 2 Chameleon keyboard to the displays Main Source File CHAM PIC KEYBOARD DEMO 01 Additional Files Required CHAM PIC SYSTEM VO010 c h CHAM PIC I2C SPI DRV VO10 c h CHAM PIC NTSC DRV VO010 c h CHAM DRV VO010 c h CHAM PIC KEYBOARD V010 h General Requirements Video ports connected to NTSC or VGA monitors
22. Controls Required PS 2 keyboard plugged into Chameleon simply type into the keyboard and watch the output on the NTSC VGA displays Technical Overview 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit This demo uses the single keyboard API call Keyboard Key to read the keyboard It then displays the key using both integer as well as ASCII format The listing below is an excerpt of the main program int main run over and over again int key key that keyboard returns char printing buffer fi k reClock first Always call Confi gu M X FCY RATE 11 SYS_ConfigureCl oc jalize SPI HOF ive Pr _ MS 11 SPI opeller driver time to boot 250 Clear screens C ClearScreen _ClearScreen MISC col of Color 0 Term Print 05 2 Keyboard Demo Char 0x0D ll se NTSC_ NTSC_ NTSC_ NTSC_ NTSC Term Char 0x0D set VGA color VGA_Color 0 VGA Term Char 0x0D VGA Term Print Press keys on local keyboard erm Print Press keys on local keyboard 221 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit VGA_Term_Char 0x0D 1 load keyboard driver this driver is already loaded by default but this call can t hurt Keyboard Load enter infinite loop e read next key return 0 null if no key wait for key press while key Keyboard Key 0 build display string i
23. Since PIC processors have become very popular globally there are also many different third party tools compilers and programmers For the sake of keeping all of the software tools consistent we are going to stick with the Microchip line of products In that regard we will also be using a C compiler and Assembler provided by Microchip that is specifically made for the PIC24 processors The PIC24 assembly language tool chain is called ASM30 The C compiler is called C30 but with recent changes to the naming conventions by Microchip we have a new name PIC24 C compiler Regardless of the name the fact remains that we will be using a command line compiler and assembler that integrates into the MPLAB IDE environment This all becomes very seamless and we will cover the installation procedures shortly The IDE contains projects that are composed of Assembly files C files object files library files and linker scripts The working method is to write all of your code in MPLAB and then compile and assemble it using the ASM30 and C30 compiler we setup and then use a device programmer to erase program and verify the flash memory on the PIC24 MPLAB allows in circuit debugging capabilities as well as processor simulation Debugging the hardware PIC24 chip requires a debugging capable programmer A inexpensive programmer with this ability is the PICkit 2 In circuit Serial Programmer ISP that can be purchased separately In addition to hardware debuggin
24. nennen 120 15 3 1 Launching the Propeller Too eee creiss eren teen eine tn sesso seen sns ta sensn sesso sees suse 123 16 0 CHAMELEON INTER PROCESSOR ARCHITECTURE 127 16 1 Master Control Program RR 128 16 2 Selecting the Drivers for the Virtual Peripherals scsscsscsssssssssssssssssscessssssscsssnessessescesssssesssssnesssssessesscesesssssnessssnesseses 130 16 2 1 Complete Data Flow from User to entren nr 131 16 3 Remote Procedure Call Primer Theory 4 e eee eee eee ee ette ee ense eaae setas tees ea et aos eS eese e en 132 16 3 ASCIL or Binary Encoded oett E ete Pet ede tete te pere e PIRE P EIU aeree Ee reete 133 16 3 2 Compressing RPC for More 4 1410 134 16 3 3 Our Simplified RPC Strategy dee Ree eon shed deed Lace EE UE Rae see ET e ieee 134 16 4 Virtual Peripheral Driver Overview scscssscsscsssssscssssssssscscescsssescsssnsssessescosesssnssessnssseseossessesssscossnessssnessessessossossnessesseseeses 135 16 4 1 Normalization of Drivers for Common RPC Calls in eene eene nennen enne innen tenerent en 136 1
25. oO Arb 0 2 mO OIE 0 2 mO oO 47 rb LUPO 6750 2 6750 1 aL wO O 5750 O 0 0 a ror mf O wO I AJTOT Q 9 1 o E ii HO 0 O HA gt OG7E0e ZOT O 0 gt O m GOT HO HA AJTOT O 0 wO ab x La O 0 oO 0 9 T 0 TT 9 ba LR LOT mO wf 10 eTa Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description NTSC version prints Hello World to screen Main Source File CHAM_PIC_NTSC_PRINT_DEMO_01 C Additional Files Required CHAM_PIC_SYSTEM_V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC DRV VO010 c h General Requirements Video port connected to NTSC TV monitor Controls Required None Technical Overview The demo simply uses the NTSC API to print Hello World on the screen When the printing reaches the bottom of the screen the terminal scrolls the screen image up one line The program is so short let s take a quick peek at only the contents of main ALIE RENE EEE CCE A A A A n mai n voi d 11 call ConfigureClock first SYS ConfigureClock MAX_FCY_RATE I initialize SPI SPI Init 11 give Prop a momen
26. 3 77 us HSync pulse C 1 89 us Back porch 25 17 us Active video time 0 94 us Front porch As you can see even the names are similar to NTSC However unlike NSTC VGA is very unforgiving you must follow the spec more closely otherwise the monitor s will typically ignore the signal The next interesting thing is that all the signals are riding on different lines For example the hsync and vsync both have their own signal lines and the R G and B signals do as well so it s much easier to generate all the signals in a large state machine and then route them to the output ports as a single byte wide stream of data Therefore to generate a line of video with a negative sync polarity you start by turning off all the R G B channels with a 0 0V and simply hold the hsync line LOW for 3 77 us B then you wait 1 89 us C and the VGA is ready to take B data now you clock out 640 pixels at 25 175 MHz for a total time of 25 17 0 for the active video portion You then turn the video lines R G B off and wait 0 94 us E and then start the process again And that s all there is too it Perform this process 480 times then it s time for a vertical sync and retrace let s look at that 10 3 2 VGA Vertical Timing The vertical sync and retrace is much easier than the horizontal timing since there is no video to interleave in the signal Referring to Figure 10 3 c the various named timing regions of th
27. Function Prototype int UART_gets unsigned char Data Parameters Data A buffer to store data in that includes the carriage return It must be as large enough to hold the string Potential buffer overrun Return Returns the actual amount of data read including the carriage return Description UART gets is a copy of the C stdio gets function The purpose is to read a string up until the carriage return from the UART Since a user may type in an extremely long string there is no way to know how big to make the Data buffer so this could become problematic Example s This example shows a simple usage scenario unsigned char ReadBuf 256 UART_puts Pl UART_gets Rea UART printf enter your name r n name is 95 that s a funny name r n ReadBuf Function Prototype int UART getchar unsigned char ch Parameters ch A pointer to receive a single byte character Return Returns 1 if there was data assigned to ch otherwise 0 Description UART getchar fills a single character into the passed in destination If the assignment takes place the function returns 1 otherwise it returns 0 meaning no data available Example s This example shows a simple usage scenario headers and globals go here int main void unsigned char ReadVal ue call SYS ock first after main begins SYS_ConfigureClock MAX_FCY_RATE Configure clock for max code goes here
28. The API listing for the NTSC module CHAM PIC NTSC DRV V010 c is listed in Table 20 1 categorized by functionality 170 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 20 1 NTSC module API functions listing Function Name Description On ee Dae o Printing E es int NTSC Term Char char ch Prints a single character to the terminal at the current cursor position int NTSC Term Print char string Prints a NULL terminated string to the terminal int Oolor int col Sets the color of the text int NTSC GetXY int x int y Gets the current cursor position on the terminal int SetXY int x int y Sets the current position on the terminal i The following lists each function a description comments and example usage of the function Function Prototype int NTSC_ClearScreen void Description ClearScreen simply clears the NTSC terminal screen and fills the screen with spaces Returns 1 Example s Clear the screen NTSC_ClearScreen Function Prototype int NTSC_GetXY int x int y Description GetXY returns the position column row of the virtual cursor Depending on the driver you are using the values have different possible ranges For the Default2 driver they are 0 31 0 23 The function takes two pointers to t
29. X 2F pP 30 0 59 pA 3B 3C lt Ps 3D a gt e 3F 40 WU Vm aou 11 5B 5C 11 5 tt 5E 77 5F 60 lt p Mu IA Beso 78 t 59 70 n 7E So when you read a key from the keyboard driver its these keycodes that are going to be translated for you into ASCII The API listing for the Keyboard module CHAM_PIC_KEYBOARD_DRV_V010 c is listed in Table 24 1 categorized by functionality 199 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 24 1 Keyboard module API functions listing Function Name Description Keyboard Driver Control int Keyboard Unload void Unloads the keyboard driver on the Propeller int Keyboard Load void Loads the keyboard driver on the Propeller Keyboard Reading Functions int Keyboard GotKey void Tests if a key is queued up int Keyboard Key void Reads the next key from the queue int Keyboard State int key Tests if a particular key is down The following lists each function a description comments and example usage of the function Function Prototype int Keyboard Unload void Description Keyboard Unload unloads the keyboard driver the Propeller and frees up a processing core Typically you will make this call before loading the mouse driver or to simply free a core for another process Returns 1 Example s Unload the keyboard driver to save power
30. Additional Files Required CHAM_PIC_SYSTEM_V010 c h CHAM PIC I2C SPI DRV VO10 c h CHAM PIC UART DRV VO010 c h CHAM PIC NTSC DRV VO010 c h CHAM DRV VO010 c h CHAM PIC KEYBOARD DRV V010 c h CHAM PIC FLASH DRV VO010 c h General Requirements NTSC display connected local PS 2 keyboard connected X Modem download program running on PC N81 2400 baud Controls Required Local PS 2 keyboard simply use menu also PC running X Modem uploader Technical Overview The program is probably the most complex of all since it has to do so much We need a NTSC VGA menuing system that allows the user to enter menu options then we needed the X Modem function to receive files which is a project in itself and finally the FLASH memory call to display and save the FLASH data So a lot of parts but with a little imagination you can use this program as the basis of a MP3 or video player You can download files into the FLASH with the X Modem function then write code that decompresses video or audio and presto Anyway we have already seen the X Modem receive file listing earlier in the overview and the complete program is rather long too long to list Therefore am just going to verbalize the FLASH aspect of the program Forgetting about the X Modem support accessing the FLASH memory is trivial with the API all you need to do is call Flash Open then you can read data with the Flash Read function When
31. Copies numbytes from src dest in wordsize chunks wordmove ile dest addr parm tile src addr parm tile numbytes parm GFX SUBFUNC FILLMEMI6 1 Fills memory with datal6 2 bytes at a ti me wordfil ile dest addr parm tile datal6 parm tile numbytes parm gt gt 1 GPU GFX SUBFUNC COPYMEM8 2 Copies numbytes from src gt dest in byte size chunks bytemove ile dest addr tile src addr tile numbytes parm gt gt 1 GFX SUBFUNC_FILLMEM8 3 F s memory with low byte of datal6 1 bytes at a ti me bytefil ile dest addr parm e datal6 parm amp FF tile numbytes parm We will see how to call all these in the API section below but the point is want you to see the big picture and see how all this stuff works not so much so you can use it but so that you might use this template model or pattern to create better faster drivers In any event when a message is sent with GPU GFX SUBFUNC STATUS W then we assume that a GPU command is being issued and the first data byte of the SPI message is used as the sub function ID lower 8 bits and the upper 8 bits or second byte is used as the operand or data Now the GPU functions are too complex to request in a single SPI message so we have to set them up Thus we have to initialize pointers to the source destination and length of bytes or words to process then we call the GPU command to actually do the work For example the sub function GPU GFX SUB
32. D__DEBUG g Wall 117 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit g Wall me m Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key ALL_DEV_STUFF Real Chamel eon PI C Code BootLoader Bi nV Hel oWorl d gt pic30 gcc exe mcpuz24HJ 128GP502 x c c CHAM PIC GFX DRV V010 c o CHAM_PIC_GFX_DRV_V010 0 D DEBUG g Wal Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key ALL_DEV_STUFF Real Chamel eon PI C PI C Boo Loader Bi He loWorld gt pic30 gcc exe mcpuz24HJ 128GP502 x c c CHAM PIC UART V010 c o CHAM PIC UART DRV V010 o D DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disable
33. PIC24HJ256GP206 lt lt oabsabIP dcnovzc 1 mm Now we need to create a blank project for the PIC24HJ128GP502 To do this launch the Project Wizard by clicking on the menu item Project Project Wizard as shown in Figure 15 27 95 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 28 Welcome screen of the project wizard Project Wizard Welcome This wizard helps you create or configure a new MPLAB IDE project To continue click Next The Welcome screen can be viewed in Figure 15 28 Click on the lt Next gt button to continue onto the device selection screen Figure 15 29 Device selection dialog Project Wizard Step One Select a device Device PIC24HJ128G3P502 Figure 15 29 shows the device selection dialog with a single drop down list to select your PIC processor Click on the down arrow and choose PIC24HJ128GP502 Then click Next to advance to the language toolsuite 96 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 30 Select a programming tool Project Wizard Step Two Select language toolsuite Active Toolsuite Microchip C30 Toolsuite Toolsuite Contents MPLAB ASM30 Assembler pic30 as exe MPLAB C Compiler pic30 gcc exe MPLAB LINK 30 Object Linker pic30 Id exe IR 2f drehiver nie Q ar evel Location C Program Files Microchip MPLAB C30 bin pic30 as exe Hel
34. back characters received g _getchar amp ReadVal ue put char ReadVal ue Echo it back 150 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype int UART_putchar int ch Parameters ch A single character to write out of the UART Return Returns 1 if the data was added to the send buffer to be sent If the output buffer is full and the define STALL_UART was not defined this function returns 0 for failure Description UART putchar adds a single byte to the send buffer If the send buffer is full and stalling is not enabled the function returns immediately with failure Example s This example shows a simple usage scenario headers and globals go here int main void unsigned char ReadValue i gur igureClock MAX_FCY_ 11 DS call SYS Confi SYS Con eClock first after main begins RATE Configure clock for max code goes here back any characters received getchar GReadval ue put char ReadVal ue Echo it back Function Prototype void UART Newline Parameters None Return None Description UART Newline adds a single byte to the send buffer If the send buffer is full and stalling is not enabled the function returns immediately with failure Example s This example shows a simple usage scenario headers and globals go here int main void unsigned char ReadVal ue Always call SYS Configur
35. 0D return carriage return and linefeed Example s Clear the screen then print Chameleon NTSC Term Char 0x00 rec veri 67 NTSC Term Char h NTSC Term Charl a NTSC Term Char NTSC Term Char e rec vena l ya NTSC Term Char e NTSC Term Char NTSC Term Char Function Prototype int Term Print char string Description Term Print prints a NULL terminated string to the screen with automatic scrolling etc if the string prints off the right of the screen or bottom of terminal Returns 1 Example s Print the string Hello World to screen NTSC Term Print Hello World 172 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype int NTSC_Color int col Description NTSC_Color sets the color of the text and background depending on driver The col parameter should be from 0 7 and selects one of a number of different foreground background color schemes for the characters printed This function has different behavior between the Default1 driver and the Default2 driver The Default2 driver is more for graphics and gaming and thus the idea is to control the color more directly with palette manipulation Returns 1 Example s Print the character X in all colors int index for index 0 index lt 8 index NTSC Color ind
36. 10 2 79 us approximately Back Porch Immediately following the color burst is the final part of the setup for the actual pixel data this is called the back porch and should last 1 6 us 11 2 6 Generating B W Video Data The remainder of the video information is 52 6 us this is where you insert your pixel data Now if you wanted a B W only signal then you would modulate the video signal from BLACK 0 3V to WHITE 1 0V for the remainder of the line and be done with it For example each line could rasterize a line buffer or a sprite and different values would map to different voltages from BLACK to WHITE With this approach most TVs have an input bandwidth wide enough to display about 320 luminance changes per active line that means that no matter how fast you try to change the luminance signal only 320 times a line will you see anything Let s see how we roughly estimate this The line length is 52 6 us we want to make 320 changes in that time that means that we need to send data at a rate of 52 6 us 320 164 375 ns per change Inverting this gives us the frequency which is 1 164 375 ns 6 0 MHz roughly Ouch that means that the input to the TV s luminance has to be 6 0 MHz or greater Sorry to say it s not In most cases you are lucky if you get 4 5 5 0 MHz input bandwidth this 320 is a definitely upper limit on B W luminance transitions per line 11 2 7 Generating Color Video Data Generating color vid
37. 11 2 6 Generating B W Video D ta eset eo eere side Jodha subs tebe 55 11 2 7 Generating Color Video RE 55 11 2 8 Signal References iic te erede ede ete tete eee 55 12 0 KEYBOARD amp MOUSE HARDWARE ccn sni eias sace aadu o LO quiu nnmnnn nne 56 12 1 Keyboard 57 12 1 1 Communication Protocol from Keyboard to Host essent nennen trennen rennen eere tenete tene 58 12 1 2 Keyboard Read Algorithm ict tre eere p cie epe t a e 59 12 1 3 Keyboard Write Algorithm icit etre e e EET e IRE CAD tr ror eei eerie 59 12 1 A Keyboard Commands tnc ce eR RR THERETO CREE ERR EE Or RHET e Re I DER 60 12 2 Communication Protocol from Mouse to Host eere eee esee ente enses tata atat ta tasse 61 12 2 1 Basic Mouse Operation meto Ro PU ER eti euge ater t DI aec Gs Aus beet ese HEUTE 62 12 2 2 Mouse Packets ride eee e eO RE De EAE e RERUM Eee use ear ivan see e PEE 62 12 2 3 Modes Of Operation ecce ette e eit ere He npe bets de tk eb e 63 12 2 Sending Mo se Commiands IT eU e tee eerte eiue DEEL ehe
38. 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit allows you to draw with the mouse The right mouse button changes the ASCII drawing character and the left mouse button clears the screen The program displays simultaneously on both the NTSC and VGA displays Figure 30 2 shows the demo in action Figure 30 2 Mouse ASCII Paint demo in action PS 2 Mouse Test ChamPaint Left button to clear screen Right to change cursor x Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Draws on the screen with the mouse using ASCII art Main Source File CHAM PIC MOUSE DEMO 01 Additional Files Required CHAM PIC SYSTEM VO010 c h CHAM PIC I2C SPI DRV V010 c h CHAM PIC NTSC DRV VO010 c h CHAM DRV VO010 c h CHAM PIC MOUSE DRV VO010 h General Requirements Video ports connected to NTSC or VGA monitors Controls Required PS 2 mouse plugged into Chameleon draw ASCII art with the mouse Left button to clear the screen right button to cycle thru different drawing characters Technical Overview This demo uses the Mouse ReadQ call to read the state of the mouse it uses this to allow you to draw the NTSC VGA screen with ASCII art characters The main while loop within the main itself is shown below this is where all the action happens main event loop whi e 1 EE read the mouse event if one Mouse Re
39. 27 55 26 ANS RP15 CN11 PMCS1 RB15 25 ANTU RTCC RP14 CN 12 PMWR RB14 24 ANTI RP13U CNT3 PMRD RB13 23 AN12 RP12U CN14 PMDO RB12 22 PGC2 EMUC2 TMS RP11 CN15 PMD1 RB11 21 PGD2 EMUD2 TDI RP10 CN 16 PMD2 RB10 20 VCAP VDDCORE 19 Vss 18 TDO SDA1 RP9 CN2 1 PMD3 RB9 17 TCKISCL1 RP8 CN22 PMD4 RB8 16 _ INTO RP7 CN23 PMDS RB7 15 PGC3 EMUC3 ASCL1 RP6 CN24 PMD6 RB6 252 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix Board Layout and I O Headers This appendix has a high resolution grayscale image of the Chameleon PIC s PCB so you can identify the header I O pins easily for your projects WWw CHAMELEON DEV COM m 11 AUMY NOATIANVAD 154 AS INDINDYIA 155 955 17 EY ZY LY dg Ps 1 a Brus 2 2 2 C14 EE 9 i q Als P27 24 P4 P3 P8 P1 PO PROP PORT R31 6 nea E2PROM DO 04 01302 01 AMELEON PIC 16 aFP44 29 6n n TX SEL RESET WR ote DIGITAL VOs AREF CNO 013012 011010 D9 IL E 0 6 16 MINI UFSGB 9 12V 253 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix D Using the PIC in Stand Alone Mode The nice thing about the Chameleon is that it s two systems in
40. After receiving the sample rate the mouse again responds with acknowledge FA and resets its movement counters Most mice accept sample rates of 10 20 40 60 80 100 and 200 samples sec 64 2 9 8 7 E6 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Get Device ID The mouse responds with acknowledge FA followed by its device ID 00 for the standard PS 2 mouse The mouse also resets its movement counters in most cases Set Remote Mode The mouse responds with acknowledge FA then resets its movement counters and enters Remote mode Set Wrap Mode The mouse responds with acknowledge FA then resets its movement counters and enters Wrap mode Reset Wrap Mode The mouse responds with acknowledge FA then resets its movement counters and enters the mode it was in prior to Wrap mode Stream Mode or Remote Mode Read Data The mouse responds with acknowledge FA then sends a movement data packet This is the only way to read data in Remote Mode After the data packet has been successfully sent the mouse resets its movement counters Set Stream Mode The mouse responds with acknowledge then resets its movement counters and enters Stream mode Status Request The mouse responds with acknowledge then sends the following 3 byte status packet then resets its movement counters as shown below Bit 7 Bit 6 Bit 5 Bit
41. Category Session Options controlling local serial lines Logging Terminal Keyboard Serial line to connect to Bell Features Window Speed baud 115200 Appearance Behaviour Translation Stop bits Selection Colours Connection Flow control Data Proxy Telnet SSH Serial Select a serial line Configure the serial line Data bits Parity To launch the terminal program you would press Open which opens a new terminal window This is where you would type on the PC keyboard to communicate with the Chameleon PIC and run the demos or do serial terminal experiments 15 2 3 1 Running the Bootloader Tool We are all ready to go let s do a final checklist before we attempt to use the serial bootloader the tool in TextPad 1 You have the USB cable plugged into the PC and you have installed the FTDI serial drivers if needed 2 You have a 9V DC power supply plugged into the Chameleon optional 3 You have moved the serial select switch into the DOWN position so the USB serial port is connected to the PIC chip not the Propeller 4 You have the VGA and NTSC cables connected to the Chameleon as well as a mouse optional 5 You have configured TextPad properly using the correct COM port found in section 15 2 3 Finally we are ready to try an example Hello World project Navigate to the location where you copied the bootloader files onto you harddrive and open up the following file in TextPad CHA
42. Exploring the Chameleon PIC 16 Bit rint on NTSC terminal screen Teri Pile OM 4 e e e _Term_Char 0x0D turn on the LED pin 7 HIGH pin 6 LOW repeat pattern down port PropPort Write 0b10101010 slow things down a bit so we can read the text DELAY MS 250 print on NTSC terminal screen MSC wer Port Data NTSC Term Char 0x0D turn off the LED pin 7 LOW pin 6 HIGH repeat pattern down port PropPort Wite 0b01010101 slow things down a bit so we can read the text DELAY Ms 250 end while 11 end main have highlighted the port commands The program starts by setting the direction bits to all 1 s which mean output Then the program immediately enters into the main loop and starts toggling the I O pins on a 500ms total cycle The output is mimicked to the NTSC screen you can add support yourself with a few lines of code Just don t forget to add the library and header files to your program Now one thing you might wonder is how fast can I control these pins This is a good question since you might want to do something like talk to a SPI or I2C device So the real bottleneck is the SPI interface from the AVR PIC chip to the Propeller we can only send commands and thus toggle the I O pins as fast as this interface Thus if you want to do something more complex then suggest that you add commands and mess
43. InstallShield Wizard Complete The InstallShield Wizard has successfully installed MPLAB Tools v8 15 Before you can use the program you must restart your computer will restart my computer later Remove any disks from their drives and then click Finish to complete setup Figure 15 9 tells us that we have successfully completed the MPLAB installation It will question you whether you want the wizard to restart your computer or not suggest that you restart your computer because the MPLAB installer in addition to the IDE installs a number of environment variables along with device drivers for USB programmers one of which is the PICkit 2 that we will be using Now that MPLAB is successfully installed we will install the PICkit 2 hardware and software option 15 1 2 Installing the PICkit2 Hardware and Software Optional Now that MPLAB IDE is installed we can install the PICkit 2 hardware Installing the PICkit 2 programmer consists of nothing more than plugging it into your PC with a USB cable Go ahead and do this now as Once you plug it in the PC should detect it and begin the installation process The PICkit 2 is recognized by windows as a Human Interface Device and as such there is nothing more to do than wait until windows says The hardware has been installed successfully If you opt for installing the PICkit 2 programming tool then the first step is to launch the installation executable found at the
44. Keyboard tree item Go ahead and copy the serial bootloader files to your harddrive from the following folder DVD ROM cham pic tools bootloader BootloaderBin In this folder you can find the following files and folders e README txt Thorough explanation of the files contained in the folder e bootloader hex The actual bootloader that can be reload onto the Chameleon PIC using a tool like the PICkit 2 e bootable_p24HJ128GP502 gld Linker command script that reserves a region of free memory for the bootloader so that new compiled programs do not overwrite the bootloader CompileDownload bat DOS batch file that automates the compile and download process FlashProg exe DOS command line tool that opens the USB serial port connected to the Chameleon and sends the compiled binary file e HelloWorld An example application that includes all the Chameleon drivers and the Hello World main file that can be used as a Starting point in creating your own program Everything in this folder is self contained and has copies of the bootloader PC software Therefore you can copy it anywhere on your harddrive and simply modify rename the helloworld file for your own projects Go ahead and open up the CompileDownload bat The contents of the batch file is also displayed below pic30 gcc exe 24 128GP502 x c c L C NAC Sp uw WOM c PIC 12C SPI DRV V010 0 D DE
45. MPLAB ASM30 MPLAB C30 MPLAB LINK30 Categories Generate Command Line Optimization Level Specific Optimizations Unroll loops Omit frame pointer Procedural abstraction code size Pre Optimization Inst Scheduling Default for Optimization Level Post Optimization Inst Scheduling Defaut for Optimization Level v ng Restore Defaults g Wall 01 C Use Altemate Settings Next you must change the Categories drop down box and choose Optimization Upon changing the selection the lower half of the window changes and presents a number of optimization settings Later on you may want to play with some of these other settings but for right now we are only interested in the Optimization Level graph You choose the optimization level by clicking on the bubbles for 0 and 1 as highlighted in green for clarity in Figure 15 47 15 1 4 2 Final Words on MPLAB Toolchain Installation This completes our installation of the toolchain all its components and a complete example of building and downloading an application As we develop applications load demos and experiment you will only have to modify the source files in the project window to the left adding and subtracting source files The programming tool setup should be the same Thus the workflow moving forward will be to add subtract files from the Source Files folder of the same project then Build
46. Not Agree The final step is to agree to the license agreement as shown in Figure 15 13 Click the I Agree radio button and simply press Next to being the coping process 87 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 14 PICkit 2 programmer installation progress bar PICkit 2 v2 55 Installing 2 v2 55 MICROCHIP PICkit 2 v2 55 is being installed Please wait A progress bar is displayed during the copying and install progress as Figure 15 14 illustrates There is nothing to do at this point other than wait for completion Figure 15 15 Installation complete i amp PICkit 2 v2 55 Installation Complete AN MICROCHIP PICkit 2 v2 55 has been successfully installed Click Close to exit Please use Windows Update to check for any critical updates to the INET Framework The installation for the 2 programmers tool is complete You can click the Close button as shown in Figure 15 15 graphical user interface The installation for the Framework can be found in the PICkit 2 requires the Microsoft NET Framework 2 0 at this time to operate its N same folder as the PICkit 2 setup exe with the file name dotnetfx exe When you have finished installing the PICkit 2 programmer tool you may now plug in your PICkit 2 debugger hardware into any available USB port After the device has been enumerated you
47. Power On left You already installed the Propeller tool so all we have to do now is run the tool which is very simple The first step is to make sure that the PC recognizes the Chameleon and installs a virtual USB COM port When you connected your test Chameleon PIC to the PC via the USB cable and powered the Chameleon up the FTDI drivers on the PC should have detected a NEW USB port and assigned a COM port to it you can find the COM port in the system devices menu You will need this later for the serial communications test however the Propeller tool will autoscan all COM ports until it finds the Propeller chip connected to one With that in mind here are the steps to load the firmware into the Propeller chip you will do this for every Chameleon PIC and AVR in the final testing process Step 1 Launch the Propeller IDE tool by clicking the shortcut on the desktop Step 2 Navigate to where you copied the source directory files on your PC and open the master file cham default2 drv 111 spin It is located on the DVD ROM here DVD ROM CHAM PIC SOURCE PROPELLER DRIVER This is shown in Figure 15 63 ignore my slightly different hard drive paths 123 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 63 Loading the Propeller firmware into the tool Propeller Tool cham_default2_dryv_111 cham default2 drv 111 Text 010 010 keyboard 010 mouse 010 NS so
48. The function that actually sends the command is listed below this function is used to send SPI commands to the Propeller slave processor SPI Prop Send Cmd2 int cmd int data int status long status low status high status busy set CS to SPI select select Prop SPI channel 2 i SP SET CS SPI CS PROPELLER send command byte and retrieve low byte of result 2 status low SP WriteRead cmd 3 DELAY US SPI PROP CMD DELAY US send command byte and retrieve high byte of result 4 status high SPI WriteRead data i5 8t DELAY US 5PI PROP DELAY US send command byte and retrieve busy byte of result 6 status busy SPI WriteRead status 7 DELAY 05 5 PROP DELAY US set CS to SPI select channel 0 null 8 SPl_SET_CS SPI_CS_O 9 DELAY_US SPI_PROP_CMD_DELAY_US 10 return status busy lt lt 16 status high lt lt 8 status low end SPI Prop Send Cmd2 Even though you don t directly call this function its where all the action happens Let s go thru it line by line I have added manual line numbers in the listing to help The function uses the built in SPI hardware and makes calls to the SPI functions we already developed so that makes things a lot easier Here s how it works Propeller Chip Selection Step 1 Line 1 here we select channel 2 with the SPI mux this chip selects the Propeller chip as the target for SPI traffic
49. Therefore to scroll down a single row we simply need to add 64 to the current tile map pointer The example that follows will show this Returns 1 Example s Scroll down a line Assumes 32x24 tile map important thing is the row pitch this defines how many bytes per row GFX Write Tilemap Ptr GFX Read Tilemap Ptr 32 2 Function Prototype unsigned int GFX Read Bitmap Ptr void Description GFX Read Bitmap Ptr reads the 16 bit bitmap pointer that points to the first bitmap indexed by tile 0 Each bitmap is 8x8 pixels 2 bits per pixel 16 bytes each The bitmap pointer is of course relative to the Propeller s 32K memory space and an absolute address Returns the 16 bit pointer value address Example s Read the current bitmap pointer unsigned int bitmap ptr bitmap ptr GFX Read Bitmap Ptr Function Prototype unsigned int GFX Write Bitmap Ptr unsigned int bitmap ptr Description GFX Write Bitmap Ptr writes the 16 bit bitmap pointer bitmap ptr that points to the first bitmap indexed by tile 0 Each bitmap is 8x8 pixels 2 bits per pixel 16 bytes each The pointer must be a valid address and within open memory or part of memory declared for the driver itself otherwise you could crash the Propeller so watch out Typically you will adjust the bitmap pointer by one or more bitmaps to create animation effects of the tiles on screen or to swap out character sets on the fly Returns
50. This is accomplished with the set display attribute escape code lt ESC gt P m Here Ps is an attribute that you set Table 18 1 lists some of the available text display attributes Table 18 1 Attribute Codes for VT100 Character Displays Attribute Code Description 0 Attribute Off 0 0 Using VT100 codes with a good terminal emulator on the PC allows you to create a rich user interface versus plain scrolling text In the demos section we will see an example program that makes use of the VT100 codes Just remember to run the program with a proper terminal emulator like Putty Zoc or Minicom and then make sure that their emulation is set to VT100 The UART driver s header CHAM_PIC_UART_DRV_V010 h contains more information than some of the past driver headers we have looked at There are a number of defines for configuration and function calling arguments listed below Comment out if you do not want the UART to stall your program when the transmit buffer gets full define STALL_UART t B a You can ad define UARTI define UARTI h is taken up by the TX RX buffers here U U jus CRX The first Zdefine STALL UART is used to signal the driver to stall any transmission functions that will fill BEYOND the current TX buffer This way the user does not have to worry about data not being written out of the serial port when they pass lots of data or large strings to be transmitted If you do not wan
51. When the driver is started it loads the ASM code into a Propeller core and that starts drawing graphics on the NTSC screen immediately Then the SPIN code has a lot of functionality to print characters strings numbers and emulation of the crude VT100 like terminal that all the other NTSC and VGA terminal drivers require In addition to the terminal functionality there is a set of virtual registers that are used to communicate with the ASM driver with These registers control everything from the top and bottom overscan tile map pointers fine scrolling etc We will see some of these constants in the following sections when we look at the header files But for now the whole point is that when the GFX driver is started the SPIN code launches the ASM driver it starts immediately drawing the tiles in the 32x24 tile map Then we can make changes to the tile map using the high level terminal functions or the low level graphics functions which is what this section is all about Tile Map and Playfield Size Now let s take a look at the specifics of this tile map engine Referring to Figure 22 1 the tile map starts off 32x24 displayed on the NTSC screen This is the physical resolution and never changes That is we can never display more than 32x24 tiles on the physical screen However the playfield can be much larger to facilitate scrolling or page flipping The engine supports horizontal tile pitches of 32 64 128 and 256 Thus
52. but send messages to the objects running on the Propeller chip so ultimately if something doesn t work it s probably the driver Each tutorial demo follows the same outline the demo will be introduced a screen shot if applicable compilation instructions for both the TextPad mode of operation and straight MPLAB Finally the tutorials are organized in order of various sub systems like keyboard sound graphics etc And each demo might have a couple versions with different video drivers and or VGA NTSC support will tend to review only one version of the demo since the others are usually variants However compilation files for each demo version will be included After experimenting with all the tutorial demos you will have a command of all the sub systems of the Chameleon PIC 16 Bit as well as be able to use the provided APIs to get things done Then suggest you start with the demos as templates to get your own programs up and running before trying to do things from scratch To compile and run any of the tutorial demos you will need to have one of two things setup 1 An MPLAB project open and ready to go along with an PICkit 2 programmer to directly download to the Chameleon s PIC programming port 2 TextPad launched with the main demo project file open and the tools menu configured as discussed in Section 15 2 In this variant we will use the USB cable and bootloader loaded onto the PIC to program its flash In a nutshell if
53. buttons amp 0601000 SCURT ox t b M end 203 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 26 0 Propeller Local I O Port Module Primer The Propeller chip on the Chameleon is more or less peripherless if that s a word In other words if you want serial SPI A D D A etc you use a core and write one yourself using software Thus the philosophy of the Propeller chip is a lot of I O pins and lot of processors what you do with them is up to you The Chameleon uses most of the pins for the video audio VGA and PS 2 port but we were able to tuck 8 I O pins away and export them out to what is called the Propeller Local Port With this you can hook up devices that are designed to interface to the Propeller us it for switches a D A A D even another video or VGA port That said what decided to do was write a very rudimentary interface to it so you can control the direction of each port bit input or output and then write read data to and from the port from the PIC So if you run out of digital I Os on the PIC headers you can use the Propeller port or if you just want to connect something to the Propeller that takes 8 or less I O pins that someone has developed a Propeller object for Either way in this section we will see the API for the Propeller Local Port One detail before we begin the Propeller Port does NOT have a driver object running on another core It s s
54. hardware is tricky to setup and the 12C protocol is a bit difficult to work with so once again we have developed a software layer on top of it for your convenience FLASH The Chameleon PIC has a 1MB SPI FLASH memory on board which can be used for storage of assets data code whatever you wish This driver API runs 100 on the client PIC chip and gives you the ability to read and write sectors pages in the FLASH memory erase etc Considering that you might want to write some software to abstract the FLASH memory into a FAT16 like device All you need are functions to read write sectors pages which we provide then you can use a B party library to add support so the FLASH memory feels like a FAT16 drive There are numerous open source drivers for SD cards and FAT16 so you are free to use them in your development For example the DOSFS Library that has FAT16 support Simply Google a bit and you can find other libraries or write one yourself Mechatronics N A Some modules like the SPI and I C are actually in the same source file since they are So similar These compose the main library modules that make up the Chameleon PIC specific API functions mostly wrapper functions Now before we continue want to make a point about language here have been using the word library in a cavalier way Library as is relates to C C programming is a pre compiled container with many binary objects For example PIC 24 L
55. horizontally the playfield can be quite large Vertically there are no power of 2 restraints so you can make the vertical pitch anything you want as long as you don t run out of memory The tile map itself starts at the declaration tile_maps make sure to take a look yourself in the driver portion of code and is controlled by changing the global variable tile map base ptr parm in the register interface The tile map represents what s on the screen physically and the entire playfield virtually which might be much larger than the physical screen of 32x24 The tile map pointer above points to the start of the tile map but how the tiles are interpreted that is how many per row is controlled by a register that controls the setup of the tile mode This variable in the driver is called tile map control parm and controls a number of interesting things here s the initial default setup code for this variable on driver start up tile map control parm AC AC 00 00 format bc tc hv ww 8 top overscan color bc bottom overscan co 0 or nr hehorizontal scroll wevertical scroll 57 quy 32 tiles 1 e 07 tiles 2 328 tiles 3 e 256 tiles green overscan with AC So the format of this 4 byte value is bottom overscan color top overscan color horizontal and vertical smooth scroll playfield width The top and bottom overscan colors these are the colors on the top and bottom of your TV screen
56. if provided will contain whether the return value contained a valid SPI byte received Example s None Function Prototype long SPI Prop Send Cmd int cmd int data int status Description SPI Prop Send CmdQ is the workhorse of the entire inter processor communications system This single function is what is used to send and receive information to and from the Propeller chip Each command has 3 byte always The first byte cmd is the command 0 255 that represents what you want to do These are the same commands that are listed in the header file and the CHAM DEFAULT2 V112 SPIN message dispatcher is listening for The second byte data is the first 8 bit data operand the 3 byte status is the 2 8 bit data operand For commands that require 16 bits then data and status are concatenated to form a 16 bit operand like this msb status data Isb Thus data is the lower 8 bits and status is the upper 8 bits For commands that only require 8 bit operands set status to 0 If you recall SPI is a circular buffer system so each byte we send out we receive a byte back thus when you call this function 3 bytes are sent 3 bytes are received Currently the function returns a 16 bit value representing the first two returned bytes the 9 byte is used internally for now Also since this is such an important function let s take a look at the source for it his function waits for any previous command to complete and then i
57. if you are sending large chunks of text or data that has repeating symbols then it s better to compress it locally transport it then de compress and execute since computers are typically 1000 s of times if not millions of times faster than the communications links Additionally advanced RPC systems might use the same data over and over Thus there is no need to keep sending the data to the server and a caching system should be employed where on the first RPC call the caller indicates that a data structure being passed is static and cacheable Thus the server caches it after its first use then on subsequent calls the client need not send the structure until it needs refreshing For example say you have a 3D data base that you want a RPC to perform calculations on The database never changes so no need to keep sending it over and over once it s in the servers memory space you can save the bandwidth 16 3 3 Our Simplified RPC Strategy Considering all these interesting methods the method used for the Chameleon is a 3 byte binary encoded SPI packets with the following format 8 data_low8 data high8 Where command is an 8 bit command code data_low8 and data_high8 are the operands for the command Thus each SPI packet is rather small and can t do much However with proper design you can use these small SPI command packets to create larger commands For example say you want a command to print a character to the VGA
58. if you have a lot of set up work to do then you don t require a delay but if you jump right into commands then you need good 1 5 2 second delay DELAY_MS 2500 clear screens NTSC ClearScreen NTSC Color 0 enter infinite loop whi e 1 l print on NTSC terminal screen NTSC Term Print Status LED ON NTSC Term Char 0x0D send command to turn on LED SP Prop Send Cmd STATUS LED ON 0 0 1 slow things down a bit so we can read the text DELAY MS 250 ire emm Print Susa Le Orr NTSC Term Char 0x0D send command to turn off LED Prop Same Cmi StAtUs LED OFF 0 0 Jz slow things down a bit so we can read the text DELAY_MS 250 I end while end main This example file can be located on the DVD here DVD ROM CHAM SOURCE CHAM PIC STATUS LED DEMO 01 Compiling and building these programs should be old hat to you now so won t waste time with that Let s just look at the code Referring back to the source listing above there are 2 things that make this program really First the addition of the message ids show here new commands for status LED control define STATUS LED ON 100 define STATUS LED OFF 101 And secondly the actual messages to the Propeller to turn the LED on and off the on message for example send command 11 to on LED SP Prop Send Cmd LED ON 0 0 turn STATUS And that s it It just works If
59. there are no color burst signals serrations pre equalizations pulses etc the interface is nearly digital as noted The dot clock used in a basic VGA generation system is 25 175 MHz all timing can be derived from this base frequency Typically designers like to run the system dot clock at this frequency and compute all events as a number of clocks for example getting ahead of myself take a look at Figure 10 3 b the Hsync pulse which is labeled B in the table and a negative polarity its 3 77us therefore at a dot clock of 25 175 MHz or inverting this to get the period time we get 39 72194638 ns This is how long a pixel takes anyway dividing this into our Hsync time we get Number of dot clocks for Hsync pulse 3 77 us 39 72194638 ns 94 90 clocks Call it 95 dot clocks thus you can simply use a counter and count 95 clocks drive Hsync LOW and that it The entire VGA signal can be generated like this Of course the tough part is when you get to video here you only have roughly 39 nanoseconds to do whatever you are going to do this amounts to more or less doing nothing but accessing a video buffer as fast as you can and getting the next data word ready to build the pixel 43 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 10 3 1 VGA Horizontal Timing Referring to Figure 10 3 b each of the 480 lines of video are composed of the following standard named regions A 31 77 us Scanline time
60. 0 0 0 0 0 50 0 0 0 1 01 15 0 40 15 105 15 0 105 1515 1 dea 0 30 0 0 0 0 10 0 10 35 O a a t o 0 1 0 11 0 1 0 31 0 0 0 2 0 2 0 0 2 0 0 0 0 1 0 0 0 1 0 1 0 0 0 11 0 1 0 0 0 0 0 11 35 0 0 0 0 0 0 00 1 0 sos t t 3E 0 0 0 0 37 0 0 0 1 0 1 t t ibo ibo tO 005 0 365 00 36 00 0 0 0 0 15 0 11 305 hy 305 0 15 105 355 The interesting thing about this array is that its defined in FLASH memory rather than SRAM so this demo shows how you do that Notice the keyword const before the array declaration This instructs the compiler to place the array in FLASH rather than SRAM However this isn t without side effects Now that the data is in FLASH you can access it as normal data For example later in the code when the logo is displayed the following function reads the data displays it on the terminal and makes some sounds draw WAR GAMES with characters from FLASH for is 0 index lt 52 5 read the image from FLASH memory with special function call that uses LPM ASM instruction to read FLASH c title string flash index based on data convert to character and send to UART Sound Pl ay 0 else eed Sound Play 2000 UART Print String end if if index 52 0 red nap o a DELAY MS 50 end for ha
61. 1 Example s Adjust the bitmap pointer down by 16 bitmap tiles 16 16 256 bytes 189 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit GFX Write Bitmap Ptr GFX Read Bitmap Ptr 256 Function Prototype int GFX Get VScroll void Description GFX Get VScroll returns the current fine vertical scroll value from 0 7 The tile engine supports smooth vertical scrolling via the vertical fine scroll register This function reads that register Example s Read the vertical scroll register int fine scrol fine scroll GFX Get Vscroll Function Prototype int GFX Set VScroll int vscroll Description GFX Set VScroll sets the vertical fine scroll register with the sent value vscroll 0 7 Use this function and register to control smooth scrolling Each tile is 8 pixels high thus you can scroll the up and down a single pixel at a time with this register call To perform continuous smooth scrolling first fine scroll 0 7 then reset to 0 and course scroll a single row Returns 1 Example s Fine scroll 8 times in about a second from 0 7 a tile height for int scroll 0 scroll lt 8 scroll GFX Set VScroll scroll delay ms 100 I end for serol Function Prototype unsigned int GFX Read Mem Port8 void Description GFX Read Mem 8 reads a 8 bit value from prop memory source note source poi
62. 10 The modified source code is provided on the DVD ROM FlashProg is simply a console program that takes as input arguments the communications port number that the Chameleon is connected to as well as the name of the binary hex file to load into the PIC24 s onboard flash When it s launched the software attempts to establish communication with the PIC24 processor and requests the processor s Device ID This 109 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit gives the FlashProg the exact part number of the PIC so that it knows which commands need to be sent to erase and load the flash correctly Located on the Chameleon PIC at least when it was originally shipped is a small section of code that acts as a bootloader It operates by first configuring the serial port for 115200 baud rate and then begins listening for serial communication If it does not receive any communication within the first two seconds it jumps execution to the user program that was last loaded in flash memory However if it does receive serial communication it acts upon the commands it receives and erases and programs the flash memory and then jumps execution to the new program 15 2 1 Installing and Configuring TextPad TextPad is a general purpose text editor that is easy to use but has a lot of features under the hood We have chosen to use it because of its minimal system requirements and because of its capability to call command line programs and disp
63. 10001000 152 98 230 10011000 168 A8 250 10101000 184 8 270 10111000 137 89 211 10001001 153 99 231 10011001 169 AQ 251 10101001 185 B9 271 10111001 138 8 212 10001010 154 9 232 10011010 177 252 10101010 186 272 10111010 139 88 213 10001011 155 9B 233 10011011 171 AB 253 10101011 187 BB 273 10111011 140 8C 214 10001100 156 9C 234 10011100 172 AC 254 10101100 188 BC 274 10111100 141 8D 215 10001101 157 9D 235 10011101 173 AD 255 10101101 189 BD 275 10111101 142 216 10001110 158 9E 236 10011110 174 AE 256 10101110 190 BE 276 10111110 143 8F 217 10001111 159 9F 237 10011111 175 257 10101111 191 BF 277 10111111 Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin 192 CO 300 11000000 208 DO 320 11010000 224 340 11100000 240 FO 360 193 1 301 11000001 209 321 11010001 225 El 341 11100001 241 1 361 11110000 194 2 302 11000010 210 02 322 11010010 226 E2 342 11100010 242 F2 362 11110001 195 303 11000011 211 D3 323 11010011 227 343 11100011 243 F3 363 11110010 196 C4 304 11000100 212 324 11010100 228 E4 344 11100100 244 F4 364 11110011 197 C5 305 11000101 213 D5 325 11010101 229 E5 345 11100101 245 5 365 11110100 198 C6 306 11000110 214 06 326 11010110 230 E6 346 11100110 246 6 366 11110101 199 C7 307 11000111 215 D7 327 11010111 231 E7 347 11100111 247 7 367 11110110 200 C8 310 11001000 216 D8 330 11011000 232 E8 350 11101000 248 F8 370 11110111 201 C9 311 11001001 217 331 11011001 23
64. 155 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 19 USPI Basis O TR O 156 19 1 1 Basic SPI Communications Steps 158 159 19 2 1 Understanding Bus States 160 19 3 Header File amp 161 19 4 API Listing 163 19 5 API Functional 164 20 0 NTSC LIBRARY MODULE PRIMER an duni E eee cai Y ek rand So co ro ce nai uad S e ter smi spada 169 20 1 Sending Messages to the Propeller Directly 1 esee cete sees ee eese ee eren etate toas eaae ease tn seta seta seta sete sete senses esos 170 20 2 Header File Contents 170 20 3 APT Listing Reference siccssesssassccescsesssssssencseossessensscococeososssovassesasessensses sus senscuonsuassneascessseesoedsqaososedaodsasessSeacdeosseasessseoscseacessnouan ens 170 20 4 API Functional Declarations sssccsssscsscsssescssssssssssscesccssessessnsssssssccsscssosssssnssessnessessessossessssossnessssnessesscssossssesssessnessesoess 171 21 0 VGA LIBRARY MODULE PRIMER
65. 16 Bit The comments should explain everything that is going on but make sure to pay attention to the highlighted lines of code that compute frequencies using the pow function Basically to compute the nth adjacent note on a standard diatonic scale you multiply the key note frequency by 2 taken to the nth power Once the chord frequencies are computed they are issued to the sound driver to play on 3 different channels leaving one left Summary This demo shows how to play music using the sound API However be aware the sound driver running on the Chameleon s Propeller chip can do a lot more than we expose with the API so if you want more features you can add them by modifying the Propeller s master driver 30 1 Input Device Demos The following demos illustrate the input devices supported on the Chameleon the keyboard and mouse The demos drive either the NTSC VGA or both But if you want to add support for the other it s simply a matter of adding a couple lines of code The examples typically consist of the primary source file for the demo as well as The System API library module CHAM_PIC_SYSTEM_V010 cjh The main SPI API library module CHAM PIC I2C SPI V010 c h The keyboard API library module CHAM PIC KEYBOARD DRV 010 The mouse API library module CHAM PIC MOUSE V010 c h The NTSC GFX driver or all of them And any other ancillary drivers keyboard mouse etc
66. 19 2 a and b show the complete timing diagrams for all variants of clock polarity CPOL and clock phase CPHA You must adhere to these timing constraints during communications In most cases you will use mode 0 since it s the default that most SPI devices boot with The good news is this is all taken care of by the PIC24 in fact most PIC microcontrollers have complete SPI and 2 hardware built in that take of all the details of both transmission and reception The only thing we have to do as programmers is set the hardware up then send and receive bytes and maybe handle an interrupt or two Thus working with SPI in the PIC24 is very easy Nonetheless the library module we developed wraps the SPI hardware with a thin layer of functions so that you don t have to deal with it all yourself However it s good to understand the protocol if you need to manually build a SPI interface with pins For example maybe you need 4 SPI interfaces all at the same time on the Chameleon s expansion port the only way to do this will be to do it manually with pin toggling 158 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit However the PIC24 provides two separate SPI ports that can be remapped to any pins suggest leaving one mapped to the Propeller so you can still control it but the other one is free to be moved to any other pins This is very good news Moreover the Chameleon s expansion headers port exports
67. 2 byte i is the color attribute which is an index into the palettes Thus a palette entry of 0 means use palette 0 a 1 means use palette 1 and so forth Each palette consists of 4 colors Each color encoded as a single byte which will discuss the encoding in a moment Currently the driver has 16 palettes allocated nothing special just made up colors black white blue basic colors kind of thing You will want to define your own palettes and your own colors as you define your bitmaps art and level designs for your games Below is a peek at the palette definition in the driver palettes extracted from file c64 font 04 8b using palette color map 1 only palette index 0 1 are used right for character font palette index 0 makes characters normal iia i makes them look inverse video tile palette map LONG c64 font 04 palette map LONG LONG 07 07 0C 02 palette index 0 LONG 07 0C 07 02 palette index 1 LONG 07 0C 07 02 palette index 2 LONG 07 0C 07 02 palette index 3 LONG 07 0C 07 02 palette index 4 LONG 07 0C 07 02 palette index 5 LONG 07 0C 07 02 palette index 6 LONG 07 0C 07 02 palette index 7 LONG 07 0C 07 02 palette index 8 LONG 07 0C 07 02 palette index 9 LONG 07 0C 07 02 palette index 10 LONG 07 0C 07 02 palette index 11 LONG 07 0C 07 02 palette index 12 LONG 07 0C 07 02 palette index 13 LONG 07 0C 07 02 palette index 14 LONG 07 0C 07 02 palette index 1
68. 4 The RGB signals and their relationship to VGA and the Propeller I O pins Prop Port Bit Chameleon Signal Description P23 VGA RED B1 Bit 1 of RED channel P22 VGA RED BO Bit 0 of RED channel P21 VGA GREEN B1 Bit 1 of GREEN channel P20 VGA GREEN Bit 0 of GREEN channel P19 VGA BLUE B1 Bit 1 of BLUE channel P18 VGA BLUE BO Bit 0 of BLUE channel P17 VGA_HSYNC VGA HSYNC TTL level P16 VGA VSYNC VGA VSYNC TTL level 10 3 3 Generating the Active VGA Video Generating the actual RGB video pixels is trivial on any system there is no look up no math just send out bytes or words that represent the RGB values and that s it Of course the Propeller will do this for us via the VSU and a driver but there is no reason you can t drive the I O pins manually with pure software as well Either way let s take a look at the mechanics of the signal On the Chameleon PIC for example there are 2 bits per channel so the encoding of the VGA data byte is as simple as generating bytes in the format shown in Figure 10 4 Figure 10 4 VGA data byte encoding 1 0 P23 P22 P21 P20 P19 P18 P17 P16 Bit 6 val Bit 4 Bit 3 DR Bit 0 R1 RO 61 60 Bl B0 VSYNC HSYNC Red Si gnal Green Signal Blue Signal Sync Signals Let s say that we have a BYTE buffer called vga byte and a function Write VGA value time us that we use to send data to the VGA port given that we can write all kinds of functions that send out different
69. 4 Bit 3 Bit 2 Bit 1 Bit 0 Byte 1 Always 0 Mode Enable Scaling Always O Left Button Middle Button Right Button Byte 2 Resolution Byte 3 Sample Rate Right Middle Left button 1 if button pressed 0 if button is not pressed Scaling 1 if scaling is 2 1 0 if scaling is 1 1 Refer to commands E7 and E6 Enable 1 if data reporting is enabled 0 if data reporting is disabled Refer to commands F5 and F4 Mode 1 if Remote Mode is enabled 0 if Stream mode is enabled Refer to commands FO and EA Set Resolution The mouse responds with acknowledge FA then reads the next byte from the host and again responds with acknowledge FA then resets its movement counters The byte read from the host determines the resolution as follows Byte Read from Host Resolution 00 1 count mm 01 2 count mm 02 4 count mm 03 8 count mm Set Scaling 2 1 The mouse responds with acknowledge FA then enables 2 1 scaling mode Set Scaling 1 1 The mouse responds with acknowledge FA then enables 1 1 scaling default Lastly the only commands the standard PS 2 mouse will send to the host are the Resend FE and Error FC They both work the same as they do as host to device commands Other than that the mouse simply sends 3 byte data motion packets in most cases before sending any other commands This way the mouse won t keep trying to send If the mouse is in Stream mode the host should disable data reporti
70. 80Mhz per core with 8 cores Each instruction takes 4 clocks thus the Propeller runs at 20 MIPS per core nominally It has 32K of SRAM and 32K ROM The Programming Manual This is the nitty gritty of the manual and has examples of programming graphics sound keyboard mice I O etc and explains how the processors work together along with their various toolchains The Chameleon PIC 16 Bit is very similar to the Chameleon AVR 8 Bit In fact the processor was removed from my originally design and replaced by the PIC 16 and the I O interfaced re connected so if you learn one system you learn them both more or less The Chameleon s were designed to be application boards to solve real world problems that you might have day to day in your designs engineering classes or work The Chameleons philosophy is to be very powerful but very simple have always been very interested in graphics and media processing however it is very hard to get a simple embedded system or development board to output NTSC PAL VGA etc Thus set out to design something that wasn t a development or educational kit like our other products but was something you just use to solve problems that is also good at displaying information and interfacing to user input devices Nonetheless wanted the Chameleons to be able to do graphics produce sound interface to keyboards and mice and be as small as a credit card There are a number of approaches to this desi
71. 89 15 1 4 Building a Project and Testing the Tool Chain eee eee eese tees tn ats tasse tassa tastes tuse ta sens 94 15 1 4 1 Loading the binary into the Chameleon PIC using the PICkit 2 104 1541 42 Enabling Compiler Optimuzations 4 tco prr ee tt e ne cte da e RH Ner dee ele ip PUR EE e e noh 107 15 1 4 2 Final Words on MPLAB Toolchain Installation eese eee eene nennen enne enne netten nn snnt enne 108 15 2 MICROCHIP SERIAL BOOTLOADER AND TEXTPAD 109 15 2 1 Installing and Configuring TextPad eee eee ee eee ee seen enean sette neta sins tuse 110 15 2 2 Serial Bootloader and FlashProg 4 eee eee eee ette setae sete sete soe ease 112 15 2 3 Preparation to Launch the serial bootloader tools for the First Time 4 reete esee 113 15 2 3 1 Installing a Serial Terminal Program 114 15 2 3 1 Running the Bootloader 1 117 15 2 3 3 A Couple Notes About using the Bootloader oo cece 119 15 3 INSTALLING THE PARALLAX PROPELLER
72. All from the Main Menu s Build menu then using the PICkit 2 programmer toolbar Program the Chameleon PIC with the new binary That s it 108 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 15 2 Microchip Serial Bootloader and TextPad Setup The Chameleon PIC ships with the Microchip serial bootloader pre loaded into the PIC s flash memory This allows you to immediately use the Chameleon in bootloader mode allowing for reprogramability without using a PICkit 2 or equivalent in circuit programming device In addition to the serial bootloader we can use a normal text editing program such as TextPad to edit our code and then call a command line batch file that will compile the code and call our serial binary transfer tool to send the data to the Chameleon PIC Figure 15 48 shows the relationship between the components of this setup Figure 15 48 The serial bootloader system setup with the Chameleon TextPad Editor e PIC24 C Tools Compile and Create Binary Hex file hex This is simply a text editor Any text editor could be used but we will describe TextPad Serial This flash utility tool simply Windows DOS lt gt transmits the compiled binary commandline hex file from the PC to tool the Chameleon over USB serial connection Chameleon PIC 16 Bit FlashProg exe As you can see the serial bootloader setup is a little bit easier than the MPLAB toolch
73. CHAM PIC TOOLS COMMUNICATIONS putty install exe is called PuTTY and is very easy to use Once installed it will create a shortcut on your desktop Click the shortcut to run the program you will see a dialog like that shown in Figure 15 54 115 Figure 15 54 PuTTY Setup for serial communications with Chameleon PIC 115200 baud N81 i amp PuTTY Configuration Category Session Logging Terminal Keyboard Bell Features Window Appearance Behaviour Translation Selection Colours Connection Data Proxy Telnet Rlogin 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Serial line Speed COM30 115200 Connection type ORaw OTelnet Rlogn OSSH Serial Load save or delete a stored session Saved Sessions Default Settings Close window on exit O lways Never Only on clean exit Click on lt Serial gt for the connection type as shown in the top right then click Serial on the bottom of the Category tree panel on the left and make sure the settings listed below and shown in Figure 15 55 Data Format Baud Rate Handshaking N81 no parity 8 data bits 1 stop bit 115200 None 116 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 55 PuTTY Setup for serial communications with Chameleon PIC 115200 baud N81 continued i amp PuTTY Configuration
74. CHAM PIC I2C SPI DRV v010 h 5 cHAM PIC NTSC DRV V010 h E CHAM PIC SYSTEM v010 h E CHAM PIC vGa DRV vo10 h Object Files Library Files Linker Script I3 bootable p24HJ128GP502 gld Other Files Symbols When you have completed adding the source header assembly and linker script files to the project your Project File Tree should resemble Figure 15 40 Now that the files are prepared we will build the project 103 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 41 Make project menu selection Demo MPLAB IDE v8 15 File Edit view Debugger Programmer Tools Configure Project Wizard Mew Open dose CdDemo Set Active Project gt Sot Clean E Export Makefile Build All Ctrl F10 g He Make F10 BY Build Configuration Ej Build Options Ej Save Project Ob Save Project As Lib Add Files to Project Add New File to Project Remove File From Project OU Select Language Set Language Tool Locations Version Control To compile assemble and link the entire project choose the Make menu item found under the Project Make location as shown in Figure 15 41 The keyboard shortcut to make a project is F10 This will begin the build process that you can follow in the output window Figure 15 42 files added to the project
75. Chameleon power is ON and the serial selection switch is in the UP position When you are ready then you can press lt F11 gt on the Propeller Tool or from the main menu you can select lt RUN Compile Current gt Load EEPROM the results will be the same the Propeller tool will scan all COM ports for a connection to a Propeller chip and then compile and download the firmware to the Chameleon This is shown in Figure 15 64 124 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 64 Downloading the firmware into the Propeller Chip mouse 010 NS sound drv 052 1lkhz 16bit CHAM GFX DRV 001 TB 001 010 2 Test 010 2 Propeller Communication Once the firmware is downloaded into the Propeller chip on the Chameleon board it will immediately start generating NTSC and VGA video If you hit RESET on the Chameleon you will see the images shown in Figure 15 65 on the NTSC and VGA monitors respectively 125 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Chameleon SPI Driver2 V1 11 E Ix Driver Initialized GA D Also when you hit reset each time you will see the LED D3 under the Video port blink 3 times shown in Figure 15 66 this is part of the testing firmware to confirm the Propeller chip is functioning correctly as well as to verify the LED is good Finally you will HEAR the Chameleon make soun
76. DRV 010 is listed in Table 18 2 categorized by functionality Table 18 2 UART driver API functions listing Function Name Initialization void UART_Init unsigned long BaudRate Transmission void UART printf const char buff void UART_puts const char buff int UART putchar int ch void UART Newline void UART BlockSend unsigned char ch Reception int UAHT gets unsigned char Data int UART getchar unsigned char ch unsigned char UART_BlockRead VT100 Commands void UART_vt100Init void void UART_vt100ClearScreen void void UART_vt100SetCursor void UART_vt100SetAttr unsigned char attr Description Initializes the UART peripheral hardware Sends the string with variable arguments to the UART Sends the NULL terminated Transmits a single character Transmits an line feed lt CR LF gt Sends a single byte and blocks until character has been transmitted Reads in a string up to and including the carriage return lt CR gt Gets a single character if any are available Waits until a character has been received Resets the VT100 terminal Clears the VT100 terminal screen Sets the terminal cursor to the specified line column Sets the next printed text s attributes The following lists each function a description comments and example usage of the function 147 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototyp
77. Data Transmission Step 2 Lines 2 3 here we simply send the 1st byte of the command packet and retrieve the 1st byte back in a buffer Step 3 Lines 4 5 here we simply send the 2nd byte of the command packet and retrieve the 2nd byte back in a buffer Step 4 Lines 6 7 here we simply send the 3 byte of the command packet and retrieve the 3rd byte back a buffer Propeller Chip De Selection Step 5 Lines 8 9 here we de select channel 2 with the SPI mux and select channel 0 the NULL channel Results Step 6 Line 10 We return the 8 16 bit result to caller This is how all commands are sent to the Propeller chip Example s Send command to NTSC driver to clear the screen So first thing we do is look in the header file at the command list in CHAM_PIC_I2C_SPI_DRV_V010 h also the Propeller driver CHAM DEFAULT2 112 SPIN has the same list and look up the command we want GFX_CMD_NTSC_CLS and now send the command with a function call clear the NTSC s creen t SPI Prop Send Cmd GFX n parameters thus send 0 0 for data bytes CMD 168 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype int SPI Prop Print String int device char string Description SPI Prop Print String is a legacy function that uses terminal NTSC VGA driver to print strings on the display Typically you will use the NTSC VGA API to print to the terminals but th
78. GFX SUBFUNC STATUS extract API subfunction and data GPU GFX subfunc g datal6 amp FF lower 8 bits defines sub function GPU GFX data g datal6 gt gt 8 upper 8 bits defines data for sub function 183 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit case GPU GFX subfunc GPU GFX SUBFUNC COPYME 16 0 Copies numbytes from src dest in wordsize chunks wordmove tile dest add r parm tile src addr tile numbytes parm GPU GFX SUBFUNC FILLMEMI wordfil tile dest ad GPU GFX SUBFUNC COPYME 6 1 Fills memory with datal6 2 bytes at a ti me d ile datal6 parm tile numbytes parm 1 gt 3 lt 8 2 Copies numbytes from src gt dest in byte size chunks bytemove tile dest addr parm tile_src_addr_parm tile numbytes parm gt gt 1 GPU GFX SUBFUNC_FILLMEM8 3 Fills memory with low byte of datal6 1 bytes at a time bytefil tile dest addr parm tile datal6 parm amp FF tile numbytes parm END CASE GPU GFX subfunc UE HEEL HEEL E TILE MAP POINTER GPU GFX TILE MAP R Made or Writes the 16 bit tile map ptr which points to the current tile map displayed g spi result tile map base ptr parm GPU
79. Init unsigned long ClockHz Parameters ClockHz in The desired clock rate in Hz Return None Description 12 _ initializes the I C peripheral hardware on the PIC24 with the specified clock rate Example s The example shows a simple usage scenario 1 CHAM PIC SYSTEM V010 h Include Cham TW SPI driver include CHAM PIC 2C SPI DRV_V010 h int main voi d Always call SYS ConfigureClock first after main begins onfigureClock MAX FCY RATE Configure clock for E TW i2c interface at 100KHz lize t 100000 I continue program bel Function Prototype void l2C_WaitTillldie Parameters None Return None 164 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Description 12 WaitTillldle stalls the PIC24 s execution until the I2C has finished all outgoing operations This could include operations such as acknowledging starting a send initiating a receive sequence resetting etc Example s The following example shows how to send and receive a byte of data Remember that the communications protocol is going to be different depending on what device you are working with VIHHHHHHE EH ERE RE pst start operation 2C1CONbits i initiate Start on SDA and SCL pins Start sequence has finished 0x4F lt lt 1 0x00 Send the data out ansmitted HHHHEHHEE HELLE READ MMT Read
80. Multiple bytes can be transferred in one direction before a repeated START or a STOP condition is issued by the Master The transfer is terminated when the Master issues a STOP condition A STOP condition is defined by a low to high transition on the SDA line while the SCL is high Confusing isn t it If a Slave device cannot handle incoming data until it has performed some other function it can hold SCL low to force the Master into a wait state for as long as it needs to All data packets transmitted on the I C bus are 9 bits long consisting of 8 data bits and an acknowledge bit Now during a data transfer the Master generates the clock and the START and 160 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit STOP conditions while the receiver is responsible for acknowledging the reception An Acknowledge is signaled by the receiver pulling the SDA line low during the 9th clock cycle pulse on SCL If the receiver leaves the SDA line high a no ACK is signaled and the transfer is not completed In conclusion 1 is a lot more complex that SPI and writing a software implementation is a lot harder as well due to the state machine bus contention and so forth However the PIC24 has built in I C hardware as mentioned which makes it all much easier to implement Setting up the registers is still a bit challenging and you have to read the documentation quite a bit to get the hang of it su
81. PIC SYSTEM V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC VGA VO010 c h CHAM PIC NTSC DRV V010 c h General Requirements NTSC port connect to NTSC TV monitor and VGA port connected to VGA monitor Controls Required None Technical Overview The demo simply uses both the NTSC and VGA terminal API functions to print Hello World on both screens and scroll Here s just the main loop excerpt since this demo is nothing more than a copy of the NTSC and versions respectively and merged nt main void run over and over again Ee kd a A Cnr UTEE OCK etn SYS ConfigureClock MAX_FCY_RATE initialize SPI SPI Init clear screens NTSC ClearScreen VGA ClearScreen enter infinite loop 215 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit DE terminal screen Print Hello World 0 m I print on VGA terminal screen VGA Color 0 VGA Term Print Hello World s slow things down a bit so we can read the text DELAY MS 10 end while end main The demo simply uses the same basic commands but send them to both the NTSC and VGA monitors Summary This demo shows how easy it is to get both NTSC and VGA terminal like text output going on the Chameleon 28 1 6 Star Field Demo The default2 VGA driver isn t as impressive as the NTSC driver In fact it s pretty boring It s good for displaying text
82. REG WRITE BYTE write byte 0 3 of carput PEGI Sir _ rey our orel 0 9 byte address to write 0 3 is data while data to write is in g dat g reg out buffer byte g data g data2 read command from byte registers of 32 bit buffer register REG CMD READ BYTE read byte 0 3 of input register g pm buffer byte 0 3 this data is then placed into spi buffer for transport back to client byte address to read 0 3 is in g data g spi result reg in buffer byte g data SYS RESET resets the prop reboot end case commands set result and set Rav neher to idle spi finishcmd g spi result dH 00p COH TTT TTT TEA ETE That s it Save the file as cham default2 drv 112 modified spin and we are done with this portion In fact you can flash it down to the Propeller and every single program will still work the same We have added messages and features but we have NOT made anything incompatible or re used message ids for something else This is very important to keep in mind 50 you do not damage a driver and make it incompatible with other software 31 1 2 Adding PIC Support at the Client Master Side At this point we have new messages added to the Propeller driver along with the message handler code If you haven t done so compile and download the new driver to the Propeller chip on the Chameleon whatever application you have running on the Chameleon should work exactly the same Now what we need
83. RESULTS THAT MAY BE OBTAINED FROM THE USE OF THE LICENSED WORKS WILL BE ACCURATE OR RELIABLE iv THE QUALITY OF THE LICENSED WORKS WILL MEET YOUR EXPECTATIONS v ANY ERRORS IN THE LICENSED WORKS WILL BE CORRECTED AND OR vi YOU MAY USE PRACTICE EXECUTE OR ACCESS THE LICENSED WORKS WITHOUT VIOLATING THE INTELLECTUAL PROPERTY RIGHTS OF OTHERS SOME STATES OR JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES OR LIMITATIONS ON HOW LONG AN IMPLIED WARRANTY MAY LAST SO THE ABOVE LIMITATIONS MAY NOT APPLY TO YOU IF CALIFORNIA LAW IS NOT HELD TO APPLY TO THIS AGREEMENT FOR ANY REASON THEN IN JURISDICTIONS WHERE WARRANTIES GUARANTEES REPRESENTATIONS AND OR CONDITIONS OF ANY TYPE MAY NOT BE DISCLAIMED ANY SUCH WARRANTY GUARANTEE REPRESENATION AND OR WARRANTY IS 1 HEREBY LIMITED TO THE PERIOD OF EITHER A Five 5 DAYS FROM THE DATE OF OPENING THE PACKAGE CONTAINING THE LICENSED WORKS OR B THE SHORTEST PERIOD ALLOWED BY LAW IN THE APPLICABLE JURISDICTION IF A FIVE 5 DAY LIMITATION WOULD BE UNENFORCEABLE AND 2 LICENSOR S SOLE LIABILITY FOR ANY BREACH OF ANY SUCH WARRANTY GUARANTEE REPRESENTATION AND OR CONDITION SHALL BE TO PROVIDE YOU WITH A NEW COPY OF THE LICENSED WORKS IN NO EVENT SHALL LICENSOR OR ITS SUPPLIERS BE LIABLE TO YOU OR ANY THIRD PARTY FOR ANY SPECIAL INCIDENTAL INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND OR ANY DAMAGES WHATSOEVER INCLUDING WITHOUT LIMITATION THOSE RESULTING FROM LOSS OF USE DATA OR PROFI
84. The Chameleon PIC composite video hardware NTSC Video Summer R15 ANT1 Antenna Port AURAL_O VIDEO_2 VIDEO 1 VIDEO 0 Referring to Figure 11 1 the composite video generation hardware consists nothing more than a crude 3 bit D A converter summing circuit along with a single signal for audio summed with the node as well The real magic of the video generation is up to the Propeller chip it not only generates the luma brightness but the chroma color in the proper format and timing for whatever the desired protocol is NTSC or PAL The Propeller chip video hardware is designed to be interfaced to a simple 3 bit DAC with the resistance values chosen and shown above in the figure Table 11 1 shows the signal relationship to the Propeller I O signals Table 11 1 The Video Hardware Prop Port Bit Chameleon Signal Description eee ___________ O 12 VIDEO 0 Bit 0 of the overall composite video signal contains both LUMA and CHROMA P13 VIDEO 1 Bit 1 of the overall composite video signal contains both LUMA and CHROMA P14 VIDEO 2 Bit 2 of the overall composite video signal contains both LUMA and CHROMA P15 AURAL 0 Single audio bit used when transmitting broadcast video There are 3 bits of D A conversion for the overall composite video signal VIDEO 0 3 thus giving a total of 8 different overall LUMA values however a number of them at the low scale of the range must be used to jump from
85. The MPLAB toolchain uses the same GNU GCC compiler as the serial bootloader 1126 method thus software written in one development environment will work exactly the same as in the other There are lots of tricks and tips to using the PIC24 Libc functionality however for the most part as long as you don t push it you can use standard C functions and everything will work out Of course you have to have common sense when using functions For example on a PC the function printf makes sense since there is some kind of terminal device On the Chameleon PIC this won t work since the developer of PIC Libc has no idea about the Chameleon PIC thus anything that is hardware specific won t work since Libc has no idea about the hardware On the other hand you might ask is it possible to get printf to work The answer is yes However you would have to go into the source files where printf is located and modify it to do something intelligent on the Chameleon PIC such as print to the UART or to the NTSC VGA screen But you get the idea Don t use standard C functions that make no sense on an embedded system Next embedded systems have multiple memory types RAM FLASH EEPROM And the PIC Libc library knows this Thus many functions only work in RAM or FLASH specifically Therefore you always have to keep in mind that you are working with a Harvard memory architecture and a separate RAM FLASH memory model The PIC24 Libc documen
86. Tool completed successfully The output also contains some statistics about the memory usage Notice that for the program FLASH memory we are using 20253 bytes or about 15 of the total memory The data memory usage SRAM we are using only 542 bytes or about 696 of the available 8K memory 15 2 3 3 A Couple Notes About using the Bootloader You might be wondering what are the differences between using MPLAB vs using the serial bootloader for development Here are a couple of the differences listed below 1 MPLAB will require the use of a real device program This could be as simple as the 2 less than 50 or the ICD3 or even an expensive MPLAB Universal Device Programmer 895 Using the serial bootloader simply requires a USB cable and that your PIC has a bootloader flashed into the first sector of memory 2 MPLAB provides a software simulator and debugging capabilities single step breakpoints variable watches while TextPad provides nothing Typically when debugging with TextPad you will blink lights or send data to a monitor for memory inspection 3 Loading the flash memory contents typically seem to run faster when using TextPad and when using the tip mentioned previously on conditionally compiling only files that have changes can have a really positive effect on code updating times So the question is which mode to use MPLAB or Bootloader Well depends on what you are doing and what you have If you do not ow
87. V010 o CHAM PIC SYSTEM V010 0 CHAM PIC UART DRV V010 o CHAM P PE V010 0 main o o program W L C Program Files Microchip MPLAB C30 lib script bootable_p24Hj128GP502 gld defsym __MPLAB_BUILD 1 de fsym MPLAB DEBUG 1 Map program map 30 2 program cof FlashProg exe i 2 program hex Each line that begins with pic30 xxx and FlashProg exe is a separate DOS command line operation that will be executed in order Specifically the pic30 gcc when used with the c FILENAME option compiles a single file to the object specified OBJECTNAME The last time the pic30 gcc exe is called we use the expression c 1 What the DOS interpreter does is it replaces the 961 text with the first argument passed to the batch script Remember when we setup the Parameters for the TextPad tool specified the first argument to be FILE or the file name that is currently being edited in TextPad Looking at the commands above we see that all the drivers are compiled into equivalent names with the o extension The last time pic30 gcc exe is called we do not use the o option and instead provide all the objects we wish to link together and instruct it to output o program cof is short for COFF which stands for Common Object File Formation which is an object file that contains machine code debugging and other information However most device prog
88. VO10 c h CHAM PIC NTSC DRV VO010 c h CHAM VO010 c h CHAM_PIC_SOUND_DRV_V010 c h 218 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit General Requirements Video port connected to NTSC VGA monitors RCA audio connected to an amplifier or the TV s audio input Controls Required None Technical Overview This demos uses the Sound API to plays tones on the speaker You need to hook up the Chameleon s audio out port to the amplifier or the TV s audio in However the program outputs to both the NTSC and VGA display for its text output This program is the most complex yet since it deals with sound First off we need a scale of frequencies which is at the top of the program and shown below float adjacent note 1 059463094 2 1 12 ratio between adjacent keys above A scale from e 554 SO O22 6509 O95 100 Jo d GU iddle A to one int scale mi octav 440 466 494 523 440 sharp sharp 0n A 6 9 2 5 8 2 5 1 gt C 698 sharp 740 8 flat 83 8 orf gt gt 0 1 coon FA The array scale holds the scale from middle A at 440Hz then from this we can compute any octave or half notes etc which are used to generate chords There are all kinds of chords and all kinds of theory about what sounds good and doesn t O
89. Where REM comments out the line This will drastically increase compile times 15 2 3 Preparation to Launch the serial bootloader tools for the First Time Before you launch the batch file bootloader tool make sure you have the USB cable plugged into the Chameleon you can also have the 9V DC power adapter plugged in if you have one The USB is needed no matter what since that s what the serial bootloader will use to send serial data to the Chameleon s bootloader with Figure 15 51 below shows the USB cable plugged into the Chameleon PIC The FTDI chip device makes it easy to use serial communications from the PC Figure 15 51 The Mini USB port on the Chameleon connects to the FTDI USB to Serial converter chip MINI YSB PORT Serial Communications as well as Propeller Chip Programming Now if your computer recognizes the FTDI chip and has drivers it will load them automatically and install a virtual COMxx port into your system However if it doesn t you will need to install the FTDI drivers This is needed for all serial communications with the Chameleon so a necessary step You can manually install the FTDI driver from the DVD ROM ZIP file here DVD ROM CHAM_PIC TOOLS DRIVERS USBDriverlnstallerV2 04 16 exe After you have installed the driver then each time you plug a Chameleon PIC into the PC via the USB port the FTDI chip will assign a NEW COM port you need to determine what COM port it attached itself to Go
90. amp BOREN amp LVPEN amp amp DEBUGDIS amp DUNPROT amp UNPROTECT In order to use the HI TECH compiler the Chameleon PIC libraries will need to be slightly ported to the new compiler For example in the CHAM_SYSTEM_DRV_V010 h it includes the following include p24HJ128GP502 h This include file would need to be changed to include htc h It s not too terribly difficult but some changes would need to be made in order to compile using the HI TECH C compiler By using the HI TECH compiler or the PIC24 C compiler by Microchip we eliminate the problem of compiling our code on various other platforms However there still is the problem of loading the compiled binary into the flash memory of the Chameleon PIC If you remember we have two options for loading firmware First we could load the software through a bootloader The second option is to load it using a PICkit 2 or other compatible in circuit programmer for PIC24 microcontrollers Right now the first option is not available at the time of this writing The Microchip bootloader source code is written to run in a Windows console The source code is available and located on the DVD ROM that shipped with the Chameleon PIC so a user could port this to other operating systems if needed The second option is to use the PICkit 2 and a command line tool provided by Microchip called PKCMD2 that has been released with no official support Both source code and b
91. are all handled at some point on the Propeller running the enhanced graphics driver for NTSC tile graphics With that in mind let s crack open the C C header file named CHAM PIC GFX V010 h and see what s inside If you look inside the file you will see nothing other than a conditional compilation section and the prototypes for the function API so where are all the register interface defines Well remember we have to keep all the SPI commands in a single place so the register interface are actually message IDs for the SPI messaging system Thus if you open up CHAM PIC I2C SPI VO010 h and scroll down then you will get to the section with the register interface messages for the GFX driver itself they are advanced GFX commands for GFX tile engine define GFX BASE ID 192 starting id for GFX commands to keep them away from normal command set define GPU GFX NUM COMMANDS 37 number of GFX commands define GFX SUBFUNC STATUS 0 GPU GFX BASE ID Reads the status of the GPU Writes the GPU Sub Function register and issues a high level command like copy fill etc define GFX SUBFUNC STATUS W 1 4GPU GFX BASE ID Writes status of the GPU Writes the GPU S
92. are going to build a project for each demo or change a single project re build and FLASH the file to the Chameleon PIC with the PICkit 2 programmer If you don t own a programmer then you will use the Chameleon in bootloader mode and thus you need the bootloader on the Chameleon which we deliver the unit with In this case make sure you have the serial select switch on the Chameleon in the down position so the PC can get to the serial port of the PIC since this is how the bootloader works via serial 28 1 Graphics Demos The following graphics demos illustrate examples in both NTSC and VGA modes as well as use of the advanced tile modes of the NTSC driver Each example will typically consist of the primary source file for the demo as well as System API library module CHAM PIC SYSTEM V010 c h main SPI API library module CHAM PIC I2C SPI V010 c h NTSC VGA GFX driver or all of them And any other ancillary drivers for sound keyboard etc All the required files can of course be found in the Source directory on the DVD which you should have already copied onto your hard drive located here DVD ROM CHAM SOURCE 28 1 1 NTSC Printing Demo This demo simply uses the NTSC terminal API to print Hello World to the NTSC screen Figure 28 1 shows the demo in action 207 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 28 1 NTSC terminal printing demo
93. as VGA SVGA XGA also differ substantially with the primary difference in the scan frequencies and resolutions These differences do not cause as much concern because most computer equipment is now designed to handle variable scan rates multisync monitors are now the de facto standard This compatibility is a major advantage for computer formats in that media and content can be interchanged on a global basis Table 11 2 lists some of the more popular formats along with comparisons of their specifications 49 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 11 2 Typical Frequencies for Common TV and Computer Video Formats High Definition Standard Definition Video Extended Graphics Graphics Digital Television Formal Array PC Array PC Television Format Television Format Description for North America for Most of Europe and Japan and South America Vertical Resolution A prox 480 525 Approx 575 625 1080 or 720 or 480 Format visible 4 i 480 768 lines per frame total lines total lines 18 different formats Horizontal Determined by Determined by bandwidth ranges bandwidth ranges 640 1024 line pixels per 32010650 from 320 to 720 DI RII 15 734 15 625 33 75 45 31 5 60 KHz 29 97 25 30 60 60 80 60 80 Rate Hz Highest Frequency MHz 4 2 5 5 25 15 3 40 7 Of course not listed in the table are HDMI video modes These are a whole other ballgame but ar
94. bits at a time Fills memory 8 bits at a time Copies memory 8 bits at a time Reads the tile map palette pointer Writes the tile map palette pointer Reads the pointer to the top of tilemaps Writes the pointer to the top of tilemaps 185 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Bitmap pointer access functions unsigned int GFX Read Bitmap Ptr void Reads the pointer to tile bitmaps unsigned int GFX Write Bitmap Ptr unsigned int bitmap ptr Writes the pointer to the tile bitmaps Scrolling functions NN EY Memory port functions ed unsigned int GFX_Read_Mem_Port8 void Reads Propeller memory 8 bit port int GFX_Write_Mem_Port8 unsigned int data Writes to the Propeller memory 8 bit port unsigned int GFX_Read_Mem_Port16 void Reads the Propeller memory 16 bit port unsigned int GFX_Write_Mem_Port16 unsigned int data Writes the Propeller memory 16 bit port Source and destination pointer access a 3M unsigned int GFX_Get_Src_Ptr void Retrieves the source GPU operation pointer unsigned int GFX Get Dest Ptr void Retrieves the destination GPU operation pointer unsigned int GFX Set Src Ptr unsigned int src ptr Sets the source GPU operation pointer unsigned int GFX Set Dest Ptr unsigned int dest ptr Sets the destination GPU operation pointer Tilemap width funct
95. byte which will again be ACK ed by the keyboard 00 return byte indicating scan code set in use 01 select scan code set 1 used on PC amp XT 02 select scan code set 2 03 select scan code set 3 F2 PS 2 Read Keyboard ID keyboard responds with ACK and a two byte keyboard ID of 83AB F3 Set Typematic Rate Delay keyboard responds with ACK and waits for rate delay byte Upon receipt of the rate delay byte the keyboard responds with an ACK then sets the new typematic values and scanning continues if scanning was enabled Typematic Rate Delay Option Byte 1716151413121110 typematic rate indicator see INT 16 3 I A in period formula see below B is period formula see below 60 4 5 F6 F7 F8 F9 FA FB FC FD FE FF 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit typematic delay always zero delay rate 1 250 milliseconds rate 8 A 2 B 4 17 in seconds 20 Defaults to 10 9 characters per second and a 500ms delay If a command byte byte with high bit set is received instead of an option byte this command is cancelled Enable Keyboard cause the keyboard to clear its output buffer and last typematic key and then respond with an ACK The keyboard then begins scanning Default w Disable resets keyboard to power on condition by clearing the output buffer resetting
96. case you can have 188 colored pixels per active scanline but it gets worst That doesn t necessarily mean that you can have 188 DIFFERENT colored pixels across the screen it just means you can request that from the poor TV with limited bandwidth Again this is a give take world and in many cases you would never have 188 different colors on the same line it would look like a rainbow In most cases objects have constant color for a few pixels at a time In any case many video system over drive the video to 224 240 or 256 virtual pixels but the color will not change that fast you can do this if you wish however suggest using a nice 160 x 192 display or thereabouts which will always look pretty good has enough resolution and you will almost get a 1 1 color change per pixel even if you change each pixel s color However give everything a try and see what you get 11 2 8 NTSC Signal References Here are a number of web sites and documents to help you understand the NTSC PAL video formats 55 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit http www ntsc tv com http www sxlist com TECHREF io video ntsc htm http www bealecorner com trv900 tech RS170A jpg http www bealecorner com trv900 tech http www maxim ic com appnotes cfm appnote_number 734 In en http pdfserv maxim ic com en an AN734 pdf 12 0 Keyboard amp Mouse Hardware PS 2 keyboards and mice are very similar from a hardware interface po
97. chroma color is enable h ec e luma signal is modul t Referring to the table the highest safe value to use for brightness luma is 6 and the lowest safe value is 3 so keep your luma in the range of 3 6 when using chroma otherwise the system won t have enough freedom to encode the color signal modulation since a 1 modulates your luma signal and you don t want it going out of range The color format is not something made up but a direct result of the underlying Propeller video hardware s color format that it needs to process pixels so we are stuck with it However other than the out of range luma values and the color modulation bit it s a fairly common way to encode color on 8 16 bit graphics hardware They rarely use RGB Tile Map Review That about sums up the tile engine design The physical tile map on the screen always displays 32x24 characters You can define larger virtual tile maps for scrolling that are 32 64 128 256 wide any height Each tile is 2 bytes representing the tile index character and the palette to use for the tile 4 colors Each tile bitmap is 8x8 pixels each pixel 2 bits Each 2 bit code refers to 1 of 4 colors in the palette for that tile The tile engine supports course scrolling by changing the pointer to the start of the current tile map or page flipping by moving the pointer an entire tile map length The engine also supports smooth scrolling in the vertical direction with the vertical sc
98. commands or setting need to be sent to the keyboard Power for the keyboard or mouse Specifications state no more than 100mA will be drawn but I wouldn t count on it and plan for 200mA for feature rich keyboards with lots of lights etc When both the keyboard and the host are inactive the CLOCK and DATA lines should be HIGH inactive Table 12 3 Pin out of PS 2 6 Pin Mini Din Pin Function DATA bi directional open collector NC GROUND VCC 5 100 mA CLOCK NC 12 1 1 Communication Protocol from Keyboard to Host When a key is pressed on the keyboard the keyboard logic sends the make scan code to the host computer The scan code data it is clocked out by the keyboard in an 11 bit packet the packet is shown in Figure 12 3 The packet consists of 58 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit a single LOW start bit 35 us followed by 8 data bits 70us each a parity bit and finally a HIGH stop bit Data should be sampled by the host computer on the data line on the falling edge of the CLOCK line driven by keyboard Below is the general algorithm for reading the keyboard Figure 12 3 Keyboard Serial Data Packet ity St 8 Data Bits Sent d0 d7 rh ala ot Scan Code 0x16 ASCII 1 12 1 2 Keyboard Read Algorithm The read algorithm makes the assumption that the main host has been forcing the keyboard to buffer the last key This is accomplished by holding CLOCK L
99. could lose important data thus the mouse waits to be told to start streaming the data and reporting the motion The movement data packets are formatted as shown in Table 12 5 You simply need to read these packets and send them upstream to your application 12 2 6 Reading Mouse Movement Assuming that the mouse has been initialized and is in Streaming mode with Reporting mode enabled then you simply loop and read each 3 byte movement packet As you read the first byte you use it to determine the state of the buttons as well as any overflows with the counters Then the next two bytes the X and Y deltas should be added to running counters 16 bit that track the absolute position of the mouse cursor That s it Of course this is only for your edification the Propeller driver does all this for you so all you have to do is send a simple command from the PIC to the Propeller to read the keyboard or mouse 66 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 13 0 The I O Headers The I O headers on the Chameleon PIC consist of a number signals that interface to both the PIC and Propeller chip The Propeller chip has its own 8 bit local I O port located right under the composite video and PS 2 ports The other headers surrounding the Chameleon PCB interface mostly to the PIC chip Let s take a look at the PCB for a moment for reference as shown in Figure 13 1 Figure 13 1 The Chameleon s annotated I O headers
100. d When you choose the PICkit 2 as the programmer for MPLAB a new toolbar appears on the right side of the MPLAB s existing toolbars The new toolbar should look like that in Figure 15 45 numbers are superimposed and NOT in MPLAB This toolbar is one method that we can use to control the PICkit 2 through MPLAB the other is through the Programmer menu that has been updated after selecting PICkit 2 Below is a description of the toolbar icons that are numbered from left to right in Figure 15 45 Program the target device Read target device memories Read target EEDATA memory not available with the PIC24HJ128GP502 Verify the contents of the target device Erase the target device memories Verify the target memories are erased Bring target MCLR to VDD remove device from reset so that it can operate normally Bring target MCLR to GND place device in reset Re establish PICkit 2 connection Now that the programmer is attached to the Chameleon PIC we tell the 2 device programmer to flash the binary file into the PIC24 processor To do this press the far left toolbar button Program the target device 1 as shown in Figure 15 45 This will begin loading the firmware into the Chameleon PIC and you may watch the progress through the PICkit 2 tab on the output window After it s done programming the processor the PICkit 2 automatically verifies the contents were written correctly If all was
101. driver now and you can use it to communicate with the PC or any other serial based device There are all kinds of interesting things you can do with a serial port and the Chameleon PIC for example you could get an external serial modem and write a simple BBS bulletin board system on the Chameleon PIC How cool would that be For example the TRENDnet 56k V 92 High Speed Voice Fax Modem has a standard RS 232 DB9 connector on it so you can connect quite easily to the Chameleon PIC and send standard HAYES AT commands at it Can you imagine running a BBS on your little Chameleon and then dialing in from a friend s house Here s a link to the product 231 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit hitp www tigerdirect com applications SearchTools item details asp EdpNo 671884 amp Catld 564 31 1 3 FLASH Memory Demo with XModem Protocol Bonus Example This demo illustrates how to use the onboard 1MB SPI FLASH memory Atmel part T26DF081A This is not to be confused with the Propeller chip s 64K EEPROM The EEPROM is for the Propeller s boot image and only directly accessible by the Propeller chip The 1 MB FLASH is accessible by the PIC chip via the SPI mux interface With that in mind you might want review the Chameleon as well as the data sheet for the FLASH memory located on the DVD here DVD ROM DOCS DATASHEETS Atmel AT26DF081A FLASH doc3600 pdf To use the FLASH is rel
102. each generating video VGA but being controlled by a super master unit to do something in unison Creating a Arduino Shield adapter board The Chameleon both AVR and PIC have similar I O headers to the Arduino but due to physical constraints they are different A cool piece of add on hardware would be a daughter board that mounts on top of the Chameleon to make it 100 I O compatible with Arduino shields 35 1 Demo Coder Applications Games and Langua When developing any product we always like to give a select few master programmers the hardware early to see what they come up with Not only is this a good way to find potential bugs in the hardware but it s interesting to see what some of the best programmers in the world can do with it For this release of the Chameleons we have a couple applications that will be very useful to you 35 1 1 Chameleon BASIC by David Betz Figure 35 1 A BASIC Life program running on the Chameleon The Chameleon BASIC is a complete compiled BASIC that runs on both the Chameleon AVR and PIC platforms Figure 35 1 shows an example of a Life cellular automata running written in BASIC You write your programs on the PC with and editor then download to the Chameleon The Chameleon runs a VM virtual machine that executes the compiled byte codes You can find the latest copy of BASIC on the DVD here DVD ROM CHAM_PIC SOURCE BASIC Simply locate the newest directory version and
103. entire memory contents including configuration and program memory Once the new program has been loaded onto the PIC24 the PICkit 2 will reset it and your program will begin executing By using a combination of the suggestions listed above a user can get the Chameleon PIC working on Mac and Linux In the near future the growing community of Chameleon users will no doubt hack away and create new tools that will be available if they aren t already now Make sure to continuously check out the message boards and development website for the latest software and documentation located at www chameleon dev com 257 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix Overclocking the PIC and Propeller As with any TTL or CMOS device you can always overclock them Typically 10 overclocking will work 99 of the time anything higher than 10 you have to take a few things into consideration such as power dissipation memory response times and overall timing of the chips However both the PIC and Propeller can be overclocked if you want to get more performance and are willing to potentially damage the chips 1 Overclocking the Propeller Microcontroller The Propeller uses an external clock or xtal that is then spun up by an internal PLL The PLL has a number of power of 2 clock multiplier rates but typically a 5 10MHz clock is used and then the clock multiplier is set at 8x or 16 For example the Defa
104. everything you need to get BASIC up and running is in there including documentation the compiler examples etc 248 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 35 1 2 Crate It by JT Cook Figure 35 2 Crate it running on the Chameleon PIC se PF XH Hit Enter www chameleon dev com WWw xXgamestation com JT Cook Ppt Hiroyuki Crate It shown in Figure 35 2 is used for the Chameleons as the Quick Start demo that is pre loaded on each unit To compile it you follow the same process as you would for all the other examples You can find the files for the game on the DVD here DVD ROM CHAM SOURCE DEMO CODERS CRATE You should have already copied this on your hard drive during the installation process earlier in the manual Any other newer demos will be located in the DEMO CODER directory so take a look there in case we don t update this manual to match Similarly always check the product web pages on www xgamestation com as well as www chameleon dev com Epilog From Intel 4004 to the Multiprocessing Multicore Chameleon Well you made it If you got this far then you should be a quite comfortable with the Chameleon PIC 16 Bit and see the true power of multiprocessing and the synergy between the Microchip PIC and the Parallax Propeller chip Hopefully you can use the Chameleons in many of your projects now and in the future am really excited
105. features to it since this is really the only way to get data from the PC into the FLASH memory at the moment unless you make something yourself Alright now that you have an idea about X Modem protocol let s take a step back and see how we are going to send X Modem files from the PC Sending X Modem Files from the PC Sending X Modem files from the PC is almost the same as setting it up for serial communications that is you need a program capable of X Modem file transfer Luckily there are many of them available but once again suggest that you use two of my favorites Absolute Telnet and ZOC which you can find online here Zoc http www emtec com zoc Absolute Telnet http www celestialsoftware net telnet Copies of them are also on the DVD ROM here DVD ROM CHAM TOOLS COMMUNICATIONS For this example let s use Absolute Telnet Similarly you need to install the program then create a communications profile for your USB serial COM port but this time there is a difference instead of 115 200 baud that we have been communicating at we are going to slow things down to 2400 baud This is to reduce the potential error rate to near zero So your final setup should look something like the dialog shown in Figure 31 4 below Figure 31 4 Setting up Absolute Telnet for X Modem transfers 237 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Ye Connection Properties Appearance Connec
106. find them on DVD located here DVD ROM CHAM_PIC TOOLS COMMUNICATIONS VT100 terminal running the Chameleon s serial port connected to the PC with the following settings on your terminal Data Format N81 no parity 8 data bits 1 stop bit Baud Rate 115 200 Handshaking None Terminal Mode VT100 Screen Size 80 24 or larger 120x50 is a good choice Local Echo Off Make sure that you have the serial selection switch in the DOWN position on the Chameleon PIC mode What we are going to focus on here is taking full advantage of the serial UART code and making a little Guess My Number game that runs on the Chameleon PIC but communicates via serial to a VT100 terminal running on the PC Figure 31 2 shows the demo program running Figure 31 2 Guess My Number running on the PC terminal need new image 228 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit COM31 PuTTY XGS WarG That s much b Would you like to play game The screen shot doesn t do the demo justice since there are sound effects and ASCII animation that occur When you run the demo you might have to hit RESET on the Chameleon a couple times to really appreciate the retro feel of the demo What did was play a bit on the 1980 s classic WarGames starring Mathew Broderick It s one of my favorite movies and if you haven t seen it definitely fun to watch The movie s plot was a teenage kid tried to
107. folder from the DVD ROM to your hard drive The source files can be located here DVD ROM CHAM_PIC SOURCE After the files have been copied you might need to change the permissions of the files and remove the read only flag You do this by right clicking on the source folder and selecting Properties from the pop up menu Then select the General tab and uncheck the Read only attribute flag 94 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The first step is to launch MPLAB IDE if you haven t already You may start the application by either double clicking onto the MPLAB IDE v8 xx icon on your desktop or by launching it through the Windows Start Menu Start Programs gt Microchip MPLAB IDE 8 gt IDE Once the MPLAB IDE has started you will be presented with a blank workspace as shown in Figure 15 27 Figure 15 27 Selecting the project wizard p D File Edit View Debugger Programmer Tools Configure Window Help Project Wizard sv lpi a d P OD Checksum 0 039 New a Open Close Set Active Project Quickbuild no asm file Clean Build Configuration Build Options Add New File to Project Remove File From Project Select Language Toolsuite Files t set Language Tool Locations Version Control Build Version Control Find in Files NIE
108. following location DVD ROM CHAM PIC TOOLS PIC 2 v2 61 00 Setup A setup exe After the installation wizard begins you will see a dialog as shown in Figure 15 10 85 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 10 PICkit 2 welcome screen i PICkit 2 v2 55 Welcome to the PICkit 2 2 55 Setup Wizard MICROCHIP The installer will quide you through the steps required to install PICkit 2 v2 55 on your computer WARNING This computer program is protected by copyright law and international treaties Unauthorized duplication or distribution of this program or any portion of it may result in severe civil or criminal penalties and will be prosecuted to the maximum extent possible under the law The above figure shows the PICkit 2 welcome screen along with copyright protection warnings Click the Next button to continue onto the installation folder selection Figure 15 11 2 installation location selection i PICkit 2 v2 55 Select Installation Folder AN MICROCHIP The installer will install 2 v2 55 to the following folder To install in this folder click Next To install to a different folder enter it below or click Browse Eolder C Program Files Microchip PICkit 2 v2 Browse Disk Cost Install 2 v2 55 for yourself or for anyone who uses this computer Everyone C Just me Cancel lt Back
109. functionality and take on the special functions requested However when you don t enable any peripherals each I O pin is a simple I O pin as listed in Table 1 2 Table 1 2 The PIC24HJ general pin descriptions Pin Group Description Port RA4 PAO Port A is 5 bit bi directional I O port All ports on the PIC contain Schmitt Trigger inputs for improved noise immunity Pins can drive from 3 0V to 3 6V and those with open drain capabilities can drive up to 5V output In addition pins can sink up to 4mA of current Port A contains the external oscillator and crystal drive capabilities so we will dedicate two pins for clocking the device The other pins can be used for analog voltage inputs and general purpose I O 20 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Port PB15 PBO Port B is a 16 bit bi directional I O port All ports on the PIC contain Schmitt Trigger inputs for improved noise immunity Pins can drive from 3 0V to 3 6V and those with open drain capabilities can drive up to 5V output In addition pins can sink up to 4mA of current All of Port B pins can be remapped to the different chip peripherals such as SPI UART ECAN bus in addition to being used as general purpose MCLR Reset input A low level on this pin for longer than the minimum pulse length will generate a reset even if the clock is not running OSCI RA2 Input to the inverting Oscillator amplifier and in
110. hi resolution drivers that you can employ that go all the way up to 1200x1024 or greater last time checked on the Parallax Object Exchange You can use any of these drivers with the Chameleon You just need to modify the Propeller driver module include the new VGA drivers make connections to it via commands and you are off and running 39 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 10 1 The Chameleon PIC VGA interface and support hardware RGB 2 2 2 Summer Sync R19 i VGA_RED_B1 gt p 270 NC 9 2 10 R20 VGA RED B0 gt Si 11 560 NC NC R21 VGA_GREEN_B1 gt 270 R22 NC VGA GREEN gt 560 R23 VGA BLUE B1 gt p ER 270 R24 VGA BLUE B0 gt 560 R25 VGA_LHSYNC gt 100 R26 VGA VSYNC gt m 100 The VGA hardware for the Chameleon is very minimal since the Propeller chip is doing all the signal generation with direct control of the signal via its built VSU video streaming unit Of course someone still has to write a driver for the VGA to work on the Propeller but that s been done 100x Referring to Figure 10 1 you see that there are 8 signals connected to the VGA port Table 10 1 shows the relationship between I O port bits and signals There are 2 bits for each channel Red Green and Blue as well as a single bit for HSYNC and VSYNC which are TTL level These outputs are connected directly to the HD15 connector via a series o
111. it provides a simple mechanism to access the Propellers RAM This function also updates the source pointer automatically anticipating another read or write The actual code looks like update src pointer based on auto increment value tile src addr parm tile mem autoinc parm Thus the variable tile mem autoinc parm is used as the memory increment stride each read write operation This comes in handy and reduces address updates when you access continuous memory There is of course a function to change tile mem autoinc Finally the function always returns 1 Example s Write FF to the byte of memory currently pointed to by the source memory pointer GFX Write Mem Port8 OxFF Function Prototype unsigned int GFX Read Mem Port16 void Description GFX Read Mem Port16 reads a 16 bit value from prop memory source ptr note source pointer is always used for memory port operations In the Propeller driver source ptr is the variable tile src addr parm and is set using GFX Set Src Ptr unsigned int src ptr defined below The idea of this function is that it provides a simple mechanism to access the Propeller s RAM Returns the 16 bit value read directly from the Propeller s 32K RAM This function also updates the source pointer automatically anticipating another read or write The actual code looks like update src pointer based on auto increment value tile src addr parm tile mem autoinc parm Thus the varia
112. keep it in the back of your mind lets switch gears to setting up the demo on the Chameleon and getting that ready to receive files Figure 31 5 Sending an XModem file with Absolute Telnet 238 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit File Edit Options Help D BUY NOW Courier New wi 12 Receive gt crc re to find out what s in the latest version SFTP XModem 1k Until d tt vModem ZModem xterm Connected 54 screen 80x24 cursor 1x1 Compiling and Running the Demo s The main file that we introduce to access the FLASH API is CHAM_PIC_FLASH_DRV_V010 C H Once you compile and FLASH the Chameleon with the demo it displays a menu on both the NTSC and VGA displays this is shown in Figure 31 6 below Chameleon FLASH Memory Demo Main Menu 1 XModem receive to FLASH 2 Dump FLASH to screen Selection 1 2 Referring to Figure 31 6 there are two menu options 1 Xmodem receive to FLASH 2 Dump FLASH to screen You control the menu with the local keyboard plugged into the Chameleon s PS 2 port Option 1 starts a 3 second countdown and then starts the X Modem download Thus the PC side better already have the XModem file transfer program ready and waiting Moreover the programs dumps the data to the screen in ASCII format so suggest that what your transfer its human readable Also make it short mayb
113. out the master SPI device itself as well as the ancillary SPI mux selects Using the PIC SPI interface is straightforward the steps are Initialize the hardware set speed clock phase and polarity etc Configure the PIN multiplexing Send and receive bytes via a pair of registers and possibly interrupts That s all there is to it Of course there s a lot of detail to getting things to work and believe me had my share of frustration figuring out the little quirks but the library functions provided shortly will get you up and running very quickly with SPI interfacing Also you can always write you own or use external libraries The PIC Libc system does not have any SPI library of note but there are others out there such as the PIC24 peripheral library included in the install of the PIC24 C compiler The bus is a little more complex that the SPI bus interface and protocol The reason is that the 2 bus uses only 2 signal lines SDA data SCL clock thus more protocol and conventions must be adhered to to deal with bus contention etc secondly 2 supports to 128 devices simultaneously connected to the bus This feature makes for daisy chaining devices together with as well as cheaper Of course you never get something for nothing and the bus is not without its shortcomings First it is nowhere near as fast as SPI SPI can operate at 25 MHz and even up to 50 MHz on the oth
114. painted on the screen by scanning all of the horizontal lines of the picture in one pass from the top to the bottom This is illustrated in Figure 11 4 48 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 11 4 Progressive non interlaced scanning system Scan Line NOTE Exaggerated in the vertical dimension for clarity Screen 11 2 2 Video Formats and Interfaces There are many different kinds of video signals which can be divided into either two classes those for television and those for computer displays The format of television signals varies from country to country In the United States and Japan the NTSC format is used NTSC stands for National Television Systems Committee which is the name of the organization that developed the standard In Europe the PAL format is common PAL phase alternating line developed after NTSC is an improvement over NTSC SECAM is used in France and stands for sequential coleur avec memoire color with memory It should be noted that there is a total of about 15 different sub formats contained within these three general formats Each of the formats is generally not compatible with the others Although they all utilize the same basic scanning system and represent color with a type of phase modulation they differ in specific scanning frequencies number of scan lines and color modulation techniques among others The various computer formats such
115. performs a 32 bit read from the addressed register 0 F and stores in the input register buffer REG CMD WRITE BYTE REG CMD READ BYTE 58 write byte 0 3 of output register reg out buffer byte 0 3 59 read byte 0 3 of input register g reg in buffer byte 0 3 system commands SYS RESET 64 resets the prop As you can see there is a lot of commands supported This is necessary so the PIC master client can issue commands to the Propeller slave to do what it needs it to do However this is only a template you can re write the default2 driver if you wish modify optimize change the objects it uses etc But you will have to modify all the APIs on the PIC side as well with the new commands and SPI API calls so we suggest you start simply by adding commands and or modifying commands that already exist Once a valid command is detected then its parsed and a case handler in the MCP tries to dispatch it to the proper driver object themselves running on other cores potentially An excerpt from that section of the driver code looks like this RHOD LIEN TRIAL UE LAURI LIBERARE ER ML MAIN LOOP Listen for packets to finish then execute commands sent to Prop over SPI interfac the longer this loop is the slower processing will be thus you will want to remove Nee nnus driver support fo your customer drivers and of course port to ASM and blend this with the virtual SPI driver code as well for the best per
116. portion of its abilities thru the current SPI messages no need to waste messages You can always add more Therefore the abilities you see exposed in the following are just a taste of what it can do In other words if you need more functions that the driver supports then you will have to add messages to the SPI driver and add them yourself With that in mind if you want to use the mouse driver then you need the following files added to your project CHAM PIC MOUSE V010 c Main C file source for Mouse module CHAM PIC MOUSE DRV V010 h Header file for Mouse module Mice typically have two axes and a number of buttons The two axes X and Y are decoded as the moves either mechanically roller mice or optically Inside the mouse is a microprocessor that actually handles all the decoding and sending of the information There are two ways that mice send messages absolute and relative In absolute mode the X Y position is accumulated and in relative mode the mouse sends the current change from the last positions Additionally mouse have sensitivity settings that you can control that slow or speed the relative mouse message values to the surface they are moving on Finally some mice have a Z axis which is usually the scrub wheel this is just like the X Y Finally the mice have a number of buttons these are encoded by the mouse as simple switches There is a whole mouse message API that most mice respond to but for ou
117. powerful To start with you might want to Google for PWM techniques and read up a bit Watch out since most PWM references are about using PWM for motor control Here are a few PWM articles to get your started hitp www freescale com files 32bit doc app_note MC68EZ328PWM pdf http www freescale com files 32bit doc app note MC68EZ328DTMF pdf http www intel com design mcs96 technote 3351 htm http ww1 microchip com downloads en AppNotes 00655a pdf http archive chipcenter com knowledge centers embedded todays feature showArticle jhtml articlelD 10100668 72 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 14 4 Duty cycle modes Standard PWM 50 Duty Cycle Cycle 0 i Cycle 1 Ous 2us 5us 1 005 1 545 2 005 t Time us 1 MHz Clock Average 0 2 5V 1 Time Slice 0 1 2 3 4 5 6 7 8 9 50 Duty Cycle x 5V b 045 i 2 3 4 5 6 7 8 910 t Time us 10 Mhz Clock Average 50 0 2 5V 0 5V over 10 clocks 1000ns After reading all these documents you should have a fairly good grasp of PWM techniques More or less PWM is really a method of digital to analog conversion using a single bit output along with a low pass filter that acts as an averaging or integration device A PWM signal is at fixed output frequency usually many times the highest frequency you want to synthesis for example a good rule of thumb is that the PWM signal should be 1
118. prototyping board that can be snapped off for prototyping and adding extra hardware to the Chameleon 13 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 1 1 Chameleon system level diagram NTSC TV VGA Monitor LIL I VT100 Emulator PC is running tools such as the Propeller IDE AVRStudio 3 4 and Arduino IDE R Local Mouse VIDEO AUDIO VGA PS 2 J o Keyboard or Mouse i mem Serial packets to PC SD 100 Media SPI Interface Processor i 1 Mouse E B USB serial UART FTDI virtual COM port drivers running on PC Remote Keyboard Chameleon AVRIPIC to interface to USB Rev A serial UART on Chameleon PC connection is not required Only needed for development Referring to Figure 1 1 this is a system level diagram of the relationship of the Chameleon to all the system components First everything to the right is optional and only needed for programming the Chameleon Once the Chameleon is programmed it s a standalone application that you can put anywhere you like With that in mind let s take a quick look at how things work To begin with there are two processors on the Chameleon PIC the PIC24HJ and the Parallax Propeller chip The PIC chip is used as the master processor You write your application on there in C C ASM and then using a very simply API you send messages to the Prop
119. screen Well that s easy enough you can use a specific command code for print to VGA then a single one of the 8 bit data words can hold the 8 bit character But what if you wrote a sound driver that plays wav files and you want to send down 1000 bytes Well that s easy you just have to break the process into to states or steps and then create a command for each state For example you could create a memory write command that consists of 3 sub commands Command 1 Set memory pointer addr Command 2 Write memory addr with x So Command 1 needs a 16 bit address you can fit that in the two operand bytes and command 2 needs only a single 8 of data Thus you can write 1000 bytes from addresses 2000 to 2999 with this simple algorithm for mem addr 2000 mem addr lt 2999 mem_addr send_spi_command COMMAND1 mem_addr amp OxFF mem_addr gt gt 8 send_spi_command COMMAND2 data 0 end for As you can see the 3 byte SPI command packet isn t a limitation In fact most SPI and devices use 2 byte command rather than 3 thus even more steps have to be performed for larger more complex operations 134 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 16 5 The virtual drivers used for the project Main SPI Command Dispatcher Drivers _ cham default2 drv 111 spin CHAM GFX DRV 001 TB O01 spin _ top le
120. should take place you will see a dialog like that shown in Figure 15 61 below click FINISH and this should complete the installation of the Propeller Tool IDE and the associated USB drivers it needs Figure 15 61 The final Propeller tool installation dialog y The Propeller Tool v1 05 5 Installer x Propeller Tool v1 05 5 Installation Completed The Propeller Tool 1 05 5 has been successfully installed Click Finish to exit 122 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit TROUBLESHOOTING At this point the Propeller tool should be installed and ready to go Let s test it out 15 3 1 Launching the Propeller Tool The Propeller tool communicates to the Propeller chip over a single 2 line serial connection with the standard RS 232 TX RX pair along with DTR data terminal ready as a reset line The Chameleon s USB serial port is used for the communications channel for the Propeller chip However if you recall the USB serial port can be used by the PIC or the Propeller The device that gets connected to the port is controlled by the serial selection switch next to the RESET button Simply place the switch in the UPPER position to select the Propeller chip to have access to the USB serial port This is shown in Figure 15 62 below Figure 15 62 Placing the Chameleon into Propeller serial mode ri Seni ce
121. slightly different but more or less with a little work any program designed for the Arduino can be ported to the Chameleon in a matter of minutes Then you get the power of the Propeller media processor to display text graphics read keyboards mice and make sounds etc As an example imagine you have an Arduino servo controller program and it uses one of the PWM ports on the AVR 328P Since we are using the same chip the Chameleon has the same PWM ports and we export the pins out to the digital and analog I O headers just like the Arduino But now imagine that instead of just sending a signal on the digital ports to move the servo right or left you can use a PS 2 keyboard Or mouse And now imagine that you can display the position and angle on a VGA monitor and even draw the servo in color graphics on the screen So the Chameleon is like a super charged Arduino with support for graphics audio keyboard mice and much more And the cool thing is that the code you have to write to support the added features and capabilities of the Chameleon are usually just a few lines that call API functions to communicate with the Parallax Propeller media processor IMPORTANT So without further ado let s begin 12 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 1 0 Architectural Overview Part Hardware Manual Figure 1 0 The Chameleon PIC 16 Bit OCOOO000000000000 o00000000000000
122. suggestion in Section 15 1 1 Installing MPLAB IDE 8 xx and left the default installation directory as is then you do not have to worry about selecting the destination folder here Simply press Next to continue otherwise click the Browse button as shown in Figure 15 20 and select an appropriate install location 91 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 21 Additional install components for C compiler 2 Select Com ponents In the options list below select the checkboxes for the options that you would like to have installed The disk space fields reflect the requirements of the options you have selected Executables standard headers and libraries are always installed Examples 224k Documents 16409 Standard Library Source 648 Peripheral Library Source 10666 k Disk Space Required 27947 k Disk Space Remaining 6148564 k lt Back The above figure shows the optional installation components you can add or remove We will install everything in this compiler so leave all items checked and press lt Next gt to move onto the next screen Figure 15 22 PIC24 C install for all or current user only 2 Current User Would you like to install for all users on this computer or only the current user Install for current user only C Install for all users requires Administrator privileges Would you like to put a shortcut to the com
123. that we use a PWM frequency of 256 KHz and we want to play a 1 KHz sine wave then this means that each second there are 256 000 PWM pulses we want to index into our table and play 1000 iterations of our data which has a length of 256 entries thus we need to index into our table at a rate of 256 000 1000 256 1 Interesting so every cycle we simple increment a counter into the sine table and output the appropriate duty cycle in the table lookup This is shown in Figure 14 6 As another example say we want to synthesis a 240 Hz signal then let s see what we would need 256 000 240 256 4 16 In this case we would increment a counter until it reached 4 then we would increment our index into our sine table But this example as well as the last should bring something to your attention there is a max frequency we can synthesis and our signal synthesis is going to be inaccurate for anything but integral divisors so that s an issue we need to address in a moment First let s look at the maximum signal frequency if you want to play back all 256 sine samples then the maximum signal frequency is always 75 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Maximum Synthesis Frequency PWM frequency Number of Samples per Cycle Which in this example is 256 000 256 1000 Hz So you have two options either increase the PWM frequency or index into your sample table at larger intervals This problem along
124. the Chameleon PIC 16 Bit need an ISP in circuit programmer and to use another tool Thus you first write your code with AVRStudio compile it then you have a binary that you download with yet another software tool and a physical ISP programmer This again is a nightmare and a mess for newbies so the Ardunio guys also integrated this into the tool and supplied a bootloader on the AVR chips their Arduino s ship with therefore all you need is a serial connection to the AVR chip on the Ardunio hardware and the Arduino tool can initiate communications and download to the FLASH memory Therefore with a single AVR chip programmed with the Arduino bootloader and the Ardunio software tool you can write code and immediately download to the chip Moreover they ported the tool to Mac and Linux so the experience from Windows to Mac OS X to Linux is more or less the same once you have the tool installed This is good since AVRStudio does NOT even work on Mac or Linux Anyway knew had to try and be compatible with the Arduino tool since it would be very cool if people could use Arduino software and tools on the Chameleons Of course was using the new Atmel 328P in my designs and Arduino was still using the Atmel 168 but hoped they would upgrade in time and they did So now the Chameleons will run the Arduino tool chain and you can use Chameleons as supped up Arduinos Of course our boards are physically different and our headers are
125. the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media IO drivers all the API functions do including the Mouse is expose some of the base functionality in nice function calls so you don t have to send SPI messages yourself Now the one thing about mice and keyboards is they are really SLOW thus its typically a problem reading them since your CPU has to slow down to do so therefore it s really nice for a core on the Propeller to completely handle the mouse for you For the mouse we decided to use a base driver from the original Propeller objects development that was designed to communicate to a standard PS 2 mouse nothing fancy The same driver is used in both Default and Default2 so the same idea apply to either driver you load on the Propeller CHAM DEFAULT1 DRV 112 SPIN or CHAM DEFAULT2 DRV 112 SPIN The actual driver object used for the mouse is mouse 010 spin Basic PS 2 mouse driver originally written by Parallax 201 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit However only exposed a
126. the source and change them to match the Chameleon s Peripheral devices The Chameleon does not have a NES game port for example so any game or program on the HYDRA that you want to port you will need to delete that peripheral code or swap it for something else Of course you can always hack a connector to the Propeller Local port and connect the controller there and switch the pins in the source code Also the Chameleon s uses a 2 line version of the keyboard and mouse drivers the HYDRA and other Propeller development boards might use a 4 signal version so watch out for that And lastly the Chameleon has a single sound PWM sound pin that routes to the RCA header some Propeller dev boards use stereo sound so in those cases you will want to route one of those pins to the Chameleon pin and leave the other dead or maybe out to the local 8 bit port Other than those 3 areas find that it takes a few mins to port anything from the HYDRA or a Propeller Development board to the Chameleon and use it in Stand Alone mode so pretty cool Appendix G Running on the Mac and Linux Currently MPLAB and Microchip s other software development projects have been exclusively made for Windows OS This causes some problems for those who run Linux and or Mac OS X operating systems Now there is always the option to run a Virtual Machine on these platforms but that almost defeats the purpose however it does work even when using the PICkit 2 We hav
127. the voltage at the 75 Ohm VGA input realizing we have a voltage divider configuration VGA IN RED 3 3V 75 Ohm 270 Ohm 560 Ohm 75 Ohm 0 95V Which is what we desire performing similar math for all 4 combinations of inputs we get the results shown in Table 10 2 for codes Table 10 2 VGA input voltages for all 2 bit inputs BO Code VGA Voltage Description Considering there are 4 shades of each channel G and B that means that there are a total of 4 4 4 64 colors available in VGA mode without any tricks Not bad For reference the VGA connector has the following pin out shown in Table 10 3 The VGA port on the Chameleon PIC is a female HD15 High Density which is standard on the back of video card hardware It will connect to any VGA monitor but be careful when making connections it s a special low profile connector and not that sturdy so hold it when you plug the cable into it 41 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 10 3 VGA female header pin out HD15 5 Function Color Code most manufactures RED Video BLACK GREEN Video BLACK WHITE BLUE Video BROWN RED Ground ORANGE 12 ID1 NC PURPLE 15 NC SHRIMP CO N gt on The VGA standard is much easier to understand that the NTSC standard is in fact using a visual explanation Figure 10 3 is usually all people need to see but still there are some gotcha s so we are going to disc
128. top not ANSI SYS CSIn k m SGR Sets SGR Select Graphic Rendition parameters After CSI can be zero or more parameters separated with With no parameters CSI m is treated as CSI 0 m reset normal which is typical of most of the ANSI codes CSI 6n Reports the cursor position to the application as as though typed at the keyboard ESC n mR where n is the row and m is the column May not work on MS DOS Saves the cursor position Restores the cursor position CSI 25 DECTC Hides the cursor EM CSI 25h DECTC Shows the cursor EM CSInK E EL SU Color Table for Select Graphics Rendition SGR Commands Intensity 0 1 2 3 4 5 6 7 9 Normal BB EMTS BB White reset Bright BEREM 61882 Yellow 2175 125808 Cyan White 261 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit SGR Select Graphic Rendition Parameters Code Effect Note 0 Reset Normal all attributes off 1 Intensity Bold 2 Intensity Faint not widely supported 3 Italic on not widely supported Sometimes treated as inverse 4 Underline Single not widely supported 5 Blink Slow less than 150 per minute 6 Blink Rapid MS DOS ANSI SYS 150 per minute or more 7 Image Negative inverse or reverse swap foreground and background 8 Conceal not widely supported 21 Underline Double 22 Intensity Normal not bold and not faint 24 Underline None 25 Blink off 27 Image Positive 28 Reveal
129. transition to NAK sta xstate break case XSTATE SEND NAK DEBUG XMODEM gt 2 NTSC Term Print XSTATE SEND NAK XSTATE SEND NAK start the transmission the variables and data structures for the xmodem transmission e to initiate xmode transfer or resend current packet NTSC Term Char 0x0D NTSC Term Pri nt S NAK NTSC Term Char 0 00 endi f send and wai UART putc CHR NAK wait for a packet xstate XSTATE_ RECEIVE PACKET break d qua E Il receives the packet if DEBUG XMODEM gt 2 NTSC Term Print XSTATE RECEIVE PACKET NTSC Term Char 0x0D dendi f wait for result while 1 ch UART getc if ch CHR SOH ch CHR EOT break end while i f DEBUG XMODEM gt 2 sprintf sbuffer Looking for SOT EOT d c ch 0 0 NTSC Term Print sbuffer endi f we have the first byte test for SOH or EOT if CHR_SOH DEBUG XMODEM gt 2 NTSC Term Pri nt R SOH NTSC Term Char 0x0D endi f end if SOH o ch CHR EOT DEBUG AMOC EN ee 0 TSC Term Pri nt UM eU NTSC Ter m Char 0x0D dendi f xstate XSTATE EOT break Il end if get packet number while ch UART getc if ch 1 ch CHR CTRLZ break end while xpacketnum ch if DEBUG XMODEM gt 2 sprintf sbuffer Packet d r xpacketnum NTSC Term Print sbuffer dendi f get packet number complement
130. typematic rate delay resetting last typematic key and setting default key types The keyboard responds with an ACK and waits for the next instruction Set Default resets to power on condition by clearing the output buffer resetting typematic rate delay and last typematic key and sets default key types The keyboard responds with an ACK and continues scanning PS 2 Set Keys to Typematic keyboard responds by sending clearing its output buffer and setting the key type to Typematic Scanning continues if scanning was enabled This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set Keys to Make Break keyboard responds by sending an clearing its output buffer and setting the key type to Make Break Scanning continues if scanning was enabled This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set All Keys to Make keyboard responds by sending an ACK clearing its output buffer and setting the key type to Make Scanning continues if scanning was enabled This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set Keys to Typematic Make Break keyboard responds by sending an clearing its output buffer and setting the key type to Typematic Make Break Scanning continues if scanning was enabled This command may be sent while using any Scan
131. well the output window will say 2 Ready 106 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The final step is to release the Chameleon PIC from reset which will also release the Propeller as well since the resets are the same You can do this by either unplugging the PICkit 2 programmer or more easily press the Bring target MCLR to VDD 7 toolbar button Now plug your Chameleon PIC into your NTSC television and VGA monitor and verify your screen looks similar to Figure 15 46 Figure 15 46 Hello World Demo running on NTSC television 4000 aS 89 TCIIES TI Lal n J E Son Wa ol EE abel abo alee eri Foa asos ngo w r ee La gt o d e gt di a GRE riot 6 LI Z 4 If you are having difficulties getting your Chameleon PIC to program properly or video is not displaying you may try the suggestions below e 5 your PICkit 2 programmer plugged into the USB port and enumerated properly The first indicator is whether or not the green power LED is lit on the PICkit 2 Additional error messages may also be displayed in the output window e 5 the Chameleon PIC powered from a 9 12V DC or USB cable power source and turned ON e 5 th
132. whenever it receives invalid data from the mouse The mouse responds by resending the last packet it sent to the host If the mouse responds to the Resend command with another invalid packet the host may either issue another Resend command issue an Error command cycle the mouse s power supply to reset the mouse or it may inhibit communication by bringing the Clock line low The action taken depends on the host F6 Set Defaults The mouse responds with acknowledge FA then loads the following values into its driver Sampling rate 100 Resolution 4 counts mm Scaling 1 1 Disable Data Reporting The mouse then resets its movement counters and enters Stream mode F5 Disable Data Reporting The mouse responds with acknowledge FA then disables Data Reporting mode and resets its movement counters This only effects data reporting in Stream mode and does not disable sampling Disabled Stream mode functions the same as Remote mode F4 Enable Data Reporting The mouse responds with acknowledge FA then enables Data Reporting mode and resets its movement counters This command may be issued while the mouse is in Remote mode or Stream mode but it will only effect data reporting in Stream mode F3 Set Sample Rate The mouse responds with acknowledge FA then reads one more byte from the host which represents the sample rate in unsigned 8 bit magnitude format The mouse saves this byte as the new sample rate
133. you re done call Flash Close and that s it If you want to write to the flash memory then in addition to the Flash Open call you must make sure that the blocks or sectors you want to write to have been erased first once they are erased you can write to them The erase function is Flash Erase and as long as you have done that once before writing or know that the FLASH is already erased then you call Flash Write and write one or more bytes anywhere in the FLASH once again call Flash Close when you re done Summary In this chapter you not only learned about the cool 1 MB Flash memory the Chameleon has but got a taste of file transfer protocols Hopefully you can take our 30 minute X Modem file transfer function and spend a good day on it and really make it robust 241 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 32 1 Native Mode Bootloader mode Currently there are two ways to use the Chameleon PIC Bootloader Mode with the Microchip bootloader pre loaded into FLASH memory Native Mode with MPLAB generating a complete FLASH image The bootloader mode is convenient since the Microchip DOS console tool can download to the Chameleon or Arduino with nothing more than a serial port The native mode is nice since you have full control and you can write large complex programs that take up all the space of the PIC download them into the PIC and not worry about the bootloader section gettin
134. 0 100x greater than the frequencies you want to synthesis Also the PWM period is fixed the modulation of information in the PWM signal is in the duty cycle of the signal Recall duty cycle is defined as Duty Cycle Time Waveform is HIGH Total Period of Waveform For example say we had 1KHz signal this means the period is 1 1KHz 1mS 1000 us Now let s say we are talking about square waves in a digital system with a HIGH of 5V and a LOW of OV Furthermore let s say that the duty cycle is 20 what would the final waveform look like Figure 14 4 a depicts this As you can see the waveform is HIGH 20 of the total period or 200 us and the waveform is LOW 800 us Therefore if you were to average this signal f t over time you would find that the average is simply the area under the HIGH part divided by the total AREA of the waveform which is Average Signal 20 duty cycle 5V 200 us 1000 us 1 00V This is a VERY interesting result by just varying the time we pulse a digital output HIGH we can create an analog voltage Thus we can modulate the analog voltage in any shape we wish to create a final waveform of any shape we want sounds explosions voices etc plus since this is all digital we can synthesis as many channels as we wish since at the end of the day we need only a single bit as the output Figure 14 4 b shows another PWM like technique where instead of modulating the duty cycle instead complete 50
135. 000 Hz at 10 msec intervals Sound Play 0 100 0 ior 100 lt 000 gd v 200 197 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 24 0 Keyboard Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media IO drivers all the API functions do including the Keyboard is expose some of the base functionality in nice function calls so you don t have to send SPI messages yourself Now the one thing about keyboards and mice is they are really SLOW thus its typically a problem reading them since your CPU has to slow down to do so therefore it s really nice for a core on the Propeller to completely handle the keyboard and queue up keypresses for you For the keyboard we decided to use a base driver from the original Propeller objects development that was designed to communicate to a standard PS 2 keyboard nothing fancy The same driver is used in both Default1 and Default2 s
136. 005 00000101 21 15 025 00010101 37 25 045 00100101 53 35 065 00110101 6 6 006 00000110 22 16 026 00010110 38 26 046 00100110 54 36 066 00110110 7 007 00000111 23 7 027 00010111 39 27 047 00100111 55 37 067 00110111 8 8 010 00001000 24 18 030 00011000 40 28 050 00101000 56 38 070 00111000 9 9 011 00001001 25 19 031 00011001 41 29 051 00101001 57 39 071 00111001 10 012 00001010 26 1 032 00011010 42 2 052 00101010 58 072 00111010 11 013 00001011 27 1B 033 00011011 43 2B 053 00101011 59 3B 073 00111011 12 C 014 00001100 28 1C 034 00011100 44 2C 054 00101100 60 3C 074 00111100 13 D 015 00001101 29 1D 035 00011101 45 2D 055 00101101 61 3D 075 00111101 14 E 016 00001110 30 1 036 00011110 46 2 056 00101110 62 076 00111110 15 017 00001111 31 037 00011111 47 2 057 00101111 63 077 00111111 Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin 64 40 100 01000000 80 50 120 01010000 96 60 140 01100000 112 70 160 01110000 65 41 101 01000001 81 51 121 01010001 97 61 141 01100001 113 71 161 01110001 66 42 102 01000010 82 52 122 01010010 98 62 142 01100010 114 72 162 01110010 67 43 103 01000011 83 53 123 01010011 99 63 143 01100011 115 73 163 01110011 68 44 104 01000100 84 54 124 01010100 100 64 144 01100100 116 74 164 01110100 69 45 105 01000101 85 55 125 01010101 101 65 145 01100101 117 75 165 01110101 70 46 106 01000110 86 56 126 01010110 102 66 146 01100110 118 76 166 01110110 71 47 107 01000111 87 57 127 01010111 103
137. 009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 10 0 VGA GRAPHICS HARDWARE 38 10 1 Origi ns of the VGA c 39 10 2 Hardware eoe inur EIFE PAKES KUNENE ININE IKUN EIFE ENK SEK AKEE ETNE FINE SiT 40 10 3 VGA Signal Primei Sias 42 10 3 1 VGA Honzontal Timing siiri a te ee RE Srs 44 10 3 2 VGA Vertical TIMIN a E E he RA IS eel E eame pedi leet nS 44 10 3 3 Gener ting the Active Video ecce etes idea eite tei e rebate Pec eee 45 11 0 NTSC PAL COMPOSITE VIDEO HARDWARE 46 11 1 Video Hardware Inter face ssssssssssrserssssrsersessrsersessrsessssersessssssessessssessessssessesensessesessnssesensesscsensesecseneasscsensnsssseneesessensessesenees 46 11 2 Introduction to NTSC 47 11 2 1 Interlaced versus Progressive Scans i i A E 47 11 2 2 Video Formats and Interfaces 49 11 2 3 Composite Color Video Blanking Sync Interface 50 11 24 Ea 52 112 5 Putting 1AM oae eto 52
138. 0ClearScreen blanks out the terminal screen that is connected to the Cham PIC You have to use a VT100 aware terminal emulator and set its mode to VT100 emulation for this command to work Example s This example shows a simple usage scenario headers and globals go here int main voi d Unsigned char ReadValue 152 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Always call SYS ConfigureClock first after main begins SYS ConfigureCl ock MAX FCY RATE Configure clock for max initialization code goes here UART nit 115200 n e screen Screen UART v Now UART v ea 0 RESE ae terminal to its defaults h I continue code Function Prototype void UART_vt100SetCursor unsigned char Line unsigned char Column Parameters Line The line to place the cursor on Ranging from 0 gt 255 Column The column to place the cursor on Ranging from 0 gt 255 Return None Description UART vtt100SetCursor sets the cursor of the VT100 terminal This can be forward or backwards from the current cursor position Often times you will both clear the screen and set the cursor back to 0 0 to start a new text page Example s This example shows a simple usage scenario en arScreen t in different locations C rsor 0 0 Cursor 23 1 are you Function Prototype void UART_vt100SetAttr unsigned char
139. 12 SPIN we are using the following Propeller Object for the NTSC tile engine and text display CHAM_GFX_DRV_001_TB_001 SPIN NTSC tile engine with support for terminal mode graphics as well as tile graphics smooth scrolling color manipulation large playfields fixed font 8x8 with 32x24 characters on the screen at one time In essence the mode acts like a console or terminal you can print to it it will scroll when you print the last line etc Additionally it supports more advanced graphics like functions for gaming applications but we will discuss that in the next section If your TV LCD has trouble displaying this driver s output then you can use the other default driver that uses the generic Parallax NTSC tile driver not as powerful but more stable signal The name of that driver is CHAM DEFAULT1 DRV 112 SPIN Then it loads the following driver for NTSC TV Text Half Height 011 spin NTSC tile engine with 40x30 characters max resolution limited scrolling no redefinition of characters Hopefully you can use the standard default2 driver which includes the more advanced graphics tile engine which supports game like applications But again the point is you can change the Propeller driver and re write it as you wish we simply give you a starting point to get going with So if you want to know what the driver supports you can always peek into the driver itself CHAM GFX DRV 001 TB 001 SPIN and to see the messages that ar
140. 12 X 32 512 X 32 512 X32 512 X 32 512 X 32 512 X 32 512 32 P22 C P6 RAM RAM RAM RAM RAM RAM RAM RAM P21 5 Processor Processor Processor Processor Processor Processor Processor Processor P20 CPA LE CP18 P2 CP17 C P1 CPO 32 a _ _ 1 Pin Inputs System Counter Data Bus Address Bus Power Up Detector 710 ms Reset Delay R 50 ms Brown Out GOEN Detector CLKSEL 8192 X 32 RC Oscillator 6192 X 32 RO SOFTRES 12 MHz 20 KHz Cog Enabl m 5 Selector CLOC MUX Lock Bits 8 PLLENA Clock PLL 1x 2x 4x 8x 16x 16x must be Crystal 64 128 MHz Cxo Oscillator DC 80 MHz OSCENA 4 8 MHz OSCMODE 2 with Clock PLL Hub and Cog Interaction 24 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The Parallax Propeller chip is a low cost multicore processor with a very simple design and programming model Referring to Figure 1 8 take a look at the block diagram of the chip The Propeller chip consists of 8 symmetrical processing units cores that are identical Each core has a 32 bit CPU 512 32 bit words of memory a pair of counters and a crude video streaming unit The cores run at 80MHz nominal and take 4 clocks to execute an instruction Therefore each core is capable of running at 20 MIPs Additionally each core has access to the 32 I O pins of the chip as well as a shared 32K Byte RAM and 32K Byte ROM Access to the RAM is arbitrated by a hu
141. 16 Bit Kit Figure 1 2 Chameleon PIC kit contents BREAK AWAY SCORING SAPS Ree eee eae Zaeapeaegcegrrraereanruna RXZEXARAREXEEARARZLUBRETEUELS Keer eee eee ee Se ee Se ee ee PROGRAMING ADAPTER BREAK AWAY SCORING Bi COLOR LED You should have the following items in your kit referring to Figure 1 2 Chameleon PIC 16 Bit System Board DVD ROM with all the software demos IDE tools and this document White solderless experimenter board to be affixed to break away experimenter prototyping area on Chameleon if desired 1 Bi color Red Green LED 6 pin right angle male header for connecting to the 2 programmer Not Included 9V power supply with tip ring 2 1mm barrel Mini B USB cable to go from PC to Chameleon PIC PICkit 2 ISP Programmer The Chameleon will run off the USB cable so you do not require a wall adapter for development Also the Chameleon PIC is pre loaded with the microchip PIC24 bootloader therefore if you use the Chameleon in bootloader mode only you 15 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit will not need a Microchip PICkit 2 programmer but we recommended one so that you can use MPLAB to write more advanced C C and ASM programs and to have more control over the platform Additi
142. 2 ICD interface to the female Chameleon PIC programming port Figure 15 43 Plugging the PICkit 2 into the Chameleon PIC note the white arrow is AWAY from the Propeller chip 7 Referring to Figure 15 43 the first step is to insert the right angle header into the 2 Next insert the complete assembly into the 6 pin not the 8 pin Propeller port PIC24 programming header When you insert the PICkit 2 into the Chameleon PIC the PICkit 2 will not lay flush on the board instead it will be propped up at an angle this is fine Make sure the white arrow is facing away from the Propeller chip and is closer to the experimenter board region as shown in Figure 15 43 The other end of the PICkit 2 is connected to a USB cable that is attached to any free USB port on the PC that is running MPLAB IDE Now we need to tell MPLAB that we will be using the PICkit 2 as our primary programming device To select the PICkit 2 choose the menu item located under Programmer Select Programmer PICkit 2 as can be seen in Figure 15 44 105 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 44 Selecting the PICkit 2 programmer Demo MPLAB IDE v8 15 File Edit View Project Debugger 7 Tools Configure Window Help n Rea v None a T 1 MPLAB ICD 2 Ill Demo mcw Demo mcp Figure 15 45 PICkit 2 programmer toolbar 12343 45 B T UR FL
143. 2 hardware and software PIC 24 C compiler a k a C30 compiler TextPad and Serial Bootloader Propeller IDE If you do not own a 2 or similar in circuit programmer then you can skim the first section 15 1 Microchip s MPLAB IDE Toolchain Overview Microchip s MPLAB is the premier development tool for PIC processors The tool is 100 free supports assembly language natively and allows multiple C compilers to be plugged in Like all tool chains this can be quite complex and a single incorrect checkbox can wreak havoc on many installation making them useless For this reason we will cover the installation of all main tools in the chain step by step For those of you reading that are already expert in the installation of MPLAB then you can skim this section and jump to the PIC24 C compiler installation 79 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 1 The relationship of the various PIC programming tools the tool chain PIC24 C Compiler MPLAB IDE 8 xx This plug in compiler is provided by Microchip A student edition is available Currently only supports This is the main application Windows Linux and MacOS you will develop your code with in the works Programmer Chameleon PIC 16 Bit L M l Hardware programmer debugger Referring to Figure 15 1 you can see that there are th
144. 2 shows a screen shot of the font file for reference Tile Bitmap Format Figure 22 2 the tile engine font I added a couple Space Invaders at the end for fun AE LE HWHlc lt GABCDEF GHI TK MNOPORSTUUMXVZE pbcde tahi Jk 1mnopurnrztuuvueuwzxuyz _ P li The font bitmap was converted using a tool wrote which you can find here DVD ROM CHAM_PIC TOOLS GRAPHICS BMP2SPIN EXE The tool takes as an input a BMP file and outputs SPIN compatible data statements Read the C source file for the control parameters and to understand how it works For example the output of the tool for the character looks like this Extracted from file c64 font 05 166 bmp at tile 1 0 size 8 8 palette index 1 c64 font 05 txl1 ty0 bitmap ORD WORD 1 11 Dr WORD 1 1 ray I pA ae The tool outputs a text line description of the location and file where the tile was extracted from then encodes the tile in 2 bit pixels where each 2 bit pixel value represents one of four colors from the tile palette to use Thus each tile has its own palette of 4 colors Also you may notice the funny character sequence this is how SPIN indicates binary representation but means to use 2 bit encoding to simplify your typing thus instead of writing 005 01 5 105 115 we can write 1 2 3 4 which is convenient Summing up each tile is a 8x8 pixels Each
145. 3 E9 351 11101001 249 F9 371 11111000 202 312 11001010 218 DA 332 11011010 284 EA 352 11101010 250 FA 372 11111001 203 CB 313 11001011 219 333 11011011 235 EB 353 11101011 251 FB 373 11111010 204 314 11001100 220 DC 334 11011100 236 EC 354 11101100 252 374 11111011 205 CD 315 11001101 221 DD 335 11011101 237 ED 355 11101101 253 375 11111100 206 CE 316 11001110 222 DE 336 11011110 238 EE 356 11101110 254 376 11111101 207 317 11001111 223 DF 337 11011111 239 EF 357 11101111 255 377 11111110 11111111 260 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix J ANSI Terminal Codes This appendix lists some of the more popular ANSI X3 64 terminal codes used to control graphically terminals and make really cool graphics on 8 bit computers The majority of ANSI codes start off with the ANSI escape sequence which is the characters ESC ASCII decimal 27 hex 0x1B and left bracket in other words ESC Where ESC is actually the decimal value 27 This sequence is called CSI for Control Sequence Introducer or Control Sequence Initiator There is a single character CSI value 155 or Ox9B hex The ESC two character sequence is more often used than the single character alternatives Devices supporting only ASCII 7 bits or which implement 8 bit code pages which use the 0x80 0x9F control character range for other purposes will recognize only the two charac
146. 32R 20 USB_RTSn USB_CTSn USB MINI B FEMALE USB Rin lt T gt UsB 0 lt T gt UsB 4 USB DTR Reset Signal Conditioning C16 USB_DTRn USB_RTSn OtuF Q1 2N3904 USB 5VOUT iD R11 zx erm 330 Referring to Figure 6 1 this is the USB to serial converter designed into the Chameleon PIC It s based on a FTDI FT232R USB to serial UART chip The chip works by converting a USB packet stream into a standard serial port signal set Of course the other end of the USB cable has to be plugged in a PC running the custom FTDI USB drivers that create virtual COM ports from the operating system s perspective This magical little chip lets us talk serial to the Chameleon with a USB port FTDI has written drivers for Windows Linux and Mac OS X so these chips are quite popular since it s very difficult to find a real DB9 RS 232 serial port on a PC anymore You can take a look at the data sheet for the chip here DVD ROM CHAM DOCS DATASHEETS DS FT232R pdf Considering all that let s take a quick look at the design The USB cable from the PC plugs into H1 which is a Mini B USB header the USB packets are converted into a serial stream by the chip and the standard RS 232 signals are generated by the chip We are only interested in TX RX and DTR data terminal ready which is used to reset the Propeller and PIC by both the Propeller tool and bootloader tools respectively The TX RX signals are r
147. 36 data entries in our virtual table and 256 in the real table 2 The PWM frequency is 256K NUM_INCREMENTS The number of times that the PWM signal increments thru the final signal table in ONE complete wave cycle This is shown in Figure 14 7 In other words NUM INCREMENTS signal period PWM period PWM frequency signal frequency Now let s compute PHASE_INC PHASE_INC 65536 NUM_INCREMENTS That is the PHASE_INC is the rate at which we need to increment thru the data table to maintain the relationship so that the output is changing at the rate of the signal frequency Now plugging this all in together and moving things around a bit PHASE_INC 65536 signal frequency PWM frequency And of course PHASE_ACC is simply set to 0 to begin with when the algorithm starts As an example let s compute some values and see if it works First let s try a 1KHz signal and see what we get PHASE_INC 65536 1KHz 256 000 256 So this means that we add 256 to the phase accumulator each PWM cycle then use the upper 8 bits of the phase accumulator as the index let s try ita few cycles as see of it works Table 14 2 Test of PWM algorithm at 1KHz with PHASE INC of 256 Iteration PHASE INC PHASE ACC PHASE ACC upper 8 bits et 256 0 256 256 256 512 o A Co N O AJOIN 256 1024 256 1280 256 1536 256 1792 N N Refe
148. 40 MHz Since the PIC has divisor and multiplier registers for its PLL we can run the PLL at different intervals than the Propeller For example we currently connect to the PIC a 5 MHz xtal and then use the onboard PLL to multiply that clock rate by 8X for a nominal speed of 40 MHz However with our divisor and multiplier we can take that 5 MHz and clock it at non integer rates allowing us to achieve 45 MHz and above hesitate suggesting going above 45 MHz because have successfully gotten some PIC24s to work at 50 MHz and some did not It was just purely device dependent on its max rate However 45 MHz seemed to work fine for the most part The chip will get hotter but not too much One thing you can do to dissipate the heat on the PIC chip if it becomes problematic is to get some silicon sealant and adhere something metal preferably a heat sink to the top of the PIC In conclusion the PIC24 will go 45 MHz no problem without any changes to the Vcc voltage or heatsinking needed 258 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix ASCII Binary Hex Octal Universal Lookup Tables ASCII Hex Table ASCII Hex Symbol ASCII Hex Symbol ASCII Hex Symbol ASCII Hex Symbol 0 0 NUL 16 10 DLE 32 20 space 48 30 0 1 1 SOH 17 11 DC1 33 21 49 31 1 2 2 STX 18 12 DC2 34 22 50 32 2 3 3 ETX 19 13 DC3 35 23 51 33 3 4 4 EOT 20 14 DC4 36 24 52 34 4 5 5 ENQ 21 15 NAK 37 25 53 35 5 6 6 22 16
149. 5 As you can see the palettes are defined at the label tile pallete map and each entry is s a LONG The register you access the palettes from in the global register interface is called tile palettes base ptr parm You can read or write this pointer and thus modify palette entries Now let s talk about the format of each color The color format is always the same the 32 bits of each palette entry represent 4 possible colors that are indexed by the 2 bit pixel data the colors are encoded as a single byte each in the following way Where each color byte is encoded as follows Composite Video Color Byte Format Luma 0 7 Fadl Modulation Enable 0 disable chroma color modulation 1 enable chroma color burst modulation org eh T E Color phase shift for color burst signal 0 15 this selects 1 of 16 phase shifts which represent 16 colors around the color wheel for NTSC PAL modes The color byte is used to represent everything you do with Propeller video for example sync black color burst and active video By setting different bits you can create colors that represent these signals For example Table 22 1 below shows how to create black sync color burst shades of gray and colors with any intensity 180 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 22 1 Color encoding for various color values Desired Sig
150. 67 147 01100111 119 T7 167 01110111 259 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 72 48 110 01001000 88 58 130 01011000 104 68 150 01101000 120 78 170 01111000 73 49 111 01001001 89 59 131 01011001 105 69 151 01101001 121 79 171 01111001 74 4A 112 01001010 90 5A 132 01011010 106 6A 152 01101010 122 7 172 01111010 75 4B 113 01001011 91 5B 133 01011011 107 6B 153 01101011 123 7B 173 01111011 76 4C 114 01001100 92 5C 134 01011100 108 6 154 01101100 124 7C 174 01111100 77 4D 115 01001101 93 5D 135 01011101 109 6D 155 01101101 125 70 175 01111101 78 4E 116 01001110 94 136 01011110 110 6E 156 01101110 126 7E 176 01111110 79 4F 117 01001111 95 137 01011111 111 6F 157 01101111 127 7F 177 01111111 Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin 128 80 200 10000000 144 90 220 10010000 160 240 10100000 176 BO 260 10110000 129 81 201 10000001 145 91 221 10010001 161 A1 241 10100001 177 261 10110001 130 82 202 10000010 146 92 222 10010010 162 2 242 10100010 178 B2 262 10110010 181 83 203 10000011 147 93 223 10010011 163 243 10100011 179 B3 263 10110011 132 84 204 10000100 148 94 224 10010100 164 244 10100100 180 264 10110100 133 85 205 10000101 149 95 225 10010101 165 5 245 10100101 181 5 265 10110101 134 86 206 10000110 155 96 226 10010110 166 AG 246 10100110 182 B6 266 10110110 135 87 207 10000111 151 97 227 10010111 167 7 247 10100111 183 B7 267 10110111 136 88 210
151. 7 Qm 0 D NS sound dr 052 11khe_ 16bit CHAM GFX DRV 001 TB t1 COMMENTS 9509 exon MEL tile this driver This is the L3 C sdvenced ryta piogammea pie emi river enduro cun an Program 4 613 Longs D anm eva 2 ide Variable 42310095 Pils 3 video U c0 Stack Free 315210195 A Multi ehannel m i aun 4 6 Kaub mendachuing 6 1 0 Clock Mode XTALI PLLIEX Total 06 5 6 Clock Freq 80 000 000 Hz dois XN Freq 5 000 000 Hz gt CHAM GFX 001 TB 01 5PIN AACHETECTURAL OVERVIEH T hi works Que SPI interface to the virtual SPI deiver runa SPI dete otrosn they are parood sed ditpotched J Keyboard driver gt PS 2 heyboerd Mouse drivar 25 2 nouse Sound driver Audio aep or TY ONSTANTS SECTION Propeter Source I pel gt lt Glove Foon The Propeller IDE allows you to program the Propeller chip in its native BASIC like language called Spin as well as assembly language The editor has lots of features like syntax highlighting and code marking to help you keep things straight Spin uses tabs for block nesting so a little tricky if you re a BASIC or C C programmer and not used to spaces tabs indicating nesting In any event if you want to pro
152. 7 0 CHAMELEON PIC API nennen nnne nn nans s nnn nnmnnn 137 17 1 System Library nep 141 17 1 1 Header File Contents 141 17 1 2 APE Tasting Reference ruere tere E 142 17 1 3 APL Functional Declarations 142 18 0 UART AND RS 232 LIBRARY MODULE 143 18 1 The Architecture of the UART API Library and Support Functionality cssssscssscssscssesssecscesscsscsssesssesssessssssssesesees 143 18 2 Terminal Emulation VT100 Commands cssccccssssscccssssccssssccccsssccccssccccesssccccssseccecssccecesaccccssnaccecssseccsssacccessnsccscssseeceses 145 18 3 Header File Contents Overview A 146 18 4 API Listing Reference siciisccsstscsscscoscscssseascsssensssossceesosscodesensesscessbes senedasssesstscasesesbandeas soneseseshosinseussobcsensenbacsedensessaioess 147 18 5 API Functional Declarations ssssssssesssrssrsessssesssssrsessessssessssssessesessessessssessasessessasessessasessessessssessassssessesesseseasessessesesseseesees 147 19 0 SPI AND I C LIBRARY MODULE PRIMER cernentes
153. ANSI CTINs RP3UICNTIRB3 7 7 22 PGC2 EMUC2 TMS RP11 CN15 PMD1 RB11 21 PGD2 EMUDZ TDI RP10 T CN 16 PMD2 RB10 VCAP VDDCORE 19 Vss 18 TDO SDA1 RP9 I CN21 PMD3 RBS TCK SCL1 RP8 I CN22 PMD4 RB8 16 _ INTO RP7 CN23 PMDS RB7 15 _ PGC3 EMUC3 ASCL1 RP6 CN24 PMD6 RB6 lt e 20 4 22 4 c0Sd9rv 9 H Z2ld 024 9 2 14 OSCI CLKI CN30 RA2 9 OSCO CLKO CN29 PMAQ RA3 10 4 11 SOSCO T1CK CNO PMA1 RA4 12 Vop 13 PGD3 EMUD3 ASDA1 RPSII CN27 PMD7 RBS 14 Z0Sd 982 LP H Z Id Z0Z d98Z LHrZOld 18 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 1 5 The Microchip PIC24HJ architecture block diagram Control Block Interrupt X Data Bus Controller Data Latch Program Counter a em dm Control Control Latch Logic Logic 16 Address Bus Instruction Decode and Control Instruction Reg Control Signals uu to Various Blocks 17 x 17 Multiplier 16 x 16 OSC2 CLKO _ Timing W Register Array OSC1 CLKI Generaton Divide Support FRC LPRC Oscillators Precision 16 bit ALU Band Gap Reference 16 Voltage Regulator x lt VODCORE VCAP Voo VSS MCLR Compar ECAN1 Timers UART1 2 1 oci jaa a Note Not all pins or teatures are implemented on device pinout contigurations See pinout diagrams tor the specihc pins and teatures present on each devic
154. AR OFFSET y 3 11 end for x Il end for y enter infinite loop while 1 change scroll position 211 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit scroll y scroll dy test for limit if Sa scroll lt 0 J scroll dy scroll dy scroll y scroll dy I end if 1 slow things down a bit so can read the text DELAY MS 50 end while have highlighted the single call that sets the smooth scrolling register that s all there is to it Summary This demo shows how easy it is to smooth scroll vertically Additionally it shows some of the hidden special characters in our little character set to help make games 212 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 28 1 4 VGA Printing Demo This demo simply uses the VGA terminal API to print Hello World to the VGA screen Figure 28 4 shows the demo in action Figure 28 4 VGA terminal printing demo llo World Hello World 1 Hello World World Hello World rld Hello World Hello World Hello World Hello Wor Hello World Hello World ello World Hello World lo Hello World World Hello World He orld Hello World Hello ld Hello World Hello Hello World Hello Wo Hello World Hello World ello World Hello W Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Descripti
155. B KP 7 6C F0 6C 57 0 45 45 7 1 16 F0 16 F8 2 1E 1E F9 3 26 F0 26 F10 4 25 25 F11 5 2E F0 2E F12 PRNT 6 36 F0 36 SCRN 7 3D F0 3D SCROLL 8 3E F0 3E PAUSE 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 83 F0 83 KP 8 75 75 OA 9 7 FO 7D 01 01 5 5 09 F0 09 4C 4C 78 F0 78 52 52 07 07 41 41 7C EO 49 F0 49 d F0 12 7E 7 4 El 14 77 E1 F0 14 NONE F0 77 The keyboard hardware interface is either an old style male 5 pin DIN or a new PS 2 male 6 pin mini DIN connector The 6 pin mini DIN s pin out is shown in Figure 12 2 referenced looking at the computer s female side where you plug the keyboard into notice the staggering of the pin numbering Figure 12 2 Female PS 2 6 Pin Mini Din Connector at Chameleon PIC socket Table 12 3 lists the signals for reference the descriptions of the signals are as follows DATA CLOCK VCC GND Bi directional and used to send and receive data Bi directional however the keyboard nearly always controls it The host can pull the CLOCK line LOW though to inhibit transmissions additionally during host gt keyboard communications the CLOCK line is used as a request to send line of sorts to initiate the host gt keyboard transmission This is used when
156. BUG g Wal pic30 gcc exe 2 4 128GP502 x c c CHAM PIC SYSTEM V010 c PIC SYSTEM 010 0 D DEBUG g Wal pic30 gcc exe mcpuz24H 128GP502 x c c CHAM PIC GFX DRV 010 o CHAM PIC GFX V010 o D__DEBUG g Wal pic30 gcc exe 2 49 128GP502 x c c CHAM PIC UART DRV 010 PIC UART 010 D__ DEBUG g Wal pic30 gcc exe mcpu z24H 128GP502 x c c CHAM PI C KEYBOARD DRV_V010 c PIC KEYBOARD DRV_V010 0 D g Wal pic30 gcc exe mcpuz24H 12862502 x c CHAM PIC MOUSE 010 o CHAM PIC MOUSE 010 D__DEBUG g Wal pic30 gcc exe mcpuz24H 128GP502 x c c CHAM PIC NTSC DRV V010 c o CHAM PIC NTSC DRV V010 o D DEBUG g 30 2 49 128GP502 x c c CHAM PIC VGA V010 c VGA 010 D DEBUG g Wall 30 mcpuz24H 1286 502 x CHAM PIC SOUND DRV V010 c CHAM PIC SOUND DRV 010 D DEBUG g Wal pic30 gcc exe mcpu 24H 128GP502 x c c CHAM PIC FLASH DRV_V010 c o CHAM PIC FLASH V010 o D__ DEBUG g Wal pi c3 ae exe mcpuz24H 128GP502 x c c 1 o main o D DEBUG g Wall pic30 gcc exe mcpuz24HJ 128GP502 CHAM PIC FLASH V010 0 CHAM PIC SOUND DRV V010 0 CHAM PIC DRV V010 CHAM PIC NTSC DRV V010 0 CHAM PIC MOUSE DRV V010 0 CHAM PIC KEYBOARD DRV 010 CHAM PIC 12 5 DRV
157. Cancel You will find that this is a standard license agreement Click on the I accept the terms of the license agreement radio button and then click lt Next gt and you will continue to the software setup type dialog Figure 15 4 Software setup type selection MPLAB Tools Setup Type Select the setup type to install AN MICROCHIP Please select a setup type Complete All program features will be installed Requires the most disk space Select which program features you want installed Recommended for advanced users lt Back Cancel In Figure 15 4 we will select what type of installation we would like to have Installing using the Complete installation will fill your hard drive with a lot of tools that you might not necessarily need By choosing Custom we will get more of a bare bones installation Press Next to continue to the next screen where we will choose our installation folder 82 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 5 Choosing the installation folder for MPLAB MPLAB Tools Choose Destination Location Select folder where setup will install files KX MICROCHIP Setup will install MPLAB Tools v8 15 in the following folder To install to this folder click Next To install to a different folder click Browse and select another folder Destination Folder C Program Files Microchip On this dialog shown in Figure 15 5
158. Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set Key Type to Typematic keyboard responds by sending an ACK clearing its output buffer and then waiting for the key ID make code from Scan Code Set 3 The specified key type is then set to typematic This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set Key Type to Make Break keyboard responds by sending an ACK clearing its output buffer and then waiting for the key ID make code from Scan Code Set 3 The specified key type is then set to Make Break This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use PS 2 Set Key Type to Make keyboard responds by sending an ACK clearing its output buffer and then waiting for the key ID make code from Scan Code Set 3 The specified key type is then set to Make This command may be sent while using any Scan Code Set but only has effect when Scan Code Set 3 is in use Resend should be sent when a transmission error is detected from the keyboard Reset Keyboard sends ACK and waits for system to receive it then begins a program reset and Basic Assurance Test BAT Keyboard returns a one byte completion code then sets default Scan Code Set 2 The mouse protocol is exactly the same as the keyboard protocol as far as sending and receiving bytes with the 11 bit packet The only difference of course is the data format the mouse sen
159. DRV_V010 h Header file for Sound module The Sound module header CHAM PIC SOUND VO010 h has nothing in it except the prototypes for the handful of functions Rather it makes more sense to show you the SPI header messages relating to the sound driver sound commands define SND PLAYSOUNDFM 40 plays a sound on a channel with the sent frequency at 90 vol ume define SND CMD STOPSOUND 41 stops the sound of the sent channel define SND CMD STOPALLSOUNDS 42 stops all channels define SND CMD SETFREQ 43 sets the frequency of playing sound channel define SND CMD SETVOLUME 44 sets the volume of the playing sound channel define SND RELEASESOUND 45 for sounds with infinite duration releases the sound and it enters the release portion of ADSR envelope The above messages are located in CHAM PIC I2C SPI VO010 H as well as in the main SPI driver running on the Propeller CHAM DEFAULT2 V112 spin or CHAM DEFAULT1 V112 spin The above messages only expose rudimentary abilities of the sound driver but they are enough to start and stop sounds play music sound fx etc The API listing for the Sound module CHAM SOUND DRV V010 c is listed in Table 23 1 categorized by functionality Table 23 1 Sound module API functions listing Function Name Description int Sound_Update int channel int frequency int volume Updates a currently playing sound The f
160. E int Mouse Load void Loads the mouse driver 202 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit int Mouse_Unload void Unloads the mouse driver Mouse Reading ae ee ee int Mouse_Read gid_event_ptr mouse Reads the mouse message a tr The following lists each function a description comments and example usage of the function Function Prototype int Mouse Load void Description _ Mouse Load loads the mouse driver up on a free Propeller core If the driver is already loaded this function has no effect Returns 1 Example s Load the mouse driver Mouse Load Function Prototype int Mouse Unload void Description Unload unloads the mouse driver freeing a core on the Propeller Typically you will do this when you want to load the keyboard driver Returns 1 Example s Load the mouse driver Mouse Load Function Prototype int Mouse Read gid event ptr mouse Description Mouse Read reads the current mouse event from the driver In this case it only reads relative events and thus the data is in delta format You send a pointer to a gid event structure and the function will write the latest mouse deltas and button states into the structure Returns 1 Example s Read the mouse position and test if left button is down gid event mouse Mouse Read amp mouse west t 3 Latte lento if mouse
161. ETWORKS LLC Exploring the Chameleon PIC 16 Bit 8 0 Parallax Propeller Subsystem Figure 8 1 The Propeller Subsystem Onboard Program Memory 32 128K EEPROM Status Debug LED 33vec STATUS_LED VCC 33VCC RESA RESn TD o Pe p T ENERO P gt 4 LE ed lt P10 2 E gt 20 Pu 2 11 LELI LZ E TI PU 1 eee 5 ees eee ps he ae T 1 d EE E FS en E 2S pi LII ILIA ee P 15 R9 R29 R31 y 100 00 00 100 100 Svce RBO 00 AAA AN AA 0 e e VV VV VV VV Bo x 95999 228 95 88 Pi og g ooog i ou 22 5h 59 QA 8885 252 5 58 g 22 T m z Q e O AE M oprea 2 Q ig ge gt gt o a D VGA CONN SL8 Figure 8 1 depicts the entire Propeller chip subsystem It consists of the Propeller chip itself package the 64K I C serial EEPROM for program storage a single LED and the Propeller Port header at 48 Additionally the Propeller is clocked by a 5 MHz nominal XTAL at X1 The only thing interesting about the design is the free Propeller Local Port at J8 it connects to Propeller I O pins PO P7 Thus you can connect other devices to this header or potentially drive another NTSC PAL VGA video device or you can just use it at 8 more
162. FUNC FILLMEM 16 requires a pointer to the destination and the number of WORDS to write along with data WORD So how do we set all those Easy we use other GFX messages to set the destination address pointer data WORD and number of bytes for operation then the GPU sub function uses those data for the operation Simple At this point you should have a good idea of how the enhanced NTSC tile engine works and the entire communication paths from the AVR PIC to the Propeller driver itself So let s move onto the API itself The API listing for the NTSC GFX driver module CHAM PIC GFX VO010 c is listed in Table 22 2 categorized by functionality Table 22 2 GFX module API functions listing Function Name Description GPU sub functions int GFX GPU Fill Mem16 unsigned int dest ptr unsigned int value unsigned int num bytes int GFX GPU Copy Memt6 unsigned int dest ptr unsigned int src ptr unsigned int num bytes int GFX GPU Fill Mem8 unsigned int dest ptr unsigned int value unsigned int num bytes int GFX GPU Copy Mem8 unsigned int dest ptr unsigned int src ptr unsigned int num bytes Palette pointer access functions unsigned int GFX Read Palette Ptr void unsigned int GFX Write Palette Ptr unsigned int palette ptr Tilemap pointer access functions unsigned int GFX Read Tilemap Ptr void unsigned int GFX Write Tilemap Ptr unsigned int tilemap ptr Fills memory 16 bits at a time Copies memory 16
163. GFX TI LE tile map base ptr parm g datal6 GPU GFX DISPLAY PTR R Reads or Writes the 16 bit tile disp where low level printing is displaye g spi result tile display ptr GPU GFX DISPLAY PTR tile display ptr g datal6 HET EB EHE PEPE PEEL LEE ie ptr which points to the location GPU GFX TERM PTR R Reads or Writes the 16 bit tile terminal He which points to the location where high level terminal mode printing is displayed g spi result tile term ptr GPU GFX TERM PTR W tile term ptr g datal6 BITMAP POINTER HOE ETE A EHE GPU GFX Reads or Writes the low byte of the 16 bit tile bitmaps ptr which points to the bitmaps indexed by the til g spi result tile bitmaps base ptr parm GPU GFX BI TMAP W tile bitmaps base ptr parm g datal6 have highlighted the register access code fragments at the top of each section So the idea is the AVR PIC sends the GFX command message via SPI the SPI message dispatcher catches these messages and passes all of them to the function then this function cases on each possible register access message and processes it viola Of course the above code is a partial listing the complete function is really long and you can look it yourself in the Propeller source file GPU Functions Overview These functions deserve a bit of explanation am using the word GPU pretty freely here a
164. I chip select hardware to cause the device passed in to be selected Next there are some timing constants that slow things down and makes sure when SPI commands are sent to the Propeller that the PIC waits long enough before issuing another command These don t matter too much as the drivers evolved but were needed in earlier driver development these two defines throttle the SPI interaction with the virtual SPI software interface on the Prop define SPI PROP STRING DELAY US 250 the prop needs time to react to each spi terminal print command define SPI PROP DELAY SHORT US 100 this delay is used where the critical path thru the SPI Prop is relatively short define SPI PROP DELAY LONG US 250 this delay is used where the critical path thru the SPlI Prop is relatively long define SPI PROP CMD DELAY US 1 the prop needs time to react to each spi transition this delay insures it can keep up l if you optimize the Prop driver or convert to ASM then you can reduce this of course The next set of defines are rather long they represent all the current commands that the Propeller driver understands These commands each have a specific set of parameters and functionality that will be clarified when we review the individual APIs for each class of messages graphics sound keyboard etc 11 display devices define DEVICE NTSC 0 define DEVICE VGA 1 PROP SPI driver media and 10 command set 1 SPI commands defin
165. I_SS1 8 _ 51 SPI SSOn gt DPIN14 SCL 8 5 SDA AIN3 4 AIN2 AINO JA J5 CONN SIL8 DPIN7 8 8 6 t GND i DPINS DPIN13 SCLK 5 DPIN12 2 MISO DPIN3 4 DPIN11 4 MOSI DPIN2 3 DPIN10 3 SS DPIN1 TXD DPIN9 DPINO RXD DPINS CONN SIL8 CONN SIL8 Also the pins on the headers obviously connect to multifunction pins such as the serial UARTS SPI and so forth In the case of the Chameleon PIC most of these pins are remapable to any peripheral Table 13 1 below maps the header pin names to the physical pin names and numbers for your convenience Table 13 1 I O header pinout map Header Designator Header Pin Name PIC Pin PIC Pin Name Extra Function AREF 2 RAO GND 8 19 27 VSS AVSS DPIN13 24 RB13 SCK DPIN12 2 RB12 MISO DPIN11 RB11 MOSI DPIN10 3 RB10 SSn DPIN9 4 DPIN8 T RB9 SDA DPIN7 RB7 DPIN6 E RB6 ISP PGC DPIN5 5 ISP PGD DPIN4 RB4 04 DPIN1 5 RBI J6 SPI_SSin NA J6 SPI_SSOn NA 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit J6 DPIN14 17 RB8 SDC 2 DPIN8 E RB9 SDA AINS AIN2 T RB15 T AIN1 HB14 AINO 1 GND 19 27 GND T GND 2 19 27 GND RESn nMCLR z 5VCC NA NA GND 8 19 27 GND Note 1 Power pins 5VCC 33VCC GND don t actually connect to the PIC but to the system power lines which in turn are electrically connected to the PIC s AVDD VDD and VSS GND resp
166. KS LLC Exploring the Chameleon PIC 16 Bit card Thus instead of digitizing sound effects the technique used to save memory is to synthesize sound effects with various techniques Still you can definitely do PCM with the Chameleon PIC and or develop a Mod player if you wish but at the output stage you only have a single bit thus you have to use PWM to output your PCM data More on this later 14 1 2 Frequency Modulation FM Frequency modulation with a fixed waveform is very easy to do and the Chameleon PIC can do this no problem The idea here is to output a Square wave or sine wave directly to the output device and then modulate the frequency So if we use the Chameleon PIC s internal timers we can do this more on this later or we can write a software loop to do it For example if you wanted to hear a 500KHz 1KHz and 2KHz signal you just write a software loop that toggles the output AUDIO_MONO at that rate and you will hear the sound on the attached output device Figure 14 3 shows this graphically Figure 14 3 Synthesizing a single frequency ims period 1 KHz I O 0 5ms 1 0 mS 090000000000 Time t Use built in timer counter or dedicated software loop Square Wave out Now there are a couple problems with this first its not readily apparent how to add signals and play more than one sound at once In fact it s nearly impossible directly using this technique Secondly the only signal yo
167. M PIC HELLO WORLD 01 Go ahead and look over the file Notice that it is quite small and should be relatively easy to understand For those of you who followed the steps in the MPLAB toolchain you will notice that this is the exact same file and simply prints the Text Hello World to both the NTSC and monitors With this file select in TextPad either choose the menu item Tools External Tools gt CompileDownload bat gt or press the keyboard shortcut Ctrl 1 Doing so will compile all the driver files and the hello world file link them together and convert them into a hex file Once the hex file is ready it will use the FlashProg exe to reset the Chameleon and initial the serial flash download If everything is configured correctly your output should look similar to the following ALL_DEV_STUFF Real Chamel Dd EN M dE gcc mcpuz24H 128GP502 x c c CHAM PIC 2C SPI V010 c CHAM PIC I2C SPI VOT D DEBUG g Wall Microchip MPLAB C30 LEER Manager Version v3 12 Build Bite Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key ALL_DEV_STUFF Real Chamel PI Code PIC BootLoader Bi nV 1 oWorl d gt pic30 gcc mcpuz24H 128GP502 x c c CHAM PIC SYSTEM V010 c o CHAM PIC SYSTEM V010 0
168. MPLAB C3 icense has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key C VALL DEV STUFFYReal Chamel eon C Code PI BootLoaderBi n Hell oWorl d pi c30 gcc exe mcpuz24H 128GP502 x c c CHAM PIC DRV V010 c PIC DRV 010 0 D DEBUG g Wal Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C3 icense has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key VALL DEV Chamel eon PI C Code Ci BootLoader Bi n He La Uan pu gcc mcpuz24HJ 128GP502 x c c CHAM_PI C_SOUND_DRV_V010 c o CHAM_PIC_SOUND_DRV_V010 0 D__DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 20 Copyright 2008 Microchip Technology Inc All rights reserved The MPLAB C3 icense has expired pic30 coff ccl exe warning Options have been disabled due to expired license isit http www microchip com to purchase a new key C ALL_DEV_STUFF Real Chamel eon PI C CodelPI BootLoader Bi n Hel 1 oWorl d pic30 gcc exe mcpuz24H 128GP502 x c c CHAM PIC FLASH DRV_V010 c PIC FLASH DRV_V010 0 D__DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Da
169. Nurve Networks LLC Version 1 0 EXPLORING THE CHAMELEON 1 amp BIT TD Oe USER MANUAL AND PROGRAMMING GUIDE y 5 Joshua Hintze amp Andre LaMothe www xgamestation com CHAMELEON PIC 16 User Manual v1 0 Exploring the CHAMELEON PIC 16 Bit A Guide to Programming the CHAMELEON PIC 16 Bit System Copyright 2009 Nurve Networks LLC Author Joshua Hintze Andre LaMothe Editor Technical Reviewer The Collective Printing 0001 ISBN Pending All rights reserved No part of this user manual shall be reproduced stored in a retrieval system or transmitted by any means electronic mechanical photocopying recording or otherwise without written permission from the publisher No patent liability is assumed with respect to the user of the information contained herein Although every precaution has been taken in the preparation of this user manual the publisher and authors assume no responsibility for errors or omissions Neither is any liability assumed for damages resulting from the use of the information contained herein Trademarks All terms mentioned in this user manual that are known to be trademarks or service marks have been appropriately capitalized Nurve Networks LLC cannot attest to the accuracy of this information Use of a term in this user manual should not be regarded as affecting the validity of any trademark or s
170. OP PORT DRV 010 is listed in Table 26 1 categorized by functionality Table 26 1 Propeller Local Port module API functions listing Function Name Description int PropPort SetDir int dirbits Sets the port bit direction bits individually int PropPort Read void Read the port input buffer int PropPort Write int data8 Writes to the port output buffer Note When reading or writing I O pins that aren t set the proper direction will have invalid data on them thus if you have set the lower 4 bits as inputs and read the port only count on the lower 4 bits having valid data Similarly when writing data only pins that are outputs will drive current They only will sink it as inputs Thus any data written to them is ignored as is should be 204 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The following lists each function a description comments and example usage of the function Function Prototype int PropPort SetDir int dirbits Description PropPort SeiDir sets the direction of the 8 I O bits on the Propeller local port 1 output O input eg 11110000 out out out out in in in in Physically on the port header bit 0 is on the right bit 7 on the left so its LSB to MSB right to left Returns 1 Example s Set the lower 4 bits to outputs upper 4 bits to inputs PropPort SetDir OKOE Function Prototype int PropPort Read void Description
171. OW Once the host releases the keyboard then the keyboard will start clocking the clock line and drop the DATA line with a start bit if there was a key in the buffer else the DATA line will stay HIGH So the following steps are after the host releases the keyboard and is trying to determine by means of polling if there is a key in the keyboard buffer Step 1 Delay 5 us to allow hold on CLOCK line to release and keyboard to send buffered scan code Step 2 Start of frame If both CLOCK and DATA are low start bit then enter into read loop else return no key present Step 3 Start of data Wait until clock goes high Step 4 Read data Read data bits loop Il pseudo code for i Oe i xe ds es d wait for CLOCK to go low delay 5 us to center sample bit t DATA end for Step 5 Read parity and Stop Bits Lastly the parity and Stop Bits must be read And that s it Of course if you want to be strict then you should read the parity and stop bit but you don t need to unless you want to perform error correction Both the keyboard and mouse use an odd parity scheme for error detection Odd parity is HIGH when the number of 1 s in a string is ODD LOW otherwise Even parity is HIGH when the number of 1 s in a string is EVEN LOW otherwise Note that parity only tells us there is an error but not how to correct it or where it was You simply have to re transmit the data 12 1 3 Keyboard
172. On this dialog Figure 15 11 you select the location where the 2 programming tool should be installed You browse to change the folder location however it s usually best just to leave it as the default location When you have chosen your install location click Next to confirm the installation 86 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 12 Confirm PICkit 2 installation i PICkit 2 v2 55 Confirm Installation MICROCHIP The installer is ready to install 2 v2 55 on your computer Click Next to start the installation Cancel lt Back a Figure 15 12 asks you to confirm your installation Normally you would click Next and the installation would being except in this case when you click Next we go onto the license agreement Bizarre Figure 15 13 Microchip license agreement i PICKit 2 v2 55 DER License Agreement AN MICROCHIP Please take a moment to read the license agreement now If you accept the terms below click I Agree then Next Otherwise click Cancel IMPORTANT YOU MUST ACCEPT THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT TO RECEIVE LICENSE FOR THE ACCOMPANYING SOFTWARE TO ACCEPT THE TERMS OF THIS LICENSE CLICK I ACCEPT OR OPEN THIS PACKAGE AND PROCEED WITH THE DOWNLOAD OR INSTALL IF YOU DO NOT ACCEPT THESE LICENSE TERMS CLICK NOT ACCEPT OR DO NOT OPEN THIS PACKAGE DOWNLOAD C 1
173. RE 1 COG 1 AVRIPIC Processor Meet gt eut SPI Interface Running main application as master Shared Memory all cores have access CORE 0 COG 0 This process starts first and then launches the ASM SPI driver on Core 1 Driver Layer Each object running on its own core aaa scott retort To I O devices posses JESEBENNI gt gt Messages passed to drivers Each object running on via sub function calls another core Referring to the figure the client master processor issues commands over the SPI interface which the master control program running on the Propeller chip processes in a large message dispatching loop to the proper driver object Thus to add messages or functionality we have to consider the following things Virtual SPI Interface Handlers 1 Will the Propeller driver need another object or driver If so we need to add this and then add code to the main message dispatcher loop that passes messages from the client to the new Propeller object 2 If we add messages to the system we need to make sure they are unique and don t overlap any other messages Its good practice to not use message ids we have already used since you want to be as compatible as possible Both the Propeller driver cham_default2_drv_112 spin and cham_pic_i2c_spi_drv_v010 h contain the master message id lists copies and the various library API files have functions
174. READ THE FOLLOWING TERMS AND CONDITIONS BEFORE USING THIS PRODUCT IT CONTAINS SOFTWARE THE USE OF WHICH IS LICENSED BY NURVE NETWORKS LLC INC TO ITS CUSTOMERS FOR THEIR USE ONLY AS SET FORTH BELOW IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT DO NOT USE THE SOFTWARE OR HARDWARE USING ANY PART OF THE SOFTWARE OR HARDWARE INDICATES THAT YOU ACCEPT THESE TERMS GRANT OF LICENSE NURVE NETWORKS LLC the Licensor grants to you this personal limited non exclusive non transferable non assignable license solely to use in a single copy of the Licensed Works on a single computer for use by a single concurrent user only and solely provided that you adhere to all of the terms and conditions of this Agreement The foregoing is an express limited use license and not an assignment sale or other transfer of the Licensed Works or any Intellectual Property Rights of Licensor ASSENT By opening the files and or packaging containing this software and or hardware you agree that this Agreement is a legally binding and valid contract agree to abide by the intellectual property laws and all of the terms and conditions of this Agreement and further agree to take all necessary steps to ensure that the terms and conditions of this Agreement are not violated by any person or entity under your control or in your service OWNERSHIP OF SOFTWARE AND HARDWARE The Licensor and or its affiliates or subsidiaries own certain rights that may exist from ti
175. ROM on the Chameleon with code we need to use this tool The Propeller is a 32 bit processor and you program it in a BASIC like language called SPIN or you can program in Assembly language The Propeller IDE supports both seamlessly The assembly language is very nice but SPIN takes a bit to get used to as does the editor which uses indentation like Python for block level This can be frustrating for C C programmer initially You can read about programming the Propeller chip here DVD ROM CHAM_PIC TOOLS PROPELLER Propeller_Manual_WebPM v1 1 pdf DVD ROM CHAM_PIC TOOLS PROPELLER PropellerDatasheet v1 2 pdf Also there is a single book about developing games and media applications for the Propeller chip Game Programming the Propeller Powered HYDRA by Andre LaMothe The installation procedure for the Propeller IDE is very simple and consists of the Propeller tool itself along with some Virtual COM port drivers developed by FTDI inc that are needed to communicate with the Propeller Chip itself These drivers are installed as part of the installer program if everything goes smoothly However you might recall we have already installed the FTDI drivers while setting up the bootloader tool As you can see everyone seems to use FTDI chips Step 1 Locate the Propeller IDE installation program Setup Propeller Tool v1 2 6 exe on the DVD here DVD ROM CHAM_PIC TOOLS PROPELLER Setup Propeller Tool v1 2 6 exe and la
176. Read Palette Ptr 4 Function Prototype unsigned int GFX Read Tilemap Ptr void Description GFX Read Tilemap Ptr reads the 16 bit pointer that points to the current map data displayed Each tile map entry is 2 bytes palette index character index and the current tile map width decides the pitch per row The tile map pointer is of course relative to the Propeller s 32K memory space and an absolute address Returns the 16 bit pointer value address Example s Read the tile map pointer 188 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit unsigned int tilemap ptr tilemap ptr GFX Read Tilemap Ptr Function Prototype unsigned int GFX Write Tilemap Ptr unsigned int ptr Description GFX Write Tilemap Pitr writes the 16 bit tilemap pointer that points to the current tile map data displayed Each tile map entry is 2 bytes palette index character index and the current tile map width decides the pitch The pointer must be a valid address and within open memory or part of memory declared for the driver itself otherwise you could crash the Propeller so watch out Scrolling page flipping and other memory effects can be achieved by changing the pointer For example say you want to scroll the one row down Assuming the current is 32x24 then we know there are 32 tiles per row and each tile is 2 bytes thus 64 bytes per row
177. SYN 38 26 amp 54 36 6 7 7 BEL 23 17 ETB 39 27 55 37 7 8 8 BS 24 18 CAN 40 28 56 38 8 9 9 TAB 25 19 EM 41 29 57 39 9 10 LF 26 1A SUB 42 2A 58 11 VT 27 1B ESC 43 2B 59 3B 12 C FF 28 1C FS 44 2C 60 3C 13 D CR 29 1D GS 45 2D 61 3D 14 E SO 30 1E RS 46 2E 62 3E gt 15 F 51 31 1 US 47 2 63 3F ASCII Hex Symbol ASCII Symbol ASCII Symbol ASCII Symbol 64 40 80 50 P 96 60 112 70 65 41 81 51 97 61 113 71 66 42 82 52 98 62 b 114 72 q 67 43 C 83 53 S 99 63 115 73 68 44 84 54 T 100 64 d 116 74 5 69 45 85 55 U 101 65 e 117 75 t 70 46 F 86 56 V 102 66 f 118 76 u 71 47 G 87 57 103 67 9 119 77 Y 72 48 H 88 58 X 104 68 h 120 78 w 73 49 89 59 105 69 i 121 79 74 4A J 90 5A 7 106 6A j 122 7A y 75 4B K 91 5 107 6 k 123 7B 2 76 4 L 92 5 108 6 124 7C 77 4 M 93 5D 109 6D m 125 7D 78 94 110 6E n 126 7E 79 4F 95 111 6F 127 7 Decimal Octal Binary Table Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin Dec Hex Oct Bin 0 0 000 00000000 16 10 020 00010000 32 20 040 00100000 48 30 060 00110000 1 1 001 00000001 17 11 021 00010001 33 21 041 00100001 49 31 061 00110001 2 2 002 00000010 18 12 022 00010010 34 22 042 00100010 50 32 062 00110010 3 3 003 00000011 19 13 023 00010011 35 23 043 00100011 51 33 063 00110011 4 4 004 00000100 20 14 024 00010100 36 24 044 00100100 52 34 064 00110100 5 5
178. Script Text Files That Define Memory and Register Locations Specific To the Processor gld Other Files Files Listed Here Will Not Be Compiled When compiling loading firmware or debugging the output window shows indicator messages to the programmer There are a few default tabs Build Version Control Find in Files that are displayed always and then depending on the current IDE mode there may be others For example when programming with the PICkit 2 there will be a tab for diagnostic messages from the PICkit 2 hardware displayed in the PICkit 2 tab on the Output window 100 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 37 Adding files to project lt Menu Option gt Demo MPLAB IDE v8 15 27929 Debugger Programmer Tools Configure Window Help Project Wizard New Open Close Set Active Project Quickbuild no File Clean Export Makefile Build All Ctrl F10 Make F10 Build Configuration Build Options Save Project Save Project As Add Files to Project Add New File to Project Remove File From Project Select Language Toolsuite Set Language Tool Locations Version Control There are multiple ways to add files to the Project We could have added them initially in the Project Wizard We could also right click on one of the folders in the Project Tree and from the pop up menu choose Add Files The l
179. TE constant that is loaded with said constant during startup Thus the variable is used in the Chameleon PIC library for calculations This gives it timing information and as noted the ability to be changed during run time That wraps it up for the header file declarations The remainder of the header file is simply the prototype listing for the functions themselves which we will see in the next section 17 1 2 API Listing Reference The API listing for the System module CHAM PIC SYSTEM V010 c is quite short As said this C file is a placeholder for future functionality that relates to system level housekeeping and utility functions so at this early stage there isn t much here Considering that Table 17 3 below lists the System API functions categorized by functionality Table 17 3 System module API functions listing Function Name Description System Configuration void SYS ConfigureClock unsigned long FCY Configures the system PLL with the given clock rate Currently only the MAX FCY RATE variable is accept 17 1 3 API Functional Declarations The following lists each function a description comments and example usage of the function 142 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype void SYS ConfigureClock unsigned long FCY Description SYS ConfigureClock configures and initializes the PIC24 s PLL register variables to the given clock ra
180. TS WHETHER OR NOT LICENSOR HAD BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND ON ANY THEORY OF LIABILITY ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE LICENSED WORKS SOME JURISDICTIONS PROHIBIT THE EXCLUSION OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES SO THE ABOVE LIMITATIONS MAY NOT APPLY TO YOU THESE LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY LIMITED REMEDY SEVERABILITY In the event any provision of this License Agreement is found to be invalid illegal or unenforceable the validity legality and enforceability of any of the remaining provisions shall not in any way be affected or impaired and a valid legal and enforceable provision of similar intent and economic impact shall be substituted therefore ENTIRE AGREEMENT This License Agreement sets forth the entire understanding and agreement between you and NURVE NETWORKS LLC supersedes all prior agreements whether written or oral with respect to the Software and may be amended only in a writing signed by both parties NURVE NETWORKS LLC 12724 Rush Creek Lane Austin TX 78732 support nurve net www xgamestation com 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit This document is valid with the following hardware software and firmware versions e CHAMELEON PIC 16 Bit Board Revision A or greater e MPLAB Integrated Development Environment 8 30 or greater e 24 Compiler 4 0 3 or greate
181. U configuration define GFX RAM PORT8 314GPU GFX BASE 10 Writes 8 bi ata pointed to by the currently addressed memory location in the GPU poi nted to by the src addr low hi 1 e operation e src add rptr are incremented as per the GPU configuration define GPU_GFX_RAM PORT16_R 32 GPU_GFX_BASE_1D Reads 16 bi ata pointed to by the currently addressed memory location in the GPU pointed to by the src addr low hi 11 eration e src addr ptr is incremented as per the GPU configuration define GPU_GFX_RAM PORT16_W 33 GPU_GFX_BASE_ID Writes 16 bit data pointed to by the currently addressed memory location in the GPU pointed to by the src addr low hi 11 ration e src add rptr are incremented as per the GPU configuration define GPU GFX RASTER LINE 344 GPU GFX BASE 10 Reads e current raster line being drawn from 0 191 or whatever the GPU s line resolution 15 Sie Il gpu configuration registers define GFX SET AUTO I NC 354GPU GFX BASE 10 Reads current memory auto increment setting for read write operations lower 4 bits 0 15 default 0 define GFX SET AUTO INC 364GPU GFX BASE 10 Writes the current memory auto increment setting for read write operations lower 4 bits AS eller 0 182 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Each register is actually a message to the SPI driver so we cleverly pass these reg
182. Write Algorithm The process of sending commands to the keyboard or writing to the keyboard is identical to that when reading The protocol is the same except the host initiates the conversation Then the keyboard will actually do the clocking while the host pulls on the data line at the appropriate times The sequence is as follows 59 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Step 1 Wait for the keyboard to stop sending data if you want to play nice This means that both the DATA and CLOCK lines will be in a HIGH state Step 2 Initiate transmission The host drives the CLOCK line LOW for 60us to tell the keyboard to stop all transmissions This is redundant if you waited for Step 1 however the keyboard might not want to shut up therefore this is how you force it to stop and listen Step 3 Data ready for transmission Drive the DATA line LOW then release the CLOCK line by release we mean not to put a HIGH or a LOW but to set the CLOCK into a tristate or input mode so the keyboard can control it This puts the keyboard into the receiver state Step 4 Write data Now the keyboard will generate a clock signal on the CLOCK line you sample the DATA line when the CLOCK line is HIGH and send it The host program should serialize the command data explained momentarily made up of 8 bits a parity bit and a stop bit for a total of 11 bits Step 5 End transmission Once the last data bit is se
183. X CMD NTSC GETX 2 GFX CMD NTSC GETY 5 GFX CMD NTSC CLS 4 VGA commands GFX_CMD_VGA_PRI NTCHAR 8 GFX CMD VGA GETX 9 GFX CMD VGA GETY 10 GFX CMD VGA CLS 11 mouse and keyboard loadable devices user must load one or the other on boot before using it keyboard commands KEY CMD RESET 16 KEYT CMD GOTKEY 17 KEYT CMD KEY 18 KEY KEYSTATE 19 20 KEY CMD START 128 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit KEY STOP 21 KEY CMD PRESENT 22 mouse commands OUSE CMD RESET 24 resets the mouse and initializes it OUSE CMD ABS X 25 returns the absolute X position of mouse OUSE CMD ABS Y 26 returns the absolute Y position of mouse OUSE CMD ABS Z 27 returns the absolute Z position of mouse OUSE DELTA X 28 returns the delta X since the last mouse cal OUSE CMD DELTA Y 29 returns the delta Y since the last mouse cal OUSE CMD DELTA Z 30 returns the delta 7 since the last mouse cal OUSE CMD RESET DELTA 31 resets the mouse deltas OUSE CMD BUTTONS 32 returns the mouse buttons encoded as a bit vector OUSE CMD START 33 starts the mouse driver loads a COG with it etc OUSE CMD STOP 34 stops the mouse driver unloads the COG its running on OUSE CMD PRESENT 35 determines if mouse is present and returns type of mouse general data read back commands READ CMD z sound comm
184. able p24HJ128GP502 gld Files of type Linker Scripts gld v Jump to C ALL_DEV_STUFF RealChameleon PIC C Remember this setting Auto Let MPLAB IDE guess User Files were created especially for this project use relative path System File s are external to project use absolute path 102 Every project needs a single linker script added to it This script is a text file that contains information the memory architecture of the particular processor you are using You add a linker script just like we added the files above see 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 39 However we need to change the Files of type filter to Linker Scripts The DEFAULT linker scripts are installed in the PIC24 C compiler directory However if we want to take advantage of the bootloaders that are installed we need to use a special linker scripts that instructs the linker to leave a section of memory untouched This way when the programmer goes to load the firmware it does not overwrite the bootloader section We lose a small section of memory but for most programs it won t make a difference Figure 15 40 All files added to the project Demo mcw Demo mcp Source Files 5 CHAM PIC HELLO WORLD O01 C BI CHAM PIC I2C SPI DRV Vv010 c S CHAM PIC NTSC DRV VO10 c BI CHAM PIC SYSTEM V010 c B CHAM_PIC_ G4_DRY_VO10 c Header Files E
185. about these little machines and haven t had this much fun programming something in a long time they just work and allow me to solve problems very quickly and get software done for real world applications It always amazes me to think about how far we have come in such a short time The Chameleons push 180 200MIPs depending on the version AVR PIC Literally 100 200x more powerful that the 8 bit computers of the 1980 s but yet are the size of credit cards The first official processor was the 4 Bit Intel 4004 shown to the left created in 1971 It contained about 2300 transistors and executed instructions at a rate of 92 000 per second Comparing this to our simple Chameleon PIC that runs about 180 million instructions per second that s about 2000 times more powerful But if we look at cutting edge GPU cores that perform computation in the trillions per second then that s 10 million times more powerful Then go ahead and parallel up 10 100 1000 of those processing cores and the amount of computation is astonishing 249 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Bottom line our little brains are easily going to be matched and surpassed by computers VERY soon So cherish these last days while humans are still the dominant species on the planet Good luck and please help us build the Chameleon community you can visit our forums at http www xgamestation com phpbb index php and http www c
186. ad amp event compute position event x event x 10 event y event y 10 t button hit C screen i lear event buttons 0X01 l clear the surface NTSC_ClearScreen VGA ClearScreen IT end if right button hit update cursor character if event buttons 0X02 223 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit update the cursor character if cursor gt 32 144 cursor 33 end if motion clamping if event x lt 2 event x 2 else 11 evont K gt 2 event 2 if event y lt 2 ent y 2 event y gt 2 event y 2 update position X event x event draw on both screens MSC Senin x w ie NTSC Term Char cursor VGA SetXY x yl2 VGA Term Char cursor things down a bit 7 E Summary have highlighted the single call to the mouse read function One thing to note is that the mouse read function takes a pointer to an gid event structure this is a generic structure that can potentially be used for other input devices such as game controllers track balls etc This demo once again shows how easy it is to interface peripherals to the Chameleon with the Propeller doing all the work Something that might be fun to do is add a bitmap NTSC or VGA driver to the master Propeller driver and then create a true paint program that allows pixel level paintin
187. ages to control the Propeller s onboard counters then you can route them to the I O pins and generate any signal you want via control from the master AVR PIC chip Summary This demos shows off a really simple way to control some of the I O pins of the Propeller chip Also the code is so simple there is no processing core for it on the Propeller it runs right on the main message dispatcher loop and just does the pin I O on demand Something you should try is hooking up a SPI 2 or other device to the port and see if you can remotely control it all the way from the AVR PIC chip 31 1 2 Serial RS 232 Communications Demo This demo shows off the serial communications of the Chameleon There are three components to this hardware UART the PIC24HJ FTDI USB to Serial UART converter software driver running on the PIC Considering these three elements to get serial from the PC s USB port to the Chameleon first we need the FTDI USB to serial UART which we have been using Secondly to communicate with the PIC we need to use its internal UART there are two available for us And finally we need to write software to control the PIC s UART and set it up This is what the CHAM PIC UART V010 library module is for have to use the USB port the serial TX RX pins from the PIC are exported to the Although we have been using the USB to serial connection to the Chameleon we don t TIP expansion hea
188. ain setup In also requires less hardware In fact the only required hardware is the PC and a USB cable which can also be used to power the Chameleon PIC In this setup we have elected to use TextPad as our text editor although any text editor could be used TextPad also contains the ability to call command line console DOS programs and map them to keyboard shortcuts We will make use of this feature and describe how to configure the preferences shortly Since TextPad can call a command line program we will have it call a DOS batch file that automates a number of operations described below e First it will call the PIC24 C compiler to compile all the drivers that we have provided so that you may use them in your main program e Second it will call the PIC24 C compiler to compile YOUR main C file e Next it calls the PIC24 linker program to link your main C file with the drivers The output of this process is cof file The cof file is not recognized by the bootloader software so we need to convert it to an Intel HEX file format This is done with the PIC24 C compiler tool pic30 bin2hex exe e Finally the software can be downloaded using FlashProg exe Referring to Figure 15 48 you will notice an intermediary program named FlashProg exe This is the PC side of the serial bootloader provided by Microchip The software has been slightly modified from the original software to fix some bugs and allow it to open serial ports numbered higher than
189. ajority of the command codes also called escape codes for the VT100 or its successors like the VT101 VT102 VT200 and VT220 We are going to add some simple VT100 commands to our UART API driver so we have more flexibility with our serial displays Before we discuss what has been implement let s talk about how you create a VT100 command code The first thing a user needs to send over a serial line is an escape sequence so the terminal or terminal emulator knows that more bytes are going to follow that make up this command With the VT100 the escape code is surprise the ASCII escape character ESC or hex Ox1B After the escape character is sent any number of bytes may follow afterwards describing the entire code There are many different escape codes and what is worse is that they are not very well documented Fortunately the codes that we will use most often seem to work among most terminal emulators An example VT100 command to clear the terminal screen is lt ESC gt 2J 145 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit That means the program sends these 4 bytes without break or pause ESC 2 J or in hexadecimal 0x1B Ox5B 0x32 0x4A Some VT100 commands immediately effect the state of the screen while other commands change the way the following ASCII characters are treated For example we can set the text attribute property so that all the following text received will be bolded or underlined
190. an be written something in the range of 10 000 to 100 000 This doesn t mean that at 10 001 or 100 001 the memory won t work it just means the erase cycles and write cycles may take longer to get the memory to clear or write And this then degrades further as the 2 write erase cycles persist Thus if you were to code all day and re write your FLASH 100x times a day then at 100 000 re write cycles you would have 3 4 years before you ever saw any problems On the other hand if you write code to use the FLASH as a solid state disk and constantly re write the memory 10 000x a run you can see how quickly you might degrade the memory Table 1 1 Differences between PIC24HJ 32 64 128 Device Flash RAM PIC24HJ32 32 Byte 4 K Bytes PIC24HJ64 64 K Byte 8 K Bytes PIC24HJ128 128 Byte 8 K Bytes Figure 1 5 shows the PIC24HJ architecture in block diagram form and Table 1 2 lists the pins and their function for the PIC24HJ128 Since the PIC24HJ has so many internal peripherals and only a finite number of pins many functions are multiplexed on the I O pins such as SPI 2 UARTS A D D A etc In addition to pin multiplexing the PIC24 allows users to remap a number of functions to different pins so the user has the ultimate flexibility in deciding which pin does what This is in contrast to the AVR that fixes the pin I O capability When you enable one of the peripherals they will typically override the I O
191. and acting as a terminal output but that s about it However with a little ingenuity we can make it do some cool things This little demo draw stars on the VGA screen on the last display line this causes the screen to scroll and presto animated star field Then on top of the star field a little character based ship is drawn Figure 28 6 shows the demo in action Figure 28 6 VGA terminal text graphics demo Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Vertically scrolls a star field and draws a little ASCII character space ship Main Source File CHAM PIC VGA STARS DEMO 01 Additional Files Required CHAM PIC SYSTEM VO010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC VGA DRV V010 c h General Requirements VGA port connected to VGA monitor Controls Required None 216 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Technical Overview Here s just the main loop excerpt which shows the entire star field generator int main void run over and over again int ship_x 12 ship_y 0 rst r ock fi RATE Always call ConfigurecCl SYS ConfigureClock MAX FCY a moment before sending it commands the boot process is about a second e you can speed it up by the Prop driver s LED blink sequence in the driver t up but commands that are sent before the Prop driver is done booting will be ignored f you have a l
192. ands SND PLAYSOUNDFM 40 plays a sound on a channel with the sent frequency at 90 vol ume SND CMD STOPSOUND 41 stops the sound of the sent channe SND CMD STOPALLSOUNDS 42 stops all channels SND CMD SETFREQ 43 sets the frequency of a sound channe SND CMD SETVOLUME 44 sets the volume of the playing sound channe SND CMD RELEASESOUND 45 for sounds with infinite duration releases the sound and it enters the release portion of ADSR envelope propeller local 8 bit port 1 0 commands PORT CMD SETDIR 48 sets the 8 bit I O pin directions for the port 1zoutput O input PORT CMD READ 49 reads the 8 bit port pins outputs are don t cares PORT CMD WRITE 50 writes the 8 bit port pins port pins set to input ignore data general register access commands Propeller registers for the SPI driver cog can be accessed ONLY ut the user can leverage the counters and even the video hardware if he wishes most users will only ay with the counters and route outputs inputs to fromthe Propeller local port but these generic access commands model how you would access a general register based system remotely so good example these commands are DANGEROUS since you can break the COG with them and require a reset so if you are going to write directly to the registers be careful SUPE D WRITE 56 performs a 32 bit write to the addressed register 0 F from the output register uffer REG CMD READ 5
193. ar cycle Thus by modulating the information onto the duty cycle we can then later demodulate the signal by integrating or averaging the PWM signal with a RC circuit and presto we have an analog voltage Figure 14 6 Indexing into a Sine look up table to synthesize a signal at a given PWM rate Sine Table 0 360 maps to 0 255 gt 8 bit entries 0 128 50 PWM Engine 90 255 100 25 15 0 90 Ground Reference at 50 Duty Cycle Vmax 1 0V Positive 315 37 0 5V 0 0V 359 127 Output voltage can t swing negative thus the ground refrence must be at 50 of the total signal strength or Vmax so the signal has room to swing around the ground The first thing we need to do is decide what kind of waveforms we want to synthesis remember they can be ANYTHING they can be periodic and simple like sine square wave redundant triangle sawtooth noise or even digitized speech But to start simple let s synthesis a single sine wave So first we need a look up table for sine wave let s call it sinetable and assume it has 256 entries and we generate it such that a single cycle has a low of 0 and a high of 255 and is encoded in 8 bits similar to an example in the references Now the algorithm is fairly simple we need to index thru the sine table a rate such that we complete a single cycle of our sine wave at the desired output signal frequency As a quick and dirty example let s say
194. ast method is to select Project Add Files to Project menu item as shown in Figure 15 37 Go ahead and click on the Add Files to Project menu item as shown above Figure 15 38 Adding source files to project Add Files to Project Look in C3 Hello World CHAM PIC SYSTEM V010 c CHAM PIC SYSTEM V010 h CHAM PIC UART DRY VO10 c CHAM PIC UART DRV VO10 h CHAM PIC VGA DRM VD10 c CHAM PIC VG VD10 h E Filename CHAM PIC VG DRV 010 CHAM Files of type All Source And Header Files 5 c hinc Jump to CALL DEV STUFF RealChameleon PICS C Remember this setting Auto Let MPLAB IDE guess User File s were created especially for this project use relative path System File s are external to project use absolute path 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit After clicking the Add Files to Project you will see a browse for files dialog box as shown in Figure 15 38 Initially it will filter out only c and s files We want to change this so we can select header files as well Do this now by changing the drop down box of Files of type to All Source and Header Files Now navigate to the Sources folder where you copied the Chameleon PIC DVD contents onto your hard drive Add the following files Drivers e CHAM_PIC_SYSTEM_V010 C Main system driver that set
195. at once without trying to use interrupts multitasking and round robin programming techniques to perform multiple tasks You simply write your code and run it on a core Then if that code crashes or is broken it does not affect the other cores at all This is exactly what the Chameleon needs a way to run multiple processes that each perform some kind of media task and then these processes wait for the master the PIC to send commands Each core does not care what the neighboring cores are doing only what it is doing Luckily if this all sounds like this is way too complicated you don t have to worry about it You do not have to program the Propeller chip at all if you do not want to The PIC communicates to it via a simple API and from the PIC your perspective the Propeller is just a media slave that generates NTSC PAL VGA graphics plays sounds reads mice and keyboards and more However to really explore the power of the Chameleon you will definitely want to play with the Propeller chip and modify its kernel driver s and so forth This is actually quite easy to do with a single tool that interfaces to the Chameleon PIC over the USB port It s called the Propeller IDE and Figure 1 10 below shows a screen shot of it Figure 1 10 The Propeller IDE in action Propeller Took chan defeutt2 drw 111 cham dofault drv 111 thin dev 111 5 HR Ful Source Condensed Document x OV 1777777777777777777
196. ations are N81 2400 baud dem receive to FLASH 2 Dump FLASH to screen Receiver Chameleon controls the flow of data from the sender PC FLASH demo running on Chameleon Simple X Modem downloader X Modem Protocol If you have never heard about X modem protocol it s probably the most widely used modem to modem download protocol on the planet and still widely used There are a number of variants that have been developed over the years such as X modem 1K X Modem CRC Y Modem Z Modem and so forth but fundamentally they all work the same way the uploader sends packets usually 128 256 bytes to the downloader until the entire file has been sent The uploader is typically the PC and the downloader is typically another PC that needs the file or a standalone device X Modem protocol is rather simple but a bit tricky to implement robustly since there are lots of potential forks in the communications logic that have to do with packets being lost errors resending timeouts etc If you have ever written a communications protocols you really understand how complex getting them to work robustly is You can read about X Modem protocol by Googling for it but here are a couple good references online http en wikipedia org wiki XMODEM http www techheap com communication modems xmodem html So what we did was take the protocol and make a simple downloader receive function that initiates an X Modem transfe
197. atively easy you open the FLASH memory up then read or write then close it Basically four API calls to do everything However that s pretty boring so we decided to do something a little more interesting We were concerned that many newbies would have a hard time putting the FLASH to use since there isn t a direct way to access it from the PC For example if you could read and write files to it over the USB port that would be ideal Moreover if the Chameleon could act like a FLASH FAT drive that would be great But no one has written software to do that and that s a good 1 2 weeks work so if you re up to it please do However as a conciliation prize we developed a little X Modem protocol driver that allows you to download files of any type from the PC to the Chameleon into a RAM buffer Then you can do what you want with the RAM buffer like write it to the FLASH memory Figure 31 3 shows a flow diagram of what s going on Figure 31 3 The various elements in an X Modem file transfer 232 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Absolute Telnet any X Modem protocol program bsa uteleinei 6 28 UMRIGISTIRID LVALUATION 7 days left Chameleon AVRIPIC listening to USB serial port X Modem protocol file transfer Data is sent a block at a time Each block consists of header information along with the 128 byte data Serial settings for FLASH Memory Das communic
198. attr Parameters attr The attribute style to apply to the text that is written next Return None Description UART vt100SetAtir sets the text attribute of the next set of characters that are sent out of the UART This can include bold underline blinking etc Below shows all the current options You may apply more than one text attribute at a time and when you want to return back to normal text use VT100 ATTR OFF 153 444444444 I e e e e COUPE COL CE C CO LOCO CDD TTC Eat V V V V V V V V Clear sc T vt100C m UAR UE gt gt Eon gt 25 lt lt T ce Eie Urnzcouo 1 DAD reen earScreen 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 20 20 mm nO m Gma RO RO MO c Mon mo Function Prototype void UART_BlockSend unsigned char ch Parameters Return Description Example s ch The character to be sent None UART_BlockSend A simple function that will not return until the given byte has been sent out the UART This example shows a simple usage scenario unsigned char Str 10 Testingl123 por OF UART lt noe ockSend Str i Function Prototype unsigned char UART_BlockRead Parameters Retur
199. b that gives each core access to the RAM in lock step thus it s impossible for one core to access RAM while another core is thus no potential for corruption of memory For complete details on the processor please review the datasheet located on the DVD ROM here DVD ROM cham_pic docs datasheets PropellerDatasheet v1 2 pdf Referring to the pinout of the Propeller as shown in Figure 1 9 the philosophy of the Propeller is to keep things really simple therefore there are no peripherals other than the video hardware on the chip The idea is that if you want a SPI port UART D A A D etc you will write one with pure software and run it on one of the cores as a virtual peripheral Therefore chip space and silicon aren t wasted on peripherals you will never use Rather the Propeller is 100 programmable and you simply load peripherals as software Figure 1 9 The Propeller pinouts PO C E25 GE P5 P6 RESn CEB 1 2 3 4 5 6 7 8 o gt 1 2 3 4 5 6 8 9 1 1 0 23 _ 22 P11 P20 P19 LQFP and QFN Packages DIP Package P15 P16 As you can see the Propeller chips have nothing more than power reset clock and 32 I O pins There are no dedicated peripherals whatsoever actually that s not completely true each core has video hardware Table 1 3 Propeller pin and signal descriptions Pin Name Direction De
200. bed from the HYDRA book in the Propeller Manual itself located on the DVD here DVD ROM cham pic docs propeller Propeller Manual WebPM v1 1 pdf Now let s discuss a little bit about NTSC video signal generation Figure 11 2 Horizontal scan versus display brightness Scan Line White Level 100 IRE Horizontal Blanking Interval Black Level Setup 7 5 IRE Blanking Level 0 IRE 11 2 Introduction to NTSC Video A video image is drawn on a television or computer display screen by sweeping an electrical signal that controls a beam of electrons that strike the screen s phosphor surface horizontally across the display one line at a time The amplitude of this signal versus time represents the instantaneous brightness at that physical point on the display Figure 11 2 illustrates the signal amplitude relationship to the brightness on the display At the end of each line there is a portion of the waveform horizontal blanking interval that instructs the scanning circuit in the display to retrace to the left edge of the display and then start scanning the next line Starting at the top all of the lines on the display are scanned in this way One complete set of lines makes a frame Once the first complete frame is scanned there is another portion of the waveform vertical blanking interval not shown that tells the scanning circuit to retrace to the top of the display and start scanning the next frame or picture This
201. ble tile mem autoinc parm is used as the memory increment stride each read write operation This comes in handy and reduces address updates when you access continuous memory There is of course a function to change tile mem autoinc Example s Read the 16 bit WORD of memory currently pointed to by the source memory pointer 191 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit datal6 GFX Read Mem Port16 Function Prototype unsigned int GFX Write Mem Port16 unsigned int data Description GFX Write Mem Port16 writes a 16 bit value to prop memory source ptr data note source pointer is always used for memory port operations read or write In the Propeller driver source ptr is the variable tile src addr parm and is set using GFX Set Src Ptr unsigned int src ptr defined below The idea of this function is that it provides a simple mechanism to access the Propellers RAM This function also updates the source pointer automatically anticipating another read or write The actual code looks like update src pointer based on auto increment value tile src addr parm tile mem autoinc parm Thus the variable tile mem autoinc parm is used as the memory increment stride each read write operation This comes in handy and reduces address updates when you access continuous memory There is of course a function to change tile mem autoinc Finally the function always returns 1 Exam
202. blue However after going thru the AC coupling capacitor the signal would look like that shown in Figure 14 2 bottom graph in red So all C15 does is block the DC Now let s talk about the some more hardware related concepts about making sounds with a couple specific techniques used for many of the Propeller audio drivers Of course you don t need to know this material since you are simply going to use a driver someone else writes like the default drivers we provide however it can t hurt to have an understanding of how the sounds are generated typically by these drivers 14 1 1 Pulse Code Modulation PCM The most common method to make sound on a game console is to use PCM or Pulse Code Modulation This is really nothing more than storing a series of samples of the sound in some resolution 4 8 12 16 bit along at some playback rate A WAVE file for example is PCM data you simply output the data at the proper rate to a D A converter with an amplifier connected to a speaker and you will hear the sound There are a number of issues with this first it takes huge amounts of memory even with compression secondly you need a D A digital to analog converter on the hardware and there is no synthesis opportunities really of course you can always synthesis the samples PCM is viable option for the Chameleon PIC but there is so little FLASH memory relatively speaking you would have to stream off and external SD 71 2009 NURVE NETWOR
203. but we choose this one to get you started since it requires only a single processing core and many of the more advanced drivers require 2 or more cores to generate higher resolutions and capabilities But again the point is you can change the Propeller driver and re write it as you wish we simply give you a starting point to get going with So if you want to know what the driver supports you can always peek into the driver itself Text 010 spin which calls sub objects and to see the messages that are getting passed to it you always look into the CHAM DEFAULT2 DRV 112 SPIN driver itself With that in mind if you want to use the VGA driver then you need the following files added to your project CHAM PIC VO010 c Main C file source for module CHAM PIC VO10 h Header file for module As you will see the VGA terminal mode functionality is nearly identical to the NTSC This is by design so when you are developing terminal applications that print out to the NTSC VGA screens basic information you don t have to worry about details each system is like a mini VT100 terminal with limited abilities but at least easy to work with 173 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The VGA API module header CHAM_PIC_VGA_DRV_V010 h has no globals or defines as of yet nothing more than the function prototypes The API listing for the VGA mo
204. cerns you press lt Cancel gt to bail out Figure 15 25 Modify path variable for command line execution Modify Environment The setup program can modify your environment to include C Program Files Microchip MPLAB C30 bin in your PATH variable Do you want the setup program to modify your environment No Cancel After the compiler for PIC24 processors is installed you have the option include the binary folder into the Windows standard PATH environment variable see Figure 15 25 By saying yes you can run the command line tools from a command prompt without specifying the full path to the tools This is required for the serial bootloader and TextPad installation to work properly press lt Yes gt to allow it 93 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 26 Installation finished successfully 2 Installation Complete MPLAB C Compiler for PIC24 MCUs Student Edition has been successfully installed Press the Finish button to exit this installation Open Release Notes The final dialog Figure 15 26 shows successfully installation of the C compiler If you leave the Open Release Notes checkbox checked you can review changes to the latest revision Press lt Finish gt to exit the installer and move onto the next section where we cover building an example project and testing the tool chain Congratulations you have installed everything necessar
205. ch of the drivers for NTSC VGA keyboard and serial Finally the main PUB start of the MCP is entered and it starts a core with the assembly language SPI driver Command Processing Loop As SPI commands are sent over the SPI channel the virtual SPI driver listens and if it detects traffic it then processes the bytes and places them into a globally shared memory buffer The MCP is sitting a 131 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit loop listening for the SPI driver to place data into this shared memory region When it detects a packet of information it then immediately tries to determine of the command portion of the packet is valid Command Processing and Execution The command processor is a handler that interrogates the previously tokenized input command data from the SPI channel and looks for commands in the packet If a command is found then it continues to process the command pattern and look for the parameters that should follow the command The parameters if any are extracted then the proper handler is entered The handler is where the action happens Each handler is connected to its respective driver and can send and receive messages from that driver So when a NTSC command is parsed for example the handler simply calls the NTSC driver and passes the request for execution When the processing is complete the MCP loops again and waits for the next command to process Even if yo
206. conceal off 30 39 o color norma 3x where x is from the color table above 40 49 colon normal 4x where x is from the color table above Examples CSI 2 J This clears the screen and sets the cursor to 0 0 or 1 1 upper left corner CSI 32 m This makes text green 262 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit NOTES 263
207. connected to NTSC TV monitors LED plugged into the Propeller Port leftmost 2 pins orientation doesn t matter Controls Required None Technical Overview This demo uses the Propeller Port API library to control the pins of the 8 bit local Propeller Port and blink an LED A couple cool things about the demo is that it toggles the pins on the I O header in pairs then thus no matter which way you have the LED nor what pins you have it plugged into it will actually blink or go bi color if you were lucky and got a bi color LED in your kit Below is the entire main loop of the program ux mai n run over and over again Always call ConfigureClock first SYS ConfigureClock MAX FCY RATE I initialize SPI Sl it ied s 1 give Prop a moment before sending it commands the boot process is about a second if you like you can speed it sp by emor iing the Prop driver s LED blink sequence in the driver or speed it up but commands that are sent before the Prop driver is done booting will be ignored therefore if you have a lot of set up work to do then you don t require a delay but if you jump right into commands then you need good 1 5 2 second delay DELAY MS 2500 clear screens NTSC ClearScreen NTSC Color 0 set direction of prop port so we have all bits output ropPort SetDir 0b11111111 1 is output 0 input T000 u 226 2009 NURVE NETWORKS LLC
208. ctors are exported off the I O headers to support other SPI devices you might connect For Sidebar example to select the Propeller chip you would use the following code which uses our macro set CS to SPI select select Prop SPI channel 2 SPI_SET_CS SPI_CS_PROPELLER And to de select the Propeller and select device 0 null device you would use set CS to SPI select channel 0 null SPI_SET_CS SPI_CS_0 Function Prototype void SPI Write unsigned char Data8 Parameters Data8 A single byte to be written out Return None Description SPI Write sends a single byte out of the initialized SPI port Example s This example shows a simple usage scenario call SYS ConfigureClock first after main begins ureCl ock FCY RATE I Configure clock ize the SPI interface 166 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit n CSI by selecting 50 Notice that we always assert then de assert the chip select line so that the SPI device comes online In some case you might want to keep the SPI device selected enabled at all times as long as you don t have other SPI devices on the bus that can contend with the SPI interface Function Prototype void SPI Write unsigned char data8 unsigned char SPI Read unsigned char Success Description These functions simply write read a byte to from the SPI port In the case of SPI READY the Success parameter
209. d table word word word word word word word word word word word word word word word word word word word word word word word word word word word I 3 p S p p i i lt gt lt gt gt OO 1 Cn 4 I lt gt ITI CJ C UU gt 1 Un gt CU P2 IS lt gt FP IE en en em e enm e e cc ccc ee A 198 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit word word word word word word word word word word word word word oc Win L gt gt gt gt gt gt M0000 CO gt gt lt FPP EP AE e a e lt gt c 1 lt gt gt gt CU CO Un gt C0 IS lt gt n rn CJ C 09 Wi n R Then the next table shows the relationship between ASCII keys and keycodes in a more easy to access method Key Codes 00 DF keypress and keystate pa E0 FF keystate only e 09 Tab B 0D Enter x 20 Space v 21 tt p 23 24 2 25 26 amp 1 3 21 1 28 29 i 2A 2B hk 2C 1 3 2D e i 2E
210. d added two new commands 100 and 101 here s a snippet of what the constants looked like before and after Before REG CMD WRITE 56 performs a 32 bit write to the addressed register 0 F from the output register buffer a 32 bit REG READ performs read from the addressed register 0 F and stores in the input register buffer REG CMD WRITE BYTE 58 write byte 0 3 of output register reg out buffer byte 0 3 REG CMD READ BYTE 59 read byte 0 3 of input register reg in buffer byte 0 3 System commands SIONIS EI 64 resets the prop A E EHE A EUER EEE EEE EER TERETE E this range of commands for future expansion TEATS EEE EEE EER UAE EEE EEE EE GPU GFX BASE ID d z starting id for GFX commands to keep them away from normal command set GPU GFX NUM COMMANDS advanced GFX commands fo number of GFX commands GFX SUBFUNC STATUS R O 4GPU GFX BASE 10 Reads the status of the GPU Writes the GPU Sub Function register and issues high level command like copy fill etc GFX SUBFUNC STATUS 14GPU GFX BASE 10 Writes status of the GPU Writes the GPU Sub Function register and issues high level command like copy fill etc 244 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit After Adding New Messages REG CMD WRITE 56 performs a 32 bit write to the addressed register 0 F f
211. d due to expired license Visit http www microchip com to purchase a new key C VALL DEV STUFF Real Chamel eon PI Ci Code PI C BootLoaderBi n gcc mcpuz24HJ 12862502 x c c CHAM PIC KEYBOARD DRV V010 c PIC KEYBOARD DRV V010 0 DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan ET 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key ALL_DEV_STUFF Real Chamel eon PI C Code BootLoader Bi n Hel loWorl d pi c30 gcc exe mcpuz24HJ 128GP502 x c c CHAM PIC MOUSE DRV_V010 c o CHAM 010 0 D__DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key C ALL_DEV_STUFF Real Chamel eon PI C Code PI BootLoaderBi n Hel loWorl d pi c30 gcc exe mcpuz24H 128GP502 x c CHAM PIC NTSC V010 c o CHAM PIC NTSC DRV V010 0 D__DEBUG g Wall Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The
212. d for the vertical retrace pulse Therefore a first attempt to generate a video signal frame is the following algorithm Step 1 Draw the top over scan For line 1 to 8 Begin Generate the next black scanline End Step 2 Draw the active region of the scan 240 lines For line nt 240 Begin Generate the next scanline End Step 3 Draw the bottom over scan For line to 10 Begin Generate the next black scanline End Step 4 Generate a vertical sync pulse basically apply OV to the signal for the time duration of scanlines note no HSYNC pulse is sent no serrations Video 0 0V Delay 4 6 Scanlines If you add up the lines you will get a total of 262 lines including active inactive and retrace or vertical sync Now due to overscan you probably won t be able to see more than 200 220 of the active scan video lines they will typically be beyond view Thus most games systems don t waste draw them and simple increase the overscan regions So a good rule of thumb is that active video should be from 192 224 lines with equal amount of top and bottom overscan 53 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Now the above algorithm to draw a frame will work and is very simple but it doesn t comply with the RS 170A spec completely It s missing a very important signal component called the vertical serrations in the vertical sync pulse If you look at the rough draft algorithm abov
213. d into a single data structure we simply call the RPC interface and pass the starting address of the structure The RPC interface in this case takes a string as the function name and then two pointers one to the input parameters and one to where the output results are stored There is obviously and agreement and set of conventions between the caller and receiver on this function and how it works so the client can make RPC calls and the server can respond to them In this case the server or other process reads the first string determines the RPC function then calls a handler with the two pointers It s up to the handler to know how to unpack the parameters and generate the results via calling the local function Thus RPC calls necessitate a number of extra steps including RPC Steps 1 Encoding 2 Transport to server 3 Decoding 4 Execution 5 Encoding 6 Transport back to client Obviously not the fastest thing in the world however if the computation workload is 2x or more than all the interface steps then it s worth it or if the local process or machine can t perform the computation etc Thus RPC calls and technology allow a process or machine to use subroutines and resources running in another process or another processor or an entirely different machine In our case we use the concept of RPCs to make calls to another processor from the PIC s SPI interface thus it s a machine to machine call where each
214. d suggest just writing the high performance portions in assembly Figure 15 18 shows the conditions Click lt Next gt to continue to the license agreement 90 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 19 compiler for PIC24 license agreement 53 License Agreement IMPORTANT YOU MUST ACCEPT THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT TO RECEIVE LICENSE FOR THE ACCOMPANYING SOFTWARE TO ACCEPT THE TERMS OF THIS LICENSE CLICK I ACCEPT OR OPEN THIS PACKAGE AND PROCEED WITH THE DOWNLOAD OR INSTALL YOU DO NOT ACCEPT THESE LICENSE TERMS CLICK I DO NOT ACCEPT OR DO NOT OPEN THIS PACKAGE DOWNLOAD OR INSTALL THIS SOFTWARE C Do Not Accept lt Back Next gt Figure 15 19 displays the license agreement dialog Once you have finished reading or having your lawyer read the license click 1 Accept radio button and press lt Next gt to move onto the installation folder selection Figure 15 20 Installation location selection 2 Choose Destination Location Setup will install MPLAB C Compiler for PIC24 MCUs Student Edition in the following folder To install into a different folder click Browse and select another folder You can choose not to install MPLAB C Compiler for PIC24 MCUs Student Edition by clicking Cancel to exit Setup Destination Folder C Program Files Microchip MPLAB C30 Browse Cancel If you followed my
215. define GPU GFX SRC ADDR 234GPU GFX BASE 10 Writes 16 bit source address for GPU operations 9 1 GFX DEST ADDR 244GPU GFX BASE 10 Reads 16 bi estination address for GPU operations 9 1 GPU GFX DEST ADDR W 254 GPU GFX BASE 10 Writes 16 bit destination address for GPU operations define GFX NUM BYTES 26 GPU GFX BASE 10 Reads 16 bit number representing e number of bytes for a GPU operation Sub Function define GFX NUM BYTES 274GPU GFX BASE ID Writes 16 bit number representing e number of bytes for a GPU operation Sub Function define GFX DATA 284GPU GFX BASE 1D Reads 16 bi ata word uses for GPU operations or memory access operations define GPU GFX DATA 29 GPU GFX BASE 10 Writes 16 bit data word uses for GPU operations or memory access operations 9 1 GFX RAM PORT8_ 30 GPU GFX BASE 10 Reads 8 bit data pointed to by the currently addressed memory location in the GPU pointed to by the src addr low hi After e operation e src addr ptr is incremented as per the GPU configuration define GFX RAM PORT8 314GPU GFX BASE 10 Writes 8 bi ata pointed to by the currently addressed memory location in the GPU poi nted y the src addr 1 e operation e src add rptr are incremented as the GPU configuration define GPU_GFX_RAM PORT16_R 32 GPU_GFX_BASE_1D Reads 16 bi ata pointed to by the currently addres
216. ders where you can directly connect them to a TTL level serial device 227 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit However in most cases the only serial device you need to connect to the Chameleon is the PC and thus the USB to serial connection suffices for most applications Setting up the Terminal Program If you are an expert at setting up serial terminals and connecting serial devices then you can skim this section but if you re not then follow along There are two parts to this demo physical connection from the Chameleon PIC s serial port to the PC s serial port Running a VT100 serial terminal program on the PC with settings N81 115 200 baud The first problem is fairly straightforward simply connect your Chameleon PIC to your PC with the mini USB serial cable The FTDI driver on the PC s side virtualizes the COM port so from the PC s point of view it s just another serial port Once you have the physical connection made then the next step is to get a terminal program up and running on your PC There are literally dozens if not hundreds of serial communications programs that you can find on internet 9996 of them are free for a reason they are junk There are a few that are actually very good such as PuTTY http www chiark greenend org uk sgtatham putty Zoc http www emtec com zoc Absolute Telnet http www celestialsoftware net telnet You can also
217. device Propeller IO Port Pins Used 12 13 14 video LSB to MSB 16 V 17 H 18 B1 19 B0 20 G1 21 G0 22 R1 23 R0 PS 2 Keyboard 26 data 27 clock 10 PWM or pure signal 30 TX 31 RX Figure 16 2 The SPI link between the PIC and Propeller chip Client processor anything with a SPI interface AVR PIC Propeller Cog i Processor Virtual SPI Driver MOSI MOSI Pi 999999999 A MISO MISO 14 SPI Bus CRM EE i2 1 SO eee Common Ground The MCP cham_default2_drv_111 spin is the primary driver that runs on the Propeller chip and listens to SPI traffic over the SPI link from the PIC chip as shown in Figure 16 2 As the virtual SPI interface running on its own core receives packets messages commands from the PIC the messages are parsed and packaged and placed into a global shared memory region The MCP is listening to the global shared region and tracks a flag Once this flag is noted to change the MCP reads the packet in and then tries to parse it to determine if it s a valid command that is supported This is achieved via a large switch statement to see if the command portion of the packet is valid Below is the list of current commands supported by the MCP by the default driver cham_default2_drv_111 spin null command does nothing NUL 0 graphics commands GFX CMD NULL 0 NTSC commands GFX CMD NTSC PRINTCHAR 1 GF
218. digital I O ports Lastly the Propeller chip only needs a 32K EEPROM to load its runtime image into its local SRAM however we are using a 64K EEPROM which not only allows 2 images but potentially a single image with additional program assets like graphics sound or code 8 1 The Propeller Local 8 Bit LOM Port The Propeller Local Port is an 8 bit port consisting of 8 free digital I O pins from PO P7 on the Propeller chip You can do anything you want with the port You can even power devices from the port by using some of the pins as power and virtual ground The Propeller can source up to 40mA per pin so if you tie 2 lines together and set them HIGH you can source up to 80mA more than enough for most applications 37 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 9 0 The SPI Bus and Communications System Figure 9 1 The SPI multiplexer design 33VCC AINT T SPI SS0n SPISS3n TD AIN2 T SPI SS1n SPI MISO T SPI SS2n SPI SS3n lt T gt sck lt T gt MOSI 1 74 138 VCC 33VCC The Chameleon uses SPI serial peripheral interface communications as the electrical communications interface to the Propeller chip as well as the on board 1MB FLASH memory The idea was we wanted to interface the PIC with both the Propeller and the FLASH The Propeller has no communications peripherals so we could use anything we wanted 2 lines 4 lines etc and any kind of protocol we wi
219. dit Project Debugger Programmer Tools Configure Window Help crm Debug 9 Checksum 0x0211 Toolbars CPU Registers Call Stack Disassembly Listing EEPROM Eje Registers Program Memory SFR Peripheral Special Function Registers Watch 1 Memory Usage Gauge PIC24HJ256GP206 99 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit After your demo project has been created it will initially start out blank as shown in Figure 15 35 We need to bring up the Project and Output floating windows To do this click on the View Project menu item as indicated in the figure above Do the same for the Output window lt View gt Output gt Figure 15 36 Project and output floating windows Demo MPLAB IDE v8 15 File Edit View Project Debugger Programmer Tools Configure Window Help DES a s Debug Vict ab lal O Checksum 0x0211 The project window shows a collapsible tree of all dependencies of the project Figure 13 36 We will be filling up this project tree as we continue building our demo Below is a listing of the different sections and the typical files you will find in each Source Files C source code files c Assembly Files s Header Files C header files h Assembly Include Files inc Object Files Precompiled Object Files Library Precompiled Library Files That Will Be Linked In To The Project a Linker
220. don t have to interrogate the buffer immediately and worry about loss of data You can finish you activities maybe a disk I O or some rendering then at your leisure call the receive function which will check the buffer for data and send it to you Referring to Figure 18 1 once again you can see some of the details of the system There are two functions similar to the C putchar and getchar called UART putchar and UART getchar these functions directly access the transmit and receive buffers for you Thus from a software perspective all the work of polling the transmission and 144 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit reception hardware is taken care of for you and all you have to do is use these two functions and pay attention to their return values So the idea of our UART module is that it loads up the ISRs for communication set the USART hardware up speed bits per character parity etc and then you communicate via a collection of functions Now although we can use the put and get class functions we have developed a number of other functions that help print strings numbers as well as directly access the USART transmit buffer so you can mix and match you serial library use as you wish or write you own 18 2 Terminal Emulation VT100 Commands The last subject wanted to broach before moving onto the actual API is the topic of terminal emulation Back in the olden days before des
221. ds as it boots up a series of tones that play musical notes when you hit RESET Make sure to have the audio port plugged into your NTSC TV as well Of course all we really did was re download the SAME firmware back into the Propeller chip so whatever is loaded into the PIC at this point will ultimately direct the Propeller slave what to do But this is the process to load the Propeller chip with a program Additionally you just saw how to load the default driver that this manual uses 99 of the time which is loaded on the Chameleons when they ship But you can surely change this driver if you wish update it make it faster better change objects it relies on etc You will learn how to do this later in the manual update the Propeller driver but for now we aren t going to touch it other than knowing where it is and how to download it This is the idea of the Chameleon the Propeller chip is like a black box when things go right we shouldn t even know it s there the Propeller should work like another other media processing chip and just execute the command we send it 126 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 16 0 Chameleon Inter Processor Architecture Overview In this section we are going to go into a bit of detail in relation to the software engineering techniques that the Chameleon s duel processor architecture is based on This section isn t necessary to use the Chameleon but it s nece
222. ds to the host and the commands the host Propeller chip can send the mouse Again we will cover real programming examples in the Programming Manual but let s just review the technical details briefly to get acquainted with the commands and data 61 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 12 2 1 Basic Mouse Operation The standard PS 2 mouse interface supports the following inputs X right left movement Y up down movement Left Middle and Right buttons The mouse has an internal microcontroller that translates the motion of either a mechanical ball or optical tracking system The inputs along with the buttons are scanned at a regular frequency and updated are made to the internal state of the mouse via various counters and flags that reflect the movement and button states Obviously there are mice these days with a lot more than 3 buttons and 2 axes but we are not going to concern ourselves with these extensions we just need to read the X Y position along with the state of the buttons The standard PS 2 mouse has two internal 9 bit 2 s complement counters with an overflow bit each that keep track of movement in the X and Y axis The X and Y counters along with the state of the three mouse buttons are sent to the host in the form of a 3 byte data packet The movement counters represent the amount of movement that has occurred since the last movement data packet was sent to the host therefore t
223. dule CHAM PIC VGA DRV V010 c is listed in Table 21 1 categorized by functionality Table 21 1 VGA module API functions listing Function Name Description 8888 Du _ _ int GetXY int x int y Gets the current cursor position on the terminal int VGA SetXY int x int y Sets the current position on the terminal Printing S m a int VGA_Term_Char char ch Prints a single character to the terminal at the current cursor position int VGA Term Print char string Prints a NULL terminated string to the terminal int Color int col Sets the color of the text The following lists each function a description comments and example usage of the function Function Prototype int VGA ClearScreen void Description VGA ClearScreen simply clears the VGA terminal screen and fills the screen with spaces Returns 1 Example s Clear the screen VGA_ClearScreen Function Prototype int GetXY int x int y Description VGA GetXY returns the position column row of the virtual cursor The function takes two pointers to the integer variables you want to receive the values Returns 1 Example s Retrieve the current cursor position 174 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit c yn VGA GetXY amp x amp y Function Prototype int Se
224. dule and functionality let s briefly review both SPI and protocols and their features For more detailed descriptions and tutorials on both protocols suggest reading the SPI and material in the PIC24 data sheet and reference manual located here DVD ROM CHAM DOCS DATASHEETS PIC24HJXXXXGPXO06 08 10 pdf DVD ROM DOCS PIC24 REF MANUAL Section18 SPI pdf DVD ROM CHAM_PIC DOCS PIC24 REF MANUAL Section19 I2C pdf Also there are numerous SPI and documents located on the DVD here DVD ROM CHAM_PIC DOCS I2C DVD ROM CHAM PIC DOCS SPI A few of which I highly recommend you read specifically are DVD ROM CHAM DOCS I2C Using C30 compiler to interface serial eeproms AN1100 pdf DVD ROM CHAM DOCS 12 basic serial i2c eeprom operation 00536 pdf 155 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit DVD ROM DOCS I2C I2C_bus pdf DVD ROM CHAM PIC DOCS SPI SPI pdf These cover PIC specific SPI controls as well as general software implementations and some interesting examples of SPI controls But if you just want a quick overview read on SPI stands for Serial Peripheral Interface originally developed by Motorola It s one of two very popular modern serial standards including which stands for Inter Integrated Circuit by Phillips SPI unlike is a clocked synchronous serial protocol t
225. duty cycle pulses are sent but they are interspersed with 0 duty cycles as a function of time If the rate of these pulses is high enough they too create an average voltage over time In Figure 14 4 b there are 10 total cycles and in 2 of them we have 50 duty cycles for a total analog voltage per 10 clocks of Average Signal 20 duty cycle 5V 50 100 ns 1000 ns 0 5V 73 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Notice we are dealing in nanoseconds in the second example this technique needs to run at a higher frequency to give the average enough time to change at the highest frequency rate you want to synthesize in this method of D A Figure 14 5 A low pass averaging filter and the stair step results a b Low Pass Filter ETE inal Output to Filter Now the only mystery component to the D A PWM converter is averaging of the signal Well fortunately for us a low pass filter as shown in Figure 14 5 acts as an averaging circuit in fact those of you with an EE background know that 1 S is integral in the S Domain and a low pass filter has a 1 S term it in Intuitively it makes sense as well since a low pass filer as shown in Figure 14 5 a is really just a charging circuit and as we send these pulses to it the circuit charges a bit then another pulse comes and it charges a bit more when a pulse doesn t come or the duty cycle is smal
226. e 16 m ian 19 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The Microchip PIC24HJ comes in a number of packages including 28 pin DIP duel inline package We are using the PIC24HJ128GP502 DIP package in the Chameleon Figure 1 4 shows the packaging and pin out of the chip The PIC24HJ was designed as a general purpose high performance microcontroller with a 16 bit data path single clock execution on many instructions as well as support for 32 bit operations and built in multiply instructions The chip has a large FLASH memory of 128K Bytes but a smaller 8K Byte SRAM which makes a lot of RAM intensive applications challenging however the Chameleon is designed for control applications and 8K of RAM should be more than enough for anything you need For complete details on the processor please review the datasheet located on the DVD ROM here DVD ROM cham pic docs datasheets PIC24HJXXXXGPX06_08_10 pdf Table 1 1 below shows the various differences between the variants of the PIC24HJxxx for reference The PIC24HJallows re writing to the FLASH as well so unused portions of FLASH can be used for storage however it s not ideal to constantly re write FLASH since there is a limit to the number of times it can be re written 100 000 give or take Additionally you can use the 1MByte SPI FLASH on the Chameleon as well for storage FLASH memories typically have a maximum number of times they c
227. e void UART_Init unsigned long BaudRate Parameters BaudRate The desired baud rate Most baud rates will work but this driver has been hand tuned for the following frequencies 9600 19200 38400 57600 115200 Return None Description UART Init initializes the UART driver using the specified baud rate It also enables the receiver interrupt Example s This example shows a simple usage scenario Include main sys include CHAM PIC te Sy Include Cham UART include Cham PIC U M M V010 h em STE dr RT A V int main void A AN ays call SYS Configur ck first after main begins Confi gureCl ock MAX FCY RATE Configure clock for max uart driver at 115200 baud rate continue program bel ow Function Prototype void UART printf const char buff Parameters buff A string that can contain the normal C printf syntax along with variable arguments Return None Description UART printf sends the given string after processing all variable arguments out of the previously opened UART port Example s This example shows a simple usage scenario Notice how the string ends with rn This is a carriage return followed by a newline that is required in terminal programs such as HyperTerminal to get the cursor to go to the beginning of the next line m main void Always call SYS ConfigureClock first after main begins SYS ConfigureC
228. e we have a vertical sync period where we simply generate sync signal for 4 6 scanlines This is fine and will work but you will notice an effect called flagging at the top of the display which is ugly A better approach is to continue to generate hsync pulses during the vsync This keeps the horizontal sync timing hardware tracking To accomplish this the hsync is simply inverted Both the hsync and vsync filters will still detect the edges of the pulses so the inversion doesn t hurt anything so both the hsync and vsync occurs and the horizontal timing circuitry doesn t lose sync Now you might ask why wouldn t you always perform this inversion of the hsync during the vsync Well the answer is that you might want to have once big continuous block of 4 6 lines that you set a single bit sync and then you can do work without interruption but the video looks quite ugly so it s a compromise In any event considering this adjustment to our algorithm all we have to do is generate 6 hsync pulses at the end of the bottom overscan that are inverted thus this new algorithm will suffice the top over scan 8 active region of the scan 240 lines Step 4 Generate a vertical sync pulse with serrated Video 0 0V for entire video line expect for BLACK du Output 6 blank lines with inverted hsync this will kee inverted hsync pulses ring hsync horizontal tracking and cause a vsync to occur 11 2 5 2 Line C
229. e API Audio API FLASH Storage SPI COMMs Mouse Keyboard NTSC Drivers VGA Drivers Driver Driver Audio Driver Drivers AVR PIC has direct connection to FLASH memory and does not need to thru SPI driver on Propeller and message dispatcher Physical Hardware Layer Referring to the figure there are a lot of components to discuss First off the primary library that all C C programs use is the open source libc library that is part of the PIC24 C compiler install and is what the GNU GCC compiler uses as the base for all of the standard C library functions you are used to Therefore when you create a program for the Chameleon PIC and include say lt stdio h gt you are including functions from the PIC24 C Libc installation Let s talk about this for a moment First embedded systems are very unique in that they are very constrained have little memory and 138 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit resources So any function that you use from the standard C library Libc emulates what you might expect on a PC platform but in many cases the behavior might not be as expected Thus you need to take care when using standard library functions and realize that they may have side effects or limitations that VC or GNU C on your PC do not Please refer to the PIC24 C Libc manual located here on the DVD ROM for a complete overview of the library DVD ROM CHAM_PIC DOCS DATASHEETS hipLib30 chm
230. e Audio Video cables plugged into your television and the Chameleon PIC properly Make sure video is connected to video and audio to audio e else fails first try to restart MPLAB save your workspace and project first If it still does not work try rebooting your computer Finally if you are still having problems contact Nurve Networks support at Ssupport nurve net and also send a copy of the email to nurve_help yahoo com just to decrease the chance spam firewalls filter your email There is also a thriving community of Chameleon users with a lot of experience who commonly use message forums at the following website http www chameleon dev com http www xgamestation com phpbb 15 1 4 2 Enabling Compiler Optimizations Before we finish wanted to mention how to enable disable compiler optimizations Remember after 60 days of use with the student edition of the MPLAB C compiler for PIC24s optimization level 0 and 1 can only be enabled Still level 1 compiles significantly faster and smaller code than level 0 To change the optimization levels first start by opening the project options Project Build Options Project Next click on the MPLAB C30 tab as highlighted in the green box in Figure 15 47 107 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 47 Project optimizations settings window Build Options For Project FinalTestProj mcp Directories ASM30 C30 Suite
231. e CHAM PIC I2C SPI V010 c h The Sound driver API library module CHAM PIC SOUND DRV VO010 c h The NTSC VGA GFX driver or all of them And any other ancillary drivers keyboard mouse etc All the required files of course be found in the Source directory on the DVD which you should have already copied onto your hard drive located here DVD ROM CHAM SOURCE In general you will include all the sources in your project C files and make sure all the MPLAB H header files are in the same working directory so the compiler can find them You do NOT include the H header files in the compilation list of source files the compiler will do TIP this for you Only include C and S files in your source file link list in your project file list to the left of the tool 29 1 1 Sound Demo This demo uses the Sound and driver to play some chords up and down The chord frequencies are displayed on both the NTSC and VGA displays Figure 29 1 shows the demo in action Figure 29 1 Sound demo VGA output Playing Chord 311 Plauing Chord 328 Playing Chord 348 Playing Chord Playing Chord Plauing Chord Chord Chord Chord Chord Chord Chord Chord Chord Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Plays sounds on the speaker Main Source File CHAM PIC SOUND DEMO 01 Additional Files Required CHAM PIC SYSTEM VO010 c h CHAM PIC I2C SPI DRV
232. e CMD NULL 0 161 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit hese commands are DANGEROUS since you can break e COG with them and require a reset so if you are going to write directly to the registers be careful 1 NTSC commands define GFX CMD NTSC PRINTCHAR 1 define GFX CMD NTSC 2 define GFX CMD NTSC 3 define GFX_CMD_NTSC_CLS 4 11 vga commands define GFX VGA PRINTCHAR 8 define GFX CMD VGA 9 define GFX CMD VGA 10 define GFX CMD VGA CLS 11 keyboard commands define KEY CMD RESET 16 define KEY CMD GOTKEY 17 define KEY CMD KEY 18 define KEY CMD KEYSTATE 19 define KEY CMD START 20 define KEY CMD STOP 21 define KEY CMD PRESENT 22 mouse commands define MOUSE CMD RESET 24 resets the mouse and initializes it define MOUSE CMD ABS X 25 returns the absolute X position of mouse define MOUSE CMD ABS Y 26 returns the absolute Y position of mouse define MOUSE CMD ABS Z 27 returns the absolute Z position of mouse define MOUSE CMD DELTA X 28 returns the delta X since the last mouse cal define MOUSE CMD DELTA Y 29 returns the delta Y since the last mouse cal define MOUSE CMD DELTA 7 30 returns the delta Z since the last mouse cal define MOUSE CMD RESET DELTA 31 resets the mouse deltas define MOUSE CMD BUTTONS 32 returns the mouse buttons encoded as a bit vect
233. e GFX is expose some of the base functionality in nice function calls so you don t have to send SPI messages yourself In the case of the NTSC driver CHAM DEFAULT2 112 SPIN we are using the following Propeller Object for the NTSC tile engine and text display CHAM GFX DRV 001 TB 001 This is the enhanced NTSC only text tile engine with support for terminal mode graphics with a tile resolution of 32x24 However the tile engine has extra features for more graphically oriented tile graphics and gaming applications Now keep in mind the GFX library functions are only supported with the Default2 driver s and only work on the NTSC Screen wrote this driver myself to fit into a single Propeller core but give you some decent control of the tile maps bitmaps palettes scrolling and colors The tile engine has two layers of functionality The topmost layer is the console or terminal layer which acts like a simple VT100 terminal you print to it it scrolls you can clear the screen etc This functionality gives you the base abilities to write applications that only need basic text output Moreover we selected the NTSC and VGA drivers in both the Default1 and Default2 example drivers to support exactly the same commands So applications written to drive the VGA terminal work exactly the same on Default1 Default2 or with a simple change of function calls from VGA to NTSC they will work on the NTSC screen That said i
234. e Setup program WARNING This program is protected by copyright law and international treaties Unauthorized reproduction or distribution of this program or any portion of it may result in severe civil and criminal penalties and will be prosecuted to the maximum extent possible under law Cancel Figure 15 17 displays the welcome screen upon first launch It is recommended that you close all especially old versions of MPLAB IDE applications before installing When you are ready to begin press lt Next gt to continue Figure 15 18 Student edition limitations 2 Student Edition Please note This is MPLAB C Compiler for PIC24 MCUs Student Edition As an evaluation edition it will be fully functional for 60 days after installation However after the 60 day trial period the following features will be disabled procedural abstraction optimization options 02 03 and Os Student Edition may be upgraded to a full edition by purchasing a license key from Microchip Without full license a Student Edition can only be upgraded with another Student Edition Upgrading to a newer Student Edition will not extend the expiration date of the trial and will not enable features which have been disabled As stated previously there are some limitations to the student edition beyond the 60 day trial period This will not affect you unless you are trying to squeeze everything out of the C compiler in which case woul
235. e a few hundred bytes to a couple K The AVR only has enough room for a 1K receive buffer the PIC obviously has more room than the AVR but we 239 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit kept it at 1K in the X Modem function thus it only buffers 1K of the data and writes it to the FLASH memory Everything else is shown on the screen as its received but lost Option 1 is shown in Figure 31 7 below Figure 31 7 The FLASH demo receiving a file Download Complete 11 Blocks File Size 1408 Opening FLASH memory Erasing first k of FLASH Writing 1408 bytes to FLASH Closing FLASH memory Main Menu 1 XModem receive to FLASH 2 Dump FLASH to screen Selectio Of course you can alter the XModem receive function to write files directly to the FLASH as they are received block by block and you probably will need to Option 2 lists out the first 1K of the FLASH memory so you can see what s in it Point being you want to boot the program see what s in the FLASH it then download something see if it changes reset re boot try again An example of Option 2 running is shown in Figure 31 8 below Figure 31 8 The FLASH demo displaying a file 1 XModem receive to FLASH 2 Dump FLASH to screen Selection 1 2 Opening FLASH memory Reading data from FLASH The Road Not Taken by Robert Fro st Two roads diverged in a yellow wood And sorry I could not travel b
236. e actually values of RC we see that very quickly larger values of f frequency very quickly dominate the denominator and the quotient goes to 0 This is why this filter is called a single pole as the term in the denominator goes to infinity the quotient goes to zero Ok so how does this help us Well if we select values of RC we can tune the frequency that this attenuation gets really strong This is typically called the 3dB point that is the point where the signal is attenuated by 3dB decibels not really important to know what a decibels is its a measure of power or ratio of signals more or less but what is important is that 3dB is about 7096 of the signal so if you want to filter out everything above 10KHz you would set the 3dB point for about 10KHz maybe a bit more and you would see the signal get filtered Also note that at DC frequency f 0 the right hand term the denominator sum 1 2 PI 0 RC 1 thus the gain is 1 1 or 1 0 which is exactly what it should be Cool huh 70 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Filters can be a lot of fun since you can chain them together low pass high pass to make a band pass or multiple low and high pass to make them fall off faster and so forth Here s a cool tool on the web to get a feel for filters Low Pass http www st andrews ac uk www_pa Scots_Guide experiment lowpass Ipf html High Pass http www st andrews ac uk www pa Scots Guide
237. e getting passed to it you always look into the CHAM DEFAULT2 DRV 112 SPIN driver itself With that in mind if you want to use the NTSC driver then you need the following files added to your project CHAM PIC DRV V010 c Main C file source for NTSC module CHAM PIC NTSC DRV VO010 h Header file for NTSC module 169 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Before we cover the API itself let s take a look at how we would manually send a message to the Propeller chip and what these wrapper functions do This is the first time we are discussing this since the UART and SPI drivers run on the PIC side of things only so they are local libraries On the other hand the NTSC VGA Keyboard Mouse Sound and Propeller I O Port libraries all make calls over the SPI channel to the Propeller chip This subtle difference is very important you do NOT need these libraries anything you can do with the libraries you can do directly with the SPI Prop Send Cmd but to make life a little easier wrapped many of the commands in function calls for convenience For example to print a character to the NTSC screen you can do it directly without the NTSC API like this SP Prop Send Cmd GFX CMD NTSC PRINTCHAR ch 0x00 Or you can call the NTSC API function to do it NTSC Term Char ch But let s dive into Term Char and take a look int NTSC Term Char char ch this p
238. e spoken with Microchip about this and they have agreed to start porting over their tools to Linux and Mac this is great news They estimated having something ready around Q1 2010 If you are reading this and we are past Q1 2010 please don t complain to me Since Microchip doesn t formally support Linux or Mac OS it doesn t mean we are completely left out in the dark There are a number of 3 party compilers that support these other platforms One such compiler is the HI TECH C compiler for the dsPIC and PIC24 microcontrollers The HI TECH C compiler contains the following features ANSI C full featured and portable supporting all standard data types IEEE floating point long data types etc Reliable based on mature field proven technology used in our PICC and PICC 18 compilers Unlimited number of source files Multiple optimization levels and types Comprehensive C library with all source code provided Mixed C and assembler programming Listings showing generated assembler Optimizing assembler Compatible integrates into the MPLAB IDE MPLAB ICD 2 Includes Native Trace support for MPLAB REAL ICE Runs on multiple platforms Windows up to Vista64 Linux and Mac OS X This is an impressive list and it is comparable to Microchip C compiler for PIC24 The only problem is that they do not have a free lite compiler for the PIC24 processor This means that you can acquire a 45 day free trial and after that you need to purchase the soft
239. e vertical timing are O 16 68 ms Total frame time P 64 us Vsync pulse Q 1 02 ms Back porch R 15 25 ms Active video time S 0 35 ms Front porch The meaning of each is similar to that in the horizontal sync period except the event they are focused around are the 480 lines of active video so the 480 lines are encapsulated in R The most important thing to realize is that these times are in measured in milliseconds for the most part except for the Vsync pulse So once again the timing of an entire frame starts off with the Vsync pulse P for 64 us after which comes the back porch Q for 1 02 ms followed by the active video R for 15 25 ms During the active video you don t need to worry about the Vsync line since you would be generating 480 lines of video when complete back to the Vsync timing region S the front porch for 0 35 ms and then the frame is complete The thing to remember is that unlike composite video a VGA signal needs to be driven by multiple signals for each of the constituent controls R G B Hsync and VSync which in my opinion is much easier than modulating and mixing them all together as in NTSC which is a blood bath of crosstalk and noise Now that we have the horizontal and vertical timing for VGA covered let s review the actual video data portion of the signal during the active video and see what that s all about 44 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 10
240. e very similar to XGA modes and higher 11 2 3 Composite Color Video Blanking Sync Interface Composite signals are the most commonly used analog video interface for NTSC PAL Composite video is also referred to as CVBS which stands for color video blanking and sync or composite video baseband signal It combines the brightness information luma the color information chroma and the synchronizing signals on just one cable The connector is typically an RCA jack This is the same connector as that used for standard line level audio connections S video of course is slightly cleaner since the analog mixing of chroma and luma does NOT take place A typical waveform of an all white NTSC composite video signal is shown in Figure 11 5 50 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 11 5 NTSC composite video waveform White Level 100 IRE Active Video 52 6 us Black Level Setup 7 5 IRE Blanking Level 0 IRE Color Burst 40 IRE p p Syne Tip 8 10 cycles 3 58Mhz Front Porch Color Burst Back Porch 1 5us 2 5us 1 6us Breezeway 0 6us This figure depicts the portion of the signal that represents one horizontal scan line Each line is made up of the active video portion and the horizontal blanking portion The active video portion contains the picture brightness luma and color chroma information The brightness information is the instantaneous amplitude at any p
241. e want to add functionality GFX CMD NTSC PRINTCHAR this command pipes right to the out function of the driver which supports the following sub commands already clear screen ome backspace ab 8 spaces per set X position X set Y position Y set color color fo return else prints the character to terminal ows ows ws 0 ol 11 gt gfx ntsc Out Term g data GFX CMD NTSC GETX return x position in spi buffer next read will pull it out on last byte of 3 byte packe g spi result gfx ntsc GetX GFX CMD NTSC GETY return y position in spi buffer next read will pull it out on last byte of 3 byte packe g spi result gfx ntsc GetY GFX CMD NTSC CLS eventhough this command is supported above we break it out as a separate SPI command just in case we want to add functionality on top of like overloading and handling manually notice we end up calling the 00 sub command but we have the flexibility to add stuff if we desire gfx ntsc Out Term 00 add other functionality to the clear screen here As you can see the code to extract and rebuild the SPI packets is tricky a lot of bit fiddling and masking to get the data back from the ASM SPI driver that is passing the data into the global shared memory All packets are 3 bytes long and look like this Command Packet Format
242. eClock first after main begins SYS ConfigureClock MAX FCY RATE I Configure clock for max initializa UART Init 115 Whi e 1 code goes here UART puts Enter letter Wait until they enter a letter 151 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit while UART_getchar amp ReadValue 0 UART Newline UART puts You entered UART_putchar ReadVal ue 1 Echo it back UART_Newline Function Prototype void UART_vt100Init void Parameters None Return None Description UART_vt100Init sends out the terminal emulation mode to signal VT100 reset This resets all terminal settings back to their defaults VT100 emulation is a simple escape sequence of commands you can send to a VT100 terminal or emulator program to be able to have more control than just printing text to the screen The Cham PIC UART driver only provides a small subset of what is available but provides enough to do many interesting effects Example s This example shows a simple usage scenario headers and globals go here int main void Unsigned char ReadVal ue Always call SYS first after main begins SYS ConfigureClock MAX FCY RATE Configure clock for max code goes here terminal to its defaults UART vt10 continue code Function Prototype void UART_vt100ClearScreen void Parameters None Return None Description _UART_vt10
243. ectively Note 2 VIN is connected to the 5V regulator s input pin This signal reflects the input analog voltage plugged into the 9V DC power jack If only the USB power is plugged in this signal will be floating or near ground 14 0 Audio Hardware There is no dedicated audio hardware inside the PIC chip nor the Propeller chip therefore we have to rely on software techniques to create sound for the system However knowing that software is going to be used to generate sound we can add a little analog circuitry to help the audio software out and allow us to use certain common techniques for generating sounds The Propeller does have counters on board and can generate PWM signals thus the audio drivers typically leverage these hardware elements Thus for most audio applications that connect to a Propeller chip all you need is a typical PWM integrator or low pass filter The Chameleon employs such a hardware design as shown in Figure 14 1 Figure 14 1 The analog audio hardware on the Chameleon PIC Audio PWM Low Pass Filter R14 C14 AUDIO 1K 10uF RCAIFEM R amp C set 3db point f3db 14 2 PFR C RING RCA AUDIO Referring to the circuit we see that the signal AUDIO I O P24 pin 31 on the Propeller is an input into the network This signal is passed thru a low pass filter consisting of a resistor R14 1K ohm and a capacitor C15 0 1uF Note these reference designators may change i
244. ectory C CHAM_PIC Demos does not exist Would you like to create it If the location you have chosen does not exist yet you may get warning as shown in Figure 15 32 Just click lt OK gt continue Figure 15 33 Add files dialog Project Wizard Step Four Add existing files to your project ALL DEV STUFF BrotherDriver CHAM PIC Demos Documents and Settin Download Gam eree eum Technolog MyWorks NVIDIA A At this point you could add files to your new project see Figure 15 33 In the future this is probably how you will handle adding initial files however we are going to add them manually once the project has already been created Do NOT add any files and click the lt Next gt button to go onto the summary window 98 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit era Project Wizard Summary Click Finish to create configure the project with these parameters Device PIC24HJ128GP502 Toolsuite Microchip C30 Toolsuite File C CHAM_PIC Demos Demo mep new workspace will be created and the new project added to that workspace CET Come Figure 15 34 shows the summary of your project parameters If they look correct click lt Finish gt to exit the Project Wizard and your project will be created on disk Demo IDE v8 15 E E
245. eless you should have your editor pointed to the source directory so you can review the complete contents of each file as we discuss them The System library module consists of a single C source file and its header The System modules must be included in every Chameleon PIC program since its contains some top level defines types and other pertinent elements that other API modules depend on In addition to the important defines it also includes the function that configures the onboard PLL allowing us to switch from an internal 7MHz RC clock to a full 40 MHz clock rate Additionally the C source file contains a few utility functions that will continue to grow in the future The System source files are named below CHAM_PIC_SYSTEM_V010 c Main C file source for System module CHAM_PIC_SYSTEM_V010 h Header file for System module You should include the h file will all your applications and add the C file to your source tree for all applications as well Next we will take a look at some excerpts from the header file review key elements and any data structures that are of interest 17 1 1 Header File Contents Overview The header files for many of the API modules are rather large and we won t have time to list their contents out in their entirety however the System header is quite manageable so we are going to take a look inside To begin with the header contains some useful macros co
246. eller chip The messages direct the Propeller chip to perform tasks These tasks can ultimately be anything but for now we have set the Propeller up so it can generate NTSC and VGA graphics audio and read keyboards and mice So the Propeller does all the work for you the PIC does very little thus freeing the PIC to take the role as master controller The messages sent to the Propeller are transferred over a high speed SPI serial peripheral interface link The PIC has SPI hardware built in so sending bytes to the Propeller is as simple as setting up a few registers and writing some bytes However the Propeller has no SPI hardware so we had to write drivers that emulate the SPI protocol with software This means there are limits to the speed you can send SPI traffic as well as the software SPI drivers are not very robust they are just starter drivers for you suggest you improve them As an example of how the system works let s say you have a PIC program you developed with MPLAB It has a A D convertor and measures temperature The temperature is then sent out to a crude LCD screen and looks ugly Also there are some controls for the program that you must use some external push button switches to set but it would be nice if you had a keyboard or mouse for user input This is no problem for the chameleon You would take you original program compile it for the Chameleon then add a few lines of code from our NTSC or VGA API that com
247. eo is much more complicated than B W however if we take a practical approach rather that a mathematical it s quite easy Forgoing the complex quadrature encoding of color and luminance and the encoding and decoding of the signals creating a color is very easy For each color clock on the active scan line you must generate a 3 579594 MHz sine wave this must ride on top or be superimposed on the luminance signal The overall amplitude of the signal is the brightness or luminance just as it was with B W but the color signal s saturation is simply the peak peak p p value of the color signal 3 579595 MHz signal as shown in Figure 11 6 The actual color that is displayed has nothing to do with the amplitude of the video signal but only the PHASE difference from the reference burst from the original color burst reference at the beginning of each line To re iterate to generate color we simply produce a 3 579594 MHz signal superimpose or add it to the overall luminance signal and the phase difference between our color signal and the reference is the color on the screen Cool Taking this further let s break up the line into pixels once again and see how many can be displayed each line There are 52 6 us of active video time We have to generate a 3 589594 MHz signal and stuff it into each pixel given this how many pixels can fit into a line Calculation of Color Clocks Per Line 52 6 us 3 579594 MHz 188 This means that at best
248. er hand averages around 100 KHz with 400 KHz being fast with many new devices supporting 1Mhz Thus SPI is at least 25 times faster But that s not the whole story The added overhead that C protocol attaches to communication addressing commands etc slow the protocol even more Thus 2 devices tend to find their way into slow peripherals where speed isn t an issue but addressing many of them may be For example serial memories sensors etc where the device itself is slow the 100 400 KHz average speed of I C is more than enough However SPI devices you will see in very high speed applications even video and audio Figure 19 4 shows an architectural diagram of how the 1 bus is laid out in relation to the master device and the slaves on the line Figure 19 4 I2C bus layout Device 1 Device 2 Device3 Device SDA SCL Electrically the bus consists of any number of masters and slaves on the bus Masters initiate communication while slaves listen and respond Masters can transmit and receive from a slave but a slave cannot initiate communications Additionally to enforce that masters are in charge the clock line SCL can only be controlled by a master furthermore placing the slave s into a passive role Moreover so that multiple devices can be connected to the same 2 signal bus from an electrical point of view both SDA and SCL are open drain thus pull up re
249. ervice mark Warning and Disclaimer Every effort has been made to make this user manual as complete and as accurate as possible but no warranty or fitness is implied The information provided is on an as is basis The authors and the publisher shall have neither liability nor any responsibility to any person or entity with respect to any loss or damages arising from the information contained in this user manual The example companies organizations products domain names e mail addresses logos people places and events depicted herein are fictitious No association with any real company organization product domain name e mail address logo person place or event is intended or should be inferred eBook License This electronic user manual may be printed for personal use and 1 copy may be made for archival purposes but may not be distributed by any means whatsoever sold resold in any form in whole or in parts Additionally the contents of the DVD this electronic user manual came on relating to the design development imagery or any and all related subject matter pertaining to the CHAMELEON systems are copyrighted as well and may not be distributed in any way whatsoever in whole or in part Individual programs are copyrighted by their respective owners and may require separate licensing NURVE NETWORKS LLC END USER LICENSE AGREEMENT FOR CHAMELEON PIC HARDWARE SOFTWARE EBOOKS AND USER MANUALS YOU SHOULD CAREFULLY
250. es are drawn into Usually this area is black on normal broadcasts of TV programs but the driver allows you to change the color The returned color value will be in Propeller color format chroma 4 bit chroma enable 1 bit luma 3 bit Example s Retrieve the current bottom overscan color int bottom overscan color GFX Get Bottom Overscan color Function Prototype int GFX Get Top Overscan Color void Description GFX Get Top Overscan Color retrieves the top overscan color of the NTSC driver The top overscan is a few lines at the top of the screen that no tiles are drawn into Usually this area is black on normal broadcasts of TV programs but the driver allows you to change the color The returned color value will be in Propeller color format chroma 4 bit chroma enable 1 bit luma 3 bit Example s Retrieve the current top overscan color int top overscan color GFX Get Top Overscan color Function Prototype int GFX Set Bottom Overscan Oolor int col 194 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Description _GFX_Set_Bottom_Overscan_Color sets the bottom overscan color to col where col is in normal Propeller color format chroma 4 bit chroma enable 1 bit luma 3 bit Returns 1 Example s Read the current color and increment the chroma portion of the color upper 4 bits I ca cu the co AS int color GFX Get Overscan Color
251. es num bytes Typically you will use this function to clear tile map bitmap memory and other repetitive operations that require the same value to be written Returns 1 Example s Fill 100 BYTEs starting at address 3456 with the value AF GFX GPU Fill MemB 0x3456 OxAF 100 Function Prototype int GFX Copy 8 int dest ptr unsigned int src ptr unsigned int num bytes Description GFX GPU Copy Mem6 copies a number of bytes from source to destination in the GPU memory space in BYTE side chunks or in other words in the Prop s local memory of 32K you can use this to overwrite SPIN code so watch out The parameters are the destination address to copy to dest ptr the source address to copy from src ptr and finally the number of bytes num bytes to copy Typically you will use this function to copy tile maps scroll page flip perform various animations etc Returns 1 Example s Assuming that the current tile map is 32x24 physically and virtually and there are two tile maps one located at 1000 and the other at 2000 copy the later to the former 187 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit GFX GPU Copy Mem8 0x1000 0x2000 32 24 2 Function Prototype unsigned int GFX Read Palette Ptr void Description GFX Head Palette Pir reads the 16 bit palette pointer that points to the set of palettes referred to by the pal
252. esscsseccusssssessessecssessecsucsessesssccsesssssececcnscsecsscsecsessoeseessese 20 1 3 The Parallax Propeller Chip 25 1 31 Propeller Core COG Video Hard Wares ue rrt rettet deer RE Pe teneri dre esee d eye 27 1 4 System Startup and Reset Details eese sees eese eese rro ooien 27 PART I HARDWARE DESIGN PRIMER 111a anc c Ou cana aa nara aon n car CE aaa Rua 28 2 05 0V amp 3 3V POWER SUPPLIES aeu oak aan akon rena Chios 31 S L RESET CMR GUE i5 code tetuer nb dedu E 31 4 0 MICROCHIP 6 PIN ISP PROGRAMMING nennen nnn nnn 32 4 1 PICKit 2 ISP Programming Port P 32 5 0 SERIAL USB UART PROGRAMMING PORT 34 6 0 USB SERIAL UART 35 7 0 MICROCHIP PIC24 SUBSYSTEM 36 8 0 PARALLAX PROPELLER SUBSYSTEM RI ied Cove end ia inr ede bowls 37 8 1 The Propeller Local 8 Bit Pot tssis seta suse ta stas enses enses ses tosta sse sesto aestu 37 9 0 THE SPI BUS AND COMMUNICATIONS SYSTEM 38 2
253. est Pir sets the 16 bit destination pointer for tile GPU fill and memory operations This is an absolute address in Propeller RAM memory Returns 1 Example s Read the destination pointer and add 4 to it and write it back GFX Set Dest Ptr GFX Get Dest Ptr 4 Function Prototype int GFX Get Tilemap Width void Description GFX Get Tilemap Width retrieves the 8 bit the tile map width encoded as 0 1 2 3 which means 32 64 128 256 tiles Example s Read the tilemap width and store it int tilemap width GFX Get Tilemap Width 193 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype int GFX_Set_Tilemap_Width int width Description GFX Set Tilemap Width sets the width of the tile map to 32 64 128 or 256 which are encoded as 0 1 2 3 with the parameter width The idea of this function call is to set the virtual playfield of the tilemap to large than its physical size which is always 32 tiles Doing so allows for horizontal scrolling course Returns 1 Example s Setthe tilemap width to 128 tiles which is 4 complete screen fills of tiles for horizontal scrolling GFX Set Tilemap Width 2 Function Prototype int GFX Get Bottom Overscan Color void Description GFX Get Bottom Overscan Color retrieves the bottom overscan color of the NTSC driver The bottom overscan is a few lines at the bottom of the screen that no til
254. ething A bit of investigation of the schematic and the boot code shows that P25 is connected to the status LED In fact the boot code that blinks the LED 3 times during boot looks like this blink the status LED 3 times to show board is alive DIRA 25 1 set to output QUAL ZS se repeat 6 OUTA 25 OUTA 25 repeat 25 000 Therefore this code already sets up the direction of the port bit all we need to do is add the two messages that set the port bit LOW and HIGH Reviewing the main message dispatcher loop we simple find the last message processed and add a couple more messages Here s that section before and after again Before REG CMD WRITE BYTE write byte 0 3 of output register g reg out buffer byte 0 3 byte address to write 0 3 is in g data while data to write is in g data g reg out buffer byte g data g_data2 read command from byte registers of 32 bit buffer register REG CMD READ BYTE 1 cead byre Dood of xut register G ges Ta plier 0 3 this data is then placed into spi buffer for transport back to client byte address to read 0 3 is in g data g spi result reg in buffer byte g data resets the prop reboot end case commands set result and set to idle spi finishcmd g spi result d 00p 245 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit After Adding New Message Handlers
255. ette index in each tile entry This pointer is of course relative to the Propeller s 32K memory space and an absolute address Each palette entry is a single 32 bit long that represents 4 colors in the format color 3 color 2 color 1 color 0 that are represented by the bitmaps as each 2 bit pair indexing as color 0 1 2 3 Returns the 16 bit pointer value address Example s Read the palette pointer unsigned int palette ptr prop palette ptr prop GFX Read Palette Ptr Function Prototype unsigned int GFX Write Palette Ptr unsigned int palette ptr Description GFX Write Palette Ptr writes the 16 bit palette pointer palette ptr that points to the set of palettes referred to by the palette index in each tile entry each palette entry is a single 32 bit long that represents 4 colors color 3 color 2 color 1 color 0 that are represented by the bitmaps as each 2 bit pair indexing as color 0 1 2 3 When this operation is performed the palettes pointed to must be valid colors otherwise sync issues could occur since the color words can represent both color and sync So make sure that when you do alter the palette pointer you have built up value palette entries and that all potential palette indices in your tile map are represented by a palette Returns 1 Example s Read the palette pointer and then shift it by 4 bytes in essence by a single palette of 4 colors down the list GFX Write Paltte Ptr GFX
256. ettings Preferences General Command File Editor View Initial folder FileDir Document Classes Associated Files C Prompt for parameters Capture output Backup Run minimized C Suppress output until completed Environment Variables MJS irst Sound alert when completed File Name Filters Folders Keyboard Language Macros Spelling Tools File Line v Column CompileDownload l Parameters CompileD ownload bat File COM Regular expression to match output Registers Next we need to make some modifications to the tool settings Take a quick look at Figure 15 50 as it shows the final settings that we need for this tool The two modifications that you need to add are first add the parameters File and COMxX onto the end of the Parameters edit box just after CompileDownload bat Second click the Save all documents first checkbox By adding on the File parameter this causes TextPad to take the current file name that you are editing in TextPad and to send that as a argument to our batch file The second argument COMX in my case COM7 is the communications port that the Chameleon is connected to This can be found under the Device Manager in Windows and we will show you how to find it explicitly in Section 15 2 3 below The Save all documents first checkbox cause TextPad to save all files that have been modified before running the DOS command line This is important because the alternative is t
257. ex NTSC Term Char X end for index 21 0 VGA Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media drivers all the API functions do including the VGA is expose some of the base functionality in nice function calls so you don t have to send SPI messages yourself In the case of the NTSC driver CHAM_DEFAULT2_DRV_112 SPIN we are using the following Propeller Object for the VGA tile engine and text display VGA_Text_010 spin VGA tile engine with support for terminal mode graphics with a tile resolution of 32x15 Very stable but limited Unlike the NTSC driver we are using the same VGA terminal driver for both Default and Default2 Propeller drivers so it doesn t matter which you are using the same rules apply The standard is much higher resolution thus this driver is much less capable than the NTSC driver However you can always use a more advanced VGA driver and modify the Propeller message dispatcher
258. experiment highpass hpf html In any event playing with the math the 3dB point for our circuit is 1 2 PI RC Notice f is not in there since we solved for it Therefore we have everything we need to use the circuit and the equation Let R and C in our circuit be 1K Ohm and 0 1uF respectively plugging them in we get 1 2 PI1K 0 1uF 1 59 KHz Which might be a little low to loosen this up let s make the resistor smaller 200 Ohm fsag 1 2 PI 200 0 1uF 7 95 KHz Which is a rather high frequency about 5096 the max range of most human ears which top out at 15 20KHz Figure 14 2 Sine wave riding on a constant DC offset as its passed thru a coupling capacitor 6 Audio signal before coupling capacitor 2 0V offset Audio signal after coupling capacitor no offset Why is this important Well first off if you send a signal thru our little low pass filter to the output connected to the audio port on the TV then the signal is going to attenuate at high frequencies We will get back to this momentarily let s move on to the second stage in the audio circuit which is based on C15 This stage of the circuit is a AC pass filter that means that it will only pass AC and the DC component will be blocked In other words say that the input was a sine wave or square or square wave with a peak to peak voltage of 1V but it was riding on a 2V signal this would look like Figure 14 2 top graph in
259. f key gt 32 sprintf sbuffer Key Code d int key char key else sprintf sbuffer Key Code d non printable int key I position cursor NTSC_SetXY 1 4 I print on NTSC terminal screen NTSC Term Print sbuffer NTSC Term Char 0x0D I position cursor VGA SetXY 1 4 I print on VGA terminal screen VGA Term Print sbuffer VGA Term Char 0x0D slow things down a bit so we can read the text DELAY MS 10 Il end while l end main have highlighted the little scanner that looks for the sequence morpheous Try typing it in and see if it works Summary This demos shows off how easy it is to access the PS 2 keyboard If you have done work with embedded systems reading a PS 2 keyboard is always a challenge since it s such a slow device Thus the best solution is to use interrupts to detect bits sent by the keyboard However this usually means that any other processes that are running on a high speed interrupt will be interrupted which is tricky However with the Propeller doing all the work on a separate processing core reading the keyboard is trivial and requires no processing load at the master s end 30 1 2 Mouse ASCII Paint Demo This demo uses the mouse API to communicate with a local PS 2 mouse plugged into the PS 2 port via the Propeller s mouse Make sure to plug your mouse into the Chameleon and get a good connection This crude ASCII Paint demo 222
260. f 2 bit D A converters that sum each 2 bit channel pair R1 RO G1 GO and B1 BO and directly interface the sync bits The VGA spec dictates that for each channel 0 intensity is 0 0V and 100 intensity is 1 0V some references use 0 7V Also each channel input to the VGA monitor itself per input has a nominal impedance of 75 Ohms similar to the NTSC input impedance Table 10 1 The Video Hardware Prop Port Bit Chameleon Signal Description P19 VGA BLUE B1 Bit 0 of BLUE channel P18 VGA BLUE BO Bit 1 of BLUE channel P17 VGA_HSYNC VGA HSYNC TTL level P16 VGA VSYNC VGA VSYNC TTL level 40 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 10 2 Electrical model of VGA inputs and 2 bit D A channels 3 3V Vec B1 1 1 1 1 Virtual Impedence of display device VGA TV CRT 1 RLOAD 75 5 0 V L 1 1 0 75 Ohm 0 z 1 0 0 B1 0 RLOAD 75O0hm Therefore from the D A s perspective with both bits on the circuit looks like that shown in Figure 10 2 for any particular channel R G or B Noting that the Propeller is a 3 3V device with both channel bits HIGH that means that we have a 270 Ohm in parallel with a 560 Ohm and this combination in series with the intrinsic impedance of 75 Ohms of the VGA thus we can do a simple computation to compute
261. f Height 011 spin 1 0 mouse 010 spin Note 1 Many of the drivers include other sub objects as well Note 2 There are two versions the MCP driver one is called CHAM DEFAULT2 DRV V112 spin this is used for all our 135 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit examples However there is a slightly modified version called CHAM_DEFAULT1_DRV_V112 spin that uses the plain vanilla NTSC terminal that might work better on some LCDs You can drop down to it if you have trouble with the default2 driver Note 3 The Chameleon only has one PS 2 port so only one driver keyboard or mouse can be active at once However the default MCP driver can hot swap the drivers so you can unplug the keyboard mouse in real time and with software start the new device All of the drivers and their sub objects are included in the source directory for this chapter located on DVD ROM in DVD ROM CHAM_PIC SOURCE PROPELLER_DRIVER If you look on the Parallax Object Exchange you should be able to find most of these drivers as well however we will use the ones from my chapter and my sources since made slight modifications to each of them to make things easier 16 4 1 Normalization of Drivers for Common RPC Calls in Future The last thing want to discuss about the drivers in the interfaces to all of them Since this is a pieced together system of other people s drivers each driver obviously has i
262. f use ASM should be used for drivers when necessary via APIs that can be called from C Additionally the Ardunio tool chain uses as well Even though the Ardunio folks call the language Processing it s just good old The tool of choice for native PIC development is of course MPLAB This tool was developed by Microchip and supports source level debugging various programmer and E ICE debuggers etc However the C compiler is a plug in based on GNU GCC called PIC24 C compiler sometimes also referred to as pic30 compiler We will discuss the installation of the tool chain shortly but keep in mind the separation Additionally we will be using straight for coding fe LU ges uet Pagar De Orare Wam w GAM aaa eae 01106 b eh PEN tM F ATRE tmailt esarp be nos 2 Fico te ON PO dnm ies 1 we 23 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit MPLAB is shown in Figure 1 7 it s a standard Windows application that is used to develop applications for the entire line of PIC microcontrollers It s very similar to Visual C with context highlighting project management etc The IDE allows viewing of the various files and statistics as builds are performed The IDE supports many different plug in compilers from different vendors
263. f you want to do gaming tile based graphics right now as is you have to use the Default2 driver CHAM DEFAULT2 DRV 112 SPIN and only the NTSC Screen output is supported But again the point is you can change the Propeller driver and re write it as you wish we simply give you a starting point to get going with So if you want to know what the driver supports you can always peek into the driver itself CHAM GFX DRV 001 TB 001 and see the messages that are getting passed to it you always look into the CHAM DEFAULT2 DRV 112 SPIN driver itself 176 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit With that in mind if you want to use the GFX NTSC driver then you need add both the base NTSC driver along with the GFX API as well to your project CHAM_PIC_NTSC_DRV_V010 c Main C file source for NTSC module CHAM _PIC_NTSC_DRV_V010 h Header file for VGA module CHAM_PIC_GFX_DRV_V010 c Main C file source for GFX module CHAM_PIC_GFX_DRV_V010 h Header file for VGA module 22 1 GFX Driver Architectural Overview The idea of the Chameleon is that you use other people s drivers make your own and change them as you need them on the Propeller side Thus we don t want to spend too much time explaining how any particular driver works since you will probably change it However the NTSC GFX API is worth covering for a little so if you do want to create a game or something m
264. face 56 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 12 1 PS 2 connector interface to Chameleon PIC Prop Port Bit Pin Chameleon Signal Description P27 PS2 CLOCK Keyboard clock signal open collector P26 PS2 DATA Keyboard data signal open collector As noted the PS 2 interface works the same for keyboards and mice the protocols are different but the low level serial and hardware interfaces are the same Thus if you plug a mouse into the port it would work the same the clock and data lines would be in the same place Thus all you would have to do is write the driver In the section below general keyboard and mouse operation is described so you can write your own drivers if you wish The driver we used for the Propeller driver supports both keyboard and mouse but it s not integrated thus a core is needed for each driver object a bit wasteful The keyboard protocol is straightforward and works as follows for every key pressed there is a scan code referred to as the make code that is sent additionally when every key released there is another scan code referred to as the break code that in most cases is composed of EO followed by the original make code scan value However many keys may have multiple make codes and break codes Table 12 2 lists the scan codes for keyboards running in default mode startup Table 12 2 Default scan codes
265. ferent functionality and you will want to re write a new high level wrapper for the driver in question However hope that you use them as starting points only to develop your own API functions and drivers that are much more optimized and complete On the other hand have spent a good deal of time trying to develop a base set of libraries to get you started so that you can do everything from graphics and sound to UART communications with the PC Table 17 1 lists all the API library modules we have developed for you to jumpstart your development and exploration of the Chameleon PIC Table 17 1 The Chameleon PIC source level library modules at a glance I 2 CICER MCN Ua MEN CHAM_PIC_GFX_DRV_V010 c h Functions to take advantage of the graphics tile engine that runs under the default2 drivers heu NTSC Text and Tile Graphics Module NI CHAM PIC NTSC V010 c h Tile engine and text console terminal functions VGA Text and Tile Graphics Module E e a eee CHAM_PIC_VGA_DRV_V010 c h Tile engine and text console terminal functions SOS Audio Driver Module O CHAM PIC SOUND V010 c h Sound driver functions Communications Modules a a CHAM_PIC_UART_DRV_V010 c h Low level Serial RS 232 communications driver CHAM l2C SPI DRV VO010 c h Low le
266. for NTSC modes wrote the tile engine to give you more performance and the ability to do some game like applications These commands are more complex and it will take a bit to explain them but for now just peruse them below advanced GFX commands for GFX tile engine define GFX BASE ID 192 I starting id for GFX commands to keep them away from normal command se define GPU GFX NUM COMMANDS 37 number of GFX commands define GFX SUBFUNC STATUS 0 GPU GFX BASE 10 Reads the status of the GPU Writes the GPU Sub Function register and issues a high leve 11 command like copy fill etc define GPU GFX SUBFUNC STATUS W 1 4GPU GFX BASE ID Writes status of the GPU Writes the GPU Sub Function register and issues a high leve command like copy fill etc I sub function constants that are executed when the GPU GFX SUBFUNC STATUS W command is issued define GPU GFX SUBFUNC COPYMEMI6 0 Copies numbytes from src gt dest in wordsize chunks define GPU GFX SUBFUNC FILLMEMI6 1 Fills memory with datal6 2 bytes at a ti me define GPU GFX SUBFUNC COPYMEM8 2 Copies numbytes from src gt dest in byte size chunks define GPU GFX SUBFUNC FILLMEM8 3 Fills memory with low byte of datal6 1 bytes at a ti me 1 normal commands define GFX TI LE 2 GPU GFX BASE ID Reads 16 bit tile map ptr which points to the current tile map displayed define GFX TI LE W 3 GPU GFX BASE 10 Wri
267. formance RUIT UB RII wait for SPI driver to receive a command packet in shared memory if g_spi_cmdpacket amp 1 00 00 00 gt 0 reset the reception flags 9 spi buffer 9g spi buffe g spi cmdpacket g spi PRSE REE extract cmd 8 bit data 8 bit status 8 bi g cmd g spi cmdpacket gt gt 16 amp FF g data g spi cmdpacket gt gt 8 amp FF low byte of 16 bit data g_data2 9 status g_spi_cmdpacket gt gt 0 amp FF high byte of 16 bit data build 16 bit data may not be valid though based on command g_datal6 g_data2 lt lt 8 9 data now process command to determine what user is client is requested via spi link case cmd GFX NULL GFX GPU TILE ENGINE COMMANDS 129 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit catch all comman rig F ds right here GPU_GFX_BASE_ D GPU_GFX_BASE_1D GPU GFX NUM COMMANDS 1 call single processing function g spi result gfx ntsc GPU GFX Process Command g cmd g datal6 IH t NTSC GFX TILE SPECIFIC COMMANDS we only expose a subset of the commands the driver supports you can add subtract more commands as desired some commands like PRI NTCHAR for example internally support a number of sub commands that we don t need to expose at this level unless w
268. functionality in nice function calls so you don t have to send SPI messages yourself For sound we decided to re use a driver from the HYDRA development that was designed for both PWM and PCM samples with multiple channels The same sound driver is used in both Default and Default2 so the same idea apply to either driver you load on the Propeller CHAM DEFAULT1 DRV 112 SPIN or CHAM DEFAULT2 DRV 112 SPIN The actual driver object used for sound is NS sound 052 1ikhz 16bit spin This is an 11Khz 16bit sound driver with 9 independent audio channels It s pretty cool However only exposed a portion of its abilities thru the current SPI messages since sound is something that you will probably want either a little or a lot no need to waste messages You can always add more Therefore the abilities you see exposed in the following are just a taste of what it can do For example to save commands mashed sound commands into a single SPI packet so you only can control 4 channels with limited frequency and control In other words 195 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit if you need more than simple 4 channel sound then you will have to add messages to the SPI driver and add them yourself With that in mind if you want to use the sound driver then you need the following files added to your project CHAM_PIC_SOUND_DRV_V010 c Main C file source for Sound module CHAM PIC SOUND
269. g filling etc and create something like the famous DPaint that we used to use to make games in the 80 s and 90 s The next group of demos illustrate the Serial port FLASH memory and Propeller functionality As usual the demos try to do something graphical so they always support NTSC output and some might support VGA output as well But they all usually use nothing more than text terminal graphics so added support is a couple lines of code The examples typically consist of the primary source file for the demo as well as 224 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The System API library module CHAM_PIC_SYSTEM_V010 cjh The main SPI API library module CHAM PIC I2C SPI V010 c h The serial API library module CHAM PIC UART VO010 c h The FLASH API library module CHAM PIC FLASH V010 c h The Propeller local 8 bit port API library module CHAM PIC PROP PORT DRV V010 c h The NTSC VGA GFX driver or all of them And any other ancillary drivers keyboard mouse etc All the required files can of course be found in the Source directory on the DVD which you should have already copied onto your hard drive located here DVD ROM CHAM SOURCE 30 1 1 Propeller Local Port LED Blinker Demo The Propeller chip on the Chameleon had 8 free pins so we decided to add an 8 bit port to it With this you can interface SD cards SPI memory control servos
270. g corrupted etc However you do not have to use the Microchip bootloader alone There are a number of bootloaders in fact the Arduino bootloader could eventually be ported to work with the PIC chip so that you can potentially use the Arduino tool to program the Chameleon PIC Thus you can make your own bootloader use Microchip s and so forth along with your own copy of the GNU GCC PIC tools and then program on Linux Windows Mac or any other operating system the GNU GCC tools are available on The bottom line is that all the bootloader does for us is allow a serial protocol to communicate to the PIC chip and FLASH its memory with a program This saves you the 29 39 of a PICkit 2 ISP programmer that s about it 33 1 Developing Your Own Propeller Drivers Well the last burning question in your mind should be how do add more functions to the Propeller driver This is a multistep process but very easy As an example we are going to add a couple messages that allow the client master application running on the PIC to control the status LED on the Chameleon next to the Propeller Local 8 bit port Before we begin let s take a quick look at the flow of messages from the PIC to the Propeller once again to review all the components take a look at Figure 33 1 below 242 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 33 1 The flow of messages from the PIC or AVR to the Propeller CO
271. g you also have access to an excellent simulator built into MPLAB The simulator works much faster as far as stepping through and watching variables as opposed to the debugger There is even a stop watch timer that allows users to time critical sections of code for analysis The downside with the simulator is that you will not be able to test peripherals like the UARTs SPI and the media processor capabilities provided by the Parallax Propeller Figure 1 8 The Parallax Propeller Chip block diagram Cog 0 Cog 2 Cog 3 Cog 4 Cog 5 Cog 6 Cog 7 Tt HH gt D D D Pin Directions Ta Pn Outputs P 2 532 N Y Y CN CN CP15 CP30 CP14 CP29 CP13 sil allo allall sil allg E sll all gl allall sil al 8 allalls 9 28 S s9leo 2112112118118 2 2 2 o allallsigs 22 CP28 a 9o r4 ajage a a 5 52 818 tel 8s CP10 5 3 2 E Ag EIE 5118 5 518 515 3 2 E 3g E 3g Es 5118 CP25 P9 51151181015 511518 5115181015 55195 5115181016 511518106 51151181016 511518105 9945 C p83 815 58 1821 8118121 81181212 8181212 3 8 S ge 8181212 8181212 e 2 Ti 512 X 32 5
272. ggest you review the following references for a more complete treatise on 2 DVD ROM CHAM DOCS I2C V I2C_bus pdf DVD ROM CHAM PIC DOCS I2C Section19 I2C pdf Now let s move onto the SPI 1 library module that implements a very thin layer of software on top of the built in hardware Moreover you may wish to develop much higher level functionality yourself The SPI I2C module header CHAM_PIC_I2C_SPI_V010 h is very important since it houses the constants for the SPI communications interface to the Propeller so we are going to cover it in detail Let s begin with the defines that declare some of the hardware signals and constants used to represent 2 and SPI interfaces I Selects the app define SPI SET CS ll 12 defines ock in Hz 2C_DEFAULT_ CLOCK 100000L initially set to 100Khz this is the default when you call 12C_Init 0 vice PORTB amp 0xC000 PORTB DEVICE Il SPI defines Chip se hoi ces define SP define SP define SP SP define The defines simply declare the macros chip selections and some timing constants For example I2C DEFAULT CLOCK is a convenient constant to pass the initialization function covered later Notice the macro SPI SET CS DEVICE This macro is meant to be called in your normal C code with the following SPI_CS_X define choices Effectively what this will do is it will reconfigure the I O port selections and SP
273. gn but with multiprocessing and multicore so popular thought it would be interesting to use both concepts in a product The Chameleon is the culmination of these ideas To create a product that with very little coding you could output NTSC PAL graphics VGA graphics read keyboards and mice as well as communicate with serial ports and perform digital and analog I O The selection of the processors was difficult as it always is We have to balance price performance user base flexibility and a number of other factors Additionally since the Chameleon is a dual processor design had to think of a clean way to interface the processors such as shared memory SPI 2 etc Taking all those factors into consideration decided to use the Microchip PIC24HJ128GP502 processor for the Master and the Parallax Propeller chip for the Slave The AVR version uses a Atmel AVR 28 8 bit processor but the idea is the same Thus the idea is that the PIC or AVR with its huge fan user base will be the ring leader you code in C ASM on the PIC processor and then over a SPI interface you send commands to the Propeller chip which is running a SPI driver and then issues the commands from the PIC to various processors more on this in the Architecture Overview This is the perfect fusion and balance of the two processors From the PIC s perspective the Propeller chip is simply a media processor the programmer need not know a single thing about the Propelle
274. gram the Propeller you will use Spin ASM primarily However there are 3 party C compilers a FORTH is available and other languages if you search the Parallax site 26 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 1 31 Propeller Core COG Video Hardware Lastly let s talk about the video hardware for a moment Probably the coolest thing about the Propeller chip is that each core has a little state machine that can stream video data out These little devices are called Video Streaming Units or VSUs and every core has one Thus you can in theory drive 8 different video signals at the same time The VSUs are not graphics engines GPUs even 2D stuff They are nothing more than serializers that send bytes out to port However they send bytes out at a specific rate and the analog signals they can generate can be timed to synthesize NTSC or PAL signals including blanking sync chroma and color burst signals In essence with each core you can use software to set up the VSU units then the unit will send out data representing one portion or chunk of the video signal then you feed it more Therefore you have to know how to generate NTSC PAL or VGA yourself but the VSU helps and offloads a lot of the timing and critical coding you would need to do usually Alas once again you don t have to worry about this Myself and numerous other programmers have written countless video drivers for the Propeller chip Everyth
275. h the value AAFF GFX Fill 16 0x3456 OxAAFF 100 2 Function Prototype int GFX Copy Memd16 unsigned int dest ptr unsigned int src ptr unsigned int num bytes Description GFX GPU Copy Mem16 copies a number of bytes from source to destination in the GPU memory space in WORD side chunks or in other words in the Prop s local memory of 32K you can use this to overwrite SPIN code so watch out The parameters are the destination address to copy to dest ptr the source address to copy from src ptr and finally the number of bytes always a multiple of 2 num bytes to copy Typically you will use this function to copy tile maps scroll page flip perform various animations etc Returns 1 Example s Assuming that the current tile map is 32x24 physically and virtually and there are two tile maps one located at 1000 and the other at 2000 copy the later to the former GFX GPU Copy 16 0x1000 0x2000 32 24 2 Function Prototype int GFX Fill Mem8 unsigned int dest ptr unsigned int value unsigned int num bytes Description GFX GPU Fill Mem6G fills a number of bytes using value to destination in the GPU memory space in BYTE side chunks or in other words in the Prop s local memory of 32K you can use this to overwrite SPIN code so watch out The parameters are the destination address of the fill dest the 8 bit data value and finally the number of byt
276. h use the serial port lines DTR to control the reset of the respective chips during programming 4 0 Microchip 6 Pin ISP Programming Port The Chameleon PIC has two different programming ports 6 pin ISP In System Programming port used to program the PIC chip directly USB UART used to program the PIC with bootloader as well as Propeller chip For more technical information on these ports and protocols please refer to these documents on the DVD DVD ROM CHAM_PIC DOCS PIC24_REF_MANUAL SECTION24 JTAG pdf DVD ROM CHAM_PIC DOCS ISP_JTAG PICKIT2_USER_GUIDE pdf Let s discuss both programming ports and their relevance beginning with PIC s built in ISP port The ISP port is for programming the PIC chip only Microchip and other 3 party manufacturers sell programmers that are compatible with MPLAB The Microchip product called the 2 is typically used by hobbyists as a low cost alternative for use with Microchip PIC line of products as in Figure 4 1 available for purchase separately Figure 4 1 The Microchip PICkit 2 programmer The circuit for the ISP programming port is presented in Figure 4 2 while the pinout and descriptions are given in Table 4 1 From the figure we can see that the programming ports are fairly simple Each line directly connects to the process or power The PICkit 2 ISP programmer can control the RESETn line of the board and even supply 3 3V power if it detects the board
277. hack into some Silicon Valley computer game company but instead modem ed into the WOPR which stood for War Operations Planned Response which was a computer running the entire USA missile system The computer wants to play a game and the story begins from there The whole point of this stroll down memory lane is that computers used to be magical devices that opened up whole worlds to people in a much more personal way than they do today And text based games used to be the conduit of much of this interaction with computers So even with a simple terminal program you can create something with the serial port that s kind of cool If you re interested in the computer used in the movie it too is very famous the IMSAI only a few left in operation Here s a link to more information http www imsai net movies wargames htm Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Serial UART demo illustrates text output and input using a game as the platform Main Source File CHAM PIC GUESS NUMBER 901 c Additional Files Required CHAM PIC SYSTEM V010 c h CHAM PIC UART DRV VO010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC SOUND DRV V010 c h General Requirements Serial port connection from Chameleon PIC to PC over the USB cable terminal programming running RCA sound output connected to speaker or TV audio Controls Required None uses PC keyboard via terminal program The game starts by aski
278. hameleon dev com Discuss and show off your demos applications drivers and games with other Chameleon programmers Also if you have any questions comments or remarks please email us at support nurve net Part III Appendices Appendix A Schematics This appendix contains the master schematic of the Chameleon PIC 16 Bit and all its sub systems 250 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure A 1 Chameleon PIC 16 Bit schematic E 8 s sl E Hin i o NEUE Tet 5122062299 vwv xgamestation com TX T8732 i 5 i i 251 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix B Microchip PIC24HJ Pinout This image shows the Microchip PIC24HJ 28 Pin SDIP and SOIC packages Figure B 1 Microchip PIC24HJ pinouts 28 Pin SDIP SOIC MCLR 1 ANO VREF CN2 RAO 2 ANT VREF CN3 RAT PGD1 EMUD1 AN2 C2IN RPO CN4 RBO 4 PGC1 EMUC1 AN3 C2IN RP1CNS RB1 5 ANAICTIN RP2UI CNG RB2 6 ANSICTINs RP3UICNTIRB3 7 7 Vss 8 OSCI CLKI CN30 RA2 9 OSCO CLKO CN29 PMAQIRA3 10 SOSCI RPAU CN1 PMBE RB4 11 SOSCO T1CK CNO PMA RA4 12 13 PGD3 EMUD3 ASDA1 RP5 CN27 PMD7 RBS5 14 Z0Sd 982 LF HPZOId 707d D8Z 09 9 9 20249 9 2 21 Z0Ed9ZECHPZOId 28
279. hardware on the Chameleon PIC The VGA hardware is very simple consisting of little more than 8 I O lines and 3 D A converters based on resistors The Propeller chip does all the work generating the VGA signal but it s nice to understand what s going on so we are going to briefly take a look at the VGA specification so you have a conversational understanding of it if you haven t programmed direct VGA before and why VGA is both good and bad from a video generation point of view So here s what s in store Origins of VGA Chameleon PIC VGA hardware design VGA signal primer 38 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Before we start into the design let s get some history and terminology correct First the last time saw a real VGA monitor was about 20 years ago the new 21 century monitors that you are used to are super sets of VGA they are typically multisync variable refresh and can go up to 2400x2400 or more The VGA specification is more of a base point than anything anyone actually uses anymore IBM released the VGA or Video Graphics Array technology in 1987 roughly It was touted to change the world definitely an improvement from CGA and EGA but it was doomed from the start with not enough resolution shortly after higher resolution monitors were available and the VGA specification was enhanced with the Super VGA standard but this was only a momentary hold on its execution w
280. hat supports full duplex communication However only takes 2 wires and a ground Where SPI needs 3 wires ground and potentially chip select lines to enable the slave devices But SPI is much faster so in many cases speed wins over and the extra clock line is warranted The advantage of I2C is that you can potentially hook hundreds of devices on the same 2 bus lines since I C devices have addresses that they respond to SPI bus protocol on the other hand requires that every SPI slave has a chip select line Figure 19 1 The SPI electrical interface 19 1 SPI Bus Basics Figure 19 1 shows a simple diagram between a master left and a slave right SPI device and the signals between them which are SCLK Serial Clock output from master MOSI SIMO Master Output Slave Input output from master MISO SOMI Master Input Slave Output output from slave SS Slave Select active low output from master Note You might find some devices with slightly different naming conventions but the idea is there is data out and data in a clock and some kind of chip select If you refer back to the Chameleon s SPI interface discussion in Section 9 0 of the Hardware Primer you can see that these signal pins are mapped from the PIC to the Propeller chip SPI is very fast since not only is it clocked but it s a simultaneous full duplex protocol which means that at the same time that you clock data out of the master into t
281. hat was needed was a more progressive standard that could change at any time and thus the VESA Video Electronics Standard Association graphics cards and drivers were created and the rest is history However the original specs for the VGA are shown below 256 KB Video RAM 16 color and 256 color modes 262 144 value color palette six bits each for red green and blue Selectable 25 MHz or 28 MHz master clock Maximum of 720 horizontal pixels Maximum of 480 lines Refresh rates up to 70 Hz Planar mode up to 16 colors 4 bit planes Packed pixel mode 256 colors 1 byte per pixel Mode 13h Hardware smooth scrolling support Some raster operations Raster Ops support to perform bitmap composition algorithms Barrel shifter in hardware Split screen support Soft fonts Supports both bitmapped and alphanumeric text modes Standard graphics modes supported by VGA are 640x480 in 16 colors 640 350 in 16 colors 320 200 in 16 colors 320 200 in 256 colors Mode 13h chunky graphics mode spent many years writing graphics algorithms and drivers for VGA cards to push them to the outer limit now my cell phone has better graphics However the VGA spec is great for baseline computer displays and any standard modern computer monitor will display old school 640x480 VGA modes and refresh rates However the Propeller chip can generate VGA modes at much higher resolutions and there are a number of multicore
282. he integer variables you want to receive the values Returns 1 Example s Retrieve the current cursor position t Xu ys NTSC Get XY amp x amp y 171 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype int NTSC SetXY int x int y Description SetXY sets the current cursor position on the NTSC terminal screen The position ranges depend on the driver but for Default2 they are 0 31 0 23 Returns 1 Example s Read the current cursor position and then move the cursor one position to the right Xu yg NTSC Get XY amp x amp y NTSC Set XY x41 y Function Prototype int NTSC Term Char char ch Description Term Char prints an ASCII character to the NTSC terminal at the current cursor position updates the current cursor position and potentially scroll the text screen up if printing on last line of display Additionally this function is a sub command conduit to the terminal manager This functionality should be maintained for any drivers that you develop so users can have a standard set of base terminal functionality You can send the following ASCII codes some functions are redundant 00 clear the screen 01 home the cursor to top left 08 backspace 09 tab 8 spaces per 0A set X position X follows 0B set Y position Y follows 0C set color color follows
283. he slave data is clocked from the slave into the master This is facilitated by a transmit and receive bit buffer that constantly re circulates as shown in Figure 19 2 156 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 19 2 Circular SPI buffers Master Slave o 3 2 3 4 5 6 7 o 2 2134 5 6 7 The use of the circular buffers means that you can send and receive a byte in only 8 clocks rather than clocking out 8 bits to send then clocking in 8 bits to receive Of course in some cases the data clocked out or in is dummy data meaning when you write data and you are not expecting a result the data you clock in is garbage and you can throw it away Likewise when you do a SPI read typically you would put a 00 or FF in the transmit buffer as dummy data since something has to be sent and it might as well be predictable Sending bytes with SPI is similar to the serial RS 232 protocol you place a bit of information on the transmit line then strobe the clock line of course RS 232 has no clock As you do this you also need to read the receive line since data is being transmitted in both directions This is simple enough but SPI protocol has some very specific details attached to it about when signals should be read and written that is on the rising or falling edge of the clock as well as the polarity of the clock signal This way there is no confusion about edge level or phase of the signa
284. henever a movement data packet is successfully sent to the host The counters are also reset after the mouse receives any command from the host other than the Resend FE command Next let s discuss the different mouse operation modes 12 2 3 Modes of Operation There are four standard modes of operation which dictate how the mouse reports data to the host they are RESET The mouse enters Reset mode at power up or after receiving the Reset FF command For this mode to occur both the DATA and CLOCK lines must be HIGH STREAMING This is the default mode after Reset finishes executing and is the mode in which most software uses the mouse If the host has previously set the mouse to Remote mode it may re enter Stream mode by sending the Set Stream Mode EA command to the mouse REMOTE Remote mode is useful in some situations and may be entered by sending the Set Remote Mode F0 command to the mouse WRAP This diagnostic mode is useful for testing the connection between the mouse and its host Wrap mode may be entered by sending the Set Wrap Mode EE command to the mouse To exit Wrap mode the host must issue the Reset FF command or Reset Wrap Mode EC command If the Reset FF command is received the mouse will enter Reset mode If the Reset Wrap Mode EC command is received the mouse will enter the mode it was in prior to Wrap mode RESET Mode The mouse enters Reset mode at power on or in
285. hey are relative positions not absolute Each time the mouse reads its inputs controlled internally by the microcontroller in the mouse it updates the state of the buttons and the delta s in the X Y counters If there is an overflow that is if the motion from the last update is so large it cant fit in the 9 bits of either counter then the overflow flag for that axis is set to let the host know there is a problem The parameter that determines the amount by which the movement counters are incremented decremented is the resolution The default resolution is 4 counts mm and the host may change that value using the Set Resolution E8 command Additionally the mouse hardware can do a scaling operation to the sent data itself to save the host the work The scaling parameter controls this By default the mouse uses 1 1 scaling which means that the reported motion is the same as the actual motion However the host may select 2 1 scaling by sending the Set Scaling 2 1 E7 command If 2 1 scaling is enabled the mouse applies the following mapping as shown in Table 12 5 the counters before sending their contents to the host in the data packet Table 12 5 Mouse scaling reported data mapping when in 2 1 mode Actual Movement Reported delta Movement _ So the scaling operation only takes affect when the actual movement delta is greater than 1 and for delta gt 5 the reported movement is always delta 2 Now let s look a
286. home backspace tab 8 spaces per set X position X set Y Md m UN set color color f return else prints the character to terminal f ol f ol ol ows ows ows TF ARAA HA em em AA lt gt gt lt gt n 2 qn gu uu n H d any gfx ntsc Out Term g data The yellow highlighted code is in the Default2 SPI message dispatcher as you can see this highlighted section catches all the graphics function calls messages and pipes them to yet another function call inside CHAM GFX DRV 001 TB 001 5 which is the actual graphics driver Now let s take a quick peek into that PUB GPU GFX Process Command g cmd g datal6 g spi result this function can be called with parameters to execute various commands to the register model of the GPU the SPI client running on the control COG with the virtual SPI interface will typically catch the GPU command and then pass it along here for efficient processing BEGIN REGISTER NTERFACE CASE HUA process command with proper handler case 9 cmd U GPU GFX SUBFUNC STATUS R Reads the status of the GPU OR Writes the GPU Sub Function register and issues a high level command like copy fill etc
287. ibc is a library hundreds of functions have been compiled into a single library file and that single file is linked against during builds with GNC GCC In our case we could have built an official library and put all the source modules into it but this would be tedious since it would hide what you are including in each project Thus have decided to keep the library in a source format as collection of C and H files so we can see what s going on include what we need and when we update one of the source files we don t have to rebuild the library we simply include the source file in the source tree with our main project file With that in mind there are a number of C and H files that make each up class of library functionality for the Chameleon API At this point we are going to drill down and list each of the files with a short description Then we are going to discuss the key data structures and header files for each library module list the functions one by one with examples 140 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Finally all source files can be found on the DVD at location DVD ROM CHAM PIC SOURCE Of course you should have already copied this to your hard drive into your project s working directory To save space we are not going to list the contents of each source file since that would take hundreds of pages however key elements will be listed for reference Noneth
288. iler for PIC24 MCUs Microchip provides a commercial and student versions of a GNU GCC compiler that has been adapted for the PIC24 16 Bit line of micro controller units MCUs Previous versions of the compiler were called the C30 compiler This compiler can be operated from a DOS prompt command line or it can be 80 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit integrated and called from MPLAB directly The student version is FREE with the following limitations first 60 days are fully featured after 60 days only optimization level 1 can be enabled in the compiler Currently the PIC24 C compiler is being ported to both Linux and Mac OS MPLAB IDE 8 xx and PIC24 C compiler are located on the DVD ROM at these locations DVD ROM CHAM PIC TOOLS PIC MPLAB_IDE_8_40 setup exe DVD ROM CHAM_PIC TOOLS PIC PICkit 2 v2 61 00 Setup A setup exe 15 1 1 Installing MPLAB IDE 8 xx Optional Installing MPLAB IDE is relatively straightforward as long as you know what you re doing to begin with This is the problem with many IDEs and installation programs you have to install the tool to figure out what not to do and then in many cases un install the tool then re install it To save you all this grief we are going to install the tool together step by step with a complete set of screen shots of each step along with explanations Thus without further ado let s get this done The first step is to locate and lau
289. inaries for various Linux Kernels and Mac OS X versions can be found at the following location http www microchip com stellent idcplg ldcService SS_GET_PAGE amp nodeld 1406 amp dDocName en023805 256 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The PKCMD2 is distributed in a compressed format tar gz for Linux and zip for Mac OS X Simply uncompress the file and located inside you will find the binary loader along with some supporting files There will also be a readme plain ASCII text file that you SHOULD read through to familiarize yourself with all the available command line options and installation procedures you want to use this loader from any folder on your system you should place the files into a folder that is pointed to by your PATH variable Otherwise another option is to manually copy the generated Intel Hex file created by the commandline compiler to the extracted PKCMDe folder The most common command line option for loading and verify the hex file can be seen below PKCMD2 P Fsomehex hex Y This command causes the PICkit2 to autodect the device being used and program the entire memory with a file named somehex hex and then verify the entire memory for correct loading Where the following arguments are P Autodetect the device being programmed Ffile hex When programming use the file named file hex M Program entire memory including configuration and program memory Y Verify
290. ince the HYDRA and Propeller development kits use slightly different pin connections for various devices but those are literally 1 2 line changes in your code The only thing you lose in Propeller stand alone mode is the use of the onboard FLASH since the Propeller can t get to it but the EEPROM for the Propeller is 64K 2x the amount needed for the boot image so that s a conciliation prize in the design if you need more assets Just make sure to keep the serial select switch in the UP position so the Propeller has access to the USB serial port 254 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Appendix Porting HYDRA and Parallax Development Board Applications to the Chameleon There really isn t much to say here other that porting from the HYDRA or Propeller Development board is usually a few lines of code that needs to be changed The things to watch out for are sure that you are using the same clocking and XTAL If the HYDRA Dev Board application you trying to port uses 10MHz XTAL and the 8x mode then make sure you change it to 5MHz and 16X mode in the source code port assignments The Chameleon s Propeller interfaces are almost the same as the HYDRA and Propeller Development boards but there are differences for example in what pin bank is used for the NTSC video or what pin for audio etc so when porting something make sure you look at the pinouts of
291. ine on top of these techniques to play music such as MIDI or MOD 78 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Part Il Programming Manual 15 0 Installing the Toolchains MPLAB TextPad and Propeller IDE The first step in developing applications for the Chameleon PIC is to install the tool chains and all their components Since the Chameleon PIC AVR is is NOT YET compatible with the Ardunio tool chain we are going to instead cover the installation of an alternative serial bootloader provided for us by Microchip In addition to the command line serial bootloader tools we will install a simple text editor that can be used as a replacement of the Microchip MPLAB IDE However for those who have a PICkit 2 programmer we will also cover the standard MPLAB tool chain installation as well as the PICkit 2 stand alone GUI Also the Chameleon s PIC is pre loaded with the Microchip bootloader in its flash memory So if you don t have a PICkit 2 programmer or you simply don t want to deal with MPLAB you can work with the bootloader toolchain and PIC24 C compiler alone However still recommend you skim the discussion of MPLAB since its a much more powerful tool than the command line tools Additionally the Chameleon has a Parallax Propeller chip on it so we have to install that tool as well so there is a lot to do We are going to show the installations of the tool in the following order MPLAB IDE PICkit
292. ing from bitmap graphics text modes to sprite engines So if you want graphics you just find a driver add it to your program and then make calls to it More on this later when we learn how to modify the Chameleon drivers at the end of the manual The Chameleon PIC has no operating system or external peripherals that need initialization thus the PIC24 more or less is the entire system When the PIC powers up out of reset it will either load the boot loader if there is one or begin execution from the primary application memory of the FLASH The initial configuration of the chip is defined by the configuration byte settings which are controlled by the programming of the chip In our case the config settings are mostly default with the clock set to an external high speed xtal We will discuss exact details when we get to the software and IDE configuration Once the PIC24 boots and starts executing code whatever is in the application program area is executed simple as that While this is all happening the Propeller chip boots as well and will start up doing whatever its programmed to do Normally this will be to load the default SPI driver system and wait for commands from the PIC However there is no reason the Propeller couldn t be programmed with a game or other application and ignore the commands on the agreed to SPI interface pins Therefore the Chameleon can be used as a standalone PIC or Propeller controller if you wish Howe
293. int of view The interface is a simple serial system with two lines DATA and CLOCK Both lines are open collector thus each end point typically can drive the line LOW but there is a pull up that pulls the line s HIGH Also PS 2 interfaces are 5V so when interfacing to a 3 3V system then some voltage translation must be performed Additionally we are interfacing the PS 2 port directly to the Propeller chip and since it s a 3 3V device care must be taken Figure 12 1 The Chameleon PIC keyboard and mouse interface hardware PS2 DATA T PS2 CLOCK gt Female Computer Side 6 PIN MINI DIN As noted above the keyboard and mouse are controlled via two bi directional data lines CLOCK and DATA To interface to the Propeller a pair of lines are all that is needed It would be nice if the serial protocol for keyboards and mice was identical to RS 232A then things would be a little easier and we could use one of the Propeller serial drivers but the hardware and protocol is slightly different so we have to use I O pins and write our own driver Or use one of the mouse keyboard drivers already written for the Propeller which is the tactic we use for the Chameleon More or less every single device interfaced uses a standard pre written driver and all we do is make calls to it from the PIC chip But it s nice to know how these things work so let s take a look Table 12 1 below lists the pins and map for the hardware inter
294. interrupt driven system with circular buffers on both the incoming and outgoing characters The System is easy to understand from a design perspective interrupts are setup to fire when both a character has been received and when a character has been transmitted These interrupts both call interrupt service routines ISRs that have been developed to support circular buffers These circular buffers allow the calling functions to place characters in the outgoing buffer and queued for transmission as well as for characters to fill up the receiving circular buffer until the caller wants to read characters The idea of this being the functions that transmit and receive characters do not have to wait they make two functions that interrogate the circular buffers and either insert or remove characters This way the system is responsive and only if the buffers are overflowed is data lost For example say you want to transmit the string Hello World Normally you would have to transmit the then wait e then wait etc But with interrupt driven architecture and the buffers the string is simply copied into the circular output buffer and the interrupt sends the string out for you The receiver is the same you can interrogate the circular buffer anytime you wish For example say that you know the transmitter on the other end is going to send a single string World is Fine back to you This string fits into the circular buffer so you
295. ions int GFX_Get_Tilemap_Width void Retrieves the width of the tilemap in encoded format int GFX Set Tilemap Width int width Sets the width of the tilemap in encoded format Top and bottom overscan control functions as int GFX_Get_Bottom_Overscan_Color void Retrieves the bottom overscan color int GFX_Get_Top_Overscan_Color void Retrieves the top overscan color int GFX_Set_Bottom_Overscan_Color int col Sets the bottom overscan color int GFX Set Top Overscan Oolor int col Sets the top overscan color The following lists each function a description comments and example usage of the function Function Prototype int GFX Fill Mem16 unsigned int dest ptr unsigned int value unsigned int num bytes Description GFX GPU Fill 16 fills a number of bytes using value to destination in the GPU memory space in WORD side chunks or in other words in the Prop s local memory of 32K you can use this to overwrite SPIN code so watch out The parameters are the destination address of the fill dest ptr the 16 bit data value and finally the number of bytes always a multiple of 2 num bytes Typically you will use this function to clear tile map bitmap memory and other repetitive operations that require the same value to be written Returns 1 186 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Example s Fill 100 WORDS starting at address 3456 wit
296. ique works perfectly Also notice that it takes only 100 cycles of the PWM clock to iterate thru one complete cycle of the sine table which makes sense as well In conclusion the software is where the magic is here The PWM audio circuitry couldn t be simpler as shown in Figure 14 5 Additionally you can synthesize multiple channels by simply having multiple phase accumulators and phase increments in fact to synthesize a 64 channel system you would just need something like int phase inc 64 phase acc 64 And you simply run a loop over everything and at sum up all the phase accumulators each cycle and use the sum as the index into the sine table Of course the sine table itself has to scaled in the amplitude axis and you must do a auto scale so that the sum doesn t overflow but you get the idea Moreover you can store other waveforms like square triangle sawtooth and so on and then mix various waveforms Finally you can easily overlay a ADSR attack decay sustain release envelope to a note based system and create just about anything The only downside to PWM is that it must be VERY accurate your ears are VERY sensitive to frequency shifts so the timing loops must be perfect thus a hardware timer or a tight loop needs to be used that doesn t vary otherwise you will hear it In conclusion that s a taste of what goes into generating sounds on the Propeller chip Then there is the whole other process of creating a sound eng
297. is currently under powered Explanations on how to use the PICkit 2 and the correct way to connect to the Chameleon PIC 16 bit are discussed in the programming section of this manual 32 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 4 2 The Chameleon ISP programming interface schematics 6 pin ISP Programming Interface RESn ISP_PGD ISP_PGC Auxiliary Table 4 1 PIC ISP signals ISP Pin Signal Name PIC24 Pin Connection on PIC24 Chameleon PIC c 3 3VCC N A Checks provides optional power from the PICkit 2 PGC Program Clock Auxiliary N A Not used Figure 4 2 shows the actual circuitry for the ISP interface As you can see its fairly straightforward Nothing more than the port header routed to the proper pins and a bypass cap on the power signals 33 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 5 0 Serial USB UART Programming Port The Propeller chip as well as the PIC can also be programmed via the serial USB UART The Propeller uses serial to communicate as default however the PIC uses serial only when there is a bootloader programmed into the PIC that listens to the serial port and there is a protocol in place as well as tool on the other end that follows the protocol agreement to re program the FLASH Therefore the native method to re program the Propeller is via the serial connection but the PIC is typically re programmed via the ISP po
298. is to add support on the client master side or write a program that sends the messages to the Propeller Rather than go into the SPI driver code header decided to just write a standalone program that blinks the LED started with the port blinking demo and then modified it to directly send the new messages Here s the entire program NCLUDES A include headers required for demo 1 CHAM PIC SYSTEM V010 h you need this one always include CHAM PIC 12C SPI DRV V010 h you need this al ways 1 CHAM PIC NTSC DRV V0IO h needed for NTSC driver DEFINES AND MACROS new commands for status LED control define STATUS LED ON 100 define STATUS LED OFF 101 RING IDIOT ARR ELEN ELLE AEE I 246 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit MAIN LE TH LLL ELE EH CHILE ee eo etre eee ELUCET ee TTT TET E ALT Meu EUN UA SM Gein nin SORE RE BANE RCAC a mai n voi d Always call ConfigureClock first SYS_ConfigureClock MAX FCY RATE Sp SPI Init 1 give Prop a moment before sending it commands the boot process is about a second if you like you can speed it up by the Prop driver s LED blink sequence in the driver or speed it up but commands that are sent before the Prop driver is done booting will be ignored therefore
299. is was created as a quick and dirty function during testing you might find it useful The first parameter is the device you want to print on DEVICE NTSC or DEVICE and the second parameter is the ASCIIZ string you want printed Returns the last byte received from the SPI transmission of all the commands Example s Print Hello World on both the NTSC and VGA monitors int String DEVICE NTSC Hello World SP Pron Pi SP Prop Print String DEVICE VGA Hello World Note in this case we are directly using the SPI command function to send commands to the Propeller so you don t need the NTSC API source files 20 0 NTSC Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media drivers all the API functions do including the NTSC is expose some of the base functionality in nice function calls so you don t have to send SPI messages yourself In the case of the enhanced NTSC driver CHAM_DEFAULT2_DRV_1
300. ister access requests right thru and tunnel them thru the SPI interface Now there are a lot of registers 37 to be exact currently but they are all more or less self explanatory if you read the comments To start we see a couple lines at the top advanced GFX commands for GFX tile engine define ID 192 I starting id for GFX commands to keep them away from normal command set define GPU GFX NUM COMMANDS 37 number of GFX commands These are important since they give the base offset for these commands 192 and there are 37 So from 192 to 192 37 1 we know are graphics commands Thus in the graphics driver it will get these messages since the SPI message dispatcher is looking for this range If we open up the Default2 driver we can see this as shown below now process command to determine what user is client is requested via spi link case g_cmd GFX CMD NULL GFX GPU TIL LLL EL LL rn A I NTSC GFX TILE SPECIFIC COMMANDS HAE we only expose a subset of the commands the driver supports you can add subtract more commands as desired some commands like PRINTCHAR for example internally support a number of sub commands that we don t need to expose at this level unless we want to add functionality GFX CMD NTSC PRI NTCHAR this command pipes right to the out function of the driver which supports the following sub commands already clear screen
301. ites current fine vertical scro register 0 7 define GPU GFX SCREEN WIDTH 204GPU GFX BASE 10 Reads screen width value 0 16 tiles 1 32 tiles 2 64 tiles etc define GPU GFX SCREEN WIDTH 214GPU GFX BASE 10 Writes screen width value 0 16 tiles 1 32 tiles 2 64 tiles etc define GFX SRC ADDR 22 GPU GFX BASE 10 Reads 16 bit source address for GPU operations define GPU GFX SRC ADDR W 23 6 _ GFX BASE 10 Writes 16 bit source address for GPU operations define GPU GFX DEST ADDR 244GPU GFX BASE 10 Reads 16 bi estination address for GPU operations 9 1 GPU GFX DEST ADDR W 25 GPU GFX BASE ID Writes 16 bit destination address for GPU operations define GFX NUM BYTES 26 GPU GFX BASE 10 Reads 16 bit number representing e number of bytes for a GPU operation Sub Function define GFX NUM BYTES 274GPU GFX BASE ID Writes 16 bit number representing e number of bytes for a GPU operation Sub Function define GFX DATA 284GPU GFX BASE 10 Reads 16 bi ata word uses for GPU operations or memory access operations define GPU GFX DATA 29 GPU GFX BASE 10 Writes 16 bit data word uses for GPU operations or memory access operations define GFX RAM PORT8_ 30 GPU GFX BASE 10 Reads 8 bit data pointed to by the currently addressed memory location in the GPU pointed to I by the src addr low hi Il After e operation e src addr ptr is incremented as per the GP
302. ive filter that consumes power based on a transistor or better yet simple Operational Amplifier Op Amp like the LM 741 Or better yet pick an 8 pole switched capacitor filter by National Tl or Linear Tech and the signal will hit a brick wall at the cutoff But for our purposes games simple music audio warnings sound effects etc a single pole passive filter will do fine if there is one thing know most people can t tell the difference between 16 bit 96 KHz sound and 8 bit 11 KHz so sound generation can be a little rough 14 1 3 2 PWM Setup Procedure As mentioned we will write some real code in the software section of this manual but just to get you thinking about it let s briefly digress a moment and work up an example with real numbers so you can see this all in your head Many of you are already sound experts and half of us have written MOD players and done DOS games for years so this is old news simple stuff but a couple of you may never have played with sound so this review can t hurt 74 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit So to PWM modulate a signal we encode the signal onto the PWM carrier by means of encoding the information or analog value of the signal onto the PWM carrier by modulating the period or the duty cycle of the fixed frequency PWM carrier This is a VERY important concept to understand the PWM frequency period NEVER changes only the duty cycle of any particul
303. ize number of bytes wi unction returns the length of the fi ecei ver oriented protoca nt buffer size standard XMODEM protocal as shown here modems xmodem ht m ge area of file along with the maximum size of the buffer untion WILL read the file and compute its length but only the be written to the file buffer le in bytes so when you want to receive a file from the PC start the on the PC end FIRST THEN run your xmodem download on this side The PC will wait a min or 2 g out but this funtion will immediately start sending NAKs and LU the sender to respond you to make this function more robust wrote it in about an hour information only prints t xmodem protocal defines e INIT 0 SEND 1 RECETVE PACKET 2 SEND ACK 3 EOT 4 acters used in xmodem pro 1 4 6 21 24 Ez 26 g output to NTSC screen MODEM i ff Ws ate running checksum xchecksum compu ialization state state machine NTSC currently tocal this is handy if you try to add more features to the function no output at all 1 display file data and file size 2 display 0 ch index ted xpacketnum xpacketnumn 234 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit case XSTATE_INIT Il initialize al DEBUG XMODEM gt 2 NTSC Term Print XSTATE_INIT NTSC Term Char 0x0D endi f reset bytes read counter etc xbytes_read 0
304. ktop computers actually fit underneath a desktop users would access a large mainframe computer via a terminal The terminal consisted of little more than a screen keyboard and a tiny amount of processing with no local storage Figure 18 2 shows an actual Digital Equipment Corporation DEC VT100 terminal Figure 18 2 DEC VT100 Terminal Characters where transmitted between the end user terminal to the mainframe over a serial line Most of the data that was sent back and forth was ASCII formatted character data However a problem arises with using ASCII as the transfer medium because ASCII characters are contained in a single byte that only represent 256 different possibilities Contained within the ASCII character set is the alphabet numbers and some simple control codes like backspace bell carriage return etc In order to transmit more advanced commands terminals and their mainframes needed more options to issue commands like Cursor position control Bold blinking and reverse text Screen Scrolling Erasing Screen or portions thereof Terminal reset commands Thus standards committees and companies implemented command codes that allowed the use of multiple bytes for describing a single command One of these standards that became incredibly popular was created by the Digital Equipment Corporation called the VT100 based on the ANS X 3 64 standard Because of its popularity many serial programs that you find today support a m
305. l ptr into the tile map termina eve rint functions use this pointer define GFX _ 84GPU GFX BASE 10 Reads 16 01 ile bitmaps ptr which points to the bitmaps indexed by the tilemap define GPU GFX 94GPU GFX BASE 10 Reads 16 bi ile bitmaps ptr which points to the bitmaps indexed by the tilemap define GFX PALETTE 10 GPU GFX BASE 1 Reads 16 bi alette array ptr which points to the palettes in use for the tilemap define GFX PALETTE W 114GPU GFX BASE 10 Writes 16 bi alette array ptr which points to the palettes in use for the tilemap define GFX TOP OVERSCAN COL R 124GPU GFX BASE 10 Reads top overscan color drawn on the screen 9 1 GPU GFX TOP OVERSCAN COL W 134GPU GFX BASE 10 Writes top overscan color drawn on the screen define GPU GFX BOT OVERSCAN COL R 144GPU GFX BASE ID Reads top overscan color drawn on the screen define GFX BOT OVERSCAN COL W 154GPU GFX BASE ID Writes top overscan color drawn on the screen define GFX HSCROLL FINE 164GPU GFX BASE 10 Reads current fine horizontal scroll register 0 7 NOTE NOT implemented yet 9 1 GFX HSCROLL FINE 174GPU GFX BASE 10 Writes current fine horizontal scroll register 0 7 NOTE NOT implemented yet define GPU GFX VSCROLL FINE 184GPU GFX BASE ID Reads current fine vertical scroll register 0 7 define GPU GFX VSCROLL FINE 194GPU GFX BASE ID Wr
306. l won t cut it 15 2 3 1 Installing a Serial Terminal Program The Chameleon PIC has a USB serial port that is used to communicate with the bootloader tool as well as the Propeller tool The Propeller tool has a simple built in serial communications but if you just want to send out serial data to and from the Chameleon you are going to need a good terminal program we suggest PuTTY Chameleon PIC 16 bit Mini USB cable PC Running Terminal Program eg PUTTY FlashProg Bootloader Tool Propeller Tool The PC can talk to either the Propeller chip onboard the Chameleon via the USB port OR the standard serial port on the PIC chip this is accomplished via a mechanical switch at the bottom of the board shown in Figure 15 53 below 114 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 53 The Serial port routing switch In the UP position it selects USB communication with the Propeller chip In the DOWN position it selects communication with the PIC chip At this point go ahead and make sure the serial select switch is in the DOWN position so the PC can talk to the PIC thru the USB serial port There are many serial terminal programs available HyperTerminal for example but we want you to use one that is very SIMPLE to setup and that works well with the Chameleon PIC we are going to use PUTTY From the DVD ROM install this program DVD ROM
307. lay the console output in one of its windows However you are free to use whatever text editor you like be it Notepad Eclipse VI Emacs etc The first step is to download the latest version of TextPad or install from the DVD ROM which was the latest at the time from here DVD ROM cham pic tools TextPad txpeng531 exe or download from http www textpad com The installation is a standard windows installation so will spare you the details here Once you have finished you have the option to launch TextPad Go ahead and launch TextPad and return here when finished so that we may setup some keyboard shortcuts and tools As we have mentioned previously we are going to be using TextPad to edit our main C programs and then have it call a DOS batch file to execute a number of commands that will ultimately end up programming the flash memory of our Chameleons Before we cover the contents of the batch file we will first configure TextPad to execute it TextPad has the ability to call external programs from its menu that a user can configure TextPad calls these external programs Tools To add a new tool to the menu you first need to pull up the preferences dialog Do this by clicking on the menu item lt Configure gt Preferences gt You will then be presented with dialog like that shown in Figure 15 49 Figure 15 49 The TextPad preferences dialog Preferences General File Editor View Use this form to add delete rename o
308. le Rate command Stream mode is the default mode of operation following reset REMOTE Mode In this mode the mouse reads its inputs and updates its counters flags at the current sample rate but it does not automatically send data packets when movement occurs rather the host must poll the mouse using the Read Data command Upon receiving this command the mouse sends back a single movement data packet and resets its movement counters WRAP Mode This is an echoing mode in which every byte received by the mouse is sent back to the host Even if the byte represents a valid command the mouse will not respond to that command it will only echo that byte back to the host There are two exceptions to this the Reset command and Reset Wrap Mode command this is obviously the only way to get the mouse back out of the Wrap mode The mouse treats these as valid commands and does not echo them back to the host Thus Wrap mode is a good diagnostic mode to test if a mouse is connected and if it s working 12 2 4 Sending Mouse Commands A mouse command similar to a keyboard command is sent using the standard 11 bit serial protocol outlined in the Keyboard Write section The commands supported are shown in Table 12 7 Table 12 7 Lists the set of command accepted by the standard PS 2 mouse Code Description FF Reset The mouse responds to this command with acknowledge FA then enters Reset Mode FE Resend The host can send this command
309. ler than the RC circuit discharges so the PWM modulated pulse train gets turned into a signal by an averaging process and looks like a stair step where you can see the averaging period superimposed on the signal Figure 14 5 b shows an example of this Here we see a PWM signal running at frequency f0 and a sine wave being synthesized at 1KHz before and after the averaging circuit We will get more into the programming of PWM when we discuss sound generation in the programming section of the manual But for now realize that the low pass filter LPF that the Chameleon PIC uses on the audio circuit acts as a LPF as well as an averaging circuit for PWM so it has two uses pretty cool 14 1 3 1 Selecting the Filtering Frequency Also there are a couple of concerns with the actual values of the LPF so that you don t get too much noise Noise is going to come from the PWM frequency itself For example say you use a PWM frequency of 1MHz then your filter obviously needs to cut this frequency out but it also needs to cut in at the highest frequency you plan to synthesis for example if you plan to have sounds all the way up to CD quality at 44KHz then you might set the 3dB point at 50KHz for example Also we are using an passive or inactive single pole filter You might want a sharper response in a more high end sound system like a 2 or 4 pole system You can achieve this by daisy chaining our little LPFs together OR you can use an act
310. ller we have saved bytes already It s still human readable but not as warm and fuzzy The entire RPC string is 11 bytes including NULL terminator But can we do better Sure if we encode in binary then we don t send the longer ASCII text we send the actual byte data Therefore the binary encoding would look like 133 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Byte 0 Byte 1 H e T o Where byte 0 and 1 would represent the NTSC and Print sub functions In this case the entire RPC call costs 7 bytes but isn t human readable anymore since byte 0 1 are in binary and could be anything depending on what we picked them to be The point is that if you were using another processor or process to make the RPC calls and not a human at a serial terminal then there is no reason to use ASCII coding However that said still prefer ASCII formats when they are feasible since they are much easier to read and debug At least sending things in ASCII format during the de bugging phase so you can at least look at your data strings on the other end and see what s going on 16 3 2 Compressing RPC for More Bandwidth The whole idea of RPC technology is to use it thus you might have a program running that makes 100 local calls with 100 RPC calls every time thru the main loop Thus you want the RPC transport process to be very quick hence compression of the RPC data and or caching is in order For example
311. lock MAX FCY RATE Configure clock for max 148 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Function Prototype void UART_puts const char buff Parameters buff A null terminated string Return None Description UART puts sends a null terminated string out of the UART If you are sending a constant string out of the UART UART puts is less resource and computational demanding than the alternative UART_printt Example s This example shows a simple usage scenario UART puts I m Sorry Dave Can t Do That Function Prototype int UART read unsigned char Data int Length Parameters Data A buffer to store data in It must be as large or larger than Length Length The amount of data to read Return Returns the actual amount of data read This could be less than Length depending on the available data Description UART read attempts to read from the UART driver s internal circular read buffer and stores the data into the passed in Data buffer This will read Length bytes if there is enough data available otherwise it returns the number of bytes actually read Example s This example shows a simple usage scenario unsigned char ReadBuf 5 Read the data in int NumberRead UART read ReadBuf 5 much data we read e read in d bytes r n NumberRead 149 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit
312. lock cycles Also there is a macro that is used to lock and unlock the IO remappable tables so that a user can configure which pins are connected to what peripherals Next are the defines and one very important definition is the processor speed 141 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Max chip specified instruction rate 40 MIPS define MAX FCY RATE 40000000L 1 Pin direction constants PICs use 0 for output 1 for input on TRIS registers define PIN DIR OUTPUT 0 define PIN DIR INPUT 1 The MAX_FCY_RATE is used by a number of libraries such as the UART init function to configure the baud rate scalars The other defines are useful for configuring pin directions using the PIC24 TRIS registers The chosen operating clock rate extern unsigned long g FCY generic input device data record type helps get back data from various multidata calls struct gid event type position data int buttons buttons bit encoded ii bite button bit3 left side button bit2 center scrollwheel button Hi ux ele button bitO left button gid event gid event ptr Included in this header is the definition of a generic input device data record that is used for reading the mouse state from the Propeller drivers Lastly so that the user can change the system frequency if he wishes during run time there is a variable shadow of the MAX FCY RA
313. ls These various modes of operation are logically called the SPI modes and are listed in Table 19 1 below Table 19 1 SPI clocking modes Mode Clock Polarity CPHA Clock Phase Mode Descriptions Mode 0 The clock is active when HIGH Data is read on the rising edge of the clock Data is written on the falling edge of the clock default mode for most SPI applications Mode 1 The clock is active when HIGH Data is read on the falling edge of the clock Data is written on the rising edge of the clock Mode 2 The clock is active when LOW Data is read on the rising edge of the clock Data is written on the falling edge of the clock Mode 3 The clock is active when LOW Data is read on the falling edge of the clock Data is written on the rising edge of the clock Note Most SPI slaves default to mode 0 so typically this mode is what is used to initiate communications with a SPI device 157 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 19 3 a SPI timing diagrams for clock phase polarity CPHA 0 SCK CPOL 1 SCK CPOL 0 Present bit Sample bit SPI signals when CPHA 0 Figure 19 3 b SPI timing diagrams for clock phase polarity CPHA 1 SCK CPOL 1 SCK CPOL 0 Present bit Sample bit SIM c SPI signals when CPHA 1 19 1 1 Basic SPI Communications Steps Figures
314. mand the Propeller to draw text on the screen Then you can print out your temperature information nicely on a little NTSC VGA monitor Moreover you can write some simple GUI controls so with the mouse or keyboard you could make command selections on the NTSC VGA screen Very slick As another example you can use the Chameleon s built in USB serial port to communicate to the PC So say you want to control some motors or do some A D but you want the PC to take that information and plug it into some larger application Normally to get something interfaced with the PC is nightmare in the era or post legacy devices where only USB connectors exist and there are no parallel or DB9 serial ports But with the Chameleon its easy you just write your driver code on the Chameleon use the serial UART library to communicate to the PC and send the information Moreover you can display status and what s going on thru one of the local video ports of the Chameleon so even if the PC is remote the local Chameleon can display what s going on and what its being told to do by the PC 14 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The possibilities are limitless with the Chameleon We wanted to take the work out of generating video audio reading keyboards and mice out of the picture for you but at the same time insulate you from what s going on under the hood unless you really want to know Next let s inventory your Chameleon PIC
315. may launch the programmer tool by clicking on the new PICkit 2 icon located on your desktop 88 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 16 2 programmer with update OS request left and normal display right PICkit 2 Programmer PICkit 2 Programmer Device Family Programmer Tools View Midrange Standard Configuration File Tools View Device Configuration Device Not Present Configuration User IDs 00 00 00 00 Device No Device Found Configuration 0000 User IDs FF FF FF FF Checksum 0000 DSCCAL 0000 BandGap 0000 Checksum 0 lt YDD PICkit 2 DD PICkit 2 50 Erase Blank Check Program Memory Program Memory Hex Only Source None Empty Erased Update Operating System 00000 PICkit 2 Operating System must be updated before it can be used with this software version Click OK to download a new Operating System EEPROM Data EEPROM Data PICkit 2 PICkit 2 Figure 15 16 right shows the main window for the PICkit 2 Programmer interface Depending on the version of the firmware running on the PICkit 2 debugger hardware the programming tool may ask you to update the Operating System on the device Figure 15 16 left Press the OK button to download it After a few seconds the new OS will be installed on the device and you may continue
316. me to time in this or any other jurisdiction whether foreign or domestic under patent law copyright law publicity rights law moral rights law trade secret law trademark law unfair competition law or other similar protections regardless of whether or not such rights or protections are registered or perfected the Intellectual Property Rights in the computer software and hardware together with any related documentation including design systems and user and other materials for use in connection with such computer software and hardware in this package collectively the Licensed Works ALL INTELLECTUAL PROPERTY RIGHTS IN AND TO THE LICENSED WORKS ARE AND SHALL REMAIN IN LICENSOR RESTRICTIONS a You are expressly prohibited from copying modifying merging selling leasing redistributing assigning or transferring in any matter Licensed Works or any portion thereof b You may make a single copy of software materials within the package or otherwise related to Licensed Works only as required for backup purposes c You are also expressly prohibited from reverse engineering decompiling translating disassembling deciphering decrypting or otherwise attempting to discover the source code of the Licensed Works as the Licensed Works contain proprietary material of Licensor You may not otherwise modify alter adapt port or merge the Licensed Works d You may not remove alter deface overprint or otherwise obscure Licensor patent
317. n Description Example s None None UART_BlockRead waits until a new character has been read from the UART and returns the character This example shows a simple usage scenario 154 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit headers and globals go here int main void unsigned char ReadVal ue unsigned char GuessNumber rand 10 code goes here ulation arScreen Cursor 0 0 UART puts Guess a number between 0 and 9 Whi e 1 Readvalue UART_BI ockRead UART_Newline ReadVal UART vtl100SetAttr VT100 REVERSE UART puts Correct Press key to try again UART vtl00SetAttr VT100 REVERSE OFF e ead and 10 arScreen Cursor 0 0 ess a number between 0 and 9 d e i u UART puts Wrong try Il end while 19 0 SPI and Library Module Primer The SPI and I C module consist of a single C source file and a number of functions for initialization transmission and reception The SPI module is one of the most important in the system since all communications with the Propeller chip are performed via the SPI hardware The API consists of the following files listed below CHAM_PIC_I2C_SPI_DRV_V010 c Main C file source for SPI and module CHAM PIC l2C SPI V010 h Header file for SPI and module Before we discuss the mo
318. n a PICkit 2 programmer then the decision is made for you you probably have to use the bootloader mode But if you do have the programmer or something else supported by MPLAB then you probably should work in the more robust MPALB since it allows debugging simulation etc But it s up to you just have fun 119 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 15 3 Installing the Parallax Propeller IDE Since each Chameleon PIC and AVR has dual processors consisting of a PIC and Parallax Propeller chip both chips need to be loaded with firmware To program the Parallax Propeller chip you need to install the Parallax IDE tool This tool is a very simply IDE that allows you edit programs for the Propeller chip and download them to the target The editor has no built in debugging which is really a result of the Propeller chip s lack of debugging internally in hardware However this isn t as bad as it seems You can use printf techniques as well as run debug like processes on other cores and have them interrogate memory locations in real time Finally it s pretty easy to test code change something recompile and download to the target since programs can only be up to 32K bytes in size The Propeller Chip IDE was developed by Parallax Inc to program their new multi core Propeller chip The Chameleon PIC and AVR uses a Propeller chip as the media processor thus to program the Propeller chip s EEP
319. n the future but the point is there is an R C network here Moving on there is also another AC coupling capacitor C14 10uF to the final RCA output The circuit has two sections and they each serve different purposes Refer to Figure 14 1 for the following explanation 69 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The signal Vin t comes in at the port and the low pass filter made up of R14 and C15 pass low frequencies but block high frequencies This is what s called a single pole RC filter The gain of the filter or the transfer function describes the relationship between the output and the input signal thus a signal with a gain of 1 at the output call it Vout t would be equal to the input with some possible phase variance but this is irrelevant for our discussion The single pole RC filter acts like a voltage divider but we have to use more complex math to describe it based on imaginary numbers and or differential equations This is a tough but there is a trick based on the Laplace Transform which transforms differential equations into algebraic equations called the S Domain then we can work with the circuit as if it were made of resistors then transform back when done This is all not that important but it s fun to know a little about analog stuff so let s continue So given all that we want to know what the voltage or signal is at the top of C15 Vout since this signal or voltage will then affec
320. nal Bit encoding Sync 00 0 0 0 0 0 0 Control Values Group Black 0 Dark Grey 0 Grey 0 Light Grey 0 Bright Grey 0 White 0 1 0 11 Grayscale Values Group 1 0 1 1 re 011 lt xxx lt 110 wh i e 3 lt xxx 56 e i e Purple Magenta Red Orange Brown Yellow Yell Grn Green Color Values Group Cyan WR 4 OO Ul CO I2 lt gt C amp Un C SUTIN gt O lt gt lt gt lt gt lt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt gt lt GJ QJ NJ I ors before and after NOT Colors without names are simp olor d ated 1 linear mixes of th NOTE 2 When
321. nch the MPLAB IDE 8 xx installer The file is located on the DVD here DVD ROM CHAM PIC TOOLS PIC MPLAB_IDE_8_40 setup exe At this point please launch the MPLAB IDE installation program You should see the initial splash screen as show in Figure 15 2 Figure 15 2 Initial splash screen for MPALB IDE 8 xx installer MPLAB Tools MPLAB Tools 8 15 Installation Welcome to the MPLAB Tools Installation Program It is strongly recommended that you follow these directions 1 Quit all applications before installing this product 2 Uninstall all previous MPLAB Tools 6 x versions 3 Disable any anti virus software running on the machine T Cancel 81 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 2 is the Welcome screen It is recommended to close all applications while installing and disable any anti virus software Click lt Next gt and the license agreement in Figure 15 3 will be displayed Figure 15 3 MPLAB IDE License Agreement MPLAB Tools MPLAB IDE License Agreement KX MICROCHIP IMPORTANT MICROCHIP IS WILLING TO LICENSE THE MPLAB IDE SOFTWARE AND ACCEPT THE TERMS OF THIS LICENSE CLICK I ACCEPT AND PROCEED WITH THE DOWNLOAD ORINSTALL IF YOU DO NOT ACCEPT THESE LICENSE TERMS CLICK IDO NOT ACCEPT AND DO NOT OPEN DOWNLOAD OR INSTALL THIS SOFTWARE MPLAB IDE LICENSE do not accept the terms of the license agreement lt Back
322. nction 11 buffer pointer to string storage where the raw ASCII fromthe UART is placed tokens an array of pointers where the function puts the tokenized strings OUTPUTS 11 returns the number of tokens TEEPE EET unsigned char c int cmd buff index 1 wo enter infinite while until valid string is entered hile 1 zo process next character d COS Wf UART_getchar amp 0 characters ge return ee uff cmd_buff_index 0 ommand to process _buff_index gt 0 process command l upcase the string to normalize tokens _strupr cmd buff string has been entered and tokenized now return number of tokens return cmd buff index p Pj eue ii empty string return lo break case 0x08 back space if cmd buff index gt 0 default otherwise normal character insert into command string and echo chort e s cmd buff index 11 end switch end if end while end Get String This function is a bit overkill since its designed to read in characters until a carriage return or a line feed character has been received It then returns the string to the calling function The bottom line is text parsing isn t as easy as you would think and when you have to write editors that run over terminal programs there are a lot of issues you need to resolve Summary Hopefully you have a good command of the serial
323. ncy is output via the lookup into the sine or waveform table Step 3 Continually add the Phase Increment to the Phase Accumulator and every cycle use the upper 8 bits of the Phase Accumulator as the index into the 256 element sine table Figure 14 7 Our final PWM setup Sine Table 256 Phase Accumulator constantly changing 4 b7 bO Bits b15 b8 used Phase Inc is added as 8 bit index to Phase Accumulator into lookup table 255 b15 bO Phase Inc constant value Now to recap we still have a table that has only 256 elements but we are going to pretend it has 65536 elements that is 256 256 to improve our accuracy this is nothing more than using a shift 8 and create a fixed point value in 8 8 format Next we are going to call out a couple vars to make the algorithm easy one is an accumulator called PHASE ACC that simply accumulates the current count then we convert it back to an integer by shifting it gt gt 8 times OR just using the upper 8 bits at the index into our 256 element sine table the latter is preferred Then we simply need the magic number 76 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit PHASE_INC that for a given PWM frequency 256 000 in this case and a desired output signal frequency along with a specific number of data table elements will make the whole thing work Here s the final math Given 1 Acomplete sine waveform has 655
324. nd it s not meant to infer there is a hidden GPU somewhere but rather than indicate that the hardware or driver is capable of doing large operations via a single command Two things that we do a lot of in computer graphics is copying data and moving data Copy move copy move copy move 90 of operations are copy move So one thing you want your GPU graphics engine software whatever to do is copy and move fast Thus one of the simple additions to the tile driver is the ability to copy and fill memory So added some sub functions that call GPU functions these are macro level functions that can fill and copy memory 8 16 bits at a time If you take a look at the listing above at the very top you will see the processing of GPU sub functions First we use the SPI command itself to identify a GPU function the register messages are GPU GFX SUBFUNC STATUS and 184 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit GPU GFX SUBFUNC STATUS W The or read message currently does nothing but the W or write message executes the GPU command which there are currently 4 of as shown in the header code below extract subfunction and data GPU GFX subfunc datal6 amp FF lower 8 bits defines sub function GPU GFX data g datal6 gt gt 8 upper 8 bits defines data for sub function case GPU GFX subfunc GPU GFX SUBFUNC COPYMEMI6 0
325. ne method of computing chords is to play 2 3 notes that are related to each other by adjacent notes from the base note There are formulas you can use to calculate these notes and simply experiment to see what sounds good dissonant resonant or just plain bad The program plays a number of chords in an increasing fashion then in decreasing Below is a copy of the increasing code so you can see the computation of the chord frequencies as well as the sound API calls to play the actual chord MSC Tarim iri ute Coi ing 0 ss NTSC Term Char 0x0D i I play the scale up for note 0 note NUM NOTES compute chord to mi 1 play these an octave above sprintf sbuffer Playing Chord d 9d d int chord freq 1 int chord freq 2 int chord freq 3 play the notes we have a freq limit of 2049 hz with the current API interface the driver do whatever you want though so you will have to create new messages and a 16 bit format if you want to play higher frequencies Sound Play 0 int chord freq 1 1 Sound Play 1 int chord freq 2 1 Sound Play 2 int chord freq 3 1 print on NTSC terminal screen NTSC_Term Print sbuffer NTSC Term Char 0x0D print on VGA terminal screen VGA Term Pri nt sbuffer VGA Term Char 0x0D slow things down a bit so we can read the text DELAY MS 500 219 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC
326. neric access commands mode ow you would access a general register based system remotely so good example 11 define REG CMD WRITE 56 performs a 32 bit write to the addressed register 0 F from the output register buffe define REG CMD READ 57 performs 32 bit read from the addressed register 0 F and stores in the input register buffe define REG CMD WRITE BYTE 58 write byte 0 3 of output register g reg out buffer byte 0 3 define REG CMD READ BYTE 59 read byte 0 3 of input register reg in buffer byte 0 3 11 system commands define SYS RESE 64 resets the prop UME ATOPIC EE EE AEE HE HH HIIEIEIEI commands are fairly straightforward and if there is anything that you want more detail on you can always open up the Propeller driver file s spin code and see exactly how the command is processed Remember all of these commands work in the same way they are sent over the SPI interface to a command dispatching loop on the Propeller a large case statement catches the commands and then sends it to the appropriate driver graphics sound keyboard etc So there are a lot of commands but each one is rather simple when you follow its complete path from the PIC to the Propeller to the media driver itself The next subset of commands are specific to the default2 driver and support the added graphics abilities of the tile map engine
327. ng command F5 N packets back while the host is trying to communicate with the mouse 65 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 12 2 5 Mouse Initialization During the mouse power up both the DATA and CLOCK lines must be pulled HIGH and or released tristated by the host The mouse will then run its power up self test or BAT and start sending the results to the host The host watches the CLOCK and DATA lines to determine when this transmission occurs and should look for the code AA ok followed by 00 mouse device ID However you can forgo this step if you like and just wait 1 2 seconds and assume the mouse was plugged in properly You do not have to respond to this code in other words If you wish to Reset the mouse you can at any time send the command code FF and the mouse should respond with a FA to acknowledge that everything went well Once the mouse sends the AA 00 startup codes then the mouse enters its standard default mode as explained in the sections above The only thing we need to do to get the mouse sending packets is to tell the mouse to start reporting movement This is done by sending the command Enable Data Reporting F4 the mouse responds with FA to acknowledge the command worked and then will start streaming out 3 byte movement packets at the default rate of 100 samples sec This step is necessary since on start up if the mouse simply started streaming data packets the host
328. ng you if you wish to play you can answer yes or no each has its consequences If you do decide to play then the computer selects a random number from 1 to 100 and asks you to guess it Just play along and see if you can guess Each guess you type in and hit lt RETURN gt 229 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Technical Overview This demo really shows off the UART and bi directional communications Not only are we printing to the UART for display on the terminal on the PC but we are getting input from the terminal and processing it so it s a very complete two way communications demo Also there are some animations and fun techniques that are used to display the logon logo and other effects to sell the game For example the intro logo is an array of data that is used to print out WarGames the title screen bitmap as a matrix of byte stored in FLASH for fun then to render we will convert to characters BLOCK and SPACE notice the use of const and PROGMEM also to access the array we must use read byte addr size of banner 52x5 const unsigned char title string flash yO hy S qos bs Qr qos qo e a Oy 15365 205 365 007005 26526 105 105 105 15 16 205 1b Op dE db do E500 305305 315 0 3 0 0 0 11 0 3 0 0 0 3 0 1 0 0 3 25 0 0 0 31 0 0 0 0 0 3 0 0 0 1 0 21 0 0 2 0 0 101 0 4 0 0 0 0 2 0
329. nitiates a new command I SP Prop Send Cmd int cmd int data int status t ng wait for previous command to complete while SPI Prop Send Cmd2 CMD NULL 0 0 amp Ox00ff0000 initiate the new command return SPI Prop Send Cmd2 cmd data status amp 0x0000f fff I end SPI Prop Send Cmd As you can see the SPI Prop Send function waits on a flag while calling a hidden function that actually does the work Let s talk about that for a moment In multiprocessor systems when one processor requests another processor to do something the whole point of multiprocessors is that the originating processor can continue to do more work in parallel Thus we need code to consider this such that say processor A the PIC sends a command to the processor B the Propeller Now processor goes about its business while processor B executes the command But the processor A finishes something and then requests processor B to do something else here is the problem Processor B can t perform another function until it completes the last requested command thus we need a mechanism that blocks processor A and 167 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit makes it wait for processor B when this set of conditions occur That s what the code above does So if processor A the PIC ask for too much too fast processor B the Propeller says hold on a minute let me finish the last thing
330. normal operation Next we are going to cover the installation of the PIC24 C compiler which is required for BOTH MPLAB operation and serial bootloader 15 1 3 Installing Microchip s MPLAB compiler for PIC24 MCUs The next component of the Chameleon PIC toolchain is Microchip s C compiler for PIC24 processors also known as the C30 compiler This compiler is required for both the MPLAB installation and the serial bootloader option We will be installing the student edition which has 60 days unlimited no restrictions use After 60 days you are limited to compiler optimizations level 1 and no procedural abstraction In most cases this will be just fine since most of the time consuming work is done for us by the Propeller Locate and run the C compiler installation executable at DVD ROM CHAM_PIC TOOLS PIC MPLABCPIC24StdEvalv3 20 B exe After the installation wizard begins you will see a dialog as shown in Figure 15 17 89 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 17 PIC24 compiler welcome screen 2 Welcome Welcome to MPLAB C Compiler for PIC24 MCUs Student Edition Setup program This program will install MPLAB C Compiler for PIC24 MCUs Student Edition on your computer It is strongly recommended that you exit all Windows programs before running this Setup Program Click Cancel to quit Setup and close any programs you have running Click Next to continue with th
331. nt of time to execute the actual instruction that turns black on Sync Tip The next part of the spec is the horizontal sync or this should be approximately 4 7 us therefore you would tell the video hardware to output a 0 0V for 4 7 us The next portion of the video signal is the Color Burst which consists of a pre burst phase called the Breezeway the burst itself called the Color Burst and finally the post burst called the Back Porch Breezeway This part of the spec says to output black for 0 6 us Color Burst This is the most complex part of the specification and the one that would be nearly impossible to do without the extra hardware support of the Propeller s VSU In any case we will explain how this works shortly but for now you need to know that you must generate 8 10 cycles of color burst tone This is 3 579594 MHz tone signal that the TV locks onto and uses as a phase reference for the remainder of the video line The color of each pixel is determined by the 54 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit phase difference from the color burst reference at the beginning of each line and the color burst tone of each pixel In any case 8 10 clocks must be sent usually send 9 10 cycles of color burst Each cycle at 3 579594 MHz takes 279 36 ns therefore if you want 10 cycles of color burst you must turn the color burst hardware on for 279 36 ns
332. nt then the parity odd parity and stop bit is sent then the host drives the DATA line Stop bit and releases the DATA line 12 1 4 Keyboard Commands Table 12 4 illustrates some of the commands one can send to a generic keyboard based on the 8042 keyboard controller originally in the IBM PC spec This table is not exhaustive and only a reference many keyboards don t follow the commands 10096 and or have other commands so be weary of the commands Table 12 4 Keyboard Commands Code Description ED Set Reset Mode Indicators keyboard responds with ACK then waits for a following option byte When the option byte is received the keyboard again ACK s and then sets the LED s accordingly Scanning is resumed if scanning was enabled If another command is received instead of the option byte high bit set on this command is terminated Hardware defaults to these indicators turned off 7 3 2 1 0 Keyboard Status Indicator Option Byte Scroll Lock indicator 0 off 1 Num Lock indicator O off 1 on o Caps Lock indicator 0 off 1 reserved must be zero EE Diagnostic Echo keyboard echoes the EE byte back to the system without an acknowledgement FO PS 2 Select Read Alternate Scan Code Sets instructs keyboard to use one of the three make break scan code sets Keyboard responds by clearing the output buffer typematic key and then transmits an ACK The system must follow up by sending an option
333. nter is always used for memory port operations read or write In the Propeller driver source ptr is the variable tile src addr parm and is set using GFX Set Src Ptr unsigned int src ptr defined below The idea of this function is that it provides a simple mechanism to access the Propeller s RAM Returns the 8 bit value read directly from the Propeller s 32K RAM This function also updates the source pointer automatically anticipating another read or write The actual code looks like update src pointer based on auto increment value tile src addr parm tile mem autoinc parm 190 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Thus the variable tile_mem_autoinc_parm is used as the memory increment stride each read write operation This comes in handy and reduces address updates when you access continuous memory There is of course a function to change tile_mem_autoinc_parm Example s Read the byte of memory currently pointed to by the source memory pointer data GFX Read Mem Port 8 Function Prototype int GFX_Write_Mem_Port8 unsigned int data Description GFX Write Mem 8 writes an 8 bit value to prop memory source ptr data note source pointer is always used for memory port operations read or write In the Propeller driver source ptr is the variable tile src addr parm and is set using GFX Set Src Ptr unsigned int src ptr defined below The idea of this function is that
334. o th And be one travel Thus the usual order of operations will be to boot the Chameleon with the FLASH demo then you might hit Option 2 to see what s in the FLASH s first 1K of memory Then you might decide to overwrite it with something so you go to your PC set up the X Modem download start the file transfer and the PC program will wait Then you go back to the Chameleon s local keyboard and press Option 1 then you will see a 3 second countdown and the program will start downloading as it downloads you will see the test stream across the screen Finally have created a few files for you to download with X Modem that have short famous poems all located in the Source directory here DVD ROM CHAM_PIC SOURCE The Road Not Taken by Robert Frost xmodem_test_file_road_not_taken txt O Captain My Captain by Walt Whitman xmodem test file o captain txt All the World s a Stage by William Shakespeare xmodem test file all the worlds stage txt They are better than using random TXT files or data files and if you are over 21 years old and haven t read these at least once in your life it s worth doing so they are very powerful and very true 240 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description FLASH memory demo that receives files via X Modem protocol Main Source File CHAM_PIC_FLASH_DEMO_01 c
335. o manually save your file before compiling which you may forget to do from time to time and instead it will recompile and download your last change causing you some grief potentially By following the recommend settings for the CompileDownload bat tool setup we have caused it so that whenever the tool is ran it selects the currently open file and uses that as the main file to compile This can have a negative side effect however when the user is modifying a different file perhaps a driver and then invokes the tool It most causes the C compiler will fail since it could not find the main function If you do not like this setup you can always modify the batch file or change the File parameter to a single file name so that it always selects the appropriate main file We are now finished with the Preferences dialog and you can click the OK button to close it If you now view the Tools menu in TextPad you will notice that at the bottom there is an item called External Tools and if you mouse over 111 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit that menu item a new popup menu will show the CompileDownload bat tool we have just created This is the first way you can invoke the tool by means of menu item selection The second way is to press the Citrl 1 keyboard shortcut For the advance user you can go back into the Preferences dialog and modify the Keyboard shortcut to your liking under the
336. o simple that we wrote the code right into the master control dispatch program object There is a complete listing of the code below excerpted from CHAM DEFAULT2 DRV 112 spin ff Propeller local pure specifie commends Jd 44 HD HL EHE OH EDHE HEAD AAAA AAAA AAAA these are handled locally in SPIN on the interface driver s COG PORT SETDIR sets the 8 bit I O pin directions for the port l output 0 i nput DIRA 7 0 g data PORT CMD READ reads the 8 bit port pins outputs are don t cares g spi result INA 7 0 amp FF data is now in PUMA TORU T client must perform a general READ CMD to get it back E writes the 8 bit port pins port pins set to input ignore data PORT gr WR OUTA 7 0 data As you can see there are 3 commands set direction read and write These are directly interfaced to SPIN native functions and port I O control The PIC side API is nothing more than 3 commands to set the direction read and write The name of the API file is CHAM_PIC_PROP_PORT_DRV_V010 c Contains the API functions for the Propeller local port functionality And once again this functionality is available in all versions of the main Propeller driver Default1 and 2 The Propeller Local Port module header CHAM PIC PROP PORT VO010 h has nothing in it but the prototypes for the API functions so nothing to show you there The API listing for the Propeller Local Port module CHAM PIC PR
337. o the same idea apply to either driver you load on the Propeller CHAM_DEFAULT1_DRV_112 SPIN or CHAM_DEFAULT2_DRV_112 SPIN The actual driver object used for the keyboard is keyboard_010 spin Basic PS 2 keyboard driver originally written by Parallax However only exposed a portion of its abilities thru the current SPI messages no need to waste messages You can always add more Therefore the abilities you see exposed in the following are just a taste of what it can do In other words if you need more functions that the driver supports then you will have to add messages to the SPI driver and add them yourself With that in mind if you want to use the keyboard driver then you need the following files added to your project CHAM PIC KEYBOARD DRV V010 c Main C file source for Keyboard module CHAM PIC KEYBOARD DRV VO010 h Header file for Keyboard module The Keyboard module header CHAM PIC KEYBOARD DRV VO10 h has no defines or globals itself since it literally nothing more than wrapper functions that call thru to the Propeller side driver But it s worthwhile to take a look at some of the constants the actual Spin ASM code keyboard driver KEYBOARD 010 There are two very large tables at the end of the driver that define the keys in terms of scan codes and ASCII codes The tables are too long to list but here s a excerpt from the first table Lookup table e scan extkey regkey keypa
338. oint in time The unit of measure for the amplitude is in terms of an IRE unit IRE is an arbitrary unit where 140 IRE 1Vp p or sometimes 1 4Vp p From the figure you can see that the voltage during the active video portion would yield a bright white picture for this horizontal scan line whereas the horizontal blanking portion would be displayed as black and therefore not seen on the screen Please refer back to Figure 11 3 4 for a pictorial explanation Some video systems NTSC only use something called setup which places reference black a point equal to 7 5 IRE or about 54mV above the blanking level Figure 11 6 a NTSC composite video waveform Timing and Level Standards of NTSC RS170A Waveform Front Porch 1 5 5 0 1pSec Blanking 10 9 0 2uSec Sync to Blanking End 9 4 1 r i Sync to Burst End 7 8 Sec 9 1 Ref White 100 IRE Breezeway Burst 2 5 714mV 4 Sync 4 7ySec 0 1pSec 40 IRE Ref Burst Amplitude Blanking Level Ref Sync Amplitude Figure 11 6 a depicts yet another timing drawing the NTSC video signal this time more formally labeled at the RS 170A color standard created in the early 1950 s as the successor to the B W only RS 170 standard created 1941 51 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 11 2 4 Colo
339. ollowing lists each function a description comments and example usage of the function Function Prototype int Sound Play int channel int frequency int duration 196 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Description Sound Play instructs the driver to play a single tone on one of the sound channels The parameters are channel 0 3 frequency 0 2000 Hz duration 0 7 seconds where 0 means to play forever Returns 1 Example s Instruct sound channel 0 to play 440hz for seconds Sound Play 0 440 3 Function Prototype int Sound_Stop int channel Description Sound Stopx stops the sound playing on channel channel Returns 1 Example s Stop all channels manually for ime cn Of cn ds Sound Stop ch Function Prototype int Sound StopAll void Description Sound StopAIl stops all sound channels and silences them Returns 1 Example s Stop all playing sounds Sound StopAll Function Prototype int Sound Update int channel int frequency int volume Description Sound Update allows you to update a sound channel 0 3 the fly without interrupting it You can modify channel s current frequency and volume Of course the parameters must be in range frequency 0 2000 and volume 0 255 where 0 means to leave as is Returns 1 Example s Start channel 0 at 100 Hz and sweep to 1
340. on version prints Hello World to screen Main Source File CHAM_PIC_VGA_PRINT_DEMO_01 C Additional Files Required CHAM_PIC_SYSTEM_V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC VGA DRV V010 c h General Requirements VGA port connected to VGA monitor Controls Required None Technical Overview The demo simply uses the VGA API to print Hello World on the screen When the printing reaches the bottom of the screen the terminal scrolls the screen image up one line The program is so short let s take a quick peek at only the contents of CETTE OA CECE EEE s mai n voi d ore way Eu oek Tigin SYS ConfigureClock FCY RATE I initialize SPI SPI Init 11 give Prop a moment before sending it commands the boot process is about a second AE o Mee NU RM m or speed it up but commands that are sent before the Prop driver is done booting will be ignored therefore if you have a lot of set up work to do then you don t require a delay but if you jump right into commands then you need good 1 5 2 second delay DELAY MS 2500 clear screens ClearScreen 213 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit
341. on VGA_Term_Print prints a NULL terminated string to the screen with automatic scrolling etc if the string prints off the right of the screen or bottom of terminal Returns 1 175 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Example s Print the string Hello World to screen VGA Term Print Hello Worl d Function Prototype int VGA Color int col Description VGA Color sets the color of the text and background depending on driver The col parameter should be from 0 7 and selects one of a number of different foreground background color schemes for the characters printed Returns 1 Example s Print the character X in all colors int index for index 0 index lt 8 index VGA Color index VGA Term Charl X II end for index 22 0 GFX Library Module Primer The basic premise of the Chameleon design is that it leverages drivers running on the Propeller chip to do all the media and graphics Thus whatever features the particular driver running on the Propeller side does is the only features we can access via the PIC side That doesn t mean we can t abstract functionality and add higher level functions that build on the sub functions however this probably isn t productive since you will want to change drivers re write the Propeller driver and so forth Thus for the majority of the media drivers all the API functions do including th
342. on later during the software installation phase Point is the moment you plug the Chameleon into the Windows PC plug and play is going to detect the new USB device of the serial UART built into the Chameleon so don t panic Step 1 Place your Chameleon PIC on a flat surface no carpet Static electricity Step 2 Make sure the power switch at the front is in the OFF position this is to the RIGHT Step 3 Plug your 9V DC wall adapter in and plug the 2 1mm connector into the bottom right power port on the Chameleon PIC If you do not have a power adapter then you can power the Chameleon PIC with the USB port Plug a USB mini B cable from your PC to your Chameleon PIC We suggest using a powered USB hub since the Chameleon will draw a lot of power Step 4 Insert the A V cable into the ORANGE video and WHITE audio port of the Chameleon PIC located top right of the board and then insert them into your NTSC Multi System TV s A V port 16 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Step 5 Plug a PS 2 compatible mouse into the PS 2 port on the Chameleon top right Step 6 Turn the power ON by sliding the ON OFF switch to the LEFT then hit the Reset button as well next to the PIC chip Step 7 The demo will start immediately it s a little block pushing game called Crate it Use the keyboard arrow keys to move your character and push blocks around and move them to their resting positions usually on the
343. onally if you inadvertently damage the FLASHed bootloader you will have to reload it Thus you need an PICkit 2 or similar programming hardware tool in the event you need to re FLASH the bootloader 1 2 Chameleon PIC Quick Start Demo Figure 1 3 The Console demo running Crate it Hit Enter www chameileon deu com www xgamestation com JT Cook Hiroyuki im The Chameleon PIC 16 bit is pre loaded with a demo programmed into the PIC s FLASH memory a screen shot is shown in Figure 1 3 that illustrates images of both the NTSC and VGA monitors during the demo We will use this to test your system out The following are a series of steps to try the demo out and make sure your hardware is working IMPORTANT First Things First Before we plug the Chameleon in and test it a couple things to pay attention to First the Chameleon can be powered by either a 9V DC adapter or draw power from the USB port connection If you have a 9V DC adapter then you can use it for power However to talk to the Chameleon you are going to need a mini B USB cable no matter what Therefore when we get to the power setup in Step 3 you can either plug in both the 9V adapter and the USB cable or just the USB cable If you plug in the USB port cable then the PC will detect a new USB device and if you have Windows SP 2 3 then it should install the drivers itself If it doesn t it s alright we will perform driver installati
344. one You are free to use the PIC as you wish and not worry about the Propeller chip However whatever driver that is on the Propeller will run and function independently even though you aren t sending it commands over the SPI channel Thus if you truly want to turn off the Propeller you might want to load a NULL program that does absolutely nothing such as CON These setti s are for 5 MHZ XTALS kmode xtall 16 enable external clock rand pl times 16 xinfreg 5 000 000 set frequency to 5 MH PUB Main repeat forever loop This will start up a single processor and just sit and do nothing Of course without the Propeller you have no access to the physical peripheral headers such as the A V headers VGA or the PS 2 header But you still have access to the USB serial port as well as the FLASH memory And of course all the headers connected to the PIC around the board you still have access to Just make sure to keep the serial select switch in the DOWN position so the PIC has access to the USB serial port Appendix Using the Propeller Stand Alone Mode The Propeller in standalone mode is much more interesting that the PIC The Propeller in standalone mode allows you to more or less run anything you would run on a HYDRA or Propeller Development kit still You have the VGA connector PS 2 A V connectors as well as 8 bit port for expansion You might have to do some porting of apps s
345. onstruction Generating each line is a little more tricky that generating a frame since the real work must be done on each line The basic idea is that you must generate the video signal which controls the luma brightness the chroma color and synchronization all within the same signal This is accomplished by mimicking the signals you see in Figures 11 5 and 11 6 Each line consists of a total of 63 5 us where 52 6 us is actual video data and the other 10 9 us is sync and setup data However you can slightly alter them if you wish For example if you want to make the video portion of a line 50 us rather than 52 6 us then it will work since you can just stuff black into non active region however the more you alter the spec especially in terms of the length of the sync and color burst the higher the chances are that the signal will not work on some older or newer sets such as LCD and plasma with digital filtering To generate the actual video signal the Propeller chip gives you total control over the actual output voltage of the composite video line therefore you program the voltages as a function of time to create each video line using the VSU video streaming unit For example each line consists of the following areas Front Porch The spec calls for a front porch of 1 5 us consisting of black therefore you would tell the Propeller hardware to send out black then you would delay for 1 5 us talking into consideration the amou
346. operation signed char Addr 0x01 Addr 2 Sa Wait till data is transmitted it 3 st 155 Wait until we have data save byte received 0 1 whi its ACKEN 1 1 Wait till ACK sequence is over Function Prototype void SPI Init void Parameters None Return None Description Init initializes the SPI peripheral hardware on the PIC24 with the following parameters SPI Polarity 0 SPI Phase 0 Master Enabled Prescalar FCY 16 2 75 Mbps Example s This example shows a simple usage scenario Include main sy 1 nclude CHAM PIC include CHAM 1 CHAM int main void Always call SYS ConfigureClo SYS ConfigureClock MAX FCY RATE Ck first after main begins E Configure clock 165 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit ize the SPI interface continue program bel ow It is important to remember that the SPI s built in CS line is not used to select anything Instead a pair of digital I O lines are used as SPI select selection bits and are multiplexed to select 1 of 4 devices named 0 3 The signals in the Chameleon design are on Port B define SPI CS0 PB14 define SPI CS1 15 To select device 0 3 you simply place 00 p 01 5 10 11 on these pins 11 3 selects the FLASH 10 2 selects the Propeller as destination The other two unused sele
347. opposite side of the screen You should see something like that shown in Figure 1 3 The actual program that is loaded into the PIC is located on your DVD here DVD ROM CHAM_PIC SOURCE DEMO CODERS CRATE_IT Of course it needs many other driver and system files to link with but we will get to this latter when we discuss the installation of MPLAB and the tool chain in general for C and ASM programming The demo took about a week to develop and was written by one of our Demo coder s JT Cook to see what he could do with the Chameleon in a week and rely 100 on our drivers The results are pretty amazing and the cool thing is the game literally was ported to the PIC version in a matter of minutes So as an extra bonus by leveraging the Propeller to do all media processing the AVR PIC processor running the applications or games is usually in pure C C and since the interface APIs to the Propeller are the same you get the exact same experience when you port an applications from the Chameleon AVR to PIC and vice versa Of course the PIC version is faster and has more memory but the AVR users like it that way a challenge Hit the Reset button over and over and the demo will reset and reload immediately If the system ever locks up rare and always due to bad code then simply hit Reset a few times or cycle the power This concludes the Quick Start demo Playing Crate It Crate it is your standard block pushing game whe
348. or define MOUSE CMD START 33 starts the mouse driver loads a COG with it etc define MOUSE CMD STO 34 stops the mouse driver unloads the COG its running on define MOUSE CMD PRESENT 35 1 determines if mouse is present and returns type of mouse general data read back commands define READ CMD 36 sound commands define SND CMD PLAYSOUNDFM 40 plays a sound on a channel with the sent frequency at 90 vol ume define SND CMD STOPSOUND 41 stops the sound of the sent channe define SND STOPALLSOUNDS 42 stops all channels define SND CMD SETFREQ 43 sets the frequency of a playing sound channe define SND CMD SETVOLUME 44 sets the volume of the playing sound channe define SND CMD RELEASESOUND 45 for sounds with infinite duration releases the sound and it enters the release portion of ADSR envelope 1l propeller local 8 bit port 1 0 commands define PORT SETDIR 48 sets the 8 bit 1 0 pin directions for the port 1zoutput 0 define PORT CMD READ 49 reads the 8 bit port pins outputs are don t cares define PORT CMD WRITE 50 writes the 8 bit port pins port pins set to input ignore data general register access commands Propeller registers for the SPI driver cog can be accessed ONLY TL dente e user can leverage the counters and even the video hardware if he wishes most users will only Il play with the counters and route outputs inputs to from the Propeller local port but these ge
349. or SPI Interface a gue Running main application as master Shared Memory all cores have access Virtual SPI Interface Handlers CORE 0 COG 0 This process starts first and then launches the ASM SPI driver on Core 1 Driver Layer Each object running on its own core scot puse To I O devices posses posee JE Messages passed to drivers Each object running on via sub function calls another core 16 2 1 Complete Data Flow from User to Driver Now that you have seen all the pieces of the puzzle from a hardware and software point of view let s review exactly how these pieces all fit together To begin with the Propeller is running a number of drivers on multiple cores NTSC graphics terminal VGA graphics terminal keyboard mouse driver and sound driver Each one of these drivers takes a single core Now by themselves they don t do much So the glue of the system is the MCP which is pure SPIN program that not only issues commands to the drivers but is the interface to the PIC via the virtual SPI drivers shared memory Thus the MCP runs on its own core controlling the media cores themselves as well as handing SPI input from the SPI driver itself which is written in ASM running on its own core With the system in this know state let s cover exactly what happens in each phase when the system boots Initialization After reset the MCP software simply loads ea
350. ore graphical you can Please refer to Figure 22 1 for the following paragraphs will assume you have some experience in tile mapped graphics and game programming for the following explanations Figure 22 1 GFX Architectural Overview Flow Diagram tilemap ptr Virtual Width 32 64 128 256 powers of 2 tM gt h Tile 0 0 Virtual Height d 24 Rows Ak 32 24 Tiles Each tile is composed Physical View 2 bytes The upper byte is the palette index l the lower byte is the 1 tile index i Palette Tile Index Index High Byte Low Byte M palettes ptr tile bitmap ptr PaletteO selects color Each bitmap is 8x8 pixels Color 0 00 Each pixel is 2 bits 1 01 Each 2 bit pattern refers to 2 10 a color in the palette for that 3 n Color oM oo Palette index from each tile 1 01 selects which palette to use 2 10 for 4 color set 3 11 Palette 2 Color 0 00 1 01 2 10 3 11 177 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The GFX NTSC tile engine is relatively simple as tiles engines go The single driver file contains both Spin and ASM language The driver file name is CHAM_GFX_DRV_001_TB_001 SPIN highly recommend you sit down and read it line by line if you want to understand how it works However it has 2 major parts to it the SPIN message dispatcher and the ASM code graphics driver
351. ot of set up work to do then you don t require a delay but if you jump right then you need a good 1 5 2 second delay sey r screens arScreen D c infinite loop draw next star ll set co VGA Color l position sta VGA SetXY rand VGA Term Pri nt m to cause scrol D draw our little ship at top set color to green with a little forcefield VGA Color 4 position at top of screen and draw with ASCII art VGA SetXY ship x ship y VGA Term Pri nt 4 gt add some logic here to move the shi p slow things down a bit DELAY MS 10 end while l end main This demo should bring back memories of BASIC programming on your C64 Atari 800 Apple if you ever did any text only games and had to resort to things like lt gt as your space ship Summary This demo shows that with a little creativity even the vanilla VGA terminal driver can be used for games 217 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 29 1 Sound Demos The following sound demo s illustrate how to make calls to the sound driver on the Chameleon running on the Propeller of course The output of the demo displays on both the NTSC and VGA monitors The examples typically consist of the primary source file for the demo as well as The System API library module CHAM_PIC_SYSTEM_V010 cjh The main SPI API library modul
352. outed to both the Propeller and PIC chips where they are interfaced to the appropriate I O pins Additionally at the top of the schematic you see the signal USB 5VOUT this is the power coming in from the USB port header this is routed to the system as 5V power when there is no external 9V supply plugged in However if you are going to use the Chameleon without a 9V power supply and power it from the USB port highly recommend you use a powered USB hub since the Chameleon will draw up to 200mA or more as it throttles its performance and powers up all its peripherals 35 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 7 0 Microchip PIC24 Subsystem Figure 7 1 The PIC24 Subsystem not including SPI mux 33vCC C18 10uF MCLRn 1 RBO RB1 RE2 RES RA2 RAS R54 RBS 2 XTAL2 22pF GNO Referring to Figure 7 1 you can see the schematic uses the PIC24HJ128GP502 The chip is very simple to interface just power and an external XTAL which is removable at 5 MHz We mentioned that the clock runs at 40 MHz so how can we possibly be using a 5 MHz XTAL The answer is that the PIC has an onboard Phase Locked Loop PLL that can multiply the incoming clock and increase the rate of execution Take note of the SPI interface lines on the right these are very important since they are used to communicate with the Propeller chip as well as the on board 1MB FLASH 36 2009 NURVE N
353. p My Suite Isn t Listed C Show all installed toolsuites There are many different compilers assemblers and linkers that can be used from within the MPLAB IDE Since we installed the PIC24 C compiler also known as the C30 compiler we will select that toolsuite here Near the top of the dialog there is a drop down list for the active tool set click the down arrow and select Microchip C30 Toolsuite as shown in Figure 15 30 Now click the Next button to continue onto the Project File location dialog Figure 15 31 New project location Project Wizard Step Three Create a new project or reconfigure the active project d _ In Figure 15 31 you will be choosing the new Project File location The project file does not need to be in the same location as all of the source files MPLAB is smart enough to compile files from outside its directory For now just choose a shallow location meaning don t use a lot of spaces strange symbols or many sub directories down for your project file 97 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit location You can either click the lt Browse gt button and choose your destination or type it into the field manually Now choose your new project file location directory and name your project Demo mocp and the click the Next button Figure 15 32 Create new directory message box Project Wizard The dir
354. peed shifting devices In any event let s talk about some preliminary materials before we begin You should review the data sheet on the PIC24 especially the USART and also the accompany section of the PIC24 Reference manual on the UART The data sheets and reference manual chapter is located here on the DVD DVD ROM CHAM DOCS DATASHEETS PIC24HJXXXXGPX06 08 10 pdf DVD ROM CHAM PIC DOCS DATASHEETS Section17 UART pdf Finally the UART and RS 232 API libraries are contained in the following files CHAM PIC UART VO010 c Main C file source for UART and RS 232 module CHAM PIC UART VO010 h Header file for UART and RS 232 module The UART library is relatively complex in as much as to save you a lot of grief trying to program the PIC UARTS we wanted to give you some ready to go software and API functionality so you could perform basic serial I O and have some fun To that end we developed a buffered interrupt driven UART communications system with some moderately powerful support functions to save you time Let s take some time to briefly discuss the overall architecture of the system so you know how it s all put together This will help understand how the API functions fit together and the data flow of the system 143 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 18 1 The system architecture of the UART driver UART Hardware Module Receive Transmi
355. piler documentation on your desktop Add Desktop icon for documentation Cancel If you are sharing a computer with another user who might also want to use MPLAB then select Install for all users option requires Administrator privileges as shown in Figure 15 22 Otherwise if you plan on working on the Chameleon PIC alone select Install for current user only You can also choose to add a desktop icon for the C compiler documentation by selecting the Add Desktop icon for documentation checkbox When you have finished making your selections click lt Next gt to take you to the final screen before the real copying and installing happens 92 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 23 Finally the beginning of the installation 53 Start Installation You are now ready to install MPLAB C Compiler for PIC24 MCUs Student Edition Press the Next button to begin the installation or the Back button to reenter the installation information We are now reading to begin installing as Figure 15 23 illustrates Now is your chance to go backwards and change any wrong options or press lt Next gt to being file copying Figure 15 24 PIC24 compiler installer progress bar Installing Copying file C Program Files Microchip MPLAB C30 bin sim30 exe m 8 Figure 15 24 displays the installer progress The install will not take very long and if you have any con
356. pixel is 2 bits therefore each tile bitmap row is a single 16 bit WORD and there are 8 WORDs that make up a tile Each 2 bit pixel represents 1 of 4 colors from the palette that is indexed from the tile entry s high byte So each tile has its own palette The tile engine is very optimized and thus needs the tile bitmaps in a specific format That is reversed So the 2 bit pixels are reversed when output that is the bitmaps you enter must be mirrored so that when displayed they are correct Normally bitmaps in tile engines might be left to right as they are on the screen but in this case the left most pixels will display on the right etc So keep that in mind when making your own tiles The tile bitmaps themselves are defined by the declaration _ tile bitmaps in the driver and you can change the pointer to them with the global tile bitmaps base ptr parm in the register interface However this is rare unless you want to point the tile bitmaps base ptr parm to another character set If you move the pointer only one bitmap in length then it would have the effect of shifting all the character so A would be B etc not very useful 179 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Palette Entry and Color Format The palette entries are very simple Each tile in the tile map character is actual 2 bytes as discussed above The low byte is the character which is a direct index into the character bitmaps and the
357. ple s Write 1234 to the 16 bit WORD of memory currently pointed to by the source memory pointer GFX Write Mem Port16 0x1234 Function Prototype unsigned int GFX Get Src Ptr void Description GFX Get Src Ptr retrieves the 16 bit source pointer in the tile GPU for memory transfer and fill operations This address is absolute in the Propeller s main RAM memory Returns the pointer Example s Retrieve the source pointer unsigned int src ptr ere pg e ORM Gee Su Function Prototype unsigned int GFX Get Dest Ptr void Description GFX Get Dest Ptr retrieves the 16 bit destination pointer in the GPU for memory transfer fill operations This address is absolute in the Propeller s main RAM memory Returns the pointer Example s Retrieve the destination pointer 192 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit unsigned int dest ptr dest ptr GFX Get Dest Ptr Function Prototype unsigned int GFX Set Src Ptr unsigned int src ptr Description GFX Set Src Ptr sets the 16 bit source pointer for tile GPU fill and memory operations This is an absolute address in Propeller RAM memory Returns 1 Example s Read the source pointer and add 4 to it and write it back rx Seu Sre Per GFX Get Sre WET a ays Function Prototype unsigned int GFX Set Dest Ptr unsigned int dest ptr Description GFX Set D
358. please send another if DEBUG XMODEM gt 2 NTSC Term Print XSTATE_SEND ACK NTSC Term Char 0x0D NTSC Term Pri nt S ACK NTSC Term Char 0x0D delay ms 100 K E packet was good endi f send and wai UART putc CHR delay ms 100 wait for a xstate XSTAT break packe ES RECEIVE PACKET Qu IN EE possible end of transmission if DEBUG XMODEM gt 2 NTSC Term Print XSTATE_EOT NTSC Term Char 0x0D NTSC Term Pri nt S NTSC Term Char 0x0D send wait for another EOT UART putc CHR NAK endi f wait for t while 1 UART getc if ch 1 ch CHR CTRLZ break end while m est fo ch if 236 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit final EOT send ACK finish UART_putc CHR_ACK if DEBUG XMODEM gt 2 NTSC Term Print S ACK NTSC Term Char 0x0D endi f exit state machine xstate_ running 0 I end if break default break end switch end while dif DEBUG XMODEM gt 1 sprintf sbuffer rDownload Complete r d Blocks rFile Size d r xbytes_read 128 xbytes_read NTSC Term Print sbuffer VGA Term Print sbuffer endi f return bytes read return xbytes read I end XModem Receive All that conditionally compilation code is to help you modify the function to add
359. port driver For messages run right on the main SPIN interpreter there is no need to add another processor 33 1 1 Adding SPIN Driver Support for the Status LED As we designed the Chameleon we added a status LED to it The idea of this LED was for the Propeller to use it to indicate status state etc For example when the Propeller boots our driver it blinks 3 times to indicate that everything is good to go and then the driver is ready to receive messages from the client master However after that we were all done designing everything and the drivers were written We left out messages to control the LED from the client master but I thought hmmm will hold off on this and later us it as the perfect example of adding some messages to do something useful Thus this example was born of that motivation With that in mind this is a good exercise since at first you will want to make small changes to the master driver but not re write it Anyway so the first thing you need to do is decide what new functionality you need In this case all needed was to control the LED turn it on and off So the first thing you need to do is copy the Propeller driver and re name it something else In this case made a copy of cham default2 drv 112 spin and renamed it to cham default2 drv 112 modified spin This way if mess something up can go back to my original Then reviewed the messages at the top of the code and found where new messages can go an
360. put to the internal clock operating circuit Shared with Port A pin 2 RA2 OSCO Output from the inverting Oscillator amplifier Shared with Port A VCC Main power 3V VCAP VDDCore CPU charge pump filter capacitor to sustain 2 5V to the CPU core VSS System ground AVDD AVDD is the supply voltage pin for the analog modules It should be externally connected to VCC even if the analog peripherals are not used AVSS Ground reference for analog modules The PIC24HJ is a 16 bit RISC like architecture chip with most instructions being a single program memory word 24 bits in size and only three instructions requiring two words The memory model is a Hardware Architecture meaning that the data and memory are located in separate memories that are not addressed as a contiguous space but rather as separate memories with different instructions to read write to them This allows faster execution since the same buses aren t used to access data and program space Therefore you will typically access SRAM as a continuous 8K of memory and program FLASH memory is in a completely different address space Additionally the PIC24HJ maps registers as well as all its I O ports in the SRAM memory space for ease of access Figure 1 6 show these memories Harvard as opposed to Von Neumann architecture are the two primary computer memory organizations used in modern processors Harvard was created at Harvard Universi
361. r e Propeller IDE 1 26 or greater The information herein will usually apply to newer versions but may not apply to older versions Please contact Nurve Networks LLC for any questions you may have Visit www xgamestation com amp www chameleon dev com for downloads support and access to the Chameleon user community and more For technical support sales general questions share feedback please contact Nurve Networks LLC at support nurve net nurve_help yahoo com 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Exploring the CHAMELEON PIC 16 Bit User Manual and Programming Guide LICENSING TERMS amp CONDITIONS iccisssiicncccicsecccssersnancisestecsetsarasannncnauentsanassuauanacsnducraseneranansneusnedsads 3 VERSION amp SUPPORT WEB SITE sscstvsissaiesaiaacaduaadudacsduccteauaccucacsdscccuecandvancsaucudsddaievencuadev ncwaacveecuadauenes 4 EXPLORING THE CHAMELEON PIC 16 BIT USER MANUAL AND PROGRAMMING GUIDE 5 0 0 INTRODUCTION AND 11 1 0 13 IBI asno seiss s nosene osoo 15 1 2 Chameleon PIC Quick Start DEMO ag Fo Fee 16 ER 16 Playing 17 1 3 The Microchip PIC2Z4HY Chiip c cccccsssssccssccessesssccecssscsccscssessesssssecssscn
362. r Encoding Color information is superimposed on top of the luma brightness signal and is a sine wave with the colors identified by a specific phase difference between it and the color burst reference phase at the beginning of each scanline This can be seen in Figure 11 6 b which shows a horizontal scan line of color bars Figure 11 6 b Composite Video Waveform of the Color Bars Amplitude gt Saturation amount of color Phase Difference gt Hue color The amplitude of the modulation is proportional to the amount of color or saturation and the phase information denotes the tint or hue of the color The horizontal blanking portion contains the horizontal synchronizing pulse sync pulse as well as the color reference color burst located just after the rising edge of the sync pulse called the back porch It is important to note here that the horizontal blanking portion of the signal is positioned in time such that it is not visible on the display screen 11 2 5 Putting it All Together Generating a NTSC or PAL signal means controlling the signal into the TV such that all the timing specifications are met There are a number of aspects that must be taken into consideration to achieve this successfully However one important detail is that the video signal does not have to be perfect that is the timings can be slightly off per line per frame per color burst etc nevertheless the amount of slack must be con
363. r change the order of the tools you want to appear on the Tools menu amp Document Classes Associated Files Backup To set the properties of a new tool Environment Variables click Apply then select it in the tree File Filters control Folders Keyboard Language Macros Spelling a 110 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit On the left hand side of the dialog is a tree view with a number of different items representing groups you can select At this time select Tools and the dialog will be updated with that shown in Figure 15 49 Next we need to add a tool do this by pressing the lt Add gt button and a popup menu will allow you to select a few different options Select lt Dos Command gt from the items and you will be requested for the name of this new tool Give this new tool the name CompileDownload bat and click the OK button A new tool will be added to the list however before you can edit the new tool s options you must first press the Apply button on the Preferences window Once the Apply button has been pressed you can expand the Tools tree view by clicking on the symbol next to the Tools and our new command will now have a subitem entry Go ahead and click on this new item called CompileDownload bat and your Preferences dialog will be updated to allow you to further edit the tool settings Figure 15 50 CompileDownload bat tool s
364. r download over the serial port The function assumes that the uploader is already running and waiting for the downloader the Chameleon to initiate the transfer This is a very important part of X Modem transfer protocol the uploader is started and it simply waits for the downloader to start requesting packets There is actually a timeout that it will give up in the minutes but usually the idea is you start the uploader and leave it THEN go run the downloader and it controls the flow of information or the rate of data reception Additionally the downloader checks each block of information against a sent checksum all of these is covered in the links above But briefly here s the packet format or block as they like to call it ASCII Control Codes 233 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit lt soh gt eot lt ack gt lt nak gt lt can gt Each block of the transfer looks like lt SOH gt lt bl gt lt 255 bl gt lt 128 data byte in S0H bl k 255 cksu which gt blk gt m gt 01 hex binary number starts at S cksum 01 increments by 1 and wraps OFFH to not to 01 blk after going thru 80 Formally this is the on the sum of the data bytes 80 instr es complement only Toss any carry Considering the block format outlined above the downloader needs to check the checksum against the
365. r if he doesn t want to On the other hand this setup is incredibly flexible The Propeller can run any set of drivers on it that we wish and thru an agreed on communications protocol the PIC can control these drivers remotely and get work done Finally when started designing the AVR version of the Chameleon a couple years ago kept hearing about this product called the Arduino finally went to the site and checked it out but was surprised that there was no Arduino per se The Arduino isn t a product so much as it s an ideal or methodology of software and tools There is nothing but a single AVR ATMega 168 328 on each Arduino board there is no extra hardware to do anything So looked deeper and found out the Arduino guys came to the same conclusion did about embedded system programming it s too hard The tool chains area nightmare installation has too many steps and it s just too complicated for newbies that just want to play with something So what they did was not concentrate on hardware but concentrate on software They took the AVR tool GNU GCC tool chain and covered it up with a Java application Therefore from your perspective as a programmer you don t need to know anything about AVRStudio GNU GCC WinAVR etc All you need to know is how to type in the Ardunio text editor and press a couple buttons Now programming AVRs and PICs is a challenge as well You normally 11 2009 NURVE NETWORKS LLC Exploring
366. r purposes we will let the Propeller driver deal with it All our API needs to do is call the driver over the SPI link get absolute relative position and the buttons simple The Mouse module header CHAM PIC MOUSE 010 actually has nothing in it once again I told you this stuff was easy However the mouse does use a data structure located in the global system file CHAM PIC SYSTEM V010 h the data structure is shown below generic input device data record type helps get back data from various multidata calls struct gid event type tion data ons bit encoded right side button left side button center scrollwheel button right button left button int NS int utt bit4 bit3 bit2 bitl bito gid event gid event ptr It s nice to think of input devices in all the same way and thus wrap a container around them This data structure was created with that in mind for future expansion So all mouse messages use this container The first ints are the position the 3 Z is usually the scrub wheel The next int buttons is a bit encoded representation of all the buttons on the mouse up to 5 different standard buttons The API listing for the Mouse module CHAM_PIC_MOUSE_DRV_V010 c is listed in Table 25 1 categorized by functionality Table 25 1 Mouse module API functions listing Function Name Description Mouse Driver Control erc ee E
367. r you Its best however to read up on the I2C registers provided by the PIC peripheral and use the registers explicitly since they are so application specific Table 19 2 below lists the SPI and I C API functions categorized by functionality Table 19 2 SPI and module API functions listing Function Name Description E 12 related functions void I2C_Init unsigned long ClockHz Initializes the 12 hardware void I2C_WaitTillldle Pauses execution until an Idle state is found 163 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit a Re SPI related functions aa ENED En M NE int SPI Init void Initializes the primary SPI unit connected to Propeller void SPI Write unsigned char Data8 Writes a byte to the SPI interface unsigned char SPI Read unsigned char Success Reads a byte from the SPI interface unsigned char SPI WriteRead unsigned char Data8 Writes and reads a byte to from the SPI interface SPI command function to communicate with Propeller CONG long SPI Prop Send cmd int data int status Sends a 3 byte command packet to Propeller int SPI Prop Print String int device char string Legacy function use terminal NTSC VGA driver to print strings on the display The following lists each function a description comments and example usage of the function Function Prototype void I2C
368. rammers prefer a hex file which is an ASCII readable file that contains hexadecimal address and values hex codes more suitable for many different programmers Thus we use the command pic30 bin2hex exe program cof to convert program cof to program exe Finally the hex file can be transmitted and saved to the PIC device with the FlashProg exe using this command 112 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit FlashProg exe i 2 program hex Remember that 2 takes the second argument we pass to it which if you remember is our communications port in the format COMX e g 5 This batch file is merely meant as a convince utility You could type everything out into a DOS terminal but then it is prone to mistakes and takes longer In the future I m sure somebody will write a GUI based tool that does the same or port the PIC bootloader to the Arduino toolset The astute reader will notice that we compile all the code every single time the batch file executes Normally a user would use a program like the Unix make which compares timestamps and only compiles files that are newer However a simple trick would be to remove or comment out the lines in the files that you know do not need to be compiled over and over For example if you are not planning on changing the device files you add the following to each of those lines REM pic30 gcc exe mcpu 24HJ128GP502 x c c CHAM_PIC_I2C_SPI_DRV_V010 c
369. re 1 6 the program memory is divided into regions as you can see most of them are pretty self explanatory The first 512 locations provide reset and interrupt vectors There is no moving these around since they are hardwired in The next section is the User Program Memory that provides 43 776 minus reset and interrupt vectors of single word instructions for your usage Since the program counter is 24 bits wide we have a lot of extra space that is mostly filled with O s or reserved sections that map to nothing Possibly as more variants of the PIC24s come out they could be filled with more space for user programs Our Data SRAM memory is segmented as illustrated in Figure 1 6 One thing that can be gleamed from the figure is that the PIC24 is using a little endian memory style Just like the program memory we don t have free reign of the entire memory space and certain sections of RAM will always map to special registers The first section is the SFR region The SFR acronym stands for the Special Function Registers This includes things like I O Port control and latch registers SPI configuration registers etc The PIC C compiler is based on the GNU GCC tool chain and thus is not the best optimizing compiler on the planet but isn t bad Hence our approach will be to use C primarily for our coding and any time critical performance code you will want to write in assembly language if you need to But we want to rely on C as much as possible for ease o
370. re 28 5 shows the demo in action Figure 28 5 Dual NTSC VGA terminal printing demo llo 1 Hello World o World Hello World 1 Hello World rid Hello World d Hello World Hello World Hello Wor Hello World Hello World ello 1 Hello World lo World Hello World World Hello World He orld Hello World Hello Hello World Hello Hello World Hello Wo Hello World Hello World ello World Hel 1 6750 Ld 27 a oF 7 on 6 b x Lo D m 5957 PP cL nb O oO 0 MO m 4750 O sgor Ti at 4750 TU ar a eh ne ar a HO 9 zorr 2 GT7EZOMI Oo Q wf GTEZOMI a3 E Lb HO 0 O mA 7 0 arom wO H Dl 0 bx Lar M 57 57 2 x 57 H ei 10 R or id w0 EP mO HD n MU 17ro r O Lb xL O mO m ron HO HA wO wA 5 mA f 0 eb Lt aro m0 O HD Li E A 25 I I 0 2 Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Prints Hello World to both NTSC and VGA displays Main Source File CHAM_PIC_NTSC_VGA_PRINT_DEMO_01 C Additional Files Required CHAM
371. re you want to get the objects blocks from one side of the screen to resting positions on the other side The problem is that if a block hits up against an immovable object they can get stuck and you are out of luck These types of games are very easy to develop but hard to play You have to really think about what order you move blocks and you have to be wary about getting stuck This version requires an NTSC monitor and the local PS 2 keyboard plugged in Also make sure to have the audio port connected to your TV there is sound To play simply move the character with the arrow keys and push the blocks around The first level has the blocks on the left side and their resting positions on the right side so you have to push the moveable blocks from the left side to the right side without getting stuck or putting yourself in a corner The first level has 6 blocks that must be moved This concludes the Quick Start demo 17 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 1 4 The Microchip PIC24HJ packing for 28 Pin SDIP and SOIC packages 28 Pin SDIP SOIC MCLR 1 28 ANO VREF CN2 RAO 2 27 AVss AN 1 VREF CN3 RA1 ANS RP15 CN11 PMCS1 RB15 PGD1 EMUD1 AN2 C2IN RPO CNA RBO 4 25 ANTO RTCC RP14 CN 12 PMWR RB14 PGC1 EMUC1 AN3 C2IN RP1U CNS RB1 5 24 ANTI RP13U CN13 PMRD RB13 ANAICTIN RP2UI CNG RB2 6 23 AN12 RP12U CN14 PMDO RB12
372. received data and can request a packet be resent if it s not correct Also if packets are late etc the downloader can time out and the downloader can simply stop the transfer if it wishes thus the protocol is receiver driven Please review the web links above to get a better handle on this protocol Now the implementation we made was quick and dirty no checksum checking no timeouts etc it simply hopes that nothing goes wrong On the other hand it s very easy to add things to the function to make it more robust we purposely wrote it this way so that you could understand the function and add to it if you wanted Implementing the complete X Modem protocol with all error handling cases makes the code look like spaghetti With that in mind here s the function itself that does the downloading int XModem Receive char file buffer i mcum E EN EE EE ra ver AE EE not a CONT es 5 n SHE gt oOo SH gt oO gt oO SSS SS GS de l con sdefin defin defin defin defin defin I con defin everyt int xs unsi gn Sica xstate xstate k r Qm sion imin dn i ns mi s Ore ti eave e debug tate xst ed char x re GUI Qi XSTATE running in x mode xstate e from an xmodem sender ki pedi org wi ki XMODEM echheap com communi cati on es a pointer to the stora exceeds the buffer the f S
373. ree main components of the tool chain for the Chameleon PIC in general they are MPLAB 8 xx PICkit 2 sold separately MPLAB C compiler for PIC24 MCUs MPLAB IDE This is Microchip s free integrated toolset for developing software for their entire line of PIC and dsPIC microcontrollers MPLAB supports compilers debuggers programmers simulators basically everything you need to develop embedded applications Most of the support comes through plug ins that can be added to MPLAB Microchip s and or 3 party plug ins are supported The default MPLAB installation does not include a C compiler for the PIC24 processors however we will install a C compiler after the MPLAB installation that integrates into MPLAB PICkit 2 This is the actual hardware programmer that is recommended for the Chameleon PIC 16 Bit The programmer supports both programming and debugging and is low cost and very versatile The programmer must be installed as well and its firmware potentially updated This installation will be done after the other tools are installed so MPLAB IDE 8 xx specifically can update any drivers needed for the tool One thing you may notice is that the PICkit 2 hardware contains a female header and there are no male headers on the Chameleon PIC We decided to keep only female headers on the board and you use a 6 pin right angle male connector to attach the PICkit 2 to the Chameleon This will be explained with pictures shortly MPLAB C comp
374. response to the Reset FF command After entering reset mode the mouse performs a diagnostic self test referred to as BAT Basic Assurance Test and sets the following default values Sample Rate 100 samples sec Resolution 4 counts mm Scaling 1 1 Data Reporting Disabled After Reset the mouse sends a BAT completion code of either AA BAT successful or FC Error The host s response to a completion code other than AA is undefined Following the BAT completion code of AA ok or FC error the mouse sends its device ID of 00 This distinguishes the standard PS 2 mouse from a keyboard or a mouse in an extended mode After the mouse has sent its device ID of 00 to the host it will enter Stream mode Note that one of the default values set by the mouse is Data Reporting Disabled This means the mouse will not issue any movement data packets until it receives the Enable Data Reporting command The various modes of operation for the mouse are 63 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit STREAM Mode stream mode the mouse sends movement data when it detects movement or a change in state of one or more mouse buttons The rate at which this data reporting occurs is the sample rate defaults to 100 samples sec on Reset This parameter can range from 10 to 200 samples sec on most drivers The default sample rate value is 100 samples sec but the host may change that value by using the Set Samp
375. rints a single character to the NTSC terminal all drivers Default1 2 etc also supports translation commands supported by the NTSC terminals 11 00 clear screen 01 home 11 08 backspace 1 09 tab 8 spaces I 0A set X position X follows 11 0B set Y Y follows 11 0 set color color follows 11 00 return other characters not translated but simply printed to the termina SPI Prop Send Cmd GFX NTSC PRINTCHAR ch 0x00 wait a bit driver takes time to respond DEALAY US SPI PROP DELAY SHORT US return success return 1 end NTSC Term Char As you can see other than comments the functionality of the two methods is identical So the point is these API functions are very thin wrapper functions that more or less give function names to the commands and make them pretty Use them if you wish However once you have a really nice Propeller driver written you will definitely want to create more advanced API layers on the PIC side so you can write high level code But in this case most of the functions are 1 1 with the equivalent SPI Prop Send code However in some cases the API functions are nice if you want to do a set of operations with a single function call and that s what APIs are all about The NTSC API module header CHAM PIC VO010 h has no globals or defines as of yet nothing more than the function prototypes
376. river uses a high performance tile engine that we developed that supports scrolling 4 colors per tile large playfields and a lot of more One of its simple features is the ability to control the top and bottom over scan colors on the screen This demo simply cycles thru those colors and shows you how to make calls to update the overscan color registers in the tile engine running on the Propeller chip Figure 28 2 shows the demo in action Figure 28 2 NTSC overscan color animation program demo Cyitone Base Star to Gutpost Message Destroy Destroy Destroy BY YOUR COMMAND Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description NTSC version prints animates overscan colors Main Source File CHAM_PIC_NTSC_GLOW_DEMO_01 C Additional Files Required 209 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit CHAM PIC SYSTEM V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC NTSC DRV V010 c h CHAM PIC GFX DRV VO010 c h General Requirements Video port connected to NTSC TV monitor Controls Required None Technical Overview The demo simply uses the NTSC GFX to animate the top and bottom overscan colors this is only supported with the default2 version of the driver and the NTSC system Below is an excerpt of the code from the main while loop that performs the animation i o infinite loop glowing the top and bottom overscan tile engine functions req
377. roll register 0 7 The tile maps tile bitmaps and palettes are all in memory and can be access by reading their base address memory locations and then writing memory This is done via the register interface which we will discuss in a moment Finally you can control the top and bottom overscan color of the NTSC screen with a 8 bit register for each That s about all there is to it but this tile engine is more than enough to write 90 of the games from the 90 s on 8 16 bit machines 22 1 1 GFX Driver Register Interface Before jumping into the header file contents overview want to re enforce that all communications to the GFX driver are thru a set of virtual registers These registers can be read written in most cases and each register usually has a bit of code that executes the read write and does what needs to be done to any low level variables or data structures in the ASM video driver itself Thus much of the functionality of the register interface isn t directly built into the driver but created via code the driver and other added elements to give the user an interface that is more robust 181 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Since the GFX driver is a special case want to re enforce that its worth reviewing the Propeller side driver as well so you can see what s really going on We are only going to cover the C PIC side of things here but all these registers functions API etc
378. rom the output register buffer a 32 bit ou REG READ performs read fromthe addressed register 0 F and stores in the input register buffer REG_CMD_WRITE_BYTE 58 write byte 0 3 of output register g reg out buffer byte 0 3 REG CMD READ BYTE 59 read byte 0 3 of input register reg in buffer byte 0 3 system commands SV RESET 64 resets the prop EEE this range of commands for future expansion EC VASTE RC PUR P TOP PU I CRUENTIS SITE RSS T ETHER advanced GFX commands it r GFX tile engine GPU GFX BASE ID 192 starting id for GFX commands to keep them away from normal command set GPU GFX NUM COMMANDS 31 number of GFX commands GFX SUBFUNC STATUS R O 4GPU GFX BASE 10 Reads the status of the GPU Writes the GPU Sub Function register and issues high level command like copy fill etc GPU GFX SUBFUNC STATUS W 14GPU GFX BASE ID Writes of the GPU Writes the GPU Sub Function register and issues high level command like Copy ete have highlighted the two new message id s That s all there is to it The selection of 100 101 are a bit random could have used 65 66 or could have used a single id and then used one of the data bytes to control on off But thought this would be a little more illustrative Now that we have the message ids we need to process the messages and do som
379. rring to Table 14 2 we see that each cycle of the PWM the _ is incremented by 1 and the next element in the 256 element sine table is accessed thus the table is cycled thru at a rate of 256 000 256 1 000 Hz Perfect Now let s try another example where the frequency is higher than what we could sustain with our more crude approach at the beginning of the section with only a counter and not using the accumulator and fixed point approach Let s try to synthesize a 2550 Hz signal PHASE_INC 65536 2550 256 000 652 8 Now this is a decimal number which will be truncated during the fixed point math to 652 but this is fine that s only an error or 77 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Truncation error 100 0 8 652 8 0 12 think can live with that Table 14 3 shows the results of the synthesis algorithm running once again Table 14 3 Test of PWM algorithm at 2500 Hz with PHASE INC of 652 Iteration PHASE INC PHASE ACC PHASE ACC upper 8 bits o 652 652 652 652 1304 652 1956 7 652 2608 10 652 3260 12 652 3912 15 4564 17 7 652 5 100 te 652 650 gt As you can see in this case each cycle the sine table is accessed by skipping an entry or two causing a bit of distortion but since the table has 256 entries the amount of distortion is 1 296 at most so once again we see that the techn
380. rt thus the serial re programming is a trick hack that is simply supported by a bootloader that supports it With that in mind the next section covers the USB UART design but before we take a look at that there is one sub section of the design we need to look at and that s the serial port routing switch shown in Figure 5 1 Figure 5 1 Serial port routing selector switch Serial Transmitter Selector SW3 TX Selector TINTS USB PIC RXD USB PROP RXD USB RXD The USB UART has a standard TX RX serial line pair But there are two targets we need these to go to the Propeller chip and the PIC thus we just can t connect them in parallel since if both the Propeller and PIC try to transmit at the same time then there will obviously be a problem Moreover the impedance reflected by tying the TX RX to both devices is not desired Thus a mechanical switch SW3 is used to switch the RX lines which at very least are needed to allow both devices to share the serial port Therefore when you want to talk to the Propeller chip via the USB serial port you must place the switch into the Propeller mode UP and similarly when you want to talk to the PIC you must put the switch into the PIC mode DOWN 34 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 6 0 USB Serial UART Figure 6 1 The FTDI USB to Serial UART USB_5VOUT USB Interface System lt T gt usB TXD lt gt Use RXD U6 H1 FTDI FT2
381. s are tile graphics only and support text printing scrolling and crude control of color The default2 driver series adds some functionality with a gaming tile engine that supports fine vertical scrolling control of overscan colors large playfield tilemaps re definable character bitmaps 4 colors per tile and many other cool features Sound This library interfaces to the Propeller sound driver object and exposes limited capabilities of the driver itself which can do a lot more The API gives you a few functions to play sounds control volume etc But you will probably want to enhance this API Keyboard Mouse There is a PS 2 port on the Chameleon which is connected to the Propeller The default driver on the Propeller has drivers for both keyboard and mouse support Thus we have developed a simple API to communicate to both the keyboard and mouse driver running on the Propeller one at a time of course UART The PIC24 processor comes with two hardware UART s but we have developed a library of functions that abstracts the functionality so you can perform buffered I O very easily with interrupt driven drivers SPI The PIC24 has built in Serial Peripheral Interface hardware as well but there is quite a bit to set it up and communicate with it thus we have created a nice abstraction layer to initialize it read and write bytes The PIC24 again has built in hardware for Inter Integrated Circuit communications but the
382. s more of a concept methodology than a specific algorithm For example in some setups the RPC call mimics the actual binary foot print of the function call Assuming the C C programming language here s a solid example float DotProduct float ux float uy float uz float vx float vy float vz Looking at this function depending on the compiler directives the parameters are passed by value on the stack right to left so there are 6 floats each 4 bytes let s assume Also there is a return value another 4 byte float thus we need to pack the parameters up into a single record and pass it along and then wait for a single float 4 byte result 132 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit So we might do something like this to pack the parameters up into a contiguous memory space this is used as transport buffer for RPC calls CHAR input buff 256 now pack the params into the array one at a time memcpy input buffsz4 Qux sizeof float memcpy input buff z4 Quy sizeof float memcpy input buff z4 Quz sizeof float memcpy input buff z4 Qvx sizeof float memcpy RPC input 4 vy sizeof float memcpy input buffs 4 Qvz sizeof float 11 call would be made to the RPC interface RPC Interface DotProduct RPC input buff RPC output buff Now that the parameters are packe
383. s up the PLL clocking for the chip e CHAM_PIC_SYSTEM_V010 H e CHAM_PIC_I2C_SPI_DRV_V010 C SPI interface driver that configures the SPI port and communicates e CHAM_PIC_I2C_SPI_DRV_V010 H e CHAM_PIC_NTSC_DRV_V010 C NTSC helper functions that send commands to the SPI driver e CHAM 010 e CHAM DRV 010 VGA helper functions that send commands to the SPI driver e CHAM PIC DRV 010 Main File e PIC HELLO WORLD 01 Main startup and operation for hello world program The C files are added the project explicitly but the compiler still needs the H header files however in the previous step you copied all of them into your working compiler directory thus the compiler will be able to find them However personally like to add them the Header Files folders just in case and so can get to them easily in my project window In the following chapters we will describe the contents of these files and many other demos For now select and add all of these files by holding down the Control keyboard key and multi selecting the files Then click the Open button to add them to your project If you missed one you can go ahead and go back to the add dialog through the Add Files To Project menu item Figure 15 39 Adding a linker script to the project Add Files to Project Look in Hello World L3 bootable p24HJ128GP502 gld Filename boot
384. scrpion PO P31 General purpose Port A Can source sink 40 mA each at 3 3 VDC CMOS level logic with threshold of VDD or 1 6 VDC 3 3 VDC The pins shown below have a special purpose upon power up reset but are general purpose I O afterwards P28 12 SCL connection to optional external EEPROM P29 12 SDA connection to optional external EEPROM P30 Serial Tx to host P31 Serial Rx from host Vo power 27 85 VOC ws e 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Brown Out Enable active low Must be connected to either VDD or VSS If low RESn becomes a weak output delivering VDD through 5 kQ for monitoring purposes but can still be driven low to cause reset If high RESn is CMOS input with Schmitt Trigger Reset active low When low resets the Propeller chip all cogs disabled and I O pins floating Propeller restarts 50 ms after RESn transitions from low to high Crystal Input Can be connected to output of crystal oscillator pack with XO left disconnected or to one leg of crystal with XO connected to other leg of crystal or resonator depending on CLK Register settings No external resistors or capacitors are required XO Crystal Output Provides feedback for an external crystal or may be left disconnected depending on CLK Register settings No external resistors or capacitors are required The Parallax Propeller is really useful for doing many things
385. sed memory location in the GPU pointed I to by the src addr low hi 11 ation e src_addr_ptr is incremented as per the GPU configuration define GPU_GFX_RAM PORT16_W 33 GPU_GFX_BASE_ID Writes 16 bit data pointed to by the currently addressed memory location in the GPU pointed y the src addr low hi 1 ration e src add rptr are incremented as per the GPU configuration 9 1 GFX RASTER LINE 34 GPU GFX BASE 10 Reads e current raster line being drawn from 0 191 or whatever the GPU s line resolution 15 Sot Teo Il gpu configuration registers define GFX SET AUTO I NC 354GPU GFX BASE 10 Reads current memory auto increment setting for read write operations lower 4 bits 0 15 default 0 define GFX SET AUTO I NC 364GPU GFX BASE 10 Writes the current memory auto increment setting for read write operations lower 4 bits 11 0 15 default 0 And that s about it for defines let s move on to the API roadmap The API listing for the SPI and 2 module CHAM PIC I2C SPI 010 supports a thin wrapper layer over the hardware functionality The SPI API is more developed since the I2C tends to have a lot state in it functions have to return with errors and other information hence you will probably want to write your own functions in the future Nonetheless have included an 12 initialization and WaitTillldle command that does some of the work fo
386. sequence is repeated at a fast enough rate so that the displayed images are perceived to have continuous motion 11 2 1 Interlaced versus Progressive Scans These are two different types of scanning systems They differ in the technique used to render the picture on the screen Television signals and compatible displays are typically interlaced and computer signals and compatible displays are typically progressive scan non interlaced These two formats are incompatible with each other one would need to be 47 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit converted to the other before any common processing could be done Interlaced scanning is where each picture referred to as a frame is divided into two separate sub pictures referred to as fields Two fields make up a single frame An interlaced picture is painted on the screen in two passes by first scanning the horizontal lines of the first field and then retracing to the top of the screen and then scanning the horizontal lines for the second field in between the first set Field 1 consists of lines 1 through 262 1 2 and field 2 consists of lines 262 1 2 through 525 The interlaced principle is illustrated in Figure 11 3 Only a few lines at the top and the bottom of each field are shown Figure 11 3 Interlaced scanning system mA us NOTE Exaggerated in the vertical dimension for clarity Picture A progressive or non interlaced picture is
387. shed However since the FLASH memory was SPI and there are 1000 s of SPI devices out there we decided to create a virtual SPI interface driver for the Propeller and let it act as a SPI slave device With this design decision we can communicate with the Propeller FLASH and any other external SPI devices all with the PIC s built in hardware very fast and we have a nice clean communications bus for everything The only challenge was supporting enough SPI devices so the design uses a couple PIC I O pins as chip selects for a multiplexer Referring to Figure 9 1 the idea is you place a 2 bit code on a pair of I O pins AIN1 AIN2 which are fed into a 74138 decoder this gives us 4 active low chip select signals SPI SSOn SPI SS3n which we can export out to 4 SPI devices on the bus Referring to the schematic SPI SS3n chip selects the FLASH And if you look back page or two at the Propeller schematic on the left hand side locate the SPI signals you will see that the Propeller uses SPI SS2n as its chip select respectively The remaining chip selects SPI SSOn SPI SS1n are exported out to the interface header J6 on pins 7 8 respectively So you can hook up 2 more SPI devices easily with the MISO MOSI SCLK lines and then connect one of the aforementioned SPI selects to enable it All the other SPI devices will be disabled and thus no bus contingency issues 10 0 VGA Graphics Hardware In this chapter we are going to take a look at the VGA
388. signals as long as we stream the bytes to the port at the 25 175MHz rate everything will work out fine For example say that we are working with a positive sync system that is a VGA monitor that wants a TTL HIGH for sync then to generate a Hsync pulse we could use some pseudo code like this vga byte 0600000010 Write VGA vga byte 3 77 Ok now consider we want to draw 640 pixels from an array video buffer that is storing the pixel data in byte format already in the proper format for our hardware then all we would do is this UCHAR video buffer 640 pre initialized video buffer for pixel 0 pixel lt 640 pixel Write VGA video buffer pixel 0 039721946 Of course you would need some might fast hardware to delay at a resolution of 39 ns but you get the idea This is a model of the algorithm for a line of video this coupled with the model for the horizontal timing vertical timing and put it all together as a state machine and you have VGA generator The VGA drivers on the Propeller are more complex than this of course but that s the idea 45 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 11 0 NTSC PAL Composite Video Hardware To begin with there are many online and written sources for NTSC the primary online resource is located here http www ntsc tv com At the end of the discussion on NTSC there is a list of other resources as well Figure 11 1
389. sions of the demos are relatively straightforward to setup We have already covered how to setup MPLAB to compile build a FLASH image and download with the PICkit 2 programmer Thus for each of the demos all you need to do is add the source C files to the project along with the main program and build the program and download 206 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit All the source API libraries for the demos and the demos themselves are located on the DVD ROM in the usual directory DVD ROM CHAM_PIC SOURCE During initial setup of the tool you should have copied this entire directory to your hard drive 27 1 3 Setup for TextPad Bootloader Version of Demos The TextPad Microchip Bootloader versions of the demos are exactly the same source code wise however there is no project per se Rather we have a batch file CompileDownoad bat and a Win32 console app FlashProg exe that are called with command line arguments to compile and download using the bootloader into the PIC s flash memory All the source API libraries for the demos and the demos themselves are located on the DVD ROM in the usual directory DVD ROM CHAM PIC SOURCE During initial setup of the tool you should have copied this entire directory to your hard drive 27 1 3 Setting the Chameleon Hardware Up Finally let s take a brief moment to remind ourselves what s going on with the hardware If you are using MPLAB then you
390. sistent In general here are the steps to generating an NTSC signal 52 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 11 7 NTSC Super Frame video signal reference for NTSC frame construction HD 21 22 23 ODD FLD1 lt START FIELD EVEN l START FIELD2 ODD j FLD3 Le 8TANT FIELD 3 VERTICAL BLANKING INTERVAL FLD 4 PRE EQUALIZING VEATICAL SYNC PULSE POST EQUALIZING J arant LEB SERRATION PULSES FIELD 4 i i E COMPOSITE BLANKING COMPOSITE i Poi 4 BLANKING i VERTICAL 8YNC EVEN ODD EVEN ODD VERTICAL SYNC 11 2 5 1 Frame Construction Referring to Figure 11 7 This diagram represents the NTSC color Super Frame The complete NTSC spec actually has 4 fields per super frame if you want to follow the spec and interlace 10096 We aren t going to follow the spec 100 but we are going to follow some of the more important parts of the spec one such area is in the vertical sync and equalization pulses area please concentrate your attention on this area of Figure 11 7 for the description below A Frame is composed of 262 5 lines non interlaced 262 will suffice Of those 262 lines many of them are invisible due to overscan and some must be use
391. sistors must be connected from SDA and SCL to Vcc via a 5 10K resistor on both lines Note that with the SPI bus all SPI devices share the MISO master input MOSI master output and SCLK serial clock lines however the CS or chip select lines for each device controls the selection of the target device not an address and when a device is selected its bus is active while any other de selected devices go tristate Thus the I2C bus is always active and arbitration is achieved thru an 159 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit open drain design where SDA and SCL can only be pulled down by the master and SDA alone by the slave Then addressing is achieved by a 7 bit address sent down the C bus to all devices only the listening device with the matching address responds and communication begin Let s discuss this process more in detail 19 2 1 Understanding Bus States The protocol is rather complex compared to SPI protocol In fact there is no SPI protocol se SPI is a simple serial packet much like RS 232 The only protocol that SPI devices have are inherent in the devices themselves and what the bytes sent and received mean on the other hand has this very complex arbitration system to handle multiple Masters on the bus this is facilitated via the electrical design as well as a state machine that lC is based on Considering this is rather complex We are only briefly going
392. ssary to understand the design more completely Figure 16 1 System level modular schematic NTSC TV Audio Amp PS 2 Keyboard Pins 16 23 Pins 12 15 VGA Core NTSC Core COG i 1 ASM SPI Interface COG 1 cham_default2_drv_111 spin top object Propeller Chip Slave Media Processor SPI signals Pins 8 11 MISO MOSI SCLK CS Microchip PIC24HJ Master Control Processor Referring to Figure 16 1 the Chameleon s Propeller co processor has a number of connections to various media I O devices These include NTSC PAL composite video VGA audio out serial not shown and PS 2 keyboard mouse devices This uses up a minimum of 5 processing cores leaving us 3 cores for other things and for future expansion Of course two cores are used for the Master Control Program that runs on the Propeller as well as the SPI virtual driver Thus we are left with 1 core ultimately for expansion unless we modify the default Propeller driver As shown in the figure the NTSC signal is on Pin 12 13 14 VGA is on pins 16 23 audio is on pin 10 the PS 2 keyboard mouse is connected to pins 26 27 and finally the serial is on pins 30 31 Basically this is a standard Propeller Board Rev C D pin map 127 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 16 1 shows the pin map in more detail Table 16 1 The I O pin map for the connections to media devices 1 0
393. sync level 0 0V to black level 0 25 0 3V For example if the entire D A range is 1 0V then 0 3 1 0 30 30 of 7 is 2 thus the 3 bit value of 0 is sync while the 4 bit value of 2 is black leaving us with only the values 3 7 or 5 different intensity levels Additionally since the chroma signal rides on top of the luma signal there is yet another constraint since the chroma need to have a peak to peak of at least 2 units this in fact we can only drive the video signal to a value of 6 so the Propeller s chroma hardware can twiddle the luma 1 to obtain the chroma However in fact most drivers simply use 0 as sync 1 as black then values 1 6 as shades of gray This gives us a total luma range of 6 values and still allows color to work which the Propeller is designed to be able output 16 phase shifts of the color burst This gives a total color luma range of 16 6 96 colors without resorting to tricks If you are really interested in how to write graphics drivers you should peruse the source code of the various graphics drivers written by various authors for the Propeller Additionally the only reference book that explains in detail how the graphics system works is Game Programming for the Propeller Powered HYDRA which you can find on Amazon com Parallax com and XGameStation com There is also some minimal 46 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit coverage of the Propellers graphics hardware transcri
394. t TX B Unit Head Tail ISR Physical Serial Port TX RX Hopefully you have read thru the application notes and data sheet on the PIC UARTS Nonetheless serial communications at the PC level is usually quite easy The PC has an API hardware interrupts and lots of sub systems so that you are insulated from what s really going on This is not true with microcontrollers The PIC24 series has hardware UARTS to take the load off the bit banging polling and transmission and reception of actual bytes but we still need to write a lot of software on top of the hardware to develop an API that is useful Transmitter Circular Buffer Receiver Circular Buffer putchar Head Tail Receiver getchar ISR There are lots of ways to approach this for example if you are happy with waiting for characters you could write a receive function that simply waits for the reception buffer to get a character this is slow though since you have to poll for it Secondly you could do the same with your transmission software and write a loop that constantly writes bytes to the transmit buffer while waiting for the bytes to transmit before writing another These methods are fine but wanted to give you a little bit more to work with as a starting point so you can see how you might develop a more robust serial communications system Referring to Figure 18 1 this is the architecture of the UART module we have developed The UART driver API is an
395. t before sending it commands the boot process is about a second if you like you can speed it un by the Prop driver s LED blink sequence the driver or speed it up but commands that are sent before the Prop driver is done booting will be ignored therefore if you have a lot of set up work to do then you don t require a delay but if you jump right into commands then you need good 1 5 2 second delay DELAY MS 2500 clear screens NTSC ClearScreen enter infinite loop l print on NTSC terminal screen 208 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit int Hello World slow things down a bit so we can read the text DELAY _MS 10 I end while l end main First it should be amazing to you that in a few lines of code you are generating a NTSC color text display Reviewing the code the program starts waits for the Propeller to boot don t forget to do this then the call to clear the screen and we enter the main while loop Here a redundant call to set the color is made and the text is printed to the NTSC terminal with NTSC Term Print that s it Summary This demo shows how easy it is to get NTSC terminal like text output going on the Chameleon 28 1 2 NTSC Glowing Top Bottom Overscan Demo This demo simply uses the NTSC tile graphics engine extensions to glow the top and bottom overscan colors on the display The default2 d
396. t the Chameleon PIC or if you have different programmers like the ICD2 Press lt Next gt to review all our settings before final install 83 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 7 MPLAB installation complete message box MPLAB Tools Start Copying Files Review settings before copying files AN MICROCHIP Setup has enough information to start copying the program files If you want to review or change any settings click Back If you are satisfied with the settings click Next to begin copying files Current Settings Destination Directory C Program FilessMicrochip Setup type selected Custom Components selected Serial Memory Devices 8 bit MCUs 16 bit MCUs 32 bit MCUs MPASM Suite We have one last chance now to bail out before the actual installation see Figure 15 7 where copying of files takes place Click on the lt Next gt button to start the copying Figure 15 8 Installation progress bar Installing Copying file C Program Files Microchip MPLAB m30 exe B 8 You will now see a progress bar as shown in Figure 15 8 that gives us an indication of how much copying is left until our install is complete If something is wrong you may stop it by pressing the Cancel button Otherwise let it finish 84 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 9 MPLAB installation complete restart computer MPLAB Tools
397. t the actual data packet format for the mouse state 12 2 2 Mouse Data Packets The PS 2 mouse sends the movement information to the host which includes the position counters button state overflow flags and sign bits in the format show in Table 12 6 62 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Table 12 6 Mouse data packet format Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0 Byte 1 Y overflow bit X overflow bit Y sign bit X sign bit Always 1 Middle Button Right Button Left Button Byte 2 X Movement delta Byte 3 Y Movement delta The movement counters are 9 bit 2s complement integers since the serial protocol only supports 8 bits at a time the upper most sign bit for each 9 bit integer is stored in Byte 1 of the overall movement packet Bit 4 holds the 9 bit of the X movement and Bit 5 holds the 9 bit of the Y movement Typically you don t need to worry about the 9 bits since that would be a lot of motion in one update so just use byte 2 and 3 to track motion The motion counters are updated when the mouse reads its input and movement has occurred The movement counters once again only record differential or delta motion rather than absolute With a 9 bit value recording each counter a total amount of 255 to 256 can be represented in 9 bit 2s complement If this range is exceeded the appropriate overflow bit is set for either the X or Y counter Note that the movement counters are reset w
398. t the remainder of the circuit Using a voltage divider made of R14 and C15 we need to write a relationship between the input voltage at AUDIO call it Vin t and the output voltage of the RC filter at the top of C15 call it Vout t Ok here goes a few steps Vout s Vin s 1 sC 1 sC Then dividing both sides by Vin s we get Gain H s 1 sC 1 sC Simplifying a bit results in Gain H s 1 1 sRC Then transforming back from the S domain to the frequency domain we get Gain H f 1 1 2 PI f RC Note Technically there is another term in there relating to phase but it s not important for this discussion In any event now this is interesting this equation Gain H f 1 1 2 PI f RC Describes the amplification or more correctly the attenuation of our signal as a function of frequency f This is very interesting Let s try something fun Let s plug in some values really quickly and see what happens let s try 0 Hz 1 Hz 100 Hz 1000 Hz 1 MHz and see what we get Table 14 1 shows the results Table 14 1 The results of passing various frequencies thru a low pass single pole RC filter Frequency f Hz Gain Comments ae ee eed 0 1 1 is 1 0 or no attenuation 1 1 1 2 PI RC 10 1 14 2 PI 10 RC 100 1 1 2 PI 100 RC 1000 1 1 2 PI 1000 RC 1 000 000 1 1 2 PI 1 000 000 RC This is very interesting ignoring for a moment th
399. t this feature simply comment out the define The next defines allow a user to specify how much space should be used for the transmit and receive buffers The PIC24HJ128GP502 has 8K of RAM which is quite a bit more than most microcontrollers so you can make these larger or smaller depending on your particular needs attributes T epe 1 1 1 MO Cn qo D D D D D D D D D D lt lt lt lt lt lt lt lt lt 1 oOo 1 146 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit The above defines are used as parameters to void UART_vt100SetAttr unsigned char attr that is used for setting VT100 terminal modes as discussed in the previous section extern vol extern extern extern vol extern vol extern extern extern vol unsigned char UART1_tx_buffer UART1_TX_BUFFER_SI unsigned int UARTI tx buffer add pointer unsigned int UARTI tx buffer send pointer unsigned int UARTI tx buffer bytes to send unsigned char UARTI rx buffer UARTI RX BUFFER SIZE unsigned int UARTI rx buffer add pointer unsigned int UARTI rx buffer out pointer unsigned int UARTI rx buffer bytes in buffer These globals simply contain the internal pointers and circular buffers used in the UART driver Users typically would not modify these directly but we extern them here for the unlikely scenario The API listing for the UART and RS 232 module CHAM PIC UART
400. tXY int x int Description VGA SetXY sets the current cursor position on the VGA terminal screen Returns 1 Example s Read the current cursor position and then move the cursor one position to the right lit xy VGA GetXY amp x amp y VGA Set XY x4l y Function Prototype int VGA Term Char char ch Description VGA Term prints an ASCII character to the VGA terminal at the current cursor position updates the current cursor position and potentially scroll the text screen up if printing on last line of display Additionally this function is a sub command conduit to the terminal manager This functionality should be maintained for any drivers that you develop so users can have a standard set of base terminal functionality You can send the following ASCII codes some functions are redundant 00 clear the screen 01 home the cursor to top left 08 backspace 09 tab 8 spaces per 0A set X position X follows 0B set Y position Y follows 0C set color color follows 0D return carriage return and linefeed Example s Clear the screen then print Chameleon VGA Term Char 0x00 VGA Term Char VGA Term Char VGA Term Char VGA Term Char VGA Term Char VGA Term Char VGA Term Char VGA Term Char VGA Term Char Function Prototype int VGA_Term_Print char string Descripti
401. tation has a lot to say about this subject so make sure to read it Alright so that s the story with PIC24 libc it s part of the GNU GCC PIC24 C compiler installation and when you build a C application functions are pulled in from this library To give you an idea of what Libc supports Table 17 2 lists the header files you can include in your Chameleon PIC applications and what functionality they support Table 17 2 PIC24 Libc library functionality listed by header file Libc Header File Description E E a General C C Library Functions e E As you can see these set of headers looks pretty familiar as you will find most of them on standard C compilers Now the hardware specific functionality for the Chameleon PIC we had to develop Referring to Figure 17 1 there are a number of library classes you can glean from the figure they are System The system library module is a glue module that ties the other modules together and is used as 139 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit a common place to put functions and constants that don t fit into any other category Currently the system library module is very small but it will grow in the future Graphics This library simply makes calls to the graphics drivers running on the Propeller chip So whatever they do this library tries to expose to the user The current driver
402. te Currently only MAX FCY RATE is allowed Example s Configure the clock to the max rate SYS ConfigureClock MAX FCY RATE 18 0 UART and RS 232 Library Module Primer The UART and RS 232 communications module supports basic transmission and reception of bytes to and from the Chameleon PIC serial port The PIC24HJ has two very advanced UARTs Universal Asynchronous Serial Receiver and Transmitters It is connected directly to the TX RX pins of the USB FTDI chip which allows serial communication via the USB port Additionally the TX RX lines can be remapped to any of the PORT B pins so it provides maximum flexibility Before we discuss the overall architecture of the UART library module here are the main features of the PIC24 UART Full Duplex Operation Independent Serial Receive and Transmit Registers high Resolution Baud Rate Generator Supports Serial Frames with 8 or 9 Data Bits and 1 or 2 Stop Bits Odd or Even Parity Generation and Parity Check Supported by Hardware Data Overrun Detection Framing Error Detection 4 deep First in First out FIFO Transmit and Receive buffer Loopback mode for diagnostic IrDA Encoder and Decoder Logic As you can see they are pretty powerful and the library API we provide here only scratches the surface of what you can do with the UART hardware They can even be used to stream audio or video data if you are really creative since they are more or less interrupt driven high s
403. te Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key C ALL_DEV_STUFF Real Chamel eon BootLoaderBi n Hel loWorl d pi c30 gcc exe mcpuz24H 128GP502 x c c C ALL_DEV_STUFF Real Chamel eon PI CodelPI BootLoaderBi n Hel loWorl d CHAM PIC HELLO WORLD 01 C o main o D__ DEBUG Microchip MPLAB C30 License Manager Version v3 12 Build Date Jan 30 2009 Copyright c 2008 Microchip Technology Inc All rights reserved The MPLAB C30 license has expired pic30 coff ccl exe warning Options have been disabled due to expired license Visit http www microchip com to purchase a new key C ALL_DEV_STUFF Real Chamel eon PI C Code PI BootLoader Bi n Hel loWorl d pi c30 gcc exe mcpu 24H 128GP502 CHAM PIC FLASH DRV_V010 0 CHAM PIC SOUND DRV V010 0 CHAM PIC VGA DRV V010 0 CHAM PIC NTSC DRV V010 o CHAM PIC MOUSE DRV V010 0 CHAM PIC KEYBOARD DRV_V010 0 CHAM PIC 2C SPI DRV V010 o0 CHAM SYSTEM V010 0 CHAM PIC UART DRV V010 0 CHAM PIC GFX DRV 010 0 main o o program cof 1 MPLAB C30 lib script bootable p24HJ 128GP502 919 _ BUILDzl defsyms DEBUG 1
404. ter sequence Though some encodings use multiple bytes per character in this topic all characters are single byte You can run a terminal program on the PC in ANSI mode and then send these commands to it from the Chameleon ANSI Codes Most Popular Code Name Moves the cursor n default 1 cells in the given direction If the cursor is already at the edge of the screen this has no effect CUU Up CUD Down CUF Forward CUB Back Moves cursor to beginning of the line n default 1 lines down next line Moves cursor to beginning of the line n default 1 lines up previous line CSI n mH Moves the cursor to row n column m The values are 1 based and default to 1 top left corner if omitted A sequence such as CSI 5H is a synonym for CSI 1 5H as well as CSI 17 H is the same as CSI 17H and CSI 17 1H CSI n J D Clears part of the screen If n is zero or missing clear from cursor to end of screen If n is one clear from cursor to beginning of the screen If n is two clear entire screen and moves cursor to upper left on MS DOS ANSI SYS Erases part of the line If n is zero or missing clear from cursor to the end of the line If n is one clear from cursor to beginning of the line If n is two clear entire line Cursor position does not change CSInS SU Scroll whole page up by n default 1 lines New lines are added at the bottom not ANSI SYS Scroll whole page down by n default 1 lines New lines are added at the
405. tes 16 bit tile map ptr which points to the current tile map displayed 162 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit define GPU_GFX_DISPLAY_PTR_R 4 GPU GFX BASE 10 Reads 16 bi ile map ptr which points to the current display ptr into the tile map low 11 level prin unctions use this pointer define GFX DISPLAY 54GPU GFX BASE 10 Writes 16 bi ile map ptr whic oints to the current display ptr into the tile map low 1 level print functions use this pointer define GPU GFX M PTR R 64GPU GFX BASE 10 Reads 16 bi ile map ptr which points to the current terminal ptr into the tile map termina eve rint functions use this pointer define GPU GFX M 74GPU GFX BASE ID Writes 16 61 ile map ptr whic oints to the current terminal ptr into the tile map termina eve rint functions use this pointer 9 1 GFX _ 8 GPU_GFX_BASE_1D Reads 16 01 ile bitmaps ptr which points to the bitmaps indexed by the tilemap define GFX W 94GPU GFX BASE 10 Reads 16 01 ile bitmaps ptr which points to the bitmaps indexed by the 11 define GPU_GFX_PALETTE_R 10 GPU_GFX_BASE_1D Reads 16 bi alette array p
406. that wrap the use of the messages in higher level functions 3 There are three classes of messages we can add Class 1 Same object more functionality There is already a driver for the messages the driver supports some extra functionality that we haven t exposed yet and wish to The sound driver for example falls under this category barely exposed its true power so you might want to add more messages In this case you have to add 243 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit the messages to the H file as well as the SPIN file In addition to this you need to add more cases to process and dispatch the messages in the SPIN driver and then on the PIC C side you might want to add more API functions Class 2 New object new functionality The second case is when you want to add a completely new driver object and run it on another processor on the Propeller In this case you will load the object in at the top of the main driver start it up and then add messages along with message handlers to the main message dispatcher loop This is the most complex case Class 3 Simple messages that can be processed in place Finally the last case is the easiest and the one we will illustrate This is the case where we want to add some functionality to the main Propeller driver but we can run that functionality right on the main processor that is running the message loop Examples of this are the Propeller local
407. tic USB driver installation dialog yj The Propeller Tool v1 05 5 Installer x Install Optional Driver L amp Choose optional driver installation la This program can automatically install or update the driver for Parallax USB based products like the Propeller Demo Board and Prop Clip Plug This driver is required to communicate with these products Automatically install update driver recommended Step 4 The tool is ready to be installed Figure 15 59 below shows the installation ready dialog click INSTALL to begin the installation 121 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 59 The final installation dialog before the software is installed y The Propeller Tool v1 05 5 Installer x Ready to Install the Program L 8 The wizard is ready to begin installation Click Install to begin the installation you want to review or change any of your installation settings click Back Click Cancel to exit the wizard Step 5 As the software installs the first thing it will do is install the FTDI inc USB drivers that the Propeller Tool relies on so you should see a message box like that shown in Figure 15 60 below Figure 15 60 The FTDI USB drivers successfully installed FTDI Driver Installation 1 FTDI CDM Drivers have been successfully installed Step 6 Click OK and the final installation
408. tion Proxy VT Options Transfer uM Global The currently selected tab will be the connection type used The connection type is currently Direct to COM E VD Telnet 8 55 1 ssH2 Dialup 2 Direct to COM Port COMB4 Configure Port Bits Per Second 2400 Parity None Stop Bits 1 Data Bits 8 Enable Bubble Help The settings should be Data Format N81 no parity 8 data bits 1 stop bit Baud Rate 2400 Handshaking None Terminal Mode VT100 doesn t really matter though since we aren t using the terminal Screen Size 80 24 or larger 120x50 is a good choice Local Echo Off Make sure that you have the serial selection switch in the DOWN position on the Chameleon PIC mode Notice the terminal mode VT100 etc doesn t really matter nor does echo really since we aren t going to type anything The PC is going to do the transfer itself in an automated fashion Moving on once you have Absolute Telnet setup then you are going to make the connection to the Chameleon once we have the FLASH demo loaded To do this you simply click the lightning bolt or connection icon on the Absolute Telnet interface Then once we want to initiate the X Modem transfer you are going to access the main menu and access the Transfer Send XModem menu item as shown in Figure 31 5 below select a file and download to the Chameleon But we are getting ahead of ourselves right now Just remember this process and
409. to Windows Start menu on and select Control Panel System Properties select Hardware Device Manager and select lt Ports gt you should see something like that shown in Figure 15 52 113 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 52 Determining the COM port that the FTDI chip on the Chameleon PIC uses Device Manager Action View Help Hee 2 m Monitors lt P Multifunction adapters 88 Network adapters 7 a Communications Port COM1 E Communications Port COM2 ECP Printer Port LPT1 PCI Parallel LPT3 Y RIM Virtual Serial Port v2 COM25 USB Serial Port COM30 Sound video and game controllers System devices Universal Serial Bus controllers Generic LISB Hub Intel R 82801BA BAM USB Universal Host Controller 2442 Intel R 82801BA BAM USB Universal Host Controller 2444 PCI to USB Enhanced Host Controller B1 NEC PCI to USB Open Host Controller NEC PCI to USB Open Host Controller Make note of the USB Serial Port in this case the driver installed on COM30 yours might be different but you will need this when running the bootloader batch file and FlashProg exe tool So write this number down for the next step of the tool setup Also we might as well install a good serial program now so you don t have to do it later The Propeller tool has one built but for general terminal experiments HyperTermina
410. to cover some of the high level concepts of the protocol and its primary states START and STOP To begin with data is transfer is always initiated by a Master device remember Slaves can only respond to Masters A high to low transition on the SDA line while SCL is high is defined to be a START condition or a repeated START condition Everything begins with the START condition that s the first thing to remember with er Figure 19 5 below show the timing waveforms for this event Figure 19 5 Timing waveforms for START Condition Addr MS AddrLSB R W SDA Y Y YN Y Y N PL Papa A N N IN SCL ON ON 1 2 7 8 9 START SLA R W A START condition is always followed by the unique 7 bit slave address along with a single bit signifying the Data Direction either read or write The Slave device addressed acknowledges the Master by holding SDA low for one clock cycle If the Master does not receive an acknowledgement the transfer is terminated Depending of the Data Direction bit the Master or Slave now transmits 8 bits of data on the SDA line The receiving device then acknowledges the data Figure 19 6 shows what happens during data transmission following the initial START and addressing phases Figure 19 6 Timing waveforms for I2C data transmission Data MSB DataLSB v n go p 2 Data Byte STOP
411. tr which points to the palettes in use for the tilemap define GFX PALETTE 114 GPU GFX BASE 10 Writes 16 bi alette array ptr which points to the palettes in use for the tilemap define GFX TOP OVERSCAN COL R 124GPU GFX BASE 1 Reads top overscan color drawn on the screen define GPU GFX TOP OVERSCAN COL W 134GPU GFX BASE ID Writes top overscan color drawn on the screen define GFX BOT OVERSCAN COL R 144GPU GFX BASE ID Reads top overscan color drawn on the screen 9 1 GPU GFX BOT OVERSCAN COL W 154GPU GFX BASE 10 Writes top overscan color drawn on the screen define GPU GFX HSCROLL FINE 164GPU GFX BASE 10 Reads current fine horizontal scroll register 0 7 NOTE NOT implemented yet define GPU GFX HSCROL INE W 174GPU GFX BASE 10 Writes current fine horizontal scroll register 0 7 NOTE NOT implemented yet define GFX VSCROLL FINE 184GPU GFX BASE ID Reads current fine vertical scroll register 0 7 define GFX VSCROLL FINE 194GPU GFX BASE ID Writes current fine vertical scro register 0 7 define GPU GFX SCREEN WIDTH 204GPU GFX BASE 10 Reads screen width value 0 16 tiles 1 32 tiles 2 64 tiles etc define GPU GFX SCREEN WIDTH 214GPU GFX BASE 10 Writes screen width value 0 16 tiles 1 32 tiles 2 64 tiles etc define GFX SRC ADDR 22 GPU GFX BASE 10 Reads 16 bit source address for GPU operations
412. trademark service mark or copyright notices e You agree that the Licensed Works will not be shipped transferred or exported into any other country or used in any manner prohibited by any government agency or any export laws restrictions or regulations f You may not publish or distribute in any form of electronic or printed communication the materials within or otherwise related to Licensed Works including but not limited to the object code documentation help files examples and benchmarks TERM This Agreement is effective until terminated You may terminate this Agreement at any time by uninstalling the Licensed Works and destroying all copies of the Licensed Works both HARDWARE and SOFTWARE Upon any termination you agree to uninstall the Licensed Works and return or destroy all copies of the Licensed Works any accompanying documentation and all other associated materials WARRANTIES AND DISCLAIMER EXCEPT AS EXPRESSLY PROVIDED OTHERWISE IN A WRITTEN AGREEMENT BETWEEN LICENSOR AND YOU THE LICENSED WORKS ARE NOW PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND EITHER EXPRESS OR IMPLIED INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR THE WARRANTY OF NON INFRINGEMENT WITHOUT LIMITING THE FOREGOING LICENSOR MAKES NO WARRANTY THAT i THE LICENSED WORKS WILL MEET YOUR REQUIREMENTS ii THE USE OF THE LICENSED WORKS WILL BE UNINTERRUPTED TIMELY SECURE OR ERROR FREE iii THE
413. ts own methodology and API For example the NTSC calls look entirely different from the keyboard calls and so forth Alas if you were to develop a system from the ground up and design drivers for NTSC VGA keyboard etc you would be wise to design all the APIs in a similar fashion with conventions for function calls inputs and outputs so that technologies like RPC calls and others could more easily be implemented and optimized better 136 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 17 0 Chameleon PIC API Overview In this section of the manual we are going to discuss the Chameleon PIC API and its related components First and foremost want to make it clear that the API we have developed is by no means complete the best the fastest etc It s just a set of source files and functions that get you started developing applications Moreover the whole idea of the Chameleon is to leverage the functionality of the drivers running on the Propeller chip The PIC side API is nothing more than wrapper functions that container a number of SPI commands so you don t have to type a lot to get things done In other words you don t have to use these libraries in most cases you can just send a command directly if you wish Moreover these API functions are designed for the specific drivers running on the default Propeller drivers If you change or modify drivers on the Propeller side chances are these new drivers will have dif
414. ty thus the moniker and likewise Von Neumann was designed by mathematician John Von Neumann Von Neumann differs from Harvard in that Von Neumann uses a single memory for both data and program storage 21 Program Flash Memory PIC24HJ128GPX02 X04 GoTo Instruction Reset Address Interrupt Vector Table Reserved Alternate Vector Table User Program Flash Memory 44032 instructions Unimplemented Read 0 5 Reserved Device Configuration Registers Reserved DEVID 2 Reserved 0 000000 0 000002 0 000004 0x0000FE 0x000100 0x000104 0x0001FE 0x000200 0x0157FE 0x015800 Ox7FFFFE 0x800000 OxF7FFFE OxF80000 OxF80017 OxF80018 OxFEFFFE OxFF0000 OxFF0002 OxFFFFFE 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 1 6 FLASH and SRAM memory layouts MSb Address 2 Kbyte 0x0001 SFR Space OxO7FF 0 0801 8 Kbyte SRAM Space Ox1 FFF 0x2001 Ox27FF L 0x2801 0x8001 Optionally Mapped into Program Memory OxFFFF Data SRAM Memory 16 bits MSb LSb SFR Space X Data RAM X Data Unimplemented X LSb Address 0 0000 Ox07FE 0x0800 8 Kbyte Near Data Space Ox1FFE 0x2000 Ox27FE 0x2800 0 8000 OxFFFE 22 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Referring to Figu
415. u can output is a square wave you can t output sine waves This tends to make the sounds have a textured sound since harmonics are in the square wave That is if you output a square wave at frequency f then you will find that there are harmonics at 5f etc all these sine wave are what really make up a square wave Take a look at Fourier transform theory to see this hitp homepages inf ed ac uk rbf CVonline LOCAL_COPIES OWENS LECT4 node2 html Of course our little low pass filter is going to filter most of these harmonics but you aren t going to hear a pure sine until you increase the frequency to about the 3dB cutoff which may be desired In any event if all you need is a single channel some noise pure tones then FM with the AUDIO_MONO port at P24 is more than enough You can use software or the built in timer in PWM mode to accomplish this as well but you won t have any control over amplitude since you would be running the output at audio frequencies and not at PWM frequencies 14 1 3 Pulse Width Modulation PWM Pulse width modulation or PWM is a very clever way to create any kind of sound with a single bit of output The bad news is that the generation of the output and the algorithms needed are fairly involved and take a little bit of numerical analysis but once you get it working it s not an issue and you can build libraries to create any sound you wish in fact many advanced synthesizers use PWM systems so it s very
416. u don t have a degree in Computer Science you have probably used remote procedure calls or RPCs in one form or another or even invented them unknowingly The idea of a remote procedure calls came about in the 1970 s actually so it s a really old concept The basic idea is very simple for one process program to be able to call use a subroutine or function in another process program More or less a form of interprocess communication Figure 16 4 RPC call from process to process in contrast to a DLL call RPC Call Overview DLL Call Overview Process 1 Process 2 Process 1 Process 2 RPC call from process 1 to 2 Local M subroutines amp Local i subroutines amp memory e DLL call process s dynamically links to common code DLL library code is loaded and executed by process s However code is not part of a seperate i Call across process process but rather simply loaded into boundaries into other common memory space and executed by processes subroutines i calling processes DLL Library RPCs are a little different than using DLLs or libraries since they are passive entities that are loaded on demand RPCs are more like making calls to another running program and using its resources subroutines Thus there is a client server relationship here and you can think of the RPC call as message passing as shown in Figure 16 4 There are various forms of the technology and it
417. ub Function register and issues a high level command like copy fill etc I sub function constants that are executed when the GPU GFX SUBFUNC STATUS W command is issued define GPU GFX SUBFUNC 16 0 Copies numbytes from src gt dest in wordsize chunks define GPU GFX SUBFUNC FILLMEMI6 1 Fills memory with datal6 2 bytes at a ti me define GPU GFX SUBFUNC COPYMEM8 2 Copies numbytes from src gt dest in byte size chunks define GPU GFX SUBFUNC FILLMEM8 3 Fills memory with low byte of datal6 bytes at a ti me 1 normal commands define GFX TI LE 24 GPU GFX BASE 10 Reads 16 bi ile map ptr which points to the current tile map displayed define GPU GFX TI LE 34GPU GFX BASE 10 Writes 16 bi ile map ptr whic oints to the current tile map displayed define GFX DISPLAY 4 6 GFX BASE 10 Reads 16 bi ile map ptr which points to the current display ptr into the tile map low 1 level print functions use this pointer define GFX DISPLAY 5 6 GFX BASE 10 Writes 16 bi ile map ptr whic oints to e current display ptr into the tile map low 1l level prin unctions use this pointer define GPU GFX M PTR R 64GPU GFX BASE 10 Reads 16 bi ile map ptr which points to the current terminal ptr into the tile map termina eve rint functions use this pointer define GPU GFX M W 74GPU GFX BASE 10 Writes 16 bi ile map ptr whic oints to e current termina
418. uired for this while 1 glow thru every color every brightness for 0 col lt 15 col roy wr 25 Wie gine lt y l build up Propeller compatible color chroma 4 chroma bit 1 uma 3 color col lt lt 4 0b00001000 bright top overscan Top Overscan Color color amp OxFF set bottom overscan GFX Set Bottom Overscan Color color amp OxFF ings down a bit so we can read the text DELAY MS 100 end for bright end for color end while The code simply formats a Propeller compliant color and then calls the API function to change the top and bottom overscan color that s it Summary This demo shows how easy it is to use the advanced GFX tile engine API functions in particular to animate the overscan color on the NTSC display 28 1 3 NTSC Smooth Scrolling Tilemap Demo This demo illustrates the smooth scrolling feature of the default2 versions of the Propeller driver The NTSC tile engine supports course horizontal and vertical scrolling simply by changing the tile map base pointer However the engine also supports pixel smooth scrolling in the vertical direction This allows you to smoothly scroll the tile map any number of rows you wish First you smooth scroll 0 7 pixels then you reset the smooth scroll register and course scroll and repeat To the user this will look like one continuous scrolling action Figure 28 3 shows the demo in action 210
419. ulated input from a wall adapter or feeds from the USB port header The supplies design is shown in Figure 2 1 for reference The supplies are straight forward the only interesting thing is the coupling of the USB power and the regulated power at node 1 of the power switch SW1 This allows the system to use power from either the regulated supply or the USB port The Chameleon PIC is a mixed voltage system to support 5V and 3 3V PIC and Propeller chips Both supplies are independent and can each supply up to 500 mA for all your needs Additionally the power supplies are exported to the expansion header J7 for external interfacing 3 0 Reset Circuit Figure 3 1 The Chameleon PIC reset circuit 5vcC USB DTR Reset Signal Conditioning CL RESn R3 C16 10K USB_DTRn USB_RTSn 01uF Q1 2N3904 Reset Switch SW2 RESn SW MOM 2 The Chameleon PIC can be reset externally a number of sources including the reset switch SW2 the ISP programming port as well as pressing as thru the DTR or RTS lines of the USB UART The reset circuitry on the PIC 328P 31 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit and Propeller don t require much conditioning thus the manual reset circuit is nothing more than a switch and a pull up resistor as shown in Figure 3 1 Typically you will reset the system yourself via the reset button next to the PIC but the Propeller tool as well as the bootloader tool bot
420. ult2 driver clock directives look like this CON These settings are for 5 MHZ XTALS cl kmode xtall plll16x enable external clock 2000 pil times 16 _xinfreq 5 000 000 set frequency to 5 MH This instructs the compiler to generate an object with settings that assume a 5MHz input clock and then the processor scales this by 16X resulting in the nominal 80MHz that the Propeller chip needs to operate The 80 MHz clock drives each processor clock and each processor executes one instruction per 4 clocks thus 20 MIPs on average Now if we want to go a little faster we could use a 6MHZ XTAL and then use the pll16x directive once again this results in a clock rate of 96 MHz and 24 MIPS per processor Depending on your Propeller chip this might work as is however the transitions are so fast that the noise margins etc of the signals become small and the capacitive loading too much for the 3 3V supply thus you might need to increase the power supply voltage to 3 6 volts to get this speed to work But point is if you need a little bit more you can increase you oscillator xtal a bit and then see if it works Also the Propeller will get hotter as you overclock it thus you might have to heat sink it 2 Overclocking the 24 Microcontroller The PIC is a little bit different than the Propeller chip when overclocking First of off it is rated to run up to a maximum of 40 MIPS where the internal Fey clock rate is at
421. unch it you will see the installer splash screen as shown in Figure 15 56 below Click NEXT Figure 15 56 The Propeller IDE installation splash screen your version might vary 3 T 3 The Propeller Tool v1 05 5 Installer Welcome to the Propeller Tool v1 05 5 installer This program will allow you to modify repair or remove the Propeller Tool v1 05 5 To continue click Next Ww PROPELLER zs by Parallax Inc Cancel Step 2 The installation type should be displayed next as shown below in Figure 15 57 select Complete install click lt NEXT gt 120 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 15 57 Selection of Complete install y The Propeller Tool v1 05 5 Installer Setup Type H Choose the setup type that best suits your needs Please select a setup type 18 All program features will be installed Requires the most disk space O Custom Choose which program Features you want installed and where they will be installed Recommended advanced users Step 3 VERY IMPORTANT The Propeller tool IDE communicates to the Chameleon PIC using a USB cable and driver this USB driver must be installed The next dialog shown below in Figure 15 58 should have the Automatically Install Update driver selected so the driver is installed Check this box and click NEXT Figure 15 58 Automa
422. und drv 052 1likhz 166 CHAM GFX 001 TB 001 3 3 Floppy amp ee D H D art Dev Cpp development advanced hydra programming apple mini arduino chameleon cham avr EM docs cham avr test 1 3 propeller driver cham default2 drv 111 spin CHAM GFX DRV 001 TB O01 SPIN keyboard 10 spin mouse I10 spin d deo 11105 1E hit enin Propeller Source spin cham defaul2 111 Full Source Condensed Summary Documentation cham default2 drv 111 spin AUTHOR Andre LaMothe a cham_default2_drv_111 spin CHAM GFX DRV 01 TB 001 SPI keyboard 010 spin Type Propeller Source Code a 01 O spi Date Modified 9 2 2009 12 18 AM BI mouse 010 spin Size 51 2 KB WB NS_sound_drv_052_11khz_16bit spin i _010 5 W Ga_Text_010 spin from the Parallax RAL OVERVIEW ina d Insert File name cham default2 drv 111 spin M Files of type Propeller Source spin Object Exchange or other sources 7 7 to fas version more gar commar ou don t uou can Prage thes T alter anc Thin sustem works bu the host RVR PIC sending commands o M Once the source code is loaded into the tool you simply have to download it into the Chameleon PIC Make sure that you have the USB cable plugged into the
423. uple simple delay routines define CYCLES PER SEC unsigned long g FCY Instructio n per millisecond ine CYCLES unsigned long g FCY 0 001 Instructio ion per microsecond INe CICLES cles R US unsigned long g FCY 0 000001 olet oru delay some seconds delay32 is provided by t piler CYCLES PER SEC unsigned long sec e co ine DELAY SEC sec delay32 delay32 is provided by e delay some of milliseconds ine DELAY_MS ms __ the lay32 PER MS unsigned long ms s ol Delay some number of micr ine DELAY US us dela 0105 CYCLES PER US unsigned long us lt o wn Delay some clocks minimumis 12 a 5 efine DELAY CLOCKS clocks _ ocks Cause a cycle stal efine NOP __asm_ volatile nop sed to unlock the 10 remapable ability efine UNLOCK_1O_REMAP __asm_ volatile MOV 0SCCON 1 n MOV 0x46 2 n MOV 0x57 3 n MOV 2 wl Yn MOV b 3 wl Vn BCLR OSCCON 6 Im 11 Used to loc the 10 remapable pna abilit define LOCK 10 RE y asm volatile MOV 0SCCON wl n MOV 0 46 w2 in MOV 0 57 w3 in MOV b w2 wl n MOV b w3 wl in EE GR These macros are primarily used to delay the processor by either seconds milliseconds microseconds or c
424. uss them as well in the brief primer To start the actual important signals you need to generate for VGA are referring to Table 10 3 are Red Green and Blue video as well as Hsync and Vsync The R G B signals are analog voltages representing the instantaneous intensity of any particular channel and range from 0 1 0V the Hsync and Vsync are simply TTL signals usually active LOW but these can be inverted on most monitors where a logic LOW is sync and a logic HIGH is no sync Now let s look more closely at the signal itself 42 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 10 3 The VGA timing specifications A VGA 640x480 Layout 640 pixels y 0 0 Horizontal Timing Diagram Red Green Blue a A L _ D E HSYNC Comen 3 D Time 31 77 us 3 77 us 1 89 us 25 17 us C Vertical Timing Diagram 480 Horizontal Refresh Cycles Red Green Blue en R S 4 VSYNC MP Parameters 0 P Q R Time 16 6 ms 64 ps 1 02 ms 15 25 ms 0 35 ms To begin with the VGA standard as implemented is 640x480 pixels across as shown in Figure 10 3 a The image is rendered left to right top to bottom similarly to the NTSC PAL signals and thus a similar syncing scheme is used that is composed of both a horizontal sync pulse each line and a vertical sync pulse each frame However
425. usually black are in a simple luma chroma format which we will discuss in the section below on color palettes The horizontal and vertical smooth scroll are encoded as 4 bits each but only vertical smooth scrolling works currently and the valid values are O 7 Finally the playfield width is controlled with this register as well It can be 32 64 128 or 256 tiles wide a subset of powers of 2 Now this register is accessed a number of separate shadow registers in the global register interface but wanted you to see this in the code so when we discuss the registers they are familiar Tile Map Entry Format Each tile map entry is a 2 bytes In the following format msb palette index tile index lsb The low byte is the actual tile character index 0 255 and the high byte is the palette index 0 255 However in most cases you won t have this many tiles or palettes In fact initially there are only 16 palettes 0 15 and there are 144 bitmaps extracted from file font file c64 font 05 16b bmp followed by 16 blanks for user definition of course you can overwrite 178 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit these as well with direct memory access if you wish to The font file was handmade and based on the Commodore 64 and Atari 800 fonts as well as some extra characters for fun The font file is located on the DVD here DVD ROM TOOLS GRAPHICS c64 font 05 16b bmp Figure 22
426. ve highlighted the special function needed to access FLASH based storage the pgm read byte function This is all you need to get to the bytes of the FLASH with a pointer The remainder of the main program is more or less printing strings with timing and a bit of conditional logic however there is one function that is the workhorse of the program and that s the Get String function When programming most programmers are completely oblivious to the underlying code in printf or scanf and so forth but in embedded systems we can t use these calls since they usually have no meaning and we need to write them ourselves Alas in this case we need some kind of simple single line text editor so the user can type on the screen backspace etc and do a few reasonable edit related keystrokes The terminal program has no idea about this and nor does the UART the UART just receives ASCII characters thus we need to write a single line text processor to make this work The function listing of this code is below nt Get String char cmd buff char tokens MCAT EEE EEE this function waits for the user to input a string on from the UART it supports some editing such as backspace When the user hits return the string is tokenized into an array 230 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit i ieee tokens The number of tokens extracted are returned by the fu
427. vel I2C and SPI peripheral driver a Input Output Devices Modules CHAM PIC MOUSE DRV VO010 c h PS 2 mouse driver CHAM PIC KEYBOARD DRV V010 c h PS 2 keyboard driver CHAM PIC PROP PORT DRV VO010 c h Propeller local 8 bit driver MERE Storage Device Modules E CHAM PIC FLASH V010 c h 1MB SPI FLASH memory chip driver 137 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Mechatronics Actuator and Sensor Modules When building applications using the Chameleon PIC drivers you will typically include the System module always and then include various modules such as video keyboard UART etc as needed by your application All the C and Header files are located on the DVD here for reference DVD ROM CHAM SOURCE In the section below we will briefly cover each one of these libraries and the functions within them Before we get started let s take a look at the big picture illustrating all the components of the Chameleon PIC development suite of software and tools Figure 17 1 shows a system level architecture diagram of all the pieces involved Figure 17 1 System level architecture of the Chameleon API and other library modules User Applications Application Layer High Level AVR LibC System API API Layer APIs Running on Client Master AVR PIC Graphics API Input Devic
428. vel object TV_Text_Half_Height_011 spin Dii lt gt VGA_Text_010 spin Q E E c t a o SSO iia Bx keyboard 010 spin 2s gt d og mouse 010 spin 99 a lo D D Optional There isn t much to say about the drivers used on the project other than went to the Parallax Object Exchange located here http obex parallax com objects and hunted around for appropriate objects to use for this project based on my experience with developing objects and using them The objects aren t the fastest the coolest or the best necessarily they just work and get the job done and in most cases are the reference objects developed by Parallax initially with small changes by myself and other authors The idea was to have the NTSC VGA audio and keyboard mouse all running at the same time and be able to access these devices In the future you might want to use other objects or improve these for more specific needs In any event referring to Figure 16 5 The objects used are shown in Table 16 2 Function MCP master control program 1 11 CHAM DEFAULT2 DRV112 spin NTSC VGA 1 0 VGA Text 010 spin Audio 2 NS_sound_drv_052_11khz_16bit spin 1 2 Serial FullDuplexSerial_drv_012 spin PS 2 Keyboard 1 0 keyboard_010 spin PS 2 Mouse Table 16 2 Objects used for the Chameleon default MCP drivers Version Top object file name 1 1 CHAM GFX DRV 001 TB 001 spin TV Text Hal
429. ver the point is to use them together than leverage their strong points the PIC s simple programming model C support huge library of software and customer base along with the multicore support of the Propeller and its ability to run multiple tasks at once as well as its special ability to generate video With that in mind now let s discuss every one of the hardware modules in the design 27 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Part Hardware Design Primer In this section we are going to cover every one of the Chameleon PIC s hardware sub sections so you can get an idea of what s going on and how the systems and signals are routed Taken as a whole the Chameleon is rather complex but as you will see each individual sub system is rather straightforward Let s begin with a bird s eye view of the entire system schematic on the next page in landscape mode given in Figure 2 0 a Please take a good look at it and see if you can locate the PIC Propeller FLASH memory EEPROM and power supplies to help with our discussions Then right under it in Figure 2 0 b is a PCB view so you can see where everything is as well as a clear view of the I O headers in black and white with high contrast The board is so small it s a bit hard to see things 28 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit Figure 2 0 a The complete Chameleon PIC 16 bit schematic
430. ware The software costs 895 at the time of this writing Well beyond the range of any hobbyist Like said let s all hope for an early release of Microchip s C compiler for the PIC24 that we can use as a student version for free In order to acquire the HI TECH C compiler for a 45 day trial you will need to register on the HI TECH website 255 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit www htsoft com Registration is free and after you have registered you will receive a User ID in an email Use this User ID to login to their website and navigate to the downloads section and download the relevant compiler for your platform be it Linux or Mac OS X or even Windows One nice thing is that you can also try out their IDE software called HI TIDE and use that in place of MPLAB or you can just stick with the command line tools as well HI TIDE is built on top of the Eclipse IDE that is quickly becoming the standard development tool used by many companies A picture of HI TIDE 3 running on Mac OS X can be seen in Figure G 1 Figure G 1 HI TIDE 3 running on Mac OS X Eclipse File Edit Navigate Search Project Tools Run Window Help 4 Thu 10 53 Administrator HI TECH C init c HI TIDE 19 0 4197 2 18 8 ci bero S C C Projects 22 Navigator 8 fd El Outline 33 ERIS Y US HI TIDE on Mac O5 X gt init CONFIG RC WDTEN amp PWRTDIS
431. whatever Of course the PIC itself has all its headers But give the Propeller a direct port itself allows drivers running on the Propeller to do more stuff Anyway that s what the Propeller 8 bit port is all about And this simple demo shows how to set the I O pin directions and blink and LED All we need is the Propeller Port API library and an LED to plug into the Propeller port which we happen to supply with your Chameleon Now you might have a red green blue or bi color LED Doesn t matter which just plug it into the 2 left most pin headers of the Propeller Port as shown in Figure 31 1 below Figure 31 1 A screen shot of the NTSC output left and the actual LED blinking on the Chameleon right 225 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit A 6900000 7777777 777 o lt gt ro gt betes i i i i i i i i iti i i ti i i ti ti ti i i i i 1 2 tddddddddddddddddddddad TITTITTTTITITIITIITTIIIIS 7737377777777 Compiling and Running the MPLAB TextPad Bootloader Version Demo Version Description Blinks and LED on the Propeller Port Main Source File CHAM PIC PROPPORT DEMO 01 Additional Files Required CHAM PIC SYSTEM V010 c h CHAM PIC I2C SPI DRV VO010 c h CHAM PIC NTSC DRV VO010 c h CHAM PIC PROP PORT DRV VO010 h General Requirements Video port
432. while 1 ch UART getc if ch 1 ch CHR CTRLZ break end while xpacketnumn ch if DEBUG XMODEM gt 2 sprintf sbuffer Packetn 255 packet d r xpacketnumn NTSC Term Print sbuffer dendi f now get the packe xchecksum computed 0 i f DEBUG XMODEM gt 2 235 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit NTSC Term Print DATA NTSC Term Char 0x0D dendi f for index 0 index lt 128 index xt byte UART getc if ch 1 ch CHR CTRLZ break end while sert into buffer if index xpacketnum e buffer index x pdate checksum Cksum computed ch i f DEBUG XMODEM gt 1 test for printable if ch gt 32 amp amp ch lt 127 0 00 NTSC Term Char ch VGA Term Char ch IT end if printable else non printable character print something for place holder TSE ew Chart s ye A Teri chart v ps and else non printable endi f end for index add bytes read xbytes read 128 ad th ecksum 1 UART getc if ch 1 ch CHR_CTRLZ break end while SU EX UI i c whi C xchecksum c DEBUG XMODEM gt 2 NTSC_Term Char 0 sprintf sbuffer C NTSC Term Print s NTSC Term Char 0x ea 9 C Jus Sent d Calc d r xchecksum xchecksum computed endi f send the A xstate XSTA break l packet was good
433. with the lack of precision can be handled by use of fixed point arithmetic and a little numerical trick We are going to scale all the math by 8 bits or in essence multiply by 256 then we are going to create two variables one called a phase accumulator PHASE_ACC and one called a phase increment PHASE_INC Then instead of using count down algorithms we are going to simply add the phase increment to the phase accumulator and use the phase accumulator as an index into the sine table Therefore what we have done is turned out 256 element sine table into a virtual 256 256 65536 element sine table for math purposes to give us more accuracy for slower non integral waveforms as well as allow fast waveforms to index and skip elements in the look up table so a possible setup is something like this The Phase Accumulator 16 bit b15 b14 613 612 611 610 b9 b8 b7 b6 65 64 b3 62 bl 60 615 68 used as index value Now we have two interesting properties first no matter what the index in the upper 8 bits can never exceed 255 so we can never go out of bounds of our table secondly we can put very small numbers into the phase accumulator via that phase increment variable So now the algorithm for PWM sound is simple Step 1 Run the PWM at the output frequency 256 000 Hz Step 2 Calculate the Phase Increment PHASE_INC to add to the Phase Accumulator PHASE_ACC such that the final desired signal freque
434. y for MPLAB and PICkit 2 to work together and if you are still with me then everything must have went correctly At this point we have to set up the tools themselves which includes a lot of detail highly recommended you first skim over this section then return back to this point This way you have an idea of what s coming If you make mistakes during the setup process they are easy to fix if you Know you made them but very hard if you don t Thus take a few moments to skim the screen shots then return here and we set things up for real Alright we are going to approach all development with the Chameleon PIC as simple as possible To that end we need to create a single project to work with then for each demo we will simply include the source files in the source tree that the demo needs and remove ones it doesn t This way we don t have dozens of projects hundreds of directories and a big mess The primary steps that we must follow are Create a new project using MPLAB s Project Wizard Add all the necessary demo files to the new project Compile the demo Load the compiled binary into the flash on the PIC24 processor Release the processor from reset and verify operation Before we go over the actual steps of creating a demo project we first need to copy all of the demo files and Chameleon PIC API libraries from the DVD ROM to your local hard drive Do this by opening up Windows Explorer and either copy or drag the entire source
435. you can choose the destination folder for Microchip s MPLAB suggest you leave it as the default location located under C Program Files Microchip The reason being that we will install other tools that use the default path for MPLAB as their first choice for installation So why not make it easier on ourselves and install where Microchip likes it Click lt Next gt to move onto the customizing install dialog Figure 15 6 Customizing install features and tools MPLAB Tools v8 15 Select Features Select the features setup will install KX MICROCHIP Select the features you want to install and deselect the features you do not want to install EE Microchip Device Support Description ga 8 bit MCUs Select the microcontroller 16 bit MCUs 3 groups you are using gg 32 bit MCUs Third Party Applications CCS Full Install Microchip Applications Procmd r31PM3Cmd 0 00 MB of space required on the C drive 5363 73 MB of space available on the C drive lt Back Cancel Figure 15 6 presents a selection tree to us with a number of additional tools we can choose to install or remove If we would have chosen complete install all of these items would have been checked The most important options to have selected are Microchip Device Support gt 16 bit MCUs and Microchip Applications gt PICkit 2 everything else can be selected if you are going to use MPLAB for other projects than jus
436. you compile and run this program you will see the status LED blink on and off as well as the NTSC monitor display messages As you can see it s very simple to add new functionality to the driver and if you are careful and make sure not to re use message ids then you can deploy your new driver for other Chameleon users both AVR and PIC and they can use the driver without change in their Chameleons and all their old programs will still work but your new functionality will be at their finger tips 247 2009 NURVE NETWORKS LLC Exploring the Chameleon PIC 16 Bit 34 1 Advanced Concepts Ideas There is so much you do with the Chameleon don t even know where to begin But some of the things you might want to try are Using the Propeller as the Master and writing a driver on the PIC chip so the Propeller can use its resources peripherals etc The Propeller has a local 8 bit port you can use this for anything One idea that is really easy to implement is adding a micro SD card adapter to it Sparkfun sells a little adapter that is mounted on a right angle header that will plug right into the 8 bit Propeller port You can then get a SD card object add some messages to the master control program driver and presto you have a FLASH hard drive you can access from the PIC chip Networking the Chameleons together The Chameleons are so small and powerful a cool idea would be to network 4 8 of them together
437. you just got your Chameleon PIC it comes pre FLASHED with a the Microchip bootloader and you can use method 2 to run all the experiments If on the other hand you prefer a more robust tool like the Microchip MPLAB IDE and you have purchases the PICkit 2 programmer or similar then you can compile and program the Chameleon PIC via the 6 pin ISP port Both methods and setups were covered earlier in the manual But let s briefly review a couple details about the differences between the MPLAB and bootloader version of each demo 27 1 1 Differences Between the MPLAB and Bootloader Demos Before we get into the pre setup of MPLAB and the TextPad Bootloader tool let s take a step back and discuss the similarities and differences between the two tools and software as you write it First off we previously discussed the setup of MPLAB IDE and the TextPad bootloader in the previous sections so refer to this if need be Both the MPLAB IDE and TextPad make use of the Microchip C compiler for PIC24 devices These were installed as standalone command line tools that you can use from a DOS terminal or from within an application For this reason the source code for either projects created in MPLAB or TextPad are 100 identical The difference between using the two tools are in the invocation of the compiler and the method for downloading into Flash Again this was discussed in previous sections of this manual 27 1 2 Setup for MPLAB Version of Demos The MPLAB ver

Chameleon PIC User Manual Ver 1 ().

Contents

Download Pdf Manuals

Related Search

Related Contents