AVR/Arduino knippert met Raspberry Pi - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Een in-system programmer (ISP) is een apparaat waarmee je veel microcontrollers kunt programmeren, bijvoorbeeld de ATMega328p die het brein is van een Arduino Uno. Je kunt zoiets kopen als een USBtinyISP, of je kunt zelfs een Arduino gebruiken. Deze instructable laat je zien hoe je een Raspberry Pi als ISP gebruikt.

Het avrdude-programma, dat de Arduino IDE onder de motorkap gebruikt om chips te flashen, kan met veel programmeurs worden gebruikt. Een van de opties is om de SPI-pinnen op de uitbreidingspoort van de Pi te gebruiken. Ik zal uitleggen hoe je de juiste verbindingen maakt, een eenvoudig circuit op perfboard samenstelt zodat je niet elke keer de bedrading opnieuw hoeft te doen als je een chip wilt flashen, en hoe je avrdude installeert en gebruikt. Ik zal je ook laten zien hoe je programma's gecompileerd kunt krijgen met behulp van de Arduino IDE op een AVR-chip zoals een ATmega of ATtiny met behulp van deze methode.

Dingen die nodig zijn:

• Raspberry Pi met de nieuwste Raspbian geïnstalleerd
• 40-pins mannelijke header-aansluiting (of 26-pins als je een oudere Pi hebt)
• IDE-kabel om verbinding te maken met uw Pi
• 16 MHz kristalresonator
• 22 pF condensatoren (2)
• LED (1) om de status van de programmeur aan te geven
• 8, 14 en/of 28-pins IC-sockets, afhankelijk van de vorm van de chips die u wilt laten flitsen
• Sommige perfboard, draden, soldeer

Stap 1: Cobbler Attachment bouwen

Serial Peripheral Interface (SPI), ook wel vierdraads serieel genoemd, is een manier om te communiceren tussen een enkel masterapparaat en een of meer slave-apparaten. We zullen dit gebruiken om chips te flashen, met de Pi als master en de chip als slave. Je maakt de volgende verbindingen tussen de Pi en je chip (zie de pinouts hierboven voor verschillende AVR's en Pi-uitbreidingspoorten om te weten welke pinnen dat zijn):

• Verbind de MOSI-pinnen (master-out-slave-in) met elkaar
• Verbind de SCLK-pinnen (gedeelde klok) met elkaar
• Verbind de MISO (master-in-slave-out) pinnen samen met een 220 Ohm weerstand, om de Pi te beschermen tegen onverwacht hoge spanningen van de chip
• Verbind GPIO 25 op de Pi rechtstreeks met de RESET-pin op de chip. De Pi trekt deze pin laag tijdens het programmeren, dus we gebruiken een weerstand van 10K om hem hoog te houden als hij niet programmeert, en een LED met een beschermingsweerstand van 1K die naar positieve spanning loopt om ons wat mooie visuele feedback te geven tijdens het programmeren.

We verbinden grond- en stroom- (3.3V) pinnen tussen de Pi en de chips die we willen programmeren. Voor het geval je het nog niet weet, de pinnen van de Raspberry Pi zijn niet 5V-tolerant - ze zullen beschadigd raken als er meer dan 3,3V op verschijnt. Als de chips die worden geprogrammeerd om de een of andere reden 5V-stroom nodig hebben, kunnen we een level shifter-chip gebruiken om de pinnen van de Pi te beschermen, maar ik heb geen problemen ondervonden bij het gebruik van 3,3V - dus ik raad aan om op veilig te spelen en te besparen op componenten.

Ten slotte verbinden we een 16MHz kristaloscillator over de XTAL-pinnen op de chip, die we ook verbinden met aarde via een paar 22pF-condensatoren. AVR-chips kunnen worden ingesteld om op verschillende frequenties te werken en kunnen ook worden ingesteld om een interne of externe bron te gebruiken om die frequentie te bepalen. Als uw chip is ingesteld om een extern kristal als frequentiebron te gebruiken, kunt u niet zonder herprogrammeren. Anders maakt het niet uit of het er is.

U kunt het schakelschema in de laatste afbeelding gebruiken als richtlijn voor het monteren van uw schoenmakerhulpstuk op perfboard. Je kunt zo veel of zo weinig verschillende vormen van IC-sockets hebben als je wilt, sluit gewoon de juiste pinnen parallel aan de Pi en het kristal. NB als je de afbeelding van mijn prototype als richtlijn gebruikt, merk dan op dat ik wat extra header-pinnen en sockets heb toegevoegd, zodat ik om niet-gerelateerde redenen toegang had tot de pinnen op de Pi.

Stap 2: Avrdude installeren en gebruiken

Om avrdude op je Pi te installeren, typ je gewoon

sudo apt-get install avrdude

U moet dan de SPI-interface inschakelen, als deze nog niet is ingeschakeld. Er is een manier om dit via de opdrachtregel te doen, maar het is veel gemakkelijker om de Raspberry Pi-configuratietool te gebruiken. Type

sudo raspi-config

en ga naar Interface-opties om SPI in te schakelen.

Om je chip te flashen, steek je de lintkabel van je Pi in de connector op het perfboard-circuit en steek je de chip in de juiste IC-socket (zorg ervoor dat deze naar de goede kant wijst).

Bij het flashen van een programma moet je er ook voor zorgen dat de zekeringen in de chip correct zijn geplaatst. Dit zijn eigenlijk alleen maar stukjes in de chip die je instelt om hem te vertellen op welke kloksnelheid hij moet draaien, of de EEPROM moet worden gewist bij het schrijven van de chip, enz. Je zou de volledige AVR-specificatie kunnen lezen om erachter te komen hoe je elk bit moet instellen, maar het is veel gemakkelijker om de zekeringcalculator te gebruiken op engbedded.com/fusecalc. Selecteer de AVR-onderdeelnaam die u gebruikt en kies de gewenste opties in het gebied "Functieselectie". Ik zorg er meestal voor dat de klokinstellingen juist zijn en laat de andere dingen standaard. U zult bijna altijd "Seriële programmering ingeschakeld" AANGESCHAKELD en "Reset uitgeschakeld" ONGECONTROLEERD willen laten - anders kunt u de chip niet herprogrammeren. Als u de juiste instellingen heeft, kunt u in het gebied "Huidige instellingen" naar beneden scrollen en de AVRDUDE-argumenten kopiëren zoals weergegeven in de afbeelding.

Voer de opdracht in om de zekeringen in te stellen:

sudo avrdude -c linuxspi -P /dev/spidev0.0 -p

waarbij partname overeenkomt met de chip die u gebruikt. U kunt de lijst met onderdeelnamen vinden door sudo ardude -c linuxspi -p ?type in te voeren. Om uw programma te flashen, moet u ervoor zorgen dat het in uw huidige map staat en typt u

sudo avrdude -c linuxspi -P /dev/spidev0.0 -p -U flash:w::i

Na beide commando's zal de LED oplichten terwijl de chip wordt aangepast.

Stap 3: Arduino-programma's op AVR's krijgen

De belangrijkste focus van deze instructable is het flashen van reeds gecompileerde programma's op chips, niet hoe ze te schrijven of te compileren. Ik wilde echter uitleggen hoe je binaries kunt compileren met behulp van de Arduino IDE en ze met deze methode op kale AVR-chips kunt krijgen, aangezien Arduino relatief eenvoudig te leren is en er zoveel tutorials en voorbeelden zijn.

Eerst moet u informatie toevoegen over de AVR-chips die u gaat flashen, zodat de IDE weet hoe ze ervoor moeten compileren. James Sleeman heeft zeer behulpzaam enkele installatiebestanden samengesteld, die beschikbaar zijn op github. Om ze te gebruiken, opent u het menu "Voorkeuren" in de Arduino IDE en klikt u op het vakje naast het veld "Extra Boards Manager-URL's". Kopieer en plak de volgende URL's in het dialoogvenster dat verschijnt:

Ga dan naar het menu "Tools" en zoek de optie "Boards Manager…" in het submenu "Board". Scrol omlaag naar de onderkant van de lijst in het dialoogvenster Boards Manager en installeer de DIY ATmega- en DIY ATtiny-borden.

Om uw programma's te compileren, moet u er eerst voor zorgen dat u de juiste chip in het menu "Processor" hebt geselecteerd, evenals de juiste processorsnelheid. Selecteer de optie "Gebruik Bootloader: Nee", omdat we direct met de Pi zullen uploaden en dus de extra ruimte kunnen gebruiken die normaal gesproken door de Arduino-bootloader zou worden ingenomen. Klik nu op de knop "Verifiëren" (het vinkje). Dit zal je programma compileren zonder te proberen het te uploaden (omdat je die stap zelf doet).

Ervan uitgaande dat alles goed gaat, moet je nu het gecompileerde programma naar je Pi krijgen. De IDE verbergt ze op een tijdelijke locatie, omdat deze is ontworpen om zelf programma's te uploaden. Op Windows bevindt het zich in AppData/Local/Temp in uw gebruikersdirectory, in een map die begint met 'arduino_build'. Zoek naar het.hex-bestand - dat is jouw programma! Stuur het naar je Pi via FTP of met een USB-stick, en je bent in zaken.

Om dit te doen, moet je een Windows-pc of Mac hebben om je programma's te compileren, die je vervolgens naar de Pi stuurt. Het zou heel gelikt zijn om dit op de Pi zelf te kunnen doen, maar helaas is de officiële versie van de Arduino IDE die beschikbaar is in de Raspbian-repository vrij oud en heeft deze geen Board Manager. Zonder dit is het een beetje lastiger om de juiste instellingen toe te voegen om te compileren voor kale AVR's. Er zijn tutorials voor het compileren van een recentere versie van Arduino op je Pi - als dat is wat je wilt doen, ga ze dan zoeken! Ik heb ook het gevoel dat het mogelijk moet zijn om de IDE de linuxspi-programmeur te laten gebruiken om een chip te flashen vanuit de IDE zelf (dwz met behulp van de "download"-knop), maar dit gaat mijn geduld en vaardigheidsniveau te boven - als je weet van een manier, post het in de reacties! Ten slotte kun je programma's gewoon rechtstreeks in AVR-C schrijven en ze op de Pi compileren met avr-gcc, waardoor je een compleet AVR-ontwikkelplatform in de Raspberry Pi krijgt. Ik heb dat een klein beetje gedaan, en als je die weg wilt gaan, groet ik je. Ga knipperen!