Archive for May, 2010

PostHeaderIcon Recovery Chip PIC16C505 Eeprom

We can Recovery CHIP PIC16C505 Eeprom, please view the CHIP PIC16C505 features for your reference:

The USART Transmit Data Buffer Register and USART Receive Data Buffer Registers share the same I/O address referred to as USART Data Register or UDRn. The Transmit Data Buffer Register (TXB) will be the destination for data written to the UDRn Register location when Recovery Chip eeprom.

Reading the UDRn Register location will return the contents of the Receive Data Buffer Register (RXB). For 5-, 6-, or 7-bit characters the upper unused bits will be ignored by the Transmitter and set to zero by the Receiver if Recovery chip eeprom.

The transmit buffer can only be written when the UDREn Flag in the UCSRnA Register is set. Data written to UDRn when the UDREn Flag is not set, will be ignored by the USART Transmitter after Recovery chip eeprom.

When data is written to the transmit buffer, and the Transmitter is enabled, the Transmitter will load the data into the Transmit Shift Register when the Shift Register is empty. Then the data will be serially transmitted on the TxDn pin. The receive buffer consists of a two level FIFO. The FIFO will change its state whenever the receive buffer is accessed. Due to this behavior of the receive buffer, do not use Read-Modify-Write instructions (SBI and CBI) on this location if Recovery Chip eeprom.

Be careful when using bit test instructions (SBIC and SBIS), since these also will change the state of the FIFO. This flag bit is set when there are unread data in the receive buffer and cleared when the receive buffer is empty (i.e., does not contain any unread data) when Recovery Chip eeprom.

If the Receiver is disabled, the receive buffer will be flushed and consequently the RXCn bit will become zero. The RXCn Flag can be used to generate a Receive Complete interrupt (see description of the RXCIEn bit) before Recovery Chip eeprom.

This flag bit is set when the entire frame in the Transmit Shift Register has been shifted out and there are no new data currently present in the transmit buffer (UDRn). The TXCn Flag bit is automatically cleared when a transmit complete interrupt is executed, or it can be cleared by writing a one to its bit location. The TXCn Flag can generate a Transmit Complete interrupt (see description of the TXCIEn bit) if Recovery Chip eeprom.

The UDREn Flag indicates if the transmit buffer (UDRn) is ready to receive new data. If UDREn is one, the buffer is empty, and therefore ready to be written. The UDREn Flag can generate a Data Register Empty interrupt (see description of the UDRIEn bit). UDREn is set after a reset to indicate that the Transmitter is ready if recovery Chip eeprom.

PostHeaderIcon Break MCU AT89C5131A Binary


We can recover MCU AT89C5131A Binary, please view below MCU AT89C5131A feature for your reference:

AT89C5130A/31A-M is a high-performance Flash version of the 80C51 single-chip 8-bit micro-controllers with full speed USB functions. AT89C5130A/31A-M features a full-speed USB module compatible with the USB specifications Version 1.1 and 2.0 when Break MCU. This module integrates the USB transceivers with a 3.3V voltage regulator and the Serial Interface Engine (SIE) with Digital Phase Locked Loop and 48 MHz clock recovery after Break MCU. USB Event detection logic (Reset and Suspend/Resume) and FIFO buffers supporting the mandatory control Endpoint (EP0) and up to 6 versatile Endpoints (EP1/EP2/EP3/EP4/EP5/EP6) with minimum software overhead are also part of the USB module if Break MCU.

AT89C5130A/31A-M retains the features of the Atmel 80C52 with extended Flash capacity (16/32-Kbytes), 256 bytes of internal RAM, a 4-level interrupt system, two 16-bit timer/counters (T0/T1), a full duplex enhanced UART (EUART) and an on-chip oscillator before Break MCU. In addition, AT89C5130A/31A-M has an on-chip expanded RAM of 1024 bytes (ERAM), a dual data pointer, a 16-bit up/down Timer (T2), a Programmable Counter Array (PCA), up to 4 programmable LED current sources, a programmable hardware watchdog and a power-on reset for Break MCU.

AT89C5130A/31A-M has two software-selectable modes of reduced activity for further reduction in power consumption. In the idle mode the CPU is frozen while the timers, the serial ports and the interrupt system are still operating after Break MCU. In the power-down mode the RAM is saved, the peripheral clock is frozen, but the device has full wake-up capability through USB events or external interrupts when Break MCU.

PostHeaderIcon Break Chip PIC12C509 Code

We can Break CHIP PIC12C509 Code, please view the CHIP PIC12C509 features for your reference:

For an CHIP to act as a master CHIP, it can use a 9-bit character frame format (UCSZn = 7). The ninth bit (TXB8n) must be set when an address frame (TXB8n = 1) or cleared when a data frame (TXB = 0) is being transmitted when Break CHIP code.

The slave CHIPs must in this case be set to use a 9-bit character frame format. The following procedure should be used to exchange data in Multi-processor Communication mode:

All Slave CHIPs are in Multi-processor Communication mode (MPCMn in UCS-RnA is set).

The Master CHIP sends an address frame, and all slaves receive and break this frame. In the Slave CHIPs, the RXCn Flag in UCSRnA will be set as normal before Break CHIP code.

Each Slave CHIP breaks the UDRn Register and determines if it has been selected. If so, it clears the MPCMn bit in UCSRnA, otherwise it waits for the next address byte and keeps the MPCMn setting.

The addressed CHIP will receive all data frames until a new address frame is received. The other Slave CHIPs, which still have the MPCMn bit set, will ignore the data frames when Break CHIP code.

When the last data frame is received by the addressed CHIP, the addressed CHIP sets the MPCMn bit and waits for a new address frame from master. The process then repeats from 2 if Break CHIP code.

Using any of the 5- to 8-bit character frame formats is possible, but impractical since the Receiver must change between using n and n+1 character frame formats before Break CHIP code.

This makes full-duplex operation difficult since the Transmitter and Receiver uses the same character size setting. If 5- to 8-bit character frames are used, the Transmitter must be set to use two stop bit (USBSn = 1) since the first stop bit is used for indicating the frame type after Break CHIP code.

Do not use Break-Modify-Write instructions (SBI and CBI) to set or clear the MPCMn bit. The MPCMn bit shares the same I/O location as the TXCn Flag and this might accidentally be cleared when using SBI or CBI instructions when Break CHIP code.

PostHeaderIcon Reverse Engineering Chip PIC12C508 Code

We can Reverse engineering CHIP PIC12C508 Code, please view the CHIP PIC12C508 features for your reference:

The recommendations of the maximum receiver baud rate error was made under the assumption that the Receiver and Transmitter equally divides the maximum total error. There are two possible sources for the receivers baud rate error. The Receiver’s system clock (XTAL) will always have some minor instability over the supply voltage range and the temperature range if Reverse engineering CHIP code.

When using a crystal to generate the system clock, this is rarely a problem, but for a resonator the system clock may differ more than 2% depending of the resonators tolerance. The second source for the error is more controllable. The baud rate generator can not always do an exact division of the system frequency to get the baud rate wanted after Reverse engineering CHIP code.

In this case an UBRR value that gives an acceptable low error can be used if possible. Setting the Multi-processor Communication mode (MPCMn) bit in UCSRnA enables a filtering function of incoming frames received by the USART Receiver before Reverse engineering CHIP code.

Frames that do not contain address information will be ignored and not put into the receive buffer. This effectively reduces the number of incoming frames that has to be handled by the CPU, in a system with multiple CHIPs that communicate via the same serial bus if Reverse engineering CHIP code.

The Transmitter is unaffected by the MPCMn setting, but has to be used differently when it is a part of a system utilizing the Multi-processor Communication mode. If the Receiver is set up to receive frames that contain 5 to 8 data bits, then the first stop bit indicates if the frame contains data or address information. If the Receiver is set up for frames with nine data bits, then the ninth bit (RXB8n) is used for identifying address and data frames after Reverse engineering CHIP code.

When the frame type bit (the first stop or the ninth bit) is one, the frame contains an address. When the frame type bit is zero the frame is a data frame when Reverse engineering CHIP code.

The Multi-processor Communication mode enables several slave CHIPs to receive data from a master CHIP. This is done by first decoding an address frame to find out which CHIP has been addressed if Reverse engineering CHIP code.

If a particular slave CHIP has been addressed, it will receive the following data frames as normal, while the other slave CHIPs will ignore the received frames until another address frame is received after Reverse engineering CHIP code.

PostHeaderIcon Recover Chip PIC12C509A Firmware

We can Recover CHIP PIC12C509A Firmware, please view the CHIP PIC12C509A features for your reference:

The same majority voting is done to the stop bit as done for the other bits in the frame. If the stop bit is registered to have a logic 0 value, the Frame Error (FEn) Flag will be set when Recover CHIP firmware.

A new high to low transition indicating the start bit of a new frame can come right after the last of the bits used for majority voting. For Normal Speed mode, the first low level sample can be at point marked (A) in Figure 89 if Recover CHIP firmware.

For Double Speed mode the first low level must be delayed to (B). (C) marks a stop bit of full length. The early start bit detection influences the operational range of the Receiver before Recover CHIP firmware.

The operational range of the Receiver is dependent on the mismatch between the received bit rate and the internally generated baud rate after Recover CHIP firmware.

If the Transmitter is sending frames at too fast or too slow bit rates, or the internally generated baud rate of the Receiver does not have a similar (see Table 99) base frequency, the Receiver will not be able to synchronize the frames to the start bit when Recover CHIP firmware.

The following equations can be used to calculate the ratio of the incoming data rate and internal receiver baud rate. Sum of character size and parity size (D = 5 to 10 bit) Samples per bit. S = 16 for Normal Speed mode and S = 8 for Double Speed mode.

First sample number used for majority voting. SF = 8 for normal speed and SF = 4 for Double Speed mode. Middle sample number used for majority voting before Recover CHIP firmware.

SM = 9 for normal speed and

SM = 5 for Double Speed mode.

Rslow is the ratio of the slowest incoming data rate that can be accepted in relation to the receiver baud rate. Rfast is the ratio of the fastest incoming data rate that can be accepted in relation to the receiver baud rate. Table 99 and Table 100 list the maximum receiver baud rate error that can be tolerated. Note that Normal Speed mode has higher toleration of baud rate variations after Recover CHIP.

PostHeaderIcon Reverse Microcontroller PIC12C508A Firmware

We can Reverse MICROCONTROLLER PIC12C508A Firmware, please view the MICROCONTROLLER PIC12C508A features for your reference:

The clock recovery logic synchronizes internal clock to the incoming serial frames. Figure 87 illustrates the sampling process of the start bit of an incoming frame when Reverse MICROCONTROLLER firmware.

The sample rate is 16 times the baud rate for Normal mode, and eight times the baud rate for Double Speed mode. The horizontal arrows illustrate the synchronization variation due to the sampling process. Note the larger time variation when using the Double Speed mode (U2Xn = 1) of operation. Samples denoted zero are samples done when the RxDn line is idle (i.e., no communication activity) before Reverse MICROCONTROLLER firmware.

Please shown in the figure. The clock recovery logic then uses samples 8, 9, and 10 for Normal mode, and samples 4, 5, and 6 for Double Speed mode (indicated with sample numbers inside boxes on the figure), to decide if a valid start bit is received after Reverse MICROCONTROLLER firmware.

If two or more of these three samples have logical high levels (the majority wins), the start bit is rejected as a noise spike and the Receiver starts looking for the next high to low-transition.

If however, a valid start bit is detected, the clock recovery logic is synchronized and the data recovery can begin. The synchronization process is repeated for each start bit before Reverse MICROCONTROLLER firmware.

When the receiver clock is synchronized to the start bit, the data recovery can begin. The data recovery unit uses a state machine that has 16 states for each bit in Normal mode and eight states for each bit in Double Speed mode after Reverse MICROCONTROLLER firmware.

Figure 88 shows the sampling of the data bits and the parity bit. Each of the samples is given a number that is equal to the state of the recovery unit.The decision of the logic level of the received bit is taken by doing a majority voting of the logic value to the three samples in the center of the received bit when Reverse MICROCONTROLLER firmware.

The center samples are emphasized on the figure by having the sample number inside boxes. The majority voting process is done as follows: If two or all three samples have high levels, the received bit is registered to be a logic 1.

If two or all three samples have low levels, the received bit is registered to be a logic 0. This majority voting process acts as a low pass filter for the incoming signal on the RxDn pin if Reverse MICROCONTROLLER firmware.

The recovery process is then repeated until a complete frame is received. Including the first stop bit. Note that the Receiver only uses the first stop bit of a frame.

PostHeaderIcon Break IC PIC16C57C Firmware

We can Break IC PIC16C57C Firmware, please view the IC PIC16C57C features for your reference:

The Parity Checker is active when the high USART Parity mode (UPMn1) bit is set. Type of Parity Check to be performed (odd or even) is selected by the UPMn0 bit when Break IC firmware.

When enabled, the Parity Checker calculates the parity of the data bits in incoming frames and compares the result with the parity bit from the serial frame if Break IC firmware.

The result of the check is stored in the receive buffer together with the received data and stop bits. The Parity Error (UPEn) Flag can then be read by software to check if the frame had a Parity Error before Break IC firmware.

The UPEn bit is set if the next character that can be read from the receive buffer had a Parity Error when received and the Parity Checking was enabled at that point (UPMn1 = 1). This bit is valid until the receive buffer (UDRn) is read after Break IC firmware.

In contrast to the Transmitter, disabling of the Receiver will be immediate. Data from ongoing receptions will therefore be lost. When disabled (i.e., the RXENn is set to zero) the Receiver will no longer override the normal function of the RxDn port pin before Break IC firmware.

The Receiver buffer FIFO will be flushed when the Receiver is disabled. Remaining data in the buffer will be lost. The receiver buffer FIFO will be flushed when the Receiver is disabled, i.e., the buffer will be emptied of its contents. Unread data will be lost. If the buffer has to be flushed during normal operation, due to for instance an error condition, read the UDRn I/O location until the RXCn Flag is cleared. The following firmware example shows how to flush the receive buffer if Break IC firmware.

The USART includes a clock recovery and a data recovery unit for handling asynchronous data reception. The clock recovery logic is used for synchronizing the internally generated baud rate clock to the incoming asynchronous serial frames at the RxDn pin after Break IC firmware.

The data recovery logic samples and low pass filters each incoming bit, thereby improving the noise immunity of the Receiver. The asynchronous reception operational range depends on the accuracy of the internal baud rate clock, the rate of the incoming frames, and the frame size in number of bits when Break IC firmware.

PostHeaderIcon Reverse Engineering IC PIC18F248 Binary

Reverse Engineering Microcontroller PIC18F248 Binary

We can Reverse engineering IC PIC18F248 Binary, please view the IC PIC18F248 features for your reference:

High-Performance RISC CPU:

· Linear program memory addressing up to 2 Mbytes

· Linear data memory addressing to 4 Kbytes

· Up to 10 MIPS operation

· DC – 40 MHz clock input

· 4 MHz-10 MHz oscillator/clock input with PLL active when Reverse engineering IC

· 16-bit wide instructions, 8-bit wide data path

· Priority levels for interrupts

· 8 x 8 Single-Cycle Hardware Multiplier

Peripheral Features:

· High current sink/source 25 mA/25 mA

· Three external interrupt pins

· Timer0 module: 8-bit/16-bit timer/counter with 8-bit programmable prescaler if Reverse engineering IC

· Timer1 module: 16-bit timer/counter

· Timer2 module: 8-bit timer/counter with 8-bit period register (time base for PWM)

· Timer3 module: 16-bit timer/counter

· Secondary oscillator clock option – Timer1/Timer3

· Capture/Compare/PWM (CCP) modules; CCP pins can be configured as:

– Capture input: 16-bit, max resolution 6.25 ns

– Compare: 16-bit, max resolution 100 ns (TCY) before Reverse engineering IC

– PWM output: PWM resolution is 1 to 10-bit Max. PWM freq. @:8-bit resolution = 156 kHz 10-bit resolution = 39 kHz

· Enhanced CCP module which has all the features of the standard CCP module, but also has the following features for advanced motor control:

– 1, 2 or 4 PWM outputs

– Selectable PWM polarity

– Programmable PWM dead time

· Master Synchronous Serial Port (MSSP) with two modes of operation:

– 3-wire SPI™ (Supports all 4 SPI modes) after Reverse engineering IC

– I2C™ Master and Slave mode

· Addressable USART module:

– Supports interrupt-on-address bit

Advanced Analog Features:

· 10-bit, up to 8-channel Analog-to-Digital Converter module (A/D) with:

– Conversion available during Sleep

– Up to 8 channels available

· Analog Comparator module:

– Programmable input and output multiplexing

· Comparator Voltage Reference module

· Programmable Low-Voltage Detection (LVD) module:

– Supports interrupt-on-Low-Voltage Detection

· Programmable Brown-out Reset (BOR)

CAN bus Module Features:

· Complies with ISO CAN Conformance Test

· Message bit rates up to 1 Mbps

· Conforms to CAN 2.0B Active Spec with:

– 29-bit Identifier Fields

– 8-byte message length

– 3 Transmit Message Buffers with prioritization

– 2 Receive Message Buffers

– 6 full, 29-bit Acceptance Filters

– Prioritization of Acceptance Filters

– Multiple Receive Buffers for High Priority Messages to prevent loss due to overflow

– Advanced Error Management Features

Special Microcontroller Features:

· Power-on Reset (POR), Power-up Timer (PWRT) and Oscillator Start-up Timer (OST)

· Watchdog Timer (WDT) with its own on-chip RC oscillator

· Programmable code protection

· Power-saving Sleep mode

· Selectable oscillator options, including:

– 4x Phase Lock Loop (PLL) of primary oscillator

– Secondary Oscillator (32 kHz) clock input

· In-Circuit Serial ProgrammingTM (ICSPTM) via two pins IC Flash Technology:

· Low-power, high-speed Enhanced Flash technology

· Fully static design Wide operating voltage range (2.0V to 5.5V) Industrial and Extended temperature ranges

PostHeaderIcon Recovery IC PIC16F54C Program

We can Recovery IC PIC16F54C Program, please view the IC PIC16F54C features for your reference:

The USART Receiver has three Error Flags: Frame Error (FEn), Data OverRun (DORn) and Parity Error (UPEn). All can be accessed by reading UCSRnA. Common for the Error Flags is that they are located in the receive buffer together with the frame for which they indicate the error status if Recovery IC program.

Due to the buffering of the Error Flags, the UCSRnA must be read before the receive buffer (UDRn), since reading the UDRn I/O location changes the buffer read location. Another equality for the Error Flags is that they can not be altered by software doing a write to the flag location. However, all flags must be set to zero when the UCSRnA is written for upward compatibility of future USART implementations after Recovery IC program.

None of the Error Flags can generate interrupts. The Frame Error (FEn) Flag indicates the state of the first stop bit of the next readable frame stored in the receive buffer.

The FEn Flag is zero when the stop bit was correctly read (as one), and the FEn Flag will be one when the stop bit was incorrect (zero). This flag can be used for detecting out-of-sync conditions, detecting break conditions and protocol handling if Recovery IC program.

The FEn Flag is not affected by the setting of the USBSn bit in UCSRnC since the Receiver ignores all, except for the first, stop bits. For compatibility with future devices, always set this bit to zero when writing to UCSRnA before Recovery IC program.

The Data OverRun (DORn) Flag indicates data loss due to a receiver buffer full condition. A Data OverRun occurs when the receive buffer is full (two characters), it is a new character waiting in the Receive Shift Register, and a new start bit is detected after Recovery IC program.

If the DORn Flag is set there was one or more serial frame lost between the frame last read from UDRn, and the next frame read from UDRn. For compatibility with future devices, always write this bit to zero when writing to UCSRnA. The DORn Flag is cleared when the frame received was successfully moved from the Shift Register to the receive buffer when Recovery IC program.

The Parity Error (UPEn) Flag indicates that the next frame in the receive buffer had a Parity Error when received. If Parity Check is not enabled the UPEn bit will always be read zero. For compatibility with future devices, always set this bit to zero when writing to UCSRnA. For more details see “Parity Bit Calculation” on page 210 and “Parity Checker” after Recovery IC program.

PostHeaderIcon Recover Mcu PIC18F452 Program


We can Recover Mcu PIC18F452 Program, please view the Mcu PIC18F452 features for your reference:

A “fast interrupt return” option is available for interrupts. A Fast Register Stack is provided for the STATUS, WREG and BSR registers and are only one in depth. The stack is not recoverable or writable and is loaded with the current value of the corresponding register when the processor vectors for an interrupt. The values in the registers are then loaded back into the working registers, if the FAST RETURN instruction is used to return from the interrupt when Recover Mcu.

A low or high priority interrupt source will push values into the stack registers. If both low and high priority interrupts are enabled, the stack registers cannot be used reliably for low priority interrupts. If a high priority interrupt occurs while servicing a low priority interrupt, the stack register values stored by the low priority interrupt will be overwritten if Recover Mcu.

If high priority interrupts are not disabled during low priority interrupts, users must save the key registers in software during a low priority interrupt. If no interrupts are used, the fast register stack can be used to restore the STATUS, WREG and BSR registers at the end of a subroutine call. To use the fast register stack for a subroutine call, a FAST CALL instruction must be executed before Recover Mcu.

Example 4-1 shows a source code example that uses the fast register stack. The program counter (PC) specifies the address of the instruction to fetch for execution. The PC is 21-bits wide. The low byte is called the PCL register. This register is recoverable and writable. The high byte is called the PCH register. This register contains the PC<15:8> bits and is not directly recoverable or writable after Recover Mcu.

Updates to the PCH register may be performed through the PCLATH register. The upper byte is called PCU. This register contains the PC<20:16> bits and is not directly recoverable or writable. Updates to the PCU register may be performed through the PCLATU register when Recover Mcu.

The PC addresses bytes in the program memory. To prevent the PC from becoming misaligned with word instructions, the LSB of PCL is fixed to a value of ’0’. The PC increments by 2 to address sequential instructions in the program memory if Recover Mcu.

The CALL, RCALL, GOTO and program branch instructions write to the program counter directly. For these instructions, the contents of PCLATH and PCLATU are not transferred to the program counter.

The contents of PCLATH and PCLATU will be transferred to the program counter by an operation that writes PCL. Similarly, the upper two bytes of the program counter will be transferred to PCLATH and PCLATU by an operation that recovers PCL. This is useful for computed offsets to the PC before Recover Mcu.

The clock input (from OSC1) is internally divided by four to generate four non-overlapping quadrature clocks, namely Q1, Q2, Q3 and Q4. Internally, the program counter (PC) is incremented every Q1, the instruction is fetched from the program memory and latched into the instruction register in Q4 after Recover Mcu.

The instruction is decoded and executed during the following Q1 through Q4. The clocks and instruction execution flow are shown in Figure 4-4. An “Instruction Cycle” consists of four Q cycles (Q1, Q2, Q3 and Q4). The instruction fetch and execute are pipelined such that fetch takes one instruction cycle, while decode and execute takes another instruction cycle when Recover Mcu.

However, due to the pipelining, each instruction effectively executes in one cycle. If an instruction causes the program counter to change (e.g., GOTO) then two cycles are required to complete the instruction (Example 4-2). The program memory is addressed in bytes. Instructions are stored as two bytes or four bytes in program memory after Recover Mcu.

The Least Significant Byte of an instruction word is always stored in a program memory location with an even address (LSB =’0’). Figure 4-5 shows an example of how instruction words are stored in the program memory. To maintain alignment with instruction boundaries, the PC increments in steps of 2 and the LSB will always recover ’0’ (see Section 4.4) if Recover Mcu.