MUL

Top 

Con un argumento

   

Realiza la multiplicación entre el acumulador (Acc) y el argumento. El resultado queda en el acumulador.

 

        MUL arg         ;acumulador = acumulador * argumento

 

El argumento puede ser una variable analógica o una constante.

   

   

Con dos argumentos

   

Multiplica las variables arg1 y arg2, y el resultado queda en el acumulador aritmético AAcc. Ambos argumentos deben ser del mismo tipo (entero, largo o real). La ejecución es condicional. Disponible a partir del CP121 BIOS 2.60 hasta 2.64, CP122 BIOS 2.10 hasta 2.13, CP123 BIOS 2.20 hasta 2.23 y CP124 BIOS 1.06

   

 MUL arg1, arg2

   

Ejemplo:

   

LD 1             ;Permiso de ejecución
    MUL sng0, sng1   ;AAccR = sng0 * sng1
    MUL AAccR, sng2 
;AAccR = AAccR * sng2

 

LD 1             ;Permiso de ejecución
MUL arg0, arg1   ;AAcc = arg0 * arg1
MUL AAcc, arg2 
 ;AAcc = AAcc * arg2

  

 Es necesario comprobar los resultados de cada operación para tener certeza de que no se superen los límites de los tipos de datos, pues esto resultaría en valores erróneos. Supongamos un caso de tres variables con un valor de 30000:

   

LD 1                ;Permiso de ejecución

MUL arg1, arg2      ;AAcc = 900000000, que es menor que 2147483648 (231)

MUL AAcc, arg3      ;AAcc debería tener 2.7 x 1013, pero tiene cualquier

                ;otro a causa del desbordamiento

   

   

Con tres argumentos

   

A partir del CP121 2.70, CP122 2.20, CP123 2.30, CP125 1.10, varias instrucciones de dos argumentos son reemplazadas por tres argumentos. El comportamiento de cada uno resulta en la siguiente forma:

   

MUL arg1, arg2, arg3               equivale a                 arg1 = arg2 * arg3

   

El primer argumento (arg1) debe ser de 32bit mientras que el resto (arg2 y arg3) pueden combinarse 16bit, 32bit y constantes. Solo para el tipo real todos deben ser del mismo tipo. Ver tipo de dato. La ejecución es condicional.

  

Para CP220, CP127, CP128

  

Tiene mas combinaciones posibles. La regla es que el resultado (arg1)  es de un tipo igual o mayor al mayor de los argumentos (arg2 y arg3). Ejemplo: si se suma un real con un entero, el resultado será en real. Las variantes son:

  

 arg1    arg2      arg3

int16 = int16   * int16
int16 = cte16   * int16
int16 = int16   * cte16
int32 = int16   * int16
int32 = cte16   * int16
int32 = int16   * int32
int32 = int32   * int32
int32 = int32   * int16
int32 = int16   * cte16
int32 = int16   * cte32
int32 = cte32   * int16
int32 = cte32   * int32
int32 = int32   * cte32
real  = real    * real
real  = real    * int16
real  = int16   * real
real  = real    * int32
real  = int32   * real
real  = real    * cte16
real  = cte16   * real
real  = real    * cte32
real  = cte32   * real
real  = real    * cteReal
real  = cteReal * real

    

En Ladder el orden cambia, ya que el arg1 = arg2 + arg3 se representa como:

 

  arg2

arg3

  arg1

  

quedando el arg1 al final en vez de al principio. Esto ocurre con ADD, DIV, FAVG, FIFO, FILL, MOD, MUL, SCALE, STDVT y SUB.

 

LIN

DIV

SCALE
ADD
SUB

Lista de instrucciones
Índice