Utgångskoder

Ett azure sphere-program på hög nivå kan använda utgångskoder för att returnera information som är relaterad till var i koden felet inträffade och varför det inträffade. En utgångskod motsvarar ett värde mellan 0 och 255, där 0 anger framgång.

Definiera och använda utgångskoder i en app

Följ dessa riktlinjer för att definiera och använda utgångskoder i en app:

• Skapa en exit code-variabel och initiera den till framgång (0) i början av programmet.
• Returnera en utgångskod från en funktion där ett fel har fått programmet att avslutas. Funktionsutgångskoderna kan ge detaljerad information om driftfel. En funktion som skickar ett meddelande till ett IoT Central-program kan till exempel returnera en felkod som innehåller information om var felet inträffade: i meddelandekonstruktion, IoT-anslutning, meddelandeöverföring och så vidare. En annan funktion som ansvarar för att initiera kringutrustning returnerar en unik utgångskod som indikerar ett fel med en viss kringutrustning.
• Om en felutgångskod (noll noll) anges eller returneras av en funktion kontrollerar du att den omedelbart sprids tillbaka för att huvudfunktionen ska returneras. Det gör att programmet avslutas med den angivna utgångskoden. Azure Sphere-operativsystemet startar omedelbart om programmet (såvida du inte använde felsökaren med en ansluten utvecklingstavla), och du kan använda felrapporter för att diagnostisera orsaken till att ett utgångsfel uppstod.

Felrapporter

När ett program på hög nivå avslutas loggar Azure Sphere-operativsystemet utgångskoden som returneras av programmet och laddar senare upp en felrapport som innehåller den här informationen till Azure Sphere Security Service dagligen. Genom att jämföra utgångskoden i felrapporten med de utgångskoder som definierats i programmet kan du ofta fastställa platsen och orsaken till felet. Mer information finns i Tolka AppExits .

RTApps kan inte returnera feldata direkt till Azure Sphere-säkerhetstjänsten. Om du vill implementera felspårning i en RTApp måste du kommunicera feldata från RTApp till en högnivåapp med hjälp av kommunikationsmekanismen mellan kärnor. Mer information finns i Kommunicera med ett program på hög nivå och Kommunicera med ett program som kan användas i realtid .

Exempel på implementering av utgångskod

Följande avsnitt visar ett exempel på hur du kan införliva utgångskoder i ett program på hög nivå.

Deklarera först ett ExitCode uppräkning i programmet som du kan använda för att definiera alla dina specifika utgångskodsvärden. Initiera sedan en global exitCode variabel till framgångstillståndet (0).

// Exit codes for this application.
typedef enum {
ExitCode_Success = 0;
ExitCode_Init_LED = 1;
ExitCode_Init_Button = 2;
} ExitCode;

// Initialize the termination state.
static volatile sig_atomic_t exitCode = ExitCode_Success;

Funktioner som innehåller felfall som ska avsluta programmet ska returnera ett ExitCode-uppräkning. Om ett felfall har nåtts som ska avsluta programmet returnerar du den specifika utgångskoden som du har definierat för det fallet. I exemplet InitPeripheralsAndHandlers nedan definieras funktionen, vilket initierar en LED-indikator och en knapp. Om någon av initieringarna misslyckas returneras motsvarande ExitCode värde som definierats ovan.

// Initialize the peripherals and handlers. Return ExitCode_Success if all resources were allocated
// successfully; otherwise another ExitCode value which indicates a specific failure.
static ExitCode InitPeripheralsAndHandler(void)
{
	// Open SAMPLE_LED as output.
	led = GPIO_OpenAsOutput(SAMPLE_LED);
	if (led == -1) {
		return ExitCode_Init_LED;
	}

	// Open SAMPLE_BUTTON as input.
	button = GPIO_OpenAsInput(SAMPLE_BUTTON);
	if (button == -1) {
		return ExitCode_Init_Button;
	}
	return ExitCode_Success;
}

Efter initieringen förblir programmet i huvudloopen så länge den globala exitCode variabeln fortfarande tilldelas det ursprungliga framgångsvärdet. Om någon del av huvudprogramlogik någonsin ställer in variabeln exitCode till ett annat värde än lyckat bryts programmet ur huvudslingan och avslutas med uppsättningen exitCode. Azure Sphere-operativsystemet registrerar appens utgångshändelse och motsvarande utgångskod i en felrapport och startar sedan om programmet.

int main(int argc, char* argv[])
{
	exitCode = InitPeripheralsAndHandler();

	while (exitCode == ExitCode_Success) {
		// Run other application functions within this loop.
		// When a function encounters an error, set a corresponding exit code and return from that function.
		// This will break out of the while loop if the exit code is not ExitCode_Success.
	}

	return exitCode;
}