¿Cómo detecta programáticamente el número de pines en un MSP430G2553?

Estoy usando un Launchpad para programar un controlador MSP430G2553. Lo uso para depurar. Este controlador tiene 20 pines. Sin embargo, el objetivo final aquí es ejecutar mi programa en un controlador MSP430G2553IPW28R. Este controlador tiene 28 pines en lugar de 20.

Estoy usando los pines P3.0 y P3.1 en el controlador de 28 pines para algunos LED. Y mi controlador Launchpad no tiene esos pines. Necesito determinar en qué controlador se está ejecutando el código.

Usaré los pines JTAG de mi plataforma de lanzamiento para programar el controlador de 28 pines. Entonces, la pregunta es, ¿cómo puedo determinar mediante programación en cuál de los 2 controladores se está ejecutando mi código y poner algún tipo de #define para usar los pines P3.0, P3.1 cuando se ejecuta en el controlador de 28 pines y los pines? P2.1 y P2.2 cuando se ejecuta en el controlador Launchpad. No quiero comentar y descomentar líneas de código cada vez que cambio de un procesador a otro...

Tenga en cuenta que estoy usando Energia como mi entorno de desarrollo.

Launchpad carece de JTAG, ¿te refieres al encabezado de 6 pines con SBW?
Por lo que recuerdo, no puede simplemente intentar alternar los pines, ya que si bien no están separados, todavía están implementados en el hardware. No debería necesitar descomentar varias líneas. Haga un conjunto de si está definido, y solo tendrá que cambiar una sola línea cuando cambie de paquete. Si se define A, defina xyz como 123, de lo contrario, si se define B, etc. Sin embargo, aún puede haber una verificación de tiempo de compilación para el paquete o la firma. ¿Qué compilador o ide estás usando?
No tiene que comentar y descomentar el código para diferentes configuraciones. Simplemente agregue -D 20PIN o -D 28PIN a la configuración de compilación, y #ifdef alrededor del código para cada opción.
¿Está dispuesto a sacrificar uno de los 8 pines adicionales para usarlo como control de arranque/tiempo de ejecución? configure el pin 7 del puerto 3 como entrada con pull-up. Si el pin está conectado a tierra en el tablero, use 3.0 y 3.1. Como no puede atar ese pin bajo en el paquete de 20 pines, sabrá qué paquete se usa. Para minimizar el consumo de corriente, cambiaría el pin a salida baja después de realizar la verificación al inicio.

Respuestas (3)

Según la complejidad del proyecto y el tamaño de la MCU, uso de 1 a 3 pines para la "identificación de PCB" con resistencias desplegables externas. Las resistencias se montan según la revisión de la placa. La aplicación dentro de la MCU mira estos pines al inicio y determina qué hacer.

Ayuda aún más si tiene varios productos con algunas diferencias que le permiten tener una sola imagen binaria para todas las revisiones de hardware.

En mi humilde opinión, la opción más preferida es buscar una identificación de chip en la documentación. La mayoría de los chips modernos proporcionan un registro interno con el tipo de chip y la revisión. Podrías usar eso para impulsar tu lógica.

Para la familia MSP430, he podido encontrar algunas identificaciones principales en la documentación de BSL (página 37). Sin embargo, estos solo se limitan a la matriz familiar y no distinguen entre paquetes de chips. Aún puede intentar probar y verificar si hay alguna diferencia.

Alternativamente, puede usar cambios físicos en la placa, como agregar pull-up/downs en ciertos pines que pueden probarse con software o atar pines bajo/alto.

El método a continuación le dirá si existe un pin en el controlador. Entonces, para determinar si estamos usando un controlador de 20 o 28 pines, seleccione un pin digital que sea > 20 y páselo como parámetro a la función a continuación. Si devuelve verdadero, tiene un controlador de 28 pines. Si devuelve falso, tiene un controlador de 20 pines. Probé esto usando mi MSP430G2553 Launchpad y obtuve los siguientes resultados:

  showPinExistence(2);
  showPinExistence(3);
  showPinExistence(5);
  showPinExistence(6);
  showPinExistence(7);
  showPinExistence(8);
  showPinExistence(11);
  showPinExistence(15);
  showPinExistence(18);
  showPinExistence(21);
  showPinExistence(22);
  showPinExistence(23);


void showPinExistence(int pin)
{
  Serial.print("Pin ");
  Serial.print(pin);
  Serial.print(" Exists: ");
  Serial.println(pinExists(pin)?"True":"False");
  Serial.flush();
}

bool pinExists(int pin)
{
    bool lowResult;
    bool highResult;

    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
    lowResult = digitalRead(pin);

    digitalWrite(pin, HIGH);
    highResult = digitalRead(pin);

    return lowResult != highResult;
}

Aquí está la salida para LaunchPad con MSP430G2553 (20 pines):

Pin 2 Exists: True
Pin 3 Exists: True
Pin 5 Exists: True
Pin 6 Exists: True
Pin 7 Exists: True
Pin 8 Exists: True
Pin 11 Exists: True
Pin 15 Exists: True
Pin 18 Exists: True
Pin 21 Exists: False
Pin 22 Exists: False
Pin 23 Exists: False

Aquí está la salida para MSP430G2553 (28 pines):

Pin 8 Exists: True
Pin 9 Exists: True
Pin 10 Exists: True
Pin 11 Exists: True
Pin 12 Exists: True
Pin 13 Exists: True
Pin 14 Exists: True
Pin 15 Exists: True
Pin 16 Exists: True
Pin 17 Exists: True
Pin 18 Exists: True
Pin 19 Exists: True
Pin 20 Exists: True
Pin 21 Exists: True
Pin 22 Exists: True
Pin 23 Exists: True

Tuve que comenzar con el pin 8 porque no me gustó cuando intenté configurar 2-7 como pines de salida :-) De todos modos, el punto es que puedes intentar configurar el pin 23 como un pin de salida y escribir y leer su valor para determinar si el chip que está utilizando es de 20 pines o si tiene más de 20 pines. No tengo un chip de 32 pines, pero me imagino que podría probar en un pin mayor a 28 para determinar si es un chip de 32 pines.

Ahora, después de TODO lo que he dicho. Desde que escribí esto, descubrí que ahora hay soporte de 28 pines en GitHub. Ahora lo estoy usando y me refiero a los pines con su notación P3_0, P2_0 adecuada en lugar de directamente por el número de pin y parece estar funcionando bien ahora.

Los pines 21, 22, 23 devuelven falso en la función anterior cuando se usa un paquete de 20 pines. Lo probaré en un paquete de 28 pines en un par de días.
Esperar. Eres OP. ¿Supongo que probaste esto y descubriste que funcionó?
Se agregaron resultados y una función de ayuda corta adicional para agregar credibilidad a la respuesta anterior.
Estoy anulando la votación, ya que la hoja de datos parece indicar que el Puerto 3 está completamente excluido en el paquete de 20 pines, lo que implica que se usa un Wafer Die diferente. Esto parece extraño. Sé con certeza que esto, si se usa para los pines P2.0-P2.5 en el MSP430 de 14 pines, no funcionará, ya que el troquel es el mismo que el paquete de 20 pines.
Consulte la nota en la página 328 de la guía de la familia x2xx, por ejemplo. El G2210/30 es la versión de 8 pines, y fallaría para P1.0, 1.1, 1.3, 1.4, 2.6 y 2.7, ya que el DIE es el mismo que el de la versión 2211 y 2231 de 14 pines. Entonces, actualice una vez que pueda probar en el pin 2253 de 28/32, ya que me encantaría confirmar esto.
Agregué una salida para un MSP430G2553 de 28 pines que indica la existencia de los pines 21-23 donde la versión de 20 pines mostraba esos pines como falsos.
esto no funciona Los registros del puerto 3 funcionan bien en mi versión msp430g2553 launchpad de 20 pines. Obtuve los mismos resultados usando su ejemplo anterior, showPinExistence() devuelve falso para los pines del puerto 3, pero eso se debe a que pinMode/digitalWrite en realidad no escribe/lee desde el puerto P3, sino porque P3 no está definido internamente . Lo que me confunde es que aparentemente funciona en la versión de 28 pines para usted, que no debería basarse en lo que estoy viendo a menos que también haya cambiado el objetivo de compilación en Energia.
¿Cómo detecta programáticamente el número de pines en un MSP430G2553?
RespuestasAquíPolítica de privacidad1y, 0v