Vous utilisez Raspberry Pi sans système d'exploitation Linux?

Je souhaite utiliser le Raspberry Pi en tant qu’unité centrale embarquée pure pour le développement d’applications intégrées. Comme le Raspberry Pi possède un processeur puissant avec un peu de mémoire, il constitue une excellente carte embarquée.

Est-il possible d'utiliser le Raspberry Pi sans système d'exploitation Linux? Comment puis-je faire ceci?

J'ai étudié la programmation en métal nu sur le Raspberry Pi et cela ressemble à ce que vous voulez faire. Il existe plusieurs bons sujets de discussion sur la programmation bare metal avec des personnes qui ont déployé beaucoup d’efforts pour que leur code fonctionne. Vérifiez-les pour commencer:

Guide pour commencer le métal nu sur Raspi

Programmer le RPi sur du métal nu

Programmation en Basic sur Bare Metal Tutorial 1

ou en général, vous pouvez aller sur le forum Bare Metal de Raspberry Pi et simplement parcourir les environs.

Si j'ai bien compris, vous devrez démarrer à partir de la carte SD en raison de la séquence de démarrage intégrée à la puce Broadcom. J'essaie de trouver le lien pour la séquence de démarrage mais mon fu google ne fonctionne pas, je le modifierai plus tard si je le trouve.

le seul moyen de démarrer consiste à démarrer depuis une carte sdcard fat32 formatée, allant de poweron à gpu, le chargement du micrologiciel exécutant tout fichier binaire appelé kernel.img. Par conséquent, si vous souhaitez créer un noyau personnalisé qui fasse tout ce que vous voulez, vous voulez le faire. À ce point

J'ai créé un émulateur IBM S / 390 en C # qui fonctionnera théoriquement sous Mono / Linux car il se compile en code CIL et n'utilise aucune ressource .NET non prise en charge. Cela permettra aux solutions intégrées d'utiliser des tables de contrôle indépendantes de la plate-forme avec un interpréteur de machine à états finis personnalisé. Il resterait néanmoins des systèmes d'exploitation Linux essentiels en arrière-plan.

Exemple de clignotant minimal en métal nu entièrement automatisé

Testé sur l'hôte Ubuntu 16.04, Raspberry Pi 2.

1. Insérer une carte SD sur l'hôte

2. Faire l'image:

   ./make.sh /dev/mmblck0 p1
   

   Où:

   • /dev/mmblck0 est l'appareil de la carte SD
   • p1est la première partition de l'appareil ( /dev/mmblck0p1)

3. Carte SD insérée sur PI

4. Éteindre et allumer

GitHub en amont: https://github.com/cirosantilli/raspberry-pi-bare-metal-blinker/tree/d20f0337189641824b3ad5e4a688aa91e13fd764

départs

.global _start
_start:
    mov sp, #0x8000
    bl main
hang:
    b hang

principal c

#include <stdint.h>

/* This is bad. Anything remotely serious should use timers
 * provided by the board. But this makes the code simpler. */
#define BUSY_WAIT __asm__ __volatile__("")
#define BUSY_WAIT_N 0x100000

int main( void ) {
    uint32_t i;
    /* At the low level, everything is done by writing to magic memory addresses. */
    volatile uint32_t * const GPFSEL4 = (uint32_t *)0x3F200010;
    volatile uint32_t * const GPFSEL3 = (uint32_t *)0x3F20000C;
    volatile uint32_t * const GPSET1  = (uint32_t *)0x3F200020;
    volatile uint32_t * const GPCLR1  = (uint32_t *)0x3F20002C;

    *GPFSEL4 = (*GPFSEL4 & ~(7 << 21)) | (1 << 21);
    *GPFSEL3 = (*GPFSEL3 & ~(7 << 15)) | (1 << 15);
    while (1) {
        *GPSET1 = 1 << (47 - 32);
        *GPCLR1 = 1 << (35 - 32);
        for (i = 0; i < BUSY_WAIT_N; ++i) { BUSY_WAIT; }
        *GPCLR1 = 1 << (47 - 32);
        *GPSET1 = 1 << (35 - 32);
        for (i = 0; i < BUSY_WAIT_N; ++i) { BUSY_WAIT; }
    }
}

ldscript

MEMORY
{
    ram : ORIGIN = 0x8000, LENGTH = 0x10000
}

SECTIONS
{
    .text : { *(.text*) } > ram
    .bss : { *(.bss*) } > ram
}

make.sh

#!/usr/bin/env bash

set -e

dev="${1:-/dev/mmcblk0}"
part="${2:-p1}"
part_dev="${dev}${part}"
mnt='/mnt/rpi'

sudo apt-get install binutils-arm-none-eabi gcc-arm-none-eabi

# Generate kernel7.img
arm-none-eabi-as start.S -o start.o
arm-none-eabi-gcc -Wall -Werror -O2 -nostdlib -nostartfiles -ffreestanding -c main.c -o main.o
arm-none-eabi-ld start.o main.o -T ldscript -o main.elf
# Get the raw assembly out of the generated elf file.
arm-none-eabi-objcopy main.elf -O binary kernel7.img

# Get the firmware. Those are just magic blobs, likely compiled
# from some Broadcom proprietary C code which we cannot access.
wget -O bootcode.bin https://github.com/raspberrypi/firmware/blob/597c662a613df1144a6bc43e5f4505d83bd748ca/boot/bootcode.bin?raw=true
wget -O start.elf https://github.com/raspberrypi/firmware/blob/597c662a613df1144a6bc43e5f4505d83bd748ca/boot/start.elf?raw=true

# Prepare the filesystem.
sudo umount "$part_dev"
echo 'start=2048, type=c' | sudo sfdisk "$dev"
sudo mkfs.vfat "$part_dev"
sudo mkdir -p "$mnt"
sudo mount "${part_dev}" "$mnt"
sudo cp kernel7.img bootcode.bin start.elf "$mnt"

# Cleanup.
sync
sudo umount "$mnt"