Referencia de Funciones MIOS (Version C)

  // envía el evento MIDI B0 07 7F
  MIOS_MIDI_BeginStream();
  MIOS_MIDI_TxBufferPut(0xb0);
  MIOS_MIDI_TxBufferPut(0x07);
  MIOS_MIDI_TxBufferPut(0x7f);
  MIOS_MIDI_EndStream();

  // poner la ID de dispositivo como el valor especificado en la cabecera de ID del PIC
    MIOS_MIDI_DeviceIDAutoSet();

  // Imprime en pantalla la ID de dispositivo
  MIOS_LCD_PrintHex2(MIOS_MIDI_DeviceIDGet());

  ;; cambiar la ID de dispositivo
  MIOS_MIDI_DeviceIDSet(0x03);

  // Envía el evento MIDI 90 36 7F
  MIOS_MIDI_BeginStream();
  MIOS_MIDI_TxBufferPut(0x90);
  MIOS_MIDI_TxBufferPut(0x36);
  MIOS_MIDI_TxBufferPut(0x7f);
  MIOS_MIDI_EndStream();

  // Dispone la interfaz MIDI como el tipo especificado en el encabezado de ID del PIC
   MIOS_MIDI_InterfaceAutoSet();

  // Obtener el tipo de interfaz y su rama dependiendo de la configuración.
  switch( MIOS_MIDI_InterfaceGet() ) {
    case MIOS_MIDI_INTERFACE_COMMON:
      // haz esto...
      break;
    case MIOS_MIDI_INTERFACE_TO_HOST:
      // haz esto otro...
      break;
    default:
      // IIC esclavo seleccionado...
  }

  // Envía el reloj MIDI a través del MIDI Out con tasa de baudios normal
  MIOS_MIDI_InterfaceSet(MIOS_MIDI_INTERFACE_COMMON);
  MIOS_MIDI_TxBufferPut(0xf8);

  // Envía el reloj MIDI a través del MBHP_IIC_MIDI con dirección 0x10
  MIOS_MIDI_InterfaceSet(0x10);
  MIOS_MIDI_TxBufferPut(0xf8);

  // Volver a la interfaz por defecto  
   MIOS_MIDI_InterfaceAutoSet();

  // Obtener configuración de fusión y rama dependiendo de la configuración
  switch( MIOS_MIDI_MergerGet() ) {
    case MIOS_MIDI_MERGER_ENABLED:
      // hacer esto...
      break;
    case MIOS_MIDI_MERGER_MBLINK_EP:
      // hacer esto...
      break;
    case MIOS_MIDI_MERGER_MBLINK_FP:
      // hacer esto...
      break;
    default: // MIOS_MIDI_MERGER_DISABLED:
      // hacer esto...
  }

  // configurar la MIDIbox como MIDIbox Link End Point
  // (significa: fusión habilitada solo para eventos que hayan sido
  // generados por otra MIDIbox que esté configurada como
  //  MIDIbox Link Forwarding Point)
  MIOS_MIDI_MergerSet(MIOS_MIDI_MERGER_MBLINK_EP);

  // Introduce un byte MIDI en el Buffer Rx si éste no está lleno
 if( MIOS_MIDI_RxBufferFree() ) {
    MIOS_MIDI_RxBufferPut(0xf8); // Reloj MIDI 
  }

  unsigned char b;

  // obtiene un byte MIDI del Buffer Rx si se ha recibido algo.
 if( MIOS_MIDI_RxBufferUsed() ) {
    b = MIOS_MIDI_RxBufferGet();
  }

  // pone un byte MIDI en el Buffer Rx si éste no está lleno.
  if( MIOS_MIDI_RxBufferFree() ) {
    MIOS_MIDI_RxBufferPut(0xf8); // Reloj MIDI
  }

  // detecta si se ha recibido algo vía MIDI
  if( MIOS_MIDI_RxBufferUsed() ) {
    // hacer algo...
  }

  // espera hasta que el buffer esté vacío, entonces manda una descarga de nuevos bytes
  MIOS_MIDI_TxBufferFlush();
  MIOS_MIDI_TxBufferPut(0xf0);
  //  ...

  // Pone un byte MIDI en el Buffer Tx si éste no está lleno
  if( MIOS_MIDI_TxBufferFree() ) {
    MIOS_MIDI_TxBufferPut(0xf8);
  }

  unsigned char b;

  // obtiene un byte libre del Buffer Tx si hay un nuevo byte disponible
  if( MIOS_MIDI_TxBufferUsed() ) {
    b = MIOS_MIDI_TxBufferGet();
  }

  // pone un byte MIDI en el Buffer Tx
 MIOS_MIDI_TxBufferPut(0xf8); // MIDI Clock

  // monitoriza si se ha introducido algo en el Buffer Tx
 if( MIOS_MIDI_TxBufferUsed() ) {
    // tiene algo
  }

  ;; inicializar el controlador MF para faders Alps RSAON11M9 
  MIOS_MF_Enable();
  MIOS_MF_DeadbandSet(3);
  MIOS_MF_PWM_DutyCycleUpSet(1);
  MIOS_MF_PWM_DutyCycleDownSet(1);
  MIOS_MF_PWM_PeriodSet(3);

  // Mover fader #7 a la posición más alta(0x3ff)
  MIOS_MF_FaderMove(0x07, 0x3ff);

  // resta -5 del valor de 7-bit del encoder #0
  MIOS_ENC_Abs7bitAdd(0, -5);

  // obtener el valor de 7 bits actual del encoder #0
  value = MIOS_ENC_Abs7bitGet(0);

  // establece el valor de 7-bit value del encoder #0 to 0x40
  MIOS_ENC_Abs7bitSet(0, 0x40);

  // devuelve el ajuste de velocidad de  encoder #0
  speed = MIOS_ENC_SpeedGet(0);

  MIOS_ENC_SPEED_NORMAL
  ~~~~~~~~~~~~~~~~~~~~~
  // este modo de velocidad no requiere ningún parámetro adicional (debería ser cero)

  // ajustar la velocidad del encoder #0 a "normal"
  MIOS_ENC_SpeedSet(0, MIOS_ENC_SPEED_NORMAL, 0);

  MIOS_ENC_SPEED_SLOW
  ~~~~~~~~~~~~~~~~~~~
  // esta velocidad permite definir un valor pre-divisor this speed mode 
  // de 0 a 7

  // ajustar la velocidad del encoder #0 a "slow", usar un pre-divisor 
  // de 3 para que el encoder incremente cada 4º paso
  // step (predivider value (- 1))
  MIOS_ENC_SpeedSet(0, MIOS_ENC_SPEED_SLOW, 3);

  MIOS_ENC_SPEED_FAST
  ~~~~~~~~~~~~~~~~~~~
  // en este modo de velocidad el valor de incremento depende de 
  //  la velocidad rotacional basándose en la siguiente fórmula :

  //    speed_ctr: decrecido con cada ciclo de actualización
  //    (-> MIOS_SRIO_UpdateFrqSet)
  //     (normalmente 1 ms) para medir el tiempo entre 
  //     dos pasos del encoder  
  //     Init value: 0x7f
  //     alcanza 0x00 después de 127 ciclos de actualización
  //    (normalmente después de 127 ms)
  //    <parameter>: especificado con el  MIOS_ENC_SpeedSet
  //
  //           función, valores permitidos:
  //        0 (rápido)     -> divisor = 2^(7-0) = 128
  //        1 (más rápido)   -> divisor = 2^(7-1) =  64
  //        ...
  //        7 (el más rápido)  -> divisor = 2^(7-7) =  1
  // ->
  //    incrementer = speed_ctr / (2^(7-parámetro))

  // establecer la velocidad para el encoder #0 a "fast", el valor de exponente de velocidad es 2
  MIOS_ENC_SpeedSet(0, MIOS_ENC_SPEED_FAST, 2);

  // limpiar  LCD e imprimir un caracter
  MIOS_LCD_Clear();
  MIOS_LCD_PrintChar('A');

  //imprime un caracter en la primera línea, primera columna
  MIOS_LCD_CursorSet(0x00 + 0);
  MIOS_LCD_PrintChar('A');

  // imprime un caracter en la segunda línea, última columna (LCD de 2x16)
  MIOS_LCD_CursorSet(0x40 + 15);
  MIOS_LCD_PrintChar('B');

  // imprime caracteres en la segunda LCD
  // (o 3ª y 4ª línea, ver MIOS_LCD_YAddressSet)
  MIOS_LCD_CursorSet(0x80 + 0);
  MIOS_LCD_PrintChar('C');
  MIOS_LCD_CursorSet(0xc0 + 15);
  MIOS_LCD_PrintChar('D');

  // imprime mensaje en pantalla durante 2 segundos
  MIOS_LCD_CursorSet(0x00 + 0);
  MIOS_LCD_PrintCString("Pot value: ");
  MIOS_LCD_PrintHex2(MIOS_AIN_Pin7bitGet(0));
  MIOS_LCD_MessageStart(255);

  //detiene el mensaje inmediatamente e invoca de nuevo DISPLAY_Tick
  MIOS_LCD_MessageStop();

  valor de caracter sin firmar;

  // imprimir en pantalla el dígito de ´valor´ de la izquierda
  MIOS_LCD_PrintBCD1(value);

 valor char sin firmar;

  // imprimir en pantalla los dos dígitos de 'valor' de la izquierda 
  MIOS_LCD_PrintBCD2(value);

  valor char sin firmar;

  // imprime en pantalla los tres dígitos de 'valor' 
  MIOS_LCD_PrintBCD3(value);

  valor int sin firmar;

  // imprime en pantalla los 4 dígitos de valor de la izquierda
  MIOS_LCD_PrintBCD4(value);

  valor int sin firmar;

  // imprime en pantalla todos los 5 dígitos de 'valor'
  MIOS_LCD_PrintBCD5(value);

  // imprime secuencia en LCD- primera línea, primera columna
  MIOS_LCD_CursorSet(0x00 + 0);
  MIOS_LCD_PrintCString("Hello World!");

  ;;imprime en pantalla cuatro caracteres
  MIOS_LCD_PrintChar('M');
  MIOS_LCD_PrintChar('I');
  MIOS_LCD_PrintChar('O');
  MIOS_LCD_PrintChar('S');

  valor char sin firmar;

  // imprime en pantalla la mitad de un byte de 'valor'
  MIOS_LCD_PrintHex1(value);

  valor char sin firmar;

  // imprimir en pantalla el contenido de 'valor' 
  MIOS_LCD_PrintHex2(value);

  // considera el uso de  MIOS_LCD_PrintMessageStart
        // ver también el ejemplo appr. 

  // definido algún sitio  *fuera* de la función!
  const unsigned char text_welcome_0[] = { "Hello World!" };

  // dentro de la función: imprimir secuencia
  MIOS_LCD_CursorSet(0x00 + 0);
  MIOS_LCD_PrintPreconfString(12, text_welcome_0);

  // por favor, vea también la función MIOS_LCD_PrintCString!

  //¡ definido algún sitio  *fuera* de la función!
  const unsigned char text_welcome_0[] = { 12, 0x00, "Hello World!" };

 // dentro de la función: imprimir secuencia
 MIOS_LCD_PrintString(text_welcome_0);

  // por favor, vea también la función  MIOS_LCD_PrintCString!

  // establece el tipo de LCD al especificado en el PIC ID header
  MIOS_LCD_TypeAutoSet();

  // ramificación dependiendo del tipo de LCD
  if( MIOS_LCD_TypeGet() == MIOS_LCD_TYPE_CLCD ) {
    // hacer algo especial si está conectado CLCD 
  }


  // !!! Mejor para ramificiones dependiendo del tipo de pantalla CLCD/GLCD !!!
  // !!! (también funciona con controlador LCD personalizado                       !!!
  if( !MIOS_BOX_CFG0.USE_GLCD ) {
    // hacer algo especial si está conectado CLCD
  }

  Las opciones LCD disponibles difieren de los tipos LCD usados, aquí va una ista
  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Tipo 0, CLCD:
     con <par1> y <par2> se especifican los pins de activación (E)
     de las pantallas de caracteres. Por defecto, el input E de la primera 
     CLCD debe ir conectada al pin  D.7, el input E de la segunda (si la hay) al pin C.4
     Son necesarias las siguientes líneas de códico para conseguir esto:

  // usa un CLCD, E input del primerCLCD en D.7, E del segundo CLCD @C.4
  MIOS_LCD_TypeSet(MIOS_LCD_TYPE_CLCD, 0x37, 0x24);

     Nota: el primer dígito del valor de parámetro establece el número de puerto
             (A=0, B=1, C=2, D=3, E=4)
             el segundo dígito establece el número de pin (0-7)
             bit #7 establece la interfaz (0=8bit, 0=7bit)

     Ejemplo para  CLCD on interfaz de 4bit :
  ;; usa una CLCD, E input de la primera CLCD en D.7, E de la segunda CLCD @C.4
  ;; usando la interfaz de 4-bit :
  ;; -> conecta MBHP_CORE:J15:D7-D4 del módulo core a D7-D4 de la LCD
        ;; -> left MBHP_CORE:J15:D3-D0 of the core module open!
  ;; -> tie D3-D0 del LCD abajo
  MIOS_LCD_TypeSet(MIOS_LCD_TYPE_CLCD, 0x80 | 0x37, 0x80 | 0x24);

     Tip: cambiando estos parámetros dinámicamente también podrás 
           manejar más de 2 lCDs con un solo módulo core. El número
           de CLCDs que pueden manejarse sólo está limitado por el  
            número de pines libres!!
            No olvides cambiar los pines apropiados al output antes de usarlos,
            y llamar a MIOS_LCD_Init por cada par de pantalla en tu  USER_Init

  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 Tipo 1, KS0108 o basadas en HD61202 
     Con <par1> se tiene que especificar si las líneas de selección del chip están invertidas 

  // usa una LCD gráfica compatible  KS0108 o HD61202 con
  // selecciones de chip no invertidas
  MIOS_LCD_TypeSet(MIOS_LCD_TYPE_GLCD0, 0x00, 0x00); // (par2 unusued)

   O:
  // usa una LCD gráfica compatible  KS0108 o HD61202 con
  // selecciones de chip invertidas
  MIOS_LCD_TypeSet(MIOS_LCD_TYPE_GLCD0, 0x01, 0x00); // (par2 unusued)

  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 Tipo 2, basadas en T6963C 
     Ya no son soportadas, en su lugar usa el controlador personalizado 
      que está disponible en la sección de descargas MIOS 

  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 Tipo 6, MIDI display
     ver implementación MIOS SysEx disponible en la sección de descargas de MIOS

     MIOS_PARAMETER1 define la ID de dispositivo del target core:

  ;; envía mensajes MIDI al núcleo con la ID de dispositivo 0x42
  MIOS_LCD_TypeSet(MIOS_LCD_TYPE_MLCD, 0x42, 0x00); // (par2 unusued)

  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

 Tipo 7, controlador LCD personalizado
     Las opciones son redirigidas al controlador LCD personal,
      siguiendo atajos que han sido preparados para una óptima 
       integración con MIOS:
          USER_LCD_Init
          USER_LCD_Clear
          USER_LCD_CursorSet
          USER_LCD_PrintChar

  // configura offsets para una LCD de 4x16 LCD:
  MIOS_LCD_YAddressSet(0x00, 0x40, 0x10, 0x50);

  // configura MIOS para LCDs de 2 caracteres:
        // (ver también http://www.ucapps.de/mbhp_lcd.html )
  MIOS_LCD_YAddressSet(0x00, 0x40, 0x80, 0xc0);

    ver http://www.ucapps.de/mios_c_lcd_schars.html

    ver http://www.ucapps.de/mios_c_lcd_schars.html

  // establecer fuente por defecto:
  MIOS_GLCD_FontInit(MIOS_GLCD_FONT)
  // poner el  cursor a 0
  MIOS_LCD_CursorSet(0x00);
  // imprimir caracter 'A'
  MIOS_LCD_PrintChar('A');

  // ajustar el cursor gráfico en160/7:
  MIOS_GLCD_GCursorSet(160, 7);

  // carga un byte de la dirección 0x80
  value = MIOS_EEPROM_Read(0x80);

  unsigned char buffer[64];

  // leer una página de 64 bytes de la EEPROM en la dirección  0x40
  MIOS_EEPROM_ReadPage(0x40, buffer);

  unsigned char error = 0;

  // writeescribe  0x47 0x11 en la EEPROM en dirección 0x80/0x81
  error |= MIOS_EEPROM_Write(0x80, 0x47);
  error |= MIOS_EEPROM_Write(0x81, 0x11);

  if( error ) {
    // aquí puedes hacer algún manejo de errores  }



  // nota: es muy improbable que ocurra un error al escribir 
  // en la EEPROM interna, aún así, puedes usar el atajo siguiente:

  // escribe 0x47 0x11 en la  EEPROM en dirección0x80/0x81
  MIOS_EEPROM_Write(0x80, 0x47);
  MIOS_EEPROM_Write(0x81, 0x11);

  unsigned char buffer[64];
  unsigned char i;

  // llena el buffer con algunos bytes
  for(i=0; i<64; ++i)
    buffer[i] = i;

  // escribe una página de 64 bytes en la memoria EEPROM en dirección 0x80
  MIOS_EEPROM_WritePage(0x80, buffer);

  unsigned char buffer[64];

  // leer una página de 64 bytes desde la memoria flash en dirección 0x7000
  MIOS_FLASH_Read(0x7000, buffer);

  unsigned char buffer[64];
  unsigned char i;

  // llenar buffer con algunos bytes
  for(i=0; i<64; ++i)
    buffer[i] = i;

  // escribir una página de 64 bytes en la memoria flash en dirección 0x7000
  if( MIOS_FLASH_Write(0x7000, buffer) ) {
    // error handler
  }

  unsigned char error = 0;

  // escribe 0x47 0x11 en dirección 0x3000-0x3001 del BankStick número 7
  MIOS_BANKSTICK_CtrlSet(0x07); // select 8th BankStick
  error |= MIOS_BANKSTICK_Write(0x3000, 0x47);
  error |= MIOS_BANKSTICK_Write(0x3001, 0x11);

  // carga un byte desde la dirección address 0x7fff (la última en un BankStick de 32 k)
  value = MIOS_BANKSTICK_Read(0x7fff);

  if( !MIOS_BOX_STAT.BS_AVAILABLE ) {
    // Aquí puedes hacer alguna corrección de errores
  }

  unsigned char buffer[64];

  // leer una página de 64 bytes dela memoria del BankStick en dirección 0x1240
  MIOS_BANKSTICK_ReadPage(0x1240, buffer);

  if( !MIOS_BOX_STAT.BS_AVAILABLE ) {
    // Aqui puedes hacer alguna corrección de errores
  }

  unsigned char error = 0;

  //escribe 0x47 0x11 en dirección  0x3000-0x3001 del BankStick
  error |= MIOS_BANKSTICK_Write(0x3000, 0x47);
  error |= MIOS_BANKSTICK_Write(0x3001, 0x11);

  if( error ) {
    // aquí puedes hacer alguna corrección de errores
  }

  unsigned char buffer[64];
  unsigned char i;

  // llena el buffer con algunos bytes
  for(i=0; i<64; ++i)
    buffer[i] = i;

  // escribe una página de 64 bytes enla memoria del BankStick en dirección 0x3000
  if( MIOS_BANKSTICK_WritePage(0x3000, buffer) ) {
    // aquí puedes hacer alguna corrección de errores
  }

        ver MIOS_IIC_ByteSend y MIOS_IIC_ByteReceive

  // recibir 3 bytes del esclavo IIC conID 0x12

  MIOS_IIC_Start();    // start IIC
  MIOS_IIC_ByteSend(0x12 | 1);  
   // envía direcciónd e dispositivo -
   //   establecer bit #0 para notificar una lectura!!!
  // no continuar si el dispositivo IIC no está disponible
  if( MIOS_BOX_STAT.BS_AVAILABLE ) {
    b0 = MIOS_IIC_ByteReceive;  // leer primer byte
    MIOS_IIC_AckSend();    // manda ACK
    b1 = MIOS_IIC_ByteReceive;  // leer segundo byte
    MIOS_IIC_AckSend();    // manda ACK
    b2 = MIOS_IIC_ByteReceive;  // leer tercer byte
  }
  MIOS_IIC_NakSend();    // manda NAK!!!
  MIOS_IIC_Stop();    // parar IIC

  Para más detalles sobre el protocolo IIC  (oficialmente llamado I2C), ver
     http://www.semiconductors.philips.com/buses/i2c/

  // envía 0x34, 0x56, 0x78 al esclavo IIC con ID 0x12

  MIOS_IIC_Start();    // start IIC
  MIOS_IIC_ByteSend(0x12);  // envía la dirección del dispositivo
                                // bit #0 limpiado para notificar una escritura!!!
  MIOS_IIC_ByteSend(0x34);  // enviar primer byte de datos
  MIOS_IIC_ByteSend(0x56);  // enviar segundo byte de datos
  MIOS_IIC_ByteSend(0x78);  // enviar tercer byte de datos
  MIOS_IIC_Stop();    // parar IIC

  Para más detalles sobre el protocolo IIC  (oficialmente llamado I2C), ver
 http://www.semiconductors.philips.com/buses/i2c/

 Puedes encontrar un ejemplo realzado con reintento de NAK en la página MBHP_IIC_MIDI

  // habilitar estrechamiento de reloj
  MIOS_IIC_CtrlSet(0x01);

        ver MIOS_IIC_ByteSend y MIOS_IIC_ByteReceive

        ver  MIOS_IIC_ByteSend y MIOS_IIC_ByteReceive

        ver MIOS_IIC_ByteSend y MIOS_IIC_ByteReceive

  // queremos configurar el prescaler con una frecuencia de  500 Hz = 2 mS
  // debe usarse  prescaler 1:1 
  // calcula el número de relojes requeridos para este período:
  // relojes = periodo / 100 nS = 2 mS / 100 nS = 20000
  // por consiguiente:
  MIOS_TIMER_Init(0x00, 20000);

  // Ahora la función Timer() se llama cada 2 mS!

  // resta -5 del valor de 16-bit (unsigned int)
  MIOS_HLP_16bitAddSaturate(-5, &value, 0x0fff);

  // adquirir el código BCD de 12345
  MIOS_HLP_Dec2BCD(12345);
  // ahora:
  //    MIOS_PARAMETER3 contiene el valor hex 0x01
  //    MIOS_PARAMETER2 contiene el valor hex 0x23
  //    MIOS_PARAMETER1 contiene el valor hex 0x45

  // esperar exactamente 250 ms
  MIOS_Delay(250);