PICkit 2: descubra por qué mi procesador está fallando

Prueba un punto de interrupción. Coloque un punto de interrupción en la función donde cree que se está estrellando. No estoy seguro de si el PICkit 2 admite esto.

Por qué Firmware Guys / Gals Love E / S digital adicional

Aún más fácil, usa un par de esas líneas de depuración. Es posible que los conozca como E / S digital sin usar, pero son líneas de depuración en lo que a mí respecta. En los puntos clave, coloque la línea en alto y, después de eso, hágalo bajo. Mueve estos y encuentra cuál no baja de nuevo. El ciclo de reloj requerido para llevar la línea a alto o bajo solo afectará levemente el código, ¡pero permitirá que su oscope le cuente una historia importante!

Más sobre los puntos de interrupción.

Coloque su punto de ruptura en su función posiblemente defectuosa y con un solo paso. Si tiene demasiadas interrupciones para que esto funcione, intente colocar el punto de interrupción a intervalos, eliminando la última si alcanza el número máximo de puntos de interrupción. Cuando no golpeas a uno, has encontrado tu error. Si crees que hay un caso específico en el que se bloquea, coloca una declaración if que será verdadera en ese caso y coloca un _nop () en el que puedas romper el punto.

Rutinas de servicio de interrupción

Coloque todos los ISR no utilizados para ir a una función especial que establecerá pines en un estado de error y se bloqueará en su lugar para que pueda ver un ISR que no debería estar habilitado.

Usted dice que no sabe cómo reducirlo:

Divide y conquista: elimina todo el código que puedas hasta que la falla desaparezca. Con un poco de experimentación, es probable que reduzca su búsqueda enormemente.

Como se sugiere, use líneas de E / S de repuesto para señalar puntos en su código. Idealmente, podría tener una línea que muestre la entrada y la salida de una subrutina y correlacionarla en un ámbito con la falla que se produce.

Algunos consejos generales:

• Cree un buen caso de prueba para que pueda reproducir el fallo a pedido
• Elimine todo no esencial para reproducir el fallo
• Mantenga sus ISR lo más cortos posible: haga lo que tiene que devolver y
• Comprenda y use la palabra clave volátil en C
• No confíe en los depuradores, conozca su código y confíe en un LED de depuración. En general, los depuradores simplemente no funcionan bien para los sistemas en tiempo real

La familia Freescale HCS08 tiene un registro de "Estado de restablecimiento del sistema" que se establece en función de la fuente del último restablecimiento, identificando cosas como LVD, POR, restablecimiento del depurador, código de operación ilegal, acceso ilegal a la dirección, tiempo de espera de vigilancia, pérdida de reloj, y hardware (reset externo). ¿Podría haber un equivalente en los PIC?

Me ha ahorrado un 50% de dolor después de aprender a usarlo, ya que te indica la posible fuente del error. Un punto de interrupción solo funciona si sabe aproximadamente dónde y cuándo el código causará un error fatal, de lo contrario, tendrá que pasar miles de veces, probablemente a través del mismo código, hasta que alcance el error.

Editar: Aquí está el código estúpido que escribí para él (obviamente, solo HCS08). No es tan bonito, pero bueno, soy un desarrollador de hardware, no software.

#ifdef Debug_MP16VLF
    const char rstsrc[] = "Source  :";
    const char clrColors[] = "\x1B[0m";

    const char * const rst_srcs[] = {
        " \x1B[32mPower On Reset",      " \x1B[32mReset Pin", 
        " \x1B[31mWatchdog",            " \x1B[35mIllegal Opcode",
        " \x1B[36mIllegal Address",     " \x1B[33mLow Voltage Detect",
        " \x1B[33mDebugger Reset"
    };
    enum rst_srcs_idxs{
        RST_POR,                        RST_PIN,
        RST_COP,                        RST_ILOP,
        RST_ILAD,                       RST_LVD, 
        RST_DBG
    };
#endif

...

#   ifdef Debug_MP16VLF
        // Find reason(s) for reset and display
        print_str(rstsrc, 0, 1);
        if (SRS_LVD) {
            if (SRS_POR) print_str(rst_srcs[RST_POR], 0, 1);
            print_str(rst_srcs[RST_LVD], 0, 1);
        } else if (SRS) {
            // possible multiple reset sources
            uint8_t i, j;
            for (i = SRS_ILAD_MASK, j = RST_ILAD;
                 i <= SRS_PIN_MASK;
                 i <<= 1, j--) {
                if (i & SRS) print_str(rst_srcs[j], 0, 1);
            }
        } else {
            print_str(rst_srcs[RST_DBG], 0, 1);
        }
        print_str(clrColors, 1, 1);
#   endif

En términos de reducir un desplome, use una técnica de búsqueda binaria . Utilizando uno de los métodos descritos en las otras respuestas (puntos de interrupción o líneas de E / S que van a un alcance o LED), seleccione un punto a la mitad de la función en la que sospecha que está el problema y configure el BP allí. Si se golpea el BP (o se enciende el LED), el problema está en la segunda mitad del código (ya que el programa no se bloqueó). Si no lo es, está en la primera mitad.

Cualquiera que sea la mitad es sospechoso, divida esa sección por la mitad y establezca un nuevo BP en el punto medio. Si se golpea el BP, el problema está en la otra parte del código (ahora se reduce a un cuarto si la función). Si es necesario, repita este proceso y aislará el problema en una sola línea de código.

Debido a que está utilizando una búsqueda binaria, este es el método más rápido para reducir dónde se produce un bloqueo.

Esté atento a los desbordamientos de pila. Tal vez tienes demasiadas llamadas anidadas a funciones. Trate de resolverlo llamándolos uno tras otro cuando sea posible. Algunas funciones podrían ser reemplazadas por macros. Eso podría agregar un poco más de peso a tu código, pero mantendrá tu pila baja.