Toggle Navigation ReadkonG
Home Read Create Sign In Join Us Search CC5X User's Manual C Compiler for the PIC Microcontrollers Page created by Laurie Robbins Travel English
Like Share Embed Fullscreen Slides Download HTML Download PDF Abuse ← CONTINUE READING
→ Page content transcription If your browser does not render page correctly, please read the page content below CC5X C Compiler for the PIC Microcontrollers Version 3.0 User's Manual B. Knudsen Data Trondheim - Norway CC5X C Compiler B. Knudsen Data This manual and the CC5X compiler is protected by Norwegian copyright laws and thus by corresponding copyright laws agreed internationally by mutual consent. The manual and the compiler may not be copied, partially or as a whole without the written consent from the author. The PDF-edition of the manual can be printed to paper for private or local use, but not for distribution. Modification of the manual or the compiler is strongly prohibited. All rights reserved. LICENSE AGREEMENT: By using the CC5X compiler, you agree to be bound by this agreement. Only one person may use the CC5X compiler at the same time with this default single license. If more than one person want to use the compiler, then this have to be done by some manual handshaking procedure (not electronic automated), for instance by exchanging this manual as a permission key. You may make backup copies of the software, and copy it to multiple computers. You may not distribute copies of the compiler to others. B Knudsen Data assumes no responsibility for errors or defects in this manual or in the compiler. This also applies to problems caused by such errors. Copyright © B. Knudsen Data, Trondheim, Norway, 1992 - 1999 This manual covers CC5X version 3.0 and related topics. New versions may contain changes without prior notice. Microchip and PICmicro are trademarks of Microchip Technology Inc., Chandler, U.S.A. COMPILER BUG REPORTS: The compiler has been carefully tested and debugged. It is, however, not possible to guarantee a 100 % error free product. If the compiler generates application code bugs, it is almost always possible to rewrite the program slightly in order to avoid the bug. #pragma optimize can used to avoid optimization bugs. Other #pragma statements are also useful. Please report cases of bad generated code and other serious program errors. 1) Investigate and describe the problem. If possible, please provide a short code sample which demonstrates the problem. A fragment of the generated assembly file (use cut and paste) is normally enough. Alternatively a short and complete C program (10 - 50 lines). 2) This service is intended for difficult compiler problems (not application problems). 3) Language: English 4) State the compiler version, serial number and your distributor. 5) Send your report to
[email protected] or by fax to (+47) 73 96 51 84. Note that it is ONLY bug and serious problem reports that should be sent directly to B. Knudsen Data. Other support requests should be sent to your distributor for the fastest response. 2 CC5X C Compiler B. Knudsen Data CONTENTS 1 INTRODUCTION ..................................................................................................................................6 1.1 SUPPORTED DEVICES ..........................................................................................................................6 1.2 INSTALLATION AND SYSTEM REQUIREMENTS ....................................................................................7 User Interface.......................................................................................................................................7 1.3 MPLAB SUPPORT ..............................................................................................................................7 1.4 SUMMARY OF DELIVERED FILES .........................................................................................................8 1.5 SHORT PROGRAM EXAMPLE ...............................................................................................................9 1.6 WHAT TO DO NEXT ...........................................................................................................................10 2 VARIABLES.........................................................................................................................................11 2.1 INFORMATION ON RAM ALLOCATION ..............................................................................................11 2.2 DEFINING VARIABLES ......................................................................................................................11 Assigning variables directly to RAM addresses .................................................................................12 Supported type modifiers....................................................................................................................13 2.3 LOCAL VARIABLES ...........................................................................................................................14 2.4 USING RAM BANKS.........................................................................................................................14 2.5 RAM BANK SELECTION BITS...........................................................................................................15 Local user update regions ..................................................................................................................16 2.6 ARRAYS AND POINTERS ...................................................................................................................16 Arrays and Pointers on the 12 bit Core..............................................................................................16 Arrays and Pointers and the IRP bit ..................................................................................................18 2.7 TEMPORARY VARIABLES ..................................................................................................................19 2.8 STRUCTURES AND UNIONS ...............................................................................................................19 Bitfields...............................................................................................................................................20 Typedef ...............................................................................................................................................20 3 SYNTAX................................................................................................................................................21 3.1 STATEMENTS ....................................................................................................................................21 if statement .........................................................................................................................................21 while statement ...................................................................................................................................21 for statement .......................................................................................................................................21 do statement........................................................................................................................................22 switch statement..................................................................................................................................22 break statement...................................................................................................................................22 continue statement..............................................................................................................................23 return statement..................................................................................................................................23 goto statement.....................................................................................................................................23 3.2 ASSIGNMENT AND CONDITIONS .......................................................................................................23 Conditions ..........................................................................................................................................24 Precedence of C operators .................................................................................................................24 Multiplication, division and modulo...................................................................................................24 3.3 CONSTANTS ......................................................................................................................................25 Constant Expressions .........................................................................................................................25 Enumeration .......................................................................................................................................26 3.4 FUNCTIONS .......................................................................................................................................26 Function definitions............................................................................................................................26 Parameters in function calls...............................................................................................................26 Function calls .....................................................................................................................................26 Internal functions ...............................................................................................................................26 3.5 TYPE CAST .......................................................................................................................................27 3.6 DIRECT BIT ACCESS..........................................................................................................................28 3.7 C EXTENSIONS .................................................................................................................................29 3 CC5X C Compiler B. Knudsen Data 3.8 PREDEFINED SYMBOLS .....................................................................................................................29 3.9 UPWARD COMPATIBILITY.................................................................................................................30 4 PREPROCESSOR DIRECTIVES ......................................................................................................31 #define ................................................................................................................................................31 #include ..............................................................................................................................................31 #undef .................................................................................................................................................31 #if........................................................................................................................................................31 #ifdef...................................................................................................................................................32 #ifndef.................................................................................................................................................32 #elif.....................................................................................................................................................32 #else....................................................................................................................................................32 endif....................................................................................................................................................32 #error .................................................................................................................................................32 #pragma .............................................................................................................................................32 4.1 THE PRAGMA STATEMENT ................................................................................................................32 #pragma assert [/] .............................................................................................33 #pragma assume * in rambank .................................................................................34 #pragma bit @ ...............................................................................34 #pragma char @ ...........................................................................34 #pragma chip [=] PIC16C ........................................................................................................34 #pragma codepage [=] .....................................................................................................35 #pragma computedGoto [=] ................................................................................................35 #pragma config = [, = ]........................................................................35 #pragma config_def [=] ......................................................................................................35 #pragma location [=] .....................................................................................................36 #pragma optimize [=] [N:] .....................................................................................................36 #pragma origin [=] ....................................................................................................................36 #pragma rambank [=] ....................................................................................................36 #pragma rambase [=] ................................................................................................................37 #pragma ramdef : [MAPPING]......................................................................................37 #pragma resetVector ..................................................................................................................37 #pragma return[] = ...............................................................................38 #pragma stackLevels ..................................................................................................................38 #pragma update_FSR [=] .......................................................................................................38 #pragma update_IRP [=] .......................................................................................................38 #pragma update_PAGE [=] ...................................................................................................38 #pragma update_RP [=] .........................................................................................................39 4.2 DEFINING NEW CHIPS ......................................................................................................................39 Interrupt Register Save Style ..............................................................................................................41 How to make a new header file ..........................................................................................................41 4.3 PICMICRO CONFIGURATION .............................................................................................................42 5 COMMAND LINE OPTIONS ............................................................................................................44 5.1 OPTIONS ON A FILE ...........................................................................................................................46 6 PROGRAM CODE ..............................................................................................................................47 6.1 PROGRAM CODE PAGES....................................................................................................................47 Another way of locating functions ......................................................................................................47 Page selection bits..............................................................................................................................48 6.2 SUBROUTINE CALLS .........................................................................................................................48 Recursive functions.............................................................................................................................48 6.3 INTERRUPTS .....................................................................................................................................48 6.4 STARTUP AND TERMINATION CODE .................................................................................................49 Clearing ALL RAM locations .............................................................................................................50 6.5 INLINE ASSEMBLY ............................................................................................................................51 4 CC5X C Compiler B. Knudsen Data Generating Single Instructions...........................................................................................................54 6.6 OPTIMIZING ......................................................................................................................................55 7 DEBUGGING .......................................................................................................................................57 Debugging methods............................................................................................................................57 Compiler bugs ....................................................................................................................................57 7.1 COMPILATION ERRORS .....................................................................................................................57 Some common compilation problems .................................................................................................58 7.2 DEBUGGING SUPPORT ......................................................................................................................58 7.3 MPLAB SUPPORT ............................................................................................................................59 7.4 ASSERT STATEMENTS.......................................................................................................................60 7.5 DEBUGGING IN ANOTHER ENVIRONMENT ........................................................................................61 8 FILES PRODUCED.............................................................................................................................63 8.1 HEX FILE ..........................................................................................................................................63 8.2 ASSEMBLY OUTPUT FILE..................................................................................................................63 8.3 VARIABLE FILE ................................................................................................................................64 8.4 LIST FILE ..........................................................................................................................................65 8.5 FUNCTION CALL STRUCTURE ...........................................................................................................65 9 APPLICATION NOTES......................................................................................................................67 9.1 DELAYS ............................................................................................................................................67 9.2 COMPUTED GOTO .............................................................................................................................68 Computed Goto Regions.....................................................................................................................69 9.4 THE SWITCH STATEMENT..................................................................................................................72 APPENDIX ...............................................................................................................................................73 A1 USING INTERRUPTS ..........................................................................................................................73 A2 PREDEFINED REGISTER NAMES ........................................................................................................74 A3 ASSEMBLY INSTRUCTIONS................................................................................................................74 Addition for the 14 bit core ................................................................................................................75 Instruction execution time ..................................................................................................................75 5 CC5X C Compiler B. Knudsen Data 1 INTRODUCTION Welcome to the CC5X C compiler for the Microchip PICmicro family of microcontrollers. The CC5X compiler enables programming using a subset of the C language. Assembly is no longer required. The reason for moving to C is clear. Assembly language is generally hard to read and errors are easily produced. C enables the following advantages: • Source code standardization • Faster program development • Improved source code readability • Easier documentation • Simplified maintenance • Portable code The CC5X compiler was designed to generate tight and optimized code. The optimizer automatically squeezes the code to a minimum. It is possible to write code that compiles into single instructions, but with C syntax. This means that the code can be optimized by rewriting C instead of rewriting assembly. The design priority was not to provide full ANSI C support, but to enable best possible usage of the limited code and RAM resources. If the compiler generated less optimal code, this would force assembly to be used for parts of the code. CC5X features • Local and global variables of 1, 8, 16, 24 and 32 bit • Efficient reuse of local variable space • Generates tight and optimized code • Produces binary, assembly, list, COD, error, function outline and variable files • Automatic updating of the page selection bits • Automatic updating of the bank selection bits • Extended call level by using GOTO instead of CALL when possible • Inserts links to "hidden" subroutines • Access to all assembly instructions through corresponding C statements • Lookup tables: #pragma return[] = "Hello world" • Integrated interrupt support • Chip configuration info in source code 1.1 Supported devices 12 bit core (PIC16C5X, PIC12C50X, etc.): • up to 2048 words of code on 1 - 4 code pages • up to 73 byte RAM in 1 - 4 banks 14 bit core (PIC12C67X, PIC14000, PIC16CXX, etc.): • up to 8192 words of code on 1 - 4 code pages • up to 512 byte RAM in 1 - 4 banks 6 CC5X C Compiler B. Knudsen Data 1.2 Installation and System Requirements The CC5X compiler runs on IBM-PC compatible machines using MSDOS, including compatible platforms (Windows NT, Windows 95/98). There should be at least 400 kB of free RAM below the 640 kB limit. Large application programs may require more. Installing CC5X is done by first creating a directory/folder on the hard disk where the compiler files should be located. Then copy all CC5X files to this directory. CC5X is now ready to compile C files. Header and C source files have to be edited by a separate editor (not included), for instance in MPLAB. If you are mainly working in a MSDOS window, it may be useful to modify PATH in the AUTOEXEC.BAT file to allow the operating system to find the compiler from any directory (PATH ...;C:\CC5X;...). This is not a required step. The CC5X files can be deleted without any uninstallation procedure. User Interface The CC5X compiler is a command-line program. It requires a list of command line options to compile a C source file and produce the required files. Starting CC5X from Windows can be done by selecting the Start->Run menu. Then type the full path name including cc5x.exe (or use Browse). The list of compiler command line options are then written to the screen. The normal way of using CC5X is to use it as a tool from an integrate environment like MPLAB. Compiling a program (in a MSDOS window) requires a file name and command line options: cc5x -a sample1.c 1.3 MPLAB Support Installation: 1. First install CC5X as previously described. 2. Then copy the files *.MTC and *.INI from the CC5X folder (directory) to the MPLAB folder (this folder contains other .ini and .mtc files). 3. Next time MPLAB is started, select the Project->Install Language Tool menu item. Select CC5X from the Language Suite. Then the Tool Name (C-Compiler or C-Compiler FREE Edition). Then the right Executable (c:\cc5x\cc5x.exe or cc5xfree.exe). Also mark the Command-line box. Then click OK. CC5X will then be one of the selectable tools in MPLAB. 4. The free package contains 2 other demo tools that also is installed by repeating step 3 and combining Tool Name with the right Executable (DEMO 250 + cc5xdemo.exe, Full Test + cc5xtest.exe). The following is a brief description on how to use CC5X in a new project under MPLAB. Please refer to the help information available under MPLAB for a complete description. 1. Start MPLAB and create a new project (Project->New Project). Chose a project name (*.prj) and a directory where to locate this file and the other project files (C, H, HEX, ASM). Type or the OK button. 2. Edit Project is the next window. MPLAB suggests a Target Filename based on the project name. This is automatically changed during step 4. Include Path do not have to be specified. Library Path and Linker Script Path are not used anyway. Use Development Mode to select the processor and simulator/debugger (ignore any MPLAB warning at the current stage). Change Language Tool Suite to CC5X or CC5X free package (this is one of the menu items if the installation steps was completed). 7 CC5X C Compiler B. Knudsen Data 3. Double-click on the (target) name in the Project File box. A window named Node Properties pops up. The typical selections are already marked. Note that few processors are supported by a command line option. The alternative is to include the right processor header file in the C program. This may require the right Include Path (c:\cc5x). Click the OK button. 4. Click on the Add Node button. Type the name of the main C file or chose an existing C file (sample1.c). If the (sample) C file does not reside in the selected project directory, copy it to this directory first. Note that files included in the main C file (and nested include) can not be listed here. Click the OK button. 5. Open the main C file. Compile the file using Project->Make Project (F10). Project->Build Node (Alt- F10) requires that the main C file is in the current active window. Double-click on the error messages (if any) and correct the C code. Repeat the compilation until there are no error messages. Use Open file to inspect the generated files. The *.occ file contains compiler output information. IMPORTANT: If you selected the Error File command line option, then MPLAB will suppress the output from the compiler and display the content of the *.err file only. Change this option to the desired setting. It may be necessary to change some of the command line options (Processor, Hex Format) if MPLAB pops up a warning window. 6. CC5X allows simulation in C or assembly mode using the COD file. This is one of the compiler options: Debugging mode (C) or (ASM). Change the compiler options setting by selecting the Project->Edit project menu item. Double-click on the (target) file in the Project Files. Click OK. (If you need many command line options, use Options on file (On) and type the file name (op.inc). Create and edit this file using the text editor.) 7. Options->Development Mode can be used to set/change the debugging tool (MPLAB-SIM Simulator, SIMICE, Emulator, etc.). You are then ready to trace program execution. 1.4 Summary of delivered files 1) CC5X.EXE : compiler 2) CC5XFREE.EXE : compiler, free edition, up to 2048 instructions 2) CC5XDEMO.EXE : demo edition, 250 instructions, full optimization 2) CC5XTEST.EXE : demo edition, checks syntax and program size INTRO.TXT : introduction INSTALL.TXT : installation guide and MPLAB setup CC5X.TXT : basic documentation on CC5X PRAGMA.TXT : the pragma statement INLINE.TXT : information on inline assembly syntax DEBUG.TXT : debugging details, MPLAB support CHIP.TXT : how to make new chip definitions CONFIG.TXT : the PICmicro configuration bits GLOBDEF.TXT : PICmicro registers INT16CXX.H : interrupt header file INLINE.H : emulating inline instructions 1) CC5X.MTC : MPLAB tool configuration file 1) TLCC5X.INI : MPLAB tool configuration file 2) CC5XFREE.MTC : MPLAB tool configuration file 2) CC5XDEMO.MTC : MPLAB tool configuration file 2) CC5XTEST.MTC : MPLAB tool configuration file 2) TLCC5X-F.INI : MPLAB tool configuration file OP.INC : command line options on a file 8 CC5X C Compiler B. Knudsen Data SAMPLE1.C : minimal program example IICBUS.C : IIC-bus interface IIC-COM.C : IIC-bus communication SERIAL.C : serial communication (RS232, RS485) STATE.C : state machines DELAY.C : implementing delays INT16XX.C : simple interrupt example 12C508.H .. 16C924.H : PICmicro header files README.TXT 1) EXTENDED, STANDARD and RED edition 2) FREE edition only 1.5 Short Program Example /* global variables */ char a; bit b1, b2; /* assign names to port pins */ #pragma bit in @ PORTB.0 #pragma bit out @ PORTB.1 void sub( void) { char i; /* a local variable */ /* generate 20 pulses */ for ( i = 0; i < 20; i++) { out = 1; nop(); out = 0; } } void main( void) { // if (TO == 1 && PD == 1 /* power up */) { // WARM_RESET: // clearRAM(); // clear all RAM if required // } /* first decide the initial output level on the output port pins, and then define the input/output configuration. This avoids spikes at the output pins. */ PORTA = 0b.0010; /* out = 1 */ TRISA = 0b.1111.0001; /* xxxx 0001 */ a = 9; /* value assigned to global variable */ 9 CC5X C Compiler B. Knudsen Data do { if (in == 0) /* stop if 'in' is low */ break; sub(); } while ( -- a > 0); /* 9 iterations */ // if (some condition) // goto WARM_RESET; /* main is terminated by a SLEEP instruction */ } 1.6 What to do next It is important to know the PICmicro family and the tools well. The easiest way to start is to read the available documentation and experiment with the examples. Then move on to a simple project. Some suggestions: • study the supplied program samples • compile code fragments and check out what the compiler accepts • study the optional assembly file produced by the compiler Note that using more than one ram bank or code page requires pragma instructions. Typical steps when developing programs is as follows: • describe the system, make requirements • suggest solutions that satisfy these requirements • write detailed code in the C language • compile the program using the CC5X compiler • test the program on a prototype or a simulator Writing programs for the PICmicro microcontroller family requires careful planning. Program and RAM space are limited, and the key question is often: Will the application code fit into the selected controller ? 10 CC5X C Compiler B. Knudsen Data 2 VARIABLES The compiler prints information on the screen when compiling. Most important are error messages, and how much RAM and PROGRAM space the program requires. The same compiler output information is also written to file *.occ. Example: delay.c: Chip = 16C74 RAM: 00h : -------- -------- -------- -------- RAM: 20h : ==.***** ******** ******** ******** RAM: 40h : ******** ******** ******** ******** RAM: 60h : ******** ******** ******** ******** RAM: 80h : -------- -------- -------- -------- RAM: A0h : ******** ******** ******** ******** RAM: C0h : ******** ******** ******** ******** RAM: E0h : ******** ******** ******** ******** Optimizing - removed 11 instructions (-14 %) File 'delay.asm' Codepage 0 has 68 word(s) : 3 % Codepage 1 has 0 word(s) : 0 % File 'delay.hex' Total of 68 instructions (1 %) 2.1 Information on RAM allocation The compiler prints information on RAM allocation. This map is useful to check out which RAM locations are still free. The map for the 16C57 chip may look like this: Mapped RAM: 00h : -------- .7.-**** Bank 0 RAM: 10h : ====4==* ******** Bank 1 RAM: 30h : ..6***** ******** Bank 2 RAM: 50h : ******** ******** Bank 3 RAM: 70h : -7****** ******** Symbols: * : free location - : predefined or pragma variable = : local variable(s) . : global variable 7 : 7 free bits in this location 16C71 map: RAM: 00h : -------- ----==== ==3.7... ******** RAM: 20h : ******** ******** 2.2 Defining Variables The following variable sizes are implemented: 1, 8, 16, 24 and 32 bit. The default int size is 8 bit, and long is 16 bit. The larger variable sizes of 24 and 32 bit have to be defined by new types. Note that 24 and 32 bit variables are not supported by all CC5X editions. unsigned a8; // 8 bit unsigned char a8; // 8 bit unsigned unsigned long i16; // 16 bit unsigned 11 CC5X C Compiler B. Knudsen Data int i; // 8 bit signed signed char sc; // 8 bit signed long i16; // 16 bit signed uns8 u8; // 8 bit unsigned uns16 u16; // 16 bit unsigned uns24 u24; // 24 bit unsigned uns32 u32; // 32 bit unsigned int8 s8; // 8 bit signed int16 s16; // 16 bit signed int24 s24; // 24 bit signed int32 s32; // 32 bit signed The bitfield syntax can also be used: unsigned x : 24; // 24 bit unsigned int y : 16; // 16 bit signed The value range of the variables are: TYPE SIZE MIN MAX ---- ---- --- --- int8 1 -128 127 int16 2 -32768 32767 int24 3 -8388608 8388607 int32 4 -2147483648 2147483647 uns8 1 0 255 uns16 2 0 65535 uns24 3 0 16777215 uns32 4 0 4294967295 Note that CC5X use (store) LOW ORDER FIRST. This means that the least significant byte of a variable is assigned to the lowest address. Char variables are unsigned by default and range from 0 to 255. Bit variables are either 0 or 1. char varX; char counter, L_byte, H_byte; bit ready; bit flag, stop, semafor; All variables are allocated from low RAM addresses and upwards. Each location can contain 8 bit variables. Address regions used for special purpose registers are not available for normal allocation. An error message is produced when there is no space left. Special purpose registers are either predefined or defined in chip-specific header files. This applies to W, INDF, TMR0, PCL, STATUS, FSR, Carry, PD, TO, etc. Assigning variables directly to RAM addresses All variables, including structures and arrays can be assigned to fixed address locations. This is useful for assigning names to port pins. It is also possible to assign overlapping variables (similar to union). The syntax is: @ ; 12 CC5X C Compiler B. Knudsen Data @ ; bit @ .; bit @ .; Examples: char th @ 0x25; //bit th1 @ 0x25.1; // warning on this bit th1 @ th.1; // no warning char tty; bit b0; char io @ tty; bit bx0 @ b0; bit bx2b @ tty.7; //char tui @ b0; // size exceeded //long r @ tty; // size exceeded char tab[5]; long tr @ tab; struct { long tiM; long uu; } ham @ tab; Pragma statements can also be used: #pragma char port @ PORTC #pragma char varX @ 0x23 #pragma bit IOpin @ PORTA.1 #pragma bit ready @ 0x20.2 #pragma bit ready @ PA2 If the compiler detects double assignments to the same RAM location, this will cause a warning to be printed. The warning can be avoided if the second assignment use the variable name from the first assignment instead of the address (#pragma char var2 @ var1). An alternative is to use the #define statement: #define PORTX PORTC #define ready PA2 Priority when allocating variables: 1. Variables permanently assigned to a location 2. Local variables allocated by the compiler 3. Global variables allocated by the compiler Supported type modifiers static char a; /* a global variable; known in the current module only, or having the same name scope as local variables when used in a local block */ extern char a; // a global variable // defined another place auto char a; // a local variable // ('auto' is normally not used) 13 CC5X C Compiler B. Knudsen Data register char a; // local variable or parameter // currently ignored const char a; // ‘const’ is currently ignored; // a warning is printed volatile char a; // ‘volatile’ is currently ignored; // a warning is printed 2.3 Local Variables Local variables are supported. The compiler performs a safe compression by checking the scope of the variables and reusing the locations when possible. The limited RAM space in therefore used efficiently. This feature is very useful, because deciding which variables can safely overlap is time consuming, especially during program redesign. Function parameters are located together with local variables. Variables should be defined in the innermost block, because this allows best reuse of RAM locations. It is also possible to add inner blocks just to reduce the scope of the variables as shown in the following example: void main(void) { char i; /* no reuse is possible at the outermost level of 'main' */ i = 9; { char a; // an inner block is added for (a = 0; a != 0;) a = PORTB; i += a; } sub(i); } In some rare situations, global variables can be more efficient than local variables. However, this will require hard work. NOTE: local variables may have the same name. However, the compiler adds an extension to produce an unique name in the assembly, list and COD files. NOTE: When a function is not called (defined but not in use), then all parameters and local variables are truncated to the same (unused) location. 2.4 Using RAM Banks Using more than one RAM bank is done by setting the active rambank: /* variables proceeding the first rambank statement are placed in mapped RAM or bank 0. This is also valid for local variables and parameters */ #pragma rambank 1 char a,b,c; /* a,b and c are located in bank 1 */ /* parameters and local variables in functions placed here are also located in bank 1 ! */ 14 CC5X C Compiler B. Knudsen Data #pragma rambank 0 char d; /* located in bank 0 */ The compiler automatically finds the first free location in the selected bank. NOTE: Local variables and function parameters also have to be located. It may be necessary to use #pragma rambank between some of the functions and even INSIDE a function. The recommended strategy is to locate local variables and function parameters in mapped RAM or bank 0. Mapped RAM is selected by: #pragma rambank - Using RAM banks requires some planning. The optimal placement requires least code to update the bank selection bits. Some advise when locating variables: 1. Try to locate variables which are close related to each other in the same bank. 2. Try to locate all variables accessed in the same function in the same bank. 3. Switching between bank 0 and 3, or bank 1 and 2 require more instructions than the other combinations. 4. Use as few banks as possible. Fill bank 0 first, then bank 1, etc. 5. Remember that local variables and function parameters also may require updating of the bank selection bits. 2.5 RAM Bank Selection Bits RAM and special purpose registers can be located in up to 4 banks. The 12 bit core uses bit 5 and 6 in FSR to select the right bank. In the 14 bit core, RP0 and RP1 in the STATUS register are used for this purpose. The bank selection bits are automatically checked and updated by the compiler, and attempts to set or clear these bits in the source code are removed by the compiler. This feature can be switched off which means that updating has to be done in the source code. The compiler uses global optimizing techniques to minimize the extra code needed to update the bank selection bits. Removing all unnecessary updating is difficult. However, there should be few redundant instructions. The compiler inserts the following instructions: BCF 04h,FSR_5 // 12 bit core (16C57,58,..) BSF 04h,FSR_5 // 12 bit core (16C57,58,..) BCF 04h,FSR_6 // 12 bit core (16C57,58,..) BSF 04h,FSR_6 // 12 bit core (16C57,58,..) CLRF FSR // 12 bit core (16C57,58,..) BCF 03h,RP0 // 14 bit core BSF 03h,RP0 // 14 bit core BCF 03h,RP1 // 14 bit core BSF 03h,RP1 // 14 bit core NOTE: The compiler REMOVES all bank updating done by the user. Actually all of the above stated instructions are removed. It is therefore possible to switch between manual and automatic updating by setting or removing the -b command line option. 15 CC5X C Compiler B. Knudsen Data Local user update regions The automatic updating can be switched off locally. This is done by pragma statements: #pragma update_FSR 0 /* OFF, 12 bit core */ #pragma update_FSR 1 /* ON, 12 bit core */ #pragma update_RP 0 /* OFF, 14 bit core */ #pragma update_RP 1 /* ON, 14 bit core */ These statements can be inserted anywhere, but they should surround a smallest possible region. Please check the generated assembly code to ensure that the desired results is achieved. NOTE: The safest coding is to not assume any specific contents of the bank selection bits when a local update region is started. The compiler uses complex rules to update the bank selection bits outside the local regions. Also, all updating inside a local update region is traced to enable optimal updating when the region ends. 2.6 Arrays and Pointers One dimensional arrays and single level pointers is implemented. Note that pointer and indexed arithmetic is currently limited to 8 bit. Assignment is allowed for 8, 16, 24 and 32 bit. char t[10], i, index, *p, x, temp; uns16 tx[3]; tx[i] = 10000; t[1] = t[i] * 20; // ok t[i] = t[x] * 20; // not allowed temp = t[x] * 20; t[i] = temp; p = &t[1]; *p = 100; p[2] ++; The equivalent of a (small) multidimensional array can be constructed by using a structure. However, only one index can be a variable. struct { char e[4]; char i; } multi[5]; multi[x].e[3] = 4; multi[2].e[i+1] += temp; Arrays and Pointers on the 12 bit Core Indirect RAM access on the 16C57/58/12C509 requires some care because the RAM bank selection bits resides in the FSR register (bit 5,6). The compiler can do most of the checking. Error messages are generated when the stated limitations are exceeded. 16 CC5X C Compiler B. Knudsen Data NOTE: Automatic bankbit updating can be switched off globally (-b command line option), or locally (#pragma update_FSR 0). Most of the checking described is performed only if the automatic bankbit updating in ON. Reading and writing arrays is straight forward: #pragma rambank 2 char a, e, t[3], s[3]; a = t[i]; s[i] = e; s[i+3] = e; The last three statements requires that variable e is located in mapped RAM (below 0x10) or in the same bank as array s[]. Otherwise an error message is printed to indicate that the compiler can not update the bank selection bits. Pointers may need a #pragma assume statement: #pragma rambank 3 char *px, r; #define LTAB 5 char tab[LTAB]; #pragma assume *px in rambank 3 px = &tab[0]; *px = r; if (++px == &tab[LTAB]) px = &tab[0]; A pointer may access more than one bank. The #pragma assume statement should NOT be used in such cases. The only difference is that the compiler will know the contents of the FSR.5,6 when a variable in a specific bank is accessed. Therefore, a statement like: *pointer_to_any_rambank = e; requires that e in located in mapped RAM (address less than 0x10). Note that the #pragma assume statement works for single pointers (and pointers in arrays), but not for pointers located in structures. Arrays are often more efficient than pointers: i = 0; // .. tab[i] = r; if (++i == LTAB) i = 0; Direct use of INDF and FSR is still possible: FSR = px; INDF = i; 17 CC5X C Compiler B. Knudsen Data Variable i have to reside in mapped RAM. The compiler performs the checking when INDF is accessed. The compiler does not try to trace the contents of FSR when it is loaded directly. Therefore, a statement like *px = r; is normally preferred. Using #pragma assume *px in rambank 3 also makes loading of px more restrictive. An error message is printed if px is loaded with an address in another bank. The following cases are checked: px = tab; // same as &tab[0] px = &tab[0]; px = &tab[i]; px = pxx; // pxx is another pointer px = &pxx[i]; A statement like px = &tab[i]; may fool the compiler if the value of i is too large. If the above syntax is too restrictive, then a local update region is the solution. All rambank updating then have to be done with C statements. Normally, local update regions requires inspection of the generated assembly file to avoid problems. /* these statements clears the buffer */ i = LTAB; #pragma update_FSR 0 /* OFF */ FSR = &tab[0]; do { INDF = 0; FSR ++; } while (--i > 0); #pragma update_FSR 1 /* ON */ Without a local update region: i = LTAB; do tab[i-1] = 0; while (--i > 0); In this example, the local update region only has a speed advantage. The same amount of instructions are generated. Note that although no rambank updating is required inside the above local region, the compiler does not know the contents of FSR.5,6 at the end of the region, and will therefore update these bits afterwards. Arrays and Pointers and the IRP bit For some 14 bit core chips, rambank 2 and 3 is in use. This means that register bit IRP have to be updated in user code when working with arrays and tables. This is valid for PIC16C66/67/76/77 and similar. #pragma rambank 2 char array[50]; char x; FSR = &array % 256 + x; // LSB of &array[x] IRP = &array / 256; // MSB NOTE: IRP is not updated by the compiler if INDF is used directly in the user code. Using array[x] instead of INDF enables automatic update of the IRP bit. 18 CC5X C Compiler B. Knudsen Data It is simplest to locate all arrays in rambank 0/1 or rambank 2/3. Then IRP can be set to 0 or 1 permanently. Otherwise it has to be updated according to the actual rambank used. Pointers may need a #pragma assume statement: #pragma rambank 1 char t[3]; #pragma rambank 3 char i, *pi, *pit; #pragma assume *pi in rambank 3 // or rambank 2 #pragma assume *pit in rambank 1 // or rambank 0 pi = &i; pit = &t[2]; Note that the compiler uses AUTOMATIC assume if the #pragma assume is missing in the user code. The compiler then assumes that the pointer access a table in the same RAM half as the pointer is located. So, if the pointer is located at an address above 0x100, the IRP bit will be set to 1 which means that a table in the upper half of RAM is accessed. The first of the above #pragma assume statements is therefore not required, but it makes things clearer. An error message is printed if a pointer is loaded with an address from the wrong RAM half. Note that rambank 0 and 1 are grouped together (the lower RAM half, 0 - 0xFF). Rambank 2 and 3 are the upper RAM half (0x100 - 0x1FF). Updating of IRP can be switched off locally. Currently, the compiler does not remove superfluous updating of the IRP register. This means that IRP is updated for each pointer or table access. An efficient strategy may be to locate (most of) the tables in upper or lower RAM (above or below address 0x100), and do all updating of IRP in the user code. A few updates is normally sufficient. #pragma update_IRP 0 /* off */ .. IRP = 1; // updated by user code .. #pragma update_IRP 1 /* on (if required) */ 2.7 Temporary Variables Operations like multiplication, division, modulo division and shifts often require temporary variables. The advantage is that the compiler needs NO PERMANENT SPACE for temporary variables. The temporary variables are allocated the same way as local variables, but with a narrow scope. This means that the RAM locations can be reused in other parts of the program. This is an efficient strategy and often no extra space is required in application programs. Note that small test examples may show different results. 2.8 Structures and Unions Normal C structures can be defined, also nested types. Unions are allowed. struct hh { long a; char b; } vx1; 19 CC5X C Compiler B. Knudsen Data union { struct { char a; int16 i; } pp; char x[4]; uns32 l; } uni; vx1.a = -10000; uni.x[3] = vx1.b - 10; Bitfields Bitfields in structures are allowed. The size have to be 1, 8, 16, 24 or 32 bit. struct bitfield { unsigned a : 1; bit c; unsigned d : 32; char aa; } zz; The CC5X compiler also allows the bitfield syntax to be used outside structures as a general way of defining variable size: int x : 24; // a 24 bit signed variable Typedef typedef struct hh HH; typedef unsigned ux : 16; // equal to uns16 ux r, a, b; 20 CC5X C Compiler B. Knudsen Data 3 SYNTAX 3.1 Statements { ; .. ; } if, while, for, do, switch, break, continue, return, goto, , while (1) { k = 3; X: if (PORTA == 0) { for (i = 0; i < 10; i++) { pin_1 = 0; do { a = sample(); a = rr(a); s += a; } while (s < 200); } reg -= 1; } if (PORTA == 4) return 5; else if (count == 3) goto X; if (PORTB != 0) break; } if statement if () ; else if () ; else ; The else if and else parts are optional. while statement while () ; while (1) { .. } // infinite loop for statement for (; ; ) ; initialization: all legal assignments or empty condition: all legal conditions or empty increment: incrementing or decrementing a variable or empty 21 CC5X C Compiler B. Knudsen Data for (v = 0; v < 10; v++) { .. } for (; v < 10; v++) { .. } for (v = 0; ; v--) { .. } do statement do ; while (); switch statement switch () { case : ; .. ; break; case : ; .. ; break; case : ; .. ; break; .. default: ; .. ; break; } : all 8 bit variables including W break: optional default: optional, can be put in the middle of the switch statement switch (token) { case 2: i += 2; break; case 9: case 1: default: if (PORTA == 0x22) break; case 'P': pin1 = 0; i -= 2; break; } break statement Used inside loop statements (for, while, do) to terminate the loop. Also used in switch statements. while (1) { .. if (var == 5) break; .. } 22 CC5X C Compiler B. Knudsen Data continue statement Used inside loop statements (for, while, do) to force the next iteration of the loop to be executed, skipping any code in between. In while and do-while loops, the loop condition is executed next. In for loops, the increment is processed before the loop condition. for (i = 0; i < 10; i++) { .. if (i == 7) continue; .. } return statement return ; /* exits the current function */ return; /* no return value */ return 12; /* return constant */ goto statement goto ; Jumps to a location, forward or backward. goto XYZ; .. XYZ: .. 3.2 Assignment and Conditions = ; = ; ++; --; variable: of type 'bit' or 'char' operation: + - & | ^ * / % > value: or constant: 34 0xFF 'A' 0b01101111 var1 = x + y; W = W & 0x1F; i = x - 100; y ^= 'A'; /* y = y ^ 'A'; */ W |= 3; /* W = W | 3; */ flag = 1; /* bit variable */ i++; /* increment: i = i + 1; */ i--; /* decrement: i = i - 1; */ 23 CC5X C Compiler B. Knudsen Data Conditions [ ++ | -- ] [ && condition] [ || condition] cond-oper : == != > >= < 44 || Carry || x != z) .. if (--index > 0) .. if (bx == 1 || ++i < max) .. if (sub_1() != 0) .. Precedence of C operators Highest: ( ) ++ -- * / % + - > < >= == != & ^ | && || Lowest: = += -= *= /= etc. Mixed variable sizes are allowed: a32 = (uns32) b24 * c8; // 24 * 8 bit, result 32 bit a16 = a16 + b8; // 16 + 8 bit, result 16 bit Most combinations of variables are allowed, the compiler performs sign extension is required. Multiple operations in the same expression are allowed when using 8 bit variables. a8 = b8 + c8 + d8 + 10; Multiplication, division and modulo multiplication : a16 = b16 * c16; // 16 * 16 bit A general multiplication algorithm is implemented, which allows most combinations of variable sizes. Of course, the instruction consumption can be high. The algorithm makes shortcuts when possible, for instance when multiplying by 2. This is treated as a left shift. division : a16 = b16 / c8; // 16 / 8 bit modulo : a32 = b32 % c16; // 32 % 16 bit The division algorithm also allows most combinations of variable sizes. Shortcuts are made when dividing by 2 (or 2*2*..). These are treated as right shifts. 24 CC5X C Compiler B. Knudsen Data 3.3 Constants x = 34; /* decimal */ x = 0x22; /* hexadecimal */ x = 'A'; /* ASCII */ x = 0b010101; /* binary */ x = 0x1234 / 256; /* 0x12 : MSB */ x = 0x1234 % 256; /* 0x34 : LSB */ x = 3 + 4; /* 7 */ x = 3 - 4; /* 255 */ x = 3 * 4; /* 12 */ x = 33 / 4; /* 8 */ x = 33 % 4; /* 1 */ x = 0xF & 0xF3; /* 3 */ x = 0x2 | 0x8; /* 10 */ x = 0x2 ^ 0xF; /* 13 */ x = 0b10 > 2; /* 3 */ x = r1 + (3 * 8 - 2); /* 22 */ x = r1 + (3 + 99 + 67 - 2); /* 167 */ x = ((0xF & 0xF3) + 1) * 4; /* 16 */ Please note that parentheses are required in some cases. Constant Expressions The size of integers is by default 8 bits for this compiler (other compilers use typically 16 or 32 bits depending on the CPU capabilities). An error is printed if the constant expression looses significant bits because of value range limitations. char a; a = (10 * 100) / 256; // an error is printed a = (10L * 100) / 256; // no error a = ((uns16) 10 * 100) / 256; // no error a = (uns16) (10 * 100) / 256; // error again a = (10 * 200) / 256; /* no error, 200 is a long int by default */ Adding a L means conversion to long (16 bit). The command line option -cu force 32 bit evaluation of constants (upward compatibility) so that no upper bits are lost. Some new built in types can also be used: TYPE SIZE MIN MAX ---- ---- --- --- int8 : 8 bit signed 1 -128 127 int16: 16 bit signed 2 -32768 32767 int24: 24 bit signed 3 -8388608 8388607 int32: 32 bit signed 4 -2147483648 2147483647 uns8 : 8 bit unsigned 1 0 255 uns16: 16 bit unsigned 2 0 65535 uns24: 24 bit unsigned 3 0 16777215 uns32: 32 bit unsigned 4 0 4294967295 25 CC5X C Compiler B. Knudsen Data The constant type is by default the shortest signed integer. Adding an U behind a constant means that it is treated as unsigned. Note that constants above 0x7FFFFFFF are unsigned by default (with or without an U behind). Enumeration An enumeration is a set of named integer constants. It can often replace a number of #define statements. The numbering normally starts with 0, but this can be changed. enum { A1, A2, A3, A4 }; enum { alfa = 8, beta, zeta = -4, eps }; 3.4 Functions Function definitions char function3(char); /* prototype, useful when the function is called before it is defined */ void subroutine1(void); /* another prototype */ /* function definitions */ void subroutine2(char p) { .. } char function1(void) { .. } char function2(char W) { .. } void main(void) { .. } A function may have a 8 bit return value. This value is placed in register W. A function with no return value is of type void. Parameters in function calls There are no fixed limit on the number of parameters allowed in function calls. Space for parameters are allocated in the same way as local variables which allows efficient reuse. The bit type is also allowed. Note that if W is used, this has to be the LAST parameter. char func(char a, uns16 b, bit ob, char W); Function calls subroutine1(); subroutine2(24); W = function1(); x = function2(W); y = function4(function3(x)); Return values can be assigned to a variable or discarded. Internal functions btsc(Carry); // void btsc(char); - BTFSC f,b btss(bit2); // void btss(char); - BTFSS f,b clrwdt(); // void clrwdt(void); - CLRWDT clearRAM(); // void clearRAM(void); clears all RAM i = decsz(i); // char decsz(char); - DECFSZ f,d W = incsz(i); // char incsz(char); - INCFSZ f,d nop(); // void nop(void); - NOP retint(); // void retint(void); - RETFIE W = rl(i); // char rl(char); - RLF i,d i = rr(i); // char rr(char); - RRF i,d 26 You can also read
OCAS/OUAC FOR FALL 2018 - Secondary School Data Transmission Specification
One-Stop Source: A Global Database of Inflation - Munich ...
PLANS LESSON GUITAR - Little Kids Rock
Fight crime. Unravel incidents... one byte at a time - SANS Forensics
GNU GLOBAL Source Code Tag System - by Tama Communications Corporation
TECHNICAL SPECIFICATION FOR THE DELIVERY OF TELEVISION PROGRAMMES AS AS-11 FILES TO - Channel 4
Exploring the iPhone Backup Made by iTunes
ReproZip Documentation - Release 2.0.0 Fernando Chirigati, Remi Rampin, Juliana Freire, and Dennis Shasha
3 Heights PDF Optimizer Shell - Version 6.18.1 - User Manual
Competition and Consumer (Industry Codes-Franchising) Regulation 2014
InsectLore.uk - Butterflies and Nature for Parents and Teachers
CODE OF ETHICS 2020 edition - FIFA.com
Government & Politics English SUMMER on Stage - 2020 ROSE SUMMER CLASSES - The Rose Theater
GLOBAL P4P Pay for Performance (P4P) Program Guide
FIFA CODE OF ETHICS 2018 edition - FIFA.com
THE INDIAN PREMIER LEAGUE - Code of Conduct for Players and Team Officials Effective as from 21st March 2019 - AWS
Product Guide 2021 2022 - RAINWATER AND AGRICULTURE RANGE
A COMPARISON OF PERFORMANCE AND LOOKS BETWEEN FLUTTER AND NATIVE APPLICATIONS - DIVA
Idaho Ethics In Government Manual - Office of the Attorney General - JULY 2015
Community Archiving of Ethnic Groups in Thailand
Measurements of the water balance components of a large green roof in the greater Paris area
Secure Production Programming Solution (SPPS) User Guide - Microsemi
Microsoft Ignite 2018 - September 24-28 // Orlando, FL - Microsoft News Center
Feasibility Study for the Implementation of Algae Cell Monitoring in Raw Water Using an Optical Sonde at the Görväln Drinking Water Treatment ...
A Guide to the Dimensions Data Approach - Dimensions Report
Estimating 500-m Resolution Soil Moisture Using Sentinel-1 and Optical Data Synergy - MDPI
IIFA: Modular Inter-app Intent Information Flow Analysis of Android Applications
ASIA-PACIFIC INVESTIGATIONS REVIEW 2020 - Forensic Risk Alliance
Government & Politics English Tabulator: Exploring and Analyzing linked data on the Semantic Web
State of play of GIS usage in the Real Estate Industry James Culley
HTC Desire 616 dual sim - User guide
A generative adversarial network approach to (ensemble) weather prediction
Did COVID-19 infections decline before UK lockdown?
REGIONAL PLAN TO END HOMELESSNESS - MARICOPA REGIONAL CONTINUUM OF CARE 2018 - City of Chandler
Information Consolidation on Users of Social Networks to Determine Their Credibility
Hybrid Malware Classification Method Using Segmentation-Based Fractal Texture Analysis and Deep Convolution Neural Network Features - MDPI
Modeling, Monitoring, and Validating Green Roof and Green Facade Solutions with Semantic City Models Using Low Cost Sensors and Open Software ...
Core Vector Machines: Fast SVM Training on Very Large Data Sets
Analysis of what makes an Euroleague team successful through player clustering
Adoption of Blockchain in Health Care - JMIR
Digital Comms in 2020-21 - What the CharityComms Digital Benchmark tells us about charities' digital response to the coronavirus
Private AI: Machine Learning on Encrypted Data - Cryptology ...
GEO Initiative Global Wildfire Information System (GWIS) - Implementation Plan February 20th, 2019
The Alan Turing Institute Internship Programme 2018 - Amazon AWS
Toward Improving the Prediction Accuracy of Product Recommendation System Using Extreme Gradient Boosting and Encoding Approaches - MDPI
DigitalCommons@USU Utah State University
ORION OPEN SCIENCE FACTSHEETS - Brief, informative, and easy-to-understand one-page factsheets on Open Science topics
WASP: a versatile, web-accessible single cell RNA-Seq processing platform - BMC Genomics
Video-Capable Ultrasonic Wireless Communications Through Biological Tissues
Detecting and tracking drift in quantum information processors - Nature
× × Share this page with your friends Page URL to share Select All
× Embed this page to your web-site Select All
× Error occurred
× Please sign in for this action Sign In
Forgot password? If you don't have an account, please Join Us →
OCAS/OUAC FOR FALL 2018 - Secondary School Data Transmission Specification 
One-Stop Source: A Global Database of Inflation - Munich ... 
PLANS LESSON GUITAR - Little Kids Rock 
Fight crime. Unravel incidents... one byte at a time - SANS Forensics 
GNU GLOBAL Source Code Tag System - by Tama Communications Corporation 
TECHNICAL SPECIFICATION FOR THE DELIVERY OF TELEVISION PROGRAMMES AS AS-11 FILES TO - Channel 4 
Exploring the iPhone Backup Made by iTunes 
ReproZip Documentation - Release 2.0.0 Fernando Chirigati, Remi Rampin, Juliana Freire, and Dennis Shasha 
3 Heights PDF Optimizer Shell - Version 6.18.1 - User Manual 
Competition and Consumer (Industry Codes-Franchising) Regulation 2014 
InsectLore.uk - Butterflies and Nature for Parents and Teachers 
CODE OF ETHICS 2020 edition - FIFA.com 
SUMMER on Stage - 2020 ROSE SUMMER CLASSES - The Rose Theater 
GLOBAL P4P Pay for Performance (P4P) Program Guide 
FIFA CODE OF ETHICS 2018 edition - FIFA.com 
THE INDIAN PREMIER LEAGUE - Code of Conduct for Players and Team Officials Effective as from 21st March 2019 - AWS 
Product Guide 2021 2022 - RAINWATER AND AGRICULTURE RANGE 
A COMPARISON OF PERFORMANCE AND LOOKS BETWEEN FLUTTER AND NATIVE APPLICATIONS - DIVA 
Idaho Ethics In Government Manual - Office of the Attorney General - JULY 2015 
Community Archiving of Ethnic Groups in Thailand 
Measurements of the water balance components of a large green roof in the greater Paris area 
Secure Production Programming Solution (SPPS) User Guide - Microsemi 
Microsoft Ignite 2018 - September 24-28 // Orlando, FL - Microsoft News Center 
Feasibility Study for the Implementation of Algae Cell Monitoring in Raw Water Using an Optical Sonde at the Görväln Drinking Water Treatment ... 
A Guide to the Dimensions Data Approach - Dimensions Report 
Estimating 500-m Resolution Soil Moisture Using Sentinel-1 and Optical Data Synergy - MDPI 
IIFA: Modular Inter-app Intent Information Flow Analysis of Android Applications 
ASIA-PACIFIC INVESTIGATIONS REVIEW 2020 - Forensic Risk Alliance 
Tabulator: Exploring and Analyzing linked data on the Semantic Web 
State of play of GIS usage in the Real Estate Industry James Culley 
HTC Desire 616 dual sim - User guide 
A generative adversarial network approach to (ensemble) weather prediction 
Did COVID-19 infections decline before UK lockdown? 
REGIONAL PLAN TO END HOMELESSNESS - MARICOPA REGIONAL CONTINUUM OF CARE 2018 - City of Chandler 
Information Consolidation on Users of Social Networks to Determine Their Credibility 
Hybrid Malware Classification Method Using Segmentation-Based Fractal Texture Analysis and Deep Convolution Neural Network Features - MDPI 
Modeling, Monitoring, and Validating Green Roof and Green Facade Solutions with Semantic City Models Using Low Cost Sensors and Open Software ... 
Core Vector Machines: Fast SVM Training on Very Large Data Sets 
Analysis of what makes an Euroleague team successful through player clustering 
Adoption of Blockchain in Health Care - JMIR 
Digital Comms in 2020-21 - What the CharityComms Digital Benchmark tells us about charities' digital response to the coronavirus 
Private AI: Machine Learning on Encrypted Data - Cryptology ... 
GEO Initiative Global Wildfire Information System (GWIS) - Implementation Plan February 20th, 2019 
The Alan Turing Institute Internship Programme 2018 - Amazon AWS 
Toward Improving the Prediction Accuracy of Product Recommendation System Using Extreme Gradient Boosting and Encoding Approaches - MDPI 
DigitalCommons@USU Utah State University 
ORION OPEN SCIENCE FACTSHEETS - Brief, informative, and easy-to-understand one-page factsheets on Open Science topics 
WASP: a versatile, web-accessible single cell RNA-Seq processing platform - BMC Genomics 
Video-Capable Ultrasonic Wireless Communications Through Biological Tissues 
Detecting and tracking drift in quantum information processors - Nature