9:06 PM

MicroFAT: A File System for Microcontrollers

File systems can be great for handling data and organizing memory, but most file systems require large amounts of memory. This is where MicroFAT comes in!

The Problem with Standard File Systems

Microcontrollers are becoming the core of many electronic projects for hobbyists and the norm in electronic design overall. With the complexity of projects increasing and the introduction of the IoT, it will not be long before micro users will need to also increase the capabilities of microcontrollers.

A common use for microcontrollers is to log data from sensors such as temperature, humidity, and other stimuli. This data can be streamed to an I2C EEPROM and then read back when this data is to be sent to an external server (via the IoT). If the user wishes to store separate instances of data (for example, different times of the day), then the memory needs to contain information regarding the time the data was sent and how the memory is organised.

While the user could design a system to cope with such matters, it would be easier to implement a file system such as FAT. However, many micros are not capable of using the FAT file system because of the memory requirements.

For example, to use FAT32 on the PIC range requires up to 12KB of program memory, 2KB of data memory. FAT16 and FAT32 are also not ideal for 8-bit systems and contain a lot of unnecessary metadata (file creation date, permissions, etc.).

Because the file system is for private use between the microcontroller and serial memory, the system does not need to be compatible with PC standards. If files are to be transferred between a microcontroller and PC, then a simple application made in either Visual C#, C++, or BASIC could stream the bytes in and then save to a file.

MicroFAT is a standard currently in development for use in 8-bit designs which has emphasis on low memory usage, smaller block sizes, and an easier interface. For example, the MicroFAT standard is designed to be used with serial memory so there is no need for a RAM copy of the current working directory (which would otherwise need an additional 256 bytes). This is because serial memory holds its own internal address and therefore any file operations need only to set the memory address to the directory location and stream in data byte by byte.

Generic Layout

Two memory models are possible with the MicroFAT system: absolute address and block address. As all addresses in the file system are encoded with a 16-bit number, the maximum number of locations is 65,535. Therefore, this allows for either 64KB (when the address points to individual bytes) or 16MB (with 256 byte block sizes).

Absolute addressing has the advantage of storing file sizes to the byte value (such as 10 bytes), whereas the block address model can only store file sizes as blocks (not ideal for file streaming). The larger memory model also requires the current address pointer to be stored for individual bytes in the current block but the advantage is the significantly larger amount of memory.

For the sake of implementation, this article considers the absolute addressing mode for MicroFAT as I2C serial memory to typically range from 1KB to 64KB.

All 16-bit values are in little endian form which means that the lower portion of the 16-bit number is stored in memory first with the upper portion stored afterwards. An example is given below:

The number 0x5ADA is stored in memory location 0x0010. This means that memory location 0x0010 has the number 0xDA and the memory location 0x0011 has the number 0x5A.

Memory Blocks

Memory is split into blocks of 256 bytes, which makes addressing very easy. As most FAT operations are concerned with blocks and 64KB is split into 256 blocks, only an 8-bit counter is needed to point to blocks in the system.

The very first block in memory is the root directory and is used to store information regarding the bitmap location and device size. It can also be used to indicate boot options and other configuration data regarding the file system.

Bitmap Block

When an operation requires a block in memory, it must not use a block that is in use. One block is devoted at the very end of the memory which keeps a record of the state of each individual block: This block is referred to as the bitmap block. Its purpose is to keep track of a block's state, such as if it's currently in use or damaged (unusable). As each block is represented by 1 byte additional information can be encoded into the bitmap system by the user (e.g. reserved / system / boot).

The location of the bitmap needs to be at the very end of the memory and its location must be stored in entry 0 of the root directory.

Since MicroFAT has two memory models (absolute and block), the bitmap is encoded as shown below.

Absolute Addressing: Each block is represented by one byte
- Bit 0 – Block is in use
- Bit 1 – Block is damaged
- Bit 2:7 – Unused (Free for user)
Block Addressing: Each bitmap byte represents 8 blocks. Each of the bits indicated if that block is in use or not. Damaged memory cannot be encoded.

Directories

Directories are 256 bytes in length (1 block) and can hold up to 16 entries. The first entry (FAT INFO) stores information about the current directory, which includes the block location of the parent directory (useful when going up a directory) and the current directory block location. The root directory contains an additional 4 bytes in its FAT INFO: the device size and the bitmap location.

File and Directory Entries

All entries, both directories and files, are 16 bytes in length (unlike the 32 bytes needed in FAT). Each directory holds up to 15 files/folders with the first 16 bytes being devoted to directory information.

Entry Type Byte (0xn0)

Bit 0	Bit 1	Bit 2	Bit 3	Bit 4	Bit 5	Bit 6	Bit 7
In Use	File / Folder	Read Only	System File	Invisible	Not used	Not Used	Not Used
1 - Yes	1 - File	1 - Read Only	1 - Sys File	1 - Invisible
0 - No	0 - Folder	0 - RW	0 - User File	0 - Visible

As each entry is only 16 bytes in length, it is easy to get to specific entries with the upper four bits of the address. Adding 0x10 and then performing a logical and with 0xF0 will get to either the next entry or the first entry (if the number overflows). Below is an example of getting to the next file in Z80 assembler:


                    

nextEntry: ld a, (fileCounter)

  add 0x10

  and 0xF0

  ld (fileCounter), a

Here is an example of a test root directory that shows the bitmap location, device size, and a few entries:

File Storing - Linked List

Files use the linked list system where the last two bytes of a block point to the next block to load. If the block pointer is 0x0000 then the end of the file has been reached as block 0x0000 refers to the root directory which is a reserved block. This means that the usable data in a block is actually 254 bytes. The benefit of this is that a table of file block ownership is not needed and significantly reduces the amount of memory needed.

The location of the first block is defined in the file entry bytes 0x01 and 0x02. The bytes are stored in little endian (like all data in the MicroFAT system), so if for example the file block was located at 0x1000, the entry bytes would be seen as 0x0001.

When deleting files, it is important that the file is scanned through the entire list to find which blocks are in use so that the bitmap can free the old blocks. It is also important that the last two bytes of every block are replaced with 0x0000 when freed so that the system does not mistake the end of the file as a load next block.

Infinite loop issue

The link system can get stuck in an infinite loop if the end-of-file pointer points to a previous block in the chain. It would be easy to create a search function that checks for such loops by keeping a record of all blocks loaded and comparing the next block load with the table. Once the file is loaded, the table can be discarded and the memory freed. If the small memory model is used, then a single 256-byte entry in memory could store the table comparison values and it would be large enough for any file (remember how blocks can be pointed to with a single 8-bit number).

Implementation

Currently, no implementation in C exists but a preliminary can be downloaded for Z80 assembler. In the future, a generic C header + source will be developed that only expects the user to create the writing and reading functions for MicroFAT. A typical example is given below:


                    

unsigned char memoryRead(unsigned short address)

{

 // User writes custom memory access code here

}


void memoryWrite(unsigned short address)

{

 // User writes custom memory access code here

}

This enables the user to create his or her own code for accessing any type of serial memory, whether it is SPI, I2C, or even external microcontrollers. The Z80 assembler is still in progress, but functions that work are those with (d) next to their function name in the comments. The rst instructions are designed to work with a custom BIOS but below is a basic set of the I2C memory rst calls that the MicroFAT calls:

I2C External Memory Routines (RST 0x18) : Z80 BIOS Calls
Register A	Function	Registers	Description
0x00	Device Probe		Probes I2C Bus for selected device. Returns 1 upon detection
0x01	Device ID	B	Sets current I2C device to register B
0x02	Read Byte		Reads a byte from I2C and returns result in register A
0x03	Write Byte	B	Writes a byte to I2C found in register B
0x04	Read Block	HL	Reads a block of 256 bytes from I2C memory into address pointed by HL
0x05	Write Block	HL	Writes a block of 256 bytes to I2C memory found at address pointed by HL
0x06	Set Address	BC	Sets the current memory address of the current device to BC

It should be noted that the Z80 assembler code provided makes a copy of the bitmap and current directory directly into RAM for the sake of speed. This, in turn, uses an additional 512 bytes but low memory implementation would not need more than 32 bytes of RAM. If the current directory name was needed, then an additional 32 bytes of RAM would be needed to store the name. However, this is only required where the user can access the file system with a keyboard and display.

10:18 PM

Microcontroller Types and Applications

Microcontroller Types and Applications:

Introduction to Microcontroller:

A microcontroller (μC or uC) is a solitary chip microcomputer fabricated from VLSI fabrication. A micro controller is also known as embedded controller. Today various types of microcontrollers are available in market with different word lengths such as 4bit, 8bit, 64bit and 128bit microcontrollers. Microcontroller is a compressed micro computer manufactured to control the functions of embedded systems in office machines, robots, home appliances, motor vehicles, and a number of other gadgets. A microcontroller is comprises components like – memory, peripherals and most importantly a processor. Microcontrollers are basically employed in devices that need a degree of control to be applied by the user of the device.

Microcontroller Basics:

Any electric appliance that stores, measures, displays information or calculates comprise of a microcontroller chip inside it. The basic structure of a microcontroller comprise of:-

CPU – Microcontrollers brain is named as CPU. CPU is the device which is employed to fetch data, decode it and at the end complete the assigned task successfully. With the help of CPU all the components of microcontroller is connected into a single system. Instruction fetched by the programmable memory is decoded by the CPU.
Memory – In a microcontroller memory chip works same asm microprocessor. Memory chip stores all programs & data. Microcontrollers are built with certain amount of ROM or RAM (EPROM, EEPROM, etc) or flash memory for the storage of program source codes.
Input/output ports – I/O ports are basically employed to interface or drive different appliances such as- printers, LCD’s, LED’s, etc.
Serial Ports – These ports give serial interfaces amid microcontroller & various other peripherals such as parallel port.
Timers – A microcontroller may be in-built with one or more timer or counters. The timers & counters control all counting & timing operations within a microcontroller. Timers are employed to count external pulses. The main operations performed by timers’ are- pulse generations, clock functions, frequency measuring, modulations, making oscillations, etc.
ADC (Analog to digital converter) – ADC is employed to convert analog signals to digital ones. The input signals need to be analog for ADC. The digital signal production can be employed for different digital applications (such as- measurement gadgets).
DAC (digital to analog converter) – this converter executes opposite functions that ADC perform. This device is generally employed to supervise analog appliances like- DC motors, etc.
Interpret Control- This controller is employed for giving delayed control for a working program. The interpret can be internal or external.
Special Functioning Block – Some special microcontrollers manufactured for special appliances like- space systems, robots, etc, comprise of this special function block. This special block has additional ports so as to carry out some special operations.

Types of Microcontroller:

Microcontrollers are divided into categories according to their memory, architecture, bits and instruction sets. So let’s discuss types of microcontrollers:-

Bits:

8 bits microcontroller executes logic & arithmetic operations. Examples of 8 bits micro controller is Intel 8031/8051.
16 bits microcontroller executes with greater accuracy and performance in contrast to 8-bit. Example of 16 bit microcontroller is Intel 8096.
32 bits microcontroller is employed mainly in automatically controlled appliances such as office machines, implantable medical appliances, etc. It requires 32-bit instructions to carry out any logical or arithmetic function.

Memory:

External Memory Microcontroller – When an embedded structure is built with a microcontroller which does not comprise of all the functioning blocks existing on a chip it is named as external memory microcontroller. For illustration- 8031 microcontroller does not have program memory on the chip.
Embedded Memory Microcontroller – When an embedded structure is built with a microcontroller which comprise of all the functioning blocks existing on a chip it is named as embedded memory microcontroller. For illustration- 8051 microcontroller has all program & data memory, counters & timers, interrupts, I/O ports and therefore its embedded memory microcontroller.

Instruction Set:

CISC- CISC means complex instruction set computer, it allows the user to apply 1 instruction as an alternative to many simple instructions.
RISC- RISC means Reduced Instruction Set Computers. RISC reduces the operation time by shortening the clock cycle per instruction.

Memory Architecture:

Harvard Memory Architecture Microcontroller
Princeton Memory Architecture Microcontroller

8051 Microcontroller:

The most universally employed set of microcontrollers come from the 8051 family. 8051 Microcontrollers persist to be an ideal choice for a huge group of hobbyists and experts. In the course of8051, the humankind became eyewitness to the most ground-breaking set of microcontrollers. The original 8051 microcontroller was initially invented by Intel. The two other members of this 8051 family are-

8052 – This microcontroller has 3 timers & 256 bytes of RAM. Additionally it has all the features of the traditional 8051 microcontroller. 8051 microcontroller is a subset of 8052 microcontroller.
8031 – This microcontroller is ROM less, other than that it has all the features of a traditional 8051 microcontroller. For execution an external ROM of size 64K bytes can be added to its chip.

8051 microcontroller brings into play 2 different sorts of memory such as- NV-RAM, UV-EPROM and Flash.

8051 Microcontroller Architecture:

8051 microcontroller is an eight bit microcontroller launched in the year 1981 by Intel Corporation. It is available in 40 pin DIP (dual inline package). It has 4kb of ROM (on-chip programmable space) and 128 bytes of RAM space which is inbuilt, if desired 64KB of external memory can be interfaced with the microcontroller. There are four parallel 8 bits ports which are easily programmable as well as addressable. An on-chip crystal oscillator is integrated in the microcontroller which has crystal frequency of 12MHz. In the microcontroller there is a serial input/output port which has 2 pins. Two timers of 16 bits are also incorporated in it; these timers can be employed as timer for internal functioning as well as counter for external functioning. The microcontroller comprise of 5 interrupt sources namely- Serial Port Interrupt, Timer Interrupt 1, External Interrupt 0, Timer Interrupt 0, External Interrupt 1. The programming mode of this micro-controller includes GPRs (general purpose registers), SFRs (special function registers) and SPRs (special purpose registers).

PIC Microcontroller:

Peripheral Interface Controller (PIC) provided by Micro-chip Technology to categorize its solitary chip microcontrollers. These appliances have been extremely successful in 8 bit micro-controllers. The foremost cause behind it is that Micro-chip Technology has been constantly upgrading the appliance architecture and included much required peripherals to the micro-controller to go well with clientele necessities. PIC microcontrollers are very popular amid hobbyists and industrialists; this is only cause of wide availability, low cost, large user base & serial programming capability.

PIC Microcontroller Architecture:

The architecture of the 8 bit PIC microcontrollers can be categorized as below –

Base Line Architecture – In the base-line architecture PIC microcontrollers of PIC10F family is included, other than that a fraction of PIC12 & PIC16 families are also included. These gadgets make use of 12 bit program word architecture with six to twenty-eight pin package alternatives. Briefly defined attribute set of baseline architecture allows the most lucrative product solutions. This architecture is perfect for battery enabled gadgets. The PIC10F200 series is another reasonably priced 8 bit flash micro-controller with a 6 pin package.
Mid Range Architecture – In this midline member of PIC12 & PIC16 families are added that attribute 14 bit program word architecture. The midrange PIC16 gadgets proffer a broad variety of package alternatives (from 8 to 64 package), with low to high levels of peripheral incorporation. This PIC16 appliance attributes a variety of analog, digital & serial peripherals, like- SPI, USART, I2C, USB, LCD & A/D converters. The mid-range PIC16 micro-controllers have suspended controlling ability with an eight level hardware load.
High Performance Architecture – The high performance architecture included the PIC18 family of appliances. These micro-controllers make use of 16 bit program word architecture along with 18 to 100 pin package alternatives. The PIC18 appliances are high performance micro-controllers with incorporated Analog to Digital converters. All PIC18 micro-controllers integrate a highly developed RISC architecture that supports flash appliances. The PIC18 has improved foundation attributes, 32 level deep load and several inner and exterior interrupts.

AVR Microcontroller:

AVR also known as Advanced Virtual RISC, is a customized Harvard architecture 8 bit RISC solitary chip micro-controller. It was invented in the year 1966 by Atmel. Harvard architecture signifies that program & data are amassed in different spaces and are used simultaneously. It was one of the foremost micro-controller families to employ on-chip flash memory basically for storing program, as contrasting to one time programmable EPROM, EEPROM or ROM, utilized by other micro-controllers at the same time. Flash memory is a non-volatile (constant on power down) programmable memory.

AVR Microcontroller Architecture:

AVR microcontrollers’ architecture was developed by Alf-Egil Bogen and Vegard Wollan. The name AVR is derived from the names of the architecture developers of the microcontroller. The AT90S8515 was the foremost micro-controller which was AVR architecture based; on the other hand the foremost micro-controller to strike the commercial marketplace was AT90S1200 which was launched in the year 1997.

The SRAM, Flash and EEPROM all are incorporated on a single chip, thereby eliminating the requirement of any other external memory in maximum devices. Several appliances comprise of parallel external bus alternative, so as to add extra data memory gadgets. Approximately all appliances, except TinyAVR chips comprise serial interface, which is used to link large serial Flash & EEPROMs chips.

ARM Microcontroller:

ARM is the name of a company that designs micro-processors architecture. It is also engaged in licensing them to the producers who fabricate genuine chips. In actuality ARM is a 32 bit genuine RISC architecture. It was initially developed in the year 1980 by Acorn Computers Ltd. This ARM base microprocessor does not have on-board flash memory. ARM is particularly designed for micro-controller devices, it is simple to be trained and make use of, however powerful enough for the most challenging embedded devices.

ARM Microcontroller Architecture:

The ARM architecture is a 32 bit RISC processor developed by ARM Ltd. Owing to its power-saving attributes, ARM central processing units are prevailing in the mobile electronics marketplace, where less power expenditure is a vital design aim. ARM architecture comprise of the underneath RISC elements:-

Maximum single cycle functioning
Constant 16×32 bit register file.
Load or store architecture.
Preset instruction width of 32 bits so as to simplify pipe-lining and decoding, at minimized code density.
For misaligned memory access there is no support.

Microcontroller Applications:

Microcontrollers are intended for embedded devices, in comparison to the micro-processors which are used in PCs or other all-purpose devices. Microcontrollers are employed in automatically managed inventions and appliances like- power tools, implantable medical devices, automobile engine control systems, , office machines, remote controls appliances, toys and many more embedded systems. By dipping the size and expenditure in comparison to a design that make use of a different micro-processor, I/O devices and memory, micro-controllers formulate it inexpensive to digitally control more & more appliances and operations. Mixed signal micro-controllers are general; putting together analog constituents required controlling non-digital electronic structures.

Application of Microcontroller in Day to Day Life Devices:

Light sensing & controlling devices
Temperature sensing and controlling devices
Fire detection & safety devices
Industrial instrumentation devices
Process control devices

Application of Microcontroller in Industrial Control Devices:

Industrial instrumentation devices
Process control devices

Application of Microcontroller in Metering & Measurement Devices:

Volt Meter
Measuring revolving objects
Current meter
Hand-held metering systems

REFERENCE // Electronics Hub

9:31 PM

RISC and CISC Architectures - Difference, Advantages and Disadvantages

RISC and CISC Architectures:

Every processor is built with the ability to execute a set of instructions for performing a limited set of basic operations. The instruction set architecture is the part of the processor which is necessary for creating machine level programs to perform any mathematical or logical operations.

The instruction set is embedded in the hardware which serves as a bridge between software and hardware. A compiler translates high level language to machine language.

If number of complex instructions within the instruction set of processor is increased, the processor working is slow down due to more complex decoding of instructions and time consuming.

The important aspect of computer architecture or any other microprocessor device is the design of the instruction set for the processor. This is because all operating systems and software applications are programmed within the boundaries of processor’s instruction set.

So a unique instruction set is employed for each processor, where machine language programs of one processor will not run on different processor.

There are two common types of architectures based on the instruction set, namely CISC (Computer Instruction Set Computer) and RISC (Reduced Instruction Set Computer). Let us discuss these two architectures in brief and their difference.

CISC (Computer Instruction Set Computer) Architecture:

Before the processor executes the instructions, the compiler convert instructions in high level languages into their equivalent low level languages as mentioned above.

If these high level languages are programmed for complex mathematical functions, compilers had to convert or translate complex subroutines into long sequences of machine functions. So the compiler development was time consuming and tricky.

In order to make easy development of the compiler, CISC was developed. The main aim of designing CISC based processors is to build the processor with more complex instruction set.

Writing instructions or programming for a CISC processor is easier as it provides single machine instruction for the statements that are written in a high-level language.

CISC incorporates an instruction with variable length format. The instructions that require register operands may take only two bytes while the instructions that require two memory addresses may take five bytes.

Therefore, CISC has the variable length encoding of instructions and the number of clock cycles required to execute the instructions may be varied.

Many CISC architectures, read the inputs and write their outputs in the memory system instead of a register file. The above figure shows the architecture of CISC with microprogrammed control and cache memory.

This architecture uses unified cache memory for holding both data and instructions. Thus, they share the same path for both instructions and data.

In CISC processor, most instructions are stored in memory and they are executed by microprogram. These have many instruction formats and many addressing modes.

In CISC based processor, control signals for the execution of an instruction are generated by a microprogram execution. This mirco program consists of a sequence of microinstructions.

The microinstructions are executed one by one and in turn necessary control signals for the execution of an instruction are produced in steps. This may significantly slow down the instruction execution.

The major characteristics of CISC architecture are

It has a large number of instructions, typically from 100 to 250 instructions.
It uses a variety of addressing modes, typically from 12 to 24 modes.
Instructions that manipulate the operands in memory.
Instruction formats have variable length.

Examples of CISC processor

IBM 370/168
Intel 80486
VAX 11/780

RISC (Reduced Instruction Set Computer) Architecture:

In RISC architecture, the instruction set of the computer is simplified to reduce the execution time. It uses small and highly optimized set of instructions which are generally register to register operations.

The speed of the execution is increased by using smaller number of instructions as compared with single long instruction (in case of CISC architecture). And the optimization of each instruction in the processor is achieved through pipeline technique.

The pipelining technique allows the processor to work on different steps of instruction like fetch, decode and execute instructions at the same time. These cycles (fetch, decode and execute) of one or more instructions are overlapped in this pipeline technique.

Therefore, more number of instructions can be executed in a shorter time. In order to avoid more interactions or to reduce access time, RISC processors are provided with multiple sets of registers with optimized register usage so that frequently accessed operands are remain in high-speed storage.

The figure shown above is the architecture of RISC processor, which uses separate instruction and data caches and their access paths also different. There is one instruction per machine cycle in RISC processor.

A machine cycle is defined as the time taken to fetch two operands from registers, perform ALU operation and store the result in a register. Due to this one cycle instruction, execution of instructions carried at a faster rate compared with microinstructions on CISC processor.

Most RISC processors use hardwired control for the machine instruction and hence no need for microinstructions thereby it is not necessary to access a microprogram control memory during instruction execution as in case of CISC processor. The design of the control unit is also simple due to the limited number of instructions.

The major characteristics of RISC architecture are

It has reduced and restricted number of instructions.
It uses a lesser number of addressing modes.
Instruction format is simple and uniform so that most instructions are executed within one cycle.
External memory access time is reduced by a larger number of registers.
Only load and store instructions have memory access.
Hard-wired control rather than micro programmed.
Pipeline architecture.

Examples of RISC processors include alpha, AVR, ARM, PIC, PA-RISC, and power architecture.

CISC Vs RISC:

CISC	RISC
It consists of a large set of instructions with variable formats (Typically 16 to 64 bits per instruction)	It consists of small set of instructions with fixed format and these instructions are of register based instructions.
It has higher number of addressing modes, typically 12 to 24.	It has a limited number of addressing modes, typically 3 to 5.
It supports complex addressing modes	In this complex addressing modes are synthesized in software.
It consists of 8 to 24 general purpose registers with a unified cache for instructions and data (recent designs use split caches).	It consists of a large number of general purpose registers, typically 32 to 192 with split data cache for instruction cache.
The processor is controlled using microcoded control memory (modern CISC processor also uses hardwired control.)	The processor is controlled by a hardwired control without control memory.
It consists of complex instructions that take multiple cycles to execute.	It consists of simple instructions that take single cycle to execute.
Instructions are not pipelined or less pipelined	Instructions are pipelined
Complexity lies in microprogram	Complexity lies the compiler

Advantages of CISC Architecture:

Microprogramming is easy to implement and much less expensive than hard wiring a control unit.
It is easy to add new commands into the chip without changing the structure of the instruction set as the architecture uses general-purpose hardware to carry out commands.
This architecture makes the efficient use of main memory since the complexity (or more capability) of instruction allows to use less number of instructions to achieve a given task.
The compiler need not be very complicated, as the microprogram instruction sets can be written to match the constructs of high level languages.

Disadvantages of CISC Architecture:

A new or succeeding versions of CISC processors consists early generation processors in their subsets (succeeding version). Therefore, chip hardware and instruction set became complex with each generation of the processor.
The overall performance of the machine is reduced due to the different amount of clock time required by different instructions.
This architecture necessitates on-chip hardware to be continuously reprogrammed.
The complexity of hardware and on-chip software included in CISC design to perform many functions.

Advantages of RISC Architecture:

The performance of RISC processors is often two to four times than that of CISC processors because of simplified instruction set.
This architecture uses less chip space due to reduced instruction set. This makes to place extra functions like floating point arithmetic units or memory management units on the same chip.
The per-chip cost is reduced by this architecture that uses smaller chips consisting of more components on a single silicon wafer.
RISC processors can be designed more quickly than CISC processors due to its simple architecture.
The execution of instructions in RISC processors is high due to the use of many registers for holding and passing the instructions as compared to CISC processors.

Disadvantages of RISC Architecture:

The performance of a RISC processor depends on the code that is being executed. The processor spends much time waiting for first instruction result before it proceeds with next subsequent instruction, when a compiler makes a poor job of scheduling instruction execution.
RISC processors require very fast memory systems to feed various instructions. Typically, a large memory cache is provided on the chip in most RISC based systems.