ZHCSGU2A July 2017 – September 2017 LP5569
PRODUCTION DATA.
The LP5569 device is a fully integrated lighting management unit for producing lighting effects for various LED applications. The LP5569 device includes all necessary power management, low-side current sinks, two-wire serial I2C-compatible interface, and programmable LED engines. The overall maximum current for each of the nine drivers is set with 8-bit resolution. The LP5569 device controls LED luminance with a pulse-width modulation (PWM) scheme with a resolution of 12 bits at 20 kHz, which is achieved by using 3-bit dithering.
The LP5569 device provides flexibility and programmability for dimming and sequencing control. Each LED can be controlled directly and independently through the serial interface, or LED drivers can be grouped together for preprogrammed flashing patterns. The device has three independent program execution engines. Each engine can control 1 to 9 LED driver outputs, but more than one engine cannot simultaneously control the same LED driver output. Any engine can be used as the master fader for all three engines.
An integrated 1× or 1.5× charge pump with adaptive control provides supply voltage for LEDs when operating with low input voltage. Because the LED drivers are low-side sinks, some or all LEDs can be powered from an external source if available. The LP5569 device has very low standby current and an automatic power-save mode when the LEDs are inactive.
Protection features include power-on reset, charge-pump input-current limiter, thermal shutdown (TSD), and undervoltage lockout (UVLO).
The LP5569 LED drivers are constant-current sources. Maximum output-current scale can be programmed by control registers up to 25.5 mA. The overall maximum current is set by 8-bit output current-control registers with 100-μA step size. Each of the 9 LED drivers has a separate output-current control register. The LED luminance pattern (dimming) is controlled with a PWM technique, which has 12-bit resolution during ramping and 8-bit user control. The LED current-sink PWM frequency is 20 kHz.
High 20-kHz PWM frequency and 12-bit control accuracy are achieved by using 3-bit dithering for PWM control. There is a 9-bit pure PWM resolution generated in the PWM generators, and one least-significant bit (1 LSB) is toggled in eight periods to output a smaller average step. For 3-bit dithering, every eighth pulse is made 1 LSB longer to increase the average value by 1 / 8th. Figure 12 shows an example of 9-bit PWM value, step of 4 / 8 (0.5) and its 12-bit representation.
A phase-shift PWM scheme allows delaying the time when each LED driver is active. When the LED drivers are not activated simultaneously, the peak load current from the charge-pump output is greatly decreased. This also reduces input-current ripple and ceramic-capacitor audible ringing. LED drivers are grouped into three different phases. In phase 1, the rising edge of the PWM pulse is fixed in time. In phase 2, the middle point of the PWM pulse is fixed, and the pulse spreads to both directions when PWM duty cycle is increased. Phase 3 has a fixed falling edge, that is, the rising edge of the pulse is changed when the duty cycle changes.
LED dimming is controlled according to an exponential or linear scale (see Figure 14) In exponential mode, the PWM output percent can be approximated by the following two equations:
All LP5569 LED drivers, LED0 to LED8, can be controlled independently through the two-wire serial I2C-compatible interface. For each low-side driver there is an 8-bit PWM control register which can be used to control the LED PWM duty-cycle value. This register cannot be written when the program execution engine is active, which could result in undesirable behavior. Care should be taken to update these registers only when the program execution engine is idle.
Engine control is used when the user wants to create programmed sequences. The program execution engine updates the direct-control registers when active. Therefore, if the user has set the PWM register to a certain value, it is automatically overridden when the program execution engine controls the driver. LED control and program-execution-engine operation is described in Programming.
In addition to LED-by-LED PWM register control, the LP5569 device is equipped with a master-fader control, which allows the user to fade in or fade out multiple LEDs from the EN/PWM pin or by writing to the master fader registers. This is a useful function to minimize serial bus traffic between the MCU and the LP5569 device. The LP5569 device has three master fader registers, so it is possible to form three master fader groups. Either writing master fader registers through the I2C interface directly or through LED engine control can set the master fader register values. The final output PWM duty cycle is the PWM register duty-cycle value multiplied by the duty-cycle value of the master fader register.
The EN/PWM pin provides a dual-function input. On power up, the pin functions as the device enable (EN) function, where the first rising edge enables the LP5569 device. After the chip_en bit is set high in the CONFIG register, the pin is reconfigured for PWM master-fader control of the LEDs. The LEDx_CONTROL register (addresses 07h–0Fh) MF_MAPPINGx bits = 5h configures LEDx for PWM control.
The PWM input is a sampled input which converts the input duty-cycle information into an 11-bit code. The use of a sampled input eliminates any noise and current ripple that is typical of traditional PWM-controlled LED drivers. The PWM input uses logic-level thresholds with VIH_MIN = 1.25 V and VIL_MAX = 0.4 V. Because this is a sampled input, there are limits on the maximum PWM input frequency as well as the resolution that can be achieved.
The PWM input frequency range is 100 Hz to 20 kHz. To achieve the full 11-bit maximum resolution of PWM duty cycle to the code, the input PWM duty cycle must be ≥ 11 bits, and the PWM sample period (1 / fSAMPLE) must be smaller than the minimum PWM input pulse duration. Figure 16 shows the possible brightness code resolutions based on the input PWM frequency.
To prevent jitter on the input PWM signal from feeding through the PWM path and causing oscillations in the LED current, the LP5569 device offers seven selectable hysteresis settings. The hysteresis works by forcing a specific number of 11-bit LSB code transitions to occur in the input duty cycle before the LED current changes. Table 1 describes the hysteresis. The hysteresis only applies during a change in direction of brightness currents. Once the change in direction has taken place, the PWM input must overcome the required LSB(s) of the hysteresis setting before the brightness change takes effect. Once the initial hysteresis has been overcome and the direction in brightness change remains the same, the PWM-to-current response changes with no hysteresis.
HYSTERESIS SETTING (0x80 bits [2:0]) |
MIN. CHANGE IN PWM PULSE DURATION (Δt) REQUIRED TO CHANGE LED CURRENT, AFTER DIRECTION CHANGE (for fPWM < 11.7 kHz) |
MIN. CHANGE IN PWM DUTY CYCLE (ΔD) REQUIRED TO CHANGE LED CURRENT AFTER DIRECTION CHANGE | MIN (ΔILED), INCREASE FOR INITIAL CODE | |
---|---|---|---|---|
EXPONENTIAL MODE | LINEAR MODE | |||
000 (0 LSB) | 1 / (fPWM × 2047) | 0.05% | 0.3% | 0.05% |
001 (1 LSB) | 1 / (f PWM× 1023) | 0.1% | 0.61% | 0.1% |
010 (2 LSB) | 1 / (fPWM × 511) | 0.2% | 1.21% | 0.2% |
011 (3 LSB) | 1 / (fPWM × 255) | 0.39% | 2.4% | 0.39% |
100 (4 LSB) | 1 / (fPWM × 127) | 0.78% | 4.74% | 0.78% |
101 (5 LSB) | 1 / (fPWM × 63) | 1.56% | 9.26% | 1.56% |
110 (6 LSB) | 1 / (fPWM × 31) | 3.12% | 17.66% | 3.12% |
The EN/PWM input timeout feature has two operating modes as follows:
The LP5569 device includes a pre-regulated switched-capacitor charge pump with a programmable voltage multiplication of 1× or 1.5×. In 1.5× mode, by combining the principles of a switched-capacitor charge pump and a linear regulator, a regulated 4.5-V output is generated from the VIN input within its normal voltage range. A two-phase non-overlapping clock, generated internally, controls the operation of the charge pump. During the charge phase, both flying capacitors (CFLY1 and CFLY2) are charged from input voltage. In the pump phase that follows, the flying capacitors are discharged to the output. A traditional switched-capacitor charge pump operating in this manner uses switches with very low on-resistance, ideally 0 Ω, to generate an output voltage that is 1.5× the input voltage. The LP5569 device regulates the output voltage by controlling the resistance of the input-connected pass-transistor switches in the charge pump.
The very low input-current ripple of the LP5569 device, resulting from internal pre-regulation, adds minimal noise to the input line. The core of the LP5569 device is very similar to that of a basic switched-capacitor charge pump: it is composed of switches and two flying capacitors (external). Regulation is achieved by controlling the current through the switches connected to the VIN pin (one switch in each phase). The regulation occurs before the voltage multiplication, giving rise to the term pre-regulation. It is pre-regulation that eliminates most of the input-current ripple that is a typical and undesirable characteristic of a many switched-capacitor converters.
The LP5569 device contains current-limit circuitry that protects the device in the event of excessive input current and/or output shorts to ground. The input current is limited to 600 mA (typical) when the output is shorted directly to ground. When the LP5569 device is current limiting, power dissipation in the device is likely to be quite high. In this event, thermal cycling should be expected.
The LP5569 device provides a feature to discharge the charge-pump output capacitor. The charge-pump output pulldown is not enabled when the MISC2 register (address 33h) CP_DIS_DISCH bit = 1. The charge pump output pulldown is enabled when the CP_DIS_DISCH bit = 0. The pulldown draws a minimal current from the output capacitor (300 μA typical) when in the SHUTDOWN and STANDBY states.
The charge pump is controlled with two CP_MODE bits in the MISC register (address 2Fh). When both of the bits are low, the charge pump is disabled, and output voltage is pulled down as described in Output Discharge. The charge pump can be forced to the bypass mode, so the battery voltage is connected directly to the current source; in 1.5× mode the output voltage is boosted to 4.5 V. In automatic mode, the charge-pump operation mode is determined by saturation of the constant-current drivers described in LED Forward Voltage Monitoring.
When the charge-pump automatic-mode selection is enabled, voltages on the LED current sinks LED0 to LED8 are monitored. If the current sinks do not have enough headroom, the charge pump gain is set to 1.5× and remains in 1.5× mode until one of the following occurs:
The red LED (R) element of an RGB LED typically has a forward voltage of about 2 V. These LEDs can be powered directly from the input voltage because battery voltage is typically high enough to drive red LEDs over the whole operating voltage range. This allows driving of three RGB LEDs with good efficiency because the red LEDs do not load the charge pump. When the LEDx_CONTROL (address 07h–0Fh) register EXTERNAL_POWERx bit = 1, the LEDx output is configured for external supply, and forward-voltage monitoring is disabled.
When the LED outputs are not active, the LP5569 device is able to enter the power-save mode automatically, thus lowering idle-current consumption down to 10 μA (typical). Automatic power-save mode is enabled when the MISC register (address 2Fh) POWERSAVE_EN bit = 1. Almost all analog blocks are powered down in power save, if an external clock signal is used. The charge pump enters the weak 1× mode using a passive current-limited keep-alive switch, which keeps the output voltage at the battery level to reduce output-voltage transients.
During program execution, the LP5569 device can enter power save if there is no PWM activity in any of the LED driver outputs. To prevent short power-save sequences during program execution, the device has an instruction look-ahead filter. In power-save mode, program execution continues without interruption. When an instruction that requires PWM activity is executed, a fast internal start-up sequence is started automatically.
The LP5569 device implements a thermal shutdown mechanism to protect the device from damage due to overheating. When the junction temperature rises to 150°C (typical), the device switches into shutdown mode. The LP5569 device releases thermal shutdown when the junction temperature of the device decreases to 130°C (typical).
Thermal shutdown is most often triggered by self-heating, which occurs when there is excessive power dissipation in the device and/or insufficient thermal dissipation. LP5569 power dissipation increases with increased output current and input voltage. When self-heating brings on thermal shutdown, thermal cycling is the typical result. Thermal cycling is the repeating process where the part self-heats, enters thermal shutdown (where internal power dissipation is practically zero), cools, turns on, and then heats up again to the thermal shutdown threshold. Thermal cycling is recognized by a pulsing output voltage and can be stopped by reducing the internal power dissipation (reduce input voltage and/or output current) or the ambient temperature. If thermal cycling occurs under desired operating conditions, thermal dissipation performance must be improved to accommodate the power dissipation of the LP5569 device. The QFN package is designed to have excellent thermal properties that, when soldered to a PCB designed to aid thermal dissipation, allows the LP5569 device to operate under very demanding power-dissipation conditions.
The LP5569 device has an internal comparator that monitors the voltage at VIN. If the input voltage drops to 2.2 V (nominal), undervoltage is detected, the LED outputs and the charge pump shut down, and the corresponding fault bit is set in the fault register. Hysteresis is implemented for the threshold level to avoid continuous triggering of a fault when the threshold is reached. If the input voltage rises above 2.3 V (nominal), the LP5569 device resumes normal operation.
The LP5569 device has internal comparators that monitor the voltages at VIN and V1P8. When VVIN is below 2.2 V or V1P8 is below 1.3 V, reset is active and the LP5569 device is in the DISABLED state.
The LP5569 device contains both open-LED and shorted-LED fault detection. These fault detections are designed to be used in production-level testing and not normal operation. For the fault flags to operate, they must be enabled via the MISC2 register (address 33h) LED_OPEN_TEST and LED_SHORT_TEST bits. The fault flags are shared by both open-LED and shorted-LED tests so only one can be enabled at a time. The default LED-fault status is ready in the LED_FAULT1 and LED_FAULT2 registers (addresses 81h and 82h). The following sections detail the proper procedure for reading back open and short faults in the LED strings.
The LP5569 device features one fault flag per LED, indicating one or more of the active low-voltage LED strings are open. An open in a low-voltage LED string is flagged if the voltage at the input to any active low-voltage current sink goes below the drv_headroom[1:0] setting in the MISC2 register. The procedure for detecting an open-LED fault is:
The LP5569 device features one fault flag per LED, indicating when any active LED is shorted (anode to cathode). During the LED short test, the charge pump is forced to the 1× mode. A short in the LED is determined when the LED voltage (VIN –V LEDx) falls below 1 V. The procedure for detecting a shorted-LED fault is:
The LP5569 device can generate a 32-kHz clock signal and use it for synchronizing multiple devices. The CLK pin is configured as an input by default. When the EN_CLK_OUT bit = 1 in the IO_CONTROL register (address 3Dh) the LP5569 device drives the CLK pin using its 32-kHz oscillator.
The GPIO/TRIG/INT pin is configured by the GPIO_CONFIG bits in the IO_CONTROL register (address 3Dh). The default configuration for this pin is the INT function.
The I2C-compatible two-wire serial interface provides access to the programmable functions and registers on the device. This protocol uses a two-wire interface for bidirectional communications between the devices connected to the bus. The two interface lines are the serial data line (SDA) and the serial clock line (SCL). Every device on the bus is assigned a unique address and acts as either a master or a slave depending on whether it generates or receives the serial clock, SCL. The SCL and SDA lines should each have a pullup resistor placed somewhere on the line and remain HIGH even when the bus is idle. Note: the CLK pin is not used for serial bus data transfer.
The data on SDA line must be stable during the HIGH period of the clock signal (SCL). In other words, state of the data line can only be changed when clock signal is LOW.
START and STOP conditions classify the beginning and the end of the data transfer session. A START condition is defined as the SDA signal transitioning from HIGH to LOW while SCL line is HIGH. A STOP condition is defined as the SDA transitioning from LOW to HIGH while SCL is HIGH. The bus master always generates START and STOP conditions. The bus is considered to be busy after a START condition and free after a STOP condition. During data transmission, the bus master can generate repeated START conditions. First START and repeated START conditions are functionally equivalent.
Every byte put on the SDA line must be eight bits long, with the most significant bit (MSB) being transferred first. Each byte of data must be followed by an acknowledge bit. The acknowledge-related clock pulse is generated by the master. The master releases the SDA line (HIGH) during the acknowledge clock pulse. The LP5569 device pulls down the SDA line during the ninth clock pulse, signifying an acknowledge. The LP5569 device generates an acknowledge after each byte has been received.
There is one exception to the acknowledge after every byte rule. When the master is the receiver, it must indicate to the transmitter an end of data by not-acknowledging (negative acknowledge) the last byte clocked out of the slave. This negative acknowledge still includes the acknowledge clock pulse (generated by the master), but the SDA line is not pulled down.
After the START condition, the bus master sends a device address. This address is seven bits long followed by an eighth bit which is a data direction bit (READ or WRITE). For the eighth bit, a 0 indicates a WRITE, and a 1 indicates a READ. The second byte selects the register to which the data is to be written. The third byte contains data to write to the selected register.
The LP5569 slave address is defined by connecting GND, SCL, SDA, or VIN to the ADDR pin. A total of four slave addresses can be realized by combinations when GND, SCL, SDA, or VIN is connected to the ADDR pin (see Table 2).
The LP5569 device is available in two versions (LP5569 and LP5569A). Each version has four possible address settings, which allows up to eight devices sharing the same I2C bus as shown in Table 2. Values are in 7-bit slave ID format. The LP5569 device responds to slave address 40h regardless of the setting of the ADDR pin and device version. Global writes to address 40h can be used for configuring all devices simultaneously. The LP5569 device supports global read using slave address 40h; however, the data read is only valid if all LP5569 devices on the I2C bus contain the same value in the register read.
SLAVE ID | VERSION | ADDR |
32h and 40h | GND | |
33h and 40h | SCL | |
34h and 40h | SDA | |
35h and 40h | VIN | |
42h and 40h | A | GND |
43h and 40h | A | SCL |
44h and 40h | A | SDA |
45h and 40h | A | VIN |
The auto-increment feature allows writing several consecutive registers within one transmission. Every time an 8‑bit word is sent to the LP5569 device, the internal address index counter is incremented by 1, and the next register is written. The auto-increment feature is enabled by default and can be disabled by setting the EN_AUTO_INCR bit = 0 in the MISC register (address 2Fh).
The LP5569 device provides flexibility and programmability for dimming and sequencing control. Each LED can be controlled directly and independently through the serial bus, or LED drivers can be grouped together for pre-programmed flashing patterns.
The LP5569 device has three independent program execution engines, so it is possible to form three independently programmable LED banks. LED drivers can be grouped based on their function so that, for example, the first bank of drivers can be assigned to the keypad illumination, the second bank to the funlights, and the third group to the indicator LED(s). Each bank can contain 1 to 9 LED driver outputs. Instructions for program execution engines are stored in the program memory. The total amount of the program memory is 255 instructions, and the user can allocate the instructions as required by the engines; however, a single engine can only allocate up to ½ the memory (128 instructions).
The LP5569 device has internal SRAM for the three LED engines. SRAM can contain up to 255 16-bit instructions (addresses 0 through 254) with a maximum size of 128 16-bit instructions for a single engine. SRAM memory address 255 is reserved and must not be allocated to any LED engine. Memory allocation among the three LED engines is done dynamically, so that each LED engine has a separate start address and program counter (PC) that are set in the ENGINEx_PROG_START registers (addresses 4Bh, 4Ch, 4Dh) and ENGINEx_PC registers (addresses 30h, 31h, 32h). This allows flexible memory allocation among the LED engines, and multiple engines can recall the same memory address. The program counter uses relative memory addressing; when the PC is zero the engine is executing an instruction at its start address.
The SRAM is loaded via the I2C interface in 33-byte-length pages. The first byte contains the program-memory-page-select (address 4Fh) followed by up to 32 bytes containing compiled program execution engine instructions (address 50h thru 6Fh). Engines must be set to load the program mode (register 01h) before writing the SRAM.
The LP5569 device has four LED engine variables which are divided into local and global variables. Variables A and B are engine-specific local variables and each of the three engines has separate A and B variables, so there is a total of six A and B variables. Variable A can be read and written via I2C registers 42h–44h. Local variable B is not available via I2C and can only be accessed by the LED engine. Variables C and D are global variables which are shared by all three LED engines. Global variable C is not available via I2C and can only be accessed by the LED engines. The D variable can be read and written via I2C register 3Eh. Variables are referenced to instructions with 2 bits, see Table 3 for details. Note that some instructions (ld, add, sub) can use only variables A, B, and C as target variables.
VARIABLE | BITS | LOCAL/GLOBAL |
A | 00 | Local |
B | 01 | Local |
C | 10 | Global |
D | 11 | Global |
The LP5569 device has three independent programmable execution engines. All the program execution engines have their own program memory block allocated by the user. The maximum program size for any one engine is limited to 128 locations. At least one engine must be in the load-program mode with the engine-busy bit cleared before writing to any program memory address. Program execution is clocked with a 32.768-kHz clock. Instruction execution takes sixteen clock cycles (488 μs). This applies also to ramp and wait instructions where execution time is a multiple of 488 μs. This clock can be generated internally or an external clock can be supplied to the CLK pin. Using an external clock enables synchronization of LED timing to the external clock signal and is also more power-efficient. The supported instruction set is listed in Table 4 through Table 6. The LP5569 device is fully compatible with the LP5523 instruction set. A command compiler is available for easy sequence programming. With the command compiler it is possible to write sequences with simple ASCII commands, which are then converted to binary or hex format.
INSTRUCTION | USAGE | COMPILER EXAMPLE |
ramp(1) | Generate a programmable PWM ramp to mapped LED driver(s) from the current value to a new value in steps of +1 or –1 with programmed step time. | ramp 0.6, 255; ramp to full scale in 0.6 s |
ramp(2) | ramp var1, prescale, var2 var1 is a variable (ra, rb, rc, rd); prescale is a boolean constant (pre = 0 or pre = 1); Var2 is a variable (ra, rb, rc, rd). Output PWM with increasing or decreasing duty cycle. | ld ra, 31 ld rb, 255 ramp ra, pre=0, +rb; ramp up to full scale over 3.9 s. |
set_pwm(1) | Set PWM or current value to mapped LED driver(s), effective immediately. | set_pwm 128; set duty cycle to 50%. |
set_pwm(2) | set_pwm var1 Var1 is a variable (ra, rb, rc, rd). Generate a continuous PWM output. | ld rc, 128; set_pwm rc; set PWM duty cycle to 50%. |
wait | Wait for a given time. Time span is from 0.488 ms to 484 ms. | wait 0.4; wait for 0.4 s; wait for 0.4 s |
INSTRUCTION(1) | ACT(2) | USAGE | COMPILER EXAMPLE |
load_start | Define the LED mapping-table start address in SRAM. | load_start 01h; starting address at 01h | |
map_start | x | Define the LED mapping-table start address in SRAM and set that address active. | map_start 01h; starting address at 01h |
load_end | Define the last address of the LED mapping table in SRAM. | load_end 03h; last address at 03h | |
map_sel | x | Connect one LED driver to the LED engine. | map_sel 0; select LED0 as output |
map_clr | x | Clear the LED driver mappings in an engine | map_clr |
map_next | x | Select the next address in the LED mapping table and set that address active. | map_next |
map_prev | x | Select the previous address in the LED mapping table and set that address active. | map_prev |
load_next | Move the mapping-table pointer to the next address. | load_next | |
load_prev | Move the mapping-table pointer to the previous address. | load_prev | |
load_addr | Set the mapping-table pointer to the assigned address. | load_addr 02h; set pointer to 02h | |
map_addr | x | Set the mapping-table pointer to the assigned address and set that address active. | map_addr 02h; set mapping to 02h |
INSTRUCTION | USAGE | COMPILER EXAMPLE |
rst | Reset program counter to zero. | Reset |
branch(1) | Branch to address. The number of loops can be set to a value or do an infinite loop. | branch 20, loop1; do 20 loops to loop1 label |
branch(2) | Branch to address. The loop count can be one of four variables A, B, C, or D. | ld ra, 20 branch ra, loop1; do 20 loops to loop1 label |
int | Send an interrupt to the host system by pulling the GPIO/TRIG/INT pin low. | int |
end | End program execution and reset the program counter to zero. Can also the set GPIO/TRIG/INT pin high and/or reset mapped LED PWM and engine LED mapping. | end; end and reset LEDs. |
trigger | Wait or send trigger. The trigger can be sent or received from an external pin or another engine. | trigger w{e}; wait for external trigger |
trig_clear(3) | Clear pending triggers. | trig_clear |
jne | Jump if not equal. A != B | Jump to loop1 if A != B: jne ra, rb, loop1 |
jl | Jump if less. A < B | Jump to loop1 if A < B : jl ra, rb, loop1 |
jge | Jump if greater or equal. A ≥ B | Jump to loop1 if A >= B: jge ra, rb, loop1 |
je | Jump if equal. A = B | Jump to loop1 if A = B: je ra, rb, loop1 |
INSTRUCTION | USAGE | COMPILER EXAMPLE |
ld(1) | Assign a value to a variable. | ld ra, 33; load value 33h to local variable A |
add(1) | Add the 8-bit value to the variable value. | add ra, 11; add value 11h to local variable A |
add(2) | Add the value of variable 3 (global variable D) to the value of variable 2 (global variable C) and store the result in variable 1 (local variable A). | add ra, rc, rd; add the value in rd to rc and store in ra |
sub(1) | Subtract the 8-bit value from the variable value. | sub ra, 11; subtract value 11h from local variable A |
sub(2) | Subtract the value of variable 3 (global variable D) from the value of variable 2 (global variable C) and store the result in variable 1 (local variable A). | sub ra, rc, rd; subtract the value in rd from rc and store in ra |
INST. | Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit [7] | Bit [6] | Bit [5] | Bit [4] | Bit [3] | Bit [2] | Bit [1] | Bit [0] |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ramp(1) | 0 | pre- scale | step time | sign | no. of increments | |||||||||||
ramp(2) | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | pre- scale | sign | step time | no. of increments | ||
set_pwm(1) | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | PWM value | |||||||
set_pwm(2) | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | PWM value | |
wait | 0 | pre- scale | time | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
This is the instruction useful for smoothly changing from one PWM value into another PWM value on the LED0 to LED8 outputs —in other words, generating ramps with a negative or positive slope. The LP5569 device allows the programming of very fast and very slow ramps using only a single instruction. Full ramp 0 to 255 ramp time ranges from 124 ms to 4 s.
The ramp instruction generates a PWM ramp, using the effective PWM value as a starting value. At each ramp step the output is incremented or decremented by 1, unless the number of increments is 0. The time span for one ramp step is defined with the prescale bit [14] and step-time bits [13:9]. The ramp instruction controls the eight most-significant bits (MSB) of the PWM values and the remaining bits are interpolated as ramp mid-values internally for smoother transition.
Prescale = 0 sets a 0.49-ms cycle time and prescale = 1 sets a 15.6-ms cycle time; so the minimum time span for one step is 0.49 ms (prescale × step time span = 0.49 ms × 1) and the maximum time span is 15.6 ms × 31 = 484 ms/step. If all the step-time bits [13:9] are set to zero, the output value is incremented or decremented during one prescale on the whole time cycle.
The number-of-increments value defines how many steps are taken during one ramp instruction: the increment maximum value is 255, which corresponds to an increment from zero value to the maximum value. If PWM reaches the minimum or maximum value (0 or 255) during the ramp instruction, the ramp instruction is executed to the end regardless of saturation. This enables ramp instruction to be used as a combined ramp-and-wait instruction. Note: the ramp instruction is a wait instruction when the increment bits [7:0] are set to zero.
Programming ramps with variables is very similar to programming ramps with numerical operands. The only difference is that step time and number of increments are captured from variable registers when the instruction execution is started. If the variables are updated after starting the instruction execution, it has no effect on instruction execution. Again, at each ramp step the output is incremented or decremented by 1 unless the step time is 0 or the number of increments is 0. The time span for one step is defined with the prescale and step-time bits. The step time is defined with variable A, B, C, or D. Variable A is set by an I2C write to the engine 1, 2, or 3 variable A register or the ld instruction, variables B and C are set with the ld instruction, and variable D is set by an I2C write to the variable D register.
Setting the EXP_EN bit of registers 07h–0Fh high or low sets the exponential (1) or linear ramp (0). By using the exponential ramp setting, the visual effect appears like a linear ramp to the human eye.
INST. | Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit [7] | Bit [6] | Bit [5] | Bit [4] | Bit [3] | Bit [2] | Bit [1] | Bit [0] |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ramp(1) | 0 | pre- scale | step time | sign | no. of increments | |||||||||||
ramp(1) | 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | pre- scale | sign | step-time variable | no.-of-increments variable |
PARAMETER NAME | NUMERIC OR VARIABLE | VALUE (d) | DESCRIPTION |
---|---|---|---|
prescale | Numeric | 0 | 32.7 kHz / 16 ≥ 0.488 ms cycle time |
1 | 32.7 kHz / 512 ≥ 15.625 ms cycle time | ||
sign | Numeric | 0 | Increase PWM output |
1 | Decrease PWM output | ||
step time | Numeric | 1–31 | One ramp increment done is in step time × prescale. Value in the variable A, B, C, or D must be from 1 to 31 for correct operation. |
Variable | 0–3 | ||
no. of increments | Numeric | 0–255 | The number of ramp cycles. Variables A to D as input. |
Variable | 0–3 |
An example of generating a 1.5-s ramp from PWM value 140 (approximately 55%) to 148 (approximately 58%). The ramp instruction uses relative values, so in this example we must ramp 8 steps up, as shown in Figure 25. The parameters for the RAMP instruction are:
This instruction is used for setting the PWM value on outputs LED0 to LED8 without any ramps. Set the PWM output value from 0 to 255 with PWM value bits [7:0]. Instruction execution takes 16 32-kHz clock cycles
(= 488 µs).
When a wait instruction is executed, the engine is set in wait status, and the PWM values on the outputs are frozen. Note: A wait instruction with prescale and time = 0 is invalid and is executed as rst.
NAME | VALUE (d) | DESCRIPTION |
---|---|---|
prescale | 0 | Divide master clock (32.7 kHz) by 16 which means 0.488 ms cycle time. |
1 | Divide master clock (32.7 kHz) by 512 which means 15.625 ms cycle time. | |
time | 1–31 | Total wait time is = (time) × (prescale). Maximum 484 ms, minimum 0.488 ms. |
These instructions define the engine-to-LED mapping. The mapping information is stored in a table, which is stored in the lower half of SRAM (program memory of the LP5569 device). The LP5569 device has three program execution engines which can be mapped to nine LED drivers. One engine can control one or multiple LED drivers. Execution engine 1 has priority over execution engines 2 and 3, with execution engine 2 having priority over execution engine 3. If an LED is mapped to more than one execution engine, the higher-priority engine controls the LED.
LED mapping instructions can be divided to two groups:
When an engine is actively mapped to the LEDs, the engine takes over the LED PWM control, and PWM control registers have no effect. Register control is returned when the engine is mapped to another LED. See Figure 26 for a simplified diagram of LED-engine data flow. The engine does not push a new PWM value to the LED driver output before the set_pwm or ramp instruction is executed. If the mapping has been released from an LED, the value in the PWM register still controls the LED brightness, and the PWM register value remains in the last engine state.
Actual PWM control resolution of the LED engines is 12 bits, but only the 8 highest bits are visible in the I2C registers. Also, engine commands use the 8 high bits for control, and the 4 low bits are used for smoother ramps.
All LED mapping instructions use the SRAM bit to LEDx pin mapping as shown in Table 10.
Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit[7] | Bit[6] | Bit[5] | Bit[4] | Bit[3] | Bit[2] | Bit[1] | Bit 0 | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LED mapping table in SRAM | — | — | — | — | — | — | 0 | LED8 | LED7 | LED6 | LED5 | LED4 | LED3 | LED2 | LED1 | LED0 |
Bit[9] is to enable master fader control by the engine. If this bit is set to 1 in engine 1, then master fader 1 is enabled.
INST. (1) | Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit [7] | Bit [6] | Bit [5] | Bit [4] | Bit [3] | Bit [2] | Bit [1] | Bit [0] |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
load_start | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 0 | 0 | SRAM addresses 0–127(2) | ||||||
map_start | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | SRAM addresses 0–127(2) | ||||||
load_end | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 | SRAM addresses 0–127(2) | ||||||
map_sel | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | LED select(3) | ||||||
map_clr | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
map_next | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
map_prev | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
load_next | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
load_prev | 1 | 0 | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 1 |
load_addr | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 0 | SRAM addresses 0–127(2) | ||||||
map_addr | 1 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | SRAM addresses 0–127(2) |
The load_start and load_end instructions define the mapping table locations in SRAM.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
SRAM address | 0–127 | Mapping table start or end address restricted to lower half of memory. |
The map_start instruction defines the mapping table start address in the memory, and the first row of the table is activated (mapped) at the same time.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
SRAM address | 0–127 | Mapping table start address restricted to lower half of memory. |
With the map_sel instruction one, and only one, LED driver can be connected to a program execution engine. Connecting multiple LEDs to one engine is done with the mapping table. After the mapping has been released from an LED, the PWM register value still controls the LED brightness.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
LED select | 0–127 | 0 = no drivers selected | |
1 = LED1 selected | |||
2 = LED1 selected | |||
... | |||
9 = LED9 selected | |||
10–127 = no drivers selected |
The map_clr instruction clears engine-to-driver mapping. After the mapping has been released from an LED, the PWM register value still controls the LED brightness.
This instruction sets the next row active in the mapping table each time it is called. For example, if the second row is active at this moment, after the map_next instruction call the third row is active. If the mapping table end address is reached, activation rolls to the mapping-table start address the next time when the map_next instruction is called. The engine does not push a new PWM value to the LED driver output before the set_pwm or ramp instruction is executed. If the mapping has been released from an LED, the value in the PWM register still controls the LED brightness.
Similar to the map_next instruction with the exception that no mapping is set. The index pointer is set to point to the next row and the engine-to-LED-driver connection is not updated.
This instruction sets the previous row active in the mapping table each time it is called. For example, if the third row is active at this moment, after the map_prev instruction call the second row is active. If the mapping table start address is reached, activation rolls to the mapping table end address next time the map_prev instruction is called. The engine does not push a new PWM value to the LED driver output before the set_pwm or ramp instruction is executed. If the mapping has been released from an LED, the value in the PWM register still controls the LED brightness.
Similar to the map_prev instruction with the exception that no mapping is set. The index pointer is set to point to the previous row and the engine-to-LED-driver connection is not updated.
The map_addr instruction sets the index pointer to point to the mapping table row defined by bits [6:0] and sets the row active. The engine does not push a new PWM value to the LED driver output before the set_pwm or ramp instruction is executed. If the mapping has been released from an LED, the value in the PWM register still controls the LED brightness.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
SRAM address | 0–127 | SRAM address containing mapping data restricted to lower half of memory. |
The load_addr instruction sets the index pointer to point to the mapping table row defined by bits [6:0], but the row is not set active.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
SRAM address | 0–127 | SRAM address containing mapping data restricted to lower half of memory. |
The branch instruction is provided for repeating a portion of the program code several times. The branch instruction loads a step number value to the program counter. A loop count parameter defines how many times the instructions inside the loop are repeated. The step number is loaded into the PC when the instruction is executed. The PC is relative to the ENGINEx_PROG_START register setting. The LP5569 device supports nested looping, that is, a loop inside a loop. The number of nested loops is not limited. The instruction takes 16 32-kHz clock cycles.
INST. | Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit [7] | Bit [6] | Bit [5] | Bit [4] | Bit [3] | Bit [2] | Bit [1] | Bit [0] |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
rst | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
branch(1) | 1 | 0 | 1 | loop count | step number | |||||||||||
branch(2) | 1 | 0 | 0 | 0 | 0 | 1 | 1 | step number | loop count | |||||||
int | 1 | 1 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
end | 1 | 1 | 0 | int | reset | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
trigger | 1 | 1 | 1 | wait for trigger | send a trigger | 0 | ||||||||||
ext trig | X(3) | X(3) | E3 | E2 | E1 | ext trig | X(3) | X(3) | E3 | E2 | E1 | |||||
trig_clear (4) |
1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
jne | 1 | 0 | 0 | 0 | 1 | 0 | 0 | Number of instructions to be skipped if the operation returns true | variable 1 | variable 2 | ||||||
jl | 1 | 0 | 0 | 0 | 1 | 0 | 1 | Number of instructions to be skipped if the operation returns true | variable 1 | variable 2 | ||||||
jge | 1 | 0 | 0 | 0 | 1 | 1 | 0 | Number of instructions to be skipped if the operation returns true | variable 1 | variable 2 | ||||||
je | 1 | 0 | 0 | 0 | 1 | 1 | 1 | Number of instructions to be skipped if the operation returns true | variable 1 | variable 2 |
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
loop count(1) | 0–63 | The number of loops to be done. 0 means an infinite loop. | |
step number | 0–127 | The step number to be loaded to program counter. | |
loop count(2) | 0–3 | Selects the variable for loop count value. Loop count is loaded with the value of the variable defined below. | |
0 = Local variable A | |||
1 = Local variable B | |||
2 = Global variable C | |||
3 = Global variable D |
Send an interrupt to the processor by pulling the INT pin down and setting the corresponding status bit high. Interrupts can be cleared by reading the interrupt bits in the ENGINE_STATUS register at address 3Ch.
The rst instruction resets the program counter register (address 30h, 31h, or 32h) and continues executing the program from the program the start address defined in register addresses 4Bh–4Dh. The instruction takes 16 32‑kHz clock cycles. Note that default value for all program memory registers is 0000h, which is the rst instruction.
End program execution. The instruction takes 16 32-kHz clock cycles.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
int | 0 | No interrupt is sent. PWM register values remain intact. | |
1 | Reset program counter value to 0 and send interrupt to processor by pulling the INT pin down and setting the corresponding status bit high to notify that the program has ended. PWM register values remain intact. Interrupts can be cleared by reading the interrupt bits in STATUS/INTERRUPT register at address 3Ch. | ||
reset | 0 | Reset program counter value to 0 and hold. PWM register values remain intact. | |
1 | Reset program counter value to 0 and hold. PWM register values of the non-mapped drivers remain. PWM register values of the mapped drivers are set to 0000 0000b. |
The wait-for-trigger or send-a-trigger instruction can be used to synchronize operation between the program execution engines. Sending a trigger instruction takes 16 32-kHz clock cycles and waiting for a trigger takes at least 16 32-kHz clock cycles. The receiving engine stores the triggers that have been sent. Received triggers are cleared by the wait-for-trigger instruction or trig_clear instruction. The wait-for-trigger instruction is executed until all the defined triggers have been received. (Note: several triggers can be defined in the same instruction.) The external-trigger input signal must stay low for at least two 32-kHz clock cycles to be executed. The trigger output signal is three 32-kHz clock cycles long. The external trigger signal is active-low; for example, when a trigger is sent or received, the pin is pulled to GND. Sending an external trigger is masked; that is, the device which has sent the trigger does not recognize the trigger it sent. If send and wait external triggers are used on the same instruction, the send external trigger is executed first, followed by the wait external trigger.
The trig_clear instruction clears pending triggers for a single execution engine. Use this instruction in each execution engine at the beginning of program execution to clear any pending triggers. Pending triggers are always cleared whenever the engine mode is in the disabled state or load program to SRAM (see SRAM Memory).
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
wait for trigger | 0–31 | Wait for trigger from the engine(s). Several triggers can be defined in the same instruction. Bit [7]: Wait for trigger from engine 1. Bit [8]: Wait for trigger from engine 2. Bit [9]: Wait for trigger from engine 3. Bit [12]: Wait for trigger from GPIO/TRIG/INT pin. Bits [10] and [11] are not used. |
|
send a trigger | 0–31 | Send a trigger to the engine(s). Several triggers can be defined in the same instruction. Bit [1]: Send trigger to engine 1. Bit [2]: Send trigger to engine 2. Bit [3]: Send trigger to engine 3. Bit [6]: Send trigger to GPIO/TRIG/INT pin. Bits [4] and [5]: are not used. |
The LP5569 instruction set includes the following conditional jump instructions: jne (jump if not equal); jge (jump if greater or equal); jl (jump if less); je (jump if equal). If the condition is true, a certain number of instructions are skipped (that is, the program jumps forward to a location relative to the present location). If the condition is false, the next instruction is executed.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
Number of instructions to be skipped if the operation returns true. | 0–31 | The number of instructions to be skipped when the statement is true. Note: value 0 means redundant code. |
|
variable 1 | 0–3 | Defines the variable to be used in the test: 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
|
variable 2 | 0–3 | Defines the variable to be used in the test: 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
INST. | Bit [15] | Bit [14] | Bit [13] | Bit [12] | Bit [11] | Bit [10] | Bit [9] | Bit [8] | Bit [7] | Bit [6] | Bit [5] | Bit [4] | Bit [3] | Bit [2] | Bit [1] | Bit [0] |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ld | 1 | 0 | 0 | 1 | target variable | 0 | 0 | 8-bit value 0 | ||||||||
add(1) | 1 | 0 | 0 | 1 | target variable | 0 | 1 | 8-bit value 0 | ||||||||
add(2) | 1 | 0 | 0 | 1 | target variable | 1 | 1 | 0 | 0 | 0 | 0 | var 1 | var 2 | |||
sub(1) | 1 | 0 | 0 | 1 | target variable | 1 | 0 | |||||||||
sub(2) | 1 | 0 | 0 | 1 | target variable | 1 | 1 | 0 | 0 | 0 | 1 | var 1 | var 2 |
This instruction is used to assign a value into a variable; the previous value in that variable is overwritten. Each of the engines has two local variables, called A and B. The variable C is a global variable.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
target variable | 0–2 | 0 = Variable A 1 = Variable B 2 = Variable C |
|
8-bit value | 0–255 | Variable value |
This operator either adds an 8-bit value to the current value of the target variable, or adds the value of variable 1 (A, B, C, or D) to the value of variable 2 (A, B, C, or D) and stores the result in the register of variable A, B, or C. Variables overflow from 255 to 0.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
8-bit value(1) | 0–255 | The value to be added. | |
target variable | 0–2 | 0 = Variable A 1 = Variable B 2 = Variable C |
|
variable 1(2) | 0–3 | 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
|
variable 2(2) | 0–3 | 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
The SUB operator either subtracts an 8-bit value from the current value of the target variable, or subtracts the value of variable 2 (A, B, C, or D) from the value of variable 1 (A, B, C, or D) and stores the result in the register of the target variable (A, B, or C). Variables overflow from 0 to 255.
NAME | VALUE (d) | DESCRIPTION | |
---|---|---|---|
8-bit value(1) | 0–255 | The value to be subtracted. | |
target variable | 0–2 | 0 = Variable A 1 = Variable B 2 = Variable C |
|
variable 1(2) | 0–3 | 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
|
variable 2(2) | 0–3 | 0 = Local variable A 1 = Local variable B 2 = Global variable C 3 = Global variable D |
Table 14 lists the memory-mapped registers for the LP5569_MAP. All register offset addresses not listed in Table 14 should be considered as reserved locations and the register contents should not be modified.
ADDRESS | ACRONYM | REGISTER NAME | SECTION |
---|---|---|---|
0h | CONFIG | Configuration Register | Go |
1h | LED_ENGINE_CONTROL1 | Engine Execution Control Register | Go |
2h | LED_ENGINE_CONTROL2 | Engine Operation Mode Register | Go |
7h | LED0_CONTROL | LED0 Control Register | Go |
8h | LED1_CONTROL | LED1 Control Register | Go |
9h | LED2_CONTROL | LED2 Control Register | Go |
Ah | LED3_CONTROL | LED3 Control Register | Go |
Bh | LED4_CONTROL | LED4 Control Register | Go |
Ch | LED5_CONTROL | LED5 Control Register | Go |
Dh | LED6_CONTROL | LED6 Control Register | Go |
Eh | LED7_CONTROL | LED7 Control Register | Go |
Fh | LED8_CONTROL | LED8 Control Register | Go |
16h | LED0_PWM | LED0 PWM Duty Cycle | Go |
17h | LED1_PWM | LED1 PWM Duty Cycle | Go |
18h | LED2_PWM | LED2 PWM Duty Cycle | Go |
19h | LED3_PWM | LED3 PWM Duty Cycle | Go |
1Ah | LED4_PWM | LED4 PWM Duty Cycle | Go |
1Bh | LED5_PWM | LED5 PWM Duty Cycle | Go |
1Ch | LED6_PWM | LED6 PWM Duty Cycle | Go |
1Dh | LED7_PWM | LED7 PWM Duty Cycle | Go |
1Eh | LED8_PWM | LED8 PWM Duty Cycle | Go |
22h | LED0_CURRENT | LED0 Current Control | Go |
23h | LED1_CURRENT | LED1 Current Control | Go |
24h | LED2_CURRENT | LED2 Current Control | Go |
25h | LED3_CURRENT | LED3 Current Control | Go |
26h | LED4_CURRENT | LED4 Current Control | Go |
27h | LED5_CURRENT | LED5 Current Control | Go |
28h | LED6_CURRENT | LED6 Current Control | Go |
29h | LED7_CURRENT | LED7 Current Control | Go |
2Ah | LED8_CURRENT | LED8 Current Control | Go |
2Fh | MISC | I2C, Charge Pump and Clock Configuration | Go |
30h | ENGINE1_PC | Engine1 Program Counter | Go |
31h | ENGINE2_PC | Engine2 Program Counter | Go |
32h | ENGINE3_PC | Engine3 Program Counter | Go |
33h | MISC2 | Charge Pump and LED Configuration | Go |
3Ch | ENGINE_STATUS | Engine 1, 2 & 3 Status | Go |
3Dh | IO_CONTROL | TRIG, INT and CLK Configuration | Go |
3Eh | VARIABLE_D | Global Variable D | Go |
3Fh | RESET | Software Reset | Go |
42h | ENGINE1_VARIABLE_A | Engine 1 Local Variable A | Go |
43h | ENGINE2_VARIABLE_A | Engine 2 Local Variable A | Go |
44h | ENGINE3_VARIABLE_A | Engine 3 Local Variable A | Go |
46h | MASTER_FADER1 | Engine 1 Master Fader | Go |
47h | MASTER_FADER2 | Engine 2 Master Fader | Go |
48h | MASTER_FADER3 | Engine 3 Master Fader | Go |
4Ah | MASTER_FADER_PWM | PWM Input Duty Cycle | Go |
4Bh | ENGINE1_PROG_START | Engine 1 Program Starting Address | Go |
4Ch | ENGINE2_PROG_START | Engine 2 Program Starting Address | Go |
4Dh | ENGINE3_PROG_START | Engine 2 Program Starting Address | Go |
4Fh | PROG_MEM_PAGE_SELECT | Program Memory Page Select | Go |
50h | PROGRAM_MEM_00 | MSB 0 | Go |
51h | PROGRAM_MEM_01 | LSB 0 | Go |
52h | PROGRAM_MEM_02 | MSB 1 | Go |
53h | PROGRAM_MEM_03 | LSB 1 | Go |
54h | PROGRAM_MEM_04 | MSB 2 | Go |
55h | PROGRAM_MEM_05 | LSB 2 | Go |
56h | PROGRAM_MEM_06 | MSB 3 | Go |
57h | PROGRAM_MEM_07 | LSB 3 | Go |
58h | PROGRAM_MEM_08 | MSB 4 | Go |
59h | PROGRAM_MEM_09 | LSB 4 | Go |
5Ah | PROGRAM_MEM_10 | MSB 5 | Go |
5Bh | PROGRAM_MEM_11 | LSB 5 | Go |
5Ch | PROGRAM_MEM_12 | MSB 6 | Go |
5Dh | PROGRAM_MEM_13 | LSB 6 | Go |
5Eh | PROGRAM_MEM_14 | MSB 7 | Go |
5Fh | PROGRAM_MEM_15 | LSB 7 | Go |
60h | PROGRAM_MEM_16 | MSB 8 | Go |
61h | PROGRAM_MEM_17 | LSB 8 | Go |
62h | PROGRAM_MEM_18 | MSB 9 | Go |
63h | PROGRAM_MEM_19 | LSB 9 | Go |
64h | PROGRAM_MEM_20 | MSB 10 | Go |
65h | PROGRAM_MEM_21 | LSB 10 | Go |
66h | PROGRAM_MEM_22 | MSB 11 | Go |
67h | PROGRAM_MEM_23 | LSB 11 | Go |
68h | PROGRAM_MEM_24 | MSB 12 | Go |
69h | PROGRAM_MEM_25 | LSB 12 | Go |
6Ah | PROGRAM_MEM_26 | MSB 13 | Go |
6Bh | PROGRAM_MEM_27 | LSB 13 | Go |
6Ch | PROGRAM_MEM_28 | MSB 14 | Go |
6Dh | PROGRAM_MEM_29 | LSB 14 | Go |
6Eh | PROGRAM_MEM_30 | MSB 15 | Go |
6Fh | PROGRAM_MEM_31 | LSB 15 | Go |
70h | ENGINE1_MAPPING1 | Engine 1 LED [8] and Master Fader Mapping | Go |
71h | ENGINE1_MAPPING2 | Engine 1 LED [7:0] Mapping | Go |
72h | ENGINE2_MAPPING1 | Engine 2 LED [8] and Master Fader Mapping | Go |
73h | ENGINE2_MAPPING2 | Engine 2 LED [7:0] Mapping | Go |
74h | ENGINE3_MAPPING1 | Engine 3 LED [8] and Master Fader Mapping | Go |
75h | ENGINE3_MAPPING2 | Engine 3 LED [7:0] Mapping | Go |
80h | PWM_CONFIG | PWM Input Configuration | Go |
81h | LED_FAULT1 | LED [8] Fault Status | Go |
82h | LED_FAULT2 | LED [7:0] Fault Status | Go |
83h | GENERAL_FAULT | CP Cap, UVLO and TSD Fault Status | Go |
Access Type | Code | Description |
---|---|---|
Read Type | ||
R | R | Read |
Write Type | ||
W | W | Write |
Reset or Default Value | ||
-n | Value after reset or the default value |
CONFIG is shown in Figure 27 and described in Table 16.
Return to Summary Table.
Configuration Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | chip_en | RESERVED | |||||
R/W-0h | R/W-0h | R/W-0h |
LED_ENGINE_CONTROL1 is shown in Figure 28 and described in Table 17.
Return to Summary Table.
LED Engine Control Register 1
Execution states are defined in this register, and they are only applicable when the corresponding mode register in LED_ENGINE_CONTROL2 is set to the run mode. Execution-state values may be written by the host in other modes, but the engine disregards the write until the mode changes to run mode. The fields in this register define how the program is executed out of SRAM:
HOLD: The engine does not execute any instructions, but the program counter holds its current value unless overwritten by the host. This is the only state in which the PC can be written.
STEP: Executes a single instruction, increments the PC, and then changes to the hold state. If the instruction is a ramp or wait, the engine waits for this instruction to complete before changing to the hold state.
FREE RUN: The engine begins instruction execution from the current value of the PC. The program counter is reset to zero when its upper-limit value is reached at the top of SRAM memory.
EXECUTE ONCE: Executes a single instruction and then changes to the hold state. The PC remains unaffected unless the instruction is a branch command, in which case it changes if the branch is taken. If the instruction is a ramp or wait, it waits for this instruction to complete before changing to hold state.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
ch1_exec | ch2_exec | ch3_exec | RESERVED | ||||
R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED_ENGINE_CONTROL2 is shown in Figure 29 and described in Table 18.
Return to Summary Table.
LED Engine Control Register 2
Operation modes are defined in this register.
DISABLED: Engines each can be configured to be disabled independently. When disabled, the program counter per ENGINEx_PC is set to 0 and the engine does not execute instructions.
LOAD PROGRAM: Writing to program memory is allowed only when the engine is in the load-program operation mode and the engine-busy bit (register 3C) is not set. The host should check the engine-busy bit before writing to program memory or allow at a least 1-ms delay after entering the load mode before memory write, to ensure initialization. If any engine is set to the load-program mode, then the other engines should be set either to the disabled or load-program mode, because they are inhibited from executing instructions while loading the SRAM. The load-program mode also resets the program counter of the respective engine. The load-program mode can only be entered from the disabled mode.
RUN PROGRAM: The run-program mode executes the instructions stored in the program memory. Execution register (LED_ENGINE_CONTROL1) bits define how the program is executed (hold, step, free-run or execute once).
HALT: Instruction execution aborts immediately and engine operation halts.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
ch1_mode | ch2_mode | ch3_mode | RESERVED | ||||
R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED0_CONTROL is shown in Figure 30 and described in Table 19.
Return to Summary Table.
LED0 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping0 | led0_ratio_en | exp_en0 | external_power0 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED1_CONTROL is shown in Figure 31 and described in Table 20.
Return to Summary Table.
LED1 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping1 | led1_ratio_en | exp_en1 | external_power1 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED2_CONTROL is shown in Figure 32 and described in Table 21.
Return to Summary Table.
LED2 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping2 | led2_ratio_en | exp_en2 | external_power2 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED3_CONTROL is shown in Figure 33 and described in Table 22.
Return to Summary Table.
LED3 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping3 | led3_ratio_en | exp_en3 | external_power3 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED4_CONTROL is shown in Figure 34 and described in Table 23.
Return to Summary Table.
LED4 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping4 | led4_ratio_en | exp_en4 | external_power4 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED5_CONTROL is shown in Figure 35 and described in Table 24.
Return to Summary Table.
LED5 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping5 | led5_ratio_en | exp_en5 | external_power5 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED6_CONTROL is shown in Figure 36 and described in Table 25.
Return to Summary Table.
LED6 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping6 | led6_ratio_en | exp_en6 | external_power6 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED7_CONTROL is shown in Figure 37 and described in Table 26.
Return to Summary Table.
LED7 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping7 | led7_ratio_en | exp_en7 | external_power7 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED8_CONTROL is shown in Figure 38 and described in Table 27.
Return to Summary Table.
LED8 Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mf_mapping8 | led8_ratio_en | exp_en8 | external_power8 | RESERVED | |||
R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
LED0_PWM is shown in Figure 39 and described in Table 28.
Return to Summary Table.
LED0 PWM Register
This is the PWM duty cycle control for the LED0 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm0 | |||||||
R/W-0h |
LED1_PWM is shown in Figure 40 and described in Table 29.
Return to Summary Table.
LED1 PWM Register
This is the PWM duty cycle control for the LED1 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm1 | |||||||
R/W-0h |
LED2_PWM is shown in Figure 41 and described in Table 30.
Return to Summary Table.
LED2 PWM Register
This is the PWM duty cycle control for the LED2 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm2 | |||||||
R/W-0h |
LED3_PWM is shown in Figure 42 and described in Table 31.
Return to Summary Table.
LED3 PWM Register
This is the PWM duty cycle control for the LED3 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm3 | |||||||
R/W-0h |
LED4_PWM is shown in Figure 43 and described in Table 32.
Return to Summary Table.
LED4 PWM Register
This is the PWM duty cycle control for the LED4 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm4 | |||||||
R/W-0h |
LED5_PWM is shown in Figure 44 and described in Table 33.
Return to Summary Table.
LED5 PWM Register
This is the PWM duty cycle control for the LED5 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm5 | |||||||
R/W-0h |
LED6_PWM is shown in Figure 45 and described in Table 34.
Return to Summary Table.
LED6 PWM Register
This is the PWM duty cycle control for the LED6 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm6 | |||||||
R/W-0h |
LED7_PWM is shown in Figure 46 and described in Table 35.
Return to Summary Table.
LED7 PWM Register
This is the PWM duty cycle control for the LED7 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm7 | |||||||
R/W-0h |
LED8_PWM is shown in Figure 47 and described in Table 36.
Return to Summary Table.
LED8 PWM Register
This is the PWM duty cycle control for the LED8 output.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm8 | |||||||
R/W-0h |
LED0_CURRENT is shown in Figure 48 and described in Table 37.
Return to Summary Table.
LED0 Current Register
LED0 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current0 | |||||||
R/W-AFh |
LED1_CURRENT is shown in Figure 49 and described in Table 38.
Return to Summary Table.
LED1 Current Register
LED1 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current1 | |||||||
R/W-AFh |
LED2_CURRENT is shown in Figure 50 and described in Table 39.
Return to Summary Table.
LED2 Current Register
LED2 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current2 | |||||||
R/W-AFh |
LED3_CURRENT is shown in Figure 51 and described in Table 40.
Return to Summary Table.
LED3 Current Register
LED3 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current3 | |||||||
R/W-AFh |
LED4_CURRENT is shown in Figure 52 and described in Table 41.
Return to Summary Table.
LED4 Current Register
LED4 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current4 | |||||||
R/W-AFh |
LED5_CURRENT is shown in Figure 53 and described in Table 42.
Return to Summary Table.
LED5 Current Register
LED5 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current5 | |||||||
R/W-AFh |
LED6_CURRENT is shown in Figure 54 and described in Table 43.
Return to Summary Table.
LED6 Current Register
LED6 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current6 | |||||||
R/W-AFh |
LED7_CURRENT is shown in Figure 55 and described in Table 44.
Return to Summary Table.
LED7 Current Register
LED7 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current7 | |||||||
R/W-AFh |
LED8_CURRENT is shown in Figure 56 and described in Table 45.
Return to Summary Table.
LED8 Current Register
LED8 driver output current control register. The resolution is 8 bits, and step size is 100 μA.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
current8 | |||||||
R/W-AFh |
MISC is shown in Figure 57 and described in Table 46.
Return to Summary Table.
Miscellaneous Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | en_auto_incr | powersave_en | cp_mode | cp_return_1x | RESERVED | int_clk_en | |
R/W-0h | R/W-1h | R/W-0h | R/W-0h | R/W-0h | R/W-0h | R/W-0h |
ENGINE1_PC is shown in Figure 58 and described in Table 47.
Return to Summary Table.
Engine1 Program Counter Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine1_pc | |||||||
R/W-0h |
ENGINE2_PC is shown in Figure 59 and described in Table 48.
Return to Summary Table.
Engine2 Program Counter Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine2_pc | |||||||
R/W-0h |
ENGINE3_PC is shown in Figure 60 and described in Table 49.
Return to Summary Table.
Engine3 Program Counter Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine3_pc | |||||||
R/W-0h |
MISC2 is shown in Figure 61 and described in Table 50.
Return to Summary Table.
Miscellaneous Register 2
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | led_short_test | led_open_test | led_headroom | cp_dis_disch | |||
R/W-0h | R/W-0h | R/W-0h | R/W-1h | R/W-0h |
ENGINE_STATUS is shown in Figure 62 and described in Table 51.
Return to Summary Table.
Engine Status Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
mask_busy | startup_busy | engine_busy | RESERVED | ch3_int | ch2_int | ch1_int | |
R/W-1h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h |
IO_CONTROL is shown in Figure 63 and described in Table 52.
Return to Summary Table.
I/O Control Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | en_clk_out | gpio_config | gpo | ||||
R/W-0h | R/W-0h | R/W-1h | R/W-0h |
VARIABLE_D is shown in Figure 64 and described in Table 53.
Return to Summary Table.
Variable D Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
variable_d | |||||||
R/W-0h |
RESET is shown in Figure 65 and described in Table 54.
Return to Summary Table.
Reset Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
reset | |||||||
W-0h |
ENGINE1_VARIABLE_A is shown in Figure 66 and described in Table 55.
Return to Summary Table.
Engine1 Variable A Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine1_variable_a | |||||||
R/W-0h |
ENGINE2_VARIABLE_A is shown in Figure 67 and described in Table 56.
Return to Summary Table.
Engine2 Variable A
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine2_variable_a | |||||||
R/W-0h |
ENGINE3_VARIABLE_A is shown in Figure 68 and described in Table 57.
Return to Summary Table.
Engine3 Variable A
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
engine3_variable_a | |||||||
R/W-0h |
MASTER_FADER1 is shown in Figure 69 and described in Table 58.
Return to Summary Table.
Master Fader1 Register
An 8-bit register to control all the LED outputs mapped to MASTER FADER1. The master fader allows the user to control dimming of multiple LEDS with a single serial bus write.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
master_fader1 | |||||||
R/W-0h |
MASTER_FADER2 is shown in Figure 70 and described in Table 59.
Return to Summary Table.
Master Fader2 Register
An 8-bit register to control all the LED outputs mapped to MASTER FADER2. Master fader allows the user to control dimming of multiple LEDS with a single serial bus write.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
master_fader2 | |||||||
R/W-0h |
MASTER_FADER3 is shown in Figure 71 and described in Table 60.
Return to Summary Table.
Master Fader3 Register
An 8-bit register to control all the LED outputs mapped to MASTER FADER2. Master fader allows the user to control dimming of multiple LEDS with a single serial bus write.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
master_fader3 | |||||||
R/W-0h |
MASTER_FADER_PWM is shown in Figure 72 and described in Table 61.
Return to Summary Table.
Master Fader PWM Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
master_fader_pwm | |||||||
R-0h |
Bit | Field | Type | Reset | Description |
---|---|---|---|---|
7–0 | master_fader_pwm | R | 0h | PWM input duty cycle. See Figure 14. |
ENGINE1_PROG_START is shown in Figure 73 and described in Table 62.
Return to Summary Table.
Engine1 Program Start Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
prog_start_addr1 | |||||||
R/W-0h |
ENGINE2_PROG_START is shown in Figure 74 and described in Table 63.
Return to Summary Table.
Engine2 Program Start Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
prog_start_addr2 | |||||||
R/W-0h |
ENGINE3_PROG_START is shown in Figure 75 and described in Table 64.
Return to Summary Table.
Engine3 Program Start Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
prog_start_addr3 | |||||||
R/W-0h |
PROG_MEM_PAGE_SELECT is shown in Figure 76 and described in Table 65.
Return to Summary Table.
Program Memory-Page Selection Register
SRAM page select. SRAM is 256 × 16 addressable from I2C, and is viewed as 16 pages of 32 bytes. This register selects which page is being accessed, serving as the upper bits of the SRAM address. The I2C host must write this register during the course of loading SRAM contents in order to access the next page.
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | page_sel | ||||||
R/W-0h | R/W-0h |
PROGRAM_MEM_00 is shown in Figure 77 and described in Table 66.
Return to Summary Table.
Program Memory 00 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd00_msb | |||||||
R/W-0h |
PROGRAM_MEM_01 is shown in Figure 78 and described in Table 67.
Return to Summary Table.
Program Memory 01 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd00_lsb | |||||||
R/W-0h |
PROGRAM_MEM_02 is shown in Figure 79 and described in Table 68.
Return to Summary Table.
Program Memory 02 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd01_msb | |||||||
R/W-0h |
PROGRAM_MEM_03 is shown in Figure 80 and described in Table 69.
Return to Summary Table.
Program Memory 03 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd01_lsb | |||||||
R/W-0h |
PROGRAM_MEM_04 is shown in Figure 81 and described in Table 70.
Return to Summary Table.
Program Memory 04 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd02_msb | |||||||
R/W-0h |
PROGRAM_MEM_05 is shown in Figure 82 and described in Table 71.
Return to Summary Table.
Program Memory 05 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd02_lsb | |||||||
R/W-0h |
PROGRAM_MEM_06 is shown in Figure 83 and described in Table 72.
Return to Summary Table.
Program Memory 06 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd03_msb | |||||||
R/W-0h |
PROGRAM_MEM_07 is shown in Figure 84 and described in Table 73.
Return to Summary Table.
Program Memory 07 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd03_lsb | |||||||
R/W-0h |
PROGRAM_MEM_08 is shown in Figure 85 and described in Table 74.
Return to Summary Table.
Program Memory 08 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd04_msb | |||||||
R/W-0h |
PROGRAM_MEM_09 is shown in Figure 86 and described in Table 75.
Return to Summary Table.
Program Memory 09 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd04_lsb | |||||||
R/W-0h |
PROGRAM_MEM_10 is shown in Figure 87 and described in Table 76.
Return to Summary Table.
Program Memory 10 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd05_msb | |||||||
R/W-0h |
PROGRAM_MEM_11 is shown in Figure 88 and described in Table 77.
Return to Summary Table.
Program Memory 11 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd05_lsb | |||||||
R/W-0h |
PROGRAM_MEM_12 is shown in Figure 89 and described in Table 78.
Return to Summary Table.
Program Memory 12 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd06_msb | |||||||
R/W-0h |
PROGRAM_MEM_13 is shown in Figure 90 and described in Table 79.
Return to Summary Table.
Program Memory 13 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd06_lsb | |||||||
R/W-0h |
PROGRAM_MEM_14 is shown in Figure 91 and described in Table 80.
Return to Summary Table.
Program Memory 14 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd07_msb | |||||||
R/W-0h |
PROGRAM_MEM_15 is shown in Figure 92 and described in Table 81.
Return to Summary Table.
Program Memory 15 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd07_lsb | |||||||
R/W-0h |
PROGRAM_MEM_16 is shown in Figure 93 and described in Table 82.
Return to Summary Table.
Program Memory 16 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd08_msb | |||||||
R/W-0h |
PROGRAM_MEM_17 is shown in Figure 94 and described in Table 83.
Return to Summary Table.
Program Memory 17 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd08_lsb | |||||||
R/W-0h |
PROGRAM_MEM_18 is shown in Figure 95 and described in Table 84.
Return to Summary Table.
Program Memory 18 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd09_msb | |||||||
R/W-0h |
PROGRAM_MEM_19 is shown in Figure 96 and described in Table 85.
Return to Summary Table.
Program Memory 19 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd09_lsb | |||||||
R/W-0h |
PROGRAM_MEM_20 is shown in Figure 97 and described in Table 86.
Return to Summary Table.
Program Memory 20 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd10_msb | |||||||
R/W-0h |
PROGRAM_MEM_21 is shown in Figure 98 and described in Table 87.
Return to Summary Table.
Program Memory 21 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd10_lsb | |||||||
R/W-0h |
PROGRAM_MEM_22 is shown in Figure 99 and described in Table 88.
Return to Summary Table.
Program Memory 22 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd11_msb | |||||||
R/W-0h |
PROGRAM_MEM_23 is shown in Figure 100 and described in Table 89.
Return to Summary Table.
Program Memory 23 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd11_lsb | |||||||
R/W-0h |
PROGRAM_MEM_24 is shown in Figure 101 and described in Table 90.
Return to Summary Table.
Program Memory 24 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd12_msb | |||||||
R/W-0h |
PROGRAM_MEM_25 is shown in Figure 102 and described in Table 91.
Return to Summary Table.
Program Memory 25 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd12_lsb | |||||||
R/W-0h |
PROGRAM_MEM_26 is shown in Figure 103 and described in Table 92.
Return to Summary Table.
Program Memory 26 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd13_msb | |||||||
R/W-0h |
PROGRAM_MEM_27 is shown in Figure 104 and described in Table 93.
Return to Summary Table.
Program Memory 27 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd13_lsb | |||||||
R/W-0h |
PROGRAM_MEM_28 is shown in Figure 105 and described in Table 94.
Return to Summary Table.
Program Memory 28 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd14_msb | |||||||
R/W-0h |
PROGRAM_MEM_29 is shown in Figure 106 and described in Table 95.
Return to Summary Table.
Program Memory 29 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd14_lsb | |||||||
R/W-0h |
PROGRAM_MEM_30 is shown in Figure 107 and described in Table 96.
Return to Summary Table.
Program Memory 30 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd15_msb | |||||||
R/W-0h |
PROGRAM_MEM_31 is shown in Figure 108 and described in Table 97.
Return to Summary Table.
Program Memory 31 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
cmd15_lsb | |||||||
R/W-0h |
ENGINE1_MAPPING1 is shown in Figure 109 and described in Table 98.
Return to Summary Table.
Engine1 Mapping1 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | eng1_map_master_fader1 | eng1_map_led8 | |||||
R-0h | R-0h | R-0h |
ENGINE1_MAPPING2 is shown in Figure 110 and described in Table 99.
Return to Summary Table.
Engine1 Mapping2 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
eng1_map_led7 | eng1_map_led6 | eng1_map_led5 | eng1_map_led4 | eng1_map_led3 | eng1_map_led2 | eng1_map_led1 | eng1_map_led0 |
R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h |
ENGINE2_MAPPING1 is shown in Figure 111 and described in Table 100.
Return to Summary Table.
Engine2 Mapping1 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | eng2_map_master_fader2 | eng2_map_led8 | |||||
R-0h | R-0h | R-0h |
ENGINE2_MAPPING2 is shown in Figure 112 and described in Table 101.
Return to Summary Table.
Engine2 Mapping2 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
eng2_map_led7 | eng2_map_led6 | eng2_map_led5 | eng2_map_led4 | eng2_map_led3 | eng2_map_led2 | eng2_map_led1 | eng2_map_led0 |
R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h |
ENGINE3_MAPPING1 is shown in Figure 113 and described in Table 102.
Return to Summary Table.
Engine3 Mapping1 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | eng3_map_master_fader3 | eng3_map_led8 | |||||
R-0h | R-0h | R-0h |
ENGINE3_MAPPING2 is shown in Figure 114 and described in Table 103.
Return to Summary Table.
Engine3 Mapping2 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
eng3_map_led7 | eng3_map_led6 | eng3_map_led5 | eng3_map_led4 | eng3_map_led3 | eng3_map_led2 | eng3_map_led1 | eng3_map_led0 |
R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h |
PWM_CONFIG is shown in Figure 115 and described in Table 104.
Return to Summary Table.
PWM Configuration Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
pwm_min_pulse_width | RESERVED | pwm_input_edge_sel | pwm_input_hysteresis | ||||
R/W-0h | R/W-0h | R/W-0h | R/W-4h |
LED_FAULT1 is shown in Figure 116 and described in Table 105.
Return to Summary Table.
LED Fault 1 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | led_fault8 | ||||||
R-0h | R-0h |
LED_FAULT2 is shown in Figure 117 and described in Table 106.
Return to Summary Table.
LED Fault 2 Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
led_fault_7 | led_fault_6 | led_fault_5 | led_fault_4 | led_fault_3 | led_fault_2 | led_fault_1 | led_fault_0 |
R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h | R-0h |
GENERAL_FAULT is shown in Figure 118 and described in Table 107.
Return to Summary Table.
General Fault Register
7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
RESERVED | cp_cap_missing | vdd_uvlo | tsd | ||||
R-0h | R-1h | R-0h | R-0h |