Är det samma metodik att programmera olika processorer?

[DanielM]

Ja. Målet är att lära sig lite mera om processorer, dvs sätta register och läsa datablad.

Men det ska vara investerad tid också. Att lära sig en uC familj och sedan så är det bortkastad tid, då är det inte värt.

Sedan tror jag måste köpa en Pickit 5 trots allt med tanke på att jag måste programmera processorer som AVRdude inte stödjer t.ex ATtiny1616.

Vad jag har läst är att AVR används mest av hobbyfolk och universitetsfolk för att dom är enkla att sätta sig in.

Egentligen spelar det ingen roll vilken processor jag använder om jag ska vara helt ärlig. Bästa vore om man började med något enkelt. När jag menar enkelt, så menar jag tydlig dokumentation. Enkelt att hitta och veta vad man ska göra. Sedan vore det riktigt bra om det jag lär mig, används ute i arbetslivet också, vilket frekvent. Inte bara "någon gång...." eller "sällan...". Detta gör så min motivation tappar. Jag själv jobbar som lärare så jag vet hur det är att förmedla kunskap och ta in kunskap.

[AndLi]

Jag vet inte heller vart AVR brukar användas. Som jag uppfattar det som så verkar PIC mera populärt bland företag och AVR är mer populärt bland hobbyfolk.

Jag har helt motsatt bild, vilket tyder på att båda är populära hos företag....

Men båda upplever jag leva en tynande tillvara, länge sedan jag var i ett projekt där någon av dem var på tapeten...

[Icecap]

Jag skippade över AVR efter att ha kollat på deras arkitektur.

Inget katastrofalt men jag gillar inte vissa delar.

PIC-spektrat är ganska mycket bredare och jag har alla verktyg till dom.

Fast till annat än småsaker, gäller det 32 bit µC, jag håller på att värma upp till ST.

[DanielM]

När jag tittar på en uC så brukar jag oftast kolla på följande:

• Tillgängligheten
• Svårighetsgrad
• Utvecklingsverktygen

Priser och strömkonsumtion är egentligen inget som intresserar mig för att det går inte sätt ett korrekt pris med tanke på att priserna vandrar. Det samma med strömkonsumtionen. Visst, STM32L0 har jättelåg strömkonsumtion, men det är bara processorn som drar den lilla mikroströmmen.

Jag värderar en uC som värdig att investera sin tid i, om tillgängligheten är hög, enkel att använda och utvecklingsverktygen är in princip gratis.
Tittar man på ST så verkar dom kasta utvecklingsverktyg på en så fort man köper något av deras Nucleo-kort för 150-200 kr. Man får med programmerare och debugger i ett och enda utvecklingsverktyg + så får man med processorn! Hos Microchip så kostar det ca 2000 kr.

Ett problem som jag känner när jag kör ST är att man blir väldigt bekväm med deras utvecklingsverktyg. Alla exempel är tillgängliga och allt finns värdigt. Man behöver aldrig titta i databladet riktigt. Lite grann gör man det. Men man behöver inte skriva register för fem öre.

Tillgängligheten är dock ett problem för ST. ST lovar att garantera att dom ska erbjuda sina kunder minst 10 års garanti. Men här slår Microchip ST på fingrarna med tanke på att man kan fortfarande köpa 1993 års Microchip PIC:ar från Mouser. Visst, dom kostar 50 kr styck, men tillgängligheten finns. Microchip har 25 års garanti att dom kan erbjuda tillverkling av processorn. I många fall så har det passerat 25 år och ändå tillverkar processorn.

Men som sagt, det viktigaste är att jag vill lära mig förstå hur jag ska programmera en processor.
Målet är att om jag tar upp ett datablad, sedan ser jag ett blockschema. Då vet jag t.ex. direkt vilka register jag ska först sätta på klockan. Men detta vet jag dock inte.

[janno]

Kan ju rekommendera https://www.electrokit.com/processorkort-rp2040/
I varje fall för hobbybruk, processorn kostar drygt 14kr i styckpris. Går att programmera i python, C++ och asm. Beroende på vad man har för prestandakrav.

[DanielM]

Näää, vadå? Ingen lokal!

Hur som helst. Jag tänkte skriva en liten metodik hur jag gör för att sätta register. Notera jag har aldrig satt dessa register förut, så jag bara antar att det är så här för att man gör väll likadant i AVR så som PIC.

Projekt:
Få en LED-lampa att blinka.

Metodik:
För att få en LED-lampa att blinka hos en STM32:a så måste jag först plocka fram en 220 ohm resistor och en liten LED. Nu råkar jag använda ett färdigt utvecklingskort med inbyggt LED-lampa.
Nu vet jag att det finns en pinne som heter PA5 som leder till en resistor och LED-lampa i serie. Så jag måste aktivera PA5 och avaktivera PA5 inom ett visst intervall.

Steg 1:
Nu gissar jag bara. Jag antar att detta är en vedertagen standard: Efter man ha satt rekommenderad spänningsnivå på en uC så ska man gå vidare och titta på den som driver själva instruktionerna hos uC:n. Detta måste väll vara oscillatorn som ska driva en fyrkantsvåg/sinusvåg till övriga periferierna hos processorn. Oscillatorn drivs av en kristall. Rätta mig om jag har fel.

Hur som helst! För att veta vilken oscillator jag ska aktivera som ska driva min PA5 pinne, då måste jag titta i referensmanualen. Jag misstänker att man ska kolla blockschemat efter vad som driver GPIO-pinnarnas instruktioner. Jag misstänker att det är AHB som jag måste titta på för att det står core. Då antar jag att det är det mest grundläggande periferierna.

Skärmbild 2024-02-22 183837.png

Jag tror jag hittade rätt. Noter att jag har aldrig gjort detta förut. Jag mest bara gissar och drar slutsatser att det kanske borde vara så. Men då vet jag att det är AHB1 som jag måste titta vidare på.

Skärmbild 2024-02-22 184427.png

Men först så måste jag sätta registerna! Jag väljer att använda HSE - High Speed External. Då aktiverar jag den och sedan kollar jag om den är redo.

Skärmbild 2024-02-22 185356.png

Kod: Markera allt

#include <main.h>

int main(){
	/* Start the HSE clock */
	RCC->CR |= 1 << 16;
	
	/* Check if the HSE clock is ready */
	while(!(RCC->CR & 1 << 17));
	
	/* Now is the HSE clock ready */	
}

Då var det dags att välja att min processor ska använda HSE som klocka.

Namnlös.png

Kod: Markera allt

#include <main.h>

int main(){
	/* Start the HSE clock */
	RCC->CR |= 1 << 16;

	/* Check if the HSE clock is ready */
	while(!(RCC->CR & 1 << 17));

	/* Now is the HSE clock ready - Time to select it as system clock */
	RCC->CFGR |= 0b01;

	/* Check if the HSE clock is selected */
	while(!(RCC->CFGR & 0b0100));

}

Efter jag har valt HSE som systemets klocka. Så då är det dags för en skalare. Jag väljer att dividera 8 MHz med 2, med tanke på att kristallen är på 8 MHz. Alltså får jag nu 4 MHz som jag kan driva AHB med.

Namnlös.png

Nu är det dags för aktivera PA5 hög och sedan låg. Jag måste först deklarera vad pinnen ska vara för något. Analog, digital in eller digital ut. Detta känner jag igen sedan min AVR-tid som jag hade på förra sidan Jag gissar att den MODER5 är PA5.

Skärmbild 2024-02-22 195200.png

Kod: Markera allt

#include <main.h>

int main(){
	/* Start the HSE clock */
	RCC->CR |= 1 << 16;

	/* Check if the HSE clock is ready */
	while(!(RCC->CR & 1 << 17));

	/* Now is the HSE clock ready - Time to select it as system clock */
	RCC->CFGR |= 0b01;

	/* Check if the HSE clock is selected */
	while(!(RCC->CFGR & 0b0100));

	/* Declare PA5 as digital output */
	GPIOA->MODER |= 1 << 10;	
}

Deklarera att utgången ska vara en push-pull och inte open-drain.

Skärmbild 2024-02-22 195908.png

Så då var det bara ha en while-sats där jag aktiverar, väntar, avaktiverar, väntar. Detta påminner mig lite om en SR-vippa. Set, Reset

Skärmbild 2024-02-22 200205.png

Kod: Markera allt

#include <main.h>

int main(){
	/* Start the HSE clock */
	RCC->CR |= (1 << 16);

	/* Check if the HSE clock is ready */
	while(!(RCC->CR & (1 << 17)));

	/* Now is the HSE clock ready - Time to select it as system clock */
	RCC->CFGR |= 0b01;

	/* Check if the HSE clock is selected */
	while(!(RCC->CFGR & 0b0100));

	/* Declare PA5 as digital output */
	GPIOA->MODER |= 0b10000000000;

	/* Declare the digital output PA5 as push-pull */
	GPIOA->OTYPER |= (0 << 5);

	/* Blink - SR latch */
	while(1){
		/* Set */
		GPIOA->BSRR |= (1 << 5);
		for(int i = 0; i < 1000; i++){};
		/* Reset the set */
		GPIOA->BSRR |= (1 << 21);
		for(int i = 0; i < 1000; i++){};
	}
}

Problemet är att den lyser inte.
Har jag missat något?

Här är ett problem.
GPIOA verkar inte vara aktiverad. Det kan vara klockan som är orsaken?

Skärmbild 2024-02-22 203645.png

Edit:
Jag glömde att aktivera GPIOA för AHB1.

Kod: Markera allt

/* Enable for GPIOA */
RCC->AHB1ENR |= 1;

Så nu fungerar det!
Jag har inte frågat ChatGBT, googlat eller sökt svaret någon annan stans. Jag bara märkte att det fanns ett register till som jag hade glömt.
LED-lampan lyser nu.

Däremot fungerar inte

Kod: Markera allt

HAL_Delay(100);

Så jag måste forska vidare där vad för register som inte är aktiverad.

[DanielM]

Jag har inte lyckats aktivera SysTick så jag tänkte fråga er om det är normalt att använda en timer som delay?
Det var rätt lätt att programmera med register....det tog bara 5 timmar

Kod: Markera allt

#include <main.h>

int main(){
	/* Start the HSE clock */
	RCC->CR |= (1 << 16);

	/* Check if the HSE clock is ready */
	while(!(RCC->CR & (1 << 17)));

	/* Now is the HSE clock ready - Time to select it as system clock */
	RCC->CFGR |= 0b01;

	/* Check if the HSE clock is selected */
	while(!(RCC->CFGR & 0b0100));

	/* Prescaler AHB from 8 MHz to 4 MHz */
	RCC->CFGR |= (0b1000 << 4);

	/* Prescaler APB1 from 4 MHz to 500 kHz (16 division) times 2 if prescaler is > 1 */
	RCC->CFGR |= (0b111 << 10);

	/* Enable for GPIOA */
	RCC->AHB1ENR |= 1;

	/* Enable TIM2 */
	RCC->APB1ENR |= 1;

	/* Enable counter and set it as internal clock */
	TIM2->CR1 |= 1;

	/* Set prescaler for TIM2 - 1000 updates per second */
	TIM2->PSC = 499;

	/* Set auto-reload for TIM2 */
	TIM2->ARR = 0xFFFF;

	/* Declare PA5 as digital output */
	GPIOA->MODER |= 0b10000000000;

	/* Declare the digital output PA5 as push-pull */
	GPIOA->OTYPER |= (0 << 5);

	/* Blink - SR latch */
	const uint32_t wait = 1000;
	while(1){
		/* Set */
		GPIOA->BSRR |= (1 << 5);

		/* Delay 1 second */
		uint32_t tickstart = TIM2->CNT;
		while((TIM2->CNT - tickstart) < wait){}

		/* Reset the set */
		GPIOA->BSRR |= (1 << 21);
		tickstart = TIM2->CNT;
		while((TIM2->CNT - tickstart) < wait){}
	}
}

[AndLi]

Jo, men att läsa den i en while loop är väl att elda för kråkorna...

Lägg den i en interrupt och låt processorn sova medan den väntar...

Javisstja du brydde dig inte om strömförbrukning...

[DanielM]

Men jag har egentligen bara kopierat hur ST egentligen hanterar sin fördröjning. Alltså en räknare och while-sats.

Hur menar du med att låta en interrupt styra ? Alltså typ en funktion som tänder och släcker lampan igenom ett avbrott?

Jo. Jag bryr mig mycket om strömförbrukning. ST är kända för att ha megalåg strömförbrukning. Men egentligen så är det ointressant om man har andra saker så som LCD som drar betydligt mer.

[TomasL]

Du laddar en timer med lämpligt värde, startar den, när den slår runt, genereras ett interrupt, om du satt alla register rätt, i interruptrutinen så togglar du LEDen och återställer räknaren.
EN brasklapp, i en interruptrutin skall man egentligen inte köra någon kod, typ, enbart sätta en flagga eller liknande som talar om för övriga delar i programmet att detta har hänt, dock att toggla en LED är rätt OK.

[DanielM]

Men....är det verkligen en stor skillnad jämfört med denna metod som jag har gjort? Jag menar...är det bättre än att använda en fördröjning?

[TomasL]

I din nuvarande applikation spelar det ingen som helst roll, men om det skall göra lite mer saker, vill du inte ligga och vänta på att en while-loop eller liknande skall ta slut, med timers och interrupt, så avlastas den delen, eftersom timern kör på oavsett v ad processorn håller på med, när interruptet kommer, så hanterar man det, sätter en flagga eller liknande, återinitierar timern, och hoppar tillbaka, grejjen är att interruptet inte skall ta någon tid alls, och därmed inte fördröja något annat. Det är just så man gör i sk realtidssystem.

Dessutom, kör man MIPS, så switchar man över till den alternativa registeruppsättningen, vilket innebär att man inte behöver spara CPUns register när man hoppar till interruptet, när interruptet är servat, switchar man tillbaka till den riktiga registeruppsättningen,, på så sätt sparar man väldigt mycket tid (och kod).

[DanielM]

Jag förstår. Det är så jag brukar använda interrupts.
Jag tänkte läsa lite digital in och ADC och skapa en PWM med timer. Det var kul att använda register.

Undra om det är exakt likadant för PIC också ? Alltså man ge sig på klockan direkt.

Såg något som jag borde göra efter denna uppsättning av registers

[TomasL]

Öh?, vad menar du med "alltså man ge sig på klockan direkt."

[TomasL]

Vad du måste lära dig är att det finns olika arkitekturer inom PIC-familjen, PIC8 och PIC18 är rätt lika, PIC18 är mer avancerad dock, dvs mer io, Flera periferienheter mer minne, mer flash osv.
PIC17 och PIC24 är väldigt mycket annorlunda, har aldrig jobbat med dem, men vad jag förstått , så är de väldigt speciella, med DSP mm.
PIC32 är en MIPS, dvs den har ingen som helst koppling till något annat i PIC-familjen, och därmed ett helt annorlunda när det gäller konfigurering, programmering osv.