vvvf_56f8346.doc

基于56F8346的异步电机VVVF控制程序。

   - TFR1_tfr16WaveGenRDITLQ -The function generates one sample and returns it.
   - TFR1_tfr16WaveGenRDITLQCreate -The function allocates the structure of type tfr16_tWaveGenRDITLQ.
   - TFR1_tfr16WaveGenRDITLQDestroy -The function frees the tfr16_tWaveGenRDITLQ data structures(s) previously allocated by 
                tfr16WaveGenRDITLQCreate.
   - TFR1_tfr16WaveGenRDITLQInit -The function initializes the tfr16_tWaveGenRDITLQ data structure used by all 
                tfr16WaveGenRDITLQ functions. The tfr16_tWaveGenRDITLQ data structure pointed to by pSWG must have been 
                allocated prior to calling tfr16WaveGenRDITLQInit.

Module "MFR1"      (bean DSP_Func_MFR)
   - MFR1_abs_s -The abs_s function calculates the 16-bit absolute value of the input value.
   - MFR1_add -The add function adds two 16-bit fractional numbers (x + y).
   - MFR1_div_s -The div_s function divides two fractional numbers (x / y); x and y must be positive and y must be greater than 
                or equal to x.
   - MFR1_mac_r -The mac function multiplies two 16-bit fractional input values (x * y) and adds the 32-bit result to w.
   - MFR1_msu_r -The msu function multiplies x by y and subtracts the 32-bit result from w.
   - MFR1_mult -This multiplication function multiply two fractional input values and return the result.
   - MFR1_mult_r -This multiplication function multiply two fractional input values and return the result. The function 
                function differs from mult in that function rounds the result, whereas mult truncates the result to 16bits.
   - MFR1_negate -The negate function negates the fractional input value.
   - MFR1_round -The round function rounds the 32-bit fractional input value to 16 bits.
   - MFR1_shl -The shl function arithmetically shifts the input variable x left n positions, zero filling the least significant 
                bits of the result. If n is negative, the shl function arithmetically shifts x right by -n bits with sign 
                extension.
   - MFR1_shr -The shr function arithmetically shifts the input variable x right n positions, sign extending the result. If n 
                is negative, the shr function arithmetically shifts x left by -n bits, zero filling the least significant bits.
   - MFR1_shr_r -The shr_r function arithmetically shifts the input variable x right n positions, sign extending the result. If 
                n is negative, the shr_r function arithmetically shifts x left by -n bits, zero filling the least significant 
                bits. shr_r differs from shr in that shr_r rounds the 32-bit fractional result.
   - MFR1_sub -The sub function calculates (x - y).
   - MFR1_L_abs -The L_abs function calculates the 32-bit absolute value of the input value.
   - MFR1_L_add -The add function adds two 32-bit fractional numbers (x + y).
   - MFR1_div_ls -The div_ls function divides two fractional numbers (x / y); x and y must be positive and y must be greater 
                than or equal to x.
   - MFR1_L_mac -The mac function multiplies two 16-bit fractional input values (x * y) and adds the 32-bit result to w.
   - MFR1_L_msu -The msu function multiplies x by y and subtracts the 32-bit result from w.
   - MFR1_L_mult -This multiplication function multiply two fractional input values and return the result.
   - MFR1_L_mult_ls -This multiplication function multiply two fractional input values and return the result. The function 
                differs from mult in that function rounds the result, whereas mult truncates the result to 16bits.
   - MFR1_L_negate -The negate function negates the fractional input value.
   - MFR1_L_shl -The L_shl function arithmetically shifts the input variable x left n positions, zero filling the least 
                significant bits of the result. If n is negative, the shl function arithmetically shifts x right by -n bits 
                with sign extension.
   - MFR1_L_shr -The L_shr function arithmetically shifts the input variable x right n positions, sign extending the result. If 
                n is negative, the L_shr function arithmetically shifts x left by -n bits, zero filling the least significant 
                bits.
   - MFR1_L_shr_r -The L_shr_r function arithmetically shifts the input variable x right n positions, sign extending the result.
                If n is negative, the L_shr_r function arithmetically shifts x left by -n bits, zero filling the least 
                significant bits. L_shr_r differs from L_shr in that L_shr_r rounds the 32-bit fractional result.
   - MFR1_L_deposit_h -The L_deposit_h function places a 16-bit fractional value into the most significant 16-bits of the 
                32-bit fractional output value and zeroes the least significant 16 bits.
   - MFR1_L_deposit_l -The L_deposit_l function places a 16-bit fractional value into the least significant 16 bits of the 
                32-bit fractional output value and sign extends the most significant 16 bits.
   - MFR1_L_sub -The L_sub function calculates (x - y).
   - MFR1_extract_h -The extract_h function extracts the most significant 16 bits from the 32-bit fractional value.
   - MFR1_extract_l -The extract_l function extracts the least significant 16 bits from the 32-bit fractional value.
   - MFR1_norm_s -The norm function calculates the number of left shifts needed to normalize a fractional value.
   - MFR1_norm_l -The norm function calculates the number of left shifts needed to normalize a fractional value.
   - MFR1_mfr16Rand -The function calculates a pseudo-random number.
   - MFR1_mfr16SetRandSeed -The function sets the random number seed used by the pseudo-random number generation algorithm.
   - MFR1_mfr16Sqrt -The function calculates the square root of the fractional input data value.
   - MFR1_mfr32Sqrt -The function calculates the square root of the fractional input data value.

Module "MEM1"      (bean DSP_MEM)
   - MEM1_memCallocEM -The memCallocEM function dynamically allocates an array with elements initialized to zero. The 
                memCallocEM function first tries to reallocate the memory from the external memory partition. For example see 
                <Typical Usage > page.
   - MEM1_memCallocIM -The memCallocIM function dynamically allocates an array with elements initialized to zero. The 
                memCallocIM function first tries to reallocate the memory from the internal memory partition. For example see 
                <Typical Usage > page.
   - MEM1_memFreeEM -The memFreeEM function deallocates a memory block in external memory that previously had been dynamically 
                allocated with the routine memMallocEM. For example see <Typical Usage > page.
   - MEM1_memFreeIM -The memFreeIM function deallocates a memory block in internal memory that previously had been dynamically 
                allocated with the routine memMallocIM. For example see <Typical Usage > page.
   - MEM1_memIsAligned -The memIsAligned function checks the address of a memory block to determine whether it is properly 
                aligned to use modulo addressing. For example see <Typical Usage > page.
   - MEM1_memIsEM -The memIsEM function checks the address of a memory block to determine whether it is in internal memory or 
                external memory. For example see <Typical Usage > page.
   - MEM1_memIsIM -The memIsIM function checks the address of a memory block to determine whether it is in internal memory or 
                external memory. For example see <Typical Usage > page.
   - MEM1_memMallocAlignedEM -The memMallocAlignedEM function allocates dynamic memory of the specified size from the memory 
                partitions and aligns the memory to use modulo addressing. The function memMallocAlignedEM first tries to 
                allocate the memory, properly aligned, from the external memory partition. However, if space is insufficient in 
                the external memory partition to satisfy the dynamic memory allocation, or if the memory request cannot be 
                properly aligned, memMallocAlignedEM then tries the allocation from the internal memory partition. If 
                memMallocAlignedEM cannot allocate an aligned buffer from either partition, it calls memMallocEM to try to 
                allocate a buffer of the correct size without the proper alignment. For example see <Typical Usage > page.
   - MEM1_memMallocAlignedIM -The memMallocAlignedIM function allocates dynamic memory of the specified size from the memory 
                partitions and aligns the memory properly to use modulo addressing. The function memMallocAlignedIM first tries 
                to allocate the memory, properly aligned, from the internal memory partition. However, if not enough space 
                exists in the internal memory partition to satisfy the dynamic memory allocation, or if the memory request 
                cannot be properly aligned, memMallocAlignedIM then tries the allocation from the external memory partition. If 
                memMallocAlignedIM cannot allocate an aligned buffer from either partition, it calls memMallocIM to try to 
                allocate a buffer of the correct size without the proper alignment. For example see <Typical Usage > page.
   - MEM1_memMallocEM -The memMallocEM function allocates dynamic memory of the specified size from the memory partitions. The 
                function memMallocEM first tries to allocate the memory from the external memory partition. However, if not 
                enough space exists in the external memory partition to satisfy the dynamic memory allocation, memMallocEM then 
                tries the allocation from the internal memory partition. For example see <Typical Usage > page.
   - MEM1_memMallocIM -The memMallocIM function allocates dynamic memory of the specified size from the memory partitions. The 
                function memMallocIM first tries to allocate the memory from the internal memory partition. However, if not 
                enough space exists in the internal memory partition to satisfy the dynamic memory allocation, memMallocIM then 
                tries the allocation from the external memory partition. For example see <Typical Usage > page.
   - MEM1_memReallocEM -The memReallocEM function dynamically reallocates and resizes a memory buffer to the specified size 
                from the memory partitions. The function memReallocEM first tries to reallocate the memory from the external 
                memory partition. However, if not enough space exists in the external memory partition to satisfy the dynamic 
                memory allocation, memReallocEM then tries the allocation from the internal memory partition. For example see 
                <Typical Usage > page.
   - MEM1_memReallocIM -The memReallocIM function dynamically reallocates and resizes a memory buffer to the specified size 
                from the memory partitions. The function memReallocIM first tries to reallocate the memory from the internal 
                memory partition. However, if not enough space exists in the internal memory partition to satisfy the dynamic 
                memory allocation, memReallocIM then tries the allocation from the external memory partition For example see 
                <Typical Usage > page.
   - MEM1_memMemcpy -The memcpy routine copies characters between memory buffers For example see <Typical Usage > page.
   - MEM1_memMemset -The memset function sets user specified number of bytes in memory to a specific character For example see 
                <Typical Usage > page.
   - MEM1_memMemsetP -The memset function sets user specified number of bytes in 'P' memory to a specific character
   - MEM1_memCopyPtoX -The memCopyPtoX copies a block of data from the P (program) data memory to the X data memory. The 
                memCopyPtoX executes the specific instructions required to read data from program P data memory, as opposed to 
                X data. For example see <Typical Usage > page.
   - MEM1_memCopyXtoP -The memCopyXtoP copies a block of data from the X data memory to the P (program) data memory. The 
                memCopyXtoP executes the specific instructions required to write data to program P data memory, as opposed to X 
                data. For example see <Typical Usage > page.
   - MEM1_memCopyPtoP -The memCopyPtoP copies a block of data from the P (program) data memory to the P data memory. The 
                memCopyPtoP executes the specific instructions required to read data from program P data memory.
   - MEM1_memReadP16 -The function memReadP16 reads a 16-bit word from the program data (P data), address space. The memReadP16 
                executes the specific instructions to reference program P data, as opposed to X data. For example see <Typical 
                Usage > page.
   - MEM1_memReadP32 -The function memReadP32 reads a 32-bit word from the program data (P data) address space. The memReadP32 
                executes the specific instructions to reference program P data, as opposed to X data. For example see <Typical 
                Usage > page.
   - MEM1_memWriteP16 -The memWriteP16 function writes a 16-bit value into the program data, (P data), address space. The 
                memWriteP16 executes the specific instructions required to write to program (P) data, as opposed to X data. For 
                example see <Typical Usage > page.
   - MEM1_memWriteP32 -The memWriteP32 function writes a 32-bit value into the program data, (P data), address space. The 
                memWriteP32 executes specific instructions required to write to program P data, as opposed to X data. For 
                example see <Typical Usage > page.

Module "Cpu"       (bean 56F8346)
   - Cpu_EnableInt -Enables all maskable interrupts
   - Cpu_DisableInt -Disables all maskable interrupts
   - Cpu_SetWaitMode -Sets low power mode - Wait mode.  For more information about the wait mode see this CPU documentation.  
                Release from wait mode: Reset or interrupt
   - Cpu_SetStopMode -Sets low power mode - Stop mode.  For more information about the stop mode see this CPU documentation.
   - Cpu_SetDataMode -Sets the Data memory map to use either internal & external resources or external resources only.

===================================================================================