Dividir un archivo FLAC y convertirlo a MP3

Este es un script en bash para dividir un archivo FLAC siguiendo las indicaciones del archivo CUE. Por último convierte los archivos FLAC a MP3

#!/bin/bash

CUE_FILE="CDImage.cue"
FLAC_FILE="CDImage.flac"


# let's make the script a little more robust
set -u   # exit if the script tries to use an unbound variable
set -e   # exit we a command fails 
set -o pipefail # exit if a command in a pipe fails


# Comprobaciones iniciales
if [ ! -f $CUE_FILE ]; then
 echo "${CUE_FILE} no existe!"
 exit 1
fi

if [ ! -f $FLAC_FILE ]; then
 echo "${FLAC_FILE} no existe!"
 exit 1
fi


# dividir
cuebreakpoints $CUE_FILE | shnsplit -o flac $FLAC_FILE

# comprueba resultado.
if [ ${PIPESTATUS[1]} -eq 0 ]; then
 echo OK
else
 echo "Problema!!"
 exit 1
fi


# metadatos
cuetag $CUE_FILE split-track*.flac


# rename files
for a in *.flac; do
 if [ "$a" != "$FLAC_FILE" ]; then 
  ARTIST=`metaflac "$a" --show-tag=ARTIST | sed s/.*=//g`
  TITLE=`metaflac "$a" --show-tag=TITLE | sed s/.*=//g`
  TRACKNUMBER=`metaflac "$a" --show-tag=TRACKNUMBER | sed s/.*=//g`
  mv "$a" "`printf %02g $TRACKNUMBER` - $ARTIST - $TITLE.flac"
 fi
done


# Convertir a mp3
mkdir mp3

for a in *.flac; do
 if [ "$a" != "$FLAC_FILE" ]; then
  TITLE=`metaflac --show-tag=TITLE "${a}" | sed 's/.*=//'`
  ARTIST=`metaflac --show-tag=ARTIST "${a}" | sed 's/.*=//'`
  ALBUM=`metaflac --show-tag=ALBUM "${a}" | sed 's/.*=//'`
  DATE=`metaflac --show-tag=DATE "${a}" | sed 's/.*=//'`
  TRACK=`metaflac --show-tag=TRACKNUMBER "${a}" | sed 's/.*=//'`
  GENRE=`metaflac --show-tag=GENRE "${a}" | sed 's/.*=//'`


  flac -cd "$a" | lame -b 320 --tt "${TITLE}" \
  --ta "${ARTIST}" --tl "${ALBUM}" \
  --ty "${DATE}" \
  --tn "${TRACK}" \
  --tg "${GENRE}" - "mp3/${a%.*}".mp3
 fi
done

Como desbloquear el MSP432P401R Launchpad

Como desbloquear el MSP432P401R Launchpad desde VirtualBox.

Paso 1: Actualizar el firmware.

1. Enumerar los dispositivos
2a. Poner el dispositivo en modo DFU
2b. En el menú de dispositivos de Virtual Box volver a seleccionar el Launchpad, que ahora a cambiado de descripción.
3. Actualizar el firmware
4. Volver a seleccionar el Launchpad en el menú de dispositivos de Virtual Box

Paso 2: restaurar la configuración de fábrica.
1. En el menu View seleccionar Target Configurations

 2. Aparece una pestaña "Target Configurations. En ella buscar el proyecto, targetConfigs, MSP432P401R.CCXML. Con el botón derecho del ratón abrir el menú y hacer click en "Launch Selected Configuration".

3. En la vista Debug, abrir el menú contextual y
a) "Show all cores"
b) Connect Target

4. En el menú Scripts, default, MSP432_Factory_Reset

Y con un poco de suerte ya funciona.

PL9823 RGB Leds con controlador integrado y MSP430

Timing
El micro funciona a 16 Mhz.

#define LONG_DELAY __delay_cycles(14);
#define SHORT_DELAY __delay_cycles(1);

#define BIT_HIGH  P1OUT |=BIT0; LONG_DELAY;  P1OUT &= ~BIT0; SHORT_DELAY;
#define BIT_LOW   P1OUT |=BIT0; SHORT_DELAY; P1OUT &= ~BIT0; LONG_DELAY;

Datos

Los datos son un array de 24 bits RGB

 //                   (MSB.........LSB)
unsigned char red1[]={1,1,1,1,1,1,1,1, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
unsigned char red2[]={0,1,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
unsigned char red3[]={0,0,0,1,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
unsigned char green1[]={0,0,0,0,0,0,0,0, 1,1,1,0,0,0,0,0, 0,0,0,0,0,0,0,0};

 

Una función para que recibe como parametro el array con los datos del color.

void sendColor(unsigned char *color){
    int n;
    for (n=0; n<24 br="" n="">        if (color[n]) {
            BIT_HIGH
        } else {
            BIT_LOW
        }
    }
}

El bucle principal envia datos a tres leds conectados en serie.

int main(){
  while(1){
    sendColor(red1);
    sendColor(red2);
    sendColor(green1);
    __delay_cycles(100000000);

    sendColor(green1);
    sendColor(red1);
    sendColor(red2);
    __delay_cycles(10000000);
  }
}

Ejecutar un script a la salida de KDE

Los scripts que se ejecutan al salir de KDE se guardan en  ~/.kde/shutdown. Si el directorio no existe hay que crearlo.

Una vez guardado el script en  el directorio, no olvidar hacerlo ejecutable.

Instalación del equalizador de pulseaudio en Debian

1. apt-get install swh-plugins ladspa-sdk
2. Descargar de aquí el archivo más reciente, p.j: pulseaudio-equalizer_2.7.0.2-5~webupd8~vivid0_all.deb
3. dpkg -i /tmp/pulseaudio-equalizer_2.7.0.2-5~webupd8~vivid0_all.deb 
4. Tal vez haya que ejecutar esto: aptitude install python-gnome2
5. Como usuario, ejecutar: pulseaudio-equalizer-gtk

Instalación del resaltado de sintaxis de Arduino en Kate

1. Descargar el archivo de sintaxis
2a. Existe ~/.kde/share/apps/katepart/syntax. Copiarlo
2b. No existe:
Menu "Preferencias/Configurar kate..."
Sección "Abrir/guardar"
Pestaña "Modos y tipos de archivo"
Botón "Descargar archivos de realce"
Botón "Instalar"

Esto crea el directorio ~/.kde/share/apps/katepart/syntax con los archivos de sintaxis.
Copiar el archivo descargado.

3. Abrir un archivo ino con Kate. Si no se ve resaltado, probar a modificarlo y guardarlo.

Acceso a los puertos de 16 bits del MSP430F5529

PCDIR = 0xFFFF; // Todos los pines de p5 y p6 como salida
PCSEL = 0;    // seleccionada función io
PCOUT = 0; // todo a 0
//
// ... algo de codigo ...
//
PCOUT = unIntDe16Bits;

Creación de un nuevo proyecto para el MSP430F5529

El nuevo proyecto incluye la MSP430driverLib.

Enviar la salida del SMCLK al pin P2.2

P2DIR |= BIT2;
P2SEL |= BIT2;

Tipos de datos en el MSP430

Fuente: MSP430 Optimizing C/C++ Compiler

Crear un Long a partir de 3 bytes, en C

// Guardo tres bytes en un array como unsigned char
unsigned char values[] = {0,0,0};
unsigned long number;

number =  values[0] + ((unsigned int) values[1] << 8) + 
          ((unsigned long) values[2] << 16);

EG 11 Rotary encoder conectado al osciloscopio

El circuito:

Giro en el sentido horario:

Giro en el sentido anti-horario:

La imagen del circuito la he sacado de aquí

Comprimir en paralelo en Linux

Para comprimir:
tar -c --use-compress-program=pigz -f /tmp/salida.tgz dir1 dir2 archivo1 archivo2

Para descomprimir:
tar -xvzf /tmp/salida.tgz

Un módulo PIR

El integrado es el BISS0001 datasheet.

Importar archivos en R

Este resumen no está disponible. Haz clic en este enlace para ver la entrada.

MSP430 y encoder rotativo

Giro en sentido horario

Giro en sentido anti-horario

Conexión:
P2.0 - Canal A
P2.1 - Canal B
Para evitar rebotes añadir condensadores de 0.1 uF.

Funcionamiento:
Las entradas 2.0 y 2.1 tienen activos las resistencias pull-up. Además, la 2.0 tiene activa la interrupción en el flanco de bajada.

#pragma vector=PORT2_VECTOR
__interrupt void PORT2_ISR_HOOK(void)
{
if ((P2IFG & ROTARY_A) == ROTARY_A) {
if ((P2IN & ROTARY_B) == ROTARY_B) {
 //Giro en sentido anti-horario
} else {
 //Giro en sentido horario
}
P2IFG &= ~ROTARY_A;
}
}

Obteniendo unidades, decenas, centenas... en python

#!/usr/bin/python
# -*- coding:utf8 -*-

# Descompone un numero en unidades, decenas, centenas y unidades de millar.

print "Introduce el número: "
numero = int(raw_input ())

umil = numero / 1000
tmp = numero % 1000

centenas = tmp / 100
tmp = tmp % 100

decenas = tmp / 10
unidades = tmp % 10

print "Unidades de millar: %i" % umil
print "Centenas: %i" % centenas
print "Decenas: %i" % decenas
print "Unidades: %i" % unidades

Can't help falling in love

Temporziador 555. Delay on, timer off

Delay on:
http://555-timer.clarkson-uk.com/operation/frames3.html

Timer off:
http://www.eleinmec.com/article.asp?4

Osciladores con el 74HC14

Apuntes sobre aritmética con bash y bc

Aritmética sencilla con bash
VALOR1="123"
VALOR2="456"
let "SUMA=${VALOR1}+${VALOR2}"

División con decimales, imposible de hacer con bash, hay que utilizar bc
PROPORCION=`bc <<< "scale=10; ${VALOR1}/${VALOR2}"`

Conversión de un número decimal a entero con bc
ENTERO=`"bc <<< "(${VALOR1}*${VALOR2}+0.5)/1"`

Creando wallpapers en doble pantalla con bash e imagemagick

1. Descripción de las pantallas

• Pantalla principal: 22 pulgadas, 1920x1080.
• Pantalla secundaria: 19 pulgadas, 1440x900.
• Físicamente la pantalla secundaria esta 1cm por debajo de la principal.
• La densidad de pixels de ambas pantallas es diferente, por lo que hay que hacer algunos cálculos para que las imágenes encajen.

2. Cálculo del tamaño de las imágenes.

• La pantalla de 22 pulgadas, 1920x1080 tiene un tamaño de 477mm x 269 mm (4 pixels por mm)
• La pantalla de 19 pulgadas, 1440x900 mide 408mm x 255mm (3.5 pixels por mm)
• Para se vea bien la imagen de la pantalla de 19 pulgadas debe medir:

•  (1440 * 4 / 3.5) x (900 * 4 / 3.5)

3. Descripción del proceso

• La imagen original es de 16 megapixels (4608x3456)
• Editar la imagen con gimp y recortarla con una proporción fija de 3360x1180. (1920+1440 de ancho y 1080 más 100 pixels de margen).
• Exportarla como TIFF para evitar pérdidas por compresión.
• Editar las variables del script según convenga. El resultado son dos imágenes (1920x1080 y 1440x900) que encajan una con la otra.

Nota: El script no está optimizado para que sea más fácil de entender y modificar.

#!/bin/bash

################################################
### Variables que siempre hay que modificar  ###

# RECUERDA: La imagen a recortar es con la proporción 3360:1080
FILENAME="pic04.tiff"

#Ajuste de la imagen de la pantalla 1 para que encaje con la
#de la pantalla 2. 
SCR1_OFFSET="60"

### Variables que tal vez haya que modificar ###

# El añadido al alto real
VIRTUAL_EXPANSION="100"

#Tamaño real de las pantallas
SCR1_WIDTH="1920"
SCR1_HEIGHT="1080"

# La pantalla es 1440x900 pero al tener diferente
# dpi hago un ajuste en el tamaño de la imagen
SCR2_WIDTH="1646"
SCR2_HEIGHT="1029"
#SCR2_WIDTH="1440"
#SCR2_HEIGHT="900"


## A partir de aquí ya no hay que modificar nada ##
###################################################

#Tamaño virtual de las pantallas
#Asumo que la pantalla 1 siempre es mayor que la 2
let "VIRTUAL_HEIGHT=$SCR1_HEIGHT+$VIRTUAL_EXPANSION"

TEMP_FILE1A="/tmp/1920x1080_tmpa.tiff"
TEMP_FILE2A="/tmp/1440x900_tmpa.tiff"

TEMP_FILE1B="/tmp/1920x1080_tmpb.tiff"
TEMP_FILE2B="/tmp/1440x900_tmpb.tiff"

#TEMP_FILE1C no es necesario
TEMP_FILE2C="/tmp/1440x900_tmpc.tiff"

FINAL_FILE1="/tmp/1920x1080.jpg"
FINAL_FILE2="/tmp/1440x900.jpg"


#Calcular tamaño total del escritori
let "VIRTUAL_WIDTH=$SCR1_WIDTH+$SCR2_WIDTH"

echo -e "Obteniendo el tamaño de la imagen..."

# Averiguar tamaño de la imagen
IMG_WIDTH=`identify $FILENAME | cut -d ' ' -f3 | cut -d 'x' -f1`
IMG_HEIGHT=`identify $FILENAME | cut -d ' ' -f3 | cut -d 'x' -f2`


# Calcular proporcion del escritorio respecto de la imagen
# Usando bc para obtener un resultado con decimales
PROPORTION=`bc <<< "scale=10; $IMG_WIDTH/$VIRTUAL_WIDTH"`


#Calculo del tamaño de los recortes teniendo en cuenta la proporción
#El resultado es un entero por la extraña operación añadida
W1_WIDTH=`bc <<< "($SCR1_WIDTH*$PROPORTION+0.5)/1"`
W2_WIDTH=`bc <<< "($SCR2_WIDTH*$PROPORTION+0.5)/1"`

W1_HEIGHT=`bc <<< "($VIRTUAL_HEIGHT*$PROPORTION+0.5)/1"`

echo -e "Preparando imágenes..."

#cortar imagenes
convert ${FILENAME} -crop ${W1_WIDTH}x${W1_HEIGHT}+0+${IMG1_OFFSET} ${TEMP_FILE1A}
convert ${FILENAME} -crop ${W2_WIDTH}x${W1_HEIGHT}+${W1_WIDTH}+${IMG2_OFFSET} ${TEMP_FILE2A}

echo -e "Redimensionando imágenes..."

#redimensionar
convert ${TEMP_FILE1A} -resize ${SCR1_WIDTH}x${VIRTUAL_HEIGHT} ${TEMP_FILE1B}
convert ${TEMP_FILE2A} -resize ${SCR2_WIDTH}x${VIRTUAL_HEIGHT} ${TEMP_FILE2B}

echo -e "Guardando imágenes..."

#Recorte final
let "SCR1_SOBRANTE=${VIRTUAL_EXPANSION}-${SCR1_OFFSET}"
convert ${TEMP_FILE1B} -crop ${SCR1_WIDTH}x${SCR1_HEIGHT}+0+${SCR1_SOBRANTE} $FINAL_FILE1

let "SCR2_SOBRANTE=$VIRTUAL_HEIGHT-$SCR2_HEIGHT"
convert ${TEMP_FILE2B} +repage -crop ${SCR2_WIDTH}x${SCR2_HEIGHT}+0+${SCR2_SOBRANTE} ${TEMP_FILE2C} 

#redimensionado final en la segunda pantalla
convert ${TEMP_FILE2C} -resize 1440x900\! ${FINAL_FILE2}

echo -e "\nSumario:"
echo -e "DATOS DE LA IMAGEN"
echo -e "El ancho es $IMG_WIDTH"
echo -e "El alto es $IMG_HEIGHT"
echo
echo -e "DATOS DEL ESCRITORIO"
echo -e "Ancho total: $VIRTUAL_WIDTH"
echo -e "Proporción entre la imagen y el escritorio: $PROPORTION"
echo
echo -e "Terminado."

Conexión del arduino mini pro al conversor UART TTL cp2102 de 6 pins

El CP2102 incluye el pin DTR que resetea automáticamente el arduino cuando se lo programa.

Arduino     CP2102
GND ------- GND
VCC ------- +5V
RXI ------- TXD
TXD ------- RXD
GRN ------- DTR 

Tutorial para usar el conversor de 5 pins

CD4017 con 4 LEDs

CD4040 como divisor de frecuencia

PIN FRECUENCIA
10  INPUT
 9  INPUT/2
 7  INPUT/4
 6  INPUT/8
 5  INPUT/16
 3  INPUT/32
 2  INPUT/64
 4  INPUT/128
13  INPUT/256
12  INPUT/512
14  INPUT/1024
15  INPUT/2048
 1  INPUT/4096

Salida de 5V a entrada de 3V con mosfet

74HC04 vs 74LS04 vs 74HC14

Una Puerta lógica:

Flanco de subida:

Flanco de bajada:

Tres puertas lógicas en serie:

Flanco de subida:

Flanco de bajada:

PWM con 74HC14

Basado en http://www.robotroom.com/PWM.html

PWM con el MSP430

• El contador del timer se configura para que cuente hasta 200.
• De 0 hasta 20 la salida está high. El resto hasta 200 está low.
• Al llegar a 200 se ejecuta la interrupción TIMER0_A0_VECTOR. 
• La salida está en P 1.2.

Configuración de la salida:
P1SEL = BIT2;

Configuración del timer:
    /*
     * TACCTL0, Capture/Compare Control Register 0
     *
     * CM_0 -- No Capture
     * CCIS_0 -- CCIxA
     * ~SCS -- Asynchronous Capture
     * ~SCCI -- Latched capture signal (read)
     * ~CAP -- Compare mode
     * OUTMOD_0 -- PWM output mode: 0 - OUT bit value
     *
     * Note: ~ indicates that has value zero
     */

    TACCTL0 = CM_0 + CCIS_0 + OUTMOD_0 + CCIE;

Configuración del PWM:
    /*
     * TACCTL1, Capture/Compare Control Register 1
     *
     * CM_0 -- No Capture
     * CCIS_0 -- CCIxA
     * ~SCS -- Asynchronous Capture
     * ~SCCI -- Latched capture signal (read)
     * ~CAP -- Compare mode
     * OUTMOD_7 -- PWM output mode: 7 - PWM reset/set
     *
     * Note: ~ indicates that has value zero
     */

    TACCTL1 = CM_0 + CCIS_0 + OUTMOD_7;

Fijar el contador en 200, la transición del high a low al llegar a 20:
TACCR0 = 200;
TACCR1 = 20;

Configurar la fuente del reloj:
    /*
     * TACTL, Timer_A2 Control Register
     *
     * TASSEL_1 -- ACLK
     * ID_0 -- Divider - /1
     * MC_1 -- Up Mode
     */

    // Usando ACL 12khz
    // TACCR0 : 1Seg = 12000
    // TACCR1 : 99% -> 198 (99% hight, 1% low)
    //          50% -> TACCR0 /2


    TACTL = TASSEL_1 + ID_0 + MC_1;

El código a ejecutar en la interrupción al llegar a 200:
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A0 (void){
P1OUT ^= BIT0;
}

DS32kHz conectado al MSP430

Las luces del coche fantástico con 4 leds. El bucle principal del programa avanza un led en cada ciclo y entra en LPM4. La interrupción del Timer se encarga de reanudar la ejecución.

src/grace/GPIO_init.c
P1.0 tiene que configurarse como TA0CLK.

/*
 *  ======== GPIO_graceInit ========
 *  Initialize MSP430 General Purpose Input Output Ports
 *
 *  The GPIO registers should be set in a specific order:
 *     PxOUT
 *     PxSEL or PxSELx
 *     PxDIR
 *     PxREN
 *     PxIES
 *     PxIFG
 *     PxIE
 *
 *     This will ensure that:
 *         - IFG doesn't get set by manipulating the pin function, edge
 *           select, and pull-up/down resistor functionalities (see
 *           Section 8.2.6 of the MSP430 User's manual)
 *         - Glitch-free setup (configuring the OUT register _before_
 *           setting the pin direction)
 *         - Pull-up/pull-down resistor enable with the correct direction
 *           (.up. vs. .down.)
 */
void GPIO_graceInit(void)
{
    /* USER CODE START (section: GPIO_graceInit_prologue) */
    /* User initialization code */
    /* USER CODE END (section: GPIO_graceInit_prologue) */

    /* Port 1 Output Register */
    P1OUT = 0;

    /* Port 1 Port Select Register */
    P1SEL = BIT0;

    /* Port 1 Direction Register */
    P1DIR = BIT1 + BIT2 + BIT3 + BIT4 + BIT5 + BIT6 + BIT7;

    /* Port 1 Interrupt Edge Select Register */
    P1IES = 0;

    /* Port 1 Interrupt Flag Register */
    P1IFG = 0;

    /* Port 2 Output Register */
    P2OUT = 0;

    /* Port 2 Port Select Register */
    P2SEL &= ~(BIT6 + BIT7);

    /* Port 2 Direction Register */
    P2DIR = BIT0 + BIT1 + BIT2 + BIT3 + BIT4 + BIT5 + BIT6 + BIT7;

    /* Port 2 Interrupt Edge Select Register */
    P2IES = 0;

    /* Port 2 Interrupt Flag Register */
    P2IFG = 0;
}

src/grace/Timer0_A3_init.c

/*
 *  ======== Timer0_A3_graceInit ========
 *  Initialize MSP430 Timer0_A3 timer
 */
void Timer0_A3_graceInit(void)
{
    /* 
     * TA0CCTL0, Capture/Compare Control Register 0
     * 
     * CM_0 -- No Capture
     * CCIS_0 -- CCIxA
     * ~SCS -- Asynchronous Capture
     * ~SCCI -- Latched capture signal (read)
     * ~CAP -- Compare mode
     * OUTMOD_0 -- PWM output mode: 0 - OUT bit value
     * 
     * Note: ~<BIT> indicates that <BIT> has value zero
     */
    TA0CCTL0 = CM_0 + CCIS_0 + OUTMOD_0 + CCIE;

    /* TA0CCR0, Timer_A Capture/Compare Register 0 */
    TA0CCR0 = 3199;

    /* 
     * TA0CTL, Timer_A3 Control Register
     * 
     * TASSEL_0 -- TACLK
     * ID_0 -- Divider - /1
     * MC_1 -- Up Mode
     */
    TA0CTL = TASSEL_0 + ID_0 + MC_1;
}

src/grace/InterruptVectors_init.c
La interrupción despierta al MCU. El cuerpo del programa está en main().

/*
 *  ======== Timer0_A3 Interrupt Service Routine ======== 
 */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR_HOOK(void)
{
    /* USER CODE START (section: TIMER0_A0_ISR_HOOK) */
 // Continua con el programa principal
 __bic_SR_register_on_exit(CPUOFF);
    /* USER CODE END (section: TIMER0_A0_ISR_HOOK) */
}

main.c

unsigned int contador = 0;
int dir=1;

/*
 *  ======== main ========
 */
int main(void)
{
    Grace_init();                   // Activate Grace-generated configuration
    
    while (1) {
  contador = contador + dir;
  if (contador==4){
   dir = -1;
  }

  if (contador == 1){
   dir = 1;
  }

  P1OUT = (1 << contador);

  LPM4;
    }
}

Usar un 74HC165 con el MSP430 a través de USI

Conexión:

74HC165           MSP430
QH -------------> P1.7 (SDI)
CLK ------------> P1.5 (SCLK)
PL (o SH/LD) ---> P.1.2 (Cualquier pin vale).



InterruptVectors_init.c

/*
 *  ======== Timer0_A3 Interrupt Service Routine ======== 
 */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR_HOOK(void)
{
    /* USER CODE START (section: TIMER0_A0_ISR_HOOK) */
    // Pedir al 74hc165 que lea las entradas
    P1OUT &= ~BIT2; // poner pin ld low
    P1OUT |= BIT2; // poner pin ld hight

    //Pedir al USI que lea 8 bits
    USICNT |= 8;

    /* USER CODE END (section: TIMER0_A0_ISR_HOOK) */
}


/*
 *  ======== USI Interrupt Service Routine ========
 */
#pragma vector=USI_VECTOR
__interrupt void USI_ISR_HOOK(void)
{
    /* USER CODE START (section: USI_ISR_HOOK) */
 USICTL1 &= ~USIIFG;
 clearDisplay();
 sendNumber(USISRL);
    /* USER CODE END (section: USI_ISR_HOOK) */
}

USI_init.c

/*
 *  This file is automatically generated and does not require a license
 */

#include <msp430.h>

/* USER CODE START (section: USI_init_c_prologue) */
/* User defined includes, defines, global variables and functions */
/* USER CODE END (section: USI_init_c_prologue) */

/*
 *  ======== USI_graceInit ========
 *  Initialize Universal Serial Interface
 */
void USI_graceInit(void)
{
    /* USER CODE START (section: USI_graceInit_prologue) */
    /* User initialization code */
    /* USER CODE END (section: USI_graceInit_prologue) */

    /* Disable USI */
    USICTL0 |= USISWRST;

    /* 
     * USI Control Register 0
     * 
     * USIPE7 -- USI function enabled
     * ~USIPE6 -- USI function disabled
     * USIPE5 -- USI function enabled
     * ~USILSB -- MSB first
     * USIMST -- Master mode
     * ~USIGE -- Output latch enable depends on shift clock
     * ~USIOE -- Output disabled
     * USISWRST -- USI logic held in reset state
     * 
     * Note: ~<BIT> indicates that <BIT> has value zero
     */
    USICTL0 = USIPE7 + USIPE5 + USIMST + USISWRST;

    /* 
     * USI Control Register 1
     * 
     * USICKPH -- Data is captured on the first SCLK edge and changed on the following edge
     * ~USII2C -- I2C mode disabled
     * ~USISTTIE -- Interrupt on START condition disabled
     * USIIE -- Interrupt enabled
     * ~USIAL -- No arbitration lost condition
     * ~USISTP -- No STOP condition received
     * ~USISTTIFG -- No START condition received. No interrupt pending
     * USIIFG -- Interrupt pending
     * 
     * Note: ~<BIT> indicates that <BIT> has value zero
     */
    USICTL1 = USICKPH + USIIE + USIIFG;

    /* 
     * USI Clock Control Register
     * 
     * USIDIV_0 -- Divide by 1
     * USISSEL_2 -- SMCLK
     * ~USICKPL -- Inactive state is low
     * ~USISWCLK -- Input clock is low
     * 
     * Note: ~<BIT> indicates that <BIT> has value zero
     */
    USICKCTL = USIDIV_0 + USISSEL_2;

    /* Enable USI */
    USICTL0 &= ~USISWRST;

    /* USER CODE START (section: USI_graceInit_epilogue) */
    /* User code */
    /* USER CODE END (section: USI_graceInit_epilogue) */
}

Usar un 74HC165 con el MSP430 y 8 interruptores

Nota:
LD --> PIN_PL
CLK--> PIN_CP
Q7 --> PIN_Q


74hc165.h

/*
 * 74hc165.h
 */

#ifndef FILE_74HC165_H_
#define FILE_74HC165_H_

#include "msp430.h"
#define PISO_IN_PORT P1IN
#define PISO_OUT_PORT P1OUT
#define PIN_PL BIT5
#define PIN_CP BIT4
#define PIN_Q BIT3

#define PIN_CP_HIGH PISO_OUT_PORT |= PIN_CP
#define PIN_CP_LOW PISO_OUT_PORT &= ~PIN_CP
#define PIN_PL_HIGH PISO_OUT_PORT |= PIN_PL
#define PIN_PL_LOW PISO_OUT_PORT &= ~PIN_PL

void init74hc165 (void);
unsigned char read74hc165(void);

#endif /* FILE_74HC165_H_ */

74hc165.c

/*
 * 74hc165.c
 */

#include "74hc165.h"

void pulseClock (void){
 PIN_CP_HIGH;
 PIN_CP_LOW;
}

void init74hc165 (void){
 PIN_PL_HIGH;
 PIN_CP_HIGH;
}

unsigned char read74hc165(void){

 unsigned char i;
 unsigned char ret = 0;
 volatile unsigned char readed;

 PIN_CP_HIGH;
 PIN_PL_LOW;
 PIN_CP_LOW;
 PIN_PL_HIGH;

 for (i=0; i < 8; i++){

  readed = PISO_IN_PORT;

  if ((readed & PIN_Q) == PIN_Q){
   ret = ret + (128 >> (i));
  }

  pulseClock();
 }

 return ret;
}